Règles générales de surcharge d'opérateur

Les règles suivantes limitent le mode d'implémentation des opérateurs surchargés. Toutefois, ils ne s’appliquent pas aux opérateurs nouveaux et supprimés , qui sont couverts séparément.

• Vous ne pouvez pas définir de nouveaux opérateurs, tels que ..

• Vous ne pouvez pas redéfinir la signification d'opérateurs lorsqu'ils sont appliqués à des types de données intégrés.

• Les opérateurs surchargés doivent être soit une fonction de membre de classe non statique, soit une fonction globale. Une fonction globale qui nécessite un accès à des membres de classe privés ou protégés doit être déclarée comme amie de cette classe. Une fonction globale doit prendre au moins un argument qui est de type classe ou énuméré ou qui est une référence à un type énuméré ou classe. Par exemple :

  // rules_for_operator_overloading.cpp
  class Point
  {
  public:
      Point operator<( Point & );  // Declare a member operator
                                   //  overload.
      // Declare addition operators.
      friend Point operator+( Point&, int );
      friend Point operator+( int, Point& );
  };
  
  int main()
  {
  }
  

  L'exemple de code précédent déclare l'opérateur Inférieur à comme fonction membre ; toutefois, les opérateurs d'addition sont déclarés comme fonctions globales qui ont un accès ami. Notez que plusieurs implémentations peuvent être fournies pour un opérateur donné. Dans le cas de l'opérateur d'addition précédent, les deux implémentations sont fournies pour faciliter la commutativité. Il est tout aussi probable que les opérateurs qui ajoutent un Point à un Point, int à un Point, et ainsi de suite, peuvent être implémentés.

• Les opérateurs obéissent aux règles de priorité, de regroupement et de nombre d'opérandes dictées par leur utilisation classique avec les types intégrés. Par conséquent, il n’existe aucun moyen d’exprimer le concept « ajouter 2 et 3 à un objet de type Point», s’attendant à ce que 2 soit ajouté à la coordonnée x et 3 à ajouter à la coordonnée y .

• Les opérateurs unaires déclarés comme fonctions membres n’acceptent pas d’argument ; s’ils sont déclarés comme fonctions globales, ils en prennent un.

• Les opérateurs binaires déclarés comme fonctions membres acceptent un argument ; s’ils sont déclarés comme fonctions globales, ils en prennent deux.

• Si un opérateur peut être utilisé en tant qu’opérateur unaire ou binaire (&, , +*et -), vous pouvez surcharger chaque utilisation séparément.

• Les opérateurs surchargés ne peuvent pas avoir d’arguments par défaut.

• Tous les opérateurs surchargés, à l’exception de l’affectation (operator=) sont hérités par des classes dérivées.

• Le premier argument pour les opérateurs surchargés déclarés comme fonctions membres est toujours le type de classe de l’objet pour lequel l’opérateur est appelé (la classe dans laquelle l’opérateur est déclaré ou une classe dérivée de cette classe). Aucune conversion n'est fournie pour le premier argument.

Notez que la signification de n'importe quel opérateur peut être modifiée complètement. Cela inclut la signification des opérateurs d’adresse (&), d’affectation (=) et d’appel de fonction. En outre, les identités sur lesquelles on peut se reposer pour les types intégrés peuvent être modifiées à l'aide de la surcharge d'opérateur. Par exemple, les quatre instructions suivantes sont généralement équivalentes une fois leur évaluation terminée :

var = var + 1;
var += 1;
var++;
++var;

On ne peut pas se reposer sur cette identité pour les types de classe qui surchargent des opérateurs. De plus, certaines des exigences implicites dans l’utilisation de ces opérateurs pour les types de base sont allégées pour les opérateurs surchargés. Par exemple, l’opérateur d’addition/affectation, +=exige que l’opérande gauche soit une valeur l lorsqu’elle est appliquée aux types de base ; il n’existe aucune exigence de ce type lorsque l’opérateur est surchargé.

Remarque

Pour des raisons de cohérence, il est souvent préférable de suivre le modèle des types intégrés lors de la définition des opérateurs surchargés. Si la sémantique d'un opérateur surchargé diffère sensiblement de sa signification dans d'autres contextes, il peut être plus perturbant qu'utile.

Voir aussi

Surcharge d'opérateur