Maîtriser la surcharge en C++ : Fonctions et opérateurs expliqués

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

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 évidemment une définition (implémentation) différente.

Lorsque vous appelez une fonction ou un opérateur surchargé, 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é s'appelle résolution de surcharge.

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 des autres par les types et/ou le nombre d'arguments dans la liste d'arguments. Vous ne pouvez pas surcharger des déclarations de fonction qui diffèrent seulement par le type de retour.

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

#include <iostream>
using namespace std;

class printData {
public:
    void print(int i) {
        cout << "Affichage int : " << i << endl;
    }
    void print(double f) {
        cout << "Affichage float : " << f << endl;
    }
    void print(char* c) {
        cout << "Affichage caractère : " << c << endl;
    }
};

int main(void) {
    printData pd;
    // Appel print pour afficher un entier
    pd.print(5);
    // Appel print pour afficher un float
    pd.print(500.263);
    // Appel print pour afficher une chaîne
    pd.print("Hello C++");
    return 0;
}

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

Affichage int : 5
Affichage float : 500.263
Affichage caractère : Hello C++

Surcharge d'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 utiliser des opérateurs avec des types définis par l'utilisateur également.

Les opérateurs surchargés sont des fonctions avec des noms spéciaux : le mot-clé « operator » 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 retourne l'objet Box final. La plupart des opérateurs surchargés peuvent être définis comme des fonctions membres ordinaires non-membres ou comme des fonctions membres de classe. Dans le cas où nous définissons la fonction ci-dessus comme 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 de surcharge d'opérateur en utilisant une fonction membre. Ici, un objet est passé comme argument dont les propriétés seront accessibles en utilisant cet objet, l'objet qui appellera cet opérateur peut être accédé en utilisant l'opérateur this 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; }
    // Surcharge de l'opérateur + pour ajouter 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 d'une boîte
    double breadth;  // Largeur d'une boîte
    double height;   // Hauteur d'une boîte
};

// Fonction principale pour le programme
int main() {
    Box Box1; // Déclare Box1 de type Box
    Box Box2; // Déclare Box2 de type Box
    Box Box3; // Déclare Box3 de type Box
    double volume = 0.0; // Stocker le volume d'une boîte ici
    // Spécification boîte 1
    Box1.setLength(6.0);
    Box1.setBreadth(7.0);
    Box1.setHeight(5.0);
    // Spécification boîte 2
    Box2.setLength(12.0);
    Box2.setBreadth(13.0);
    Box2.setHeight(10.0);
    // Volume boîte 1
    volume = Box1.getVolume();
    cout << "Volume de Box1 : " << volume << endl;
    // Volume boîte 2
    volume = Box2.getVolume();
    cout << "Volume de Box2 : " << volume << endl;
    // Ajouter deux objets comme suit :
    Box3 = Box1 + Box2;
    // Volume boîte 3
    volume = Box3.getVolume();
    cout << "Volume de Box3 : " << volume << endl;
    return 0;
}

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

Volume de Box1 : 210
Volume de Box2 : 1560
Volume de Box3 : 5400

Opérateurs surchargeables / non-surchargeables

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

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

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

::

.*

.

?:

Exemples de surcharge d'opérateurs

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

N°	Opérateurs et exemple
1	Surcharge d'opérateurs unaires
2	Surcharge d'opérateurs binaires
3	Surcharge d'opérateurs relationnels
4	Surcharge d'opérateurs Entrée/Sortie
5	Surcharge des opérateurs ++ et --
6	Surcharge d'opérateurs d'affectation
7	Surcharge de l'opérateur d'appel de fonction ()
8	Surcharge de l'opérateur d'indexation []
9	Surcharge de l'opérateur d'accès aux membres de classe ->