7.8. Constructeurs et destructeurs

7.8.1. Déclaration des constructeurs et des destructeurs

Le constructeur se définit comme une méthode normale. Cependant, pour que le compilateur puisse la reconnaître en tant que constructeur, les deux conditions suivantes doivent être vérifiées :

• elle doit porter le même nom que la classe ;

• elle ne doit avoir aucun type, pas même le type void.

Le destructeur doit également respecter ces règles. Pour le différencier du constructeur, son nom sera toujours précédé du signe tilde ('~').

Un constructeur est appelé automatiquement lors de l'instanciation de l'objet. Le destructeur est appelé automatiquement lors de sa destruction. Cette destruction a lieu lors de la sortie du bloc de portée courante pour les objets de classe de stockage auto. Pour les objets alloués dynamiquement, le constructeur et le destructeur sont appelés automatiquement par les expressions qui utilisent les opérateurs new, new[], delete et delete[]. C'est pour cela qu'il est recommandé de les utiliser à la place des fonctions malloc et free du C pour faire une création dynamique d'objets. De plus, il ne faut pas utiliser delete ou delete[] sur des pointeurs de type void, car il n'existe pas d'objets de type void. Le compilateur ne peut donc pas déterminer quel est le destructeur à appeler avec ce type de pointeurs.

Le constructeur est appelé après l'allocation de la mémoire de l'objet et le destructeur est appelé avant la libération de cette mémoire. La gestion de l'allocation dynamique de mémoire avec les classes est ainsi simplifiée. Dans le cas des tableaux, l'ordre de construction est celui des adresses croissantes, et l'ordre de destruction est celui des adresses décroissantes. C'est dans cet ordre que les constructeurs et destructeurs de chaque élément du tableau sont appelés.

