opérateur dynamic_cast

Salut,
j'ai besoin de tester le type d'un argument reçu comme void * dans la fonction:

Code:

---

1 2 3 4 5 6 7 8

void Toto::handler(void *arg) { MyType *test = (MyType *)arg; if (dynamic_cast<MyType *>(test)) != NULL) cout << "-> arg is a MyType" << endl; else cout << "-> arg is not a MyType" << endl; }

---

Quelque soit le type d'objet dont je passe un pointeur en paramètre a Toto::handler, le cast ne renvoie jamais NULL. Je compile sous Visual Studio 2005 donc l'option /GR devrait être activée par défaut... j'utillise mal l'opérateur dynamic_cast à mon avis. Qq1 peut m'expliquer?
merci :-)

tous sur les cast C++ : http://c.developpez.com/tutcpp/x4111.php ;)

merci mais meme en connaissant la théorie je n'arrive pas à résoudre mon exemple :-(

Code:

---

MyType *test

---

Ca défini bien la variable test comme un MyType*
On peut toujours tester ensuite si son type est bien MyType*, ce sera toujours vrai !

Il faut tester le type de arg :

Code:

---

if (dynamic_cast<MyType *>(arg)) != NULL)

---

Ben justement, quand j'essaye de caster arg directement, Visual Studio refuse de compiler:
'void *' : invalid expression type for dynamic_cast

Explication lue dans le livre de stroustrup:
le compilateur ne peut emettre aucune hypotheses concernant la mémoire pointée par un void * ,cela implique que dynamic_cast qui doit examiner l'objet pour en determiner le type ne peut effectuer une conversion à partir d'un void * .

Il te faudra donc faire un static_cast vers un objet acceptable avant de le tester par dynamic_cast...

:D

Exact, j'ai répondu un peu vite, on ne peut pas faire de dynamic_cast à partir d'un void*.

Cependant, un static_cast suivi d'un dynamic_cast, ça me semble imprévisible si le static_cast n'est pas correct, c'est à dire si on ne sait pas du tout de quel type est l'argument.

Je pense qu'il faut changer le type d'argument pour utiliser une interface ou une classe de base à la place d'un void*. (c'est pas bien les void* :mouarf:)

Citation:

---

Cependant, un static_cast suivi d'un dynamic_cast, ça me semble imprévisible si le static_cast n'est pas correct, c'est à dire si on ne sait pas du tout de quel type est l'argument.

---

pourtant tout le but de mon opération est d'arriver à détecter les cas ou le cast n'aurait pas été valide, de m'assurer que arg était de type MyTest avant d'etre un paramètre void *

Citation:

---

(c'est pas bien les void* :mouarf:)

---

le prototype de la fonction est imposé malheuresement, c'est bien pour ca que j'essaye de retrouver le type de départ avec certitude :-)

Citation:

---

Il te faudra donc faire un static_cast vers un objet acceptable avant de le tester par dynamic_cast

---

je pensais que ca revenait au meme que mon tout premier cast sur arg, mais meme apres essai, avec static_cast ca ne change rien apparament...

Citation:

---

Explication lue dans le livre de stroustrup:
le compilateur ne peut emettre aucune hypotheses concernant la mémoire pointée par un void * ,cela implique que dynamic_cast qui doit examiner l'objet pour en determiner le type ne peut effectuer une conversion à partir d'un void * .

---

argh, ben je pensais que la toute-puissance du dynamic_cast me permettrait d'arriver à mes fins... y a une autre méthode que ça du coup?

De toute manière un void* en C++ est à éviter. Mieux vaut passer un pointeur vers une classe mère, on aura moins de soucis et un design un peu meilleur.

ok merci

Finalement j'ai remplacé le void * par un type abstrait dont tous les objets susceptibles d'être passés en paramètre héritent.
Bon c'est pas terrible vu que du coup, presque toutes les classe du projet héritent de la classe abstraite en question, mais au moins le dynamic_cast fonctionne...
merci Miles ;-)

Effectivement c'est pas terrible comme design.

Quel est le rôle de cette fonction ? Tu ne peux pas plutôt utiliser les templates ? Ou la surcharge ?

Sinon tu peux aussi passer un identifiant avec ton void*, c'est généralement ce qui se fait en C.

Au pire tu peux également utiliser boost::any et boost::any_cast, ça t'évitera de faire dériver toutes tes classes d'une base qui ne sert finalement à rien.