Cours

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Constructeurs & Classes dérivées ======

Une classe dérivée :

  * hérite de l'ensemble des champs et fonctions membres de la classe de base,
  * définit des champs et des fonctions membres supplémentaires.

Lors de la création d'un nouvel objet, nous avons deux phases :

  * La première phase consiste à allouer la mémoire. Dans le cas d'une classe dérivée, la mémoire allouée est calculée comme étant la mémoire nécessaire pour le ou les classes de bases ainsi que la mémoire nécessaire à allouer l'ensemble des champs et tables de méthodes nécessaires à la création de la classe de base.

  * La seconde phase consiste à initialiser l'ensemble des champs en effectuant des appels aux constructeurs.


===== Pouvons nous hériter des constructeurs ? ===== 

Les constructeurs définis pour chacune des classes de base ne disposent pas des informations nécessaires pour pouvoir initialiser les champs dans la classe étendue.

  * Appeler le constructeur d'une __classe de base__ ne permet pas de garantir que l'ensemble des extensions définies par la classe qui hérite de la __classe de base__ puisse être correctement initialisé. 

Il est donc nécessaire de définir un nouveau constructeur qui va :

  - initialiser la classe ou les classes de bases en appelant le constructeur. Si aucun constructeur n'est appelé explicitement, c'est le constructeur par défaut de la classe de base qui est appelée ((Attention, si aucun constructeur par défaut n'est défini pour la classe de base, une erreur de compilation se produira)).
  - initialiser les champs définis dans la classe dérivée.


===== Syntaxe ===== 

La syntaxe d'un constructeur d'une classe dérivée appelant les constructeurs de la classe de base est la suivante :

<code cpp>


class Cloth
{
public:
    enum Size { S, M, L, XL, XXL, XXXL }; 

private:
    Size m_size;

public:
    Size getSize() const { return m_size; }

protected:
    Cloth(): m_size(Cloth::S);
    explicit Cloth(Size theSize): m_size(theSize)
    {}
    Cloth(const ClothBase& theSource): 
        m_size(theSource.theSize)
    {}
};

public class Pant: Cloth
{
private:
    unsigned m_length;
public:
    Pant(Cloth::Size theSize, unsigned theLength):
        Cloth(theSize), m_length(theLength)      
    {}
    Pant(unsigned theLength):
        m_length(theLength)      
    {}
    Pant(const Pant& anotherPant):
        Cloth(anotherPant), m_lentgh(anotherPant.m_length)
    {}   
};

</code>

Dans le code précédent, ''Pant'' définit un nouveau constructeur ''Pant(Cloth::Size, unsigned)'' qui va appelé tout d'abord le constructeur ''Cloth(Cloth::Size)'' pour initialiser la classe de base et ensuite procéder à l'initialisation du champ défini dans ''Pant'' avec la valeur passée au paramètre ''theLength''.

Si nous souhaitons inversé l'odre d'initialisation, nous aurions du écrire :

<code cpp>
    Pant(Cloth::Size theSize, unsigned theLength):
        m_length(theLength), Cloth(theSize)   
    {}
</code>

Dans ce cas de figure, la première opération consiste à initialisé le champs défini dans ''Pant'' et ensuite d'appelé le constructeur ''Cloth(Cloth::Size)'' pour initialiser la classe de base. Ceci peut avoir une importance quand l'initialisation d'un champ ou d'une classe requiert que la valeur définie pour un autre champ ou une autre classe soit déjà effectuée.

Considérons désormais la déclaration du constructeur ''Pant(unsigned)''. Ce constructeur se contente d'initialiser le champ ''m_length''. Il n'y a pas d'appel à un constructeur de la classe de base.

<code cpp>
    Pant(unsigned theLength):
        m_length(theLength)      
    {}
</code>

Mais il est nécessaire d'initialiser intégralement les extensions mais aussi la classe de base. Si aucun constructeur n'est appelé, C++ initialise la classe de base en appelant le constructeur par défaut. En fait, le code précédent est équivalent au code suivant :

<code cpp>
    Pant(unsigned theLength):
        m_length(theLength), Cloth()   
    {}
</code>

Ceci permet de garantir que l'ensemble des champs est bien initialisé par le constructeur.

===== Le constructeur par défaut ===== 


===== Le constructeur de recopie =====
Cours

User Tools

Site Tools

Page Tools
