c++11新特性——智能指针详解
智能指针：
一、解决了什么问题
- 内存泄漏：在未使用智能指针时，我们在堆上malloc申请一段内存或者new一个对象，如果忘记释放就会造成内存泄漏；
- 指针共享所有权的传递和释放，比如：多线程同时使用同一个对象时的析构问题。
- 使用普通指针，容易造成内存泄露（忘记释放）、二次释放、程序发生异常时内存泄露等问题等。
二、C++11 智能指针
std::auto_ptr : 已被c++11废弃
std::unique_ptr ：独占资源所有权的指针。
std::shared_ptr ：共享资源所有权的指针。
std::weak_ptr ：共享资源的观察者，需要和 std::shared_ptr 一起使用，不影响资源的生命周期。
三、线程安全问题
对于shared_ptr来说，引用计数是线程安全的，但是数据是线程不安全的，需要内部对数据进行加锁。
四、指针指针使用范例
4.1 unique_ptr
当我们想独占资源的所有权时，可以使用std::unique_ptr对资源进行管理，离开该std::unique_ptr对象的作用域时，会自动释放资源。这是很基本的RAII思想（RAII，Resource Acquisition Is Initialization，由c++之父Bjarne Stroustrup提出，即：资源获取即初始化，他说：使用局部对象来管理资源的技术称之为“资源获取即初始化”）。
4.1.1 使用裸指针，需要手动释放
{
int* p = new int(10);
// ...
delete p; // 要记得释放内存
}
4.1.2 使用unique_ptr，自动释放内存
{
std::unique_ptr<int> u_ptr = std::make_unique<int>(10);
// ...
// 离开该作用域会自动释放内存
}
4.1.3 unique_ptr所有权的转移，只支持move转移
{
std::unique_ptr<int> u_ptr = std::make_unique<int>(10);
std::unique_ptr<int> u_ptr1 = u_ptr; // 编译报错， unique_ptr只支持move转移所有权
std::shared_ptr<int> s_ptr = u_ptr; // 编译报错，不支持与shared_ptr混用
std::unique_ptr<int> u_ptr2 = std::move(u_ptr);
}
4.1.4 unique_ptr 还可以指向数组
{
std::unique_ptr<int[]> u_ptr = std::make_unique<int[]>(10);
for (int i = 0; i < 10; i++) {
u_ptr [i] = i;
}
for (int i = 0; i < 10; i++) {
std::cout << u_ptr [i] << std::endl;
}
}
4.2 shared_ptr
本质是对资源做引用计数，当引用计数为0时，释放该资源。
4.2.1 使用shared_ptr，自动释放内存
{
std::shared_ptr<int> p = new int(1); // 错误，不能将裸指针直接赋值为智能指针
std::shared_ptr<int> s_ptr = std::make_shared<int>(10);
assert(s_ptr.use_count() == 1); // 此时，s_ptr的引用计数为1
{
std::shared_ptr<int> s_ptr1 = s_ptr;
assert(s_ptr.use_count() == 1); // 此时，s_ptr的引用计数为2
}
assert(s_ptr.use_count() == 1); // 离开s_ptr1 的作用域，引用计数减1
}
// 引用计数为0，释放该资源
4.2.2 shared_ptr也可以指向数组
{
std::shared_ptr<int[]> s_ptr(new int[10]);
// std::shared_ptr u_ptr = std::make_shared(10); c++20才支持
for (int i = 0; i < 10; i++) {
s_ptr[i] = i;
}
for (int i = 0; i < 10; i++) {
std::cout << s_ptr[i] << std::endl;
}
}
4.2.3 当需要获取原始指针时，可以通过get方法。不过，谨慎使用get方法。
{
int main()
{
int *ptmp = new int(10);
std::shared_ptr<int> s_ptr(ptmp); // 裸指针委托智能指针进行管理
//std::shared_ptr s_ptr = std::make_shared(10);
int* ptr = s_ptr.get();
std::cout << ptmp << ", " << ptr << std::endl;
return 0;
}
}
4.2.4 通过 shared_from_this() 返回 this 指针
不要将this指针作为shared_ptr 返回出来，因为 this 指针本质上市裸指针，可能会导致多次析构。
#include 运行结果会调用两次析构函数。因为用一个this指针构造了两个指针指针，而这两个智能指针是没有关系的。所以，在程序结束时，都会调用各自的析构函数，导致重复析构。
正确的做法是：让需要返回的类共有继承 std::enable_shared_from_this 类，然后使用基类的成员函数shared_from_this() 来返回目标类 this 的 shared_ptr。
#include 4.2.5 循环引用，导致内存泄漏
#include 说明：循环引用导致ap和bp的引用技术都是2，在离开作用域后，各自的引用记数减1，并没有减为0。导致两个智能指针都没有被析构，导致内存泄漏。
解决方法：把A和B任何一个成员变量改为weak_ptr
五、shared_ptr实现原理
shared_ptr内部有两个指针，一个指向目标对象，另一个指向控制块，控制块包含引用计数、弱计数和删除器和其他数据。
5.1 指定删除器
在使用shared_ptr管理非new对象或者没有析构函数时，需要为其指定删除器。
//1-3-1-delete
#include 六、weak_ptr
share_ptr虽然已经很好用了，但是有一点share_ptr智能指针还是有内存泄露的情况，当两个对象相互
使用一个shared_ptr成员变量指向对方，会造成循环引用，使引用计数失效，从而导致内存泄漏。
weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从
一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。
6.1 基本用法
int main()
{
shared_ptr<int> sp(new int(10));
weak_ptr<int> wp(sp);
cout << wp.use_count() << endl; //结果讲输出1
// 通过 expired 方法判断所观察对象是否已经被释放
if(wp.expired())
cout << "weak_ptr无效,资源已释放";
else
cout << "weak_ptr有效";
return 0;
}
6.2 通过lock方法获取监视对象的shared_ptr。
举例：比如在多线程情况下
- 线程1正在使用某个shared_ptr，线程2，可能在某个时刻需要释放指针，因为线程1使用了 lock() 方法锁住这个指针，线程2只能等线程1使用完才能释放。
- 线程2已经释放了该shared_ptr，线程1会通过expired判断该资源是否还存在，规避了异常发生。
std::weak_ptr<int> gw; // 全局变量
void func()
{
auto sptr = gw.lock();
if (gw.expired()){
cout << "gw无效,资源已释放";
}else{
cout << "gw有效, *spt = " << *spt << endl;
}
}
int main()
{
{
auto sp = std::shared_ptr<int>(100);
gw = sp;
func(); // 还在shared_ptr作用域内，gw有效
}
func(); // 出了作用域，打印："gw无效,资源已释放";
}
文章参考与<零声教育>的C/C++linux服务期高级架构。