dynamic_cast conversion

Convierte de forma segura punteros y referencias a clases hacia arriba, hacia abajo y lateralmente a lo largo de la jerarquía de herencia.

Sintaxis

Explicación

Para facilitar la descripción, " expresión o el resultado es una referencia a T " significa que "es un glvalue de tipo T " , lo cual sigue la convención de decltype (desde C++11) .

Solo las siguientes conversiones pueden realizarse con dynamic_cast , excepto cuando dichas conversiones eliminen constancia (o volatilidad).

Cuando dynamic_cast se utiliza en un constructor o destructor (directa o indirectamente), y la expresión se refiere al objeto que actualmente está en construcción/destrucción, el objeto se considera el objeto más derivado. Si el tipo-destino no es un puntero o referencia a la propia clase del constructor/destructor o a una de sus bases, el comportamiento es indefinido.

Similar a otras expresiones de conversión, el resultado es:

Notas

Un downcast también puede realizarse con static_cast , que evita el costo de la verificación en tiempo de ejecución, pero solo es seguro si el programa puede garantizar (mediante otra lógica) que el objeto apuntado por expression es definitivamente Derived .

Algunas formas de dynamic_cast dependen de la identificación de tipos en tiempo de ejecución (RTTI), es decir, información sobre cada clase polimórfica en el programa compilado. Los compiladores normalmente tienen opciones para deshabilitar la inclusión de esta información.

Palabras clave

dynamic_cast

Ejemplo

#include <iostream>
struct V
{
    virtual void f() {} // debe ser polimórfico para usar dynamic_cast verificado en tiempo de ejecución
};
struct A : virtual V {};
struct B : virtual V
{
    B(V* v, A* a)
    {
        // conversiones durante la construcción (ver la llamada en el constructor de D abajo)
        dynamic_cast<B*>(v); // bien definido: v de tipo V*, V base de B, resulta en B*
        dynamic_cast<B*>(a); // comportamiento indefinido: a tiene tipo A*, A no es 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; // el objeto más derivado
    A& a = d; // upcast, dynamic_cast puede usarse, pero no es necesario
    [[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(); // seguro de llamar
    }
    Base* b2 = new Derived;
    if (Derived* d = dynamic_cast<Derived*>(b2); d != nullptr)
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // seguro de llamar
    }
    delete b1;
    delete b2;
}

downcast from b2 to d successful

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Referencias

Véase también

• const_cast
• static_cast
• reinterpret_cast
• conversión explícita
• conversiones implícitas