Discussion :

[kassidy]

Bonjour,

J'ai actuellement une classe (A) contenant une autre classe (B), et des classes C, D... qui hériterons de B.

La classe A contiendra alors des classes C ou D.

Des instances de la classe A seront contenues dans un vector.

Lors de mon parcours du vector, je récupère donc les classes B que je cast (dynamic_cast) pour recupérer C ou D.

Ça fonctionne, mais je suis obligé de passer par un pointeur (c'est a dire que ma classe A contient un pointeur sur B), pour que le dynamic_cast fonctionne.

Ma question est la suivante : suis-je obligé de passer par des pointeurs (qui me font un peu peur ) pour pouvoir utiliser le dynamic_cast de cette façon ?

voici un bout de code simplifié afin d'illustrer mes propos :

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
 
//la classe A
class A {
 
public :
    void setB(B*);
    B* getB();
 
private:
    B * b;
};
void A::setB(B* b){
    this->b= b;
}
 
B * A::getB(){
    return b;
}
 
//la classe B
class B{
 
    static const int TYPE_C = 0;
    static const int TYPE_D = 1;
    void setType(int);
    int getType();
 
protected:
    int type;
};
 
void B::setType(int type){
    this->type = type;
}
 
int B::getType(){
    return type;
}
 
class C{
 
};
 
class D{
 
};
 
// et dans le main
int main()
{
    vector<A> liste;
 
    C c1;
    c.setType(B::TYPE_C);
 
    D d1;
    d.setType(B::TYPE_D);
 
    A a1;
    a1.setB(&c1);
    A a2;
    a2.setB(&d1);
 
    liste.push_back(a1);
    liste.push_back(a2);
 
    vector<A>::iterator it;
 
    for(it = liste.begin(); it !=liste.end(); it++){
 
    B * b = it->getB();
 
    if(b->getType() == B::TYPE_C){
        C* c2 = dynamic_cast<DbInteger*>(b);
        cout<< "c";
    }else{
        D* d2 = dynamic_cast<DbInteger*>(b);
        cout<< "d";
    }
}

Merci

[3DArchi]

Salut,
Seuls les pointeurs et les références peuvent avoir des types statiques et des types dynamiques différents. Donc, la réponse à ta question première est oui si tu souhaites avoir indifféremment des C ou des D dans ton A.
Quelques remarques :
-> il est rarement utile d'utiliser this dans une fonction de la classe, celui-ci est implicite et il est préférable d'éviter d'avoir des variables qui en masquent d'autres :

Code :

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

1
2
3
void B::setType(int type_){
    type = type_;
}

-> inutile d'ajouter un type dans B, le RTTI l'a fait pour toi : dynamic_cast retourne un pointeur nul si le type dynamique de la variable ne correspond pas à celui que tu demandes :

Code :

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

1
2
3
4
5
6
7
    if(dynamic_cast<C*>(b)){
        C* c2 = dynamic_cast<C*>(b);
        cout<< "c";
    }else if(dynamic_cast<D*>(b)){
        D* d2 = dynamic_cast<D*>(b);
        cout<< "d";
    }

-> Tu peux utiliser des pointeurs intelligents à la place de tes pointeurs nus ;
-> get/set sont souvent synonyme d'une mauvaise encapsulation des données privées ou pour dire autrement la classe A pêche dans le niveau d'abstraction qu'elle propose ;
-> dynamic_cast traduit aussi en général un problème de conception de la classe B (mauvais niveau d'abstraction, héritage publique n'étant pas un EST-UN, besoin de fonction virtuelle, etc.).

[kassidy]

Merci pour la réponse, et pour les conseils

Je vais me pencher sur les pointeurs intelligents, voir comment ça marche (et améliorer la conception, c'est vrai que là c'était ultra simplifié et épuré pour faire un exemple clair)