Arbeite derzeit an einem größeren Projekt und bin da jetzt auf ein Problem gestoßen, welches ich bis jetzt noch nicht zu lösen vermochte (ich versteh's nicht einmal!). Ich versuch es code-mäßig kurz zu halten, wenn ihr zusätzlichen Code braucht, sagt mir einfach bescheid!
Also. Ich habe zwei Listen (Template-Klasse ogUtilsList) und eine Iterator-Klasse (ogUtilsIterator). Beide Listen enthalten Elemente unterschiedlichen Typs (eine CBuilding* und die Andere CDivision*).
Während des Programmablaufs werden immer wieder Elemente in der Liste hinzugefügt. Wenn das Programm dann beendet wird, durchlaufe ich mit dem Iterator jede der beiden Listen, und rufe für den jeweiligen Datapointer die Exit()-Methode auf, anschließend wird das Element selbst aus der Liste gelöscht. Wenn jetzt nur EINE der beiden Listen Einträge enthält, dann funktioniert alles wunderbar. Soweit so gut. Wenn nun aber BEIDE Listen Einträge enthalten (was eigentlich alles andere als selten vorkommt!), dann unterbricht das Programm bei einem zufällig (mir erscheint es jedenfalls so!) gewählten Eintrag der 2. (es ist IMMER die 2. Liste!!) Liste ab! Um genau zu sein, bricht es an jenem Punkt ab, wo der Container für ein Listenelement gelöscht werden soll. Meldung ist folgende:

Windows has triggered a breakpoint in Orb to conquer.exe.

This may be due to a corruption of the heap, and indicates a bug in Orb to conquer.exe or any of the DLLs it has loaded.

The output window may have more diagnostic information

Im "output window" steht oberhalb dieses Textes lediglich:

HEAP[Orb to conquer.exe]: HEAP: Free Heap block 87bfc40 modified at 87bfc74 after it was freed

(Leider kann ich diese "Aussage" nicht nachvollziehen!

______________________________________________

Hier jetzt noch der Code der Listen-klasse und des Iterators (Die stelle an welcher das Programm abbricht ist markiert (in der Remove-Methode):

template <typename T> class ogUtilsIterator;

template <typename T> struct ogUtilsListEntry
{
	ogUtilsListEntry<T>*		pNext;
	T							Data;
};

template <typename T>
class ogUtilsList
{	
private:
	ogUtilsListEntry<T>*		m_pFirst;
	ogUtilsListEntry<T>*		m_pLast;
	UINT						m_iSize;

	ogUtilsList(const ogUtilsList<T>&)								{}
public:
	ogUtilsList() : m_iSize(0), m_pFirst(NULL), m_pLast(NULL)		{}
	~ogUtilsList()													{Clear();}

	ogUtilsListEntry<T>*		Begin()				{return m_pFirst;}
	ogUtilsListEntry<T>*		End()				{return m_pLast;}
	UINT						GetSize()			{return m_iSize;}
	//-------------------------------------------------------------------------//

	bool Insert(T& Data)
	{
		if(m_iSize <= 0) m_pFirst = m_pLast = new ogUtilsListEntry<T>;
		else
		{
			m_pLast->pNext	= new ogUtilsListEntry<T>;
			m_pLast			= m_pLast->pNext;
		}
		m_pLast->pNext = NULL;
		m_pLast->Data  = Data;
		++m_iSize;
		return true;
	}

	bool Remove(T& Data)
	{
		ogUtilsListEntry<T>* pTemp = m_pFirst;
		ogUtilsListEntry<T>* pLast = NULL;
		for(UINT i = 0; i < m_iSize; ++i)
		{
			if(::memcmp(&(pTemp->Data), &Data, sizeof(T)) == 0)
			{
				if(pLast) pLast->pNext = pTemp->pNext;
				else m_pFirst = pTemp->pNext;
				if(pTemp == m_pLast) m_pLast = pLast;

				//Delete it!
				OG_SAFE_DELETE(pTemp);
				--m_iSize;
				return true;
			}
			pLast = pTemp;
			pTemp = pTemp->pNext;
		}
		return false;
	}
	bool Remove(ogUtilsIterator<T>* it)
	{
		ogUtilsListEntry<T>* pTemp = m_pFirst;
		ogUtilsListEntry<T>* pLast = NULL;
		for(UINT i = 0; i < m_iSize; ++i)
		{
			if(it->m_pCurrent == pTemp)
			{
				if(pLast) pLast->pNext = pTemp->pNext;
				else m_pFirst = pTemp->pNext;
				if(pTemp == m_pLast) m_pLast = pLast;

				it->m_pNextOne = pTemp->pNext;
				it->m_pCurrent = NULL;

				//Delete it!
				OG_SAFE_DELETE(pTemp);           //<<<<<<----- HIER PASSIERTS!!
				--m_iSize;
				return true;
			}
			pLast = pTemp;
			pTemp = pTemp->pNext;
		}
		return false;
	}

	bool Clear()
	{
		for(UINT i = 0; i < m_iSize; ++i)
		{
			ogUtilsListEntry<T>* pTemp = m_pFirst;
			m_pFirst = m_pFirst->pNext;
			OG_SAFE_DELETE(pTemp);
		}
		m_iSize		= 0;
		m_pFirst	= NULL;
		m_pLast		= NULL;
		return true;
	}
};

template <typename T>
class ogUtilsIterator
{
public:
	ogUtilsListEntry<T>*		m_pCurrent;
	//Wird verwendet, um während eines Schleifendurchgangs auch etwas aus der Liste löschen zu können
	//Hier wird dann gespeichert, auf welchen Eintrag der Iterator beim nächsten ++ springen soll
	ogUtilsListEntry<T>*		m_pNextOne;

	ogUtilsIterator() : m_pCurrent(NULL), m_pNextOne(NULL)									{}
	ogUtilsIterator(ogUtilsListEntry<T>* pStart) : m_pCurrent(pStart), m_pNextOne(NULL)		{}
	~ogUtilsIterator()																		{}

	bool					EndOfList()					{return m_pCurrent == NULL;}
	bool					NotEndOfList()				{return m_pCurrent != NULL;}
	void					SetData(T NewData)			{if(m_pCurrent) m_pCurrent->Data = NewData;}

	//Operatoren
	ogUtilsIterator<T>& operator ++ ()								
		{if(m_pCurrent) m_pCurrent = m_pCurrent->pNext; else {m_pCurrent = m_pNextOne; m_pNextOne = NULL;} return *this;}
	ogUtilsIterator<T>& operator ++ (int)							
		{ogUtilsIterator<T> OldIt = *this; if(m_pCurrent) m_pCurrent = m_pCurrent->pNext; else {m_pCurrent = m_pNextOne; m_pNextOne = NULL;} return OldIt;}

	ogUtilsIterator<T>& operator () (ogUtilsListEntry<T>* pStart)	{m_pCurrent = pStart; return *this;}
	ogUtilsIterator<T>& operator = (ogUtilsListEntry<T>* pStart)	{m_pCurrent = pStart; return *this;}

	bool operator == (const ogUtilsListEntry<T>* pEntry) {return m_pCurrent == pEntry;}
	bool operator != (const ogUtilsListEntry<T>* pEntry) {return m_pCurrent != pEntry;}

	T* operator -> () {return &(m_pCurrent->Data);}
	T operator * () {return m_pCurrent->Data;}
};

_____________________________________________

Vielleicht wäre es auch noch interessant wie die Listen geleert werden:
(Lasst euch durch das 2-dimensionale Listenarray (pppDivisions) nicht irritieren, es enthält (bis jetzt) nur eine Liste Einträge!)

//Alle Einheiten löschen
	CGame* pGame = CMain::Instance().GetCurrentGameState<CGame>();
	for(UINT y = 0; y < pGame->m_iGridHeight; ++y)
	{
		for(UINT x = 0; x < pGame->m_iGridWidth; ++x)
		{
			for(ogUtilsIterator<CDivision*> i = m_pppDivisions[y][x]->Begin(); i.NotEndOfList(); ++i)
			{
				//Einheit dieses Sektors löschen
				og2DVector vPos = og2DVector(static_cast<float>(x), static_cast<float>(y));
				ogEMS::Instance().SendOneMessage(this, OTCEM_DIVISIONDESTROYED, &i, &vPos);
			}
			OG_SAFE_DELETE(m_pppDivisions[y][x]);
		}
		OG_SAFE_DELETE_ARRAY(m_pppDivisions[y]);
	}
	OG_SAFE_DELETE_ARRAY(m_pppDivisions);

	//Alle Buildings löschen
	for(ogUtilsIterator<CBuilding*> iterator = m_pBuildings->Begin(); iterator.NotEndOfList(); ++iterator)
	{
		ogEMS::Instance().SendOneMessage(this, OTCEM_BUILDINGDESTROYED, &iterator);
	}
	OG_SAFE_DELETE(m_pBuildings);

Und das sind die jeweiligen Methoden, welche aufgerufen werden, sobald eine Instanz die BUILDINGDESTROYED oder DIVISIONDESTROYED Nachricht erhält.

bool BuildingDestroyed(ogUtilsIterator<CBuilding*>* iterator)
	{
		//Aus EntityManager löschen
		ogEMS::Instance().DeleteObject(**iterator);

		//Instanz selbst löschen
		OG_SAFE_DELETE(iterator->m_pCurrent->Data);

		//Aus GebäudeListe entfernen
		m_pBuildings->Remove(iterator);
		return true;
	}

	bool DivisionDestroyed(ogUtilsIterator<CDivision*>* it, const UINT x, const UINT y)
	{
		//Aus EntityManager löschen
		ogEMS::Instance().DeleteObject(**it);

		//Instanz selbst löschen
		OG_SAFE_DELETE(it->m_pCurrent->Data);

		//Aus der "richtigen" Liste löschen
		m_pppDivisions[y][x]->Remove(it);
		return true;
	}

(Es passiert hier immer beim Aufruf der Remove()-Methode!)
_____________________________________________

Anmerkung: Es ist egal, welche der beiden Listen als erste geleert wird, es ist IMMER die Zweite bei der der Fehler auftritt!

Hoffe ihr könnt mir helfen... bin am Verzweiflen...

Im Grunde nichts, nur möchte ich 1. verstehen wo da das Problem liegt, und 2. wollte ich eigentlich die STL nicht verwenden...

Der erste Grund ist hoch lobenswert. Den zweiten versteh ich nicht. Wieso willst du nicht die STL verwenden? Nichtbenutzen der STL bringt meist viel mehr Code als das verwenden genannter.

bool Insert(T& Data)

Das macht sowas unmöglich:

ogUtilsList< int > list;
list.Insert( 10 );

Dass SetData sein Parameter per-value übernimmt ist auch zumindest suboptimal, und "const" scheint für dich auch ein unbekanntes Keyword zu sein -- zumindest fehlt es an vielen vielen Stellen wo man es (zu Recht) anzutreffen erwarten würde.

Davon abgesehen wäre der Code mit STL + Boost (speziell shared_ptr oder pointer container) wohl etwa 1/4 - 1/2 so lange, und hätte wahrscheinlich auch weniger Fehler. Ganz davon abgesehen dass er wahrscheinlich übersichtlicher und u.U. auch etwas "normaler" und nicht so abgedreht wie das was du gepostet hast. Und ziemlich sicher auch wesentlich performanter. BTW: Wenn ich raten müsste würde ich tippen dass dort wo du jetzt Listen verwendest eher Vektoren die bessere Wahl wären.

Nochwas: Instanzen mit memcmp vergleichen ist nicht wirklich generisch, normalerweise verwendet man da einfach den operator ==, oder alternativ den operator < (mit "!(a < b || b < a)").

Ansonsten würde ich dir, wenn du schon alles selbst schreiben willst (ich hoffe du überlädst auch die new/delete-Operatoren selbst und schreibst den Code fürs Stack-Unrolling/RTTI :p), dann setz dich wenigstens mal mit der STL auseinander, weil die Lösungen die dort benutzt werden, sind gar nicht mal so schlecht...

Die Dokumentation von SGI ist nicht schlecht, da man dort auch die Hintergründe und Konzepte versteht http://www.sgi.com/tech/stl/table_of_contents.html

ein Blick ich GotW sollte auch nicht schaden.