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

定义于头文件 <memory>。

声明

C++20

// 1)
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 2)
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
// 3)
template< class T, class U >
std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 4)
template< class T, class U >
std::shared_ptr<T> dynamic_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
// 5)
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 6)
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
// 7)
template< class T, class U >
std::shared_ptr<T> reinterpret_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 8)
template< class T, class U >
std::shared_ptr<T> reinterpret_pointer_cast( std::shared_ptr<U>&& r ) noexcept;

C++17

// 1)
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 3)
template< class T, class U >
std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 5)
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 7)
template< class T, class U >
std::shared_ptr<T> reinterpret_pointer_cast( const std::shared_ptr<U>& r ) noexcept;

C++11

// 1)
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 3)
template< class T, class U >
std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
// 5)
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ) noexcept;

创建一个新的 std::shared_ptr 实例，其存储的指针是通过对 r 的存储指针进行类型转换表达式获得的。

如果 r 是空的，那么新的 shared_ptr 也是空的（但其存储的指针不一定为 null）。否则，新的 shared_ptr 将与 r 的初始值共享所有权，但如果 dynamic_pointer_cast 执行的 dynamic_cast 返回一个 null 指针，则它为空。

令 Y 为类型 std::shared_ptr<T>::element_type，则结果 std::shared_ptr 的存储指针将通过分别求值获得：

1-2) static_cast<Y*>(r.get())
3-4) dynamic_cast<Y*>(r.get()) (如果 dynamic_cast 的结果是 null 指针值，则返回的 shared_ptr 将为空。)
5-6) const_cast<Y*>(r.get())
7-8) reinterpret_cast<Y*>(r.get())

除非从 U* 到 T* 的相应转换格式正确，否则这些函数的行为是未定义的。

1-2) 除非 static_cast<T*>((U*)nullptr) 格式正确，否则行为是未定义的。
3-4) 除非 dynamic_cast<T*>((U*)nullptr) 格式正确，否则行为是未定义的。
5-6) 除非 const_cast<T*>((U*)nullptr) 格式正确，否则行为是未定义的。
7-8) 除非 reinterpret_cast<T*>((U*)nullptr) 格式正确，否则行为是未定义的。

调用 rvalue 重载（2,4,6,8）后，r 为空且 r.get() == nullptr，但对于 dynamic_pointer_cast (4)，如果 dynamic_cast 失败（自 C++20 起），则 r 不会被修改。

参数

r - 要转换的指针

备注

表达式 std::shared_ptr<T>(static_cast<T*>(r.get())), std::shared_ptr<T>(dynamic_cast<T*>(r.get()))
以及 std::shared_ptr<T>(const_cast<T*>(r.get())) 看起来可能具有相同的效果，但它们都可能导致未定义行为，试图删除同一对象两次！

可能的实现

static_pointer_cast

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

dynamic_pointer_cast

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

const_pointer_cast

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

reinterpret_pointer_cast

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

示例

#include <iostream>
#include <memory>
 
class Base
{
public:
    int a;
    virtual void f() const { std::cout << "I am base!\n";}
    virtual ~Base(){}
};
 
class Derived : public Base
{
public:
    void f() const override { std::cout << "I am derived!\n"; }
    ~Derived(){}
};
 
int main()
{
    auto basePtr = std::make_shared<Base>();
    std::cout << "Base pointer says: ";
    basePtr->f();
 
    auto derivedPtr = std::make_shared<Derived>();
    std::cout << "Derived pointer says: ";
    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 to go down/across class hierarchy
    auto downcastedPtr = std::dynamic_pointer_cast<Derived>(basePtr);
    if (downcastedPtr)
    {
        std::cout << "Downcasted pointer says: ";
        downcastedPtr->f();
    }
 
    // All pointers to derived share ownership
    std::cout << "Pointers to underlying derived: "
              << derivedPtr.use_count()
              << '\n';
}

结果

Base pointer says: I am base!
Derived pointer says: I am derived!
Base pointer to derived says: I am derived!
Downcasted pointer says: I am derived!
Pointers to underlying derived: 3