Ma question porte sur le transtypage d'un vector<A*> en vector<B*> pour itérer correctement sur les objets de type B*.
 

J'ai besoin maintenant dans une méthode de la classe Fille d'itérer sur le conteneur v (contenant des objets de type B* à ce moment).
 

Ce code marche bien mais le reinterpret_cast n'est pas du meilleur goût.
 
 
Je pensais à quelquechose du genre :
 
vector<B*>::iterator beg_it = dynamic_cast<vector<B*>::iterator>(v->begin());
 
mais j'ai du essayer sans succès.
 
Ou alors tout simplement, serait-il mieux d'itérer sur v normalement (après tout v ne contient que des pointeurs A* ou B* donc l'itération est identique (valeurs 32bits / 64bits) ?) et de caster au déréférencement de l'itérateur ?
vector<A*>::iterator it = v->begin()
B * b = dynamic_cast<B*>(*it);
 
merci pour vos lumières
 
edit: le forum n'aime pas les < > dans le code...

tu ne peut pas dynamic_caster des iterator car il s'agi d'objet à part entiere et non de pointeur. Tu peut dynamic_caster leur dereferencement.
 
vector<B*>::iterator> it = v.begin();
B* pb = dynamic_cast<A*>( *i ) ;
 
Apres normalement si ta modelisation est correct, le dynamic_cast est inutile.

Oui je comprends.
 
Je souhaite trier v. J'emploie pour ça la fonction callback suivante :
bool foo(B * x, B * y);
 
c'est précisement pour ça que je voulais caster pour avoir un itérateur sur B* et non A*. Dès lors comment appeler la fonction sort pour lui donner un itérateur sur le debut de v et sa fin ?
sort(v.begin(), v.end(), foo);
n'est pas correct car foo attend B* et non A*
 
voilà le sort() est vraiment mon objectif et c'est pour ça que je voulais caster mes itérateurs, et n'y arrivant pas j'avais décidé de reinterpret_caster directement v…
 
merci pour ton aide.

ecrit foo pour qu'il attendent des A* et dynamic_cast à l'interieur

d'accord, mais j'ai défini foo exprès dans B (statique) parce que foo ne peut trier que des B (foo accède un membre de B qui n'est pas dans A via ses paramètres), si on change sa signature avec des A*, n'aura-t-on pas une mauvaise sémantique ? et puis surtout on n'a pas un problème de securité ? car je pourrais appeler foo sur des A* ce qui est impossible/interdit.

tu peux pas juste surcharger l'opérateur < ?

bonne idée mais non ce n'est pas possible car j'ai plusieurs tris de la sorte qui fonctionnent sur différents membres de B.

 
bah le dynamic_cast t'empeche de le faire de toute façon

la surcharge ne résout pas le polymorphisme

effectivement
 
pour arriver a ses fins, il doit passer par une fonction wrapper qui va faire les dynamic_cast

 
en effet je n'y avais pas pensé.
 
merci pour votre aide, je vais réfléchir à tout ça.