Surcharge des opérateurs

Surcharge des opérateurs

Comme la plupart des langages, le C++ fournit un ensemble d’opérateurs pour manipuler ses types intégrés (int, float, char, etc.). Vous savez déjà, par exemple, que x+y*z se traduit par « multiplier y et z puis ajouter le résultat à x ».

Si vous créez vos propres types de données, vous devrez aussi créer les opérateurs associés si les opérateurs fournis par défaut par le compilateur ne conviennent pas.

Par exemple, nous allons surcharger l’opérateur + pour être en mesure « d’additionner » deux dates simplement.

Code 4.9 : surcharge de l’opérateur + (fichier en-tête Date.h)

#include<iostream>      //Pour les entrées/sorties    
using namespace std;    
     
class Date    
{    
private:    
   int jour, mois, annee;    
public:    
   Date(int,int,int);          //Constructeur par défaut    
   ~Date();                    //Destructeur    
   void DefinirDate(int j,int m,int a)    
     { jour=j; mois=m; annee=a; }    
   void LireDate() const     
     { cout<<jour<<" "<<mois<<" "<<annee<<endl; }    
   int LireJour() const { return jour; }    
   int LireMois() const { return mois; }    
   int LireAnnee() const { return annee; }    
   Date operator+ (const Date &);    
}; 

Code 4.10 : surcharge de l’opérateur + (fichier source Date.cpp)

#include"Date.h"   //Inclusion de la déclaration de Date    

/****Définition du constructeur****/    
Date::Date(int j,int m,int a)    
{ jour=j; mois=m; annee=a; }    

/****Définition du destructeur****/    
Date::~Date() { }    

/****Définition de l’opérateur +****/    
Date Date::operator +  (const Date &source)     
{     
   int j, m, a;     
   j=jour + source.LireJour();     
   m=mois + source.LireMois();     
   a=annee + source.LireAnnee();     
   if(j>30) {     
      j-=30;     
      m+=1;     
    }     
   if(m>12) {     
      m-=12;     
      a+=1;     
    }     
   return Date(j,m,a);     
}     

int main()    
{    
   cout << "Nous créons l’objet Date_initiale= 1 1 2009 ";    
   Date Date_initiale(1,1,2009);    
   cout << "nNous lui ajoutons 30 jours et 6 mois via l’objet Duree 30 6 0" << endl;    
   Date Duree(30,6,0);    
   //on ajoute la durée à la date initiale :    
   Date Date_finale=Date_initiale + Duree ;    
   cout << "Nous obtenons la nouvelle date: ";    
   Date_finale.LireDate();    
}  

Exemple d’exécution de ce programme :

Nous créons l’objet Date_initiale= 1 1 2009    
Nous lui ajoutons 30 jours et 6 mois via l’objet Duree 30 6 0    
Nous obtenons la nouvelle date: 1 8 2009  

Pour ne pas compliquer notre exemple, nous avons considéré une version simplifiée de l’année constituée de 12 mois de 30 jours.

La surcharge s’obtient en déclarant une fonction opérateur nommée operator(fonction opérateur)", suivie du caractère représentant l’opérateur lui-même (operator+ dans notre exemple).

En fait, la syntaxe :

Date Date_finale=Date_initiale + Duree ;  

est la version abrégée de :

Date Date_finale=Date_initiale.operator+(Duree) ; 

C’est dans la définition de cette fonction que sont fournis tous les détails des opérations à effectuer sur chaque membre de l’objet.

Le tableau 4.1 donne la liste des opérateurs que vous pouvez redéfinir de cette façon.

Tableau 4.1 : liste des opérateurs pouvant être redéfinis

+	-	*	/	%	^	&
⎢	˜	!	=	<	>	+=
<<	>>	>>=	<<=	==	!=	<=
>=	&&	⎢⎥	++	--	->*	,
->	[ ]	()	new	new[ ]	delete	delete[ ]

À savoir

Vous ne pouvez pas changer la signification des opérateurs suivants :

• :: (résolution de portée) ;
• . (sélection de membre) ;
• .* (sélection de membre via un pointeur de fonction).

Vous ne pouvez pas non plus inventer d’autres mots clés d’opérateur. Si vous avez besoin d’une opération spécifique et qu’aucun mot clé ne semble approprié, créez une fonction.

Vous pouvez redéfinir un opérateur par l’intermédiaire d’une méthode de classe ou d’une fonction standard. Certains opérateurs peuvent cependant être définis comme membre de classe : l’opérateur d’affectation =, l’opérateur exposant [], l’opérateur appel de fonction (), et l’opérateur d’adressage indirect ->.
Vous trouverez un exemple de surcharge des opérateurs = et [] dans le code 5.2, et un exemple de la surcharge de << dans le code 5.4.

Le texte original de cette fiche pratique est extrait de
«Tout sur le C++» (Christine EBERHARDT, Collection
CommentCaMarche.net, Dunod, 2009)