【C++】智能指针

原创已于 2022-10-11 11:07:53 修改 · 410 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

于 2022-10-05 22:59:21 首次发布

C++ 专栏收录该内容

3 篇文章

订阅专栏

本文详细介绍了C++中的三种智能指针：unique_ptr（独占指针）、shared_ptr（共享指针）和weak_ptr（弱指针）。unique_ptr不允许拷贝和赋值，通过reset方法管理内存。shared_ptr允许多个实例共享同一对象，当最后一个shared_ptr析构时，对象会被删除，可能存在线程安全问题。weak_ptr作为辅助类，不增加对象的引用计数，通过lock()函数获取关联的shared_ptr。

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

四种智能指针：auto_ptr（C++11已经摒弃）、unique_ptr、shared_ptr 和 weak_ptr

1、unique_ptr（独占指针）

3种创建方式

using namespace std;

// 1.使用原始指针创建
A *p1 = new A("OK");  // A是一个类
unique_ptr<A> u_p1 ( p1 );
u_p1->print();

// 2.使用new的方式创建（推荐使用）
unique_ptr<A> u_p2 ( new A("OK") );
u_p2->print();

// 3.make_unique 创建（推荐使用）
unique_ptr<A> u_p3 = make_unique<A>("OK");
u_p3->print();

任何时刻，只能有一个指针管理内存，因此不支持拷贝和赋值操作，只能移动（move），这样所有权将会被转移

unique_ptr<A> u_p4 = move(u_p2);
u_p4->print();
u_p2->print();  // 程序崩溃，因为所有权转移了

reset 方法：可以解除原始内存的管理，也可以用来初始化一个独占的智能指针

u_p4.reset();
u_p4->print();  // 程序崩溃

unique_ptr<A> u_p5;
u_p5.reset(new A(“520”));  // 初始化一个独占指针

2、shared_ptr（计数指针/共享指针）

允许多个 shared_ptr 共同管理同一个对象
每当shared_ptr的最后一个所有者被销毁时，关联对象或关联资源就会被删除
shared_ptr 对象除了包括一个所拥有对象的指针外，还必须包括一个引用计数代理对象的指针
2种创建方式

// 1.
shared_ptr<A> s_p1(new A("OK"));
s_p1->print();

// 2.
shared_ptr<A> s_p2 = make_shared<A>("OK");
s_p2->print();

reset 用法

shared_ptr<A> s_p3;
s_p3.reset(new A("point"));  // 初始化一个共享指针

其他操作

shared_ptr<A> s_p4 = make_shared<A>("OK");
cout << s_p4.use_count() << endl;       // 1
shared_ptr<A> s_p5 = s_p4;              // copy
cout << s_p4.use_count() << endl;       // 2  // 计数+1
cout << s_p5.use_count() << endl;       // 2

s_p4->set_str("ok!");                   // change
s_p4->print();                          // ok!
s_p5->print();                          // ok!

s_p4 = nullptr;                         // nullptr
cout << s_p4.use_count() << endl;       // 0   // 清空后计数为0
cout << s_p5.use_count() << endl;       // 1   // 只有一个指针共享

强制类型转换

share_ptr<void> point(new int(1)); //共享指针内部保存void型指针
share_ptr<int> point(static_cast<int *>(point.get())); //compile error，undefined pointer
static_pointer_cast<int *>(point);

// 1、static_pointer_cast
// 2、dynamic_pointer_cast
// 3、const_pointer_cast

线程安全问题

（1）同一个shared_ptr被多个线程 “读” 是安全的；
（2）同一个shared_ptr被多个线程 “写” 是不安全的；
证明：在多个线程中同时对一个shared_ptr循环执行两遍swap。shared_ptr的swap函数的作用就是和另外一个 shared_ptr交换引用对象和引用计数，是写操作。执行两遍swap之后，shared _ptr引用的对象的值应该不变
（3）共享引用计数的不同的shared_ptr被多个线程 ”写” 是安全的。

共享指针有内存泄漏风险

当两个类对象中各自有一个 shared_ptr 指向对方时，会造成循环引用（有一个shared_ptr，计数加一，那么指向的内存就不会释放，对方不释放，里面指向自己的shared_ptr就不被销毁，计数也不能为0，互相纠缠，谁也不释放内存），使引用计数失效，从而导致内存泄露。解决此问题，引入weak_ptr，其允许共享但不拥有对象所有权，因此不会增加关联对象的引用次数。

3、weak_ptr（弱指针）

弱指针是共享指针辅助类，其允许共享但不拥有对象所有权，因此不会增加关联对象的引用次数
不能使用运算符 * 和 -> 直接访问弱指针的引用对象，而是使用 lock() 函数生成关联对象的共享指针（可能为空）
当拥有该对象的最后一个共享指针失去其所有权时，任何弱指针都会自动变为空

shared_ptr<A> s_p6 = make_shared<A>("OK");
weak_ptr<A> w_p1(s_p6);             // 构造weak_ptr
cout << s_p6.use_count() << endl;   // 1
cout << w_p1.use_count() << endl;   // 1
	
shared_ptr<A> s_p7 = w_p1.lock();   // 使用lock()函数生成关联的共享指针
cout << s_p6.use_count() << endl;   // 2
cout << s_p7.use_count() << endl;   // 2
cout << w_p1.use_count() << endl;   // 2