C++11 智能指针的Cast

最新推荐文章于 2025-04-02 21:57:11 发布
最新推荐文章于 2025-04-02 21:57:11 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： # C++11/14/17/20 文章标签： std::static_pointer_cast std::dynamic_pointer_cast std::const_pointer_cast
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/luoshabugui/article/details/103149658
版权
本文详细介绍了C++11及以后版本中智能指针的转换方法，包括static_pointer_cast, dynamic_pointer_cast, const_pointer_cast和reinterpret_pointer_cast的使用，对比了C++11之前的转换方式，展示了如何在继承层次结构中进行指针转换，并提供了具体示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一 C++11前

在C++11之前，对智能指针转换的方法大概如下：

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()))

但它们有可能导致未定义行为，即删除同一对象两次。

二 C++11

C++11开始引入了std::static_pointer_cast，std::dynamic_pointer_cast，std::const_pointer_cast。（std::reinterpret_pointer_cast在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 起)
template< class T, class U > 
std::shared_ptr<T> static_pointer_cast( std::shared_ptr<U>&& r ) noexcept; (2)(C++20 起)
template< class T, class U > 
std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r ) noexcept; (3)(C++11 起)
template< class T, class U > 
std::shared_ptr<T> dynamic_pointer_cast( std::shared_ptr<U>&& r ) noexcept; (4)(C++20 起)
template< class T, class U > 
std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r ) noexcept; (5)(C++11 起)
template< class T, class U > 
std::shared_ptr<T> const_pointer_cast( std::shared_ptr<U>&& r ) noexcept; (6)(C++20 起)
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 起)

特别是C++20中引入的右值引入版本，除了（4）若dynamic_cast失败不会更改r，（2）（6）（8）调用后，r为空且r.get() == nullptr 

三 举例

#include <iostream>
#include <memory>
 
struct Base 
{ 
    int a; 
    virtual void f() const { std::cout << "I am base!\n";}
    virtual ~Base(){}
};
 
struct Derived : Base
{
    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"; 
}

 结果：

四 参考

cppreference

