Département : ATE

Module : Programmation orientée objet en C++

Enseignant : M. DIBOUNE.

Chapitre 4 : Programmation Orientée Objet en C++

Partie 3 : Surcharge des opérateurs, mot clé this, membres
statiques, class template
1. Surcharge des opérateurs
Les classes permettent de définir de nouveaux types à utiliser dans un code C ++. Or les types en C ++
n'interagissent pas avec le code seulement au moyen de constructions (déclarations) et d'affectations,
mais également via des opérateurs.
Exemple 1.
Listing 4.1 : opération sur des types simples
01 int a, b, c;
02 a = b + c * 5;

Dans l’exemple précédent, deux variables d'un type fondamental (int) sont appliquées à l'opérateur
d'addition, puis le résultat de l’opération est appliqué à l'opérateur d'affectation. Bien que la signification
de ces opérations soit évidente pour les types simples, elle peut ne pas l'être pour les types classe.

Exemple 2.
Listing 4.2 : opération sur des types classes (code erroné à compléter)
01 #include <iostream>
02 using namespace std;
03
04 class Vecteur {
05 int x,y;
06 public:
07 Vecteur (){}
08 Vecteur (int a,int b) : x(a), y(b) {};
09 double get_x(){return x;};
10 double get_y(){return y;};
11 }
12
13 int main () {
14 Vecteur v1 (2,4);
15 Vecteur v2 (3,6);
16 Vecteur v;
17 v = v1 + v2;
18 cout << result.get_x() << ',' << result.get_y() << endl;
19 return 0;
20 }

Dans le code précèdent, il n'est pas évident de prédire le comportement de l'opération d'addition sur les
objets v1 et v2. En fait, ce code à lui seul est faux et génère une erreur de compilation, car la classe
Vecteur n'a pas de comportement prédéfini pour les additions. Pour résoudre ce problème, le C ++
permet la surcharge de la plupart des opérateurs afin que leur comportement puisse être redéfini pour
n'importe quel autre type de classes. La liste des opérateurs qui peuvent être surchargés est donnée dans
le tableau suivant :

1
 Tableau 4.1 : les opérateurs pouvant être surchargés
+ - * / = < > += -= *= /= << >>
<<= >>= == != <= >= ++ -- % & ^ ! |
~ &= ^= |= && || %= [] () , ->* -> new
delete new[] delete[]

Les opérateurs sont surchargés via des fonctions-opérateurs, leur nom commence par le mot-clé
operator suivi du l’opérateur qui est surchargé. La syntaxe complète est la suivante :

type operator opérateur(paramètres) {} ;

Dans l’exemple 4.2., l'opération d'addition de deux vecteurs est définie comme l'addition à la fois de de
leurs premières composantes (v1.x + v2.x) et de leurs deuxièmes composantes (v1.y + v2.y). Cela peut
être implémenté comme suit :
Listing 4.4 : opération sur des types classes (code complet)
01 #include <iostream>
02 using namespace std;
03
04 class Vecteur {
05 int x,y;
06 public:
07 Vecteur (){}
08 Vecteur (int a,int b) : x(a), y(b) {};
09 double get_x(){return x;};
10 double get_y(){return y;};
11 Vector operator + (const Vector&);
12 }
13
14 Vector Vecteur::operator + (const Vector& v)
15 {
16 Vecteur w(x+v.get_x(), y+v.get_y());
17 return w;
18 };
19
20 int main () {
21 Vecteur v1 (2,4);
22 Vecteur v2 (3,6);
23 Vecteur v;
24 v = v1 + v2;
25 cout << result.get_x() << ',' << result.get_y() << endl;
26 return 0;
27 }

La fonction operator+ de la classe Vecteur surcharge l'opérateur d'addition (+). Une fois déclarée,
cette fonction peut être appelée soit implicitement à l'aide de l'opérateur +, soit explicitement à l'aide de
son nom operator+.
Listing 4.5 : utilisation de la fonction operator+
01 Vecteur a, b;
02 Vecteur c(5,6);
03 Vecteur d(4,7);
04 a = c + d;
05 b = c.operator+(d);

2
2. Mot clé this
En C++ (comme dans la majorité des langages de programmation orientée objet), le mot-clé this
représente un pointeur sur l'objet qui a appelé la fonction membre qui est en cours d'exécution. Il est
généralement utilisé dans la fonction membre d'une classe pour faire référence à l'objet lui-même.
Exemple 3.
Dans la classe Vecteur définie précédemment, on essaye de surcharger l’opérateur d’affectation (=)
tel que w=v implique la copie de tous les attributs de v dans w.
Listing 4.6 : definition de la fonction operator=
01 Vecteur& Vecteur::operator=(const Vector& v)
02 {
03 x=v.get_x();
04 y= v.get_x();
05 return *this;
06 }

3. Membres statiques
Les attributs statiques d'une classe sont également connus comme les variables de classe, étant donné
que ce sont des variables communes (partageant la même valeur) pour tous les objets de cette même
classe.
Exemple 4.
Déclarer une classe donnée A qui contient comme attribut un compteur cpt permettant de calculer le
nombre d’objets de cette classe créés.
Listing 4.7 : Manipulation des membres statiques
01 #include <iostream>
02 using namespace std;
03
04 class A {
05 public:
06 static int cpt;
07 A () { n++; };
08 };
09
10 int A::cpt=0;
11
12 int main () {
13 A a;
14 A b[100];
15 cout << a.cpt << endl;
16 A * c = new A();
17 cout << A::cpt << endl;
18 return 0;
19 }

Les attributs statiques peuvent être manipulés comme les variables non membres tout en bénéficiant de
la portée de la classe.
Les attributs statiques ne peuvent pas être initialisés directement depuis la classe, mais doivent être
initialisés en dehors des classes.

3
4. Classes templates
C++ permet de créer des modèles de classes (templates), permettant aux classes d'avoir des membres
(attributs et méthodes) utilisant les paramètres du modèle comme types.
Exemple 5.
Listing 4.8 : Class template
01 template <class T>
02 class Triplet {
03 T val [3];
04 public:
05 Triplet (T v1, T v2, T v3)
06 {
07 val[0]=v1;
08 val[1]=v2;
09 val[2]=v3;
10 }
11 };

La classe Triplet est utilisée pour stocker trois éléments de tout type valide. Par exemple, pour déclarer
un objet de type Triplet permettant de stocker trois valeurs entières de type int, ayant comme valeurs 10,
20 et 30, nous écririons :
Triplet<int> t1 (10,20,30);
Cette même classe peut être utilisée pour instancier un objet permettant de stocker trois valeurs de tout
autre type. Exemple :

Triplet<double> t2 (1.50, 2.50, 3.14);