Maîtriser la surcharge d'opérateurs en C++ : Exemples pratiques et bonnes pratiques

Surcharge d'opérateurs en C++

Dans ce tutoriel, nous apprendrons la surcharge d'opérateurs avec des exemples pratiques.

En C++, nous pouvons modifier le comportement des opérateurs pour les types définis par l'utilisateur comme les objets et les structures. C'est ce qu'on appelle la surcharge d'opérateurs. Par exemple,

Supposons que nous ayons créé trois objets c1, c2 et result à partir d'une classe nommée Complex qui représente les nombres complexes.

Puisque la surcharge d'opérateurs nous permet de changer le fonctionnement des opérateurs, nous pouvons redéfinir le fonctionnement de l'opérateur + et l'utiliser pour additionner les nombres complexes de c1 et c2 en écrivant simplement :

result = c1 + c2;

au lieu de quelque chose comme :

result = c1.addNumbers(c2);

Cela rend notre code plus intuitif et facile à comprendre.

Note : Nous ne pouvons pas utiliser la surcharge d'opérateurs pour les types de données fondamentaux comme int, float, char, etc.

Syntaxe pour la surcharge d'opérateurs en C++

Pour surcharger un opérateur, nous utilisons une fonction operator spéciale. Nous définissons la fonction à l'intérieur de la classe ou de la structure dont nous voulons que l'opérateur surchargé fonctionne avec les objets/variables.

class nomClasse {
    ...
    typeRetour operator symbole(arguments) {
        ...
    }
    ...
};

Ici,

typeRetour est le type de retour de la fonction.
operator est un mot-clé.
symbole est l'opérateur que nous voulons surcharger. Par exemple : +, <, -, ++, etc.
arguments sont les arguments passés à la fonction.

Surcharge d'opérateurs unaires

Les opérateurs unaires opèrent sur un seul opérande. Les opérateurs d'incrémentation ++ et de décrémentation -- sont des exemples d'opérateurs unaires.

Exemple 1 : Surcharge de l'opérateur ++ (opérateur unaire) en préfixe

// Surcharge de ++ lorsqu'il est utilisé comme préfixe
#include <iostream>
using namespace std;

class Count {
private:
    int value;
public:
    // Constructeur pour initialiser count à 5
    Count() : value(5) {}
    
    // Surcharge de ++ lorsqu'il est utilisé comme préfixe
    void operator ++ () {
        ++value;
    }
    
    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;
    // Appelle la fonction "void operator ++ ()"
    ++count1;
    count1.display();
    return 0;
}

Sortie

Count: 6

Ici, quand nous utilisons ++count1;, la fonction void operator ++ () est appelée. Cela augmente l'attribut value de l'objet count1 de 1.

Note : Quand nous surchargeons des opérateurs, nous pouvons les faire fonctionner comme nous voulons. Par exemple, nous aurions pu utiliser ++ pour augmenter value de 100. Cependant, cela rendrait notre code confus et difficile à comprendre. C'est notre travail en tant que programmeur d'utiliser la surcharge d'opérateurs correctement et de manière cohérente et intuitive.

L'exemple ci-dessus fonctionne seulement quand ++ est utilisé comme préfixe. Pour faire fonctionner ++ comme postfixe, nous utilisons cette syntaxe :

void operator ++ (int) {
    // code
}

Remarquez le int à l'intérieur des parenthèses. C'est la syntaxe utilisée pour utiliser les opérateurs unaires comme postfixes ; ce n'est pas un paramètre de fonction.

Exemple 2 : Surcharge de l'opérateur ++ (préfixe et postfixe)

// Surcharge de ++ lorsqu'il est utilisé comme préfixe et postfixe
#include <iostream>
using namespace std;

class Count {
private:
    int value;
public:
    // Constructeur pour initialiser count à 5
    Count() : value(5) {}
    
    // Surcharge de ++ lorsqu'il est utilisé comme préfixe
    void operator ++ () {
        ++value;
    }
    
    // Surcharge de ++ lorsqu'il est utilisé comme postfixe
    void operator ++ (int) {
        value++;
    }
    
    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;
    // Appelle la fonction "void operator ++ (int)"
    count1++;
    count1.display();
    // Appelle la fonction "void operator ++ ()"
    ++count1;
    count1.display();
    return 0;
}

Sortie

Count: 6 Count: 7

L'Exemple 2 fonctionne quand ++ est utilisé comme préfixe et postfixe. Cependant, il ne fonctionne pas si nous essayons de faire quelque chose comme ceci :

Count count1, result;
// Erreur
result = ++count1;

C'est parce que le type de retour de notre fonction d'opérateur est void. Nous pouvons résoudre ce problème en faisant de Count le type de retour de la fonction d'opérateur.

// Retourne Count quand ++ utilisé comme préfixe
Count operator ++ () {
    // code
}
// Retourne Count quand ++ utilisé comme postfixe
Count operator ++ (int) {
    // code
}

Exemple 3 : Retour de valeur depuis la fonction d'opérateur (opérateur ++)

#include <iostream>
using namespace std;

class Count {
private:
    int value;
public:
    // Constructeur pour initialiser count à 5
    Count() : value(5) {}
    