std::dynamic_pointer_cast 是 C++ 中用于在 std::shared_ptr 智能指针之间进行动态类型转换的函数模板
m0_46376834的博客
03-20 1230
只能用于智能指针之间的动态类型转换，并且在进行转换时会自动检查转换的安全性。如果尝试将指向不相关类的指针进行转换，或者源指针为空指针，则返回的结果将是空指针。智能指针从一个派生类类型向另一个派生类类型进行转换，前提是这两个类之间存在继承关系。如果转换成功，将返回一个新的。，指向目标类型的对象；如果转换失败，则返回一个空的。智能指针之间进行动态类型转换的函数模板。）一起提供了方便且安全的智能指针类型转换操作。在这个示例中，我们首先创建了一个指向。以下是一个示例，展示了如何使用。如果转换成功，则可以通过。
C++智能指针滥用带来的性能与内存问题有哪些
大模型大数据攻城狮的专栏
04-30 1161
通过对std::unique_ptr、std::shared_ptr和std::weak_ptr的深入剖析，我们可以看到智能指针在内存管理中的重要作用。它们通过RAII机制和明确的所有权语义，极大地简化了资源管理流程，降低了内存相关错误的发生概率。然而，智能指针并非万能工具，其性能开销和潜在的误用问题也需要开发者格外关注。接下来的内容将聚焦于智能指针滥用带来的具体问题，例如std::shared_ptr在高并发场景下的性能瓶颈，以及循环引用等内存管理隐患。
C++11之强制类型转换（static_cast,const_cast,dynamic_cast,reinterpret_cast）
林夕07
07-15 1328
为解决C旧式类型转换的缺点，C++导入4个新的转换操作符：static_cast,const_cast,dynamic_cast,reinterpret_cast。
std::dynamic_pointer_cast
wangwl1998的博客
04-02 487
它依赖于运行时类型信息（RTTI），并且只有在转换成功时才会返回一个有效的。的详细介绍，包括其用法、行为和注意事项。通过理解其行为和限制，你可以更有效地使用。是 C++ 标准库中用于安全类型转换。是一个安全的类型转换工具，专门用于。如果转换失败，它会返回一个空指针。以下是一个完整的示例，展示。来编写安全、可靠的代码。
C++11新特性：四种类型转换cast说明
面条有点辣
02-01 3529
C++11四种cast转换笔记。
【C++ 11】c++智能指针转化:static_pointer_cast、dynamic_pointer_cast、const_pointer_cast、reinterpret_pointer_ca
qq_43331089的博客
08-25 3856
如果需要进行类层次上的上下行转换时，可以使用std::static_pointer_cast()、std::dynamic_pointer_cast、std::const_pointer_cast()和std::reinterpret_pointer_cast()。它们的功能和std::static_cast()、std::dynamic_cast、std::const_cast()和std::reinterpret_cast()类似。，只是dynamic_cast在进行下行转换的时候（即基类到派生类）
C++的四种_cast运算符
lzg_na的博客
08-29 1664
前言 在C语言中，使用强制类型转换进行变量之间的类型转换，主要形式有两种，如下： int a(10); double b=(double)a; double c=double(a); 对于进行简单的类型转换，这种方法简单有效，C++也保留了这种强制类型转换，但是这种强制类型转换无法适用于类和类的指针； ANSI-C++标准定义了四个新的转换符：reinterpret_cast, static_cast, dynamic_cast和const_cast，目的在于提供类之间的类型转换； 1、reinterpre
C++ 智能指针
TABE_的博客
05-29 8195
C++STL共提供了四个智能指针: auto_ptr, unique_ptr,shared_ptr, weak_ptr 其中C++11只支持后三个，C++98支持所有四个。 STL智能指针auto_ptrunique_ptrshared_ptrweak_ptrshare_ptr和weak_ptr的核心实现Counter简单实现share_ptr的简单实现weak_ptr简单实现 auto_ptr auto_ptr采用所有权模式，下面有一个例子： auto_ptr<string> p1 (new
C++之智能指针
weixin_54940900的博客
03-12 765
RAII是啥子？智能指针怎么传参？所谓的循环引用到底是啥？智能指针如何进行强制类型转换？学完之后感觉智能指针是真的好，真现代，以后写代码看见raw pointers心里都膈应！
C++11新特性：万字详解智能指针-unique_ptr篇
R6bandito的博客
11-28 1263
横向对比auto_ptr与unique_ptr之间差异，其中之一便是unique_ptr可以由用户自己提供自定义的删除器，而auto_ptr则不支持该功能，这也是auto_ptr淘汰的原因之一。为什么删除器如此重要？删除器（Deleter）是智能指针用来管理资源销毁方式的。默认情况下，智能指针会使用标准的 delete 或 delete[] 运算符来释放所持有的资源。但在某些情况下，例如管理文件句柄、套接字等非内存资源，或者需要自定义释放逻辑时，删除器就显得尤为重要。
C++11智能指针最全面试题及代码示例参考答案（100+面试题11万字）
大模型大数据攻城狮的专栏
08-31 1096
目录 什么是智能指针？请简述其作用。 C++ 中提供了哪几种智能指针？它们分别是什么？ 请解释 RAII（Resource Acquisition Is Initialization）原则与智能指针的关系。 智能指针如何解决内存泄漏问题？ 请比较 std::unique_ptr 和原始指针的异同。 std::shared_ptr 和 std::weak_ptr 之间有何关联？ 什么是循环引用？如何使用 std::weak_ptr 解决循环引用问题？ 智能指针在异常安全性方面有何优势？ 请简
static_pointer_cast智能指针互转，static_cast
sun007700的专栏
03-13 1168
智能指针用到的与之对应的转换函数为：static_pointer_cast、dynamic_pointer_cast、const_pointer_cast和reinterpret_pointer_cast。比如普通指针用到的static_cast、dynamic_cast、const_cast和reinterpret_cast。C++ static_cast、dynamic_cast、const_cast和reinterpret_cast。二、static_pointer_cast:静态转换。
259_C++_`std::dynamic_pointer_cast` 是 C++ 中的一个模板函数，用于进行动态类型转换操作，主要用于智能指针的转换’
HanLongXia的博客
08-27 462
`std::dynamic_pointer_cast` 是 C++ 中的一个模板函数，用于进行动态类型转换操作，主要用于智能指针的转换。它的作用是将一个派生类类型的智能指针转换为基类类型的智能指针，或者将基类类型的智能指针转换为派生类类型的智能指针。
c++_cast_最完整最详细的解释
DotLive
12-09 8708
关于强制类型转换的问题，很多书都讨论过，写的最详细的是C++ 之父的《C++ 的设计和演化》。最好的解决方法就是不要使用C风格的强制类型转换，而是使用标准C++的类型转换符：static_cast, dynamic_cast。标准C++中有四个类型转换符：static_cast、dynamic_cast、reinterpret_cast、和const_cast。下面对它们一一进行介绍。static
std::static_pointer_cast（智能指针类型转换）
lw07192522的博客
09-06 1560
是 C++11 引入的一个模板函数，用于将智能指针（例如或）从一种类型为另一种类型。它与类似，但专门用于智能指针。
dynamic_pointer_cast
qq_42996149的博客
11-13 2009
用法：dynamic_pointer_cast是一个函数模板，接受两个参数，分别是要转换的指针和目标类型的指针类型。如果转换是引用类型，会抛出std::bad_cast异常。适用对象类型：dynamic_pointer_cast适用于智能指针类型，如std::shared_ptr和std::weak_ptr，用于进行智能指针的动态类型转换。dynamic_pointer_cast只适用于std::shared_ptr和std::weak_ptr类型的智能指针，用于进行智能指针的动态类型转换。
std::dynamic_pointer_cast转换shared_ptr
hanhan的博客
08-27 1121
是 C++ 标准库中的一个函数模板，用于在共享指针之间进行动态类型转换。它允许将一个指向基类的。是一种安全的和方便的动态类型转换工具，可以帮助在继承层次结构中进行共享指针的类型转换。
c++11智能指针实现
最新发布
05-16
### C++11 智能指针实现详解 #### 1. `unique_ptr` 的实现 `unique_ptr` 是一种独占式智能指针，其核心特性在于它的不可复制性和资源的唯一所有权。其实现主要依赖于模板类以及删除拷贝构造函数和赋值运算符来确保独占性。 以下是简化版的 `unique_ptr` 实现： ```cpp template<typename T> class unique_ptr { public: // 构造函数 explicit unique_ptr(T* ptr = nullptr) noexcept : _ptr(ptr) {} // 删除拷贝构造函数和赋值运算符 unique_ptr(const unique_ptr& other) = delete; unique_ptr& operator=(const unique_ptr& other) = delete; // 移动语义 unique_ptr(unique_ptr&& other) noexcept : _ptr(other._ptr) { other._ptr = nullptr; } unique_ptr& operator=(unique_ptr&& other) noexcept { if (this != &other) { reset(other.release()); } return *this; } // 获取底层指针 T* get() const noexcept { return _ptr; } // 显式释放资源 void reset(T* ptr = nullptr) noexcept { if (_ptr && _ptr != ptr) { delete _ptr; } _ptr = ptr; } // 转让所有权 T* release() noexcept { T* temp = _ptr; _ptr = nullptr; return temp; } // 解引用操作 T& operator*() const noexcept { return *_ptr; } T* operator->() const noexcept { return _ptr; } // 判断是否为空 explicit operator bool() const noexcept { return _ptr != nullptr; } ~unique_ptr() noexcept { if (_ptr) { delete _ptr; } } private: T* _ptr = nullptr; }; ``` 此实现通过移动语义实现了资源转移的功能，并且禁用了拷贝构造函数和赋值运算符以防止共享所有权的情况发生[^3]。 --- #### 2. `shared_ptr` 的实现 `shared_ptr` 使用引用计数机制来管理动态分配的对象。当最后一个 `shared_ptr` 对象销毁时，才会释放其所管理的资源。为了提高性能并减少循环引用的风险，通常会引入控制块的概念。 以下是简化版的 `shared_ptr` 实现： ```cpp #include <memory> template<typename T> class shared_ptr { public: // 构造函数 explicit shared_ptr(T* ptr = nullptr) : _ptr(ptr), _count(new std::size_t(1)) {} // 复制构造函数 shared_ptr(const shared_ptr& other) : _ptr(other._ptr), _count(other._count) { ++(*_count); } // 赋值运算符 shared_ptr& operator=(const shared_ptr& other) { if (this != &other) { --(*_count); if (*_count == 0) { delete _ptr; delete _count; } _ptr = other._ptr; _count = other._count; ++(*_count); } return *this; } // 销毁函数 ~shared_ptr() { --(*_count); if (*_count == 0) { delete _ptr; delete _count; } } // 获取底层指针 T* get() const noexcept { return _ptr; } // 解引用操作 T& operator*() const noexcept { return *_ptr; } T* operator->() const noexcept { return _ptr; } // 返回引用计数值 long use_count() const noexcept { return static_cast<long>(*_count); } private: T* _ptr = nullptr; std::size_t* _count = nullptr; }; ``` 在此实现中，`std::size_t* _count` 表示引用计数器，用于跟踪有多少个 `shared_ptr` 正在共同拥有该资源。每当创建一个新的副本时，引用计数加一；而当一个实例被销毁时，引用计数减一。如果引用计数降为零，则表示没有任何 `shared_ptr` 存活，此时将释放资源[^1]。 --- #### 3. `weak_ptr` 的实现 `weak_ptr` 不增加引用计数，因此不会阻止所指向对象的销毁。它可以用来观察由 `shared_ptr` 管理的对象是否存在。只有当对应的 `shared_ptr` 尚未销毁时，才能通过 `lock()` 方法获得有效的 `shared_ptr`。 以下是简化版的 `weak_ptr` 实现： ```cpp template<typename T> class weak_ptr { public: // 构造函数 weak_ptr() : _sp(nullptr) {} weak_ptr(std::shared_ptr<T> sp) : _sp(sp) {} // lock 函数尝试返回一个 shared_ptr std::shared_ptr<T> lock() const { if (!_sp || !_sp.use_count()) { return std::shared_ptr<T>(); } return std::shared_ptr<T>(_sp); } // 是否过期 bool expired() const noexcept { return !(_sp && _sp.use_count()); } private: std::shared_ptr<T> _sp; }; ``` 在这个实现中，`weak_ptr` 并不直接持有原始指针，而是保存了一个对 `shared_ptr` 的弱引用。调用 `lock()` 可以检查目标对象是否仍然存在，并返回一个临时的 `shared_ptr` 来访问它[^1]。 --- ### 总结 - **`unique_ptr`** 提供了一种轻量级、高效的解决方案，适用于不需要共享所有权的场景。 - **`shared_ptr`** 基于引用计数技术，适合需要多个指针共享同一个对象的情形。 - **`weak_ptr`** 主要作为辅助工具配合 `shared_ptr` 使用，避免因循环引用而导致内存泄漏的问题。 这些智能指针的设计极大地提高了现代 C++ 中动态内存管理的安全性和便利性。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值