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 p2 : x = 1 et y= 9
Point p3 : x = 4 et y= 14
Voici la liste des opérateurs pouvant être surchargés
| + | - | * | / | % | ^ |
| & | | | ~ | ! | , | = |
| < | > | <= | >= | ++ | -- |
| << | >> | == | != | && | || |
| += | -= | /= | %= | ^= | &= |
| |= | *= | <<= | >>= | [] | () |
| -> | ->* | new | new[] | delete | delete[] |
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
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 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 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 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 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[5] : 10
A[12] : Index hors limites
0
