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

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

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

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;
}

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

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

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.