Frage zu Operatoren und deren Rückgabewerten



  • Hi,

    mir stellt sich zu Operatoren folgende Frage. Angenommen ich haette eine Klasse und möchte dazu den "=" Operataor schreiben.

    VektorKlasse& operator +=(int d){
    ...
    return *this
    }
    Jetzt schreibt der Compiler den Aufruf des Operators mit z.b
    ```cpp
    VektorKlasse v;
    v += 5;
    

    um zu
    v.operator+(5) nur wie gelangt jetzt der rückgabewert *this bzw. die Adresse davon wieder an das aufrufende Objekt bzw. v?

    Realisiert man einen + mit auch dem rückgabewert *this, dann ist das ganze ziemlich einfach, denn
    v = v2 + 3
    schreibt der Compiler um zu:
    v = v2.operator+(3);
    und der "=" Operator weist es wiederum dem v zu. Damit ist eig. ziemlich klar, was mit dem rückgabewert passiert. nur bei einem += operator, der am ende sich selbst zurück gibt, ist mir nicht klar, wie der rückgabewert wieder an das aurufende objekt selbst zurück geliefert wird, wenn der Compiler es intern zu v.operator+(5) umschreibt und aufruft, damit müsste ja der Rückgabewert an gar nichts zurückgeliefert werden. Wenn die Funktion bzw. der Operator das Objekt verändert, dann müsste es doch eig. gar keinen Rückgabewert übergeben, oder nicht? Oder ist das nur fuer den Fall damit so eine Kombination möglich ist:
    v2 = v+=5?



  • @tes32

    möchte dazu den "=" Operataor schreiben.

    VektorKlasse& operator +=(int d){

    um zu v.operator+(5)

    Wieviele verschiedene Operatoren werden hier genannt?



  • Ich tippe auf +=. 1.

    @tes32 sagte in Frage zu Operatoren und deren Rückgabewerten:

    nur bei einem += operator, der am ende sich selbst zurück gibt, ist mir nicht klar, wie der rückgabewert wieder an das aurufende objekt selbst zurück geliefert wird, [...]

    Wie meinst du "an das aufrufende objekt selbst zurück geliefert wird"?



  • @Swordfish Ich frage mich, wie es dazu kommt, dass ein *this zurückgegeben wird? Damit passiert doch eig. nichts? Wenn der Compiler den Aufruf wie eh zu
    v.operator+=(5) umschreibt, warum wird dann da noch ein this zurückgegeben?
    Ist das dann nur dazu da, um solche Konstellationen zu ermöglichen:
    v2 = v+=(5), denn dann würde es umgeschrieben werden zu,
    v2=v.operator+(5);



  • Was zurückgegeben wird kann verwendet werden, muss aber nicht.

    Umgeschrieben wird garnichts.

    In

    struct foo {
        foo& operator+=(foo const &) { return *this; }
    };
    

    ist

    foo a, b;
    a += b;
    

    dasselbe wie

    a.operator+=(b);
    

    Du scheinst da irgendwie ein Verwechslungsproblem mit +, += und = zu haben, denn

    @tes32 sagte in Frage zu Operatoren und deren Rückgabewerten:

    v2 = v+=(5) [...][und]
    v2 = v.operator+(5);

    ist nicht dasselbe.

    @tes32 sagte in Frage zu Operatoren und deren Rückgabewerten:

    Ist das dann nur dazu da, um solche Konstellationen zu ermöglichen:
    v2 = v+=(5)

    "Nur"? Ja. Und ähnliches.

    Wenn zB. operator<<() keine Referenz auf den Stream zurückgeben würde, wäre mit std::cout << "foo " << 42 << " bar"; Essig.



  • @tes32 sagte in Frage zu Operatoren und deren Rückgabewerten:

    Ist das dann nur dazu da, um solche Konstellationen zu ermöglichen:
    v2 = v+=(5),

    Ja. Wobei man es bei += eigentlich hauptsächlich macht, weil die "eingebauten" Operatoren es auch machen, und man möchte dass die selbstdefinierten Operatoren so ähnlich wie möglich sind.
    Sicher, manche Leute finden es schick solchen Code zu schreiben, speziell beim Aufruf von Funktionen (also someFunction(x += 5) o.Ä.). Ich bin da aber eher kein Fan davon, weil ich finde dass es den Code schwerer lesbar macht. Trotzdem schreibe ich meine Operatoren so dass es möglich ist, "weil man das halt so macht". Und "weil man das halt so macht" würde sich dann jeder wundern der den Code liest ob a) ich mich nicht auskenne weil ich das nicht weiss oder b) ich einen guten, aber ihnen nicht bekannten Grund habe es nicht so zu machen "wie man es halt macht". Was somit eine POLA-Verletzung wäre, und ich mache halt nicht gerne absichtlich POLA-Verletzungen.



  • @hustbaer sagte in Frage zu Operatoren und deren Rückgabewerten:

    "weil man das halt so macht"

    Anderes Stichwot: Do as the ints do:

    Instead of being cute, the library writers should have followed Scott Meyers' excellent advice to "do as the ints do." That is, when using operator overloading or any other language feature for your own classes, when in doubt always make your class follow the same semantics as the builtin and standard library types.

    @hustbaer Ich wünsch' Dir und Deinen liebsten morgen heute ein frohes Fest und geruhsame Tage 🙂



  • @Swordfish Danke! Ich wünsch dir ebenfalls frohe Feiertage und ein gutes neues Jahr 🙂



  • @hustbaer sagte in Frage zu Operatoren und deren Rückgabewerten:

    und ein gutes neues Jahr

    Naja, davor lesen wir uns ja sicher noch. Du Junky 😛



  • @Swordfish
    Ja haste auch wieder Recht. Vermutlich. Aber falls nicht bin ich schonmal safe xD



  • lol.


Anmelden zum Antworten