当前位置： 首页 > news >正文

智能指针(shared_ptr)之二

news 来源：原创 2025/4/24 15:40:10

1. std::shared_ptr

1.1 定义与用法

std::shared_ptr 是一种共享所有权的智能指针，允许多个 shared_ptr 实例共享对同一个对象的所有权。通过引用计数机制，管理资源的生命周期。

主要特性：

  • 共享所有权：多个 shared_ptr 可以指向同一个对象。
  • 引用计数：跟踪有多少 shared_ptr 实例指向同一对象。
  • 自动释放：当引用计数为0时，自动释放资源。

1.2 引用计数与控制块

shared_ptr 背后依赖一个控制块（Control Block），用于存储引用计数和指向实际对象的指针。控制块的主要内容包括：

  • 强引用计数
  • 弱引用计数

1.3 构造函数与赋值

shared_ptr 提供多种构造函数和赋值操作，以支持不同的使用场景。

  • 默认构造函数：创建一个空的 shared_ptr。
  • 指针构造函数：接受一个裸指针，拥有其所有权。
  • 拷贝构造函数：增加引用计数，共享对象所有权。
  • 移动构造函数：转移所有权，源 shared_ptr 变为空。
  • 拷贝赋值操作符：释放当前资源，增加引用计数，指向新对象。
  • 移动赋值操作符：释放当前资源，转移所有权，源 shared_ptr 变为空。

1.4 代码案例

#include <iostream>
#include <memory>class Test
{
public:Test(int val) : value(val){std::cout << "Test(int val) " << std::endl;}Test(Test &&){std::cout << "Test moved\n";}~Test(){std::cout << "~Test() " << std::endl;}void show() const{std::cout << "Value: " << value << std::endl;}private:int value;
};int main()
{// shared_ptr<T>接受的是一个已经创建好的指针或者nullptrstd::shared_ptr<Test> ptr1(new Test(100)); // 不推荐Test *t1 = new Test(100);std::shared_ptr<Test> ptr2(t1); // 不推荐,原生指针和只能指针共同存在// std::shared_ptr<Test> ptr2_ = t1;  // 不推荐,这是隐式构造，而且shared_ptr也不支持 explicit shared_ptr( T* p) noexcept;Test t2(100);std::shared_ptr<Test> ptr3(&t2); // error,  shared_ptr 默认使用 delete 释放资源，但 t2 是栈上的对象，不能 delete，// 会导致 ​​未定义行为（UB）​​（通常是程序崩溃）。std::shared_ptr<Test> ptr4(); // 实际上是一个函数声明，不是初始化！可以用std::shared_ptr<Test> ptr4{};std::shared_ptr<Test> ptr4_(nullptr);// make_unique<T>会调用T对应的构造函数std::shared_ptr<Test> ptr5 = std::make_shared<Test>(100); // 推荐!std::shared_ptr<Test> ptr5_ = ptr5; // 调用的是拷贝构造，会增加其引用计数std::cout << "ptr5 use_count: " << ptr5.use_count() << std::endl;/*调用的是shared_ptr里面的operator bool()函数：explicit operator bool() const noexcept{return get() != nullptr;}if (!ptr5) 等价于：if(!ptr5.operator bool())*/if (!ptr5){std::cout << "ptr5 is now nullptr" << std::endl;}ptr5.reset(new Test(300));  //释放detele原资源(如果引用计数为0，否则引用计数-1)、接管新资源，是替换资源最干净、安全的方式。ptr5.get()->show();   //借用原生指针ptr5.reset(); //调用 delete 销毁这个对象(如果引用计数为0，否则引用计数-1)，然后把内部的指针设为 nullptr，并不是销毁了ptr5return 0;
}

输出：

Test(int val) 
Test(int val)
Test(int val)
Test(int val)
ptr5 use_count: 2
Test(int val)
Value: 300
~Test()
~Test()
~Test()

SimpleSharedPtr 的完整实现及其使用示例。

