heritage class en c++

**gusgus** · 03/05/2008, 23h10

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** · 03/05/2008, 23h39

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** · 03/05/2008, 23h45

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** · 04/05/2008, 02h48

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:

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 /*,
   ...*/
};
```
Ajouter un membre du type de cette énumération dans la classe de base

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;}
/*...*/

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;
}

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){}
```
(éventuellement, rajouter un accesseur à ce nouveau membre, ce qui permettra l'utilisation d'un bloc "switch... case")

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* */

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** · 04/05/2008, 08h53

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** · 04/05/2008, 14h13

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.

**gusgus** · 04/05/2008, 14h50

euh,j'ai pas trop compris la

d'apres ce que je comprend,*it renvoy un A*.Donc sa devrais planter non?

**coyotte507** · 04/05/2008, 15h09

Envoyé par gusgus

euh,j'ai pas trop compris la

d'apres ce que je comprend,*it renvoy un A*.Donc sa devrais planter non?

Tu as raison

.
Il faut ajouter un cast dans ce cas

. (dynamic_cast, ou cast barabare)

**koala01** · 04/05/2008, 15h12

Effectivement, mea-culpa, il faut quand même transtyper l'élément du type de base en un élément du type dérivé...

Cependant, si tu sait le type réel de l'objet pointé par l'élément qui se trouve dans ton conteneur, tu peux alors t'éviter le recours ( couteux du point de vue des performances) au transtypage dynamique, et utiliser un transtypage sans vérification
voici un code complet qui peut te permettre de comprendre le principe:

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
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#include <iostream>
#include <list>
enum eType
{
    tIsA,
    tIsB
};
class A
{
    public:
        A():m_type(tIsA){}
        virtual ~A(){}
        bool isAnA()const {return m_type==tIsA;}
        bool isA_B()const {return m_type==tIsB;}
        eType getType() const{return m_type;}
        void print(){std::cout<<"je suis un A";}
    protected:
        A(eType t):m_type(t){}
	private:
        eType m_type;
};
class B: public A
{
    public:
        B():A(tIsB){}
        virtual ~B(){}
        void identify(){std::cout<<"Je suis un B";}
    protected:
	private:
};
class C
{
    public:
        C(): m_items(){}
        ~C()
        {
            for(std::list<A*>::iterator it=m_items.begin();
            it!=m_items.end();++it)
                delete (*it);
    }
    void createA(){m_items.push_back(new A());}
    void createB(){ m_items.push_back(new B());}
    size_t size() const{return m_items.size();}
    A* getA(size_t ind)
    {
        std::list<A*>::iterator it=m_items.begin();
        for(size_t i=0;i<ind;++i)
        {
            ++it;
        }
        return (*it);
    }
    B* getB(size_t ind)
    {
        std::list<A*>::iterator it=m_items.begin();
        for(size_t i=0;i<ind;++i)
        {
            ++it;
        }
        return static_cast<B*>(*it);
    }
    eType getTypeOfElement(size_t ind)
    {
        std::list<A*>::iterator it=m_items.begin();
        for(size_t i=0;i<ind;++i)
        {
            ++it;
        }
        return (*it)->getType();
    }
    void identifyAll()
    {
        size_t num=1;
        for(std::list<A*>::const_iterator it=m_items.begin(); it!= m_items.end();
        ++it)
        {
            std::cout<<"Element "<<num<<" dit ";
            if( (*it)->isAnA())
            {
                A* elem= (*it);
                elem->print();
            }
            else
            {
                B* elem=static_cast<B*> (*it);
                elem->identify();
            }
            std::cout<<std::endl;
            ++num;
        }
    }
    protected:
 
    private:
    std::list<A*> m_items;
};
 
int main()
{
    C c;
    c.createA();
    c.createB();
    c.createA();
    c.createB();
    std::cout<<"nombre d'éléments" <<c.size()<<std::endl;
    std::cout<<"Appel de l'identification de tous les éléments contenus dans c"
             <<std::endl;
    c.identifyAll();
    std::cout<<"voyons ce qui se passe avec les méthodes fournies par la classe"
             <<" C"<<std::endl;
    for(size_t i=0;i<c.size();++i)
    {
        std::cout<<"l'element "<<i<<" est du type ";
        switch(c.getTypeOfElement(i))
        {
            case tIsA:
                std::cout<<"A et utilise la methode print :";
                c.getA(i)->print();
                break;
            case tIsB:
                std::cout<<"B et utilise la méthode identify :";
                c.getB(i)->identify();
        }
        std::cout<<std::endl;
    }
    return 0;
}

Il a, en outre, l'avantage de mettre ce que je disais plus haut en évidence:

Les méthodes A::print et B::identify ont toutes les deux le même but: faire afficher "je suis un" suivi du type réel (identifier le type) de l'objet pointé par l'élément de la liste

Il serait donc opportun d'envisager ces deux méthodes comme un seul et même comportement polymorphique

Il faut noter que les méthodes de C utilisant un indice ne sont certainement pas les plus efficaces ici... C'est, simplement, parce que je n'ai pas fournit d'autres moyens permettant de sélectionner un élément

Dans le cas présent, l'utilisation d'un vector serait sans doute plus adaptée

**gusgus** · 06/05/2008, 19h18

Merci!j'ai bien compris maintenant.

Sinon,j'aurais aussi préfer les vector,mais j'aurais surement besoins de suprimer des elements au millieu de la liste et c'est pas possible avec vector non?(quoique je pourais juste les metre a NULL mais pour le moment je ne cours pas apres les performances,si un jours des optimisations s'imposes,je saurais ou chercher!)

Bref,merci pour tout

**coyotte507** · 06/05/2008, 22h12

Salut,

si avec un vector tu peux supprimer un élément au milieu: http://www.cplusplus.com/reference/s...tor/erase.html

Mais c'est sûr que c'est pas l'idéal pour les performances.

Sinon, si l'ordre n'a pas d'importance, tu peux échanger l'élément en question avec le dernier élément, puis effacer le dernier élément.

**koala01** · 06/05/2008, 23h42

Il faut bien comprendre que l'ensemble des classes de conteneur fournies par le C++ en standard autorise les mêmes choses (du moins une fois que l'on ne travaille pas sur une pile ou sur une file)...

Ce qu'il y a, c'est que certains conteneurs sont particulièrement intéressants dans certaines situations, et beaucoups moins dans d'autres.

Ainsi, la classe vector, par exemple, est particulièrement efficace lors d'acces "aléatoires" aux données, et particulièrement peu efficace pour les ajouts ou les suppressions successifs

A contrario, la classe list est particulièrement efficace dans la gestion des ajout/suppression/insertion, mais n'est réellement intéressante, pour le parcours des éléments que dans le cadre d'un parcours itératif (et très peu intéressante dans le cadre de recherches nombreuses)

Et l'on pourrait continuer cette étude comparative sur les avantages et les inconvénients des différentes classes de conteneur pendant longtemps...

C'est à tel point qu'il existe une entrée dans la FAQ qui a trait à la STL qui fournit un organigramme permettant de choisir le conteneur qui correspond le mieux à ses besoins

**gusgus** · 07/05/2008, 17h55

J'avais pas vu la fonction erease de Vector

De toute les fassons,sa ne devrais pas avoir un impacte énorme sur le perfs vu qu'il y aura beacoup d'iteratif et peu de recherche,et le changement ne devrais pas etre compliqué s'il est necessaire.

Merci!

heritage class en c++

C++

Discussions similaires

Partager

Partager