C++ Surcharge des opérateurs et surcharge des fonctions

C++ permet à une certaine [fonction] dans la même portéeFonctionetOpérateursde spécifier plusieurs définitions, appelées respectivementSurcharge de fonctionetSurcharge d'opérateur。

Une déclaration de surcharge est une déclaration qui a le même nom qu'une fonction ou méthode précédemment déclarée dans cette portée, mais leurs listes de paramètres et définitions (implémentations) sont différentes.

Lorsque vous appelez unefonction surchargéeouun opérateur surchargé, le compilateur décide quelle définition est la plus appropriée en comparant les types de paramètres que vous utilisez avec les types de paramètres dans la définition. Le processus de sélection de la fonction surchargée ou de l'opérateur surchargé le plus approprié est appeléRésolution de surcharge。

Surcharge de fonctions en C++

Dans la même portée, vous pouvez déclarer plusieurs fonctions ayant une fonctionnalité similaire et le même nom, mais ces fonctions de même nom doivent avoir des paramètres formels différents (faisant référence au nombre, au type ou à l'ordre des paramètres). Vous ne pouvez pas surcharger des fonctions en vous basant uniquement sur des types de retour différents.

Dans l'exemple suivant, les fonctions portant le même nomprint()sont utilisées pour afficher différents types de données :

Exemple

#include <iostream> using namespace std; class printData { public: void print(int i) { cout << "L'entier est :" << i << endl; } void print(double f) { cout << "Le nombre à virgule flottante est :" << f << endl; } void print(char c[]) { cout << "La chaîne est :" << c << endl; } }; int main(void) { printData pd; // Afficher un entier pd.print(5); // Afficher un nombre à virgule flottante pd.print(500.263); // Afficher une chaîne de caractères char c[] = "Hello C++"; pd.print(c); return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

整数为: 5
浮点数为: 500.263
字符串为: Hello C++

Surcharge des opérateurs en C++

Vous pouvez redéfinir ou surcharger la plupart des opérateurs intégrés de C++. De cette façon, vous pouvez utiliser des opérateurs avec des types personnalisés.

Les opérateurs surchargés sont des fonctions avec des noms spéciaux. Le nom de la fonction est composé du mot-clé `operator` suivi du symbole de l'opérateur à surcharger. Comme les autres fonctions, un opérateur surchargé a un type de retour et une liste de paramètres.

Box operator+(const Box&);

Déclarez l'opérateur d'addition pour additionner deux objets Box et renvoyer l'objet Box final. La plupart des opérateurs surchargés peuvent être définis comme des fonctions ordinaires non membres 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 passer 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érateurs à l'aide de fonctions membres. Ici, les objets sont passés comme arguments, et les propriétés de l'objet sont accessibles en utilisantthisl'opérateur, comme indiqué ci-dessous :

Exemple

#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; } // Surcharger l'opérateur + pour additionner deux objets 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; // Longueur double breadth; // Largeur double height; // Hauteur }; // La fonction principale du programme int main( ) { Box Box1; // Déclarer Box1 de type Box Box Box2; // Déclarer Box2 de type Box Box Box3; // Déclarer Box3 de type Box double volume = 0.0; // Stocker le volume dans cette variable // Détails de Box1 Box1.setLength(6.0); Box1.setBreadth(7.0); Box1.setHeight(5.0); // Détails de Box2 Box2.setLength(12.0); Box2.setBreadth(13.0); Box2.setHeight(10.0); // Volume de Box1 volume = Box1.getVolume(); cout << "Volume de Box1 : " << volume <<endl; // Volume de Box2 volume = Box2.getVolume(); cout << "Volume de Box2 : " << volume <<endl; // Additionner les deux objets pour obtenir Box3 Box3 = Box1 + Box2; // Volume de Box3 volume = Box3.getVolume(); cout << "Volume de Box3 : " << volume <<endl; return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400

Opérateurs surchargeables / Opérateurs non surchargeables

Voici une liste des opérateurs qui peuvent être surchargés :

Opérateurs arithmétiques binaires + (addition), - (soustraction), * (multiplication), / (division), % (modulo)
Opérateurs relationnels == (égal à), != (différent de), < (inférieur à), > (supérieur à), <= (inférieur ou égal à), >= (supérieur ou égal à)
Opérateurs logiques || (OU logique), && (ET logique), ! (NON logique)
Opérateur unaire + (positif), - (négatif), * (déréférencement), & (adresse de)
Opérateurs d'incrémentation et de décrémentation ++ (incrémentation), -- (décrémentation)
Opérateurs bit à bit | (OU bit à bit), & (ET bit à bit), ~ (NON bit à bit), ^ (OU exclusif bit à bit), << (décalage à gauche), >> (décalage à droite)
Opérateurs d'affectation =, +=, -=, *=, /= , % = , &=, |=, ^=, <<=, >>=
Allocation et libération de mémoire new, delete, new[ ] , delete[]
Autres opérateurs ()(appel de fonction),->(accès aux membres),,(virgule),[](indice)

Voici une liste d'opérateurs qui ne peuvent pas être surchargés :

  • .Opérateur d'accès aux membres
  • .*, ->*Opérateur d'accès au membre via pointeur
  • ::: opérateur de portée
  • sizeof: opérateur de longueur
  • ?:: opérateur conditionnel
  • #: symbole de prétraitement

Exemple de surcharge d'opérateur

Ce qui suit fournit divers exemples de surcharge d'opérateurs pour vous aider à mieux comprendre le concept de surcharge.

Numéro de sérieOpérateurs et exemples
1Surcharge d'opérateur unaire
2Surcharge de l'opérateur binaire
3Surcharge des opérateurs relationnels
4Surcharge des opérateurs d'entrée/sortie
5Surcharge des opérateurs ++ et --
6Surcharge de l'opérateur d'affectation
7Surcharge de l'opérateur d'appel de fonction ()
8Surcharge de l'opérateur d'indice []
9Surcharge de l'opérateur d'accès aux membres de classe ->
autres extensions