Héritage cpp redéfinition

[ridazero]

Lorsqu' une fonction membre est définie dans une classe, elle masque toutes les
fonctions membres de même nom de la classe de base (et des classes ascendantes).
Autrement dit, la recherche d’une fonction (surdéfinie ou non) se fait dans une
seule portée, soit celle de la classe concernée, soit celle de la classe de base (ou
d’une classe ascendante), mais jamais dans plusieurs classes à la fois.

j'ai pas compris la phrase souligner

[PilloBuenaGente]

(bonsoir)
Une classe de base se nommant animal, parent de chien, chat...contenant un prénom.
Si tu veux récupérer le prénom, soit :

Code :

animal.GetNom();

ou :

Code :

chien.GetNom();

Mais tu n'auras jamais les deux en même temps car elles renvoient à la même fonction.

[zhouyu]

Salut.
Ce qu'il explique c'est que tu n'as accès qu'a une instance de ta méthode en fonction de la classe que tu utilises.
Exemple :

Code :

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
27
28
29
 
    public class A
    {
        public void affiche()
        {
            printf("A \n");
        }
    }
 
    public class B : A
    {
        public void affiche()
        {
            printf("B  \n");
        }
    }
 
    public class C : B
    {
    }
 
    public class D : C
    {
        public void affiche()
        {
            C::affiche();//pas sur de la syntaxe
            printf("D  \n");
        }
    }

Une méthode affiche est défini dans la classe mère A.
Dans B on la redéfinit ce qui fait qu'on a plus accès à la méthode affiche de base.
Dans C on n'y touche pas, donc à l'appelle de la méthode affiche, il regarde dans C, rien, il remonte dans l'arbre d'héritage, une méthode affiche est défini dans B, il appelle cette version de affiche.
Dans D, on veut garder le comportement du parent mais rajouter quelque chose, donc dans la redéfinition j'appelle la version du parent et je rajoute mes modifications.

[Bousk]

Quand tu manipules un objet il faut distinguer 2 choses
- son type statique
- son type dynamique
Ils peuvent être différents quand on manipule un pointeur ou référence, ils sont identiques sinon.
Avec la virtualité et le typage dynamique on crée des interfaces et on fait ce qu'on apelle polymorphisme.

Code :

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
27
28
29
30
31
32
33
34
struct A { void Do() { std::cout<<"je suis A"<<std::endl; } virtual void Do2() { std::cout<<"je suis A::Do2"<<std::endl; } };
struct B : A {};
struct C : A { void Do() { std::cout<<"je suis C"<<std::endl; } virtual void Do2() { std::cout<<"je suis C::Do2"<<std::endl; } };
struct D : C { void Do() { std::cout<<"je suis D et "<<C::Do(); } virtual void Do2() { std::cout<<"je suis D::Do2 et"<<C::Do2(); } };
 
int main() {
A a;
B b;
C c;
D d;
a.Do(); // je suis A
a.Do2(); // je suis A::Do2
b.Do(); // je suis A
b.Do2(); // je suis A::Do2
c.Do(); // je suis C
c.Do2(); // je suis C::Do2
d.Do(); // je suis D et je suis C
d.Do2(); // je suis D::Do2 et je suis C::Do2
A* ptrA = &a;
ptrA->Do(); // je suis A
ptrA->Do2(); // je suis A::Do2
ptrA = &b;
ptrA->Do(); // je suis A
ptrA->Do2(); // je suis A::Do2
ptrA = &c;
ptrA->Do(); // je suis A
ptrA->Do2(); // je suis C::Do2
A& refA = d;
refA.Do(); // je suis A
refA.Do2(); // je suis D::Do2 et je suis C::Do2
A aD = d;
aD.Do(); // je suis A
aD.Do2(); // je suis A::Do2
}