Surcharge C++ (opérateur et fonction)

C++ vous permet de spécifier plusieurs définitions pour une fonction nom ou un opérateur dans la même portée, ce qui est appelé surcharge de fonction et surcharge d'opérateur respectivement.

Une déclaration surchargée est une déclaration déclarée avec le même nom qu'une déclaration précédemment déclarée dans la même portée, sauf que les deux déclarations ont des arguments différents et une définition (implémentation) évidemment différente.

Lorsque vous appelez une fonction surchargée ou opérateur , le compilateur détermine la définition la plus appropriée à utiliser, en comparant les types d'arguments que vous avez utilisés pour appeler la fonction ou l'opérateur avec les types de paramètres spécifiés dans les définitions. Le processus de sélection de la fonction ou de l'opérateur surchargé le plus approprié est appelé résolution de surcharge .

Surcharge de fonctions en C++

Vous pouvez avoir plusieurs définitions pour le même nom de fonction dans la même étendue. La définition de la fonction doit différer l'une de l'autre par les types et/ou le nombre d'arguments dans la liste d'arguments. Vous ne pouvez pas surcharger les déclarations de fonction qui ne diffèrent que par le type de retour.

Voici l'exemple où la même fonction print() est utilisé pour imprimer différents types de données −

Démo en direct

#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é, il produit le résultat suivant −

Printing int: 5
Printing float: 500.263
Printing character: Hello C++

Surcharge des opérateurs en C++

Vous pouvez redéfinir ou surcharger la plupart des opérateurs intégrés disponibles en C++. Ainsi, un programmeur peut également utiliser des opérateurs avec des types définis par l'utilisateur.

Les opérateurs surchargés sont des fonctions avec des noms spéciaux :le mot-clé « opérateur » suivi du symbole de l'opérateur en cours de définition. Comme toute autre fonction, un opérateur surchargé a un type de retour et une liste de paramètres.

Box operator+(const Box&);

déclare l'opérateur d'addition qui peut être utilisé pour ajouter deux objets Box et renvoie 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. Dans le cas où nous définissons la fonction ci-dessus comme une fonction non membre d'une classe, nous devrions passer deux arguments pour chaque opérande comme suit -

Box operator+(const Box&, const Box&);

Voici l'exemple pour montrer le concept d'opérateur sur le chargement à l'aide d'une fonction membre. Ici un objet est passé en argument dont les propriétés seront accessibles à l'aide de cet objet, l'objet qui appellera cet opérateur est accessible à l'aide de this opérateur comme expliqué ci-dessous −

Démo en direct

#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;
      }
      
      // Overload + operator to add two Box objects.
      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;      // Length of a box
      double breadth;     // Breadth of a box
      double height;      // Height of a box
};

// Main function for the program
int main() {
   Box Box1;                // Declare Box1 of type Box
   Box Box2;                // Declare Box2 of type Box
   Box Box3;                // Declare Box3 of type Box
   double volume = 0.0;     // Store the volume of a box here
 
   // box 1 specification
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // box 2 specification
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // volume of box 1
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // volume of box 2
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;

   // Add two object as follows:
   Box3 = Box1 + Box2;

   // volume of box 3
   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/non surchargeables

Voici la liste des opérateurs qui peuvent être surchargés −

+	-	*	/	%	^
&	|	~	!	,	=
<	>	<=	>=	++	--
<	>>	==	!=	&&	||
+=	-=	/=	%=	^=	&=
|=	*=	<<=	>>=	[]	()
->	->*	nouveau	nouveau []	supprimer	supprimer []

Voici la liste des opérateurs, qui ne peuvent pas être surchargés −

::

.*

.

? :

Exemples de surcharge d'opérateur

Voici divers exemples de surcharge d'opérateurs pour vous aider à comprendre le concept.

Sr.No	Opérateurs et exemple
1	Surcharge d'opérateurs unaires
2	Surcharge d'opérateurs binaires
3	Surcharge des opérateurs relationnels
4	Surcharge des opérateurs d'entrée/sortie
5	++ et -- surcharge des opérateurs
6	Surcharge des opérateurs d'affectation
7	Appel de fonction () Surcharge d'opérateur
8	Surcharge d'opérateur d'abonnement []
9	Opérateur d'accès aux membres du groupe -> Surcharge