#include <iostream>// 控制块结构
struct ControlBlock {int ref_count;ControlBlock() : ref_count(1) {}
};// 简化版的 shared_ptr 实现
template <typename T>
class SimpleSharedPtr {
private:T* ptr;                // 指向管理的对象ControlBlock* control; // 指向控制块// 释放当前资源void release() {if (control) {control->ref_count--;std::cout << "Decremented ref_count to " << control->ref_count << std::endl;if (control->ref_count == 0) {delete ptr;delete control;std::cout << "Resource and ControlBlock destroyed." << std::endl;}}ptr = nullptr;control = nullptr;}public:// 默认构造函数SimpleSharedPtr() : ptr(nullptr), control(nullptr) {std::cout << "Default constructed SimpleSharedPtr (nullptr)." << std::endl;}// 参数化构造函数explicit SimpleSharedPtr(T* p) : ptr(p) {if (p) {control = new ControlBlock();std::cout << "Constructed SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;} else {control = nullptr;}}// 拷贝构造函数SimpleSharedPtr(const SimpleSharedPtr& other) : ptr(other.ptr), control(other.control) {if (control) {control->ref_count++;std::cout << "Copied SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;}}// 拷贝赋值操作符SimpleSharedPtr& operator=(const SimpleSharedPtr& other) {if (this != &other) {release();ptr = other.ptr;control = other.control;if (control) {control->ref_count++;std::cout << "Assigned SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;}}return *this;}// 移动构造函数SimpleSharedPtr(SimpleSharedPtr&& other) noexcept : ptr(other.ptr), control(other.control) {other.ptr = nullptr;other.control = nullptr;std::cout << "Moved SimpleSharedPtr." << std::endl;}// 移动赋值操作符SimpleSharedPtr& operator=(SimpleSharedPtr&& other) noexcept {if (this != &other) {release();ptr = other.ptr;control = other.control;other.ptr = nullptr;other.control = nullptr;std::cout << "Move-assigned SimpleSharedPtr." << std::endl;}return *this;}// 析构函数~SimpleSharedPtr() {release();}// 解引用操作符T& operator*() const {return *ptr;}// 箭头操作符T* operator->() const {return ptr;}// 获取引用计数int use_count() const {return control ? control->ref_count : 0;}// 获取裸指针T* get() const {return ptr;}// 重置指针void reset(T* p = nullptr) {release();ptr = p;if (p) {control = new ControlBlock();std::cout << "Reset SimpleSharedPtr, ref_count = " << control->ref_count << std::endl;} else {control = nullptr;}}
};// 测试类
class Test {
public:Test(int val) : value(val) {std::cout << "Test Constructor: " << value << std::endl;}~Test() {std::cout << "Test Destructor: " << value << std::endl;}void show() const {std::cout << "Value: " << value << std::endl;}private:int value;
};int main() {std::cout << "Creating default constructed shared_ptr..." << std::endl;SimpleSharedPtr<Test> ptr1; // 默认构造std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;std::cout << "\nCreating shared_ptr with resource..." << std::endl;SimpleSharedPtr<Test> ptr2(new Test(100)); // 非默认构造std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;ptr2->show();std::cout << "\nCopying ptr2 to ptr3..." << std::endl;SimpleSharedPtr<Test> ptr3 = ptr2; // 拷贝构造std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;ptr3->show();std::cout << "\nAssigning ptr3 to ptr1..." << std::endl;ptr1 = ptr3; // 拷贝赋值std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;std::cout << "\nResetting ptr2..." << std::endl;ptr2.reset(new Test(200)); // 重新指向新的对象std::cout << "ptr2 use_count: " << ptr2.use_count() << std::endl;ptr2->show();std::cout << "ptr1 use_count: " << ptr1.use_count() << std::endl;std::cout << "ptr3 use_count: " << ptr3.use_count() << std::endl;std::cout << "\nExiting scope..." << std::endl;} // ptr2, ptr1, ptr3 离开作用域std::cout << "End of main." << std::endl;return 0;
}

1.5 enable_shared_from_this

它允许一个对象在 不自己持有自身的 shared_ptr 的情况下，获得一个指向自己的 shared_ptr 实例。

为什么不能直接用 std::shared_ptr(this)？

看这个反面例子：

class MyClass {
public:void doSomething() {std::shared_ptr<MyClass> ptr(this);  // ❌危险！会 double delete！}
};
  • 这里你直接用 shared_ptr(this) 会产生一个新的 shared_ptr 实例，它并不知道有没有其他 shared_ptr 管理着这个对象。
  • 如果你之前已经用 std::make_shared<MyClass>() 创建过一个，这里再来一次相当于有两个独立的 shared_ptr，它们都会尝试在析构时删除这个对象，就爆炸了（double free）。

正确做法：用 enable_shared_from_this

#include <memory>
#include <iostream>class MyClass : public std::enable_shared_from_this<MyClass> {
public:void doSomething() {std::shared_ptr<MyClass> ptr = shared_from_this(); // 安全！std::cout << "use_count: " << ptr.use_count() << std::endl;}
};int main() {std::shared_ptr<MyClass> obj = std::make_shared<MyClass>();obj->doSomething(); // ✅ 没问题
}
  • 当你继承了 enable_shared_from_this，并用 make_shared 构造对象时，enable_shared_from_this 内部会记录这个对象的 shared_ptr。
  • 所以调用 shared_from_this() 就能安全地返回一个新的 shared_ptr 指向自己，而不是重新创建一个。

🧠 小总结：

用途作用
std::enable_shared_from_this<T>允许类内部通过 shared_from_this() 获取自身的 shared_ptr
解决问题避免 shared_ptr(this) 导致的 双重删除 / 崩溃
依赖前提对象必须是由 shared_ptr 创建的，否则 shared_from_this() 会抛异常

相关文章：

  • 新手村：正则化
  • 高防IP是什么
  • Linux——进程优先级/切换/调度
  • LeetCode算法题(Go语言实现)_58
  • Linux系统编程---精灵进程与守护进程
  • 基于 Vue 2 开发的分页卡片列表组件（带懒加载和点击事件）
  • 对流对象的理解
  • 知识储备-DC综合相关
  • 新手村：过拟合（Overfitting）
  • # 深度学习中的学习率调度：以 PyTorch 图像分类为例
  • Java 开发瓶颈破局：飞算 JavaAI 如何一站式生成标准化项目结构？
  • 云贝餐饮 最新 V3 独立连锁版 全开源 多端源码 VUE 可二开
  • C++面向对象特性之继承篇
  • 生物计算安全攻防战：从DNA存储破译到碳基芯片防御体系重构
  • PowerQuery汇总整个文件夹中的数据
  • DC-2寻找Flag1、2、3、4、5，wpscan爆破、git提权
  • python：mido 提取 midi文件中某一音轨的音乐数据
  • 容器修仙传 我的灵根是Pod 第7章 傀儡秘术（StatefulSet）
  • 电控---DMP库
  • Java 加密与解密：从算法到应用的全面解析
  • 岭南非遗大IP来上海了，舞剧《英歌》在文化广场连演两场
  • 陕西全省公开征集涉企行政执法问题线索，切实减轻企业负担
  • 沂水县委书记陈士贤，跨市履新泰安市委常委、组织部部长
  • 生态环境部：我国核电规模全球第一，总体安全可控
  • 央行研究局局长答澎湃：持续优化跨境金融服务政策工具箱，有效支持企业走出去
  • “动漫短剧”值不值得做？