Langage c++

Appelez-nous au numéro (+212) 616 374 790 ou écrivez-nous à essaddouki@gmail.com

Demander le soutien en ligne de l'un de nos professeurs, à toute heure et où vous voulez, de 8h à minuit (GMT) Détails

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

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.

Exemple 1 :
                                Point operator+(const Point&);
                            

Déclare l'opérateur d'addition qui peut être utilisé pour ajouter deux objets Point et renvoie l'objet Point final.
La plupart des opérateurs surchargés peuvent être définis en tant que fonctions ordinaires non membres ou en tant que fonctions membres de classe. Si nous définissons la fonction ci-dessus comme fonction non-membre d'une classe, nous devrions alors passer deux arguments pour chaque opérande comme suit:

Exemple 2 :
                                Point operator+(const Point&, const Point&);
                            
Pourquoi " const typeObjet & " ?

Même si const vous empêche de changer la valeur de votre paramètre, il est préférable d’envoyer une référence à cette valeur plutôt que de l’envoyer par valeur, car, dans les grands objets, l’envoyer par valeur nécessiterait de le copier en premier, ce qui est pas nécessaire dans le passage par référence.

Il accélère l'exécution du code et la simplicité d'utilisation.

L'exemple suivant illustre le concept de surcharge de l'opérateur à l'aide d'une fonction membre. Ici, un objet est passé en tant qu'argument dont les propriétés seront accessibles à l'aide de cet objet. L'objet qui appellera cet opérateur est accessible à l'aide de pointeur this, comme expliqué ci-dessous.

Exemple 3 :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    class Point
                                    {
                                    private:
                                        int x, y;
                                    
                                    public:
                                        Point(int, int);
                                        void afficher();
                                        Point operator+(const Point &);
                                    };
                                    
                                    Point::Point(int a, int b) : x(a), y(b) {}
                                    void Point::afficher()
                                    {
                                        cout << " x = " << x << " et y= " << y << endl;
                                    }
                                    
                                    Point Point::operator+(const Point &p)
                                    {
                                        Point res(0, 0);       // résultat de l'addition
                                        res.x = this->x + p.x; // ou simplement x+p.x
                                        res.y = this->y + p.y;
                                        return res;
                                    }
                                    
                                    int main()
                                    {
                                        Point p1(3, 5), p2(1, 9), p3(0, 0);
                                        cout << "Point p1 : ";
                                        p1.afficher();
                                        cout << "Point p2 : ";
                                        p2.afficher();
                                    
                                        p3 = p1 + p2;
                                        cout << "Point p3 : ";
                                        p3.afficher();
                                    
                                        return 0;
                                    }
                            

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

Point p1 : x = 3 et y= 5
Point p2 : x = 1 et y= 9
Point p3 : x = 4 et y= 14

Voici la liste des opérateurs pouvant être surchargés

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

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

::.*.?:

Exemples

Opérateurs unaires

Les opérateurs unaires opèrent sur un seul opérande, voici les exemples d'opérateurs unaires

  •   Opérateur d'incrémentation (++) ou décrémentation (--)
  •   L'opérateur unaire moins (-).
  •   L'opérateur logique non (!).

Les opérateurs unaires opèrent sur l'objet pour lequel ils ont été appelés et normalement, cet opérateur apparaît sur le côté gauche de l'objet, comme dans !obj, -obj et ++obj, mais ils peuvent parfois être utilisés comme postfix aussi bien que obj++ ou obj--.

l'exemple suivant montrera les utilisations de ces opérateurs

Exemple 4 :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    class Point
                                    {
                                    private:
                                        int x, y;
                                    
                                    public:
                                        Point(int, int);
                                        void afficher();
                                        Point operator-();
                                        Point operator++();    // surchargé l'opérateur préfixe ++
                                        Point operator++(int); // surchargé l'opérateur postfix ++
                                    
                                        Point operator--();    // surchargé l'opérateur préfixe --
                                        Point operator--(int); // surchargé l'opérateur postfix --
                                        Point operator!();
                                    };
                                    
                                    Point::Point(int a, int b) : x(a), y(b) {}
                                    void Point::afficher()
                                    {
                                        cout << " x = " << x << " et y= " << y << endl;
                                    }
                                    
                                    Point Point::operator-()
                                    {
                                        x = -x;
                                        y = -y;
                                        return Point(x, y);
                                    }
                                    Point Point::operator++()
                                    {
                                        return Point(++x, ++y); // ajouter 1 à x et y;
                                    }
                                    Point Point::operator++(int a)
                                    {
                                        return Point(x++, y++); // ajouter 1 à x et y;
                                    }
                                    Point Point::operator--()
                                    {
                                        return Point(--x, --y); // soustraire 1 de x et y
                                    }
                                    Point Point::operator--(int b)
                                    {
                                        return Point(x--, y--); // soustraire 1 de x et y
                                    }
                                    
                                    Point Point::operator!()
                                    {
                                        x = x * (-1);
                                        y = y * (-1);
                                        return Point(x, y); // la négation d'un point sert par exemple à multiplier les coordonées par (-1)
                                    }
                                    
                                    int main()
                                    {
                                        Point p1(3, 5);
                                        cout << "Point p1 initial";
                                        p1.afficher();
                                    
                                        Point p = p1++;
                                        cout << " Incrémentation Postfixe " << endl;
                                        cout << " p : ";
                                        p.afficher();
                                        cout << " p1 : ";
                                        p1.afficher();
                                    
                                        -p1;
                                        cout << "moins";
                                        p1.afficher();
                                    
                                        !p1;
                                        cout << "négation";
                                        p1.afficher();
                                    
                                        return 0;
                                    }
                            

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

Point p1 initial x = 3 et y= 5
Incrémentation Postfixe
p : x = 3 et y= 5
p1 : x = 4 et y= 6
moins x = -4 et y= -6
négation x = 4 et y= 6

Opérateurs binaires

Les opérateurs binaires prennent deux arguments. Voici des exemples d'opérateurs binaires.

  •  Addition (+)
  •  Soustraction(-)
  •  Division (/)
  •  Multiplication

L'exemple suivant vous montrera comment implémenter ces opérateurs en tant que fonctions membres.

Exemple 5 :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    class Point
                                    {
                                    private:
                                        int x, y;
                                    
                                    public:
                                        Point(int, int);
                                        void afficher();
                                        Point operator+(const Point &);
                                        Point operator-(const Point &);
                                        Point operator/(const Point &);
                                        Point operator*(const Point &);
                                    };
                                    
                                    Point::Point(int a, int b) : x(a), y(b) {}
                                    void Point::afficher()
                                    {
                                        cout << " x = " << x << " et y= " << y << endl;
                                    }
                                    
                                    Point Point::operator+(const Point &p)
                                    {
                                        return Point(x + p.x, y + p.y);
                                    }
                                    Point Point::operator-(const Point &p)
                                    {
                                        return Point(x - p.x, y - p.y);
                                    }
                                    Point Point::operator*(const Point &p)
                                    {
                                        return Point(x * p.x, y * p.y);
                                    }
                                    Point Point::operator/(const Point &p)
                                    {
                                        return Point(x / p.x, y / p.y);
                                    }
                                    
                                    int main()
                                    {
                                        Point p1(3, 5), p2(6, -2);
                                    
                                        Point somme = p1 + p2;
                                        cout << "la somme est ";
                                        somme.afficher();
                                    
                                        Point soust = p1 - p2;
                                        cout << "la soustraction est ";
                                        soust.afficher();
                                    
                                        Point mult = p1 * p2;
                                        cout << "la multiplication est ";
                                        mult.afficher();
                                    
                                        Point div = p1 / p2;
                                        cout << "la division est ";
                                        div.afficher();
                                    
                                        return 0;
                                    }
                            

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

la somme est x = 9 et y= 3
la soustraction est x = -3 et y= 7
la multiplication est x = 18 et y= -10
la division est x = 0 et y= -2

Nous pouvons également utiliser des fonctions amies pour implémenter ces opérateurs en dehors de la classe, comme dans l'exemple suivant.

