Double polymorphisme? (virtual)

Version imprimable

Salut à tous!!!!!

Voila donc mon problème: j'ai deux classes B et C qui héritent de la classe A.
J'ai besoin à l'interieur de méthodes de B et C de tester le type d'un A* de cette manière : a1->memeType(a2) (renvoie un bool). Le type de a2 peut être connu puisque l'on se trouve dans la classe B ou C, le type de a1 est inconnu et donc considéré par defaut comme A (d'où l'utilisation de virtual)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class A { public: virtual bool memeType(const A* a) const = 0; } class B : public A { public: bool memeType(const A* a) {return false;} bool memeType(const B* b) {return true;} } class C : public A { public: bool memeType(const A* a) {return false;} bool memeType(const C* c) {return true;} }
Comme on peut le voir, dans la classe mère A il n'y a que l'objet (this) pour lequel on arrive à differencier le type. Le 2eme paramètre est déclaré en A* alors que l'on veut déceler si en réalité c'est un A*, B* ou C* (sans mentioner B et C dans la classe A ....

Dans notre cas, la méthode appellée est toujours :

Code:

bool B::memeType(const A* a) {return false;}

ou

Code:

bool C::memeType(const A* a) {return false;}

L'idéal serait d'avoir ce paramètre en virtual également ... est ce possible ?
Sinon, existe-t-il une autre solution ?

Important (rappel) ! Je ne peux pas ajouter les prototypes :

Code:

bool A::memeType(const B* b) {return true;}

Code:

bool A::memeType(const C* c) {return true;}

Merci d'avance!!! ;)

13/11/2006, 11h45
Jean-Marc.Bourguet

Il y a des techniques qui permettent de le faire. Recherche "double dispatch" et visiteur.
13/11/2006, 12h43
SuperAldoIsDead

Merci!! ;)
Je vais aller voir ca!!

Mais là, ça implique l'ajout de prototypes que tu ne peux pas faire.

Le seul moyen, c'est d'utiliser de la RTTI (Run-Time Type Identification). Soit la RTTI native de C++ (opérateur dynamic_cast<> etc.) soit une RTTI perso comme celle que fait MFC...

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
30
31
32
33
34
35
36
class A
{
private:
	static int s_pourAdresseType;
public:
	virtual int *VGetAdresseType(void)
	{ return &s_pourAdresseType; }
public:
	static bool SMemeType(A *pa1, A *pa2)
	{ return (pa1->VGetAdresseType() == pa2->VGetAdresseType()); }
};
 
 
class B : public A
{
private:
	static int s_pourAdresseType;
public:
	virtual int *VGetAdresseType(void)
	{ return &s_pourAdresseType; }
}
 
 
class C : public A
{
private:
	static int s_pourAdresseType;
public:
	virtual int *VGetAdresseType(void)
	{ return &s_pourAdresseType; }
}
 
 
int A::pourAdresseType;
int B::pourAdresseType;
int C::pourAdresseType;

13/11/2006, 14h59
loufoque

Mieux vaut utiliser le RTTI standard plutôt que de le recoder, ne serait-ce que pour réduire la taille des objets.
13/11/2006, 16h36
Médinoc

À mon avis, ça ne change pas la taille des objets eux-mêmes.
Par contre, ça peut agir sur la taille des données statiques et/ou celle de la vtable.