Apprendre C/C++ Étape par Étape - Page 15

15. Étape par Étape C/C++ — Programmation C++ - Surcharge d’Opérateurs

Surcharge d’Opérateurs

| | 1. Introduction

2. Opérateur
   • Règles de Surcharge d’Opérateurs
   • Restrictions sur la Surcharge d’Opérateurs
3. Surcharge des Opérateurs Unaires
4. Surcharge des Opérateurs Binaires
5. Surcharge d’Opérateurs avec des Chaînes |

1. Introduction

| | // Assigner une variable à une autre
#include
using namespace std;
int main()
{
int a = 10, b;
b = a; // valide
cout << b;
return 0;
} | // Assigner un objet à un autre
#include
using namespace std;
class emp
{
public:
int eno;
float sal;
};
int main()
{
emp e1= { 1001, 2300.45 },e2 ;
cout << endl << e1.eno << e1.sal;
e2 = e1; // valide
cout << endl << e2.eno << e2.sal;
return 0;
} |

Les expressions sont courantes dans chaque langage ; une expression est une collection d’opérandes et d’opérateurs. Tandis qu’une opération est une collection d’expressions.
Les deux programmes ci-dessus démontrent comment les variables/objets ont été assignés ensemble.

Les deux programmes sont valides, ils démontrent l’utilisation de l’opérateur égal à ( = ).

| | | |

La surcharge d’opérateurs est l’une des fonctionnalités les plus passionnantes de la programmation orientée objet. Elle est utilisée pour surmonter des situations comme l’opération de structure illégale ci-dessus. Elle peut transformer des listings de programmes complexes et obscurs en listings intuitivement évidents.

Grâce à la surcharge d’opérateurs, nous pouvons voir comment les opérateurs C++ normaux peuvent se voir attribuer de nouvelles significations lorsqu’ils sont appliqués à des types de données définis par l’utilisateur. Le mot-clé opérateur est utilisé pour surcharger un opérateur, et l’opérateur résultant adoptera la signification fournie par le programmeur.

Par exemple, en utilisant un objet, nous pouvons effectuer une opération d’assignation de chaîne directe.

| | // Programme pour assigner une chaîne à une autre
#include
#include
#include
using namespace std;
class string
{
char str;
public:
string() { }
string(char s) { str = s; }
void putstring()
{
cout << str;
}
};
int main()
{
string s1(“Ordinateur”);
string s2;
s2 = s1;
s2.putstring();
return 0;
} |

2. Opérateur

type operator symbole-opérateur ( liste-des-paramètres )

Le mot-clé operator déclare une fonction spécifiant ce que symbole-opérateur signifie lorsqu’il est appliqué aux instances d’une classe. Cela donne à l’opérateur plus d’une signification, ou le “surcharge”. Le compilateur distingue entre les différentes significations d’un opérateur en examinant les types de ses opérandes.

Règles de Surcharge d’Opérateurs

• Vous pouvez surcharger les opérateurs suivants :

| | ^= | &= | |= | << | >> | <<= | | | <= | >= | && | || | ++ | –– | | | ( ) | [ ] | new | delete | & | | | | | ~ | = | /= | %= | >>= | == | | | != | , | –> | –> | | |

• Si un opérateur peut être utilisé comme opérateur unaire ou binaire, vous pouvez surcharger chaque utilisation séparément.

• Vous pouvez surcharger un opérateur en utilisant soit une fonction membre non statique, soit une fonction globale qui est amie d’une classe. Une fonction globale doit avoir au moins un paramètre qui est de type classe ou une référence à un type classe.

• Si un opérateur unaire est surchargé en utilisant une fonction membre, il ne prend aucun argument. S’il est surchargé en utilisant une fonction globale, il prend un argument.

Si un opérateur binaire est surchargé en utilisant une fonction membre, il prend un argument. S’il est surchargé en utilisant une fonction globale, il prend deux arguments.

Restrictions sur la Surcharge d’Opérateurs

• Vous ne pouvez pas définir de nouveaux opérateurs, tels que **.

• Vous ne pouvez pas changer la priorité ou le regroupement d’un opérateur, ni changer le nombre d’opérandes qu’il accepte.

• Vous ne pouvez pas redéfinir la signification d’un opérateur lorsqu’il est appliqué à des types de données intégrés.

• Les opérateurs surchargés ne peuvent pas prendre d’arguments par défaut.

• Vous ne pouvez pas surcharger de symbole de préprocesseur, ni surcharger les opérateurs suivants :

| | . | .* | :: | ?: |

L’opérateur d’assignation a des restrictions supplémentaires. Il ne peut être surchargé que comme une fonction membre non statique, pas comme une fonction amie. C’est le seul opérateur qui ne peut pas être hérité ; une classe dérivée ne peut pas utiliser l’opérateur d’assignation d’une classe de base.

