Hier der Code:

template <class T> 
class CDynPtrArray{

	T **m_pArray;	//Template Pointer Array
	int iSize;		//Aktuelle Array Größe

public:

	//Konstruktor
	CDynPtrArray(int iSize){
		 this->iSize=iSize;
		 m_pArray= new T*[iSize];
	}
	//Standart Konstruktor
	CDynPtrArray(){
		 this->iSize=0;
		 m_pArray= new T*[0];
	}

	//Destruktor
	~CDynPtrArray(){
		delete[] m_pArray;
	}

	//Size
	inline int GetSize(){ return iSize;}

	//Pointer adden
	void add(T* Ptr){

		//Array um ein Elment vergrössern
		resize(iSize+1);

		//Pointer als letzes Element
		m_pArray[iSize]= Ptr;

		//Größe erweitern
		iSize++;

	}

	// Pointer zurückgeben
	T* getAt(int iPos){

		if(iPos<0 || iPos>iSize)
			return NULL;

		return m_pArray[iPos];

	}
	//BOOL delAt(int iPos){
	//	
	//	if(iPos<0 || iPos>iSize)
	//		return false;
	//
	//}

private:

	void resize(int iNewSize){
		T  **ppNewArray= new T*[iNewSize];

		//Referenzen kopieren
		for( int i=0; i< iSize; i++)
			ppNewArray[i]= m_pArray[i];

		//Altes Array löschen und mit neuem Array referenzieren
		delete[] m_pArray;
		m_pArray= ppNewArray;
	}

};

Damit würde die Akzeptanz des Containertyps schneller steigen. Ich würde sowas ungern benutzen.

Zweitens: Du brauchst noch einen Copy-Ctor und operator=, sonst kommst du schnell in Teufels Küche.

Drittens: Eventuell solltest du vorsorglich etwas mehr Speicher anfordern als du für die aktuelle Größe benötigst, dann mußt du die Daten nicht bei jedem add() umkopieren (kann bei größeren Arrays schnell langwierig werden).

Viertens: Ist zwar nur eine Kleinigkeit, aber - nimm Initialisierungslisten:

CDynPtrArray(int size=0)
: iSize(size), m_pArray(new T*[size])
{}

Fünftens: GetSize() und getAt() kannst du auch als const-Methoden deklarieren - die ändern nichts an deinen Daten (btw, einige dich mal mit dir selbst auf eine einheitliche Schreibweise :D).

CDynPtrArray(size_t size=0)
: iSize(size), m_pArray(size ? new T*[size] : 0)
{}

Das Problem mit der dynamischen größe könnte ich ja mit einer verketten list umsetzen oder? grüße

achso d.h. std::vector reservier immer doppelt soviel sovielspeicher wie nötig ist... wenn der speicher mit "add" dann ausgereitzt ist, wird wieder rum das doppelte vom doppelten reserviert und umkopierT?

Nein, muß der Vector nicht unbedingt. Hängt von der Implementierung ab.