Operatoren in C++

[SideWinder]

Letztens wurde meine Operator-Datei hier verlinkt, war mir Anreiz die Datei endlich mal zu überarbeiten: http://cache.sidewindershome.net/Operators.h

-> Was ist falsch?
-> Wo sind Verbesserungen möglich?
-> Was fehlt?

Hoffe jemand findet die Zeit mal kurz drüber zu schauen

MfG SideWinder

[volkard]

beim op= vermisse ich copy&swap.

[HumeSikkins]

Example operator++ (int); // obj++
Example operator-- (int); // --obj

Das soll wohl:

Example operator++ (int); // obj++
Example operator-- (int); // obj--

heißen.

/* Cast-Operatoren

Es gibt in C++ nur genau vier Cast-Operatoren, nämlich static_cast, const_cast, reinterpret_cast und dynamic_cast. Was du da beschreibst, und was in der Regel implizit aufgerufen wird, sind Konvertierungs-Operatoren.

Example obj;
obj[5] = "Hugo"; // Aufruf der "normalen" Version
std::string str = obj[5]; // Aufruf der konstanten Version

Nope. Bei der Auswahl von const/non-const Memberfunktionen
unterschdeitet C++ nicht automatisch Lese- und Schreibzugriffe. Entscheidend ist nur die "constness" des Objekts für das die Memberfunktion aufgerufen wird. Da obj nicht const ist, wird hier jeweisle die "normale" Version aufgerufen.

/* Q: Warum sind diese Operatoren keine Member?
[...]
Danach wird im globalen Namensraum nach einem operator==(int,Example) gesucht, in diesem wird der Compiler nur fündig, wenn wir den operator== als Friend der Klasse deklariert haben und extern im globalen Namensraum definiert haben.

Die Erklärung ist falsch bzw. mindestens verwirrend. Erstmal ist friend für das eigentliche Problem irrelevant.
Und dann ist doch die eigentliche Frage, warum nicht einfach die 2 nach Example konvertiert (über den entsprechenden Ctor) und dann die Memberversion von op+ aufgerufen wird.

Das geht nun aber nicht, da auf this niemals eine implizite Konverierung durchgeführt wird. D.h. Kommutative Operatoren die als Argumente Objekte von udts erwarten, welche über Konvertierungsctoren verfügen die implzite Konvertierungen erlauben, müssen als non-member implementiert werden, da sonst auf dem linken Operand keine Konvertierungen möglich sind.

Dann gleich noch dazu: Warum sind die Operatoren friend? Die kanonische Implementation verwendet einfach den passenden op@= (wobei @ für +-*/ steht).

Example operator @ (const Example& lhs, const Example& rhs) {
    Example t(lhs);
    return t @= rhs;
}

Zu den Stream-Operatoren: Auch die würde ich nicht standardmäßig zu friends machen. Eher würde ich diese zu read/write-Memberfunktion delegieren, da ich diese z.B. auch problemlos virtuell machen kann.