Rückgabeproblem

Jeffson

Hi,

Wieso funktioniert folgendes nicht?:

const String String::operator+(const String &string2) const
{
   ...
}

const String String::operator+=(const String &string2)
{
	return(*this = *this + string2);
}

Es wird dann irgendein willkürlicher String ausgegeben

lg

CStoll

Hast du denn mal im Debugger verfolgt, was passiert? Ansonsten kann es zu viele Unklarheiten in der Implementation von operator+ und operator= geben, die dir einen Strich durch die Rechnung machen könnten.

PS: Normalerweise kenne ich die Lösung andersrum - operator+ wird auf der Basis von operator+= implementiert.

EOutOfResources

Hast du den Zweisungsoperator korrekt implementiert (wenn du es überhaupt selbst gemacht hast)?

Jeffson

Es sieht insgesamt so aus:

class String
{
	....
        public:
	// Operator-Methode
	const String operator+(const String &) const;
	const String operator+=(const String &);
};
....
const String String::operator+(const String &string2) const
{
	unsigned int len2 = len + string2.len;
	char *zeichen_tmp = new char[len2 +1];
	memset(zeichen_tmp, '\0', sizeof(zeichen_tmp));
	cout << "strlen(zeichen) == " << strlen(zeichen) << endl;
	strncpy(zeichen_tmp, zeichen, strlen(zeichen));
	strncat(zeichen_tmp, string2.zeichen, strlen(string2.zeichen));

	String str_erg(zeichen_tmp);

	return(str_erg);
}

const String String::operator+=(const String &string2)
{
	*this = this->operator+(string2);

	return(*this);
}

Wo ist hier der Bug?

lg

EOutOfResources

Minimales kompilierbares Beispiel bitte!

CStoll

Zeig doch mal noch den Konstruktor für char* und den Zuweisungs-Operator. Auf den ersten Blick sehe ich auf jeden Fall ein potentielles Speicherleck (wer gibt den Speicher hinter "zeichen_tmp" wieder frei) und ernsthaftere Probleme, wenn len nicht immer korrekt aktualisiert wurde.

PS: Ich wiederhole mich noch mal: es ist vermutlich einfacher, wenn du die Operatoren andersherum aufeinander beziehst:

String& String::operator+=(const String& rhs)
{
  ...
  return *this;
}

//das braucht noch nicht mal eine Methode der Klasse sein:
String operator+(const String& lhs, const String& rhs)
{
  String tmp = lhs;
  return tmp+=rhs;
}

Enthält deine Klasse möglicherweise so etwas:

class String
{
private:
  char* zeichen;
public:
  String( char* z ) { zeichen = z;}
  ~String() { delete[] zeichen; }
};

Jeffson

Hi,

So etwas ähnliches. Wobei bei mir der Konstruktor durchaus umfangreicher ist. Es müsste doch so sein, dass der Destruktor eigentlich Zeichenketten in den lokal angelegten Objekten löscht, doch bei mir ist das nicht der Fall. Komisch.. In dem Buch C++ von A bis Z sind ja lauter Fehler drinnen. Das ist der Wahnsinn. Er gibt als Rückgabewert "String" an und gibt letztendlich "char *" zurück... Wahnsinn

lg

DocShoe

Jeffson schrieb:

Hi,
...
Er gibt als Rückgabewert "String" an und gibt letztendlich "char *" zurück... Wahnsinn
lg

Ich nehme JW ja nur ungern in Schutz, aber das ist gültiges C++, wenn es einen Konstruktor der Klasse String gibt, der einen char* erwartet. In diesem Fall wird der Konstruktor implizit aufgerufen und ein temporäres String Objekt zurückgegeben.