Exemple 6 :
                                    #include <iostream>
                                    using namespace std;
                                    
                                    class Point
                                    {
                                    private:
                                        int x, y;
                                    
                                    public:
                                        Point(int, int);
                                        void afficher();
                                        friend Point operator+(const Point &, const Point &);
                                        friend Point operator-(const Point &, const Point &);
                                        friend Point operator/(const Point &, const Point &);
                                        friend Point operator*(const Point &, const Point &);
                                    };
                                    
                                    Point::Point(int a, int b) : x(a), y(b) {}
                                    void Point::afficher()
                                    {
                                        cout << " x = " << x << " et y= " << y << endl;
                                    }
                                    
                                    Point operator+(const Point &p1, const Point &p2)
                                    {
                                        return Point(p1.x + p2.x, p1.y + p2.y); // Point est le constructeur
                                    }
                                    Point operator-(const Point &p1, const Point &p2)
                                    {
                                        return Point(p1.x - p2.x, p1.y - p2.y); // Point est le constructeur de classe
                                    }
                                    Point operator*(const Point &p1, const Point &p2)
                                    {
                                        return Point(p1.x * p2.x, p1.y * p2.y);
                                    }
                                    Point operator/(const Point &p1, const Point &p2)
                                    {
                                        return Point(p1.x / p2.x, p1.y / p2.y);
                                    }
                                    
                                    int main()
                                    {
                                        Point p1(3, 5), p2(6, -2);
                                    
                                        Point somme = p1 + p2;
                                        cout << "la somme est ";
                                        somme.afficher();
                                    
                                        Point soust = p1 - p2;
                                        cout << "la soustraction est ";
                                        soust.afficher();
                                    
                                        Point mult = p1 * p2;
                                        cout << "la multiplication est ";
                                        mult.afficher();
                                    
                                        Point div = p1 / p2;
                                        cout << "la division est ";
                                        div.afficher();
                                    
                                        return 0;
                                    }
                            

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

la somme est x = 9 et y= 3
la soustraction est x = -3 et y= 7
la multiplication est x = 18 et y= -10
la division est x = 0 et y= -2

Opérateurs relationnels

Il existe différents opérateurs relationnels pris en charge par le langage C ++, tels que (<, >, <=, >=, ==, etc.), qui peuvent être utilisés pour comparer les types de données intégrés C++.

Vous pouvez surcharger n'importe lequel de ces opérateurs, ce qui peut être utilisé pour comparer les objets d'une classe.

L'exemple suivant explique comment utiliser ces opérateurs. Dans cet exemple, nous utilisons la distance du racine pour comparer deux points.

