Warum sollte es Fluch sein?

weil es evtl. schwerer zu verstehen ist, bzw. falsch überladen missverständnisse auftreten können? man muß schon relativ genau wissen, welcher operator auf welche klasse angewendet wird, stelle mir das schon bischen schwerer vor

weil es evtl. schwerer zu verstehen ist, bzw. falsch überladen missverständnisse auftreten können? man muß schon relativ genau wissen, welcher operator auf welche klasse angewendet wird, stelle mir das schon bischen schwerer vor

Und Funktionen kann man nicht falsch benennen?

Nexus schrieb:

Warum sollte es Fluch sein?

weil es evtl. schwerer zu verstehen ist, bzw. falsch überladen missverständnisse auftreten können? man muß schon relativ genau wissen, welcher operator auf welche klasse angewendet wird, stelle mir das schon bischen schwerer vor

Das muss man bei normalen Funktionen auch wissen. Außerdem überlädt man Operatoren ja nicht irgendwie. Es ist selbstverständlich, dass man mit operator [] auf die Elemente eines std::vector zugreifen kann und dass Zeigerersetzer wie ein Iterator oder std::auto_ptr über * und -> verfügen.
Bei sowas wie boost.spirit muss man natürlich genau wissen, wofür welcher Operator da ist. Das lohnt sich aber, weil die Lesbarkeit deutlich verbessert wird.

Bei sowas wie boost.spirit muss man natürlich genau wissen, wofür welcher Operator da ist. Das lohnt sich aber, weil die Lesbarkeit deutlich verbessert wird.

Boost.Spirit halte ich für sehr grenzwertig. Sicher mag es noch witzig sein, es ähnlich zur EBNF notieren zu können, wenn du dann aber noch Actions reinpflanzt, verbunden mit Boost.Bind, dann kann ich aber nicht mehr wirklich viel von der Lesbarkeit erkennen

Aber Operatorüberladung ist definitiv ein Segen. Ein einfaches aber mächtiges Konzept. Und wie so vieles in C++ ist hier halt wieder die Verantwortung beim Programmierer. Wenn der Programmierer zu dumm ist für die Operatorüberladung, dann sei es halt so. Es ist jedem frei gestellt eine Bibliothek zu nutzen oder nicht. Und in Firmen kann man Richtlinien und Regeln einführen.

Grüssli

weil es evtl. schwerer zu verstehen ist, bzw. falsch überladen missverständnisse auftreten können? man muß schon relativ genau wissen, welcher operator auf welche klasse angewendet wird, stelle mir das schon bischen schwerer vor

schwerer zu verstehen: nein, wenn man nichts unerwartetes macht. Zahlenartige Klassen, Pointerartige Klassen, Streamklassen wären ohne Operatorüberladung nicht halb so intuitiv zu handhaben, in templates müsste man ständig zwischen eingebauten und userdefinierten Zahlenklassen etc. unterscheiden.

falsch überladen: siehe oben bereits genanntes gleiches Problem bei Funktionsbenamsung. Wer den Code Obfuscation Award gewinnen will kann das auch ohne Operatorüberladung.

Wies schon in meinem Artikel steht: do as the ints do, und alles wird gut

Dravere schrieb:

Und wie so vieles in C++ ist hier halt wieder die Verantwortung beim Programmierer. Wenn der Programmierer zu dumm ist für die Operatorüberladung, dann sei es halt so.

Dem kann ich nur zustimmen.

Allein schon dass man Sachen schreiben kann wie

some_functor = (boost::bind(yadayadayadayada) == 123);

Und wie schon mehrfach (sinngemäss) gesagt wurde: es zwingt einen ja keiner Operatoren zu überladen.

Andrerseits denke ich auch, dass jedes zusätzliche Feature einer Sprache, diese schwerer verständlich/überblickbar macht. Wenn ich dran denke wie es da Anfängern geht, die frisch aus der Schule/Uni/FH/... kommen, und in ein "modernes" C++ Projekt geworfen werden ... hmja.

Aber wie gesagt: eher Segen als Fluch.

Und wie schon mehrfach (sinngemäss) gesagt wurde: es zwingt einen ja keiner Operatoren zu überladen.

Na dann erklär mal wie folgender Code richtig funktionieren kann, wenn keiner (auch std::string und std::vector nicht) gezwungen würde Operatoren zu überladen?

class KomplexerToast{};
class DerUeberLaden
{
private:
	int i;
	std::string text;
	std::vector<int> vec;
	KomplexerToast t;
};

