Discussion :

[lokida]

Bonjour à tous,

Je suis face à un problème dont je n'arrive pas à trouver la solution.
J'ai le code suivant:

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
 
#include <iostream>
 
using namespace std;
 
 
////////////////////////////////////////////////////////
 
class A
{
 
public:
 
	A() { std::cout << "A BAD_0!" << std::endl; }
 
	A( unsigned int val )  { std::cout << "A BAD_1!" << std::endl; }
 
	A( float val_1, unsigned int val_2, unsigned int val_3 )  { std::cout << "A GOOD!" << std::endl; }
 
};
 
////////////////////////////////////////////////////////
 
class B : public A
{
public:
 
	B( unsigned int val = 0 ) : A( val ) 
	{ std::cout << "B BAD!" << std::endl; }
 
	B( float val_1, unsigned int val_2, unsigned int val_3 = 0) 
		: A( val_1, val_2, val_3 )
	{ std::cout << "B GOOD!" << std::endl; }
};
 
////////////////////////////////////////////////////////
 
//class C : public B // VERSION WITH NO PROBLEM
class C : public virtual B // VERSION WITH PROBLEM
{
public:
 
	C( unsigned int val = 0) : B( val ) 
	{ std::cout << "C BAD!" << std::endl; }
 
 
	C( float val_1,	unsigned int val_2, unsigned int val_3 = 0 ) 
		: B( val_1, val_2, val_3 )
	{ std::cout << "C GOOD!" << std::endl; }
 
};
 
////////////////////////////////////////////////////////
 
class D :  public virtual C
{
public:
 
 
	D( unsigned int val = 0) : C( val ) 
	{ std::cout << "D BAD!" << std::endl; }
 
	D( float val_1, unsigned int val_2, unsigned int val_3) 
		: C(val_1, val_2, val_3 )
	{ std::cout << "D GOOD!" << std::endl; }
};
 
////////////////////////////////////////////////////////
 
 
int main( int argc, char ** argv)
{
	D* d_instance = new D(1, 2, 3);
 
	std::cout << " ----" << std::endl;
 
	C* c_intance = new C(1, 2, 3 );
 
	getchar();
 
	return EXIT_SUCCESS;
}

Quand je l'exécute(sous linux avec g++ et sous windows avec visual C++) j'ai cette trace:

A BAD_1!
B BAD!
C GOOD!
D GOOD!
----
A GOOD!
B GOOD!
C GOOD!

Je ne comprends pas pourquoi pour D* d_instance = new D(1, 2, 3); il ne passe pas par les bons contructeurs.

Par contre si je remplace class C : public virtual B // VERSION WITH PROBLEM par class C : public B // VERSION WITH NO PROBLEM l'exécution est bonne. Il passe par les bons constructeurs.
voici la trace:
A GOOD!
B GOOD!
C GOOD!
D GOOD!
----
A GOOD!
B GOOD!
C GOOD!

Donc c'est le fait de déclarer la classe B comme virtuelle qui pose problème. Mais je ne vois pas en quoi !

J'ai bien trouvé cela http://www.greyc.ensicaen.fr/ensicaen/CPP/x2951.html Mais je ne me trouve pas dans ce cas de figure.

Si quelqu'un a une explication ! Merci

[poukill]

Code :

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

class C : public virtual B

Qu'est ce que c'est que ça ? Ca compile ?
C'est du jamais vu pour moi.....

Code :

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

class C : public B

Ah ça je connais !

[Davidbrcz]

poukill >> C'est l'héritage virtuel. Ca sert dans les cas d'héritage en diamand ( une classe D hérite de C et B qui toutes deux héritent d'une classe A. Sans héritage virtuel, il y a deux fois les membres de A dans D).

Par contre, j'ai plus l'habitude de mettre le mot clé virtual avant, bien qu'il est possible que cela ne change rien, je ne suis pas assez calé en théorie des langages pour comprendre la grammaire de la norme.

