Operator Overloading

Dann nimm doch gleich keine Pointer...

int main() {
    Bruch bruch(3, 5);
    Bruch bruch_2(3, 5);
    Bruch bruch_3 = bruch * bruch_2;
}

wx++

Mach's doch ohne Pointer:

const Bruch operator*(Bruch& otherBruch) {
                   int new_zaehler, new_nenner;
                   new_nenner = otherBruch.GetNenner() * this->GetNenner();
                   new_zaehler = otherBruch.GetZaehler() * this->GetZaehler();
                   return Bruch(new_zaehler, new_nenner);
}

Normalerweise würde ich das aber als freie Funktion machen, da du dann implizite Typumwandlungen nutzen kannst.

const Bruch operator*(Bruch& otherBruch) {
                   int new_zaehler, new_nenner;
                   new_nenner = otherBruch.GetNenner() * this->GetNenner();
                   new_zaehler = otherBruch.GetZaehler() * this->GetZaehler();
                   return Bruch(new_zaehler, new_nenner);
}

Ich würde kein const Bruch zurück geben, ist unnötig. Stattdessen ein const Bruch& als Parameter, da ich im operator* hoffentlich (!) die Parameter nicht verändert werden. Non-const-Referenz verbaut dem Compiler auch Optimierungsmöglichkeiten.

Dankeschön!

Noch ne Frage, wenn ich das so mache, wie Du es vorgeschlagen hast, nämlich:

return Bruch(new_zaehler, new_nenner);

Wird dann das Objekt erst erstellt wenn ich wieder im main() bin? Oder wird es erstellt, zurückgeschickt und dann aus diesem scope gelöscht?

Denn ich würde noch Gerne die Memberfunktion Kuerzen() aufrufen, vor dem zurückschicken, aber falls das uneffizient ist, lässt sich auch den Nenner und Zaehler vor der Multiplikation kuerzen.

wx++

Es wird erstellt, kopiert und anschließend gelöscht. Das kann der Compiler aber optimieren. Wenn du vorher kürzen willst, dann tu es doch:

Bruch newbruch(new_zaehler, new_nenner);
   newbruch.kuerzen();
   return newbruch;
}

Danke für die Hilfe!

Noch eine letzte Frage habe ich.
Weiter oben hast du angedeutet, dass man so etwas erstellen könnte:

bruch * bruch_1 * bruch_2 .. etc.

Ganz allgemein zum Operator Overloading, wie würde man das denn anstellen?

MfG

wx++

So, wie es ist.
bruch1 * bruch2 * bruch3 ist das gleiche wie
(bruch1 * bruch2) * bruch3

OperatorOverloading schrieb:

Danke für die Hilfe!

Noch eine letzte Frage habe ich.
Weiter oben hast du angedeutet, dass man so etwas erstellen könnte:

bruch * bruch_1 * bruch_2 .. etc.

Ganz allgemein zum Operator Overloading, wie würde man das denn anstellen?

Probiers doch aus...
Mit folgendem Operator geht das von selbst:

Bruch operator*(const Bruch& left, const Bruch& right)

Ist jetzt als freie Funktion, das geht auch. Ist hier angebracht, da beide Operanden gleichberechtigt sind.

Nexus

Du brauchst den Operator also nur einmal -- ganz normal -- zu überladen.

Du kannst dir das so vorstellen, dass bei

bruch1 * bruch2 * bruch3

zuerst

bruch1 * bruch2

ausgewertet wird und ein temporäres Objekt vom Typ Bruch erzeugt. Nennen wir es vorläufig zwischenresultat , um das Verständnis zu erleichtern. Der gesamte Ausdruck wird dann zu:

zwischenresultat * bruch3

So kann der operator* erneut auf die beiden Objekte angewandt werden, und man erhält das endgültige Resultat.

Aha, ich verstehe!

Danke vielmal