3. operatorüberladung

operatorüberladung

  • ?

    Hallo zusammen, könnte mir mal einer bitte erklären, wie ich diesen Code zu verstehen habe!!

    Geld Geld::operator += (Geld Geld2) //Definition der Memberfunktion +=
    {
    Euro += Geld2.Euro;
    Cent += Geld2.Cent;

    return *this;
    }

    Geld operator + (const Geld Geld1,const Geld Geld2) //Deklaration und Definition
    { // der Operators +
    return Geld(Geld1)+=Geld2; // als externe Funktion
    }
    Die Überladung des += operators, nimmt man über den + operator vor, um den Code besser pflegen zu können und wegen der übersicht. Soweit sollte es stimmen. Ich bekomm aber den Übergang von + nach += nicht hin. Was wird übergeben? Geld2 wo kommte der this Zeiger her oder hin??? Wäre super nett, wenn es mir jemand erklären könnte!

    Vielen Dank gruss Alex

    0
  • S

    += gleich operator ist sysmatisch schon mal falsch oder zumindest komisch.

    ch meine du solltest überprüfen ob cent über 100 geht wenn ja dann bei eure eins dazu zählen.

    mfg

    0
  • C

    Wie wäre es wenn du deinen Code in

    Sowas einfügst

    ", dann könnten Leute die was von deinem Problem verstehen (ich nicht!!), den Code besser lesen und deine Frage beantworten.

    PS: Ist mir auch schon einige Male passiert 😉

    MfG CSS

    0
  • V
     

    Geld Geld::operator += (Geld Geld2)         //Definition der Memberfunktion +=
{
        Euro += Geld2.Euro;
        Cent += Geld2.Cent;

        return *this;
}

Geld  operator + (const Geld Geld1,const Geld Geld2) //Deklaration und Definition
{                                           // der Operators +
      return Geld(Geld1)+=Geld2;          // als externe Funktion
}

    Wenn ichd as richtig sehe, dann ist der op+= nicht abhängig von op+, da ich mal vermute, dass Geld::Euro und Geld::Cent integer sind. D.h. das dem Objekt, auf dem op+= aufgerufen wird, zu Euro und Cent jeweilks nur die € und Cent Werte des Objektes hinzu addiert werden, die zu dem Objekt gehören, das auf der rechten Seite des Ops stehen:

    Geld geld, geld2;

geld += geld2;
//ist gleichbedeutent mit:
geld.Euro += geld2.Euro;
geld.Cent += geld2.Cent;

    Dabei ist this immer ein Zeiger auf de Objekt, auf dem this benutzt wird.

    Nur der op+ benutzt danmn wohl den op+=, wie ich das grad sehe :p

    Naja, vielleicht hab ich auch falsch verstanden, was du wolltest ...

    0
  • ?

    Hallo nochmal,
    hier der ganze Code, damit man verstehen kann, was das alles soll!

    #include <iostream>
using namespace std;

class Geld
{
  private:
    int    Euro;
        int    Cent;

  public:
    Geld (int euro=0, int cent=0):Euro(euro),Cent(cent){};   //Konstruktor
    int getEuro () const { return Euro; } //Methoden
    int getCent () const { return Cent; } //Methoden
    void putEuro (int input){Euro=input;}
    void putCent (int input){Cent=input;}
    Geld operator += (Geld Geld2);          //Deklaration des Operators +=
                                            // als Memberfunktion
        void normalize();

};

Geld Geld::operator += (Geld Geld2)         //Definition der Memberfunktion +=
{
        Euro += Geld2.Euro;
        Cent += Geld2.Cent;

        return *this;
}

Geld  operator + (const Geld Geld1,const Geld Geld2) //Deklaration und Definition
{                                           // der Operators +
        return Geld(Geld1)+=Geld2;          // als externe Funktion
}

