Constructeurs de copie

Les constructeurs d’une classe donnée classe peuvent avoir n’importe quoi comme arguments, sauf des données de type classe. Ils peuvent avoir des pointeurs *classe comme arguments, ainsi que des références &classe. Cependant, dans ce dernier cas, le constructeur ne doit avoir qu’un seul argument &classe, et les autres arguments, s’il y en a, doivent avoir une valeur par défaut. Ce constructeur est alors appelé constructeur de copie. Il sert lors d’affectations du genre :

class classexmpl {     // champs ...     public :     classexmpl();              // constructeur par défaut     classexmpl(int i);         // un autre constructeur     classexmpl(classexmpl& c); // constructeur de copie     // méthodes...     };classexmpl c1;         // constructeur par défautclassexmpl c2 = c1;    // appel du constructeur de copie                        // équivaut à classexmpl c2(c1);

Toute classe a nécessairement un constructeur de copie. Lorsqu’aucun n’est défini explicitement, le compilateur en crée un automatiquement, qui se contente de recopier champ par champ l’argument dans this. Ce constructeur suffit dans les cas simples. Nous donnons un peu plus loin des exemples où il ne suffit pas.

Noter ce point très important : le constructeur de copie n’est appelé (comme tout constructeur) que lors d’une initialisation. De ce fait, si l’on écrit :

c2 = c1;

ce n’est pas ce constructeur qui est appelé, mais l’opérateur d’affectation =, qui par défaut recopie les champs un à un ; il faut également le redéfinir si nécessaire (voir chapitre 7). Cette remarque met en relief un fait essentiel qui est que lors des deux écritures :

exemple c2 = c1;  // appel du constructeur de copiec2 = c1          // appel de l'opérateur d'affectation;

l’opérateur d’affectation n’est appelé qu’une fois (la seconde), tandis que c’est le constructeur de copie qui est appelé la première fois. Si ces deux appels n’ont pas été différenciés jusqu’alors, c’est que par défaut ils provoquent le même effet ; il n’en est pas nécessairement ainsi dans des classes définies par un programmeur.

Pour la même raison, il faut comprendre que, lors de l’appel d’une fonction f(exemple ex) sous la forme f(e1), ce n’est pas une affectation qui est réalisée, malgré les apparences, sur l’argument ex, mais le constructeur de copie de nouveau ; ici aussi les effets peuvent être différents.

Précédent

Sommaire

Suivant