    // Surcharge de ++ lorsqu'il est utilisé comme préfixe
    Count operator ++ () {
        Count temp;
        // Ici, value est l'attribut value de l'objet appelant
        temp.value = ++value;
        return temp;
    }
    
    // Surcharge de ++ lorsqu'il est utilisé comme postfixe
    Count operator ++ (int) {
        Count temp;
        // Ici, value est l'attribut value de l'objet appelant
        temp.value = value++;
        return temp;
    }
    
    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1, result;
    // Appelle la fonction "Count operator ++ ()"
    result = ++count1;
    result.display();
    // Appelle la fonction "Count operator ++ (int)"
    result = count1++;
    result.display();
    return 0;
}

Sortie

Count: 6 Count: 6

Ici, nous avons utilisé le code suivant pour la surcharge de l'opérateur préfixe :

// Surcharge de ++ lorsqu'il est utilisé comme préfixe
Count operator ++ () {
    Count temp;
    // Ici, value est l'attribut value de l'objet appelant
    temp.value = ++value;
    return temp;
}

Le code pour la surcharge de l'opérateur postfixe est également similaire. Remarquez que nous avons créé un objet temp et retourné sa valeur à la fonction d'opérateur.

Remarquez aussi le code :

temp.value = ++value;

La variable value appartient à l'objet count1 dans main() car count1 appelle la fonction, tandis que temp.value appartient à l'objet temp.

Surcharge d'opérateurs binaires

Les opérateurs binaires fonctionnent sur deux opérandes. Par exemple,

result = num + 9;

Ici, + est un opérateur binaire qui fonctionne sur les opérandes num et 9.

Quand nous surchargeons l'opérateur binaire pour les types définis par l'utilisateur en utilisant le code :

obj3 = obj1 + obj2;

La fonction d'opérateur est appelée en utilisant l'objet obj1 et obj2 est passé comme argument à la fonction.

Exemple 4 : Surcharge d'opérateur binaire en C++

// Programme C++ pour surcharger l'opérateur binaire +
// Ce programme additionne deux nombres complexes
#include <iostream>
using namespace std;

class Complex {
private:
    float real;
    float imag;
public:
    // Constructeur pour initialiser real et imag à 0
    Complex() : real(0), imag(0) {}
    
    void input() {
        cout << "Entrez les parties réelle et imaginaire respectivement : ";
        cin >> real;
        cin >> imag;
    }
    
    // Surcharge de l'opérateur +
    Complex operator + (const Complex& obj) {
        Complex temp;
        temp.real = real + obj.real;
        temp.imag = imag + obj.imag;
        return temp;
    }
    
    void output() {
        if (imag < 0)
            cout << "Nombre complexe de sortie : " << real << imag << "i";
        else
            cout << "Nombre complexe de sortie : " << real << "+" << imag << "i";
    }
};

int main() {
    Complex complex1, complex2, result;
    cout << "Entrez le premier nombre complexe :\n";
    complex1.input();
    cout << "Entrez le second nombre complexe :\n";
    complex2.input();
    // complex1 appelle la fonction d'opérateur
    // complex2 est passé comme argument à la fonction
    result = complex1 + complex2;
    result.output();
    return 0;
}

Sortie

Entrez le premier nombre complexe:
Entrez les parties réelle et imaginaire respectivement: 9 5
Entrez le second nombre complexe:
Entrez les parties réelle et imaginaire respectivement: 7 6
Nombre complexe de sortie: 16+11i

Dans ce programme, la fonction d'opérateur est :

Complex operator + (const Complex& obj) {
    // code
}

Au lieu de cela, nous aurions aussi pu écrire cette fonction comme :

Complex operator + (Complex obj) {
    // code
}

Cependant,

l'utilisation de & rend notre code plus efficace en référençant l'objet complex2 au lieu de créer un objet dupliqué à l'intérieur de la fonction d'opérateur.
l'utilisation de const est considérée comme une bonne pratique car elle empêche la fonction d'opérateur de modifier complex2.

Maîtriser la surcharge d opérateurs en C++ : Exemples pratiques et bonnes pratiques

Points à retenir pour la surcharge d'opérateurs en C++

Deux opérateurs = et & sont déjà surchargés par défaut en C++. Par exemple, pour copier des objets de la même classe, nous pouvons utiliser directement l'opérateur =. Nous n'avons pas besoin de créer une fonction d'opérateur.
La surcharge d'opérateurs ne peut pas changer la priorité et l'associativité des opérateurs. Cependant, si nous voulons changer l'ordre d'évaluation, des parenthèses doivent être utilisées.
Il y a 4 opérateurs qui ne peuvent pas être surchargés en C++. Ce sont :
1. :: (résolution de portée)
2. . (sélection de membre)
3. .* (sélection de membre via pointeur vers fonction)
4. ?: (opérateur ternaire)

Lectures recommandées :

Comment surcharger l'opérateur d'incrémentation correctement ?
Comment surcharger l'opérateur binaire - pour soustraire des nombres complexes ?

Comment passer et retourner des objets dans les fonctions C++ Comprendre les pointeurs en C++ : Guide pratique complet

Langue C