Ich habe gerade ein merkwürdiges Problem. Ich wollte gerade etwas zu Ende machen, als mein Programm in eine Art Dauerschleife fällt. Ich habe also den Debugger zu Rate gezogen, aber das hilft mir auch nicht weiter:

int _tmain(int argc, _TCHAR* argv[])
{
	int iTemp;
	HighScore->Init("HighScore.dat",10);
	Logfile->CreateLogfile();
	SDL::Framework->Init(1024,768,32,false,true);
	CIntro m_Intro;
	m_Intro.Init(0);
	m_Intro.Run();
	if(m_Intro.Quit() > 0)
	{
		CGame m_Game;
		m_Game.Init();
		m_Game.Run();
		AskForName m_AskForName;
		m_AskForName.Init(m_Game.Quit());
		m_AskForName.Run();
		m_AskForName.Quit();
	}					//wenn ich hier den Breakpoint mache und dann weitersteppe, geht gar nichts mehr
	SDL::Framework->Quit();
	SDL::Framework->Del();
	HighScore->Del();
	Logfile->Del();
	return 0;
}

Wie bereits im Code beschrieben, kann ich bei der letzten Klammer einen Breakpoint setzen und wenn ich dann versuche weiterzusteppen, werden alle Debuggertasten zum Navigieren grau und ich kann nur noch auf Stopp drücken. Im der Titelleiste steht „running“, aber ich kann nicht mehr weitergehen. Kennt jemand dieses Problem und weiß vielleicht eine Lösung.

Vielleicht ist das blöd erklärt, aber ich weiß nicht, wie ich hier weiter machen soll.

chrische

Ich weiss, dass der Code nicht besonders geeignet ist, aber ich habe ja leider keine Ahnung, wo der Fehler steckt. Alle anderen Teile bin ich eigentlich mit Debugger durchgegangen und es hat alles geklappt und dann auf ein mal das. Ich poste jetzt mal die Funktion m_AskForName.Run() vielleicht hilft das ja:

void AskForName::Run(void)
{
	while(m_bGameRun)
	{
		SDL::Framework->Clear();
		SDL::Framework->Update();
		ProcessEvents();
		if(!m_bIsInHighscore)
		{
			m_Text.Render("Sie haben leider nur " + ConvertToString(m_iPoints) + " erreicht.",SDL::HCENTER,400);
			m_Text.Render("Damit sind Sie nicht in der HighScore",SDL::HCENTER,450);
		}
		else
		{
			m_Text.Render("Sie haben " + ConvertToString(m_iPoints) + " Punkte erreicht und belegen damit den " + ConvertToString(HighScore->GetPositionInHighScore(m_iPoints)) + "Rang in der HighScore.",SDL::HCENTER,400);
			m_Text.Render("Bitte geben Sie Ihren Namen ein:",SDL::HCENTER,450);
			m_Text.GetInPut(m_strName);
			m_Text.Render(m_strName,SDL::HCENTER,500);
		}
		if(SDL::Framework->KeyDown(SDLK_RETURN))
		{
			if(m_strName.empty())
				m_strName = "unbekannt";
			HighScore->Update(m_strName,m_iPoints);
			m_bGameRun = false;
		}
		SDL::Framework->Flip();
	}

}

Ich hoffe, dass Ihr damit was anfangen könnt.

chrische

b7f7 schrieb:

auf den ersten Blick würd ich sagen:
2 Instanzen gehen aus dem Scope.
2 Dtoren werden aufgerufen. hat einer ein endlos loop?

Meinst du, dass es einem Dtor eine Endlosschleife gibt. Das ist sicher nicht der Fall.
Wie kann es, dass ich einfach nicht mehr weitersteppen kann ohne das irgendeine Fehlermeldung kommt und warum ist das der Fall nachdem ich durch die Dtor gesteppt bin und nicht währenddessen.

chrische

Ich brauch wirklich eure Hilfe. Fehlt es an Information oder wisst Ihr auch nicht weiter.

chrische

b7f7 schrieb:

code solte compilierbar sein das der fehler nachvolzogen werden kann.

was meinst du mit dem Satz. Der Code ist compilierbar und er funktioniert uach wie gewünscht, aber eben nur solange bis ich das Programm beende, dann steht immer im Fenstertitel "running" und nichts passiert mehr.

chrische

@b7f7: ich hatte deine Aussage nicht genau verstanden, aber nun ist es klar.

Ich habe nun den Fehler noch weiter eingegrenzt. Wenn ich die Schleife verlasse, werden viele Dstruktoren aufgerufen und bei einem hägnt er sich auf.

Ich habe in der Klasse CGame folgendes stehen:

std::vector<CCube> m_vCube;

wenn nun der Destruktor des std::vectors aufgerufen wird, bleibt er einfach hängen und zwar genau hier:

~vector()
		{	// destroy the object
		_Tidy();
		}

