Réponse.

Surcharge de fonctions — c'est la possibilité de créer plusieurs fonctions avec le même nom, mais des arguments différents. Cela est utilisé pour améliorer la lisibilité et garantir une interface intuitive.

Surcharge d'opérateurs — c'est la possibilité de définir comment les opérateurs standard fonctionnent avec des types de données utilisateur (classes ou structures).

Limitations de la surcharge d'opérateurs :

• Tous les opérateurs ne peuvent pas être surchargés (.:, .*, ::, sizeof, ?:, etc.).
• L'opérateur doit être soit une fonction membre, soit une fonction amie.
• Il n'est pas possible de redéfinir la sémantique pour créer une syntaxe totalement nouvelle.

Exemple de surcharge de l'opérateur "+" :

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

Question piégeuse.

Est-il permis en C++ de surcharger l'opérateur virgule (,) et si oui, à quoi cela pourrait-il servir ?

Réponse :
Oui, l'opérateur virgule peut être surchargé pour des classes utilisateur.
Cependant, il est conseillé de ne surcharger l'opérateur virgule que s'il y a un sens valable, car cela peut embrouiller celui qui lit le code et mener à des conséquences inattendues.

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

Exemples d'erreurs réelles dues à une méconnaissance des subtilités du sujet.

---

Histoire
Dans le cadre d'une bibliothèque mathématique, l'opérateur == avait été surchargé pour comparer des objets, mais l'opérateur < avait été oublié. Cela a conduit à des erreurs de compilation lors de l'utilisation de conteneurs STL nécessitant un opérateur de comparaison, par exemple std::set, std::map.

---

Histoire
Un développeur a surchargé l'opérateur + pour la classe Matrix, mais au lieu de retourner un nouvel objet, il modifiait toujours l'opérande gauche. Le résultat a entraîné des effets secondaires inattendus et une violation du principe de "pureté" des opérations.

---

Histoire
Lors de la surcharge d'une fonction avec différents types d'arguments, le modificateur const n'a pas été prévu :

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

Cela a conduit à une ambiguïté dans l'appel de fonction et à des erreurs de compilation lors du passage d'objets temporaires.