Espacios de nombres
Variantes
Acciones

std::static_pointer_cast, std::dynamic_pointer_cast, std::const_pointer_cast, std::reinterpret_pointer_cast

De cppreference.com
< cpp‎ | memory‎ | shared ptr
 
 
Biblioteca de servicios
 
Gestión de memoria dinámica
Punteros inteligentes
(C++11)
(C++11)
(C++11)
(hasta C++17)
(C++11)
(C++23)
Asignadores de memoria
Recursos de memoria
Almacenamiento no inicializado
Algoritmos de memoria no inicializada
Algoritmos restringidos de memoria no inicializada
Apoyo para recolección de basura
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
(C++11)(hasta C++23)
Misceláneos
(C++20)
(C++11)
(C++11)
 
 
Definido en el archivo de encabezado <memory>
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(1) (desde C++11)
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(2) (desde C++20)
template< class T, class U >
std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(3) (desde C++11)
template< class T, class U >
std::shared_ptr<T> dynamic_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(4) (desde C++20)
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(5) (desde C++11)
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(6) (desde C++20)
template< class T, class U >
std::shared_ptr<T> reinterpret_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(7) (desde C++17)
template< class T, class U >
std::shared_ptr<T> reinterpret_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(8) (desde C++20)

Crea una nueva instancia de std::shared_ptr cuyo puntero almacenado se obtiene del puntero almacenado de r mediante una expresión de conversión.

Si r está vacío, también lo está el nuevo shared_ptr (pero su puntero almacenado no es necesariamente nulo). De lo contrario, el nuevo shared_ptr compartirá la posesión con el valor inicial de r, excepto que está vacío si el dynamic_cast realizado por dynamic_pointer_cast devuelve un puntero nulo.

Sea Y typename std::shared_ptr<T>::element_type, luego el puntero almacenado del std::shared_ptr resultante se obtendrá evaluando, respectivamente:

1-2) static_cast<Y*>(r.get()).
3-4) dynamic_cast<Y*>(r.get()) (Si el resultado de dynamic_cast es un valor de puntero nulo, el shared_ptr devuelto estará vacío).
5-6) const_cast<Y*>(r.get()).
7-8) reinterpret_cast<Y*>(r.get()).

El comportamiento de estas funciones no está definido a menos que la conversión correspondiente de U* a T* esté bien formada:

1-2) El comportamiento no está definido a menos que static_cast<T*>((U*)nullptr) esté bien formado.
3-4) El comportamiento no está definido a menos que dynamic_cast<T*>((U*)nullptr) esté bien formado.
5-6) El comportamiento no está definido a menos que const_cast<T*>((U*)nullptr) esté bien formado.
7-8) El comportamiento no está definido a menos que reinterpret_cast<T*>((U*)nullptr) esté bien formado.

Después de llamar a las sobrecargas r-valor (2,4,6,8), r está vacío y r.get() == nullptr, excepto que r no se modifica para dynamic_pointer_cast (4) si dynamic_cast no tiene éxito.

(desde C++20)

Contenido

[editar] Parámetros

r - El puntero a convertir.

[editar] Notas

Las expresiones std::shared_ptr<T>(static_cast<T*>(r.get())), std::shared_ptr<T>(dynamic_cast<T*>(r.get())) y std::shared_ptr<T>(const_cast<T*>(r.get())) podría parecer que tienen el mismo efecto, pero es probable que todas resulten en un comportamiento no definido: intentan eliminar el mismo objeto dos veces.

[editar] Posible implementación

Primera versión
template< class T, class U > 
std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ) noexcept
{
    auto p = static_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return std::shared_ptr<T>{r, p};
}
Segunda versión
template< class T, class U > 
std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r ) noexcept
{
    if (auto p = dynamic_cast<typename std::shared_ptr<T>::element_type*>(r.get())) {
        return std::shared_ptr<T>{r, p};
    } else {
        return std::shared_ptr<T>{};
    }
}
Tercera versión
template< class T, class U > 
std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ) noexcept
{
    auto p = const_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return std::shared_ptr<T>{r, p};
}
Cuarta versión
template< class T, class U > 
std::shared_ptr<T> reinterpret_pointer_cast( const std::shared_ptr<U>& r ) noexcept
{
    auto p = reinterpret_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return std::shared_ptr<T>{r, p};
}

[editar] Ejemplo

#include <iostream>
#include <memory>
 
struct Base 
{ 
    int a; 
    virtual void f() const { std::cout << "Soy Base\n";}
    virtual ~Base(){}
};
 
struct Derivada : Base
{
    void f() const override
    { std::cout << "Soy Derivada\n"; }
    ~Derivada(){}
};
 
int main(){
    auto basePtr = std::make_shared<Base>();
    std::cout << "Puntero a Base dice: ";
    basePtr->f();
 
    auto derivedPtr = std::make_shared<Derivada>();
    std::cout << "Puntero a Derivada dice: ";
    derivedPtr->f();
 
    // static_pointer_cast to go up class hierarchy
    basePtr = std::static_pointer_cast<Base>(derivedPtr);
    std::cout << "Base pointer to derived says: ";
    basePtr->f();
 
    // dynamic_pointer_cast para ir hacia abajo/a través de la jerarquía de clases
    auto downcastedPtr = std::dynamic_pointer_cast<Derivada>(basePtr);
    if(downcastedPtr)
    { 
        std::cout << "Puntero de conversión hacia abajo dice: ";
        downcastedPtr->f(); 
    }
 
    // Todos los punteros a Derivada comparten la posesión
    std::cout << "Punteros a la Derivada subyacente: " 
            << derivedPtr.use_count() 
            << "\n"; 
}

Salida:

Puntero a Base dice: Soy Base
Puntero a Derivada dice: Soy Derivada
Base pointer to derived says: Soy Derivada
Puntero de conversión hacia abajo dice: Soy Derivada
Punteros a la Derivada subyacente: 3

[editar] Véase también

Construye un nuevo shared_ptr.
(función miembro pública) [editar]