CKTIS / C++
dynamic_cast — conversion vérifiée dans les hiérarchies de classes
dynamic_cast convertit des pointeurs et des références au sein des hiérarchies de classes, en vérifiant à l’exécution les conversions qui l’exigent. Un échec avec un pointeur renvoie nullptr, tandis qu’un échec avec une référence déclenche std::bad_cast.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
dynamic_cast<T>(expression)dynamic_cast<T>(expression) convertit des pointeurs ou des références au sein des hiérarchies de classes. T doit être un pointeur ou une référence vers un type classe complet, ou un pointeur vers void, éventuellement qualifié cv. L’opérateur ne peut supprimer ni const ni volatile.
Les conversions descendantes vers des classes dérivées et les conversions croisées entre branches d’héritage exigent un type source polymorphe : une classe comportant au moins une fonction virtuelle. La réussite dépend de l’objet réel ainsi que des règles d’héritage public et non ambigu. Une conversion ascendante vers une classe de base accessible et non ambiguë n’exige pas de polymorphisme ; une conversion implicite suffit généralement.
En cas d’échec avec un pointeur, le résultat est nullptr ; en cas d’échec avec une référence, l’opérateur déclenche std::bad_cast, déclaré dans <typeinfo>. Un pointeur d’entrée nul produit un pointeur résultat nul. Une conversion vers un pointeur sur void exige que le type statique pointé par p soit polymorphe. Si p n’est pas nul, le résultat pointe vers l’objet le plus dérivé. Le type pointé à l’arrivée doit conserver les éventuels qualificatifs const et volatile du type pointé au départ. Par exemple, si p pointe vers un type polymorphe qualifié const mais pas volatile, on utilise dynamic_cast<const void*>(p) plutôt que dynamic_cast<void*>(p). L’opérateur ne valide pas les pointeurs pendants : enfreindre les exigences de durée de vie des objets peut entraîner un comportement indéfini.
L’exemple montre une réussite et les deux formes d’échec. Il cible C++23 ; l’URL de la norme fournie renvoie à un brouillon évolutif, et non à une publication C++23 figée. L’exemple a été exécuté dans un environnement isolé ; aucune exécution en production n’est attestée.
Exemples
#include <iostream>
#include <typeinfo>
struct Base {
virtual ~Base() = default;
};
struct Derived : Base {
int value = 42;
};
int main() {
Derived derived;
Base base;
Base* good = &derived;
Base* other = &base;
if (auto* p = dynamic_cast<Derived*>(good)) {
std::cout << p->value << '\n';
}
std::cout << std::boolalpha
<< (dynamic_cast<Derived*>(other) == nullptr) << '\n';
try {
(void)dynamic_cast<Derived&>(*other);
} catch (const std::bad_cast&) {
std::cout << "bad_cast\n";
}
}
Résultat
42 true bad_cast
Le code affiché a été exécuté sans modification dans un environnement isolé. Sa sortie standard (`stdout`) correspondait exactement à la sortie indiquée.