Discussion :

[F0ul]

Bonjour
Mon projet comporte 4 classes liées de la manière suivante :
D -----> C ----- > A
D -----> B ----- > A
où une flèche signifie : héritage public de

Premier problème :
Quand je crée un objet D, comment faire pour qu'il n'appelle pas deux fois le constructeur de la classe A ?

Ensuite j'ai le code suivant :

Code :

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

1
2
3
4
A b = B();
A c = C();
b.afficher();
c.afficher();

Second problème :
Comment faire pour que lorsque je fais b.afficher() ça appelle la fonction B::afficher() (alors que dans ce cas cela appelle A::afficher()) ?

Merci d'avance pour votre aide

[Médinoc]

Premier problème: Cas classique d'héritage en losange. Voir "classes de base virtuelles".

Second problème: Tu dois travailler par référence (ou pointeur) et non par valeur. Avec ce code, tu ne fais que recopier la partie A de tes objets dans de nouveaux objets de type A.

Pour éviter cela, tu devrais déclarer protected le constructeur de copie de A.

[0ColdZero0]

Je peux peut-être répondre à ta seconde question. L'héritage ainsi que le polymorphisme permet aux classes de remonter la hiérarchie si elle ne trouve pas la méthode demandé de sa classe. Donc, pour que B appel sa méthode à lui Afficher(), tu dois la créer dans la classe A ainsi que dans la classe B. De ce fait, lorsque tu appel la fonction afficher par b.afficher(), il va trouver la méthode afficher de la classe B, si elle n'existe pas, elle va donc remonté pour choisir la méthode afficher de la classe A.

[F0ul]

J'ai donc fait mes classes de la manière suivante :

Code :

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

1
2
3
4
class A {};
class B : public virtual A {};
class C : public virtual A {};
class D : public virtual B,public C {};

Je veux ensuite tester mon code mais toujours des erreurs :

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
int main(void)
{
A *tab[3];
 
B b = B();
tab[0] = &b;
 
C c = C();
tab[1] = &c;
 
D d = D();
tab[2] = &d;
 
tab[0]->affiche();
// Appel à A::affiche()
 
tab[1]->affiche();
// Appel à A::affiche()
 
tab[2]->affiche();
// Appel à A::affiche()
 
return 0;
}

[Médinoc]

Pour ta première erreur, c'est bizarre (je ne pensais pas avoir ça avec l'héritage virtuel).
Pour la seconde, A::affiche() doit être déclarée virtual.

[F0ul]

Oui effectivement j'avais déclarée cette fonction virtuelle au départ mais j'ai oublié de le remettre. Donc j'ai remis cela, ça appelle bien les bonnes fonctions maintenant.
Cependant un autre problème est arrivé entre temps

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class A {};
class B : public virtual A {};
class C : public virtual A {};
class D : public virtual B,public C {};
 
D d = D();
tab[2] = &d;
/* Appel au constructeur B()
 * Appel au constructeur C()
 * Appel au constructeur D()
 ** Il n'y a plus d'appel au constructeur A()
 */

[Médinoc]

C'est bizarre, normalement, le constructeur de A est appelé (mais tous les appels suivants sont ignorés).

[F0ul]

En fait j'arrive à faire fonctionner mon code si je fais appel au constructeur A lors de l'appel à celui de D. Peut être je ne m'exprime pas bien alors voici le code :

Code :

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

D::D(int a,int b) : A(a),B(b),C(b)

Bon, ça fonctionne mais je me demande juste si c'est bien correct de procéder comme tel ? ou si je risque d'avoir des problèmes ensuite ?

[koala01]

Salut,

Quand tu utilise l'héritage multiple, et que les classes "mères" héritent toutes d'une classe "ancêtre" de base, tu dois non seulement recourir à un héritage virtuel pour la classe ancêtre, mais aussi appeler le constructeur de cette classe dans toutes les classes dérivées (quel que soit le niveau de dérivation atteint), avant d'appeler le constructeur des classes "directement parentes"

La seule exception étant le fait que le constructeur de la classe ancêtre rende la classe défaut constructible (ne nécessitant aucun argument).

La raison est simple: en déclarant l'héritage virtuel, cela revient - entre autres -à dire au compilateur quelque chose comme

Attention, ce n'est pas forcément la classe qui hérite directement qui devra se charger de l'initialisation de la classe de base

Or, les classes sont naturellement paresseuses, et il suffit qu'on leur dise que "quelqu'un d'autre" se charge peut-être de faire leur travail (ici, invoquer le constructeur de la classe de base) pour qu'elle décide... de ne pas le faire si elle n'y sont pas obligées

Du coup, lorsque tu as B et C qui héritent de A et D qui hérite de B et de C, B se dit "pas besoin d'invoquer le constructeur de A, C ou D s'en chargeront" et C se dit la même chose concernant B et D...

Au final, il n'y a plus que D pour accepter de faire le travail

