Surcharge d'opérateur C++

Dans ce didacticiel, nous allons découvrir la surcharge d'opérateurs à l'aide d'exemples.

En C++, nous pouvons changer la façon dont les opérateurs fonctionnent pour les types définis par l'utilisateur comme les objets et les structures. C'est ce qu'on appelle la surcharge d'opérateur . Par exemple,

Supposons que nous ayons créé trois objets c1 , c2 et résultat d'une classe nommée Complex qui représente des nombres complexes.

Étant donné que la surcharge des opérateurs nous permet de modifier le fonctionnement des opérateurs, nous pouvons redéfinir la façon dont le + l'opérateur fonctionne et utilisez-le pour additionner les nombres complexes de c1 et c2 en écrivant le code suivant :

result = c1 + c2;

au lieu de quelque chose comme

result = c1.addNumbers(c2);

Cela rend notre code intuitif et facile à comprendre.

Remarque : Nous ne pouvons pas utiliser la surcharge d'opérateur pour les types de données fondamentaux comme int , float , char et ainsi de suite.

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

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

class className {
    ... .. ...
    public
       returnType operator symbol (arguments) {
           ... .. ...
       } 
    ... .. ...
};

Ici,

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

Surcharge d'opérateurs dans les opérateurs unaires

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

Exemple1 :Surcharge de l'opérateur ++ (opérateur unaire)

// Overload ++ when used as prefix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Sortie

Count: 6

Ici, lorsque nous utilisons ++count1; , le void operator ++ () est appelé. Cela augmente la valeur attribut pour l'objet count1 par 1.

Remarque : Lorsque nous surchargeons les opérateurs, nous pouvons l'utiliser pour travailler comme nous le souhaitons. Par exemple, nous aurions pu utiliser ++ pour augmenter la valeur par 100.

Cependant, cela rend notre code confus et difficile à comprendre. C'est notre travail en tant que programmeur d'utiliser la surcharge d'opérateur correctement et de manière cohérente et intuitive.

L'exemple ci-dessus ne fonctionne que lorsque ++ est utilisé comme préfixe. Faire ++ fonctionnent comme un suffixe, 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 suffixe ; ce n'est pas un paramètre de fonction.

Exemple 2 :Surcharge de l'opérateur ++ (opérateur unaire)

// Overload ++ when used as prefix and postfix

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public:

    // Constructor to initialize count to 5
    Count() : value(5) {}


    // Overload ++ when used as prefix
    void operator ++ () {
        ++value;
    }


    // Overload ++ when used as postfix
    void operator ++ (int) {
        value++;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1;

    // Call the "void operator ++ (int)" function
    count1++;
    count1.display();

    // Call the "void operator ++ ()" function
    ++count1;

    count1.display();
    return 0;
}

Sortie

Count: 6
Count: 7

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

Count count1, result;

// Error
result = ++count1;

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

// return Count when ++ used as prefix

Count operator ++ () {
    // code
}

// return Count when ++ used as postfix

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

Exemple 3 :Valeur renvoyée par la fonction opérateur (opérateur ++)

#include <iostream>
using namespace std;

class Count {
   private:
    int value;

   public
       :
    // Constructor to initialize count to 5
    Count() : value(5) {}

    // Overload ++ when used as prefix
    Count operator ++ () {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = ++value;

        return temp;
    }

    // Overload ++ when used as postfix
    Count operator ++ (int) {
        Count temp;

        // Here, value is the value attribute of the calling object
        temp.value = value++;

        return temp;
    }

    void display() {
        cout << "Count: " << value << endl;
    }
};

int main() {
    Count count1, result;

    // Call the "Count operator ++ ()" function
    result = ++count1;
    result.display();

    // Call the "Count operator ++ (int)" function
    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 de préfixe :

// Overload ++ when used as prefix
Count operator ++ () {
    Count temp;

    // Here, value is the value attribute of the calling object
    temp.value = ++value;

    return temp;
}

Le code pour la surcharge de l'opérateur postfixé est également similaire. Notez que nous avons créé un objet temp et renvoie sa valeur à la fonction opérateur.

Notez également le code

temp.value = ++value;

La variable valeur appartient au count1 objet en main() parce que count1 appelle la fonction, tandis que temp.value appartient à la temp objet.

Surcharge d'opérateur dans les opérateurs binaires

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

result = num + 9;

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

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

obj3 = obj1 + obj2;

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

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

// C++ program to overload the binary operator +
// This program adds two complex numbers

#include <iostream>
using namespace std;

class Complex {
   private:
    float real;
    float imag;

   public:
    // Constructor to initialize real and imag to 0
    Complex() : real(0), imag(0) {}

    void input() {
        cout << "Enter real and imaginary parts respectively: ";
        cin >> real;
        cin >> imag;
    }

    // Overload the + operator
    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 << "Output Complex number: " << real << imag << "i";
        else
            cout << "Output Complex number: " << real << "+" << imag << "i";
    }
};

int main() {
    Complex complex1, complex2, result;

    cout << "Enter first complex number:\n";
    complex1.input();

    cout << "Enter second complex number:\n";
    complex2.input();

   // complex1 calls the operator function
   // complex2 is passed as an argument to the function
    result = complex1 + complex2;
    result.output();

    return 0;
}

Sortie

Enter first complex number:
Enter real and imaginary parts respectively: 9 5
Enter second complex number:
Enter real and imaginary parts respectively: 7 6
Output Complex number: 16+11i

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

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

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

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

Cependant,

en utilisant & rend notre code efficace en référençant le complex2 objet au lieu de créer un objet dupliqué dans la fonction opérateur.
en utilisant const est considéré comme une bonne pratique car il empêche la fonction opérateur de modifier complex2 .

Éléments à retenir dans la surcharge d'opérateurs C++

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

Visitez ces pages pour en savoir plus sur :

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

Comment passer et renvoyer un objet à partir de fonctions C++ ? Pointeurs C++

Langue C