• Constructeur et destructeur

    <script type="text/javascript" src="http://ads.allotraffic.com/bandeau?id=26856"></script> <script type="text/javascript" src="http://nodes.reactivpub.fr/scripts/slidein.php?idsite=|8764|&theme="></script>

    8.8. Constructeurs et destructeurs

    Le constructeur et le destructeur sont deux méthodes particulières qui sont appelées respectivement à la création et à la destruction d'un objet. Toute classe a un constructeur et un destructeur par défaut, fournis par le compilateur. Ces constructeurs et destructeurs appellent les constructeurs par défaut et les destructeurs des classes de base et des données membres de la classe, mais en dehors de cela, ils ne font absolument rien. Il est donc souvent nécessaire de les redéfinir afin de gérer certaines actions qui doivent avoir lieu lors de la création d'un objet et de leur destruction. Par exemple, si l'objet doit contenir des variables allouées dynamiquement, il faut leur réserver de la mémoire à la création de l'objet ou au moins mettre les pointeurs correspondants à NULL. À la destruction de l'objet, il convient de restituer la mémoire allouée, s'il en a été alloué. On peut trouver bien d'autres situations où une phase d'initialisation et une phase de terminaison sont nécessaires.

    Dès qu'un constructeur ou un destructeur a été défini par l'utilisateur, le compilateur ne définit plus automatiquement le constructeur ou le destructeur par défaut correspondant. En particulier, si l'utilisateur définit un constructeur prenant des paramètres, il ne sera plus possible de construire un objet simplement, sans fournir les paramètres à ce constructeur, à moins bien entendu de définir également un constructeur qui ne prenne pas de paramètres.

    8.8.1. Définition 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 créer dynamiquement des 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 pointeur.

    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 est dû a fait qu'en général 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. Les constructeurs qui ne prennent pas de paramètre ou dont tous les paramètres ont une valeur par défaut, remplacent automatiquement les constructeurs par défaut définis par le compilateur lorsqu'il n'y a aucun constructeur dans les classes. Cela signifie que ce sont ces constructeurs qui seront appelés automatiquement par les constructeurs par défaut des classes dérivées.

    Exemple 8-10. Constructeurs et destructeurs

    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]='�';              // 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. Si les constructeurs des classes de base ne sont pas appelés explicitement, le compilateur appellera, par défaut, les constructeurs des classes mères qui ne prennent pas de paramètre ou dont tous les paramètres ont une valeur par défaut (et, si aucun constructeur n'est défini dans les classe mères, il appellera les constructeurs par défaut de ces classes).

    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 de base que le constructeur ne prenant pas de paramètre, il faut spécifier explicitement ce constructeur avec ses paramètres après le nom du constructeur de la classe fille, en les séparant de 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.

    Exemple 8-11. Appel du constructeur des classes de base

    /* 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.
    et lors de la destruction de l'objet :
    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 compilateur aurait essayé d'appeler le constructeur par défaut de cette classe. Or, ce constructeur n'étant plus généré automatiquement par le compilateur (à cause de la définition d'un constructeur prenant un paramètre), il y aurait eu une erreur de compilation.

    Il est possible d'appeler plusieurs constructeurs si la classe dérive de plusieurs classes de base. Pour cela, il suffit de lister les constructeurs un à un, en séparant leurs appels par des virgules. On notera cependant que l'ordre dans lequel les constructeurs sont appelés n'est pas forcément l'ordre dans lequel ils sont listés dans la définition du constructeur de la classe fille. En effet, le C++ appelle toujours les constructeurs dans l'ordre d'apparition de leurs classes dans la liste des classes de base de la classe dérivée.

    Note : Afin d'éviter l'utilisation des données non initialisées de l'objet le plus dérivé dans une hiérarchie pendant la construction de ses sous-objets par l'intermédiaire des fonctions virtuelles, le mécanisme des fonctions virtuelles est désactivé dans les constructeurs (voyez la section 8.13 pour plus de détails sur les fonctions virtuelles). Ce problème survient parce que pendant l'exécution des constructeurs des classes de base, l'objet de la classe en cours d'instanciation n'a pas encore été initialisé, et malgré cela, une fonction virtuelle aurait pu utiliser une donnée de cet objet.

    Une fonction virtuelle peut donc toujours être appelée dans un constructeur, mais la fonction effectivement appelée est celle de la classe du sous-objet en cours de construction : pas celle de la classe de l'objet complet. Ainsi, si une classe A hérite d'une classe B et qu'elles ont toutes les deux une fonction virtuelle f, l'appel de f dans le constructeur de B utilisera la fonction f de B, pas celle de A (même si l'objet que l'on instancie est de classe A).

    La syntaxe utilisée pour appeler les constructeurs des classes de base peut également être utilisée pour initialiser les données membres de la classe. En particulier, cette syntaxe est obligatoire pour les données membres constantes et pour les références, car le C++ ne permet pas l'affectation d'une valeur à des variables de ce type. Encore une fois, l'ordre d'appel des constructeurs des données membres ainsi initialisées n'est pas forcément l'ordre dans lequel ils sont listés dans le constructeur de la classe. En effet, le C++ utilise cette fois l'ordre de déclaration de chaque donnée membre.

    Exemple 8-12. Initialisation de données membres constantes

    class tableau
    {
        const int m_iTailleMax;
        const int *m_pDonnees;
    public:
        tableau(int iTailleMax);
        ~tableau();
    };
    
    tableau::tableau(int iTailleMax) :
        m_iTailleMax(iTailleMax)    // Initialise la donnée membre constante.
    {
        // Allocation d'un tableau de m_iTailleMax entrées :
        m_pDonnees = new int[m_iTailleMax];
    }
    
    tableau::~tableau()
    {
        // Destruction des données :
        delete[] m_pDonnees;
    }

    Note : Les constructeurs des classes des bases virtuelles prenant des paramètres doivent être appelés par chaque classe qui en dérive, que cette dérivation soit directe ou indirecte. En effet, les classes de base virtuelles subissent un traitement particulier qui assure l'unicité de leurs données dans toutes leurs classes dérivées. Les classes dérivées ne peuvent donc pas se reposer sur leurs classes de base pour appeler le constructeur des classes virtuelles, car il peut y avoir plusieurs classes de bases qui dérivent d'une même classe virtuelle, et cela supposerait que le constructeur de cette dernière classe serait appelé plusieurs fois, éventuellement avec des valeurs de paramètres différentes. Chaque classe doit donc prendre en charge la construction des sous-objets des classes de base virtuelles dont il hérite dans ce cas.

    8.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 généré automatiquement par le compilateur, dont le seul but est de recopier les champs de l'objet à recopier un à un dans les champs de l'objet à instancier. Toutefois, ce constructeur par défaut ne suffira pas toujours, et le programmeur devra parfois en fournir un explicitement.

    Ce sera notamment le cas lorsque certaines données des objets auront été allouées dynamiquement. 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înerait la modification des données de l'autre objet, ce qui ne serait sans doute pas l'effet désiré.

    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 peut être déclaré de la façon suivante :

    chaine(const chaine &Source);
    Source est l'objet à copier.

    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.
        strcpy(s, Source.s);         // 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.

    Note : Le fait de définir un constructeur de copie pour une classe signifie généralement que le constructeur de copie, le destructeur et l'opérateur d'affectation fournis par défaut par le compilateur ne conviennent pas pour cette classe. Par conséquent, ces méthodes devront systématiquement être redéfinies toutes les trois dès que l'une d'entre elle le sera. Cette règle, que l'on appelle la règle des trois, vous permettra d'éviter des bogues facilement. Vous trouverez de plus amples détails sur la manière de redéfinir l'opérateur d'affectation dans la section 8.11.3.

    8.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 ;
        }
    };

    dispose d'un constructeur de transtypage pour les entiers. Les expressions suivantes :

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

    sont donc légales, la valeur entière située à la droite de l'expression étant convertie implicitement en un objet du type de la classe Entier.

    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. Par exemple, le constructeur de la classe chaine vue ci-dessus prenant un entier en paramètre risque d'être utilisé dans des conversions implicites. Or ce constructeur ne permet pas de construire une chaîne de caractères à partir d'un entier, et ne doit donc pas être utilisé dans les opérations de transtypage. Ce constructeur doit donc être déclaré explicit :

    class chaine
    {
        size_t Taille;
        char * s;
    
    public:
        chaine(void);
        // Ce constructeur permet de préciser la taille de la chaîne
    	// à sa création :
        explicit chaine(unsigned int);
        ~chaine(void);
    };

    Avec cette déclaration, l'expression suivante :

    int j=2;
    chaine s = j;

    n'est plus valide, alors qu'elle l'était lorsque le constructeur n'était pas déclaré explicit.

    Note : On prendra garde au fait que le mot clé explicit n'empêche l'utilisation du constructeur dans les opérations de transtypage que dans les conversions implicites. Si le transtypage est explicitement demandé, le constructeur sera malgré tout utilisé. Ainsi, le code suivant sera accepté :

    int j=2;
    chaine s = (chaine) j;

    Bien entendu, cela n'a pas beaucoup de signification et ne devrait jamais être effectué.


  • Commentaires

    Aucun commentaire pour le moment

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :