Operatoren Überladen Verständnisproblem

raised.fist

Hallo,

Wir schreiben morgen Klausur und ich hab noch eine kleine Frage die mich schon den ganzen Tag beschäftigt.

Und zwar haben wir das Buch C++ - Kurz und gut und da steht ein Beispiel zur Operatorenüberladung drin. Das verstehe ich nicht ganz. Vllt kanns mir einer schnell sagen...

class Account
{
public:
Account &operator+=(Account &a)
{balance+= a.balance;
return *this;}

private:
double balance;
}

Damit kann ich ja jetzt zwei Accountinstanzen addieren und balance von b auf a draufaddieren.

Aber ich verstehe nicht, warum man das & verwendet.

bei *Account **&*a weiß ich dass man dort die referenz von account benutzt, wegen der lokalen sichtbarkeit usw.

Aber warum schreibt man *Account **&*operator+=? Das ergibt für mich keinen Sinn, weil bei ner Referenz stellt man das & doch eigentlich voran, und nich hintendran.

mfg

ipsec

Der Rückgabewert von operator+= ist eine Referenz auf Accout. Das macht man, damit so etwas möglich wird:

Account a, b, c;
a += b += c;

// Equivalent zu
b += c;
a += b;

// Edit: NICHT equivalent zu
a += b;
a += c;

Übrigens sollte der Parameter des Operators besser const Account &a sein.

raised.fist

ipsec schrieb:

Der Rückgabewert von operator+= ist eine Referenz auf Accout. Das macht man, damit so etwas möglich wird:
Account a, b, c;
a += b += c;

// Equivalent zu
a += b;
a += c;
Übrigens sollte der Parameter des Operators besser const Account &a sein.

Ok danke.

Stimmt, im buch ist der Parameter auch const Account, aber ich hab ihn weggelassen. Warum sollte der const sein?

mfg

Michael E.

Ganz einfach:

Account a;
const Account b;
a += b;

Dieser Code klappt nur, wenn operator+= ein konstantes Objekt erwartet, weil eine implizite Konvertierung von const Account in Account nicht möglich ist.

raised.fist schrieb:

Stimmt, im buch ist der Parameter auch const Account, aber ich hab ihn weggelassen. Warum sollte der const sein?

Weil du damit nur einen lesenden Zugriff machst (a.balance) und keinen schreibenden,
du also die Attribute des Objekts 'a' in der Funktion nirgends verändern willst.
Wenn etwas nich verändert werden soll, macht man es 'const'.

Michael E.

ipsec schrieb:

Account a, b, c;
a += b += c;

// Equivalent zu
a += b;
a += c;

Nein, das ist nicht äquivalent, denn b wird auch verändert.

ipsec

Oh ja hast Recht, ich hab vergessen, dass += von rechts nach links und nicht von links nach rechts abgearbeitet wird.

ipsec schrieb:

Der Rückgabewert von operator+= ist eine Referenz auf Accout. Das macht man, damit so etwas möglich wird:
Account a, b, c;
a += b += c;

// Equivalent zu
b += c;
a += b;

// Edit: NICHT equivalent zu
a += b;
a += c;
Übrigens sollte der Parameter des Operators besser const Account &a sein.

also

a += b += c;

ist equivalent zu

b+=c;
a+=b;

da Abarbeitung von right-to-left stattfindet.

Der Grund, warum du

Account &operator+=

machst: Wenn eine Funktion etwas zurückgibt, das bereits vor dem Aufruf der Funktion existiert, macht man eine Referenzrückgabe.

--> b+=c; --> Returnwert ist 'b' und 'b' existiert ja bereits vor dem Methodenaufruf... wieso also eine unnötige copy machen, kann man doch gleich das Original verwenden.