Surcharge d’opérateur

Dr SIDIBE A. MA, ENI-ABT

 Surcharge d'opérateurs

Le processus de définition des significations supplémentaires des opérateurs est connu

sous le nom de surcharge d'opérateurs. Il permet à un opérateur d'effectuer différentes
opérations selon le type d'opérandes. Il permet également aux opérateurs de traiter les
types de données définis par l'utilisateur.
Les opérateurs arithmétiques de base tels que +, -, * et / fonctionnent normalement avec des
types de base tels que int, float et long etc. L'application de ces opérateurs avec des types de
base est déjà définie dans le langage. Cependant, une erreur se produira si ces opérateurs sont
utilisés avec des objets définis par l'utilisateur.
 Surcharge d'opérateurs

Exemple
L'opérateur d'addition est utilisé pour additionner deux valeurs numériques. Supposons que a, b
et c soient trois variables entières. L'instruction suivante ajoutera le contenu de a et b et
stockera le résultat dans la variable c :
c=a+b;
L'opérateur d'addition sait déjà comment traiter les opérandes entiers. Mais il ne sait pas
comment traiter deux objets définis par l'utilisateur. L'instruction ci-dessus générera une erreur
si a, b et c sont des objets d'une classe. Cependant, la surcharge de l'opérateur peut
permettre à l'opérateur d'addition de manipuler deux objets.
Nous avons déclaré plus d'une fois que C++ essaie de faire en sorte que les types de données
définis par l'utilisateur se comportent à peu près de la même manière que les types intégrés. Par
exemple, C++ nous permet d'ajouter deux variables de types définis par l'utilisateur avec la
même syntaxe que celle appliquée aux types de base. Cela signifie que C++ a la capacité de
fournir aux opérateurs une signification spéciale pour un type de données. Le mécanisme
consistant à donner de telles significations spéciales à un opérateur est connu sous le nom de
surcharge d'opérateur.
▪ La surcharge d'opérateur est la capacité de dire au compilateur comment effectuer une
certaine opération en fonction du type de données de son opérateur correspondant.
▪ comme + effectue l'addition de deux nombres entiers, la concaténation de deux variables
de chaîne et fonctionne totalement différemment lorsqu'il est utilisé avec des objets de
classe de Time.
 Déclaration de la surcharge d'un opérateur
Un opérateur peut être surchargé en déclarant une fonction membre spéciale dans la classe. La
fonction membre utilise le mot clé operator avec le symbole de l'opérateur à surcharger.
La syntaxe
La syntaxe de surcharge d'un opérateur est la suivante :
type_retour opérator op()
{
corps de fonction;
}
- type_retour indique le type de valeur renvoyé par la fonction membre.
- operator est le mot clé qui indique que la fonction membre est utilisée pour surcharger un
opérateur.
- op c'est le symbole de l'opérateur à surcharger.
Exemple
void operator ++()
{
corps de fonction;
}
La Surcharge des opérateurs unaires
Un type d'opérateur qui fonctionne avec un seul opérande est appelé opérateur unaire. Les
opérateurs unaires sont surchargés pour augmenter leurs capacités.
Les opérateurs unaires pouvant être surchargés en C++ sont les suivants :
+ - * ! ~ &
++ -- () -> new delete
 Surcharge de l'opérateur ++
