Surcharge d'opérateurs en C++ : Guide pratique avec exemples de code

Qu'est-ce que la surcharge d'opérateurs ?

En utilisant la surcharge d'opérateurs en C++, vous pouvez assigner plusieurs significations à un opérateur dans la même portée. Le but est de donner un comportement personnalisé à un opérateur pour un type défini par l'utilisateur.

Avec la surcharge d'opérateurs, vous pouvez redéfinir la plupart des opérateurs C++ et effectuer différentes opérations en utilisant un seul symbole.

Dans ce tutoriel, vous apprendrez :

• Ce qu'est la surcharge d'opérateurs
• Syntaxe
• Différentes approches pour surcharger les opérateurs en C++
• Quels opérateurs ne peuvent pas être surchargés
• Points clés à retenir
• Règles de la surcharge d'opérateurs
• Comment surcharger un opérateur en pratique

Syntaxe

Pour surcharger un opérateur C++, définissez une fonction membre spéciale à l'intérieur d'une classe comme suit :

class nom_classe {
    ...
public:
    type_retour operateur symbole (argument(s)) {
        ...
    }
    ...
};

Les composants sont :

• type_retour – le type retourné par la fonction opérateur.
• operator – le mot-clé qui commence la déclaration.
• symbole – l'opérateur à surcharger, ex. +, -, <, ++.
• argument(s) – paramètres, comme toute autre fonction.

Exemple 1 :

#include <iostream>
using namespace std;
class TestClass {
private:
    int count;
public:
    TestClass() : count(5) {}
    void operator --() {
        count = count - 3;
    }
    void Display() {
        cout << "Count: " << count;
    }
};
int main() {
    TestClass tc;
    --tc;
    tc.Display();
    return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure <iostream> pour accéder aux facilités d'entrée/sortie.
2. Utiliser l'espace de noms std pour la brièveté.
3. Définir une classe TestClass.
4. Rendre count un membre de données privé.
5. Fournir un constructeur public qui initialise count à 5.
6. Surcharger l'opérateur préfixe -- pour soustraire 3 de count.
7. Implémenter Display() pour afficher la valeur courante.
8. Dans main(), créer une instance, appliquer l'opérateur surchargé et afficher le résultat.

Différentes approches de la surcharge d'opérateurs en C++

La surcharge peut être réalisée par :

1. Fonctions membres
2. Fonctions non-membres (amies ou fonctions libres)
3. Fonctions amies (quand l'accès aux données privées est nécessaire)

• Si l'opérande de gauche est un objet de la classe, une fonction membre est généralement utilisée.
• Quand l'opérande de gauche est d'un type différent, une fonction non-membre est requise.
• Les fonctions amies sont utiles quand l'opérateur doit accéder à des membres privés ou protégés.

Tous les opérateurs C++ peuvent-ils être surchargés ?

Non. Les opérateurs suivants ne sont pas surchargeables :

• :: – résolution de portée
• ?: – conditionnel ternaire
• . – accès aux membres
• sizeof – requête de taille
• * (sélecteur de pointeur de membre)

Choses à retenir

1. La surcharge n'affecte que les types définis par l'utilisateur ; les types intégrés conservent leur comportement original.
2. Les opérateurs d'affectation (=) et d'adresse (&) sont automatiquement surchargés pour les classes qui fournissent des constructeurs de copie ou des opérateurs d'affectation.
3. La précédence des opérateurs reste inchangée ; vous pouvez utiliser des parenthèses pour forcer l'ordre d'évaluation.
4. Trois opérateurs — ::, ., ?: — sont explicitement interdits de surcharge.

Règles de la surcharge d'opérateurs

• Au moins un opérande doit être un type de classe défini par l'utilisateur.
• Seuls les opérateurs existants peuvent être surchargés ; vous ne pouvez pas introduire de nouveaux symboles d'opérateurs.
• Certains opérateurs (ex. new, delete) ne peuvent pas être surchargés comme fonctions amies mais peuvent l'être comme fonctions membres.

Comment surcharger un opérateur

Exemple 1 : Opérateur d'incrémentation

#include <iostream>
using namespace std;
class OperatorOverload {
private:
    int x;
public:
    OperatorOverload() : x(10) {}
    void operator ++() {
        x += 2;
    }
    void Print() {
        cout << "The Count is: " << x;
    }
};
int main() {
    OperatorOverload ov;
    ++ov;
    ov.Print();
    return 0;
}

Sortie :

Capture d'écran du code :

Explication du code :

1. Inclure <iostream> et utiliser l'espace de noms std.
2. Définir la classe OperatorOverload avec un int x privé.
3. Le constructeur initialise x à 10.
4. Surcharger l'opérateur préfixe ++ pour ajouter 2 à x.
5. Implémenter Print() pour afficher la valeur mise à jour.
6. Dans main(), créer un objet, invoquer l'opérateur surchargé et afficher le résultat.

Exemple 2 : Addition de nombres complexes

#include <iostream>
using namespace std;
class TestClass {
private:
    int real, over;
public:
    TestClass(int rl = 0, int ov = 0) : real(rl), over(ov) {}
    TestClass operator + (TestClass const &obj) {
        TestClass result;
        result.real = real + obj.real;
        result.over = over + obj.over;
        return result;
    }
    void print() {
        cout << real << " + i" << over << endl;
    }
};
int main() {
    TestClass c1(9, 5), c2(4, 3);
    TestClass c3 = c1 + c2;
    c3.print();
}

Sortie :

Capture d'écran du code :

Explication du code :

1. Inclure <iostream> et utiliser l'espace de noms std.
2. Définir TestClass avec composants real et over.
3. Fournir un constructeur pour l'initialisation.
4. Surcharger l'opérateur + pour effectuer l'addition de nombres complexes.
5. Retourner une nouvelle instance TestClass contenant la somme.
6. Implémenter print() pour afficher le nombre complexe.
7. Dans main(), créer deux instances, les additionner et afficher le résultat.

Résumé

• La surcharge d'opérateurs permet plusieurs significations pour un opérateur dans une portée.
• Elle fournit un comportement personnalisé pour les types définis par l'utilisateur.
• La plupart des opérateurs C++ peuvent être surchargés, mais quelques-uns ne le peuvent pas.
• Au moins un opérande doit être un type défini par l'utilisateur.
• Seuls les opérateurs existants sont surchargeables.