Operatorüberladungen

Hallo,
wann nutzt ihr bei Operatorüberladungen freie Funktionen (eventuell friend) und wann implementiert ihr sie als Memberfunktion?
Beides ist möglich und beides habe ich schon öfter gesehen, aber ich habe keine Ahnung wann was Sinnvoll ist?

(static wäre ja auch noch möglich, wobei ich das noch nie gesehen habe.)

CStoll

Generelle Richtlinien gibt es afaik nicht, aber was nicht unbedingt auf die Klassen-Interna angewiesen ist, sollte nicht in die Klasse rein. Ansonsten kenne ich nur die Fälle, die als Member (Zuweisung, Index, Funktion, Dereferenzierung) bzw. als freie Funktionen (Stream-IO, linker Operand ist Build-in oder vergleichbares) implementiert werden müssen.

operatorRR schrieb:

(static wäre ja auch noch möglich, wobei ich das noch nie gesehen habe.)

Das kenne ich nur von new und delete (und da ist es afaik implizit).

CStoll schrieb:

Generelle Richtlinien gibt es afaik nicht, aber was nicht unbedingt auf die Klassen-Interna angewiesen ist, sollte nicht in die Klasse rein.

Sind mit Interna nur private Dinge gemeint? Wenn man z.B. eine (geometrische) Vektorklasse hat, dann sind die x1, x2, x3 bzw. x, y, z Member ja public. Unäre/Binäre +/- Operatoren jetzt in der Klasse oder frei implementieren?

Macht das überhaupt irgendeinen Unterschied? (Also von der Nutzung her.)

CStoll

Ich würde die unären Operatoren und die Zuweisungen als Klassenmember schreiben und die normalen Rechenoperatoren als freie Inline-Funktionen darauf aufsetzen lassen.
Und der einzige Unterschied, der mir auf Anhieb bei der Anwendung einfällt, sind mögliche Typ-Umwandlungen der Parameter - Ausdrücke wie "4711+x" lassen sich nur mit einem freien Additions-Operator übersetzen.

pumuckl

operatorRR schrieb:

aber ich habe keine Ahnung wann was Sinnvoll ist?

Ich hab da mal was vorbereitet http://magazin.c-plusplus.net/artikel/�berladung von Operatoren in CPlusPlus (Teil 1)

pumuckl schrieb:

Ich hab da mal was vorbereitet http://magazin.c-plusplus.net/artikel/�berladung von Operatoren in CPlusPlus (Teil 1)

Hahaha danke, das lese ich mir mal durch. Toll, dass du das extra für mich geschrieben hast.

krümelkacker

Kurz und knackig: Ziehe, falls möglich, freie Funktionen vor. Die Zahl der Funktionen, die direkt mit den Internas spielen können, sollte man klein halten.

inline friends haben aber auch ihre Vorzüge, gerade bei Klassentemplates:

template<class T> class mycomplex;
...
template<class T> mycomplex<T> operator+(T,mycomplex<T>);
...

int main() {
  mycomplex<double> x;
  5 + x; // template argument deduction failure, T=double und T=int beißen sich.
}

Alternativ:

template<class T> class mycomplex {
  ...
  friend mycomplex operator+(T x, mycomplex y) {
    ...
  }
  ...
};

int main() {
  mycomplex<double> x;
  5 + x; // funkioniert. operator+ ist hier kein Template
         // und 5 wird implizit zu einem double konvertiert
}

Hier wird also "friend" hauptsächlich deswegen benutzt, um aus operator+ eine "normale" Funktion zu machen und kein eigenes Funktionstemplate.

Noch ein Tipp: "Effective C++" kaufen.