std::static_pointer_cast, std::dynamic_pointer_cast, std::const_pointer_cast, std::reinterpret_pointer_cast - cppreference.com

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.

Parámetros

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.

Posible implementació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};
}

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>{};
    }
}

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};
}

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};
}

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"; 
}

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

Véase también