dynamic_cast conversion

De cppreference.com

Esta página se ha traducido por ordenador/computador/computadora de la versión en inglés de la Wiki usando Google Translate.

La traducción puede contener errores y palabras aparatosas/incorrectas. Planea sobre el texto para ver la versión original. Puedes ayudar a corregir los errores y mejorar la traducción. Para instrucciones haz clic aquí.

Con seguridad convierte punteros y referencias a clases de arriba, abajo y hacia los lados a lo largo de la jerarquía de herencia .

Contenido

[editar] Sintaxis


`dynamic_cast <` new_type `> (` expression `)`

Si la operación tiene éxito, dynamic_cast devuelve un valor del tipo new_type. Si la operación falla y new_type es un puntero, se devuelve un puntero null. Si la operación falla y new_type es una referencia, se lanza una excepción de tipo std::bad_cast.

[editar] Explicación

Sólo las siguientes conversiones se puede hacer con dynamic_cast, excepto cuando tales conversiones sería desechado constness''' o volatilidad .

Original:
Only the following conversions can be done with dynamic_cast, except when such conversions would cast away constness or volatility.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Si el tipo de expression es exactamente la new_type o una versión menos cv-calificado de new_type, el resultado es expression .

Si el valor de expression es el valor del puntero nulo, el resultado es el valor de puntero nulo de new_type tipo

Si new_type es un puntero o referencia a Base, y el tipo de expression es un puntero o referencia a Derived, donde Base es una clase única, base accesible de Derived, el resultado es un puntero o una referencia a la clase subobjeto Base dentro de la Derived objeto puntiagudo o identificado por expression. (Nota: La conversión implícita y static_cast puede realizar esta conversión también)

Si expression es un puntero o una referencia a un tipo polimórfico, y new_type es un puntero a void, el resultado es un puntero a la mayoría de los derivados objeto puntiagudo o referenciado por expression .

Si expression es un puntero o referencia a un tipo polimórfico Base y new_type es un puntero o una referencia al tipo Derived una comprobación en tiempo de ejecución que se realiza

El objeto más derivado extendidos / identificado por expression se examina. Si, en ese objeto, los puntos expression / es referida a una base pública de Derived, y si sólo una subobjeto de tipo Derived se deriva del subobjeto señaló / identificado por expression, entonces el resultado de los puntos de reparto / subobjeto que se refiere a Derived. (Esto se conoce como la "abatido")

De lo contrario, si los puntos de expression / refiere a una base pública del objeto más derivada, y, simultaneamente, la mayoría de los derivados objeto tiene una clase base pública inequívoca de Derived tipo, el resultado de los puntos de reparto / refiere a que Derived (esto se conoce como la "sidecast")

De lo contrario, el tiempo de ejecución de verificación falla. Si el dynamic_cast se utiliza en punteros, el valor de puntero nulo new_type tipo se devuelve. Si se ha utilizado en las referencias, el std::bad_cast excepción .

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

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

un valor-si new_type es un tipo de valor-referencia (expression debe ser un valor-I)
Original:
an lvalue if new_type is an lvalue reference type (expression must be an lvalue)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
un xValue si new_type es un tipo de referencia rvalue (expression puede ser lvalue o rvalue)
Original:
an xvalue if new_type is an rvalue reference type (expression may be lvalue or rvalue)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
un prvalue lo contrario (en este caso, si new_type es un tipo de puntero)
Original:
a prvalue otherwise (in this case, if new_type is a pointer type)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Nota

Abatido también se puede realizar con static_cast, lo que evita el coste de la comprobación de tiempo de ejecución, pero sólo es seguro si el programa puede garantizar, a través de alguna otra lógica, que el objeto apuntado por expression es definitivamente Derived .

[editar] Palabras clave

dynamic_cast

[editar] Ejemplo

Ejecuta este código

#include <iostream>
 
struct V {
    virtual void f() {};  // must be polymorphic to use runtime-checked dynamic_cast
};
struct A : virtual V {};
struct B : virtual V {
  B(V* v, A* a) {
    // casts during construction
    dynamic_cast<B*>(v); // well-defined: v of type V*, V base of B, results in B*
    dynamic_cast<B*>(a); // undefined behavior: a has type A*, A not a base of B
  }
};
struct D : A, B {
    D() : B((A*)this, this) { }
};
 
struct Base {
    virtual ~Base() {}
};
 
struct Derived: Base {
    virtual void name() {}
};
 
int main()
{
    D d; // the most derived object
    A& a = d; // upcast, dynamic_cast may be used, but unnecessary
    D& new_d = dynamic_cast<D&>(a); // downcast
    B& new_b = dynamic_cast<B&>(a); // sidecast
 
 
    Base* b1 = new Base;
    if(Derived* d = dynamic_cast<Derived*>(b1))
    {
        std::cout << "downcast from b1 to d successful\n";
        d->name(); // safe to call
    }
 
    Base* b2 = new Derived;
    if(Derived* d = dynamic_cast<Derived*>(b2))
    {
        std::cout << "downcast from b2 to d successful\n";
        d->name(); // safe to call
    }
 
    delete b1;
    delete b2;
}

Salida:

downcast from b2 to d successful

[editar] Ver también

Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/language/dynamic_cast&oldid=33536»

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Espacios de nombres

Variantes

Vistas

Acciones