J'ai un code dont les classes A,B,C héritent de X.
Comment changer un pointeuren pointeur sur A ?
Code : Sélectionner tout - Visualiser dans une fenêtre à part X* pointeur
J'ai un code dont les classes A,B,C héritent de X.
Comment changer un pointeuren pointeur sur A ?
Code : Sélectionner tout - Visualiser dans une fenêtre à part X* pointeur
Par contre fais en sorte d'être assuré que pointeur pointe bien vers un A.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2 A* pA = static_cast<A*>(pointeur);
Salut,
Tu as trois possibilités, de la plus sécurisante à la plus potentiellement problématique:
- Le dynamic_cast qui s'utilise sous la forme de
qui effectue une vérification dynamique du type réel, et qui empeche d'obtenir une instance moins bien "cv-qualifiée" (on peut augmenter la "cv-qualification", mais pas la descendre) que l'instance d'origine
Code : Sélectionner tout - Visualiser dans une fenêtre à part B* b = dynamic_cast<B*>(instance_de_X*);- le static_cast qui s'utilise sous la forme de
qui ne vérifie pas a priori si tu peux effectivement transtyper ton instance de départ en autre chose, mais qui empêche une instance moins bien "cv-qualifiée" que l'instance d'origine, et
Code : Sélectionner tout - Visualiser dans une fenêtre à part B* b = static_cast<B*> (instance_de_X*);- le transtypage "C style", sous une forme proche de
qui n'effectue aucune vérification et qui, en outre, n'empeche pas d'obtenir une instance non constante au départ d'une instance cv-qualifiée.
Code : Sélectionner tout - Visualiser dans une fenêtre à part B* b = (B*) instance_de_X*;
En outre, il faut être conscient du fait que, non seulement static_cast et dynamic_cast sont plus sécurisés à l'emploi, mais ils facilitent également la recherche dans le code...
En effet, étant donné que l'on utilise les parenthèses et l'étoile * à toutes les sauces en C++, tu risque de devoir passer pas mal de code en revue avant de trouver le transtypage (B*)x; qui t'intéresse![]()
, alors qu'une recherche sur static_cast ou dynamic_cast t'amènera beaucoup plus vite sur la partie recherchée
Enfin, il peut être utile de se demander si tu n'es pas face à un problème de conception lorsque tu as besoin d'un transtypage allant d'une classe mere à une classe fille...
En effet, dans la plupart des cas - et nous nous comprenons sur ces termes: ils indiquent qu'il ne s'agit pas d'une règle absolue- tu utilisera un pointeur de type de la classe mère pour pouvoir représenter n'importe quel type dérivé... en le faisant passer pour une instance du type de la classe mère.
*Normalement*, tu ne devrais donc essayer d'accéder qu'à des méthodes propres à la classe mère
Si tu souhaites effectuer une action particulière en fonction du type réel dérivé, tu peux te tourner vers la surcharge (ou redéfinition) de fonction (virtuelle), le pattern visiteur ou le pattern "chaine de responsabilité" qui te permettent d'obtenir quelque chose de bien plus évolutif![]()
A méditer: La solution la plus simple est toujours la moins compliquée
Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
Compiler Gcc sous windows avec MinGW
Coder efficacement en C++ : dans les bacs le 17 février 2014
mon tout nouveau blog
Merci beaucoup
Chez moi le transtypage "C style" est rejeté par le débugger, du moins tel que je l'utilise :
Code : Sélectionner tout - Visualiser dans une fenêtre à part (B*)instance_de_X*;
Peux tu conserver le nom du pointeur ???
Mon debugger accepte mais quand je vérifie, le type est inchangé.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3 Mere* pX = new Mere(); pX = dynamic_cast<Fille>(px);
NB :se lit convertir pX en type fille ==> (pA)
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2pX = dynamic_cast<File*>pA;
Bonsoirs,
Non c'est impossible. Le C++ étant un langage a typage fort, une variable ne peut avoir qu'un type, et ne peut pas en changer. Il faut donc un nouveaux pointeur, pour avoir un nouveaux type.Peux tu conserver le nom du pointeur ???
j'aurai plutôt dit:pX = dynamic_cast<File*>pA;
se lit convertir pX en type fille ==> (pA)
Convertir pA en type Fille*, et stocker le résultat dans pX
Ça n'a rien à voir avec le typage fort, c'est à cause du typage statique.Le C++ étant un langage a typage fort, une variable ne peut avoir qu'un type, et ne peut pas en changer.
Si tu as besoin de downcaster, c'est que tu as sûrement un problème de conception.
Partager