Héritage en C++

Cet article montre, à travers un exemple simple, comment fonctionne l’héritage. Considérons une classe Parent avec deux fonctions membres (fct1 et fct2). Notons que fct2 est virtuelle. Considérons maintenant une seconde classe Child (qui hérite de la classe Parent) qui contient aussi deux fonctions membres (fct1 et fct2). Toutes ces fonctions sont déclarées en protégées et peuvent être appelées grâce aux fonctions publiques callFunction1 et callFunction2 qui sont déclarées dans la classe Parent. La question est : que va-t-il se passer quand ces fonctions seront appelées de la classe Child ? Dans le cas de fct1, qui n’est pas virtuelle, c’est la fonction fct1 de la classe Parent qui est appelée. En revanche, dans le cas de fct2, qui est virtuelle, c’est la fonction qui est déclarée dans la classe Child qui est appelée. Notons que la fonction de la classe parent peut être appelée avec la syntaxe suivante : Parent::fct2(). Notons enfin que lors de l’instanciation de la classe Child, le constructeur de la classe Parent est appelé en premier. Le programme suivant illustre ces explications :

#include 


class Parent
{
public:
    Parent() {std::cout << "Constructor Parent" << std::endl;}

    void            callFunction1() { fct1(); }
    void            callFunction2() { fct2(); }

protected:
    void            fct1() 
    {   std::cout << "Class Parent :: function 1" << std::endl; }
    
    virtual void    fct2() 
    {   std::cout << "Class Parent :: function 2" << std::endl; }
};



class Child : public Parent
{
public:
    Child() {std::cout << "Constructor Child" << std::endl;}

protected:
    void            fct1() 
    {   std::cout << "Class Child :: function 1" << std::endl; }
    
    void            fct2() 
    {   std::cout << "Class Child :: function 2" << std::endl; 
        Parent::fct2(); }
};

int main()
{

    Child c;
    c.callFunction1();
    c.callFunction2();
    return 0;
}

Ce code affiche les lignes suivantes. Le constructeur parent est apellé avant le constructeur Child. Pour fct1, c'est la fonction de la classe Parent qui est appelée. Pour fct2, c'est la fonction de la classe Child qui est appelée car la fonction est virtuelle.

Constructor Parent
Constructor Child
Class Parent :: function 1
Class Child :: function 2
Class Parent :: function 2

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *