+ Operator überladen

Hallo,

#include <iostream.h>
#include <conio.h>

class Bruch
{
    private:
    double Z;
    double N;

    public:
    void SetZ (double);
    void SetN (double);
    double GetZ ();
    double GetN ();

    Bruch operator+ (Bruch);
};

was ist der unterschied zwischen den beiden folgenden Quellcodes:

Bruch Bruch::operator+ (Bruch Value)
{
      Bruch Ergebnis;
      Ergebnis.Z = this->Z + Value.Z;
      Ergebnis.Z = this->N + Value.N;
      return Ergebnis;
}

und

Bruch Bruch::operator+ (Bruch Value)
{
    this->Z = this->Z + Value.Z;
    this->N = this->N + Value.N;
    return *this;
}

die oberste Version soll es möglich machen:
Bruch1 + Bruch2 + Bruch3 + Bruch4 zu schreiben
Ob das auch so geht weiß ich nicht!

die untere Version soll es möglch machen
Bruch1 + Bruch2 zu schreiben
das funktioniert. Anschließend frage ich einfach
mit GetZ und GetN die Werte aus Bruch1 ab (das ist das Ergebnis)
der Addition und bin glücklich. Aber beim oberen Code, wo wird da das Ergebnis abgespeichert? Wie funktioniert das?
???

Gruß Giovanni

Das mache ich übrigens im Hauptprogramm:

Bruch Bruch1;
    Bruch Bruch2;

    Bruch1.SetZ(edtBruch1Zaehler->Text.ToDouble());
    Bruch1.SetN(edtBruch1Nenner->Text.ToDouble());

    Bruch2.SetZ(edtBruch2Zaehler->Text.ToDouble());
    Bruch2.SetN(edtBruch2Nenner->Text.ToDouble());

    Bruch1 + Bruch2;

    edtErgebnisZaehler->Text = Bruch1.GetZ();
    edtErgebnisNenner->Text  = Bruch1.GetN();

Ahh, kann es sein, dass bei der unteren Version:

Bruch Bruch::operator+ (Bruch Value)
{
    this->Z = this->Z + Value.Z;
    this->N = this->N + Value.N;
    return *this;
}

Das Ergebnis direkt in Bruch1 gespeichert wird? D. h. kann schreiben:
Bruch1 + Bruch2;
Bruch1 + Bruch2;

oder bei der oberen Version:

Bruch Bruch::operator+ (Bruch Value)
{
      Bruch Ergebnis;
      Ergebnis.Z = this->Z + Value.Z;
      Ergebnis.Z = this->N + Value.N;
      return Ergebnis;
}

wo das Ergebnis zurückgegeben wird, da kann ich schreiben:
Ergebnis = Bruch1 + Bruch2 + Bruch2
Aber dazu muss ich erst den operator= programmieren, oder?

Bashar

Die untere Version verändert den Bruch auf der linken Seite, und das würde man nicht unbedingt erwarten, weil die eingebauten Operatoren sich anders verhalten. Nimm z.B.

int main() {
  int a = 42, b = 3;
  a + b;
  cout << a << endl; // würdest du etwas anderes als 42 erwarten???
}

Der untere + Operator hat eher das Verhalten des operator+=, und sollte daher IMHO auch so heißen. Einen operator= brauchst du zwar, aber musst ihn nicht definieren, weil der Compiler einen für dich anlegt, der bei deiner Klasse schon selbst das richtige tut.

Is ja geil! Funzt einwandfrei!
Danke

groovemaster

Eine feine Sache ist, solche Operatoren über den zugehörigen Assignment Operator zu implementieren:

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

Man beachte auch die const correctness. Dann wäre dir auch aufgefallen, dass deine 2. Version keine gute Idee ist.

nachtrag: dem Wunsch von Shade entsprechend

Bruch operator +(Bruch lhs, const Bruch& rhs)
{
    return lhs += rhs;
}

Shade Of Mine

jetzt nur den op+ nicht als memberfunktion bitte, danke.