Discussion :

[zerbynette]

Bonjour,

j'ai une classe mere avec une fonction virtuelle:

Code :

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

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

[Médinoc]

La fonction do() est virtuelle, donc tu as déjà le comportement que tu veux.

[Sylvain Togni]

En effet, aucun cast dans le code que tu montre.

Un downcast serait :

Code :

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

1
2
Aa* aa = (Aa*)a; // Non safe
Aa* aa = dynamic_cast<Aa*>(a); // Safe

[zerbynette]

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 :

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

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.

[Médinoc]

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

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
#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.

[koala01]

Salut,

Pour te permettre de comprendre...

Si tu as une hiérarchie de classes 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
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"

[zerbynette]

je ne dois pas faire de cast justement!

Exemple:

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
 
#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

[koala01]

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 ) que pour la classe CFemme ) que tu devra recourir au transtypage