c++.de :: Überladung von Operatoren in C++ (Teil 1)

pumuckl Moderator 15:41:07 21.01.2009 Titel:

hab dort geantwortet.

pospiech Mitglied 15:09:02 12.02.2009 Titel:

Ich würde das hier mit const schreiben, also statt

C++:
X operator+(X const& lhs, X const& rhs)

das hier

C++:
const X operator+(X const& lhs, X const& rhs)

Dann kann man nicht "(a+b)=c" schreiben.

icarus2 Mitglied 23:35:23 06.05.2011 Titel:

*Edit
Sry, habe etwas in den falschen Thread kopiert.

Unregistrierter

Sehr guter Artikel.

Solltest du gewillt sein, an der ein oder anderen Stelle etwas ausführlicher zu werden, würde ich mich sehr darüber freuen.

Mir ist allerdings etwas aus deinem Beispiel aufgefallen. Folgender Code dürfte nicht ganz richtig sein, schließlich hast du extra den Konstruktor programmiert, verwendest ihn aber nicht. Bei der Erzeugung von a, b und c solltest du noch Standardwerte nachreichen, ansonsten kommt bei der Addition nur Mumpitz raus.

Code:
1 2 3 4 5 6 7 8 9 10 11 12	class Rational { public: Rational(int i); //Konstruktor für Konvertierungen von Ganzzahlen Rational operator+(Rational const& rhs) const; }; Rational a, b, c; int i; a = b + c; //ok, keine Konvertierung nötig a = b + i; //ok, implizite Konvertierung des zweiten Arguments a = i + c; //FEHLER: erstes Argument kann nicht konvertiert werden, da operator+ keine freie Funktion

Nexus Mitglied 17:32:45 09.06.2012 Titel:

nuke1600 schrieb:

schließlich hast du extra den Konstruktor programmiert, verwendest ihn aber nicht.

Doch, er wird für die implizite Konvertierung von int nach Rational verwendet.

nuke1600 schrieb:

Bei der Erzeugung von a, b und c solltest du noch Standardwerte nachreichen, ansonsten kommt bei der Addition nur Mumpitz raus.

Der Code würde gar nicht kompilieren, weil kein Defaultkonstruktor vorhanden ist. Aber wie die Objekte erzeugt werden, ist in dem Beispiel nebensächlich...

pumuckl Moderator 18:44:43 11.06.2012 Titel:

Nexus schrieb:

wie die Objekte erzeugt werden, ist in dem Beispiel nebensächlich...

Richtig. Ein weitgehend vollständiges beispiel für so eine Rational-Zahlenklasse findest du im zweiten und dritten Teil des Artikels.

Sone Mitglied 12:52:20 19.08.2012 Titel:

Btw, jetzt mit C++11 können einige Operatoren wie operator?: überladen werden. Kommt dazu noch was?

pyhax Mitglied 13:35:13 19.08.2012 Titel:

Sone schrieb:

Btw, jetzt mit C++11 können einige Operatoren wie operator?: überladen werden. Kommt dazu noch was?

Wo hast du das den her?

Sone Mitglied 16:58:42 19.08.2012 Titel:

pyhax schrieb:

Sone schrieb:

Btw, jetzt mit C++11 können einige Operatoren wie operator?: überladen werden. Kommt dazu noch was?

Wo hast du das den her?

Mein Fehler, hab mich im Standard verguckt. Siehe 13.6.24, war schon ne Weile her, hab mich falsch erinnert...

Zsar Mitglied 08:56:23 15.11.2012 Titel:

Mmh, wäre es möglich, Beispiele für die Überladung von operator-> und operator->* zu bekommen? Insbesonders, da das hier anders als der Artikel zu behaupten scheint, dass typ * operator->() für den Zugriff auf Elemente von typ gedacht ist (mag aber auch einfach nur schlecht formuliert sein).

... Kann mir nicht recht vorstellen, wie man das zu verwenden hat.

Ich glaube, dass ich damit elegant dieses Ding hier vereinfachen könnte:

Code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15	typedef struct Nest { double wert; double * koordinaten; double * wertigkeiten; } Nest * LeeresNest(const size_t & dimension, const size_t & bewohner) { Nest * ausgabe = (Nest )operator new(2 sizeof(double ) + (1 + dimension + bewohner) sizeof(double)); ausgabe->koordinaten = (double *)(&ausgabe->wertigkeiten + 1); ausgabe->wertigkeiten = ausgabe->koordinaten + dimension; return ausgabe; }

(siehe dieses Thema, falls die Motivation kümmert)

Weiterhin:
Wenn ich mir diesen überladenen Operator anschaue:

Code:
vector<T,Allocator>& operator= (const vector<T,Allocator>& x);

dann wird derselbe so benutzt:

Code:
vector a; vector b = a;

Mit diesem hier:

Code:
void* operator new (std::size_t size) throw (std::bad_alloc);

sollte die Verwendung also dergestalt aussehen:

Code:
Nest * (Nest )new 2 sizeof(double ) + (1 + dimension + bewohner) sizeof(double);

Funktioniert aber nicht - die Syntax aus dem oberen Beispiel ist erforderlich. Wie kommt das?

Gleichsam wird aus

Code:
void* operator new (std::size_t size, void* ptr) throw();

in der Anwendung nicht etwa

Code:
new <wert> <zeiger>;

sondern eines von diesen beiden:

Code:
operator new(<wert>, <zeiger>); // keine Ahnung, wie hier der Konstruktor zu wählen wäre new (<zeiger>) <Konstruktor>;

Praktisch. Aber woher!?