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

来自cppreference.com
 
C++
 
内存管理库
(仅用于阐述*)
分配器
未初始化内存算法
受约束的未初始化内存算法
内存资源
未初始化存储 (C++20 前)
(C++17 弃用)
(C++17 弃用)
(C++17 弃用)

垃圾收集器支持 (C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
(C++11)(C++23 前)
 
std::shared_ptr
成员函数
修改器
观察器
(C++17)
(C++20 前*)
(C++26)
(C++26)
非成员函数
(C++20)
(C++20)
(C++17)
(C++20 前)(C++20 前)(C++20 前)(C++20 前)(C++20 前)(C++20)
函数 (C++26 前*)
辅助类
(C++20)
推导指引(C++17)
 
在标头 <memory> 定义 
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(1) (C++11 起)
(C++26 起为 constexpr)		 
template< class T, class U >
std::shared_ptr<T> static_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(2) (C++20 起)
(C++26 起为 constexpr)		 
template< class T, class U >
std::shared_ptr<T>
    dynamic_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(3) (C++11 起)
(C++26 起为 constexpr)		 
template< class T, class U >
std::shared_ptr<T> dynamic_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(4) (C++20 起)
(C++26 起为 constexpr)		 
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(5) (C++11 起)
(C++26 起为 constexpr)		 
template< class T, class U >
std::shared_ptr<T> const_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(6) (C++20 起)
(C++26 起为 constexpr)		 
template< class T, class U >
std::shared_ptr<T>
    reinterpret_pointer_cast( const std::shared_ptr<U>& r ) noexcept;
(7) (C++17 起) 
template< class T, class U >
std::shared_ptr<T> reinterpret_pointer_cast( std::shared_ptr<U>&& r ) noexcept;
(8) (C++20 起)

创建新的 std::shared_ptr 对象，它存储的指针从 r 的存储指针用转型表达式获得。

  • 如果 r 为空，那么新的 shared_ptr 也为空（但它存储的指针不一定为空）。
  • 否则，新的 shared_ptr 将与 r 的初始值共享所有权，但它在 dynamic_pointer_cast 所进行的 dynamic_cast 返回空指针时为空。
3,4) 设 expr 为表达式 dynamic_cast<typename shared_ptr<T>::element_type*>(r.get())：
  • 如果 expr 非良构，那么程序非良构。
  • 如果 expr 不具有良构行为，那么行为未定义。

如果以下表达式非良构，那么程序非良构：

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)

参数

r - 要转换的指针

返回值

设 Y 为 typename std::shared_ptr<T>::element_type：

1) shared_ptr<T>(r, static_cast<Y*>(r.get()))
2) shared_ptr<T>(std::move(r), static_cast<Y*>(r.get()))
3,4) 设 p 为 dynamic_cast<Y*>(r.get())：
3) p ? shared_ptr<T>(r, p) : shared_ptr<T>()
4) p ? shared_ptr<T>(std::move(r), p) : shared_ptr<T>()
5) shared_ptr<T>(r, const_cast<Y*>(r.get()))
6) shared_ptr<T>(std::move(r), const_cast<Y*>(r.get()))
7) shared_ptr<T>(r, reinterpret_cast<Y*>(r.get()))
8) shared_ptr<T>(std::move(r), reinterpret_cast<Y*>(r.get()))

注解

表达式 std::shared_ptr<T>(/* ***_cast */<T*>(r.get())) 看起来可能拥有相同效果，但它很可能导致未定义行为，试图删除同一对象两次。

调用右值重载 (2,4,6,8) 后，r 为空且 r.get() == nullptr，但对于 dynamic_pointer_cast (4)，在 dynamic_cast 失败时不会修改 r。

(C++20 起)

示例

运行此代码
#include <iostream>
#include <memory>
 
class Base
{
public:
    int a;
    virtual void f() const { std::cout << "我是基类！\n"; }
    virtual ~Base() {}
};
 
class Derived : public Base
{
public:
    void f() const override { std::cout << "我是派生类！\n"; }
    ~Derived() {}
};

int main()
{
    auto basePtr = std::make_shared<Base>();
    std::cout << "基类指针说：";
    basePtr->f();
    
    auto derivedPtr = std::make_shared<Derived>();
    std::cout << "派生类指针说：";
    derivedPtr->f();
    
    // 沿类层次向上的 static_pointer_cast
    basePtr = std::static_pointer_cast<Base>(derivedPtr);
    std::cout << "指向派生类的基类指针说：";
    basePtr->f();
    
    // 沿类层次向下/跨类层次的 dynamic_pointer_cast
    auto downcastedPtr = std::dynamic_pointer_cast<Derived>(basePtr);
    if (downcastedPtr)
    {
        std::cout << "向下转型的指针说：";
        downcastedPtr->f();
    }
    
    // 所有指向派生类的指针都共享所有权
    std::cout << "指向底层派生类的指针数量："
              << derivedPtr.use_count()
              << '\n';
}

输出： 

基类指针说：我是基类！
派生类指针说：我是派生类！
指向派生类的基类指针说：我是派生类！
向下转型的指针说：我是派生类！
指向底层派生类的指针数量：3

参阅

 构造新的 shared_ptr
(公开成员函数) [编辑]