Ordre d'appel des constructeurs
Remonter à Constructeurs - Index
Lorsqu'une classe a une ou plusieurs classes de base, les constructeurs des classes de base sont appelés avant celui de la classe dérivée. Ils sont en outre appelés dans l'ordre de leur déclaration.
Par exemple, dans la définition,
class Y {...}
class X : public Y {...}
X one;
les constructeurs sont appelés dans l'ordre suivant :
Y(); // constructeur de la classe de base
X(); // constructeur de la classe dérivée
Dans le cas ou il y a plusieurs classes de base,
class X : public Y, public Z
X one;
les constructeurs sont appelés dans l'ordre de déclaration :
Y(); // les constructeurs des classes de base en premier
Z();
X();
Les constructeurs des classes de base virtuelles sont appelés avant toutes les autres classes de base non virtuelles. Si la hiérarchie contient plusieurs classes de base virtuelles, leurs constructeurs sont appelés dans l'ordre des déclarations des classes. Toute base non virtuelle est ensuite construite avant que le constructeur de classe dérivée ne soit appelé.
Si une classe virtuelle dérive d'une classe de base non virtuelle, celle-ci apparaît en premier, afin que la construction de la classe de base virtuelle soit correcte. Par exemple, le code :
class X : public Y, virtual public Z
X one;
produit l'ordre suivant :
Z(); // initialisation de classe de base virtuelle
Y(); // classe de base non virtuelle
X(); // classe dérivée
Voici un exemple plus complexe :
class base;
class base2;
class level1 : public base2, virtual public base;
class level2 : public base2, virtual public base;
class toplevel : public level1, virtual public level2;
toplevel view;
L'ordre de construction de view sera le suivant :
base(); // classe de base virtuelle la plus haute dans
// la hiérarchie ; base est construite une seule fois
base2(); // base non virtuelle de base virtuelle level2
// doit être appelée pour construire level2
level2(); // classe de base virtuelle
base2(); // base non virtuelle de level1
level1(); // autre base non virtuelle
toplevel();
Lorsqu'une hiérarchie de classe contient plusieurs instances d'une classe de base virtuelle, la classe de base n'est construite qu'une fois. Cependant, s'il existe plusieurs instances virtuelles et non virtuelles de la classe de base, le constructeur est appelé une seule fois pour toutes les instances virtuelles, et une autre fois pour chaque occurrence non virtuelle de la classe de base.
Les constructeurs appliqués à des éléments de tableau sont appelés dans l'ordre croissant des indices.