L'opérateur d'incrémentation ++ est un opérateur unaire. Il fonctionne avec un seul opérande. Il augmente la
valeur de l'opérande de 1. Il ne fonctionne qu'avec des valeurs numériques par défaut. Il peut être surchargé pour
lui permettre d'augmenter les valeurs des données membres d'un objet de la même manière.
Exemple Écrivez un programme qui surcharge l'opérateur d'incrémentation pour travailler avec des objets
définis par l'utilisateur.
#include<iostream> void operator++()
using namespace std; {
class Count n = n+1;
{ }
private: };
int n; int main()
public: {
Count() Count obj;
{ obj.show();
n = 0; ++obj;
} obj.show();
void show() return 0;
{ }
cout<< “ n= “ <<n<<endl;
}
Comment fonctionne le programme ci-dessus
Le programme ci-dessus surcharge l'opérateur d'incrémentation ++ pour travailler avec les objets de
toute la classe Count définie par l'utilisateur. Il augmente la valeur du membre de données n de 1.
L'utilisateur peut utiliser le même format pour augmenter la valeur de l'objet que celui utilisé avec
les entiers. La surcharge ci-dessus ne fonctionne qu'en notation préfixée.
Surcharge d'opérateur avec valeur renvoyée
L'opérateur d'incrémentation peut être utilisé dans l'instruction d'affectation pour stocker la valeur
incrémentée dans une autre variable. Supposons que a et b soient deux entiers. L'instruction suivante
incrémentera la valeur de a de 1, puis affectera la nouvelle valeur à b :
b=++a;
La fonctionnalité ci-dessus peut être affectée à l'opérateur en renvoyant la nouvelle valeur à partir de
la fonction membre. La valeur renvoyée peut être stockée dans un autre objet du même type sur le
côté gauche de l'opérateur d'affectation.
Exemple
Écrivez un programme qui surcharge l'opérateur d'incrémentation pour travailler avec des objets définis par
l'utilisateur. La fonction surchargée doit renvoyer un objet après avoir incrémenté le membre de données.
Count operator++()
class Count {
{ Count temp;
private: n = n+1;
temp.n = n;
int n;
return temp;
public: }
Count() };
int main()
{
{
n = 0; Count x, y ;
} x.show();
void show() y.show();
y = ++x ;
{ x.show();
cout<< “ n=”<<n<<endl; y.show();
} return 0 ;
}
Comment fonctionne le programme ci-dessus ?
Le programme ci-dessus surcharge l'opérateur d'incrémentation. La fonction membre
incrémente la valeur données membre n. Il stocke la valeur d'incrément dans l'objet
temporaire et renvoie l'objet. Il permet à l'utilisateur d'utiliser l'opérateur d'incrémentation
dans un opérateur d'affectation.
Surcharge des opérateurs binaires
Un type d'opérateur qui fonctionne avec deux opérandes est appelé opérateur binaire. Les
opérateurs binaires sont surchargés pour augmenter leurs capacités.
Les opérateurs binaires pouvant être surchargés en C++ sont les suivants :
+ - * / % & | ^ << >>

== += -= /= %= &= |= ^= <<= >>=

> < <= >= && || [] ()

Opérateurs arithmétiques

Les opérateurs arithmétiques binaires tels que +, -, *, / sont des opérateurs binaires. Ils
fonctionnent avec deux opérandes. Ces opérateurs peuvent être surchargés pour leur permettre
de travailler avec un objet défini par l'utilisateur de la même manière qu'ils travaillent avec
des types de base tels que int, long et float etc.
Exemple: Écrivez un programme qui surcharge l'opérateur d'addition binaire +.
#include<iostream>
using namespace std; Add operator +(Add p)
class Add {
{ Add temp;
private: temp.a = a + p.a;
int a, b; temp.b = b + p.b;
public: return temp;
Add() }
{ };
a = b = 0; int main()
} {
void in() Add x, y, z;
{ x.in();
cout<<” Enter a:”; y.in();
cin>>a; z = x + y;
cout<<” Enter b:”; x.show();
cin>>b; y.show();
} z.show();
void show() return 0;
{ }
cout<< ”a= ”<<a<<endl;
cout<< ”b= ”<<b<<endl;
}
Comment fonctionne le programme ci-dessus ?

Le programme ci-dessus surcharge l'opérateur d'addition binaire. Lorsque l'opérateur binaire

est utilisé avec des objets, l'opérande gauche agit comme objet appelant et l'opérande droit
agit comme paramètre passé à la fonction membre.
z=x+y;
Dans l'instruction ci-dessus, x est l'objet appelant et y est passé comme objet paramètre. La
fonction membre ajoute les valeurs de l'objet appelant et de l'objet paramètre. Il stocke le
résultat dans un objet temporaire, puis renvoie l'objet temporaire. L'objet renvoyé est copié
dans l'objet situé à gauche de l'opérateur d'affectation dans la fonction main().

NB: En règle générale, lors de la surcharge d'opérateurs binaires, l'opérande de gauche est
utilisé pour invoquer la fonction d'opérateur et l'opérande de droite est passé en argument.
 Surcharge des opérateurs d'affectation arithmétique

Les opérateurs d'affectation arithmétique (ou opérateurs d'affectation composé) permettent