Das Programm durchläuft diese Zeilen bei einigen Vektoren vorher problemlos. Vielleicht kann jetzt jemand helfen.

chrische

Da scheint es wohl ein Problem mit dem Destruktor von CCube zu geben. Wie ist denn die Klasse deklariert?

Eigentlich ist der Destruktor leer. Hier die hpp und cpp Dtaei:

h:

#pragma once

#include <iostream>
#include "Sprite.h"
#include <string>

class CCube
{
public:
	CCube(void);
	~CCube(void);
	void Init(int p_iBitmapPosX, int p_iBitmapPosY);
	void Dice(void);
	void Render(void);
	void SetMarkedOrNonMarked(void);
	int GetCubeState(void) const
	{
		return m_iCubeState;
	}
	int m_iCubeState;

protected:
	SDL::CSprite m_CubeSprite;
	std::string m_strFileName;

	int m_iBitmapPosX;
	int m_iBitmapPosY;
};

und hier die cpp Datei:

#include "Cube.h"

CCube::CCube(void)
{

}

CCube::~CCube(void)
{

}

void CCube::Init(int p_iBitmapPosX, int p_iBitmapPosY)
{
	m_strFileName = "pictures/wuerfel_";
	m_iBitmapPosX = p_iBitmapPosX;
	m_iBitmapPosY = p_iBitmapPosY;

}

void CCube::Dice(void)
{
	m_iCubeState = rand()%6 + 1;
}

void CCube::Render(void)
{
	if(m_iCubeState>6)
		m_CubeSprite.Load(m_strFileName + ConvertToString(m_iCubeState-6) + "gesetzt.bmp");
	else
		m_CubeSprite.Load(m_strFileName + ConvertToString(m_iCubeState) + ".bmp");
	m_CubeSprite.SetPos(static_cast<float>(m_iBitmapPosX),static_cast<float>(m_iBitmapPosY));
	m_CubeSprite.Render();
}

void CCube::SetMarkedOrNonMarked(void)
{
	if(m_iCubeState < 7)
		m_iCubeState += 6;
	else
		m_iCubeState -= 6;
}

Vielleicht hilft das ja weiter.

chrische

PS: ist das richtig so, daß 'm_iCubeState' öffentlich ist?

Ja es ist richtig, dass m_iCubeState public ist. Das will ich später noch ändern, aber zum Testen geht es so einfach schneller.

Hier jetzt noch einmal h und cpp Datei von Sprite:

h Datei:

#pragma once

#include "Framework.h"

namespace SDL
{
	class CSprite
	{
	public:
		CSprite(void);
		~CSprite(void);
		void Load(const std::string p_strFileName);
		void Load(std::string p_strFileName, int p_iNumFrames, int p_iFrameWidth, int p_iFrameHeight);
		void SetColorKey(Uint8 p_iR, Uint8 p_iG, Uint8 p_iB);
		void SetPos(float p_fXPos, float p_fYPos);
		void Render(void);
		void Render(float p_fFrameNumber);
		SDL_Rect GetRect(void) {return m_Rect;}

	private:
		SDL_Surface* m_pScreen;		//Zeiger auf den Screen des Frameworks
		SDL_Surface* m_pImage;		//das eigentliche des Sprites
		SDL_Rect	 m_Rect;		//Rect des Sprites
		SDL_Rect	 m_FrameRect;	//Ausschnitt für Animatiomsphase
		int			 m_iNumFrames;	//Anzahl der Animationsphasen
		int			 m_iFrameWidth;	//Breite der Animationsphase
		int			 m_iFrameHeight;//Höhe einer Animatiosphase
		int			 m_iNumFramesX;	//Wie viele Animationsphasen in X-Richtung 
	};
}

und die cpp Datei:

#include "StdAfx.h"
#include ".\sprite.h"

using namespace SDL;

CSprite::CSprite(void)
: m_pScreen(Framework->GetScreen())
, m_pImage(NULL)
{
}

CSprite::~CSprite(void)
{
	SDL_FreeSurface(m_pImage);
}

void CSprite::Load(const std::string p_strFileName)
{
	//Bitmap laden
	m_pImage = SDL_LoadBMP(p_strFileName.c_str());

	//Prüfen ob alles glatt ging
	if(m_pImage == NULL)
	{
		Logfile->WriteTopic("Laden des Bitmaps",3);
		Logfile->TextOut("Laden des Bitmaps ist fehlgeschlagen<br>");
		std::string strErrorCode = SDL_GetError();
		Logfile->TextOut("Fehler: " + strErrorCode + "<br>");

		Framework->Quit();

		exit(1);
	}

	//Rect initialisieren
	m_Rect.x = 0;
	m_Rect.y = 0;
	m_Rect.w = static_cast<Uint16>(m_pImage->w);
	m_Rect.h = static_cast<Uint16>(m_pImage->h);
}

