Salut,
Je ne sais pas si j'utilise le bon terme (DownCast) mais j'ai un petit souci.
En fait j'ai une classe "element" qui est abstraite et j'ai des sous classes concretes elementA, elementB et elementC.
J'ai une autre classe abstraite "collecteur" qui est sensée travailler sur un élément spécifique. Selon l'élément concret je ne veut pas faire les memes opérations. J'ai donc les classes concrete collecteurA, collecteurB et collecteurC. Elles implémentent toutes la fonction exec_query().
 
Ensuite j'ai une classe fabriquecollecteur qui définie 3 fonctions :
       

 
Jusque la ca peut aller, mais le probleme c'est que lorsque je créer mon collecteur je ne connait pas le type concret de mon element, je sais juste qu'il est du type élément. Exemple :
         
       

 
 
et la j'ai une belle erreur de compilation :  
error C2664: 'collecteurA *FabriqueCollecteur::creerCollecteur(elementA *)' : cannot convert parameter 1 from 'element *' to 'elementA *'
 
Ce que je comprend mais comment résoudre cette erreur?
 
Il y a bien des solutions en modifiant l'architecture et en spécifiant a chaque élément son collecteur mais j'aimerais que cette premiere solution fonctionne.
 
Si vous le souhaitez, vous pouvez tester les sources en prenant ca : sources

dynamic_cast<T*>( ... ) qui renvoie 0 si il échoue
dynamic_cast<T&>( ... ) qui lui lance une exception std::bad_cast
 
mais enfait, tu ferais mieux de t'intéresser au design pattern visitor.
 
et la question qui tue : ton destructeur est-il bien virtuel ?

 
 
Euh je sais pas... Ca change quoi que le destructeur soit declare virtual ou non?
 
Tu peux me donner plus d'infos sur "dynamic_cast"? Tu le met où?
 
Tu penses que ce que je souhaite faire correspond au pattern visiteur? Je vais regarder ca, dans mon beau livre Design Patterns

/me retourne se coucher

Pour faire un dynamic_cast il faut quand meme connaitre le type de destination, dans mon cas elementA, elementB ou elementC

et ben il faut essayer les 3 ... je vois pas comment tu veux faire autrement ...
 
 
if(ElementA* a = dynamic_cast<ElementA*>(e))
{
  // code pour un ElementA
}
else if(ElementB* b = dynamic_cast<ElementA*>(e))
{
  // code pour un ElementB
}
else if(ElementC* c = dynamic_cast<ElementA*>(e))
{
  // code pour un ElementC
}
else
{
  // mais c'est quoi ce truc ?
}
 
sinon, penche toi sur le visitor

Ok, c'est bien ce que je craignais, je veux justement éviter les switchs.
 
Je crois que je vais me rabattre vers une sorte de pattern visitor.
 
Merci bien

pour le destructeur virtuel, fait un petit test :  
 
(ecrit a l'arrache)

 
essaye avec et sans les virtual, tu comprendras

Effectivement c'est utile  

En fait, le dynamic_cast c'est comme un instanceof en Java?

ou l'inverse.

 
aussi