d'augmenter la valeur d'une variable. Supposons que a et b soient deux entiers et que
l'instruction suivante soit exécutée :
a+=b;
l'instruction ci-dessus ajoutera les valeurs de a et b et attribuera le résultat à a. L'opérateur
d'affectation arithmétique += ne peut pas fonctionner avec des objets définis par l'utilisateur.
Mais il peut être surchargé afin de l'utiliser avec des objets définis par l'utilisateur.
 Exemple: Écrivez un programme qui surcharge l'opérateur d'affectation arithmétique pour travailler avec des
objets définis par l'utilisateur. void show()
{
#include<iostream> cout<< “You have read”<<pages in<<days<<” days.”<<endl;
using namespace std; }
class Read void operator +=(Read r)
{ private: {
int days, pages; days = days + r.days;
public: pages = pages +r.pages;
Read() }
{ int main()
days = pages = 0; { Read r1, r2;
} r1.in();
void in() r2.in();
{ cout<<”\n Reading number 1…”<<endl;
cout<<” How many days have you read”; r1.show();
cin>>days; cout<<”\n Reading number 2…”<<endl;
cout<<” How many pages have you read”; r2.show();
cin>>pages; cout<<”\n Adding r1 to r2 using += operator …”<<endl;
} r2 +=r1;
cout<<”\n Total reading is as follows;”<<endl;
r2.show();
return 0;
}
Comment fonctionne le programme ci-dessus ?
Le programme ci-dessus surcharge l'opérateur d'affectation arithmétique += pour travailler
avec des objets de la classe Read. La fonction membre de surcharge accepte un objet en
tant que paramètre et ajoute les valeurs de paramètre à l'objet appelant comme suit :
days = days + r.days ;
pages = pages +r.pages;
Dans les instructions ci-dessus, days et pages sont les données membres de l'objet appelant r2
et r.days et r.pages sont les données membres de l'objet paramètre r1.
Exemple: #include <iostream>
using namespace std; void Complex :: display(void)
Écrivez un programme qui {
surcharge l'opérateur d’addition class Complex
{ private: cout << x << " + i" << y << "\n";
pour travailler avec des objets de la }
float x; //partie réelle
classe des nombre complexes int main()
float y; // partie imaginaire
définie par l'utilisateur. public: {
Complex(){ } Complex C1, C2, C3;
Complex(float real, float imag) C1 = Complex(2.5, 3.5);
{ C2 = Complex(1.6, 2.7);
x = real; C3 = C1 + C2; //C3 = C1.operator+(C2);
y = imag; cout << "C1 = ";
} C1.display();
Complex operator+(complex); cout << "C2 = ";
void display(void); C2.display();
}; cout << "C3 = ";
Complex Complex :: operator+(Complex c) C3.display();
{ return 0;
Complex temp; }
temp.x = x + c.x;
temp.y = y + c.y;
return temp;
}
Exemple: Écrivez un programme qui surcharge l'opérateur d’addition pour travailler avec des objets de la classe
Box (un carton en français) définie par l'utilisateur. La classe Box a trois attributs: longueur, largeur et la hauteur.
#include <iostream>
using namespace std;
class Box void setHeight(double hei)
{ private: {
double length; height = hei;
double breadth; }
double height; // la surcharge de l'opérateur + pour ajouter deux objets Boxs.
public: Box operator+(const Box& b)
double getVolume() {
{ Box box;
return length*breadth*height;
} box.length = this->length + b.length;
void setLength(double len) box.breadth = this->breadth + b.breadth;
{
length = len; box.height = this->height + b.height;
} return box;
void setBreadth(double bre)
}
{
};
breadth = bre;
}
int main()
{ // volume du box 1

Box Box1 ; volume = Box1.getVolume();

Box Box2 ; cout << "Volume du Box1 : "<<volume<< endl;

Box Box3 ; // volume du box2

double volume = 0.0 ; volume = Box2.getVolume();

// specification du box1 cout << "Volume du Box2 : " << volume << endl;

Box1.setLength(6.0); // Ajouter deux objets comme suit

Box1.setBreadth(7.0); Box3 = Box1 + Box2 ;

Box1.setHeight(5.0); // volume du box 3

// specification du box2 volume = Box3.getVolume();

Box2.setLength(12.0); cout << "Volume du Box3 : " << volume << endl;

Box2.setBreadth(13.0); return 0 ;

Box2.setHeight(10.0); }