bei mir macht die Klasse "vector" immer Fehler. Bei einer Debug-Kompileirung gibt es (der vector) mir Warnings aus, Funktioniert aber halbwegs. Bei einer Realease-Kompilierung sind die Warnings weg, aber beim Erzeugen von neuen Speicherplatz mit der Routine "push_back" stürtzt mir dann das Programm ab.

Desshalb wollte ich mir für mein Programm meinen eigenen Kontainer schreiben.
Bei meinem Container gibt es Listen, also eine Mainliste, die ihrer seits Unterlisten erzeugen kann. In diese Unterlisten können dann Typen erzeugt werden.

So weit so gut, nun hab ich das Problem, dass beim "Item" löschen, alle folgenden Items neu "ausrichten" muss. Das Löschen übernimmt die Funktion "erease", bei deren Rücksprung mein Programm abstürtzt.

Hier der Code:

#include <iostream.h>
#include <memory.h>

template<class T> 
class CFastContainer  
{
public:
	CFastContainer() :
	  m_Mainlistsize(100) ,
	  m_Sublistsize(50)
	{
		m_nSublistCount = 0;
		m_nItemCount = 0;
		pMainlist = new T**[m_Mainlistsize];
		memset(pMainlist,NULL, m_Mainlistsize);

	//	CreateSublist();
	}
	  CFastContainer(unsigned int MainSize, unsigned int SubSize) :
	  m_Mainlistsize(SubSize) ,
	  m_Sublistsize(50)
	{
		m_nSublistCount = 0;
		m_nItemCount = 0;
		pMainlist = new T**[m_Mainlistsize];
		memset(pMainlist,NULL, m_Mainlistsize);

		CreateSublist();
	}

	~CFastContainer()
	{
		//alles löschen
		//mit sublisten anfengen
		for(unsigned int i = 0; i < m_nSublistCount; i++)
			for(unsigned int j = 0; j < m_Sublistsize; j++)
				if(pMainlist[i][j])
					delete pMainlist[i][j];

		i = 0;
		while( pMainlist[i] && i < m_Mainlistsize)
			delete[] pMainlist[i++] ;
		delete[] pMainlist;

	}

	unsigned int size()	{ return m_nItemCount; }

	void push_back(T & data)
	{
		unsigned int listNr = m_nItemCount / m_Sublistsize;
		unsigned int SubItemsNr = m_nItemCount - (listNr * m_Sublistsize);

		if(! pMainlist[listNr])
			CreateSublist();

		pMainlist[listNr][SubItemsNr] = new T;
		*pMainlist[listNr][SubItemsNr] = data;
		m_nItemCount++;

	}

	T & at(unsigned int index)
	{
		unsigned int listNr = GetListNr(index);
		unsigned int SubItemsNr = SubListNr(index);

		return *pMainlist[listNr][SubItemsNr];

	}

	T & operator[] ( unsigned int index) { return at(index); }

//	bool pop_back();
	void erease( unsigned int index)
	{
		unsigned int listNr = GetListNr(index);
		unsigned int SubItemsNr = SubListNr(index);
		unsigned int listNr2;

		delete pMainlist[listNr][SubItemsNr];
		pMainlist[listNr][SubItemsNr] = NULL;
		m_nItemCount--;

		//von hinten aufrücken.........
		for(unsigned int i = index; i < m_nItemCount-1; i++)
			pMainlist[ GetListNr(i) ][ SubListNr(i) ] = pMainlist[ GetListNr(i+1) ][ SubListNr(i+1) ];

		//Leere liste löschen
		listNr2 = GetListNr(m_nItemCount-1);
		if(listNr2 < listNr)
		{
			delete[] pMainlist[listNr];
			pMainlist[listNr] = NULL;
		}	
	}
private:
	const unsigned int m_Mainlistsize;
	const unsigned int m_Sublistsize;
	unsigned int m_nSublistCount;
	unsigned int m_nItemCount;
	T *** pMainlist;

	bool CreateSublist()
	{
		if(m_nSublistCount < (m_Mainlistsize -1 ))
		{
			pMainlist[m_nSublistCount++] = new T*[m_Sublistsize];
			memset(pMainlist[m_nSublistCount-1], NULL , m_Sublistsize);;
			return true;
		}
		return false;
	}

	unsigned int GetListNr(unsigned int index) { return index / m_Sublistsize; }
	unsigned int SubListNr(unsigned int index) { return index - ((index / m_Sublistsize) * m_Sublistsize); }

};

void main()
{
	CFastContainer<int> a;

	for(int i = 0; i < 100;  i++)
		a.push_back(i);

	for( i = 0; i < 100;  i++)
		cout << a[i] << endl;

	//for( i = 0; i < 50;  i++)
	//{
	//	cout << i << " ,," << endl;
	//	a.erease(i);
	//}
	a.erease(0);
}

Kurzfassung:
Beim Rückspsrung aus der Funktion erease stürtzt das Programm ab, mit der Meldung : "BLOCK_TYPE_IS_VALID" .

Irgentwo muss ich mir den Speicher Kaputt machen, aber ich kann nicht erkennen wo das passiert.

Ich bin über jede Hilfe dankbar.

Gruß Stu

PS.: Ich benutze VC++ 6.0.

fahre ihn mal explizit mit dem debugger durch.
gruß