Discussion :

[hbenji]

Bonjour,

Je vais expliquer mon problème par un exemple.

J'ai 4 class, une class mère, une class fils1, une class fils2 et une class3

les class fils héritent de class mère.

Dans mon main j'ai un vecteur (vecteur <mere*>), donc lors d'un nouveau class1, class2 ou class3 je le place dans ce vecteur.

Ce que je voudrais savoir c'est s'il y a un moyen de savoir lorsque je manipule les class qui se trouvent dans mon vecteur, qu'elle class je manipule ou est-ce que je dois ajouter un attribut en plus.

Merci pour votre aide.

[poukill]

Non, tu peux pas savoir.
Une bonne question, c'est "pourquoi tu veux savoir ?"
Sinon une solution qui marche c'est un truc du genre :

Code :

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

1
2
3
4
class Base
{
     virtual const std::string GetTypeName const () = 0;
};

Tu fais hériter tes classes de Base, et dans tes classes tu redéfinis la méthode GetTypeName :

Code :

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

1
2
3
4
class Mere : public Base
{
     virtual const std::string GetTypeName const () {return "Mere";}
};

Tu peux faire une macro pour automatiser ça...

[ternel]

Mias surtout, répond d'abord à la question importante: Pourquoi en ai-je besoin?
C'est à dire:
Pourquoi mettrai-je des choses différentes dans le même tas, si c'est pour les traiter différemment?
Il y a deux façons de réfléchir à ce problème:

• N'aurai-je pas du faire plusieurs tas? c'est à dire utiliser plusieurs vecteurs
• Ne puis-je pas faire en sorte d'agir de la même façon? utiliser l'héritage et la virtualité permet d'avoir des réactions différentes à une même stimulation

[Iradrille]

Ce que je voudrais savoir c'est s'il y a un moyen de savoir lorsque je manipule les class qui se trouvent dans mon vecteur, qu'elle class je manipule ou est-ce que je dois ajouter un attribut en plus.

Bonjour,

Tu peux récupérer le type à l'aide du pattern visiteur, ça donne quelque chose du genre :

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
struct Visitor {
	void operator()(Class1& c) { /* code spécifique à Class1 */ }
	void operator()(Class2& c) { /* code spécifique à Class2 */ }
};
 
struct Mere {
	...	
	virtual void accept(V& visitor) = 0;
}
 
struct Class1 {
	...
	virtual void accept(V& visitor) { v(*this); }
}
 
struct Class2 {
	...
	virtual void accept(V& visitor) { v(*this); }
}
 
std::vector<Mere*> vec;
...
Visitor v;
for(auto ptr: vec) {
	ptr->accept(v);
}

Pourquoi mettrai-je des choses différentes dans le même tas, si c'est pour les traiter différemment?

Il arrive de devoir faire une opération a() sur tous les éléments, et une opération b() seulement sur un seul type par exemple. Mais effectivement, la question est à se poser.

[Bousk]

Il arrive de devoir faire une opération a() sur tous les éléments, et une opération b() seulement sur un seul type par exemple. Mais effectivement, la question est à se poser.

Dans ce cas, pourquoi de l'héritage ?
Si l'on doit réaliser un traitement différent, que l'on ne peut factoriser dans les services ou comportements de la classe, l'héritage est superflu non non avenu.

[oodini]

Je suis tout à fait en désaccord.

Cela signifierait que les classes filles ne peuvent offrir que les services offerts par la classe mère, et ne peuvent définir aucune autre nouvelle fonction. C'est une curieuse conception de la programmation objet.

Ce sur quoi on peut s'interroger, c'est sur la pertinence de tout mettre dans un seul vecteur.

[r0d]

Dans ce cas, pourquoi de l'héritage ?
Si l'on doit réaliser un traitement différent, que l'on ne peut factoriser dans les services ou comportements de la classe, l'héritage est superflu non non avenu.

Je plussoie.
C'est décidément un problème à la mode ces temps-ci.
Pourquoi vouloir faire une hiérarchie de classe si chaque classe a un protocole différent? ça ne fait que rajouter des complications et ça n'apporte rien.
C'est comme les templates; parfois je vois du code où on voit clairement que le développeur à voulu absolument utiliser des templates alors que ça n'apporte que, dans le meilleur des cas, de la complexité au code.

[koala01]

Salut,

De manière générale, tu peux (comprends: il est tout à fait légal de le faire ) envisager de fournir une méthode qui permet de récupérer le type réel de ton pointeur et de travailler à coup de dynamic_cast.

Cela pourrait prendre la forme 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
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
enum ClassType
{
    fils1,
    fils2,
    fils3
};
class Mere
{
    public:
        virtual ClassType type() const = 0;
};
class Fils1 : public Mere
{
    public:
        virtual ClassType type() const {return fils1;}
};
class Fils2 : public Mere
{
    public:
        virtual ClassType type() const {return fils2;}
};
class Fils3 : public Mere
{
    public:
        virtual ClassType type() const {return fils3;}
};
 
int main()
{
    std::vector<Mere*> tab;
    /* ... */
    for(auto it : tab)
    {
        switch(it->type())
        {
            case fils1:
                Fils1 * temp= dynamic_cast<Fils1*>(it);
                /* ... */
                break;
            case fils1:
                Fils2 * temp= dynamic_cast<Fils2*>(it);
                /* ... */
                break;
            case fils1:
                Fils3 * temp= dynamic_cast<Fils3*>(it);
                /* ... */
                break;
        }
    }
}

Mais je te déconseille très fortement et avec la plus grand insistance de faire de la sorte

En effet, si tu choisis cette option, tu vas très rapidement te retrouver dans une situation dans laquelle tu passeras ton temps à tester le type réel de tes objets (ou plutôt de tes pointeurs ou de tes références) avant de les transtyper afin de pouvoir les utiliser.

Cela va mener à une complexification systématique et largement inutile de ton code et cela va présenter un inconvénient majeur:

Si tu décides, un jour, de rajouter une classe dérivée (et les raisons pour le faire sont nombreuses, la question n'est donc pas de savoir SI tu voudras le faire, mais bien QUAND tu voudras le faire ), tu devras reprendre systématiquement tout ton code pour prendre cette nouvelle classe en compte

L'idéal est donc de se baser sur le principe du double dispatch:

L'idée est de se dire que les pointeurs connaissent leur type réel.

Il est donc possible d'envisager un comportement que l'on appellera au départ de "tout objet passant pour être du type de base" qui s'adaptera au type réel de l'objet.

Le principe du visiteur se base sur un principe similaire

[oodini]

Ce que je voudrais savoir c'est s'il y a un moyen de savoir lorsque je manipule les class qui se trouvent dans mon vecteur, qu'elle class je manipule ou est-ce que je dois ajouter un attribut en plus.

Il y a la solution du dynamic_cast, qui n'est généralement pas des plus heureuses.

[poukill]

Il y a la solution du dynamic_cast, qui n'est généralement pas des plus heureuses.

C'est vrai c'est pas toujours heureux mais il y a parfois des cas où c'est une bonne solution.