Edit: je viens de comprendre que c'est en tant que constructeur par défaut que B est appelé (car si tu retire la valeure par défaut dans le constructeur, la compilation plante). Reste à trouver pourquoi.

[white_tentacle]

Juste pour être sûr, j'imagine que c'est un exemple qui reproduit le problème, et que tu as réellement besoin d'un héritage virtuel à cause d'un héritage multiple ?

Parce que héritage virtuel et fonctions virtuelles ne sont pas liés.

Ensuite, par rapport au lien que tu donnes, il y a l'explication dedans :

Deuxièmement, chaque classe dérivée directement ou indirectement d'une classe virtuelle doit en appeler le constructeur explicitement dans son constructeur si celui-ci prend des paramètres. En effet, elle ne peut pas se fier au fait qu'une autre de ses classes de base, elle-même dérivée de la classe de base virtuelle, appelle un constructeur spécifique, car il est possible que plusieurs classes de base cherchent à initialiser différemment chacune un objet commun hérité de la classe virtuelle.

C'est exactement le cas.

Suppose, par exemple, que tu aies, dans le cas d'un héritage en diamand :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class B : public virtual A
{
  B() : A(10) {}; 
}
 
class C : public virtual A
{
  C() : A(15);
}
 
class D: public B, public C
{
  D() : C(), B() {};
}

Le compilateur ne sait pas quel constructeur de A il doit appeler. Donc tu dois préciser lequel en écrivant :

Code :

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

1
2
 
D() : C(), B(), A(10) {};

[poukill]

poukill >> C'est l'héritage virtuel. Ca sert dans les cas d'héritage en diamand ( une classe D hérite de C et B qui toutes deux héritent d'une classe A. Sans héritage virtuel, il y a deux fois les membres de A dans D)..

Au temps pour moi, je ne savais pas.

[3DArchi]

Bonjour,
Pour rappel, l'ordre de construction des objets est le suivant :
1/ Pour l'objet le plus bas de la hiérarchie, les classes virtuelles dans l'ordre de leur apparition (gauche->droite) depuis la plus profonde (celle le plus haut dans la hierarchie).
2/ les classes de bases dans l'ordre où elles apparaissent dans la définition,
3/ Les membres statiques dans l'ordre de leur définition.

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
 
class A {};
 
class B {};
 
class C :public virtual A, public  B {};
 
class D {};
 
class E {};
 
class F :virtual public D, public C
{
   E e;
};

Ordre des constructeurs : D, A, B, C, E, F.
D car c'est la première classe virtuelle,
puis A car c'est la classe virtuelle la plus profonde en remontant la branche par C
Puis B, C, les classes de bases non virtuels,
Puis E pour le membre e
Enfin, F.

Ensuite, si le constructeur de la classe la plus basse ne spécifie pas de constructeur pour la classe virtuelle, alors c'est le constructeur par défaut qui est pris :

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
 
class A
{
public:
   A(){std::cout<<"A"<<std::endl;}
   A(int){std::cout<<"A - 1"<<std::endl;}
};
 
class B : public virtual A
{
public:
   B():A(1){std::cout<<"B"<<std::endl;}
};
 
class C : public B
{
public:
   C(){std::cout<<"C"<<std::endl;}
};
 
int main()
{
   std::cout<<"Construction de B"<<std::endl;
   B b;
   std::cout<<"Construction de C"<<std::endl;
   C c;
   return 0;
}

On a :

Construction de B
A - 1
B
Construction de C
A
B
C

Par abus de langage, on peut dire qu'avec une classe virtuelle on n'hérite pas des appels de constructeurs des classes de base. Il faut le re-spécifier à chaque niveau si on ne veut pas l'appel implicite.

[lokida]

Depuis vos réponses la solution a été trouvée de mon côté.
Il faut appeler le constructeur de base pour ne pas avoir ce problème.

Merci

[3DArchi]

Depuis vos réponses la solution a été trouvée de mon côté.
Il faut appeler le constructeur de base pour ne pas avoir ce problème.

Merci

Tu verras aussi dans les différentes réponses pourquoi...