ArrayList

Anaconda

hi,

ich habe seit längerem wieder angefangen in c++ zu programmieren und will jetzt eine arrayliste machen.

die klasse schaut so aus:

template <typename Type> class CArrayList{

private:
	Type* m_pData;
	int m_iSize;
	int m_iMaxSize;

public:
	CArrayList();
	~CArrayList();
	bool Add(Type* pData);
	bool Remove(int i);
	bool Contains(Type* pData);
	Type* Get(int i);
	int GetSize();
	void Clear();
};

jetzt zu meinem problem, dass in der Add-Methode liegt:

template <typename Type> bool CArrayList<Type>::Add(Type *pData){

	if(pData == NULL){
		return false;
	}

	if(m_iSize >= m_iMaxSize){

		m_iMaxSize += 32;

		if(m_pData == NULL){
			m_pData = new Type[m_iMaxSize * sizeof(Type)];
			if(m_pData == NULL){
				return false;
			}

		}else{
			void* pNewMemory;
			pNewMemory = new Type[m_iMaxSize * sizeof(Type)];

			if(pNewMemory == NULL){
				return false;
			}

			memmove(pNewMemory, m_pData, m_iSize * sizeof(Type));
			m_pData = (Type*)pNewMemory;
		}
	}

	memcpy((Type*)m_pData + (m_iSize * sizeof(Type)), pData, sizeof(Type));

	m_iSize++;

	return true;
}

es funktioniert alles solange bis ich über die 32 einträge hinauskomme und neuen speicher allokieren muss
irgendwie kopiert er nicht alles in den neuen bereich und ich weiß nicht warum???

hat da jemand eine ahnung wie das geht

mfg

David_pb

Du brichst dir ja fast einen ab mit dem ganzen void* type* gecaste...

// ...
size += 32;

type *tmp = data;
data = new type[ size ];
memmove( data, tmp, cnt*sizeof( int ) ); // oder per for, memmove is ja c ;)
data[ cnt++ ] = newvalue;

// ...

if ( tmp ) 
  delete [] tmp;
// ...

Simon2

Hi,

insgesamt scheinst Du vom malloc noch nicht ganz beim new angekommen zu sein ... (nicht böse gemeint, irgendwann muß man ja mal anfangen)

mal ein paar prinzipielle Beobachtungen (ergänzend zu Davod_pb):

Ein delete[] täte auch mal ganz gut bei der ganzen new[]-erei,
"NULL-checken" bringt bei new/new[] auch nichts, weil new/new[] standardmäßig eine bad_allocation-exception schmeißt, wenn es Probleme hat,
new Type[m_iMaxSize * sizeof(Type)] allokiert nicht (m_iMaxSize * sizeof(Type)) Bytes, sondern soviele Objekte !! "new Type[m_iMaxSize]" wäre wohl gewesen, was Du im Sinn hattest,
new[] liefert auch ein Type* zurück, also kann pNewMemory bereits den Typ Type* haben,
man darf bei Standard-Arrays auch gerne mittels [] zugreifen; ich persönlich finde "&m_pData[m_iSize]" deutlich aussagekräftiger als "m_pData, m_iSize * sizeof(Type)"...... und
Add() sollte ruhig den Wert per const-Referenz entgegennehmen ("const-as-const-can"); hier spart Dir das ebenfalls die NULL-checkerei -> Add(const Type& data);

Zum eigentlichen Problem kann ich leider auch nix sagen .... memmove() kenn' ich nicht.
Meine Implementierung wäre

template <typename Type> 
bool CArrayList<Type>::Add(const Type& data){
	if(m_iSize >= m_iMaxSize) {
		m_iMaxSize += 32;
		Type* pNewMemory = new Type[m_iMaxSize];
		if(m_pData != 0) {
			for(int i=0; i<m_iSize; ++i) pNewMemory[i] = m_pData[i];
			delete[] m_pData;
		}
		m_pData = pNewMemory;
	}
	m_pData[m_iSize++] = data;

	return true;
}

Gruß,

Simon2.