// Normalisieren der Zahlendarstellung (0 <= Cent < 100)
void Geld::normalize ()
{
        if (Cent >= 100)
        {
                int eur = Cent / 100; 
                Euro += eur; 
                Cent -= eur * 100;
        }
}
main ()
{
        int i1,i2, i3,i4;
        Geld a, b, c;

        cout << "Objekt1" << endl;
        cout << "Euro: ";
        cin >> i1;
        cout << "Cent: ";
        cin >> i2;
        a.putEuro(i1);
        a.putCent(i2);

        cout << "Objekt2" << endl;
        cout << "Euro: ";
        cin >> i3;
        cout << "Cent: ";
        cin >> i4;
        b.putEuro(i3);
        b.putCent(i4);

        cout <<"a= "<< a.getEuro() << "." << a.getCent() << endl;
        cout <<"b= "<< b.getEuro() << "." << b.getCent() << endl;
        cout <<"SUMME vor Addition= "<< c.getEuro() << "." << c.getCent() << endl;
        c=a+b;                              //Operator: Infix Notation 
        //c=operator+(a,b);          //Methode: Funktions Notation (als ext. Funktion)
        //c=a.operator+=(b);          //Methode: Funktions Notation (als Memberfunktion)
        cout <<"a= "<< a.getEuro() << "." << a.getCent() << endl;
        cout <<"b= "<< b.getEuro() << "." << b.getCent() << endl;

        c.normalize();

        cout <<"SUMME nach Addition= "<< c.getEuro() << "." << c.getCent() << endl;
        getchar();   getchar();
        return 1;
}

    Danke für die Tipps!
    Gruss Alex

    0
  • C

    Ich weiß nicht genau was du nicht verstehst, aber ich versuch mal etwas Licht in den Nebel zu bringen.

    (An alle die es besser wissen: bitte korrigiert mich, wenn ihr Fehler findet! Ich möchte nämlich ebenfalls lernen!)

    Es gibt zwei Arten der Operatorenüberladung.

    1. Art: Operatoren werden als Methoden von Klassen definiert. Binäre Operatoren haben dann ein Argument, unäre keins. (Folgende Operatoren müssen als Methoden definiert werden: =, (), [], ->)

    2. Art: Operatoren werden global definiert. Binäre Operatoren haben dann zwei Argumente, unäre eins.

    Das liegt daran, dass wenn ein Operator als Methode einer Klasse definiert ist, der Compiler davon ausgeht, dass der linke Operand stets ein Objekt der Klasse ist. Somit wird nur ein Argument benötigt.

    Der Vorteil bei Operatorfunktionen, die als Methoden definiert sind, ist, dass sie auf die Privaten-Datenelemente der Klasse zugreifen können.
    Der Nachteil ist, dass man sowas z.B. nicht schreiben kann, wenn der +-Operator als Methode definiert ist.

    // b1 bekommt z.B. durch den Ctor den Wert 10 zugewiesen.
// b2 wird z.B. durch den Standard-Ctor auf 0 gesetzt.
foo b1(10), b2;

// b2 soll nun den Wert 20 zugewiesen bekommen => Compiler-Error.
b2 = 10 + b1;

    Der Vorteil der globalen Operatorfunktionen ist, dass man wenn man z.B. den +-Operator global definiert, folgendes schreiben kann.

    // b1 bekommt z.B. durch den Ctor den Wert 10 zugewiesen.
// b2 wird z.B. durch den Standard-Ctor auf 0 gesetzt.
foo b1(10), b2;

