downcast et liste d'instances

Version imprimable

23/02/2010, 10h49
zerbynette

downcast et liste d'instances
Bonjour,

j'ai une classe mere avec une fonction virtuelle:
Code:

1 2 3 4 5 6 7 8 9 10 class A{ protected: unsigned int m_type; public: A(); virtual ~A(); virtual bool do(); };
et des classes filles Aa et Ab qui implementent la methode do().

je souhaite avoir une liste vector<A*> myList et pouvoir iterer de maniere à appeler la bonne methode do() en fonction de la fille ( *it->do() ), tout en restant générique. Or j'ai lu (et testé) que le downcast en C++ n'etait pas safe (contrairement à Java).

Alors, je ne vois pas comment procéder. Avez-vous des conseils à me donner?

Merci de votre aide
23/02/2010, 11h15
Médinoc

La fonction do() est virtuelle, donc tu as déjà le comportement que tu veux.
23/02/2010, 11h19
Sylvain Togni
En effet, aucun cast dans le code que tu montre.

Un downcast serait :
Code:

1 2 Aa* aa = (Aa*)a; // Non safe Aa* aa = dynamic_cast<Aa*>(a); // Safe
23/02/2010, 11h28
zerbynette

manque de clarté desolée
je m'explique donc:

dans mon main j'instancie un Aa* pAa et un Ab* pAb, chacun ayant sont m_type à 0 et 1 respectivement (via un enum).

Par la suite je les "push" dans la liste:
Code:

1 2 3 myList.push_back(dynamic_cast<A*>(pAa)); myList.push_back(dynamic_cast<A*>(pAb));
Or myList[0]->do() appelle la declaration dans la classe mère et non celle de la fille.

Euh, mais tu n'as même pas à faire de dynamic_cast, ici...

Code:

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
#include<iostream>
#include <list>
 
class A{
 
public:
   A() {}
   virtual ~A() {}
   virtual void do() { std::cout<< "A" << std::endl; }
};
 
class Aa : public A {
 
public:
   Aa() {}
   virtual ~Aa() {}
   virtual void do() { std::cout<< "Aa" << std::endl; }
};
 
class Ab : public A {
 
public:
   Ab() {}
   virtual ~Ab() {}
   virtual void do() { std::cout<< "Ab" << std::endl; }
};
 
void TestHeritage(void)
{
  std::list< A* > myList;
  myList.push_back(new Aa);
  myList.push_back(new Ab);
 
  for(std::list< A* >::iterator it=myList.begin ; it!=myList.end() ; ++it)
  {
    (*it)->do();
  }
}

Ceci, si ça compile, devrait donner le bon comportement.

Salut,

Pour te permettre de comprendre...

Si tu as une hiérarchie de classes proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class A { public: virtual ~a(); //nécessaire si tu veux pouvoir détruire tes objets // dérivés au départ des pointeurs sur A virtual bool do(); /*tout le reste */ }; class B : public A { /*les trucs adaptés pour B */ }; class C : public A { /* les trucs adaptés pour C */ };
Tu dispose, du fait de l'héritage, d'une relation EST-UN pour tes classe B et C.

En effet, B EST-UN A et on peut en dire autant de la part de C.

De ce fait, n'importe quel B ou n'importe quel C peut parfaitement passer pour un A, bien qu'il souffre de la restriction que tu ne puisse appeler que les fonctions déclarées dans A.

Si donc, tu crées des B et des C et que tu les places dans une collection de pointeurs de type A, tu pourra sans problème invoquer la fonction do depuis n'importe quel élément de la dite collection.

Comme la fonction do est déclarée virtuelle, son comportement sera adapté au type dynamique de l'objet, si elle est redéfinie dans une des classes enfant de A.

C'est ca ce que l'on appelle le polymorphisme (enfin, l'un des polymorphismes possibles en C++) ;)

Il n'y aura que si tu veux, en partant de ta collection de pointeurs sur des objets de type A, pouvoir appeler des comportements spécifiques au B ou au C que tu devra envisager le downcasting.

Dans ce cas, il vaut mieux privilégier un transtypage "sécurisant" tel que dynamic_cast ou static_cast par rapport à un transtypage sauvage "a la C"

j'ai compris...

je ne dois pas faire de cast justement!

Exemple:

Code:

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
 
#include <string>
#include <iostream>
#include <vector>
using namespace std;
 
class Chumain{
protected:
	std::string m_Genre;
public:
	Chumain(){};
	virtual ~Chumain(){};
	virtual void jesuis(){cout<<"je suis un humain"<<endl;};
};
 
class Cfemme: public Chumain{
public:
	Cfemme(){};
	virtual ~Cfemme(){};
	void jesuis(){cout<<"je suis une femme"<<endl;};
};
 
class Chomme: public Chumain{
public:
	Chomme(){};
	virtual ~Chomme(){};
	void jesuis(){cout<<"je suis un homme"<<endl;};
};
 
 
 
int main() {
	Cfemme* sophie = new Cfemme();
	Chomme* vincent = new Chomme();
 
	std::vector<Chumain*> mesHumains;
	mesHumains.push_back(sophie);
	mesHumains.push_back(vincent);
 
	for (std::vector<Chumain*>::iterator it = mesHumains.begin(); it != mesHumains.end(); it++) {
		(*it)->jesuis();
	}
	return 0;
}

au run, on a les traces suivantes:
je suis une femme
je suis un homme
Merci

23/02/2010, 11h59
koala01

Citation:

Envoyé par zerbynette

je ne dois pas faire de cast justement!

Ben oui, c'est bien ce que je t'expliquais...

Ici, tu laisse simplement agir le polymorphisme ;)

il n'y a que si tu veux récupérer, selon ton exemple, un objet de type CFemme pour le premier élément de ta liste (parce que tu veux appeler, par exemple, la fonction membre tricoter, qui n'existe (soyons machos :D) que pour la classe CFemme ) que tu devra recourir au transtypage ;)
23/02/2010, 12h08
3DArchi

