dynamic_cast conversion

Convertit de manière sécurisée les pointeurs et références vers des classes vers le haut, vers le bas et latéralement le long de la hiérarchie d'héritage.

Syntaxe

Explication

Pour faciliter la description, « expression ou le résultat est une référence à T » signifie que « c'est une glvalue de type T » , ce qui suit la convention de decltype (depuis C++11) .

Seules les conversions suivantes peuvent être effectuées avec dynamic_cast , sauf lorsque ces conversions supprimeraient la constance (ou la volatilité).

Lorsque dynamic_cast est utilisé dans un constructeur ou un destructeur (directement ou indirectement), et que expression fait référence à l'objet actuellement en cours de construction/destruction, l'objet est considéré comme l'objet le plus dérivé. Si target-type n'est pas un pointeur ou une référence vers la propre classe du constructeur/destructeur ou l'une de ses bases, le comportement est indéfini.

Similaire à d'autres expressions de cast, le résultat est :

Notes

Un downcast peut également être effectué avec static_cast , ce qui évite le coût de la vérification à l'exécution, mais cela n'est sûr que si le programme peut garantir (par une autre logique) que l'objet pointé par expression est définitivement Derived .

Certaines formes de dynamic_cast reposent sur l' identification du type à l'exécution (RTTI), c'est-à-dire des informations sur chaque classe polymorphe dans le programme compilé. Les compilateurs disposent généralement d'options pour désactiver l'inclusion de ces informations.

Mots-clés

dynamic_cast

Exemple

#include <iostream>
struct V
{
    virtual void f() {} // doit être polymorphe pour utiliser dynamic_cast vérifié à l'exécution
};
struct A : virtual V {};
struct B : virtual V
{
    B(V* v, A* a)
    {
        // casts pendant la construction (voir l'appel dans le constructeur de D ci-dessous)
        dynamic_cast<B*>(v); // bien défini : v de type V*, V base de B, donne B*
        dynamic_cast<B*>(a); // comportement indéfini : a a le type A*, A n'est pas une base de B
    }
};
struct D : A, B
{
    D() : B(static_cast<A*>(this), this) {}
};
struct Base
{
    virtual ~Base() {}
};
struct Derived : Base
{
    virtual void name() {}
};
int main()
{
    D d; // l'objet le plus dérivé
    A& a = d; // upcast, dynamic_cast peut être utilisé, mais inutile
    [[maybe_unused]]
    D& new_d = dynamic_cast<D&>(a); // downcast
    [[maybe_unused]]
    B& new_b = dynamic_cast<B&>(a); // sidecast
    Base* b1 = new Base;
    if (Derived* d = dynamic_cast<Derived*>(b1); d != nullptr)
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // sûr d'appeler
    }
    Base* b2 = new Derived;
    if (Derived* d = dynamic_cast<Derived*>(b2); d != nullptr)
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // sûr d'appeler
    }
    delete b1;
    delete b2;
}

downcast from b2 to d successful

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Références

Voir aussi

• const_cast
• static_cast
• reinterpret_cast
• conversion explicite
• conversions implicites