Opérateurs C++ surchargés et fonctions surchargées
C++ permet de spécifier plusieurs définitions pour une certaine fonction et opérateur dans la même portée, respectivement appelées surcharge de fonction et surcharges des opérateurs .
Une déclaration surchargée est une déclaration portant le même nom qu'une fonction ou une méthode qui a été précédemment déclarée dans cette portée, mais leur liste de paramètres et leur définition (implémentation) sont différentes.
Lorsque vous appelez une fonction surchargée ou un opérateur surchargé, le compilateur compare les types de paramètres que vous utilisez avec les types de paramètres dans la définition, décidez d'utiliser le. définition la plus appropriée. Le processus de sélection de la fonction surchargée ou de l'opérateur surchargé le plus approprié est appelé décision de surcharge.
Surcharge de fonctions en C++
Dans une même portée, vous pouvez déclarer plusieurs fonctions de même nom avec des fonctions similaires, mais les paramètres formels de ces fonctions de même nom (faisant référence au numéro, au type ou ordre des paramètres) doivent être différents. Vous ne pouvez pas surcharger une fonction simplement en différant dans le type de retour.
Dans l'exemple suivant, la fonction du même nom print() est utilisée pour générer différents types de données :
#include <iostream> using namespace std; class printData { public: void print(int i) { cout << "Printing int: " << i << endl; } void print(double f) { cout << "Printing float: " << f << endl; } void print(char* c) { cout << "Printing character: " << c << endl; } }; int main(void) { printData pd; // Call print to print integer pd.print(5); // Call print to print float pd.print(500.263); // Call print to print character pd.print("Hello C++"); return 0; }
Lorsque le code ci-dessus est compilé et exécuté, cela produira les résultats suivants :
Printing int: 5 Printing float: 500.263 Printing character: Hello C++
Surcharge d'opérateurs en C++
Vous pouvez redéfinir ou surcharger la plupart des opérateurs intégrés de C++. Cela vous permet d'utiliser des types d'opérateurs personnalisés.
Un opérateur surchargé est une fonction avec un nom spécial. Le nom de la fonction est composé du mot-clé opérateur et du symbole de l'opérateur à surcharger. Comme les autres fonctions, les opérateurs surchargés ont un type de retour et une liste de paramètres.
Box operator+(const Box&);
Déclare que l'opérateur d'addition est utilisé pour ajouter deux objets Box et renvoyer l'objet Box final. La plupart des opérateurs surchargés peuvent être définis comme des fonctions non membres ordinaires ou comme des fonctions membres de classe. Si nous définissons la fonction ci-dessus comme une fonction non membre de la classe, nous devons alors transmettre deux paramètres pour chaque opération, comme indiqué ci-dessous :
Box operator+(const Box&, const Box&);
L'exemple suivant démontre le concept de surcharge d'opérateur à l'aide de fonctions membres . Ici, l'objet est passé en paramètre et les propriétés de l'objet sont accessibles à l'aide de l'opérateur this comme indiqué ci-dessous :
#include <iostream> using namespace std; class Box { public: double getVolume(void) { return length * breadth * height; } void setLength( double len ) { length = len; } void setBreadth( double bre ) { breadth = bre; } void setHeight( double hei ) { height = hei; } // 重载 + 运算符,用于把两个 Box 对象相加 Box operator+(const Box& b) { Box box; box.length = this->length + b.length; box.breadth = this->breadth + b.breadth; box.height = this->height + b.height; return box; } private: double length; // 长度 double breadth; // 宽度 double height; // 高度 }; // 程序的主函数 int main( ) { Box Box1; // 声明 Box1,类型为 Box Box Box2; // 声明 Box2,类型为 Box Box Box3; // 声明 Box3,类型为 Box double volume = 0.0; // 把体积存储在该变量中 // Box1 详述 Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0); // Box2 详述 Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0); // Box1 的体积 volume = Box1.getVolume(); cout << "Volume of Box1 : " << volume <<endl; // Box2 的体积 volume = Box2.getVolume(); cout << "Volume of Box2 : " << volume <<endl; // 把两个对象相加,得到 Box3 Box3 = Box1 + Box2; // Box3 的体积 volume = Box3.getVolume(); cout << "Volume of Box3 : " << volume <<endl; return 0; }
Lorsque le code ci-dessus est compilé et exécuté, il produit le Résultat suivant :
Volume of Box1 : 210 Volume of Box2 : 1560 Volume of Box3 : 5400
Opérateurs surchargeables/Opérateurs non surchargeables
Voici la liste des opérateurs surchargeables :
+ | - | * | / | % | ^ |
& | | | ~ | ! | , | = |
< | > | <= | >= | ++ | -- |
<< | >> | == | != | && | || |
+= | -= | /= | %= | ^= | &= |
|= | *= | <<= | >>= | [] | () |
-> | ->* | new | new [] | delete | delete [] |
Voici la liste des opérateurs non surchargeables d'opérateurs :
:: | .* | . | ?: |
Exemples de surcharge d'opérateur
Ce qui suit fournit des exemples de diverses surcharges d'opérateur pour vous aider à mieux comprendre le concept de surcharge.
序号 | 运算符和实例 |
---|---|
1 | 一元运算符重载 |
2 | 二元运算符重载 |
3 | 关系运算符重载 |
4 | 输入/输出运算符重载 |
5 | ++ 和 -- 运算符重载 |
6 | 赋值运算符重载 |
7 | 函数调用运算符 () 重载 |
8 | 下标运算符 [] 重载 |
9 | 类成员访问运算符 -> 重载 |