Les constructeurs pourront avoir des paramètres. Ils peuvent donc être surchargés, mais pas les destructeurs (cela signifie qu'en pratique, on connaît le contexte dans lequel un objet est créé, mais qu'on ne peut pas connaître le contexte dans lequel il est détruit : il ne peut donc y avoir qu'un seul destructeur).

class chaine   // Implémente une chaîne de caractères.
{
    char * s;   // Le pointeur sur la chaîne de caractères.

public:
    chaine(void);           // Le constructeur par défaut.
    chaine(unsigned int);   // Le constructeur. Il n'a pas de type.
    ~chaine(void);          // Le destructeur.
};

chaine::chaine(void)
{
    s=NULL;                 // La chaîne est initialisée avec
    return ;                // le pointeur nul.
}

chaine::chaine(unsigned int Taille)
{
    s = new char[Taille+1]; // Alloue de la mémoire pour la chaîne.
    s[0]='\0';              // Initialise la chaîne à "".
    return;
}

chaine::~chaine(void)
{
    if (s!=NULL) delete s;   // Restitue la mémoire utilisée si
                             // nécessaire.
    return;
}

Pour passer les paramètres au constructeur, on donne la liste des paramètres entre parenthèses juste après le nom de l'objet lors de son instanciation :

chaine s1;        // Instancie une chaîne de caractères
                  // non initialisée.
chaine s2(200);   // Instancie une chaîne de caractères
                  // de 200 caractères.

Les constructeurs devront parfois effectuer des tâches plus compliquées que celles données dans cet exemple. En général, ils peuvent faire toutes les opérations faisables dans une méthode normale, sauf utiliser les données non initialisées bien entendu. En particulier, les données des sous-objets d'un objet ne sont pas initialisées tant que les constructeurs des classes de base ne sont pas appelés. C'est pour cela qu'il faut toujours appeler les constructeurs des classes de base avant d'exécuter le constructeur de la classe en cours d'instanciation.

Il faut spécifier ces constructeurs, sinon le compilateur appellera, par défaut, les constructeurs des classes mères qui prennent void pour paramètre (et si ceux-ci ne sont pas définis, les constructeurs par défaut, qui ne font rien).

Comment appeler les constructeurs et les destructeurs des classes mères lors de l'instanciation et de la destruction d'une classe dérivée ? Le compilateur ne peut en effet pas savoir quel constructeur il faut appeler parmi les différents constructeurs surchargés potentiellement présents... Pour appeler un autre constructeur d'une classe mère que le constructeur ne prenant pas de paramètres, il suffit de donner le nom de ce constructeur avec ses paramètres après le nom du constructeur de la classe fille, séparés par deux points (':').

En revanche, il est inutile de préciser le destructeur à appeler, puisque celui-ci est unique. Le programmeur ne doit donc pas appeler lui-même les destructeurs des classes mères, le langage s'en charge.

/* Déclaration de la classe mère. */

class Mere
{
    int m_i;
public:
    Mere(int);
    ~Mere(void);
};

/* Définition du constructeur de la classe mère. */

Mere::Mere(int i)
{
    m_i=i;
    printf("Exécution du constructeur de la classe mère.\n");
    return;
}

/* Définition du destructeur de la classe mère. */

Mere::~Mere(void)
{
    printf("Exécution du destructeur de la classe mère.\n");
    return;
}

/* Déclaration de la classe fille. */

class Fille : public Mere
{
public:
    Fille(void);
    ~Fille(void);
};

/* Définition du constructeur de la classe fille
   avec appel du constructeur de la classe mère. */

Fille::Fille(void) : Mere(2)
{
    printf("Exécution du constructeur de la classe fille.\n");
    return;
}

/* Définition du destructeur de la classe fille
   avec appel automatique du destructeur de la classe mère. */

Fille::~Fille(void)
{
    printf("Exécution du destructeur de la classe fille.\n");
    return;
}

Lors de l'instanciation d'un objet de la classe fille, le programme affichera dans l'ordre les messages suivants :

Exécution du constructeur de la classe mère.
Exécution du constructeur de la classe fille.

Exécution du destructeur de la classe fille.
Exécution du destructeur de la classe mère.

Si l'on n'avait pas précisé que le constructeur à appeler pour la classe Mere était le constructeur prenant un entier en paramètre, le constructeur par défaut aurait été appelé et seul le message de construction de la classe Fille aurait été affiché. Par ailleurs, on notera que l'ordre d'appel est important.

7.8.2. Constructeurs de copie

Il faudra parfois créer un constructeur de copie. Le but de ce type de constructeur est d'initialiser un objet lors de son instanciation à partir d'un autre objet. Toute classe dispose d'un constructeur de copie par défaut, dont le seul but est de recopier les champs de l'objet à recopier un à un dans les champs de l'objet à instancier.

Le constructeur par défaut ne suffira pas toujours, c'est pour cela que le programmeur devra parfois en fournir un. Ce sera notamment le cas lorsque certaines données des objets auront été allouées. Une copie brutale des champs d'un objet dans un autre ne ferait que recopier les pointeurs, pas les données pointées. Ainsi, la modification de ces données pour un objet entraînera la modification pour les données de l'autre objet.

La définition des constructeurs de copie se fait comme celle des constructeurs normaux. Le nom doit être celui de la classe, et il ne doit y avoir aucun type. Dans la liste des paramètres cependant, il devra toujours y avoir une référence sur l'objet à copier.

Pour la classe chaine définie ci-dessus, il faut un constructeur de copie. Celui-ci pourra être déclaré de la façon suivante :

chaine(const chaine &Source);

Si l'on rajoute la donnée membre Taille dans la déclaration de la classe, la définition de ce constructeur peut être :

chaine::chaine(const chaine &Source)
{
    int i = 0;                   // Compteur de caractères.
    Taille = Source.Taille;
    s = new char[Taille + 1];    // Effectue l'allocation.
    while ((s[i]=Source.s[i])!='\0') i=i+1;   // Recopie
                                 // la chaîne de caractères source
    return;
}

Le constructeur de copie est appelé dans toute instanciation avec initialisation, comme celles qui suivent :

chaine s2(s1);
chaine s2 = s1;

Dans les deux exemples, c'est le constructeur de copie qui est appelé. En particulier, à la deuxième ligne, le constructeur normal n'est pas appelé et aucune affectation entre objets n'a lieu.

7.8.3. Utilisation des constructeurs dans les transtypages

Les constructeurs sont utilisés dans les conversions de type dans lesquelles le type cible est celui de la classe du constructeur. Ces conversions peuvent être soit implicites (dans une expression), soit explicite (à l'aide d'un transtypage). Par défaut, les conversions implicites sont légales, pourvu qu'il existe un constructeur dont le premier paramètre a le même type que l'objet source. Par exemple, la classe Entier suivante :

class Entier
{
    int i;
public:
    Entier(int j)
    {
        i=j;
        return ;
    }
};

int j=2;
Entier e1, e2=j;
e1=j;

Si, pour une raison quelconque, ce comportement n'est pas souhaitable, on peut forcer le compilateur à n'accepter que les conversions explicites (à l'aide de transtypage). Pour cela, il suffit de placer le mot-clé explicit avant la déclaration du constructeur.

class Entier
{
    int i;
public:
    explicit Entier(int j)
    {
        i=j;
        return ;
    }
};

À présent, l'expression donnée ci-dessus n'est plus valide. Si l'on veut convertir l'entier en objet de classe Entier, on est maintenant forcé d'utiliser un transtypage explicite (ce qui donne l'origine du mot-clé). L'exemple précédent donne alors :

int j=2;
Entier e1, e2=(Entier) j;
e1=(Entier) j;