Bonjour a tous, j'ai un problème pour utiliser des vectors et avec une hierarchie de classes. Pour résumer, j'ai une classe mere et deux classes filles qui en dérive. Je dois mettre des objets des deux classes filles dans une collection. Je la déclare donc :  
vector<Mere*> collection.  
Ensuite, j'envoie des éléments de ce "vector" dans des fonctions du type :  
void fonction (Mere *a);
Le problème est que j'ai des méthodes et variables spécifiques à chaque classe fille auxquelles je voudrais accéder dans les fonctions...  
Comment puis-je y accéder ? Comment retrouver le type de dynamique des variables des fonctions ? (type_info ?)
Si quelqu'un peut m'aider ce serait bien sympa ! J'arrive pas à vraiment trouver ce que je cherche sur le net... Quelques précisions, je développe sous linux, sans IDE, j'ai des bases de c et java et je débute le c++.

rencadre toi sur le POLYMORPHISME et les méthodes VIRTUELLES

Merci pour l'orientation de recherche, mais mon problème est que je n'ai pas les méthodes auxquelles je veux accéder dans la classe mère, donc je ne peux pas les y déclarer virtuelles...

bah reinterpret_cast<> ?
de toutes façon ça semble être la mauvaise approche

et tu peux pas plutot avoir des fonctions void fonction (Fille1 *a) et void fonction (Fille2 *a) ?

en koi est-ce que c'est une mauvaise approche... dites moi que je ne m'embarque pas dans des trucs s'il faut que je revoie ma conception...

C'est une mauvaise approche si tu as besoin de connaitre le type de ton objet pour décider quelle méthode appeler. Ca devrait se faire tout seul, soit au runtime, soit à la compilation.

Oui pour les deux fonctions séparée mais le traitement à une toute petite différence prêt serait le même...

bah ché pas tu as l'air de vouloir tester dans une fonction le type d'un objet.
c'est ptet pas bon...
 
et n'oublies pas qu'avec le vector<Mere *>, quand le vector sera détruit, tes instances de Mere de ta collection ne le seront pas.

Alors, en fait, il ne peut pas y avoir (à l'execution tout du moins) d'instances de Mere. Mais bon, je crois que je v revoir ma conception... petite question hors topic, est-ce que vous ne trouvez pas que le c++ est légérement plus chiant à coder que le java... (je me lance dans un sujet sensible, je sais... mais ca me rassurerait de savoir que je ne suis pas le seul à penser ça )

Tu n'es pas le seul Mais un codeur C++ qui passe au java pense la même chose. C'est une question d'approche différente.

juste une petite question encore, si je fais un trux du style :

Alors dans ma fonction, objFille est devenu un objet de la classe Mere*, c'est ca ? Je n'ai plus aucun moyen d'y accéder en tant que fille ? C'est ca ?

Fille est casté vers la mere.
si Fille dérive de Mere c'est bon.
 
et fonction() voit une Mere.
 
dans fonction(), tu peux caster Mere en Fille, mais pris comme ça -rien- ne peut te garantir que tu peux caster une Mere en Fille.
 
si tu as dérivé une autre classe Fille2 de Mere, et que tu passes pas donc une Fille2 à fonction(), fonction va récupérer une Mere qu'il castera en Fille, et boum dans le mur un peu plus loin.
 
le problème c'est qu'une fois dans fonction(), tu as une Mere, rien ne te garanti que tu peux la faire passer pour une Fille.

Ben tu peux toujours caster, mais c'est sale : ta fonction déclare prendre des paramètres de type Mere *, elle doit donc les traiter en tant que tels. Si tu veux faire un traitement spécifique à Fille, fais-le dans une méthode qui prend une Fille en paramètre.

plus précisément,  "fonction()" qui fait un traitement, devrait être une méthode membre de ta classe Mere.
et tu fais une version pour la classe Mere et Fille.
et si tu veux pouvoir apeller la version de Fille, via un Mere*, il faut que ta méthode "fontion()" soit virtuelle dans Mere.

Donc je fait deux fonctions, une  

l'autre

mais si ces objets sont stockés dans un vector<Mere> maman et que je fais un appel :  

... là ca va pas marcher... si ?

désolé bjone, j'avais pas vu ton post, le problème c'est que ces fonctions comme expliqué juste au dessus font partie d'un algo qui traite les objets... pas des objets eux-même.

tu peux peut-être utiliser mere en temps qu'interface :
 

 
ensuite, sur les items de ton std::vector<mere*> tu peux appeler fonction()
 
edit : le destructeur virtuel

en fait c pas possible car ma "fonction" est complètement détachée de la représentation des classes car elle contient pas mal de paramètres... ou alors, faut absolument que je change toute mon implémentation pour la rendre un peu plus objet ... mais si c'est la seule solution...

bah dans fonction(), si tu fais un cast forcé d'une Mere en Fille, quand tu le fais, est-ce qu'il y a un moyen d'être SÛR que c'est faisable ? (ie un flag/attribut visible à travers Mere, un attribut passé en paramètre à fonction() )

nan, aucun moyen, c bien pour ca que je suis encore de vous emmerder à vous poser des questions qui peuvent, j'en suis sûr vous paraitre un peu con parfois

bin sinon le moyen tu le rajoute.

et le destructeur virtuel

 
exact  

qu'est-ce donc que cela est exactement ? Et comment m'en servir ?

en fait c'est simple:
 
mettons un:
 
class Mere
{
public:
  ~Mere(); // destructeur de Mere
};
 
class Fille : public Mere
{
public:
  ~Fille(); // destructeur de Fille
};
 
mettons à un moment tu as:
 
Fille *TaSoeur=new Fille();
 
un peu plus loin tu te retrouves avec quelque chose comme:
 
Mere *TaMere=TaSoeur;  
 
et puis à un moment:
 
delete TaMere;
 
TaMere pointe comme TaSoeur sur une instance de Fille.
Mais comme l'instance est détruite à travers un pointeur sur "Mere", c'est le destructeur de Mere qui sera appellé, et non le destructeur de Fille. (et donc kaput la destruction des objets de Fille, seuls les objets de Mere passent).
 
Pour remédier à cela, il faut que le destructeur soit virtuel dans Mere, du style:
 
class Mere
{
public:
   virtual ~Mere();
};
 
Comme ça, si tu crées plein de classes dérivées de Mere, Fille1,Fille2,Fils,Oncle, en détruisant à travers un pointeur sur Mere, le destructeur de la classe dérivée sera bien appellé.
 
dsl si j'ai glissé