Antwort.

Funktionsüberladung – dies ist die Möglichkeit, mehrere Funktionen mit demselben Namen, aber unterschiedlichen Argumenten zu erstellen. Dies wird verwendet, um die Lesbarkeit zu erhöhen und ein intuitives Interface zu gewährleisten.

Operatorüberladung – die Möglichkeit, zu definieren, wie Standardoperatoren mit benutzerdefinierten Datentypen (Klassen oder Strukturen) arbeiten.

Einschränkungen der Operatorüberladung:

Nicht alle Operatoren können überladen werden (.:, .*, ::, sizeof, ?: usw.).
Der Operator muss entweder eine Mitgliedsfunktion oder eine befreundete Funktion sein.
Es ist nicht möglich, die Semantik zu überschreiben, um eine vollständig neue Syntax zu erstellen.

Beispiel für die Überladung des Operators "+":

class Vector2D {
public:
    float x, y;
    Vector2D(float _x, float _y): x(_x), y(_y) {}
    Vector2D operator+(const Vector2D& rhs) const {
        return Vector2D(x + rhs.x, y + rhs.y);
    }
};

Fangfrage.

Ist es in C++ erlaubt, den Kommaoperator (,) zu überladen, und wenn ja, wofür könnte dies verwendet werden?

Antwort:
Ja, der Kommaoperator kann für benutzerdefinierte Klassen überladen werden.
Allerdings sollte der Kommaoperator nur dann überladen werden, wenn es einen triftigen Grund dafür gibt, da dies den Leser des Codes verwirren und zu unerwarteten Folgen führen kann.

struct Logger {
    Logger& operator,(const std::string& msg) {
        std::cout << msg;
        return *this;
    }
};

Beispiele für tatsächliche Fehler aufgrund mangelnden Wissens über die Feinheiten des Themas.

Geschichte
Im Rahmen einer mathematischen Bibliothek wurde der Operator == für den Vergleich von Objekten überladen, aber der Operator < wurde nicht überladen. Dies führte zu Kompilierungsfehlern, als versucht wurde, STL-Container zu verwenden, die einen Vergleichsoperator erforderten, z. B. std::set, std::map.

Geschichte
Ein Entwickler überlud den Operator + für die Klasse Matrix, änderte jedoch anstelle der Rückgabe eines neuen Objekts immer den linken Operanden. Das Ergebnis waren unerwartete Seiteneffekte und eine Verletzung des Prinzips der "Reinheit" von Operationen.

Geschichte
Bei der Überladung einer Funktion mit unterschiedlichen Typen von Argumenten wurde der const-Qualifier nicht berücksichtigt:
void foo(SomeClass&);
void foo(const SomeClass&);
Dies führte zu Unklarheiten beim Aufruf der Funktion und zu Kompilierungsfehlern beim Übergeben von temporären Objekten.