Destruktur und return

[thundermare]

hallo,

ich weiss der titel sagt nicht viel aus aber jetzt kommt ja eine beschreibung.

class Test

{


char *string;


public:

      ~Test(){

       delete[] string;

       string = 0;

      }


     Test foo(Test tmp){

      Test tmp2;  


      tmp2 = tmp;


      return tmp2; //springt in den destruktor und verursacht einen fehler beim               

                        //delete

     }//wie koennte man das anders lösen ???


};

[Klotzkopp]

Es gibt eine Regel, die besagt: Wenn du einen der "großen Drei" (Copykonstruktor, Copy-Zuweisungsoperator, Destruktor) benötigst, benötigst du alle drei.

Das Problem ist in deinem Fall, dass du keinen Copykonstruktor definiert hast. Der Compiler erstellt dann selbst einen, aber der macht nur eine flache Kopie, d.h. er kopiert den Zeiger. Du hast also zwei Objekte, die denselben Zeiger benutzen. Und damit knallt's beim zweiten delete.

Einen Member im Destruktor auf Null zu setzen, ist übrigens ziemlich sinnlos.

[thundermare]

im monkreten fall geht es um diesen quelltext

#include "TString.h"


TString::TString()

{


}


TString::~TString()

{

	delete[] string;

	string = 0;

}


TString::TString(char *charVal)

{

	string = charVal;

	string = new char[getTStrlen()];

	int i = 0;


	while(string[i] != '\0')

	{

		string[i] = charVal[i];

		i++;

	}

}



/*TString TString::operator = (TString &TString2)

{ 

  *this = TString2;

  return *this;

}*/


TString::TString(TString &TString2)

{ 

  *this = TString2;

}


int TString::TStrlen()

{

	int i=0;

	while(string[i] != '\0'){

		i++;

	}


	/*if(i != 0)

	{

		i--; //garantiert das i nie negativ ist um folgendes zu verhindern

	}		//string[-1];*/


	return i;

}


TString TString::operator +(TString &string2)

{

	TString tmp;

	int i = 0;

	int index = 0;

	int len_string = getTStrlen();

	int len_string2 = string2.getTStrlen();


	tmp.string = new char[len_string + len_string2+2];


	for(i;i <= len_string + len_string2+1;i++)

	{

		tmp.string[i] = '\0';

	}


	i = 0;


	for(i;i < len_string;i++)

	{

		tmp.string[i] = string[i];

	}



	for(i;i < len_string + len_string2;i++)

	{

		tmp.string[i] = string2.string[index];

		index++;

	}


	return tmp;

}



int TString::getTStrlen()

{

	return TStrlen();

}


char* TString::getString()

{

	return string;

}

wo steckt denn hier der fehler???

[Klotzkopp]

wo steckt denn hier der fehler???

Naja, der Zuweisungsoperator ist auskommentiert. Vermutlich deswegen, weil er nichts weiter tut als sich selbst aufzurufen, also eine Endlosrekursion. Irgendwo musst du dir schon die Arbeit machen und festlegen, was genau bei einer Zuweisung passieren soll. Dass der Zuweisungsoperator eine Kopie zurückgibt, ist auch nicht gut, das sollte eine Referenz sein.

Es ist übrigens nicht empfehlenswert, den Copykonstruktor mit Hilfe des Zuweisungsoperators zu implementieren, weil der Zuweisungsoperator dann in der Lage sein muss, mit einem nicht (oder zumindest nicht vollständig) initialisierten Zielobjekt zurechtzukommen. Besser ist es, einen ordentlichen Copykonstruktor zu schreiben, und dazu eine Swap-Methode, die zwei TString tauschen kann und sicher keine Exception wirft. Dann kann man den Zuweisungsoperator ganz einfach mittels "Copy and Swap" implementieren:

TString& TString::operator = (TString &TString2)

{

    TString temp( TString2 );

    Swap( temp, *this );

    return *this;

}[/code]

Aber wie gesagt, das erfordert einen "richtigen" Copykonstruktor, keinen, der einfach nur den Zuweisungsoperator aufruft.