Tutorial C++ : Surcharge des opérateurs

Théorie:

Le C++ permet de surcharger des fonctions, c'est à dire de déclarer plusieurs fonctions avec le même nom, tant qu'elles ont des types de paramètres d'appel différents. Cela permet d'uniformiser l'utilisation des fonctions: il n'y a pas besoin de se souvenir du nom particulier d'une fonction pour un type particulier d'argument.

Pratique:

Le C++ offre une possibilité très intéressante qui est de pouvoir surcharger les opérateurs existants: +, -, *, /, <<, >>, etc, pour les objets d'une nouvelle classe. Il suffit pour cela de redéfinir les opérateurs comme des méthodes ou fonctions amies normales. Pour les opérateurs autres que << et >> la redéfinition peut se faire de deux façons:

1. type_de_retour operator nom_opérateur (arguments); où operator est un mot clé du C++. Le premier argument de l'opérateur est implicite et correspond à l'objet appelant. Ainsi dans objet1 + objet2, objet1 est l'objet appelant le +.

2. friend type_de_retour nom_operatuer (argument1, arguments). Les opérateurs << et >> sont obligatoirement déclarés comme fonctions amies car ils prennent en premier argument le flot sur lequel ils agissent. Leur déclaration est donc de la forme: friend type_flot& operator << (type_flot&, type_objet). Les types de flots possibles sont principalement ostream pour une sortie et istream pour une entrée.  ;

Exemple:

class liste
{
public:
...
// opérateur de sortie sur flot
friend ostream& oerator << (ostream&, liste);


//opérateur d'assignation
liste operator = (liste);
...
};


ostream& operator <<(ostream& flot, liste list)
{
liste::maillon *index;


flot <<"( ";
for(index=list.debut_liste;index!=NULL;index=index->suivant)
flot<<index->valeur<<" ";
flot <<")";


return flot;
}


liste liste::operator=(liste source)
{
// Si la liste est la même que la liste cible, on ne fait rien
if (this == &source)
return *this;


// destruction des maillons de l'ancienne liste
maillon *index, *suivant_index;


index = debut_liste;


while(index!=NULL)
{
suivant_index = index->suivant;
delete index;
index = suivant_index;
}


// copie de la liste source


maillon *nouveau;


debut_liste = NULL;


for(index=source.debvut_liste;index!=NULL;index=index->suivant)
{
if ((nouveau = new maillon) == NULL)
{
cout <<" Espace mémoire insuffisant " << endl;
exit(1);
}


nouveau->valeur = index->valeur;
nouveau->suivant = debut_liste;
debut_liste = nouveau;
}
return *this;
}