C++ Surcharge de l'opérateur et de la fonction

C++ Surcharge de la fonction

Dans le même domaine d'application, il est possible de déclarer plusieurs fonctions nommées de manière identique qui jouent un rôle similaire, mais les paramètres formels (c'est-à-dire le nombre, le type ou l'ordre) de ces fonctions homonymes doivent être différents. Vous ne pouvez pas surcharger une fonction uniquement en différenciant leur type de retour.

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

#include <iostream>
using namespace std;
　
class printData
{
　　　public:
　　　　　　void print(int i)
　　　　　　　　cout << "Les nombres entiers sont : " << i << endl;
　　　　　　}
　
　　　　　　void print(double f)
　　　　　　　　cout << "Les nombres à virgule flottante sont : " << f << endl;
　　　　　　}
　
　　　　　　void print(char c[])
　　　　　　　　cout << "La chaîne est : " << c << endl;
　　　　　　}
};
　
int main(void)
{
　　　printData pd;
　
　　　//　Sortie du nombre entier
　　　pd.print(5);
　　　//　Sortie du nombre à virgule flottante
　　　pd.print(500.263);
　　　//　Sortie de la chaîne
　　　char c[] = "Hello C++";
　　　pd.print(c);
　
　　　return 0;
}

Lorsque le code suivant est compilé et exécuté, il produit le résultat suivant :

Les nombres entiers sont :　5
Les nombres à virgule flottante sont :　500.263
La chaîne de caractères est : Hello C++

C++ de surcharge des opérateurs

Vous pouvez redéfinir ou surcharger la plupart des opérateurs C++ opérateurs intégrés. De cette manière, vous pouvez utiliser des opérateurs personnalisés pour des types personnalisés.

Les opérateurs surchargés sont des fonctions portant un nom spécial, le nom de la fonction est composé du mot-clé operator suivi de l'opérateur à surcharger. Comme d'autres fonctions, les opérateurs surchargés ont un type de retour et une liste de paramètres.

Box operator+(const Boîte&);

Déclaration de l'opérateur d'addition pour ajouter deux objets Boîte et retourner l'objet Boîte final. La plupart des opérateurs surchargés peuvent être définis en tant que fonctions membres normales ou en tant que fonctions membres de la classe. Si nous définissons la fonction ci-dessus en tant que fonction membre non membre de la classe, nous devons passer deux paramètres à chaque opération, comme suit :

Box operator+(const Boîte&, const Boîte&);

L'exemple suivant utilise les fonctions membres pour démontrer le concept de surcharge d'opérateurs. Ici, l'objet est passé en tant que paramètre, et les attributs de l'objet sont utilisés this opérateurs pour accéder, comme suit :

#include <iostream>
using namespace std;
　
class Boîte
{
　　　public:
　
　　　　　　double getVolume(void)
　　　　　　{
　　　　　　　　　retourner longueur　*　largeur　*　hauteur;
　　　　　　}
　　　　　　void setLongueur(double len)
　　　　　　{
　　　　　　　　　　longueur = len;
　　　　　　}
　
　　　　　　void setLargeur(double bre)
　　　　　　{
　　　　　　　　　　largeur = bre;
　　　　　　}
　
　　　　　　void setHeight(double hei)
　　　　　　{
　　　　　　　　　　height = hei;
　　　　　　}
　　　　　　//　Surcharge　+　Opérateur, utilisé 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éclaration de Box1，Type de Box
　　　Box Box2;　　　　　　　　　　　　　　　　//　Déclaration de Box2，Type de Box
　　　Box Box3;　　　　　　　　　　　　　　　　//　Déclaration de Box3，Type de Box
　　　double volume = 0.0;　　　　　//　Stocker la volume dans cette variable
　
　　　//　Box1　Détails
　　　Box1.setLength(6.0);　
　　　Box1.setBreadth(7.0);　
　　　Box1.setHeight(5.0);
　
　　　//　Box2　Détails
　　　Box2.setLength(12.0);　
　　　Box2.setBreadth(13.0);　
　　　Box2.setHeight(10.0);
　
　　　//　Box1　Le volume
　　　volume = Box1.getVolume();
　　　cout << "Box1Le volume : " << volume << endl;
　
　　　//　Box2　Le volume
　　　volume = Box2.getVolume();
　　　cout << "Box2Le volume : " << volume << endl;
　
　　　//　Ajouter deux objets, obtenir Box3
　　　Box3　= Box1　+　Box2;
　
　　　//　Box3　Le volume
　　　volume = Box3.getVolume();
　　　cout << "Box3Le volume : " << volume << endl;
　
　　　return 0;
}

Lorsque le code suivant est compilé et exécuté, il produit le résultat suivant :

Box1Le volume :　210
Box2Le volume :　1560
Box3Le volume :　5400

Opérateurs redéfinissables/Opérateurs non redéfinissables

Voici la liste des opérateurs redéfinissables :

Voici la liste des opérateurs non redéfinissables :

• . : Opérateur d'accès aux membres

• .*, ->*: : Opérateur d'accès aux pointeurs de membres

• :: : Opérateur de domaine

• sizeof : Opérateur de longueur

• ? : Opérateur conditionnel

• # : Symbole de prétraitement

Exemples de surcharge d'opérateurs

Des exemples de surcharge d'opérateurs variés sont fournis ci-dessous pour vous aider à mieux comprendre le concept de surcharge.