Surcharge d’opérateur

  • Article

La operator mot clé déclare une fonction spécifiant ce que signifie l’opérateur-symbole lorsqu’elle est appliquée aux instances d’une classe. Cela donne à l'opérateur plusieurs significations ou le « surcharge ». Le compilateur fait la distinction entre les différentes significations d’un opérateur en examinant les types de ses opérandes.

Syntaxe

typeoperatoroperator-symbol(parameter-list)

Notes

Vous pouvez redéfinir la fonction de la plupart des opérateurs intégrés de manière globale ou classe par classe. Les opérateurs surchargés sont implémentés en tant que fonctions.

Le nom d’un opérateur surchargé est operatorx, où x est l’opérateur tel qu’il apparaît dans le tableau suivant. Par exemple, pour surcharger l’opérateur d’ajout, vous définissez une fonction appelée operator+. De même, pour surcharger l’opérateur addition/affectation, +=définissez une fonction appelée operator+=.

Opérateurs redéfinissables

Opérateur Nom Type
, Virgule Binaire
! NOT logique Unaire
!= Inégalité Binaire
% Modulo Binaire
%= Assignation de modulo Binaire
& ET au niveau du bit Binaire
& Adresse-de Unaire
&& ET logique Binaire
&= Assignation d'opération AND au niveau du bit Binaire
( ) Appel de fonction —
( ) Opérateur de conversion Unaire
* Multiplication Binaire
* Déréférencement du pointeur Unaire
*= Assignation de multiplication Binaire
+ Addition Binaire
+ Plus unaire Unaire
++ Incrémenter 1 Unaire
+= Assignation d'addition Binaire
- Soustraction Binaire
- Négation unaire Unaire
-- Décrémentation 1 Unaire
-= Assignation de soustraction Binaire
-> Sélection de membres Binaire
->* Sélection de pointeur de membre Binaire
/ Division Binaire
/= Assignation de division Binaire
< Inférieur(e) à Binaire
<< Décalage vers la gauche Binaire
<<= Assignation de décalage vers la gauche Binaire
<= Inférieur ou égal à Binaire
= Affectation Binaire
== Égalité Binaire
> Supérieur(e) à Binaire
>= Supérieur ou égal à Binaire
>> Décalage vers la droite Binaire
>>= Assignation de décalage vers la droite Binaire
[ ] Indice de tableau —
^ OR exclusive Binaire
^= Assignation OR exclusive Binaire
| Opération OR inclusive au niveau du bit Binaire
|= Assignation d'opération OR inclusive au niveau du bit Binaire
|| OU logique Binaire
~ Complément à 1 Unaire
delete Supprimer —
new Nouvelle —
opérateurs de conversion opérateurs de conversion Unaire

1 Deux versions des opérateurs d’incrément et de décrémentation unaire existent : préincrement et postincrement.

Pour plus d’informations, consultez Règles générales pour la surcharge des opérateurs. Les contraintes sur les différentes catégories d'opérateurs surchargés sont décrites dans les rubriques suivantes :

Les opérateurs indiqués dans le tableau suivant ne peuvent pas être surchargés. Le tableau inclut les symboles # de préprocesseur et ##.

Opérateurs non redéfinissables

Opérateur Nom
. Sélection de membres
.* Sélection de pointeur de membre
:: Résolution de portée
? : Conditions
# Préprocesseur convertir en type string
## Préprocesseur concaténer

Bien que les opérateurs surchargés soient généralement appelés implicitement par le compilateur quand ils sont trouvés dans le code, ils peuvent être invoqués explicitement de la même façon que n'importe quelle fonction membre ou non membre :

Point pt;
pt.operator+( 3 );  // Call addition operator to add 3 to pt.

Exemple

L’exemple suivant surcharge l’opérateur + pour ajouter deux nombres complexes et retourne le résultat.

// operator_overloading.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

struct Complex {
   Complex( double r, double i ) : re(r), im(i) {}
   Complex operator+( Complex &other );
   void Display( ) {   cout << re << ", " << im << endl; }
private:
   double re, im;
};

// Operator overloaded using a member function
Complex Complex::operator+( Complex &other ) {
   return Complex( re + other.re, im + other.im );
}

int main() {
   Complex a = Complex( 1.2, 3.4 );
   Complex b = Complex( 5.6, 7.8 );
   Complex c = Complex( 0.0, 0.0 );

   c = a + b;
   c.Display();
}

6.8, 11.2

Contenu de cette section

Voir aussi

Opérateurs intégrés, priorité et associativité C++
Mots clés