「前言」文章是关于C++11的智能指针方面
「归属专栏」C嘎嘎
「笔者」枫叶先生(fy)
「座右铭」前行路上修真我
「枫叶先生有点文青病」
「每篇一句」
人生就是一列开往坟墓的列车，
路途上会有很多站，
很难有人自始至终陪着你走完。
当陪你的人要下车时，
即使不舍也该心存感激，
然后挥手道别。
——宫崎骏
目录
一、 为何需要智能指针
1.1 内存泄漏问题
1.2 使用智能指针解决
1.3 智能指针的原理
二、C++的智能指针
2.1 std::auto_ptr
2.2 std::unique_ptr
2.5 std::weak_ptr
三、C++11和boost中智能指针的关系
一、 为何需要智能指针
1.1 内存泄漏问题
关于内存泄漏的问题，例如下面的代码：
#include <iostream>
using namespace std;
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
int* p1 = new int;
int* p2 = new int;
cout << div() << endl;
delete p1;
delete p2;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}执行上述代码时，如果输入的除数为0，那么div函数中就会抛出异常，这时程序的执行流会直接跳转到主函数中的 catch块中执行，最终导致 Func函数中申请的内存资源没有得到释放
对于这种情况，我们可以在 Func函数中先对 div函数中抛出的异常进行捕获，捕获后先将之前申请的内存资源释放，然后再将异常重新抛出，代码如下
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
int* p1 = new int;
int* p2 = new int;
try
{
cout << div() << endl;
}
catch (...)
{
delete p1;
delete p2;
throw;
}
delete p1;
delete p2;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}new也会抛异常的，如果p1这里new 抛异常，这时程序的执行流会直接跳转到主函数中的 catch块中执行，这里没有问题。假设p1没有问题，那如果p2的 new 也抛异常呢？需要再嵌套一个 try、catch？？
void Func()
{
int* p1 = new int;
int* p2 = nullptr;
try
{
int* p2 = new int;//p2的new可能会抛异常
try
{
cout << div() << endl;
}
catch (...)
{
delete p1;
delete p2;
throw;
}
}
catch (...)
{
delete p1;
throw;
}
delete p1;
delete p2;
}这样的代码显得很low，疯狂嵌套try、catch语句，所以为了解决这个问题就出现的智能指针。
补充：内存泄漏分类，C/C++程序中一般我们关心两种方面的内存泄漏：
- 堆内存泄漏(Heap leak)：堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
- 系统资源泄漏：指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具
1.2 使用智能指针解决
什么是智能指针？？
- 把申请到的内存空间交给了一个 SmartPtr 进行管理
- 在构造SmartPtr对象时，把需要被管理的内存空间传入SmartPtr 的对象中
- 在 SmartPtr 对象消亡时，SmartPtr 的析构函数中会自动将管理的内存空间进行释放、
- 如果出现抛异常的情况，申请的空间会随着 SmartPtr 对象的生命周期而释放，内存泄漏的问题可以得到很好的解决
- 为了让 SmartPtr 对象能够像原生指针一样使用，还需要对
*和->运算符进行重载
例如：
//智能指针
template<class T>
class SmartPtr
{
public:
SmartPtr(T* ptr)
:_ptr(ptr)
{}
~SmartPtr()
{
cout << "delete: " << _ptr << endl;
delete _ptr;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
int div()
{
int a, b;
cin >> a >> b;
if (b == 0)
throw invalid_argument("除0错误");
return a / b;
}
void Func()
{
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(new int);
cout << div() << endl;
}
int main()
{
try
{
Func();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}上面的代码中将申请到的内存空间交给了一个SmartPtr的对象 sp1、sp2进行管理，这样一来，无论程序是正常执行完毕返回了，还是因为某些原因中途返回了，或是因为抛异常返回了，只要SmartPtr对象的生命周期结束就会调用其对应的析构函数，进而完成内存资源的释放。
1.3 智能指针的原理
（1）RAII
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。
这种做法有两大好处：
- 不需要显式地释放资源。
- 采用这种方式，对象所需的资源在其生命期内始终保持有效
比如：
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
}
private:
T* _ptr;
};（2）像指针行为
上述（1）的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：智能指针中还得需要将 * 、-> 重载下，才可让其像指针一样去使用
template<class T>
class SmartPtr {
public:
SmartPtr(T* ptr = nullptr)
: _ptr(ptr)
{}
~SmartPtr()
{
if (_ptr)
delete _ptr;
}
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
T* _ptr;
};总结一下智能指针的原理：
- RAII特性
- 重载operator*和opertaor->，具有像指针一样的行为
但是这样的智能指针还不够完善，会存在智能指针对象拷贝的问题，所以C++出现了不同版本的智能指针
决智能指针对象的拷贝问题：比如上面实现的智能指针 SmartPtr类，如果用一个SmartPtr对象来拷贝构造另一个SmartPtr对象，或是将一个SmartPtr对象赋值给另一个SmartPtr对象，都会导致程序崩溃
int main()
{
SmartPtr<int> sp1(new int);
SmartPtr<int> sp2(sp1); //拷贝构造
SmartPtr<int> sp3(new int);
SmartPtr<int> sp4(new int);
sp3 = sp4; //拷贝赋值
return 0;
}
原因：
- 编译器默认生成的拷贝构造函数对内置类型完成值拷贝（浅拷贝），因此用sp1拷贝构造sp2后，相当于这sp1和sp2管理了同一块内存空间，当sp1和sp2析构时就会导致这块空间被释放两次。
- 编译器默认生成的拷贝赋值函数对内置类型也是完成值拷贝（浅拷贝），因此将sp4赋值给sp3后，相当于sp3和sp4管理的都是原来sp3管理的空间，当sp3和sp4析构时就会导致这块空间被释放两次，并且还会导致sp4原来管理的空间没有得到释放
二、C++的智能指针
2.1 std::auto_ptr
C++98版本的库中就提供了 auto_ptr 的智能指针，文档介绍：std::auto_ptr
头文件：
#include <memory> 
auto_ptr 通过管理权转移的方式解决智能指针的拷贝问题，保证一个资源在任何时刻都只有一个对象在对其进行管理，这时同一个资源就不会被多次释放了
测试代码如下：
int main()
{
std::auto_ptr<int> ap1(new int(1));
std::auto_ptr<int> ap2(ap1);
*ap2 = 10;
std::auto_ptr<int> ap3(new int(1));
std::auto_ptr<int> ap4(new int(2));
ap3 = ap4;
return 0;
}进行调试查看：
对一个对象的管理权转移后也就意味着，该对象不能再用对原来管理的资源进行访问了，会造成对象悬空，比如上面的 sp1、sp2，继续使用这两个对象程序就会直接崩溃，因此使用 auto_ptr之前必须先了解它的机制，否则程序很容易出问题。
auto_ptr是一个失败设计，很多公司也都明确规定了禁止使用auto_ptr
auto_ptr的简单模拟实现
namespace fy
{
template<class T>
class auto_ptr
{
public:
//RAII
auto_ptr(T* ptr)
:_ptr(ptr)
{}
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
sp._ptr = nullptr;// 管理权转移
}
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
if (this != &ap)// 检测是否为自己给自己赋值
{
// 释放当前对象中资源
if (_ptr)
delete _ptr;
// 转移ap中资源到当前对象中
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
~auto_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};
}2.2 std::unique_ptr
unique_ptr是C++11中引入的智能指针，unique_ptr通过防拷贝的方式解决智能指针的拷贝问题，也就是简单粗暴的防止对智能指针对象进行拷贝，这样也能保证资源不会被多次释放
头文件：
#include <memory> 文档介绍：unique_ptr
测试代码
int main()
{
std::unique_ptr<int> up1(new int(1));
std::unique_ptr<int> up2(up1); //error,不允许拷贝
return 0;
}编译报错
unique_ptr简单模拟实现
namespace fy
{
template<class T>
class unique_ptr
{
public:
// RAII
unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//防拷贝
unique_ptr(const unique_ptr<T>&sp) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
private:
T* _ptr;
};
}2.3 std::shared_ptr
shared_ptr是 C++11中引入的智能指针，shared_ptr通过引用计数的方式解决智能指针的拷贝问题，也就是说shared_ptr支持拷贝
头文件：
#include <memory> 文档介绍：shared_ptr
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源
- shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
- 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
- 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
- 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了
通过这种引用计数的方式就能支持多个对象一起管理某一个资源，也就是支持了智能指针的拷贝，并且只有当一个资源对应的引用计数减为0时才会释放资源，因此保证了同一个资源不会被释放多次
测试代码：
// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
int main()
{
shared_ptr<int> sp1(new int(1));
shared_ptr<int> sp2(sp1);
*sp1 = 2;
*sp2 = 3;
//use_count成员函数，用于获取当前对象管理的资源对应的引用计数
cout << sp1.use_count() << endl;
shared_ptr<int> sp3(new int(1));
shared_ptr<int> sp4(new int(2));
shared_ptr<int> sp5(new int(3));
sp4 = sp3;
sp5 = sp3;
cout << sp3.use_count() << endl;
return 0;
}
运行结果
调试查看
shared_ptr简单模拟实现
- 需要增加一个成员变量count，表示智能指针对象管理的资源对应的引用计数
- 在构造函数中申请资源，开辟在堆上，并初始化引用计数，设置为1，表示当前只有一个对象在管理这个资源
- 在拷贝构造函数中，拷贝一次，需同时将该资源对应的引用计数++
- 在拷贝赋值函数中，先将当前对象管理的资源对应的引用计数--（如果减为0则需要释放），然后再与传入对象一起管理它管理的资源，同时需要将该资源对应的引用计数++。
- 在析构函数中，将管理资源对应的引用计数 --，如果减为0则需要将该资源释放
namespace fy
{
template<class T>
class shared_ptr
{
public:
// (1)RAII
shared_ptr(T* ptr)
:_ptr(ptr)
,_pCount(new int(1))
{}
~shared_ptr()
{
if (--(*_pCount) == 0)
{
if (_ptr != nullptr)
{
std::cout << "_ptr: " << _ptr << std::endl;
delete _ptr;
_ptr = nullptr;
}
delete _pCount;
_pCount = nullptr;
}
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pCount(sp._pCount)
{
++(*_pCount);
}
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
if (_ptr != sp._ptr)//管理同一块空间的对象之间无需进行赋值操作
{
if (--(*_pCount) == 0)
{
std::cout << "operator= delete: " << _ptr << std::endl;
delete _ptr;
delete _pCount;
}
_ptr = sp._ptr;
_pCount = sp._pCount;
++(*_pCount);
}
return *this;
}
//获取引用计数
int use_count()
{
return *_pCount;
}
// (2)可以像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;//管理的资源
int* _pCount; //管理的资源对应的引用计数
};测试运行
注意：shared_ptr中的引用计数count不能单纯的定义成一个int类型的成员变量，因为这就意味着每个shared_ptr对象都有一个自己的count成员变量，而当多个对象要管理同一个资源时，这几个对象应该用到的是同一个引用计数
2.4 shared_ptr线程安全问题
上面模拟实现的 shared_pt r还存在线程安全的问题，由于管理同一个资源的多个对象的引用计数是共享的，因此多个线程可能会同时对同一个引用计数进行自增或自减操作，而自增和自减操作都不是原子操作，因此需要通过加锁来对引用计数进行保护，否则就会导致线程安全问题
所以需要对代码中的 ++ -- 操作进行加锁
修改代码如下：
#pragma once
#include <iostream>
#include <memory>
#include <mutex>
namespace fy
{
template<class T>
class shared_ptr
{
public:
// (1)RAII
shared_ptr(T* ptr)
:_ptr(ptr)
,_pCount(new int(1))
, _mutex(new mutex)
{}
//对++操作进行加锁
void Add()
{
_mutex->lock();
(*_pCount)++;
_mutex->unlock();
}
//对--操作进行加锁
void Release()
{
_mutex->lock();
bool flag = false;
if (--(*_pCount) == 0) //将管理的资源对应的引用计数--
{
if (_ptr != nullptr)
{
cout << "delete: " << _ptr << endl;
delete _ptr;
delete _pCount;
_ptr = nullptr;
_pCount = nullptr;
flag = true;
}
}
_mutex->unlock();
if (flag == true)//释放锁
{
delete _mutex;
}
}
~shared_ptr()
{
Release();
}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pCount(sp._pCount)
, _mutex(sp._mutex)
{
Add();
}
shared_ptr<T>& operator=(shared_ptr<T>& sp)
{
if (_ptr != sp._ptr)//管理同一块空间的对象之间无需进行赋值操作
{
Release();
_ptr = sp._ptr;
_pCount = sp._pCount;
_mutex = sp._mutex;
Add();
}
return *this;
}
//获取引用计数
int use_count()
{
return *_pCount;
}
// (2)可以像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;//管理的资源
int* _pCount; //管理的资源对应的引用计数
mutex* _mutex; //管理的资源对应的互斥锁
};
}- 在Release函数中，当引用计数被减为0时需要释放互斥锁资源，但不能在临界区中释放互斥锁，因为后面还需要进行解锁操作，因此代码中借助了一个flag变量，通过flag变量来判断解锁后释放需要释放互斥锁资源
- shared_ptr只需要保证引用计数的线程安全问题，而不需要保证管理的资源的线程安全问题
- 指向堆上资源的线程安全问题是访问的人处理的，智能指针不管，也管不了
智能指针的定制删除器
当智能指针对象的生命周期结束时，所有的智能指针默认都是以delete的方式将资源释放，这是不太合适的，因为智能指针并不是只管理以new方式申请到的内存空间，智能指针管理的也可能是以new[]的方式申请到的空间，或管理的是一个文件指针，以new[]的方式申请到的内存空间必须以delete[]的方式进行释放，而文件指针必须通过调用fclose函数进行释放
定制删除器是通过仿函数、Lambda表达式或函数指针来实现的，这里简单了解一下，定制删除器是实现很复杂。
2.5 std::weak_ptr
shared_ptr存在一个致命的缺陷：循环引用，为了解决这个问题，产生了weak_ptr。 weak_ptr是C++11中引入的智能指针，weak_ptr不是用来管理资源的释放的，weak_ptr 是对 shared_ptr的补充。
头文件：
#include <memory> 文档介绍：weak_ptr
循环引用问题
shared_ptr的循环引用问题在一些特定的场景下才会产生。
比如定义如下的结点类：在堆上新建了两个节点，并将这两个结点连接起来，最后再释放这两个节点
struct ListNode
{
ListNode* _next;
ListNode* _prev;
int _val;
~ListNode(){ cout << "~ListNode()" << endl;}
};
int main()
{
//新建节点
ListNode* node1 = new ListNode;
ListNode* node2 = new ListNode;
node1->_next = node2;
node2->_prev = node1;
//释放
delete node1;
delete node2;
return 0;
}上述程序是没有问题的，两个结点都能够正确释放。为了防止程序中途返回或抛异常等原因导致结点未被释放，我们将这两个结点分别交给两个shared_ptr对象进行管理，这时为了让连接节点时的赋值操作能够执行，就需要把ListNode类中的next和prev成员变量的类型也改为shared_ptr类型
struct ListNode
{
std::shared_ptr<ListNode> _next;
std::shared_ptr<ListNode> _prev;
int _val;
~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
//新建节点
std::shared_ptr<ListNode> node1(new ListNode);
std::shared_ptr<ListNode> node2(new ListNode);
node1->_next = node2;
node2->_prev = node1;
return 0;
}这时程序运行结束后两个结点都没有被释放，但如果去掉连接结点时的两句代码中的任意一句，那么这两个结点就都能够正确释放，根本原因就是因为这两句连接结点的代码导致了循环引用
循环引用分析：
- node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
- node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
- node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
- 也就是说_next析构了，node2就释放了。
- 也就是说_prev析构了，node1就释放了。
- 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放
weak_ptr是C++11中引入的智能指针，weak_ptr不是用来管理资源的释放的，它主要是用来解决shared_ptr的循环引用问题的
- 原理：weak_ptr支持用shared_ptr对象来构造weak_ptr对象，构造出来的weak_ptr对象与shared_ptr对象管理同一个资源，但不会增加这块资源对应的引用计数
在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数。
修改代码如下：
struct ListNode
{
std::weak_ptr<ListNode> _next;
std::weak_ptr<ListNode> _prev;
int _val;
~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
//新建节点
std::shared_ptr<ListNode> node1(new ListNode);
std::shared_ptr<ListNode> node2(new ListNode);
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
node1->_next = node2;
node2->_prev = node1;
cout << node1.use_count() << endl;
cout << node2.use_count() << endl;
return 0;
}编译运行，资源正常释放
weak_ptr简单模拟实现
shared_ptr还会提供一个get函数，用于获取其管理的资源，辅助weak_ptr
T* get() const
{
return _ptr;
}weak_ptr模拟实现代码如下：
- weak_ptr支持用shared_ptr对象拷贝构造weak_ptr对象，构造时获取shared_ptr对象管理的资源
- weak_ptr支持用shared_ptr对象拷贝赋值给weak_ptr对象，赋值时获取shared_ptr对象管理的资源
template<class T>
class weak_ptr
{
public:
// RAII
weak_ptr()
:_ptr(nullptr)
{}
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())//weak_ptr支持用shared_ptr对象拷贝构造weak_ptr对象，构造时获取shared_ptr对象管理的资源。
{}
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp.get();//weak_ptr支持用shared_ptr对象拷贝赋值给weak_ptr对象，赋值时获取shared_ptr对象管理的资源
return *this;
}
// (2)可以像指针一样使用
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};三、C++11和boost中智能指针的关系
- C++ 98 中产生了第一个智能指针auto_ptr.
- C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
- C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
- C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的
- boost库是为C++语言标准库提供扩展的一些C++程序库的总称，boost库社区建立的初衷之一就是为C++的标准化工作提供可供参考的实现，比如在送审C++标准库TR1中，就有十个boost库成为标准库的候选方案。
--------------------- END ----------------------
「 作者 」 枫叶先生
「 更新 」 2023.5.13
「 声明 」 余之才疏学浅，故所撰文疏漏难免，
或有谬误或不准确之处，敬请读者批评指正。
