Discussion :

[gusgus]

Bonjours.
J'ai un probleme que je n'arrive pas a résoudre.
J'ai une class A et une class B qui hérite de la class A. J'ai aussi une class C qui contient une std::list<A*> et qui a une fonction

Code :

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

1
2
3
4
5
A* createA()
{
A a=new A;
enregistre a dans std::list;
}

et

Code :

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

1
2
3
4
A* getA(name)
{
return std::list etc
}

Maintenant,je créer une instance de la class B.Est ce que je peu utiliser la fonction createA de la class C(je suppose que non)?
Et apres,si je fait getA(nom instance class B), comment est ce que je peu récuperer la class B?

J'ai pas l'impression d'être tres clair la mais bon.

Merci

[hiko-seijuro]

en gros tu veux créer une instance de B en utilisant la méthode pour créer une instance de A ? si c'est cela ca m'étonnerait que ca passe :p

[coyotte507]

Pour récupérer ton objet B, après, si tu le stockes dans ta liste sous forme de A *, via ta méthode tu récupèreras un objet de type A *, et pour être prudent, utiliser dynamic_cast<> (voir FAQ) sur ce pointeur pour le convertir en B * (il vaudra NULL alors si ce n'est pas un objet B ou dérivé de B qu'il y a dans le pointeur A *)

[koala01]

Salut,

*Normalement*, mais bon, on se comprend sur l'acception du terme ici , si tu décide de faire cohabiter des A* et des B* dans une même classe alors que B hérite de A, c'est que tu as déterminé que tous tes B pouvaient être gérés comme s'il s'agissait de A...

Cela voudrait dire, si on suit la logique jusqu'au bout - ainsi que les recommandations de certains grands pontes du C++ de par le monde, dont, en particulier, celle qui dit qu'une classe dérivée devrait se contenter de spécialiser des comportements, et non en rajouter - que la classe A "devrait" au moins exposer toutes les méthodes qui permettent, via le polymorphisme, de gérer aussi bien des A que des B.

Si tu as fait cas des dites recommandations, tu te rendra compte que tu n'as normalement plus aucune raison de t'inquiéter quant au type réel d'un élément particulier lorsque tu y fait accès.

La seule précaution qu'il te resterait à prendre serait alors de prévoir une fonction "createA(/*...*)" qui ajouterait un ... A* à ta liste et une autre createB(/*...*/) qui ajouterait... un B* à ta liste

Maintenat, j'admets volontiers qu'il peut exister quantité de raisons qui pourrait rendre le fait de suivre cette recommandation impossible, même si la plupart sont généralement mauvaises.

Pour palier cette impossibilité, je vois deux alternatives majeures:

• Utiliser le transtypage avec vérification (dynamic_cast<>), et vérifier s'il a réussit, ce qui me semble honnêtement être la plus mauvaise du point de vue conceptuel
• fournir le moyen aux éléments de déterminer s'ils sont de type A ou de type B (en quelque sorte, implémenter un RTTI de base). Ce qui me semble, conceptuellement parlant la meilleure des mauvaises solutions

La première solution a été exposée plus haut, et je ne vais rien ajouter dessus.

Par contre, voici comment je verrais la deuxième:

1. Définir une énumération reprenant une valeur unique pour chaque type de base/dérivé, sous une forme proche de
   

   Code :

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

   1
   2
   3
   4
   5
   6
   enum eType
   {
      tIsA,
      tIsB /*,
      ...*/
   };

2. Ajouter un membre du type de cette énumération dans la classe de base
3. Ajouter une méthode renvoyant une valeur boléenne pour chacun des types attendus, sous un forme proche de
   

   Code :

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

   1
   2
   3
   bool isAnA() const{return m_type==tIsA;}
   bool isA_B() const{return m_type==tIsB;}
   /*...*/