// Kein Compiler-Error
b2 = 10 + b1;

    Nachteil: Globale Operatorfunktionen können nicht auf die Privaten Datenelemente zugreifen. (Das kann man dann mit friend-Funktionen noch umgehen... aber jetzt schweife ich aus...)

    Jetzt noch ein Wort zu this:
    Jede nicht-statische Methode einer Klasse besitzt einen this-Zeiger. Dieser wird beim Aufruf expliziet (d.h. automatisch) übergeben.
    der this-Zeiger repräsentiert im Prinzip das aktuelle Objekt und man kann mit diesem darauf zugreifen.
    Lange Rede kurzer Sinn:
    Bei deinem Operator += gibst du *this zurück.
    Das ist sinnvoll, da das aktuelle Objekt verändert wird und du es jetzt als ganzes wieder zurückgibst. (Allerdings wäre hier eine Referenz auf *this imho angebrachter).

    Jetzt gibt es natürlich noch sehr viel mehr über Operatoren zu sagen, aber ich hoffe das hilft dir ein wenig weiter.

    für weitere Infos siehe Bücher oder Tutorials (Unter c-plusplus.net gibt es eine eigene Rubrik dazu).
    Ein Tutorial zum "sofort starten" http://tutorial.schornboeck.net/operatoren_ueberladung.htm

    Caipi

    0
  • ?

    Hallo Caipi,
    vielen Dank für die super Erklärung. Auf der Seite war ich auch schon und da hab ich auch diese Erklärung gefunden:
    "zB operator+ ist mit Hilfe von operator+= implementiert, etc. Das ist sehr wichtig, da man dadurch die Lesbarkeit und vorallem die Wartbarkeit des Codes erhöt"
    Aufgerufen wird doch über c=a+b der operator +. Das ist keine Memberfunktion und in dieser Fkt ist wiederum der Aufruf der Memberfkt +=. Diese Fkt brauch einen Parameter, welcher Parameter wird übergenben? Ist es Geld2?? Mir ist einfach der Übergabemechanismus nicht klar von operator + nach +=.

    return Geld(Geld1)+=Geld2;

    Wie kann man das verstehen??? wird mit Geld1 eine neue Instanz der Klasse Geld erzeugt? Vielleicht hab ich ja auch nen totalen Denkfehler, aber deshalb versuch ich es ja zu verstehen.
    Vielen Dank nochmal für eure Hilfe

    0
  • C

    kong schrieb:

    [...]Aufgerufen wird doch über c=a+b der operator +. Das ist keine Memberfunktion und in dieser Fkt ist wiederum der Aufruf der Memberfkt +=. Diese Fkt brauch einen Parameter, welcher Parameter wird übergenben? Ist es Geld2?? Mir ist einfach der Übergabemechanismus nicht klar von operator + nach +=.

    return Geld(Geld1)+=Geld2;

    Wie kann man das verstehen??? wird mit Geld1 eine neue Instanz der Klasse Geld erzeugt? Vielleicht hab ich ja auch nen totalen Denkfehler, aber deshalb versuch ich es ja zu verstehen.[...]

    Jep. Es wird das Argument "Geld2" übergeben.
    Stell dir das ganze am besten so vor:
    Die Operator-Funktion + erwartet zwei Argumente. In der +-Operatorfunktion wird nun eine neue Instanz von Geld definiert und mit dem Parameter Geld1 intialisiert. Nun wird die +=-Operatorfunktion aufgerufen. Diese Operatorfunktion bekommt als Argument Geld2 übergeben, da "Geld(Geld1) ja der "*this-Teil" ist, d.h. das linke Objekt. Nun wird alles zusammengezählt und es wird das aktuelle veränderte Objekt zurückgegeben. Die +=-Operatorfunktion wird verlassen und es geht zurück in die +-Operator-funktion. Dort ist nun ebenfalls die Return-Anweisung erreicht. und es wird nun das neu initialisierte und zusammengezählte Objekt zurückgegeben

    Caipi

    0
  • ?

    👍 👍 👍 👍 🙂
    VIELEN VIELEN DANK!!!! Das war's super genial! Ich dachte mir, das es in die Richtung geht, aber sicher war ich mir nicht aber die Erklärung ist super, danke.
    Schönen Abend noch und nochmal vielen Dank
    Alex

    0
Anmelden zum Antworten