Operator += überladen

Hi,

ich will in einer Klasse Atomkern den "+=" Operator überladen.

Deklaration der Funktion in Atomkern.h

void operator+=(const Atomkern&);

Implementierung in Atomkern.cpp

void Atomkern::operator+=(const Atomkern& atomkern_addieren)
{

     this->ordnungszahl += atomkern_addieren.ordnungszahl;
     this->massenzahl +=  atomkern_addieren.massenzahl;
}

Wenn ich Funktion als Void definiere und so implementiere macht die Funktion das was ich will und speichert die neuen Werte für Ordnungszahl bzw. Massenzahl in dem aufrufenden Objekt.

Wieso ist es aber nicht möglich, die Deklaration bzw. Implementierung so zu gestalten:

Atomkern operator+=(const Atomkern&);

Atomkern Atomkern::operator+=(const Atomkern& atomkern_addieren)
{
     Atomkern temp;
     temp.ordnungszahl += atomkern_addieren.ordnungszahl;
     temp.massenzahl +=  atomkern_addieren.massenzahl;
     return temp;
}

Ich gebe hier dann einen temporären Wert zurück, der natürlich nach Funktionsaufruf wieder "undefiniert bzw. nicht mehr vorhanden" ist, aber trotzdem müsste doch die Zuweisung an meinen aufrufendes Objekt mit den neuen Werten noch stattfinden?

Hoffe mein Problem ist klar geworden.

mit freundlichen Grüßen

bei return temp müsste der Aufruf aber :

irgendwas = xzy.() sein.
Ich denke du musst entweder this oder ne refernz zurück geben.

Hi,

Atomkern& Atomkern::operator+=(const Atomkern& atomkern_addieren)
{
     this->ordnungszahl += atomkern_addieren.ordnungszahl;
     this->massenzahl +=  atomkern_addieren.massenzahl;
     return *this;
}

Wenn ich das so mache, dann funktioniert es auch.

Aber die Frage die sich mir stelle ist, warum ich die Übergabe nicht mit einem temporären Objekt durchführen kann.

Eine Referenz ist ja prinzipiell mit der Übergabe per Wert zu vergleichen, nur dass ich beim Funktionsaufruf keine Kopie des Objektes erstelle, sondern direkt mit dem Objekt arbeite, oder sehe ich das falsch ?

Jockelx

Nenne die +=-Operator-Memberfunktion mal in 'plusGleich' um und überlege, was du mit deiner 2ten Implementierung bei

Atomkern a;
a.plusGleich();

für ein Resultat erwarten würdest.

Das ist ja totaler Mist, was ich da gemacht habe.

Mal ganz davon abgesehen, dass ich den "+=" operator auf das temporäre Objekt anwenden, dass durch den Konstruktor der Klasse mit 0 initialisiert ist.

Außerdem muss ich in meiner Main-Funktion dann ja nochmals eine Zuweisung durchführen wie z.B.

Atomkern a, b, c;

c = a.plusgleich(b);

Herzlichen dank für deinen Denkanstoß, mein Problem dürfte damit geklärt sein.

Atomkern Atomkern::operator+=(const Atomkern& atomkern_addieren)
{
     Atomkern temp;
     temp.ordnungszahl += atomkern_addieren.ordnungszahl;
     temp.massenzahl +=  atomkern_addieren.massenzahl;
     return temp;
}

Jetzt mal die Operator Sache ausser Acht gelassen, kannst du aber normal schon eine lokale Variable oder dergleichen zurück geben wenn das gleich zugewiesen wird, oder lieg ich da falsch ?

Sonst würde ja sowas auch nicht gehen,

int foo(int x){
	int tmp; 

	tmp = 2*x;
	return tmp;
}

main : 

int dummy = foo(2);

std::cout << dummy << "\t" << foo(4);

Jockelx

Ich verstehe zwar nicht, wie du auf die Frage in dem Zusammenhang oben kommst, aber ja:
Natürlich kannst du eine lokale Variable als Kopie zurück geben.