Surcharge d'opérateur
Le mot clé d' operator déclare spécifier de fonction qui operator-symbol signifie appliqué aux instances d'une classe.Cela donne à l'opérateur plusieurs signification, ou « la surcharge ».Le compilateur respecte les significations différentes d'un opérateur en examinant les types de ses opérandes.
type operator operator-symbol ( parameter-list )
Notes
vous pouvez redéfinir la fonction de la plupart des opérateurs prédéfinis globalement ou sur une base de 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'addition, vous devez définir une fonction appelée operator+.De même, pour surcharger l'ajout/opérateur d'assignation, +=, 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 |
& |
Opération de bits AND |
Binaire |
& |
adresse |
Unaire |
&& |
AND logique |
Binaire |
&= |
Opération de bits AND peut-être |
Binaire |
( ) |
Appel de fonction |
— |
( ) |
opérateur de cast |
Unaire |
* |
Multiplication |
Binaire |
* |
Déréférencement de pointeur |
Unaire |
*= |
Assignation de multiplication |
Binaire |
+ |
Addition |
Binaire |
+ |
unaire plus |
Unaire |
++ |
incrément 1 |
Unaire |
+= |
Assignation d'addition |
Binaire |
– |
Soustraction |
Binaire |
– |
Négation unaire |
Unaire |
–– |
Decrement 1 |
Unaire |
–= |
Assignation de soustraction |
Binaire |
–> |
Sélection de membres |
Binaire |
–>* |
sélection de pointeur vers membre |
Binaire |
/ |
Division |
Binaire |
/= |
Assignation de Division |
Binaire |
< |
Inférieur à |
Binaire |
<< |
Décalage vers la gauche |
Binaire |
<<= |
Assignation de décalage vers la gauche |
Binaire |
<= |
Inférieur ou égal à |
Binaire |
= |
Assignation |
Binaire |
== |
Égalité |
Binaire |
> |
Supérieur à |
Binaire |
>= |
Supérieur ou égal à |
Binaire |
>> |
Décalage vers la droite |
Binaire |
>>= |
Assignation de décalage vers la droite |
Binaire |
[ ] |
indice de tableau |
— |
^ |
OR exclusif |
Binaire |
^= |
OR exclusif peut-être |
Binaire |
| |
Opération OR inclusive au niveau du bit |
Binaire |
|= |
Inclusifs de bits OR peut-être |
Binaire |
|| |
OR logique |
Binaire |
~ |
Complément à 1 |
Unaire |
delete |
Delete |
— |
new |
New |
— |
conversion operators |
opérateurs de conversion |
Unaire |
1 Deux versions de l'incrément les opérateurs et de décrémentation unaires existe : preincrement et postincrement.
Consultez Règles générales de la surcharge d'opérateur pour plus d'informations.Les contraintes sur les différentes catégories d'opérateurs surchargés sont décrites dans les rubriques suivantes :
Les opérateurs affichés dans le tableau suivant ne peuvent pas être surchargés.Le tableau inclut les symboles # et ##de préprocesseur.
opérateurs de Nonredefinable
Operator |
Name |
. |
Sélection de membres |
.* |
sélection de pointeur vers membre |
:: |
Résolution de portée |
? : |
Conditionnel |
# |
Format de préprocesseur à la chaîne |
## |
le préprocesseur concatènent |
Bien que les opérateurs surchargés soient généralement appelés implicitement par le compilateur lorsqu'ils sont produits dans le code, ils peuvent être appelés explicitement la même façon que les fonction membre ou non - membre est appelé :
Point pt;
pt.operator+( 3 ); // Call addition operator to add 3 to pt.
Exemple
L'exemple suivant surcharge l'opérateur d' + 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();
}
Sortie
6.8, 11.2