Discussion :

[Spandelles]

Bonjour !
Je me noie un peu dans l'heritage, pouvez vous m'aider ?
J'explique mon probleme :
J'ai une classe A
Puis une classe B qui hérite de A
Puis une classe C qui herite de A
et enfin une classe D qui herite de B et C
Si j'ai bien tout suivi, il faut que je declare B et C en heritage virtuel sinon j'aurais deux A dans mes objets D, c'est ça ?
Donc j'ai fait

Code :

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

1
2
3
4
5
6
7
8
class B : virtual public A
{
...
}
class C : virtual public A
{
...
}

Ca marche.
Maintenant je manipule des B*, des C* et des D* en tant que A* (je manipule une liste contenant des A*)
J'ai compris qu'il fallait des fonctions virtuelles pour mes affichages par exemple, tout ça ça marche bien.
Là où ça marche pas, c'est quand je veux utiliser une methode de B ou de C. J'ai par exemple une methode publique fb() dans ma classe B
et mon pointeur A* pa
si j'appelle pa->fb() le compilo me dit que la fonction n'est pas déclarée
alors j'essaye un
((B*)pa)->fb()
et il me dit : cannot convert from base `A' to derived type `B' via virtual base `A'
donc il peut pas car c'est un heritage virtuel ?
Alors comment je fais ?
Merci d'avance pour vos réponses.

[dtrosset]

Bonjour,

Non. Tu ne peux pas.

La seule solution, c'est de déclarer la fonction membre de la classe B comme virtuelle pure dans la classe A.

Didier

[Spandelles]

Merci beaucoup !

[3DArchi]

Bonjour et bienvenu,
dynamic_cast? Cependant lire ça, mais surtout ç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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
class A
{
public:
   void fn_A()
   {
      std::cout<<"A"<<std::endl;
   }
   virtual void cestqui()
   {
      std::cout<<"c'est A"<<std::endl;
   }
};
 
class B: virtual public A
{
public:
   void fn_B()
   {
      std::cout<<"B"<<std::endl;
   }
   virtual void cestqui()
   {
      std::cout<<"c'est B"<<std::endl;
   }
};
 
class C: virtual public A
{
public:
   void fn_C()
   {
      std::cout<<"C"<<std::endl;
   }
   virtual void cestqui()
   {
      std::cout<<"c'est C"<<std::endl;
   }
};
 
class D: public B, public C
{
public:
   void fn_D()
   {
      std::cout<<"D"<<std::endl;
   }
   virtual void cestqui()
   {
      std::cout<<"c'est D"<<std::endl;
   }
};
 
void Fonction(A*p_a)
{
   p_a->cestqui();
   if(dynamic_cast<D*>(p_a)){
      dynamic_cast<D*>(p_a)->fn_D();
   }
   else
   if(dynamic_cast<B*>(p_a)){
      dynamic_cast<B*>(p_a)->fn_B();
   }
   else
   if(dynamic_cast<C*>(p_a)){
      dynamic_cast<C*>(p_a)->fn_C();
   }
   else{
      p_a->fn_A();
   }
}
 
 
int main()
{
   A a;
   B b;
   C c;
   D d;
   Fonction(&a);
   Fonction(&b);
   Fonction(&c);
   Fonction(&d);
   return getchar();
}

[koala01]

Salut, et bienvenue sur le forum.

Déjà, il serait sans doute intéressant de se poser la question de savoir s'il est vraiment nécessaire de la classe D dans ton exemple hérite des classes B et C...

En effet, il faut toujours se rappeler que l'héritage est la relation la plus forte qui puisse exister entre deux classe: c'est la relation qui permet - d'un point de vue sémantique - de dire que la classe enfant est un objet de la classe parent.

Il faudrait donc voir quelles sont les classes réellement créées, mais tu te rend bien compte que les cas où une classe doit hériter de plusieurs types sont donc déjà *relativement* rares, et que les cas où il se fait que ces différents types doivent hériter d'une classe identiques deviennent... l'exception à une exception.

Je ne dis absolument pas qu'il faut renoncer à l'héritage multiple et / ou à l'héritage virtuel, je dis - simplement - qu'il faut veiller à ce qu'il soit réellement nécessaire

Si donc tu pouvais nous donner quelques explications supplémentaires sur l'implémentation réelle, nous pourrions peut être en arriver à te dire si tu te trouve dans un cas où l'héritage multiple virtuel est réellement la meilleure solution