int main()
{
	DerUeberLaden megaShop;
	DerUeberLaden hyperStore;
	megaShop = hyperStore;
}

Operatorüberladung ist wie vieles in C++ einfach notwendigerweise so gewachsen.

Dravere schrieb:

Aber Operatorüberladung ist definitiv ein Segen. Ein einfaches aber mächtiges Konzept. Und wie so vieles in C++ ist hier halt wieder die Verantwortung beim Programmierer. Wenn der Programmierer zu dumm ist für die Operatorüberladung, dann sei es halt so.

Und du bist natürlich intuitiv von selber drauf gekommen, wie man den assignment operator richtig überläd, ohne jemals von Copy-and-swap und Co gehört zu haben.

Und du bist natürlich intuitiv von selber drauf gekommen, wie man den assignment operator richtig überläd, ohne jemals von Copy-and-swap und Co gehört zu haben.

Ist er bestimmt nicht. Bist du intuitiv drauf gekommen wie die Syntax einer while-Schleife aussieht, wie man Templates benutzt, eine Klasse von einer anderen ableitet, .......... ? Sicher nicht..
Operatorüberladung ist wie vieles andere auch ein Sprachbestandteil von C++, den man erstmal lernen will. Wie bei jedem anderen Sprachmittel auch kann man es schnell syntaktisch richtig machen, weil das nun wirklich nicht schwer ist, kann dann aber noch einiges mehr dazulernen um es auch semantisch richtig zu machen, exceptionsicher, leicht lesbar, erweiterbar. Das ist alles kein großes Hexenwerk und nicht schwerer als andere Dinge auch in C++.
Ich denke, das einzige was einem an der Operatorüberladung wirklich Kopfzerbrechen bereiten könnte ist, dass es ein weiteres feature ist, von denen C++ eh schon so viele hat, und dass damit die Kombinationsmöglichkeiten, die man im Hinterkopf haben sollte noch mehr werden. Das macht den Umfang der möglichen Idiome um einiges größer als vielleicht in anderen Sprachen, aber auch das ist eher ein Segen für die, die immer auf der Suche nach dem richtigen und besseren Werkzeug sind, als es ein Fluch für die Denkfaulen ist

Und du bist natürlich intuitiv von selber drauf gekommen, wie man den assignment operator richtig überläd, ohne jemals von Copy-and-swap und Co gehört zu haben.

Da glaub ich besteht ein kleines Misverständnis wie "korrekt überladen" gemeint war.
Copy & Swap ist ein Idiom, mit dem man mit sehr wenig Aufwand einen exceptionsicheren Assigment-Operator bekommt. Das ist schön - war aber nicht so gemeint. Gemeint war, dass die Operatorüberladung Sinn ergeben soll. Würdest du eine Überladung von "operator +=(size_t)" verstehen, die eigentlich "operator[](size_t)" sein hätte sollen? Ich denke nicht.

nadann schrieb:

Dravere schrieb:

Aber Operatorüberladung ist definitiv ein Segen. Ein einfaches aber mächtiges Konzept. Und wie so vieles in C++ ist hier halt wieder die Verantwortung beim Programmierer. Wenn der Programmierer zu dumm ist für die Operatorüberladung, dann sei es halt so.

Und du bist natürlich intuitiv von selber drauf gekommen, wie man den assignment operator richtig überläd, ohne jemals von Copy-and-swap und Co gehört zu haben.

Du bist natürlich intuitiv von selber drauf gekommmen, wie man in einer Programmiersprache eine Funktion zum kopieren eines Objektes schreibt, ohne jemals von Copy-and-swap und Co gehört zu haben.

Wer hatte das letztens schon wieder so schön geschrieben?
"Ein Operator ist nichts anderes als eine Funktion mit syntactic sugar."

Grüssli

...

Nu wird's aber ein wenig zu trollig. Ich lösche Trollpostings einfach raus, auch wenn dadurch der Gesprächszusammenhang zerstört wird. Schon passiert.

nadann schrieb:

...

Nu wird's aber ein wenig zu trollig. Ich lösche Trollpostings einfach raus, auch wenn dadurch der Gesprächszusammenhang zerstört wird.

Oh, neee! Spielverderber :p

Jetzt wollte ich gerade diesen Code noch reinschreiben:

struct Test
{
    operator void const*() const
    {
        return 0;
    }
};

typedef void const* (Test::*MemPtr)() const;

int main()
{
    MemPtr ptr = &Test::operator void const*;

    return 0;
}

In welchem Zusammenhang sage ich jetzt aber halt nicht mehr

Grüssli