void CSprite::Load(std::string p_strFileName, int p_iNumFrames, int p_iFrameWidth, int p_iFrameHeight)
{
	Load(p_strFileName);

	m_iNumFrames	= p_iNumFrames;
	m_iFrameWidth	= p_iFrameWidth;
	m_iFrameHeight	= p_iFrameHeight;
	m_FrameRect.w	= static_cast<Uint16>(p_iFrameWidth);
	m_FrameRect.h	= static_cast<Uint16>(p_iFrameHeight);
	m_iNumFramesX	= m_pImage->w / m_iFrameWidth;
}

void CSprite::SetColorKey(Uint8 p_iR, Uint8 p_iG, Uint8 p_iB)
{
	//Colorkey einstellen
	SDL_SetColorKey(m_pImage, SDL_SRCCOLORKEY, SDL_MapRGB(m_pImage->format,p_iR, p_iG, p_iB));
}

void CSprite::SetPos(float p_fXPos, float p_fYPos)
{
	m_Rect.x = static_cast<Sint16>(p_fXPos);
	m_Rect.y = static_cast<Sint16>(p_fYPos);
}

void CSprite::Render(void)
{
	SDL_BlitSurface(m_pImage, NULL, m_pScreen, &m_Rect);
}

void CSprite::Render(float p_fFrameNumber)
{
	//Ausschnitt der aktuellen Animationsphase berechnen

	//Spalte berechnen
	int iColumn = static_cast<Sint16>(p_fFrameNumber)%m_iNumFramesX;

	//Zeile berechnen
	int iRow = static_cast<Sint16>(p_fFrameNumber/m_iNumFramesX);

	//Rect berechnen
	m_FrameRect.x = static_cast<Sint16>(iColumn * m_iFrameWidth);
	m_FrameRect.y = static_cast<Sint16>(iRow * m_iFrameHeight);

	//Ausschnitt rendern
	SDL_BlitSurface(m_pImage, &m_FrameRect, m_pScreen, &m_Rect);
}

Mal schauen, ob Ihr was findet.

Vielen Dank für Eure Hilfe.

chrische

Sorry, aber das verstehe ich nicht. Wo wird den kopiert und außerdem habe ich in einem anderen Programm genau diese Version von CSprite benutzt ohne das es Probleme gab.

chrische

Ich würde gerne noch einmal meine Frage vom letzten Post wiederholen. Ich habe nun noch einen Kopüierkonstruktor hinzugefügt und ich habe immernoch das selbe, oben beschriebene, Problem.

chrische

Ich bin mir nicht sicher, ob mein Copyconstructor richtig ist, weil ich sowas noch nie geschrieben habe, also zeige ich ihn Euch mit der Bitte mir den Sand aus den Augen zu waschen.

CSprite::CSprite(const CSprite& rhs)
{
	m_pImage = new SDL_Surface;
	m_pImage = rhs.m_pImage;
	m_pScreen = rhs.m_pScreen;
	m_Rect = rhs.m_Rect;
	m_FrameRect = rhs.m_FrameRect;
	m_iFrameHeight = rhs.m_iFrameHeight;
	m_iFrameWidth = rhs.m_iFrameWidth;
	m_iNumFrames = rhs.m_iNumFrames;
	m_iNumFramesX = rhs.m_iNumFramesX;
}

Rest der Klasse siehe oben.

chrische

CSprite::CSprite(const CSprite& rhs)
{
	m_pImage = new SDL_Surface;
	m_pImage = rhs.m_pImage;
        .....
}

du erzeugst erst mal eine neue SDL_Surface und mit der nächsten Istruktion überschreibst du sie schon wieder --> Speicherleck
Kurt

Dann kapiere ich einfach nicht, wie das gehen soll. Kann mir mal jemand einen Anstoss geben.

chrische

Es weiß doch bestimmt einer von Euch, wie der korrekte Copyconstructor aussehen muss.

chrische

Es weiß doch bestimmt einer von Euch, wie der korrekte Copyconstructor aussehen muss.

Kommt ganz drauf an was SDL_Surface ist
Wahrscheinlich so wenn SDL_Surface einen Copyconstructor hat.

CSprite::CSprite(const CSprite& rhs)
{
    m_pImage = new SDL_Surface(*rhs.m_pImage);
        .....
}

das könnte eventuell auch funktionieren wenn z.B. SDL_Surface nur ein typedef für ein char array ist

CSprite::CSprite(const CSprite& rhs)
{
    m_pImage = new SDL_Surface;
    memcpy(m_pImage, rhs.m_pImage , sizeof(SDL_Surface));
        .....
}

Langer Rede kurzer Sinn: keiner kann dir sagen wie dein copyconstructor aussehen muss wenn du uns nicht sagst woraus genau dein CSprite besteht.
Kurt

Erstmal dank für deine Antwort. Dieses Thema ist halt noch neu für mich. Den kompletten Code der Klasse steht doch schon im Forum nur ein paar Post weiter oben (früher). Brauchst du noch mehr Information?

chrische