Exemple 7 :
                                    #include <iostream>
                                    #include <math.h>
                                    using namespace std;
                                    
                                    class Point
                                    {
                                    private:
                                        int x, y;
                                    
                                    public:
                                        Point(int, int);
                                        void afficher();
                                        bool operator==(const Point &);
                                        bool operator<(const Point &);
                                        bool operator>(const Point &);
                                        bool operator<=(const Point &);
                                        bool operator>=(const Point &);
                                    };
                                    
                                    Point::Point(int a, int b) : x(a), y(b) {}
                                    void Point::afficher()
                                    {
                                        cout << " x = " << x << " et y= " << y << endl;
                                    }
                                    
                                    bool Point::operator==(const Point &p)
                                    {
                                        double d1 = sqrt(x * x + y * y);
                                        double d2 = sqrt(p.x * p.x + p.y * p.y);
                                        if (d1 == d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    
                                    bool Point::operator<=(const Point &p)
                                    {
                                        double d1 = sqrt(x * x + y * y);
                                        double d2 = sqrt(p.x * p.x + p.y * p.y);
                                        if (d1 <= d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    bool Point::operator>=(const Point &p)
                                    {
                                        double d1 = sqrt(x * x + y * y);
                                        double d2 = sqrt(p.x * p.x + p.y * p.y);
                                        if (d1 >= d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    
                                    bool Point::operator<(const Point &p)
                                    {
                                        double d1 = sqrt(x * x + y * y);
                                        double d2 = sqrt(p.x * p.x + p.y * p.y);
                                        if (d1 < d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    bool Point::operator>(const Point &p)
                                    {
                                        double d1 = sqrt(x * x + y * y);
                                        double d2 = sqrt(p.x * p.x + p.y * p.y);
                                        if (d1 > d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    
                                    int main()
                                    {
                                        Point p1(3, 5), p2(6, -2), p3(5, 3);
                                    
                                        if (p1 == p3)
                                            cout << "p1 et p3 sont égaux " << endl;
                                    
                                        if (p1 <= p2)
                                            cout << "p1 est inférieur à p2 " << endl;
                                    
                                        // autres utilisation
                                        return 0;
                                    }
                            

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

p1 et p3 sont égaux
p1 est inférieur à p2

Nous pouvons également utiliser des fonctions amies pour implémenter ces opérateurs en dehors de la classe, comme dans l'exemple suivant.

Exemple 8 :
                                    #include <iostream>
                                    #include <math.h>
                                    using namespace std;
                                    
                                    class Point
                                    {
                                    private:
                                        int x, y;
                                    
                                    public:
                                        Point(int, int);
                                        void afficher();
                                        friend bool operator==(const Point &, const Point &);
                                        friend bool operator<(const Point &, const Point &);
                                        friend bool operator>(const Point &, const Point &);
                                        friend bool operator<=(const Point &, const Point &);
                                        friend bool operator>=(const Point &, const Point &);
                                    };
                                    
                                    Point::Point(int a, int b) : x(a), y(b) {}
                                    void Point::afficher()
                                    {
                                        cout << " x = " << x << " et y= " << y << endl;
                                    }
                                    
                                    bool operator==(const Point &p1, const Point &p2)
                                    {
                                        double d1 = sqrt(p1.x * p1.x + p1.y * p1.y);
                                        double d2 = sqrt(p2.x * p2.x + p2.y * p2.y);
                                        if (d1 == d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    
                                    bool operator<=(const Point &p1, const Point &p2)
                                    {
                                        double d1 = sqrt(p1.x * p1.x + p1.y * p1.y);
                                        double d2 = sqrt(p2.x * p2.x + p2.y * p2.y);
                                        if (d1 <= d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    bool operator>=(const Point &p1, const Point &p2)
                                    {
                                        double d1 = sqrt(p1.x * p1.x + p1.y * p1.y);
                                        double d2 = sqrt(p2.x * p2.x + p2.y * p2.y);
                                        if (d1 >= d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    
                                    bool operator<(const Point &p1, const Point &p2)
                                    {
                                        double d1 = sqrt(p1.x * p1.x + p1.y * p1.y);
                                        double d2 = sqrt(p2.x * p2.x + p2.y * p2.y);
                                        if (d1 < d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    bool operator>(const Point &p1, const Point &p2)
                                    {
                                        double d1 = sqrt(p1.x * p1.x + p1.y * p1.y);
                                        double d2 = sqrt(p2.x * p2.x + p2.y * p2.y);
                                        if (d1 > d2)
                                            return true;
                                        else
                                            return false;
                                    }
                                    
                                    int main()
                                    {
                                        Point p1(3, 5), p2(6, -2), p3(5, 3);
                                    
                                        if (p1 == p3)
                                            cout << "p1 et p3 sont égaux " << endl;
                                    
                                        if (p1 <= p2)
                                            cout << "p1 est inférieur à p2 " << endl;
                                    
                                        // autres utilisation
                                        return 0;
                                    }
                            

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

p1 et p3 sont égaux
p1 est inférieur à p2

Opérateur d'indice [ ]

L'opérateur d'indice [] est normalement utilisé pour accéder aux éléments du tableau. Cet opérateur peut être surchargé pour améliorer les fonctionnalités existantes des tableaux C++.

Exemple 9 :
                                    #include <iostream>
                                    using namespace std;
                                    const int TAILLE = 10;
                                    
                                    class Tableau
                                    {
                                    private:
                                        int tab[TAILLE];
                                    
                                    public:
                                        Tableau();
                                        int &operator[](int);
                                    };
                                    
                                    Tableau::Tableau()
                                    {
                                        for (int i = 0; i < TAILLE; i++)
                                        {
                                            tab[i] = i*2;
                                        }
                                    }
                                    int &Tableau::operator[](int index)
                                    {
                                        if (index > TAILLE)
                                        {
                                            cerr << "Index hors limites" << endl;
                                            return tab[0];
                                        }
                                    
                                        return tab[index];
                                    }
                                    int main()
                                    {
                                        Tableau A;
                                        cout << "A[2] : " << A[2] << endl;
                                        cout << "A[5] : " << A[5] << endl;
                                        cout << "A[12] : " << A[12] << endl;
                                    
                                        return 0;
                                    }
                            

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

A[2] : 4
A[5] : 10
A[12] : Index hors limites
0

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :