Ich habe ein Problem auf das ich nicht wirklich eine Antwort weiß.

template<typename Type>
Array<Type> Array<Type>::operator+(Array<Type>& ratArray)
{
	Array<Type> atArray;
        // hier kopiere ich alles
	return atArray;
}

Das ist die Methode.
Wenn ich dies jetzt anwende bekomme ich eine Assertiation.

BLOCK_TYPE_IS_VALID(...)

Array<int> a1(1),a2(1),a3(2);

a1=1;
a2=2;

a3=a1+a2;

Aber ich habe keine Ahnung warum.
Wenn ich aber in der Methode den Rückgabewert static mache funktioniert es ohne Probleme.

template<typename Type>
Array<Type> Array<Type>::operator+(Array<Type>& ratArray)
{
	static Array<Type> atArray;
        // hier kopiere ich alles
	return atArray;
}

Diese Art von Fehler erinnert mich an Fehler die passieren, wenn man Pointer oder Referenzen zurückgibt, aber in diesem Fall benutze ich keine.

Falls ihr den ganzen Code braucht sagt nur Bescheid.

mfg Babu

template<typename Type>
class Array
{
	public:

		Array(void);
		Array(un unSize);
		Array(un unSize,Type* ptSourceData,un unDataSize,un unIndex);

		~Array(void);

		void SetSize(un unNewSize);

		void AssignData(Type* ptSourceData,un unDataSize,un unIndex);

		void operator=(Array<Type>& ratArray);

		Array<Type> operator+(Array<Type>& ratArray);

		Type* ptData;
		un unSize;
};

template<typename Type>
Array<Type> Array<Type>::operator+(Array<Type>& ratArray)
{
	Array<Type> atArray; // wenn man hier ein static setzt funktioniert es
                             // aber ich weiß nicht warum

	atArray.SetSize(this->unSize+ratArray.unSize);
	atArray.AssignData(this->ptData,this->unSize,0);
	atArray.AssignData(ratArray.ptData,ratArray.unSize,this->unSize);

	return atArray;
}

template<typename Type>
void Array<Type>::AssignData(Type* ptSourceData,un unDataSize,un unIndex)
{
	for(un unTicks=0;unTicks<unDataSize;unTicks++)
	{
		this->ptData[unTicks+unIndex]=ptSourceData[unTicks];
	}

	return;
}

template<typename Type>
void Array<Type>::operator=(Array<Type>& ratArray)
{
	this->SetSize(ratArray.unSize);
	this->AssignData(ratArray.ptData,ratArray.unSize,0);

	return;
}

template<typename Type>
void Array<Type>::SetSize(un unNewSize)
{
	delete[] this->ptData;
	this->ptData=new Type[unNewSize];
	this->unSize=unNewSize;

	return;
}

template<typename Type>
Array<Type>::Array(void)
{
	this->ptData=new Type[0];
	this->unSize=0;
}

template<typename Type>
Array<Type>::Array(un unSize)
{
	this->ptData=new Type[unSize];
	this->unSize=unSize;
}

template<typename Type>
Array<Type>::Array(un unSize,Type* ptSourceData,un unDataSize,un unIndex)
{
	this->ptData=new Type[unSize];
	this->unSize=unSize;

	this->AssignData(ptSourceData,unDataSize,unIndex);
}

template<typename Type>
Array<Type>::~Array(void)
{
	delete[] this->ptData;
}

Array(const Array<Type>& other);

EDIT: Der muss im wesentlichen die Struktur so initialisieren wie sie der operator= kopieren würde...

CtrIsValidHeapPointer(...)

Aber ich frage mich woher kann das alles kommen.
Der Code ist bis jetzt ja nicht wirklich schwer und eher primitiv.

Spaßvogel! Du arbeitest mit nackten Arrays. Selbst Schuld. Da gibt es dutzende Möglichkeiten Fehler zu machen, die man ganz schnell übersieht. Mit einem std::vector wäre dir das vermutlich nicht passiert.

Selber Spaßvogel! Er baut sich doch genau deswegen eine Arayklasse -.-

Z2 schrieb:

Spaßvogel! Du arbeitest mit nackten Arrays. Selbst Schuld. Da gibt es dutzende Möglichkeiten Fehler zu machen, die man ganz schnell übersieht. Mit einem std::vector wäre dir das vermutlich nicht passiert.

Selber Spaßvogel! Er baut sich doch genau deswegen eine Arayklasse -.-

Wenn eine spezielle Array-Klasse benötigt wird (std::vector es also aus irgendeinem Grund nicht tut), ist es trotzdem sinnvoll diese auf eine bereits etablierte Array-Klasse zurückzuführen (eben std::vector).
Wenn es nur um eine Übung geht, ok. Allerdings sehe ich nicht, welchen Sinn es hat eine Programmiertechnik zu üben, die im Allgemeinen keinen praktischen Nutzen mehr hat.