Antwoord.

Functie-overloading is de mogelijkheid om verschillende functies met dezelfde naam maar verschillende argumenten te maken. Dit wordt gebruikt om de leesbaarheid te vergroten en een intuïtieve interface te bieden.

Operator-overloading is de mogelijkheid om te definiëren hoe standaardoperatoren werken met gebruikersgegevens (klassen of structuren).

Beperkingen van operator-overloading:

• Niet alle operatoren kunnen worden overbelast (.:, .*, ::, sizeof, ?:, enz.).
• De operator moet ofwel een lidfunctie zijn of een vriendfunctie.
• Het is niet toegestaan de semantiek te overschrijven om volledig nieuwe syntaxis te creëren.

Voorbeeld van het overladen van de operator "+":

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);
    }
};

Misleidende vraag.

Is het toegestaan om de komma-operator (,) in C++ te overbelasten en zo ja, waarvoor kan dit worden gebruikt?

Antwoord:
Ja, de komma-operator kan worden overbelast voor gebruikersklassen.
Echter, de komma-operator mag alleen worden overbelast als daar een goede reden voor is, omdat dit de lezer van de code kan verwarren en tot onverwachte gevolgen kan leiden.

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

Voorbeelden van echte fouten door onwetendheid over de nuances van het onderwerp.

---

Verhaal
In het kader van een wiskundige bibliotheek werd de operator == overbelast voor het vergelijken van objecten, maar de operator < werd vergeten te overbelasten. Dit leidde tot compilatiefouten bij het proberen te gebruiken van STL-containers die een vergelijkingsoperator vereisen, zoals std::set, std::map.

---

Verhaal
Een ontwikkelaar overloadde de operator + voor de klasse Matrix, maar in plaats van een nieuw object te retourneren, wijzigde hij altijd de linkeroperand. Dit resulteerde in onverwachte bijeffecten en schending van het principe van "zuiverheid" van bewerkingen.

---

Verhaal
Bij het overbelasten van een functie met verschillende types argumenten werd de const-kwalificator niet in aanmerking genomen:

void foo(SomeClass&);
void foo(const SomeClass&);

Dit leidde tot ambiguïteit bij het aanroepen van de functie en compilatiefouten bij het doorgeven van tijdelijke objecten.