Discussion :

[Tsuna]

Bonjour, J'aurai donc une petite questions car en ayant chercher sur internet et ne voyant pas grand chose j'aimerais savoir comme indiqué dans mon intitulé, qu'es qu'est le polymorphisme d'héritage, comment l'utiliser (pourquoi, dans quel cas).

Cordialement.

[metagoto]

En C++, tout du moins, le polymorphisme d’héritage est ce que l'on appelle communément "le polymorphisme". Historiquement c'est un peu la raison principale pour laquelle le C++ a été crée.

En fait il y a divers types de polymorphisme et divers types d’héritage. C'est un vaste sujet et le mieux est de consulter la FAQ.

Chapitres 4 et 6 de la FAQ
http://cpp.developpez.com/faq/cpp/

[koala01]

Salut,

Comme metagoto l'a si bien dit, le polymorphisme d'héritage correspond à ce que l'on appelle plus simplement le polymorphisme, tout simplement, bien que le terme correct soit en réalité le polymorphisme d'inclusion.

C'est, pour faire simple, le fait de pouvoir obtenir un comportement adapté au type réel ("dynamique") d'un objet, alors que l'utilisateur connait l'objet comme étant un pointeur ou une référence sur le type de base (la classe "mère" du type réel).

La manière de l'utiliser en C++ est *relativement* simple, mais nécessite trois points:

1. Le type réel doit hériter publiquement du type de base
2. La fonction polymorphe doit être connue dans le type de base comme étant une fonction virtuelle
3. l'objet doit être manipulé sous la forme d'une référence (éventuellement constante) ou sous la forme d'un pointeur

En gros, si tu as une classe de base A qui prend la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class A{
    public:
        /* ceci est une fonction polymorphe, le comportement
         * peut etre adapté dans les types dérivés
         */
        virtual void foo() const { std::cout<<"je suis un A"<<std::endl;}
        /* cette fonction n'est pas polymorphe: on défini une bonne fois
         * pour toutes le comportement qu'elle doit avoir
         */
        void bar(){/* ... */}
};

tu pourras profiter du polymorphisme d'inclusion avec ta classe B si elle prend la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
class B : public A { //héritage publique OBLIGATOIRE
    public:
        /* on adapte le comportement de foo() */
        /*virtual */ void foo() const{std::cout<<"je suis un B"<<std::endl;}
       /* on ne peut pas redéfinir le  comportement de bar */
};

et pour autant que l'objet de type B soit manipulé sous la forme d'un pointeur ou d'une référence(éventuellement constante) sur un objet de type A:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/* cette fonction considérera ton objet de type B comme étant de type
 * A et est particulièrement dangereuse à l'emploi (slicing)
 */
void nonPolymporhe( A a){
   a.foo(); // affichera toujours "je suis un A" quoi qu'il advienne
}
/* ici, nous pouvons utiliser le polymoprhisme parce qu'on utilise une référence*/
void polymorphByRef( A /*const */ & a){
   a.foo(); // affichera "je suis un A" si c'est vraiment un A qui est fourni en paramètre 
            // et "je suis un B" si c'est en fait un B 
}
/* Meme chose, mais transmission par pointeur */
void polymorphByPtr( A * a){
   a.foo(); // affichera "je suis un A" si c'est vraiment un A qui est fourni en paramètre 
            // et "je suis un B" si c'est en fait un B 
}
int main(){
    A a;
    B b;
    nonPolymporhe(a);
    nonPolymporhe(b);
    polymorphByRef(a);
    polymorphByRef(b);
    polymorphByPtr(&a);
    polymorphByPtr(&b);
};

[Tsuna]

Merci beaucoup pour vos explication je vais essayer de comprendre tout sa en détail et revenir vous voir si je ne saisie pas une notions.