4. rajouter un constructeur protégé dans la classe de base prenant en paramètre (outre ceux qui sont nécessaires à la construction d'un A), le type de l'élément sous une forme proche de
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   class A
   {
       public:
           /* constructeur propre aux A* qui sont réellement des A*/
           A(/*...*/):/*...*/m_type(tIsA){}
           ~A();
           /*...*/
       protected:
           A(/*..., */ eType t):/*...*/m_type(t){}
       private :
           eType m_type;
   }

5. Appeler systématiquement le constructeur protégé dés que l'on travaille avec un type dérivé, sous une forme proche de
   

   Code :

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

   B::B(/*...*/):A(/*...,*/eType tIsB){}

6. (éventuellement, rajouter un accesseur à ce nouveau membre, ce qui permettra l'utilisation d'un bloc "switch... case")
7. rajouter dans la classe regroupant les différents types une méthode permettant de récupérer un objet de chaque type sous une forme proche de
   

   Code :

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

   1
   2
   A* getA(/*...*/){return elem;} /* elem est l'élément dont on sait que c'est un A* */
   B* getA(/*...*/){return elem;} /* elem est l'élément dont on sait que c'est un B* */

8. Si nécessaire, et en considérant que la classe C dispose d'un moyen de savoir en permanence quel élément de la liste est sélectionné, rajouter une méthode isAnA et consort à la classe C (éventuellement, si C ne dispose pas du moyen de retenir en permanence l'élément sélectionné, en modifiant les arguments de manière à permettre un choix dans la liste )

De cette manière, tu pourrais très bien envisager un code proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
void C::function()
{
    for(std::list<A*>::iterator it=m_items.begin(); it!=m_items.end();++it)
    {
        if( *it->isAnA())
            A* elem=*it;
        else /* ici, si ce n'est pas un A*, c'est que c'est un B* */
            B* elem=*it,
    }
}

voire un code proche de

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
 
/* c est une variable de type C ;)*/
eType t=c.getType(/*ce qu'il faut pour sélectionner l'élément à trouver*/);
switch(t)
{
    case tIsA :
        A* elem=c.getA(/*...*/);
        /* la suite */
        break;
    case tIsB:
        B* elem=c.getB(/*...*/);
        /* la suite */
        break;
    /* de meme pour tous les types dérivés ;)*/
 
}

Les codes sont volontairement incomplets, et il y a sans doute un intéret majeur à réfléchir aux arguments à fournir aux différentes méthodes

Ils n'ont d'ailleurs, étant donné l'heure et les trous qu'ils contiennent, pas été testés

Si tu veux plus de précisions, il faudra commencer par nous en donner

Si tu ne comprend pas l'un des raisonnements suivi ici, n'hésite pas à demander des précisions

[gusgus]

Merci!

Pour tout vous dire,je ne suis pas un pro du c++ et je n'est jamais vraiment utiliser la fonction dynamic_cast<>,et je n'arrive pas a trouver sur le net ce qu'elle fait vraiment.
Edit2:j'ai rien dit,j'ai trouver.

Sinon,j'utilise un moteur physique avec une class actor.Quand 2 actor rentrent en collision,une fonction renvoy 2 actor.Par contre,une foi que j'ai les actor,il faut que je trouve le "reste"(en gros j'ai une class qui dérive de actor que je voudrais retrouver) pour pouvoir modifier certains trucs dans cette class dérivée. D'ou ma question.

Je pense avoir compris la 2eme methode mais cette ligne me laisse perplexe:

Code :

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

B* elem=*it

Le c++ rale quand on lui met 2 pointeurs different non?j'avais essayer de faire des trucs du genre B* = *A mais sa compile pas.

Edit:je ne peu pas metre de enumType dans la class de base(en fait si je pourais,mais sa impliquerais de modifier le moteur physique et je suis moyennement chaud pour sa)

[coyotte507]

Salut,

les vectors c'est encore différent

Si tu fais un vecteurs d'éléments E, alors *it te donneras accès à l'élément E correspondant à ton itérateur.

Par exemple si tu fais un vecteur de pointeurs Actor *, *it te donneras un objet du type Actor *.

C'est possible en 'surchargeant' l'opérateur '*', c'est-à-dire en lui donnant une fonction différente.