Discussion :

[buzzkaido]

EDIT : je précise que j'utilise VS2005 Express

Bonjour,

J'ai une architecture avec pas mal de classes.

En gros, une classe mère et plusieurs classes filles.

Je sais que le downcasting, c'est mal !

Mais bon, là j'ai fouillé dans tous les sens :
- essayé avec des templates : ça devient beaucoup trop lourdingue comme code
- essayé avec des fonctions dont le type de retour est covariant, mais ça ne resoud pas tous mes problèmes.

En fait, je voudrais surtout savoir quel type de cast utiliser sachant que :
- je sais que le cast est possible (je cast un pointeur du type de la classe mère qui pointe vers un objet de la classe fille vers un pointeur de CETTE classe fille)
- les performances sont importantes

Si j'ai tout bien compris, dans mon cas, je peux utiliser un static_cast

Mais que se passe-t-il au niveau du compilateur ?

Il y a une quelconque verification ?

En fait je voudrais eviter toute verification, vu que je sais que la conversion est possible, que mon objet existe, etc....



Pour donner une idée, c'est ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class Mere
{
   .....
}

class Fille : public Mere
{
  ....
}

Mere* pointeurMere = new Fille();

Fille* pointeurFille = quelcastutiliser<Fille*> pointeurMere;

[koala01]

Salut,

Le static_cast n'effectue aucune vérification quant au fait que le transtypage est possible...

Le dynamic_cast, pour sa part, renverra un pointeur NULL ou lancera une exception bad_cast si la convertion est impossible.

Ainsi, si tu as plusieurs classes dérivées, le static_cast risque de poser quelques problèmes:

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
 
class Mere
{
    /*...*/
};
class Prem:public Mere
{
    /*...*/
};
class Second:public Mere
{
    /*...*/
};
 
int main()
{
    Mere* f=new Prem;
    /* ce transtypage fonctionne... mais... */
    Second *t1=static_cast<Second*>(f);
    /* ce transtypage échouera */
    Second *t2=dynamic_cast<Second*>(f);
    /* par contre, le transtypage sera correct si on travaille sur Prem ;) */
    Prem *p=dynamic_cast<Prem>(f);
}

Imaginons, maintenant, que dans Second, il y ait une fonction quelconque qui soit propre à cette classe... Que se passera-t-il si elle est appelée sur une variable issue d'un mauvais transtypage pour lequel tu aurais utilisé le static_cast

[EDIT]Du point de vue des pures performances, le static_cast est plus rapide que le dynamic_cast... mais pose le problème qu'il faut etre sur que la convertion réussira

[buzzkaido]

Merci.

Je suis bien au courant du risque que peut engendrer un downcast foireux...

Mais dans mon cas, je sais exactement dans quelles conditions je fais ce cast et quelles fonctions je vais appeler dessus.

J'aimerais eviter ça, mais c'est au prix de beaucoup de travail sur mon architecture, donc tant pis, je prend le risque !

Habituellement j'utilise le dynamic_cast, mais sur 2-3 parties du code qui sont tres clairement definies (je sais ce que je downcast à coup sûr) et qui sont un peu sensibles en performances, je voudrais eviter des verifications inutiles...

[koala01]

C'était bien le sens de mon intervention...

Je voulais m'assurer que tu étais au courent des risques, mais, si tu te trouve dans une portion de code dans laquelle tu es sur de ton coup, le static_cast présentera de meilleures performances

[buzzkaido]

Farpait !

Merci !

[JolyLoic]

Une technique consiste à faire un static_cast en release, et en debug, à faire un dynamic_cast suivi d'un assert si ça n'a pas marché. Ca peut éviter des mauvaise surprises si on s'est trompé sur la validité du static_cast.