Surcharge C ++ (opérateur et fonction)

C ++ vous permet de spécifier plus d'une définition pour un function nom ou un operator dans la même portée, qui s'appelle function overloading et operator overloading respectivement.

Une déclaration surchargée est une déclaration qui est 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 un surchargé function ou operator, le compilateur détermine la définition la plus appropriée à utiliser, en comparant les types d'argument 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éoverload resolution.

Surcharge de fonction en C ++

Vous pouvez avoir plusieurs définitions pour le même nom de fonction dans la même portée. La définition de la fonction doit différer les unes des autres 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 diffèrent uniquement par le type de retour.

Voici l'exemple où la même fonction print() est utilisé pour imprimer 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é, 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 adddeux 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 devrons 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 en surcharge à 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 viathis opérateur comme expliqué 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;
      }
      
      // 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	effacer []

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

::

. *

.

?:

Exemples de surcharge d'opérateur

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

Sr.Non	Opérateurs et exemple
1	Surcharge des opérateurs unaires
2	Surcharge des 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
sept	Appel de fonction () Surcharge de l'opérateur
8	Souscription [] Surcharge de l'opérateur
9	Opérateur d'accès aux membres de la classe -> Surcharge