Discussion :

[beckerfriedman]

Bonjour,
j'ai une question en ce qui concerne l'heritage :
Voila, J'ai une classe Mere. Cette classe a 2 classes dérivées : Fils et Fille (qui par exemple ont des attributs en plus).

Je dispose d'une Liste de Mere : static QList<Mere*> liste_mere;

Et dans cette liste je mets des Fils ou des Filles : liste_mere.append(new Fils(attributs));


Un peu plus tard dans mon programme j'ai besoin de récupérer les éléments de ma liste, mais je me rends compte qu'ils sont devenus tous des Mere :
Quand je fais :

typeid(* liste_mere.at(i)).name() j obtiens "class Mere", comme si il avait été converti.
Or je j'ai pas envie de les caster après, il faudrait que je puisse savoir en prenant les éléments de la liste-mere si se sont des fils ou des filles.

Est ce que c est possible ?, est ce que j ai bien expliqué mon problème, et surtout j'ai peur de ne rien avoir compris à l'héritage vu que ca ne marche pas .

Merci de votre aide !!!

[Swoög]

tes objets sont bien des Fils normalements... puisque ce sont des pointeurs...

ce que tu veux utiliser ici s'appelle le polymorphisme.

il y a simplement quelques points auxquels il te faut faire attention :

Le destructeur de Mere DOIT être déclaré virtual, ainsi que les fonctions que tu veux ensuite éventuellement appeller sur les fils...

je m'explique au cas où :

déclarer une méthode virtual implique que la méthode appelée ne sera pas cette méthode là, mais celle correspondant au vrai type... exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
class M
{
   public :
      virtual void V() { cerr <<"Je suis un M" <<endl; }
      void NV() { cerr <<"Je suis un M" <<endl; }
};
 
class F : public M
{
    public :
      void V() { cerr <<"Je suis un F" <<endl; }  //pas obligatoirement besoin de déclarer virtual ici...
      void NV() { cerr <<"Je suis un F" <<endl; }
};
 
int main()
{
     F* f = new F();
     M* m = f;
     f->V();
     f->NV();
     m->V();
     m->NV();
}

normalement, tu devrais voir s'afficher :

Je suis un F
Je suis un F
Je suis un F
Je suis un M

j'espère que tu as bien saisie ce qu'était une fonction virtuelle ... en cas, n'hésite pas à demander plus d'explication ^^

[beckerfriedman]

Ok,
merci de tes eclaircissements, mais je ne pensai pas utiliser le polymorphisme vu que je n ai pas les memes noms de fonctions dans ma classe Mere et dans mes classes Fille et Fils.
Par contre, pour en revenir a ta première phrase, tu me dis que mes objets sont des Fils normalement vu que ce sont des pointeurs.
Or quand je fais un cout de typeid( *Mere.at(i)).name()); j obtiens "class Mere " et non "class Fils".
Encore merci de la rapidite de ta reponse !

[Swoög]

si tu ne stocke que des pointeurs, alors c'est sûrement parce que typeid ne gère pas le polymorphisme justement... étrange, mais je ne vois pas vraiment d'autre explication...

si a auncun moment tu n'as de copie de tes objets (uniquement des pointeurs), le type réel est conservé...

[beckerfriedman]

C'est aussi ce que je pensais, mais vu que j'utilise Qt sous Visual studio a mon avis ça doit être une histoire d'options avec le compilateur peut-être.
Parceque si je veux tester à chaque fois si les objets dans ma liste_mere sont des fils ou des filles je n'ai pas d'autre choix que d'utiliser typeid ?

[Laurent Gomila]

Parceque si je veux tester à chaque fois si les objets dans ma liste_mere sont des fils ou des filles

Mauvaise idée. Voir la FAQ C++ avec comme mot-clé "dynamic_cast".

[Matthieu Brucher]

typeid(* liste_mere.at(i)).name() j obtiens "class Mere", comme si il avait été converti.

C'est un peu plus sournois, tu as toujours de bons éléments dans ta liste, mais si tu appelles l'opérateur de déréférencement *, tu transformes ton objet en Mere...

[beckerfriedman]

En effet c'est bien vicieux !!!
Moi en fait je gère un affichage. J'ai une classe Meteo et de cette classe dérivent des classes Foudre, Neige, ... avec juste des attributs en plus pour l'affichage. (la foudre juste des coordonnées, un nuage un diamètre en plus pour le représenter par un cercle, ...).
Je mets tous ces différents objets dans une liste de Meteo quand je les crée.
Puis, lorsque je procède à l'affichage un peu plus tard (dans une autre classe qui gère l'affichage) j'ai besoin de récupérer les objets et de savoir si c'est une foudre ou un nuage afin de récupérer les bons champs !!!
Or , la je me retrouve toujours avec 'class Meteo" ou "class * Meteo" si je n 'utilise pas le * dans typeid.
Voila, donc je ne pense pas avoir besoin de faire des cast puisque je ne sais pas ce que sont les objets quand je veux les récupérer, j'ai juste besoin de connaitre leur type.

[beckerfriedman]

En fait je vais rajouter une même méthode dans chaque classe qui me renvoit le type d'objet que c est puis je fais le dynamic cast.
Merci a tous en tout cas

[Jan Rendek]

En fait je vais rajouter une même méthode dans chaque classe qui me renvoit le type d'objet que c est puis je fais le dynamic cast.

Hélas, si tu fais cela, tu ne profites en rien de ce qu'offre l'héritage. De ce que tu décris, tu as effectivement un problème de conception. Beaucoup de chose on déjà été dites dans ce fil, toutes ne sont pas tout à fait exactes d'ailleurs. Rentrer dans le détail rendrait les choses encore plus confuses.
Si tu continues à programmer en C++, je te conseilles néanmoins de regarder la base d'un cours de programmation objet. Cela te fera gagner un temps précieux.

[beckerfriedman]

En fait je pensai faire une methode virtuelle pure getType() dans meteo que je redefinie a chaque fois dans les classes filles me permettant ainsi de trouver le bon type. Cela me semblait assez propre

[Swoög]

tu devrais plutôt faire une seule méthode qui te retournerais un toutes les infos d'un coup...

exemple une méthode getCoord qui renverrais une map normalisée (les index sont les même pour toutes les classes filles de Meteo.

ensuite, tu as juste à parcourir la map avec un itérateur, et tu dessines selon ce qui y est indiqué...

du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
"x" => 250
"y" => 300
"thunder" => 1
"diameter" => 30

etc... (j'ai pris une map<string, int> dans ce cas...)

c'est peut-être pas encore le mieux, tu peux aussi donner toutes les fonctions nécessaires à la classe Meteo, puis ensuite changer le résultat dans les classes filles...

ces fonctions seraient virtuelles (éventuellement virtuelles pures dans la classe Météo) comme ça tu pourras faire jouer le polymorphisme...

c'est déjà nettement plus OO et nettement plus propre