pb Héritage multiple

Version imprimable

28/01/2007, 18h13
Pascal22

pb Héritage multiple
J'ai à utiliser des objets de type :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 // classe de bases : class Obj_Base { }; class Node { }; // classe instanciées : class Obj_1 : public Node, public ObjBase { }; class Obje_N : public Node, public ObjBase
Les Objet instancié devant être utilisés sour la forme Obj_Base (manipulations diverses) ou Node (Stockage et accès en mémoire).
Le pb est le suivant :
Accédant aux objets sous la forme Node, il m'est impossible de les transtyper directement en Obj_Base . Si, par contre je connais précisément la classe instanciée par de pb.

J'ai remarqué que lorsque je transtype un objet de Obj_N vers Node (en vue de le stocker), le pointeur change d'adresse.
Est-ce un mécanisme normal ?
Y a-t-il quelque chose qui m'échappe ? (vraisemblablement)
Enfin quel moyen pour contourner le pb ?

j'espère avoir été assez clair...
28/01/2007, 21h37
Luc Hermitte

http://www.ddj.com/dept/cpp/184402074 ?
Comment réalises-tu tes casts?

Genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
//instanciation :
Obj_1* NouvObj=new Obj_1();
 
// stockage :
Ma_Classe_de_Stockage->Ajoute((Node*) NouvObj);
 
//recupération :
Node* InstNode=Ma_Classe_de_Stockage->Donne(...);
 
// en vue de manipulations:
Obj_Base* Obj= (Obj_Base*) InstNode;
 
Obj->Fonction_Virtuelle_Implémentée_dans_Obj1(); // problème

par contre l'alternative ci-dessous fonctionne :

Code:

1
2
3
4
5
 
// en vue de manipulations:
Obj_Base* Obj= (Obj_1*) InstNode;
 
Obj->Fonction_Virtuelle_Implémentée_dans_Obj1(); // Ok

Mais beaucoup moins interessente...

29/01/2007, 01h36
Luc Hermitte

:?
(Pourquoi je ne suis pas surpris par le fait que tu aies des problèmes?)
Déjà que les casts à la C sont déconseillés en C++, ils sont tout simplement à bannir dès qu'il y a de l'héritage en jeu, plus particulièrement de l'héritage multiple. :sm:

Je t'ai donné de la lecture. C'est la meilleure que je connaisse sur le sujet -- De mémoire, il y avait aussi un bouquin de Lipmann.
29/01/2007, 21h32
Pascal22

Citation:

Déjà que les casts à la C sont déconseillés en C++, ils sont tout simplement à bannir dès qu'il y a de l'héritage en jeu, plus particulièrement de l'héritage multiple

Après un peu de lecture, j'ai tout repris correctement, mais ca n'y change rien...
Ceci dit, je m'en doutais un peu, car l'article que tu m'as 'prescrit', m'a permis de mieux comprendre les différents mécanismes liés à l'héritage multiple.

J'ai pour l'instant contourné (ou plutot relégué à plus tard) le problème en faisant dériver Obj_Base depuis Node. Ca ne me plais pas trop mais pour l'instant ça colle...
30/01/2007, 11h20
Ulmo

Et les "dynamic_cast" n'arrangent pas tes affaires ?

Non, lors de la récupération de mon objet il faut nécessairement que je connaisse la classe qui l'a instancié si je veux récuperer un pointeur valide. C'est une limitation sérieuse que me laisse à penser qu'il y a quelque chose qui m'échappe...
Afin de résoudre le pb si je ne trouve pas d'autre solution je pense stoker le type de l'objet instancié dans la classe Node de sorte qu'une fonction gèrant le cast me fournisse un pointeur valide. Du genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Obj_Base* Ma_Fonction_de_Cast(Node* Ptr) { switch(Ptr->TypeObj) { case TYPE_OBJ_1: return static_cast<Obj_1*> (Ptr); case TYPE_OBJ_N: return static_cast<Obj_N*> (Ptr); } return NULL; }
Que pensez-vous de cette approche ?

01/02/2007, 08h17
Jan Rendek

Le problème ne vient pas des opérations de transtypage, mais du fait que d'après ton design, un Node n'est pas un ObjBase.
Si tous les ObjBase peuvent être considérés comme des Node, alors la correction que tu as faite est justifiée.

Si tu souhaites faire dans le porco, tu peux ajouter une fonction membre à l'interface ObjBase du style :

Code:

virtual Node * getAsNode() const

dans laquelle un Node est reconstruit à partir d'un ObjBase ou sauvagement transtypé.

Si elle est applicable, je milite pour la première solution.
01/02/2007, 11h11
Ulmo
Puisque c'est le sujet, je ne comprend pas pourquoi le code suivant ne compile pas (GCC 3.2.3 ou VC8). J'ai comme message :
Source type is not polymorphic.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class Base { }; class Derived : public Base { }; int main(void) { Base *a = new Derived; Derived *p; p = dynamic_cast<Derived *>(a); return 0; }
01/02/2007, 11h18
Laurent Gomila

Ta classe de base ne possède aucune fonction virtuelle. Ajoute par exemple le destructeur virtuel, qui sera de toute façon nécessaire si tu utilises le polymorphisme.

Merci Laurent.

Donc au risque de paraître lourd, un dynamic_cast est vraiment ce qu'il te faut.

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
class Base1 {
public:
	virtual int function1(void);
};
 
int Base1::function1(void) {
	return 1;
};
 
class Base2 {
public:
	virtual int function2(void);
};
 
int Base2::function2(void) {
	return 2;
};
 
class Derived : public Base1, public Base2 {
};
 
int main(void) {
	Base1 *a = new Derived;
	Base2 *b = dynamic_cast<Base2 *>(a);
	return 0;
}