können Operatoren für Standarddatentypen wie unsigned int nicht überladen werden?
Ich bekomme nämlich bei so etwas einen Fehler:

bool operator< (unsigned int int1, unsigned int int2) {
// ...
}

können Operatoren für Standarddatentypen wie unsigned int nicht überladen werden?

Nein, das geht nicht. Dafür muss mindestens ein benutzerdefinierter Typ involviert sein.

Hallo,

können Operatoren für Standarddatentypen wie unsigned int nicht überladen werden?
Ich bekomme nämlich bei so etwas einen Fehler:

bool operator< (unsigned int int1, unsigned int int2) {
// ...
}

Das geht nicht und das ist auch gut so.

Vielen Dank
lg, freakC++

Warum ist das gut?

Weil Stroustrup gesagt hat, daß er das absichtlich verboten hat, um Mißbrauch vorzubeugen.
Ich finde es nicht gut.

Ich finde es nicht gut.

Gibt es bei dir Fälle, in denen du eine Überladung der BuiltIn-Operatoren benötigt hättest?

Ich finde es nicht schlecht, so wie es ist. Wenn man sich nicht einmal mehr auf die Operatoren der einfachen Typen verlassen kann, entsteht meiner Meinung nach schnell ziemliche Verwirrung. Besonders wenn man anderen Code bearbeitet und in irgendeinem entfernten Header mal eben die Semantik einer int -Addition neu implementiert wurde.

Davon abgesehen: Wie sollte man die Operatoren überhaupt implementieren, wenn man sie neu definiert? Auf die Standardversion kann man dann wahrscheinlich nicht mehr zugreifen. Also über Bitoperationen? Und wenn die auch überladen sind, über Assembler?

Zusammen mit der Tatsache, dass man sich sehr schnell benutzerdefinierte Typen mit eigener Semantik bauen kann, finde ich gut, dass die Operatoren für skalare Typen unverändert bleiben.

Ich kann mir außerdem gut vorstellen, daß es zur Firmenpolitik gehört, daß keine versehentlichen Interger-Überläufe geschehen dürfen. Mit der Erlaubnis, diese Operatoren zu überladen, könnte man das absichern.

Das wäre sicher nicht schlecht. Aber die skalaren Typen haben auch sonst einige Unsicherheiten, zum Beispiel die implizite Konvertierung. Oder die Vermischung von unsigned und signed , die auch darunter fällt.

Es scheint vielleicht umständlich, aber in Fällen, wo solche Dinge wirklich wichtig sind, wäre doch das Naheliegendste, die Typen über Klassen zu wrappen und eigene Semantiken zu implementieren...?

Es scheint vielleicht umständlich, aber in Fällen, wo solche Dinge wirklich wichtig sind, wäre doch das Naheliegendste, die Typen über Klassen zu wrappen und eigene Semantiken zu implementieren...?

Auch damit habe ich experimentiert. Aber ich hatte es nichtmal Ansatzweise geschafft, das durchzuhalten. Dauernd will die WinAPI dann doch Zeiger auf elementare Typen und so. Oder C++ selber mag bestimmte Typen, zum Beispiel als Arrayindex. Wird man dann schwach und macht

int Int::operator int()

weicht man sein Konzept wieder auf und kommt in Teufels Küche.

Was man tun könnte, ist nur für die "kritischen" Fälle – vor allem bei komplexeren Berechnungen, wo schnell Überläufe passieren – zu solchen Hilfsmitteln zu greifen. Bibliotheken wie Boost.Numeric/Conversion unterstützen einen ebenfalls im Kampf gegen solche Fehler.

Ich denke, Stroustrups Entscheid ist schon nicht ganz so daneben. Klar hätte es ein paar nette Vorteile, selbst zu überladen, aber im Vergleich zu den dadurch entstehenden Problemen scheinen die mir nicht sehr relevant. Ich will mir nicht vorstellen, wie sehr man beim Debugging verzweifeln kann, wenn einfache Anweisungen wie 3 + 5 nicht mehr nachvollziehbar sind...

Ich denke, Stroustrups Entscheid ist schon nicht ganz so daneben.

Denke ich auch.
Ich stelle mir nur mal vor, ich überlade den op+(int,int), damit er Überläufe assertet und inkludiere tollelib/tools/random.hpp, aua!
so eine überladung wäre auch irgendwie wie die redefinierung des globalen new() und müßte überall ziehen, oder? aber das wird nix, denn die ganzen anderen übersetzungseinheiten, wissen davon erstmal nichts. alles ganz komisch und ist wohl den aufwand nicht wert.

int operator+(int, int) { ... }

schreiben. Wie würden wir eigentlich den Funktionskörper zu schrieben haben ohne uns in Rekursion zu verlieren?

Nur so ein Gedanke nebenbei. Angenommen wir könnten z.B.

int operator+(int, int) { ... }

schreiben. Wie würden wir eigentlich den Funktionskörper zu schrieben haben ohne uns in Rekursion zu verlieren?

Auf Bitmanipulation? Inline Assembler?

Edit: Das ist eben das Problem:

drakon schrieb:

Auf Bitmanipulation?

Wenn die entsprechenden Operatoren auch überladen sind?

drakon schrieb:

Inline Assembler?

Nicht wirklich plattformunabhängig.

Auf Bitmanipulation?

und wenn die auch überladen werden?

Inline Assembler?

Was letztlich undefiniertes Verhalten bedeutet, denn die abstrakte Maschine für C++ kennt keinen Assembler. Halte ich daher für keinen günstigen Ausweg.