création dynamique d’un nouvel emplacement dans lequel on recopie les valeurs de
l’emplacement désigné par a ;
mise en place des valeurs des membres donnée de b.
Si a et b désignent le même objet (on s’en assurera dans l’opérateur d’affectation, en
comparant les adresses des objets concernés), on évitera d’appliquer ce mécanisme qui
conduirait à un emplacement dynamique pointé par « personne », et qui, donc, ne
pourrait jamais être libéré. En fait, on se contentera de... ne rien faire !
Par ailleurs, pour que l’affectation multiple (telle que c = b = a) fonctionne
correctement, il est nécessaire que notre opérateur renvoie une valeur de retour (elle
sera de type set_int) représentant la valeur de son premier opérande (après affectation,
c’est-à-dire la valeur de b après b = a).
Voici ce que pourrait être la définition de notre fonction operator = (en ce qui concerne
la déclaration de la classe set_int, il suffirait d’y ajouter set_int & operator = (set_int &) :
set_int & set_int::operator = (set_int & e) // ou : const set_int & e
// surdéfinition de l'affectation - les commentaires correspondent à b = a
{
if (this != &e) // on ne fait rien pour a = a
{ delete adval ; // libération partie dynamique de b
adval = new int [nmax = e.nmax] ; // allocation nouvel ensemble
// pour a
nelem = e.nelem ; // dans lequel on recopie
int i ; // entièrement l'ensemble b
for (i=0 ; i
}
return * this ;
}
1. On associera obligatoirement const à la transmission par référence, si l’on souhaite
pouvoir appliquer l’affectation à une expression de type set_int. Cela n’est pas
nécessairement justifié ici.
2. Une telle surdéfinition d’un opérateur d’affectation pour une classe possédant des
parties dynamiques ne sera valable que si elle est associée à une surdéfinition
comparable du constructeur par recopie (pour la classe set_int, celle proposée dans
la solution de l’exercice 26 convient parfaitement).
3. A priori, seule la valeur du premier opérande a vraiment besoin d’être transmise par
référence (pour que = puisse le modifier !) ; cette condition est obligatoirement
remplie puisque notre opérateur doit être surdéfini comme fonction membre.
Toutefois, en pratique, on utilisera également la transmission par référence, à la fois
pour le second opérande et pour la valeur de retour, de façon à être plus efficace (en
206
l’emplacement désigné par a ;
mise en place des valeurs des membres donnée de b.
Si a et b désignent le même objet (on s’en assurera dans l’opérateur d’affectation, en
comparant les adresses des objets concernés), on évitera d’appliquer ce mécanisme qui
conduirait à un emplacement dynamique pointé par « personne », et qui, donc, ne
pourrait jamais être libéré. En fait, on se contentera de... ne rien faire !
Par ailleurs, pour que l’affectation multiple (telle que c = b = a) fonctionne
correctement, il est nécessaire que notre opérateur renvoie une valeur de retour (elle
sera de type set_int) représentant la valeur de son premier opérande (après affectation,
c’est-à-dire la valeur de b après b = a).
Voici ce que pourrait être la définition de notre fonction operator = (en ce qui concerne
la déclaration de la classe set_int, il suffirait d’y ajouter set_int & operator = (set_int &) :
set_int & set_int::operator = (set_int & e) // ou : const set_int & e
// surdéfinition de l'affectation - les commentaires correspondent à b = a
{
if (this != &e) // on ne fait rien pour a = a
{ delete adval ; // libération partie dynamique de b
adval = new int [nmax = e.nmax] ; // allocation nouvel ensemble
// pour a
nelem = e.nelem ; // dans lequel on recopie
int i ; // entièrement l'ensemble b
for (i=0 ; i
}
return * this ;
}
1. On associera obligatoirement const à la transmission par référence, si l’on souhaite
pouvoir appliquer l’affectation à une expression de type set_int. Cela n’est pas
nécessairement justifié ici.
2. Une telle surdéfinition d’un opérateur d’affectation pour une classe possédant des
parties dynamiques ne sera valable que si elle est associée à une surdéfinition
comparable du constructeur par recopie (pour la classe set_int, celle proposée dans
la solution de l’exercice 26 convient parfaitement).
3. A priori, seule la valeur du premier opérande a vraiment besoin d’être transmise par
référence (pour que = puisse le modifier !) ; cette condition est obligatoirement
remplie puisque notre opérateur doit être surdéfini comme fonction membre.
Toutefois, en pratique, on utilisera également la transmission par référence, à la fois
pour le second opérande et pour la valeur de retour, de façon à être plus efficace (en
206