Réponse.

La surcharge d'opérateurs est la possibilité de définir un comportement utilisateur pour les opérateurs standards (par exemple, +, -, *, ==) pour vos propres classes. Cela aide à écrire un code expressif et lisible lors du travail avec des types utilisateurs (par exemple, vecteur, matrice).

Historique de la question

Le mécanisme de surcharge d'opérateurs a été introduit dans C++ pour soutenir un syntaxe intuitive lors du travail avec des objets (par exemple, addition des nombres complexes, travail avec des itérateurs) tout comme cela se fait avec des types de base.

Problème

Sans la surcharge d'opérateurs, de nombreuses opérations ressembleraient à des fonctions ordinaires (add(a, b)), ce qui complique la lecture du code et en réduit l'expressivité. Mais une utilisation excessive ou incorrecte entraîne de la confusion et des erreurs.

Solution

En C++, vous pouvez surcharger la plupart des opérateurs en déclarant des fonctions membres ou des fonctions amies appropriées pour définir la logique de nouvelles opérations.

Exemple de code :

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

Caractéristiques clés :

Augmente la lisibilité du code et rend les types utilisateurs "natifs"
Nécessite un strict respect de la sémantique des opérations
Tous les opérateurs ne sont pas autorisés à être surchargés

Questions pièges.

Peut-on surcharger l'opérateur . (point) et :: (deux-points)?

Non, des opérateurs comme . (point), ::, sizeof, ?: et d'autres ne peuvent pas être surchargés selon la norme de la langue.

Le comportement des opérateurs surchargés doit-il entièrement correspondre à leur sémantique standard?

Pas nécessairement, mais c'est recommandé (par exemple, en surchargeant ==, faire une comparaison d'équivalence).

Que se passe-t-il en cas de passage incorrect d'un objet par valeur dans un opérateur surchargé?

Cela peut entraîner des copies ou des déréférencements inutiles, ce qui ralentit le programme ou entraîne une erreur. Il est préférable de passer une référence constante (const T&).

Exemple de code :

Vector2D operator+(Vector2D rhs) const; // inefficace, l'objet est copié

Erreurs typiques et anti-modèles

Surcharge d'opérateurs avec une sémantique inattendue/illogique
Surcharge excessive uniquement pour la syntaxe, et non pour le sens
Utilisation de l'opérateur = non pour la copie
Surcharge de && ou || avec des effets secondaires

Exemple de la vie réelle

Cas négatif

Dans la classe DataFrame, l'opérateur * a été surchargé pour le produit scalaire avec un effet secondaire (modification de l'objet).

Avantages :

Code concis

Inconvénients :

Comportement inattendu
Difficulté de débogage

Cas positif

Dans la classe des nombres complexes, les +, -, == ont été surchargés avec une logique mathématique habituelle, sans modification des objets d'origine.