Salut,
Pour tout savoir ou presque sur les fonctions virtuelles : Les fonctions virtuelles en C++, par votre serviteur :mrgreen:
23/02/2010, 12h48
zerbynette

mais un doute subsiste
car quand j'ecris:
Code:

1 2 3 4 Chumain* humain = new Chumain(); Cfemme* annie = static_cast<Cfemme*> (humain); annie->jesuis();
la trace retournée est : je suis un humain... Le downcast n'a pas marché
23/02/2010, 12h59
3DArchi

Le downcast ne transforme pas une variable de type Chumain en variable de type Cfemme. Il dit que tu connais le type dynamique à la compilation et c'est pour ça que tu veux obtenir un pointeur dessus.

Le type dynamique d'une variable ne change pas en cours d'exécution :

Code:

Chumain* humain = new Chumain();

Tu alloues une variable de type dynamique Chumain et humain pointe vers cette variable.
Lorsque tu écris :

Code:

Cfemme* annie = static_cast<Cfemme*> (humain);

Tu dis au compilateur que la variable humain a un type dynamique Cfemme et que donc tu veux l'utiliser avec annie . Or c'est faux.
Tu as juste de la chance que ça ne plante pas. Je n'ai pas vérifié, mais je pense qu'il s'agit d'un comportement indéterminé.
23/02/2010, 13h22
Médinoc

Dans ces circonstances, un dynamic_cast<> aurait gueulé (retourné NULL ou lancé une exception std::bad_cast selon que tu aies employé un pointeur ou une référence)
23/02/2010, 14h47
zerbynette

comment faire le downcast alors?

car oui, avec dynamic_cast, la compilation passe mais l'execution plante.
Comment faire alors?
23/02/2010, 14h52
Médinoc

Eh bien, ne pas tenter ce downcast?
Dans un modèle objet parfait, tu n'es pas censée en avoir besoin.
23/02/2010, 14h53
3DArchi
Code:

1 2 3 Chumain* humain = new Cfemme(); Cfemme* annie = static_cast<Cfemme*> (humain); annie->jesuis();
Tu ne peux en aucun cas changer le type dynamique d'une variable.
static_cast fait un cast à la compilation avec le risque que ce soit faux à l'exécution. Ce qui est ton cas.
dynamic_cast permet de vérifier à l'exécution que le type dynamique est compatible :
Code:

1 2 3 4 5 6 7 8 Chumain* humain = new Chumain(); Cfemme* annie = dynamic_cast<Cfemme*> (humain); if(annie){ annie->jesuis(); } else{ std::cout<<"humain n'est pas Cfemme \n !"; }
Note que dans la plus part des cas, c'est une erreur de conception que de vouloir faire un down cast (dynamic_cast ou static_cast).
23/02/2010, 14h55
Médinoc

D'ailleurs, Chumain devrait sans doute être une classe abstraite.

Il faut comprendre que, si tu peux faire passer une instance de la classe fille pour une instance de la classe mère, tu ne peux pas faire le contraire...

La raison principale en est que la classe fille va (vraisemblablement) utiliser plus d'espace mémoire que la classe mère, et que si classe fille connait tout de la classe mère (du moins, tout ce qui est publique et protégé), la classe mère ne sait absolument rien de la class fille.

Donc, si tu as besoin d'un objet de la classe fille, tu crées un objet de... la classe fille...

Soit statiquement
Code:

1 2 3 4 5 6 Fille lafille(/* paramètre éventuel */); /*peut être transmise à la fonction */ void foo(Mere const & m) { /*...*/ }
soit dynamiquement:
Code:

1 2 3 4 5 6 /* en sachant qu'il s'agit d'un pointeur sur une instance de la classe Fille */ Fille * ptrfille= new Fille(/* paramètre éventuel*/); /* ou en faisant passer le pointeur comme un pointeur sur une instance * de la classe Mere */ Mere * ptr = new Fille(/*parametre éventuel */);
Le premier peut être passé en paramètre à une fonction attendant un pointeur ou une référence vers une instance de la classe Fille ou de la classe Mere, le second ne peut l'être qu'au travèrs du transtypage.

Si tu veux surpasser cette restriction, tu dois t'orienter vers le pattern décorateur ;)

23/02/2010, 15h48
zerbynette

Merci à tous

pour vos réponses et vos conseils.