Ce comportement est - sommes toutes - assez logique: comme si B et C venaient à invoquer le constructeur de A, il y aurait au mieux double construction (dont une inutile), au pire, une construction qui ne correspond peut être pas au "plus petit commun" entre les besoins de B et ceux de C et qui puisse s'utiliser dans D... Donc, pour éviter ces deux problèmes, il faut que ce soit D qui se charge d'invoquer le constructeur de A

[F0ul]

Super merci pour cet éclaircissement koala01 ... Et merci à Médinoc et 0ColdZero0 pour m'avoir aider à résoudre mes problèmes.

[3DArchi]

Quand tu utilise l'héritage multiple, et que les classes "mères" héritent toutes d'une classe "ancêtre" de base, tu dois non seulement recourir à un héritage virtuel pour la classe ancêtre, mais aussi appeler le constructeur de cette classe dans toutes les classes dérivées (quel que soit le niveau de dérivation atteint), avant d'appeler le constructeur des classes "directement parentes"

Salut,
Il me semble qu'on n'est pas obligé d'appeler explicitement le constructeur de cette première classe de base dans toute la chaîne d'héritage.
Le constructeur de la classe virtuelle est appelé dès le début soit implicitement (constructeur par défaut de A) soit explicitement. Les appels présents pour le constructeur virtuel ancêtre dans les classes parentes ne sont pas appelés :

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
class A {
public:
   A(){std::cout<<"A"<<std::endl;}
   A(std::string org)
   {
      std::cout<<"A depuis "<<org<<std::endl;
   }
};
class B : public virtual A {
public:
   B():A("B")
   {std::cout<<"B"<<std::endl;}
 
};
class C : public virtual A {
   public:
   C():A("C")
   {std::cout<<"C"<<std::endl;}
};
class D : public B,public C {
   public:
   D()
   {std::cout<<"D"<<std::endl;}
   D(int):A("D")
   {
      std::cout<<"D explicit"<<std::endl;
   }
};
 
int main()
{
std::cout<<"Un b"<<std::endl;
B b;
 
std::cout<<"Un C"<<std::endl;
C c;
 
std::cout<<"Un D"<<std::endl;
D d;
 
std::cout<<"Un D explicite "<<std::endl;
D d2(0);
   return 0;
}

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
Un b
A depuis B
B
Un C
A depuis C
C
Un D
A
B
C
D
Un D explicite
A depuis D
B
C
D explicit

[koala01]

Tu as arrêté ta lecture une ligne trop tôt: juste après, j'ai présenté l'exception des classes défaut-constructibles (dont le constructeur ne nécessite pas d'argument)

Mais il reste le problème que le constructeur ne nécessitant pas d'argument, s'il existe, peut s'avérer moins "intéressant" que celui qui en nécessite (des arguments) pour les classes dérivées et qu'il n'est pas forcément toujours opportun de rendre la classe défaut constructible

C'est la raison pour laquelle la règle de base est plutôt d'appeler explicitement le constructeur de la classe "ancêtre" dans le constructeur de toutes les classes qui en dérivent et que l'exception est le cas d'une classe ancêtre défaut constructible

[3DArchi]

Tu as arrêté ta lecture une ligne trop tôt: juste après, j'ai présenté l'exception des classes défaut-constructibles (dont le constructeur ne nécessite pas d'argument)

Oups Faut dire que vu la longueur, je lis souvent en diagonal, ce qui est, le preuve en est, un tort.

Mais il reste le problème que le constructeur ne nécessitant pas d'argument, s'il existe, peut s'avérer moins "intéressant" que celui qui en nécessite (des arguments) pour les classes dérivées et qu'il n'est pas forcément toujours opportun de rendre la classe défaut constructible

C'est la raison pour laquelle la règle de base est plutôt d'appeler explicitement le constructeur de la classe "ancêtre" dans le constructeur de toutes les classes qui en dérivent et que l'exception est le cas d'une classe ancêtre défaut constructible

Pour abonder dans ton sens je dirais 2 choses:
1/ Il faut bien comprendre avec l'héritage virtuel que l'appel au constructeur de la classe ancêtre se fait au niveau de la classe effectivement instanciée et pas sur une des classes intermédiaires (dans mon exemple, au niveau de D et ni au niveau de B ou C),
2/ Si, dans la hiérarchie, à un moment, on a décidé qu'il fallait appeler un constructeur spécialisé, il y a peu de chance qu'en descendant les raisons aient changées...

[koala01]

Oups Faut dire que vu la longueur, je lis souvent en diagonal, ce qui est, le preuve en est, un tort.

Ne t'en fais pas... ca m'arrive aussi

Pour abonder dans ton sens je dirais 2 choses:
<snip>
2/ Si, dans la hiérarchie, à un moment, on a décidé qu'il fallait appeler un constructeur spécialisé, il y a peu de chance qu'en descendant les raisons aient changées...

Le fait est que, dans l'exemple, B pourrait (après tout pourquoi pas) utiliser le constructeur de A ne prenant pas d'argument et C celui qui en prend un (ou plusieurs), ou l'inverse...

Dés lors, seul le développeur est en mesure de déterminer quel sera le constructeur de A le plus adapté à D qui hérite à la fois de B et de C

Il n'existe en effet aucune règle pour permettre au compilateur de le décider tout seul