3. Surcharge des Opérateurs Unaires

Commençons par surcharger un opérateur unaire. Les opérateurs unaires agissent sur un seul opérande. (Un opérande est simplement une variable sur laquelle agit un opérateur). Des exemples d’opérateurs unaires sont les opérateurs d’incrément et de décrément ++ et –, et le moins unaire.

Exemple :
L’exemple suivant démontre l’utilisation de l’opérateur d’incrément ++.

| | #include
using namespace std;
class counter
{
private:
unsigned int count;
public:
counter(){ count = 0; }
int get_count()  { return count; }
counter operator ++()
{
count++;
counter temp;
temp.count = count;
return temp;
}
};
int main()
{
counter c1, c2;                            // c1 = 0,  c2 = 0
cout << “\nC1 = “ << c1.get_count();       // afficher
cout << “\nC2 = “ << c2.get_count();

++c1; // c1 = 1
c2 = ++c1 ; // c1 = 2, c2 = 2

cout << “\nC1 = “ << c1.get_count();       // afficher à nouveau
cout << “\nC2 = “ << c2++.get_count();     // c2 = 3
return 0;
} |

Un exemple de plus pour surcharger le moins unaire.

| | #include
using namespace std;
class subtract
{
int a;
int b;
public:
void getdata(int x, int y)
{
a = x; b = y;
}
void putdata()
{
cout<< endl << “A = “ << a <<”B = “ << b;
}
void operator -()
{
a = -a; b = -b;
}
};

int main()
{
subtract s;
s.getdata(34, -6);
cout << endl << “S : “;
s.putdata();
-s;
cout << endl << “S : “;
s.putdata();
return 0;
}
|

4. Surcharge des Opérateurs Binaires

Mais les opérateurs peuvent être surchargés tout aussi facilement que les opérateurs unaires.  Nous allons examiner des exemples qui surchargent les opérateurs arithmétiques, les opérateurs de comparaison et les opérateurs d’assignation arithmétique.

Nous venons de voir comment surcharger un opérateur unaire. Le même mécanisme peut être utilisé pour surcharger un opérateur binaire.

| | // Surcharge de l’opérateur +
#include
using namespace std;
class time
{
int hh; int mm; int ss;
public:
time( ) { }
time(int h, int m, int s)
{
hh =h; mm = m; ss = s;
}
void disp_time()
{
cout << endl << hh<< “ : “
<< mm << “ : “ << ss;
}
time operator+(time);
};

time time::operator+(time t)
{
time temp;
temp.hh = hh + t.hh;
temp.mm = mm + t.mm;
temp.ss = ss + t.ss;
return temp;
}

int main()
{
time t1(12,1,24) , t2(5, 23, 45), t3;
t3 = t1 + t2;
t3.disp_time();
return 0;
} |

5. Surcharge d’Opérateurs avec des Chaînes

C/C++ traite les chaînes de manière assez différente ; nous ne copions jamais, concaténons ou comparons des chaînes en utilisant des opérateurs comme d’autres langages. C/C++ a construit des fonctions pour effectuer les opérations ci-dessus. Mais C++ fournit la possibilité de tout faire sur des chaînes en utilisant des opérateurs. Cela signifie que nous devons fournir une responsabilité supplémentaire aux opérateurs pour effectuer de telles choses.

L’exemple suivant démontre la comparaison entre deux chaînes en utilisant l’opérateur de comparaison ==.

| | // Programme pour comparer deux chaînes en utilisant la surcharge d’opérateurs
#include
#include
#include
using namespace std;

enum boolean{ false, true };

class string
{
char str;
public:
string() { str = NULL; }
string(char *s) { str = s; }
int operator ==(string ts)
{
if (strcmp(str, ts.str) >= 0)
return true;
else
return false;
}
};

int main()
{
string s1(“Ordinateur”);
string s2(“Ordinateurs”);

if(s1 == s2)
cout << “Égal”;
else
cout << “Pas Égal”;

return 0;
} |

| | // concaténation de deux chaînes
#include
#include
#include
using namespace std;

class string
{
char str;
public:
string()
{
str = new char[30] ; str = NULL;
}
string(char *s) { str = s; }
string operator +(string ts)
{
string t;
strcat(t.str, str);
strcat(t.str, ts.str);
return t;
}
void putstring()
{
cout << endl << str;
}
};

int main()
{
string s1(“Ordinateur”); string s2(“Institut”);
s1.putstring(); s2.putstring();
string s3;

s3 = s1 + s2;

s3.putstring();
return 0;
} |

Réf : Programmation orientée objet dans Turbo C++ : Robert Lafore