【C++11】智能指针

🔥个人主页： Forcible Bug Maker
🔥专栏： C++

🌈前言

本篇博客主要内容：C++11中的智能指针的使用；并对几种常见智能指针进行简单自实现。

上篇博客主要讲到了异常的使用，也稍微提到一些规定，如：不要再new后delete前抛出异常。稍后将会为大家详解其中缘由，并给出解决方式——智能指针。

🔥抛异常导致的内存泄露

int div()
{int a, b;cin >> a >> b;if (b == 0)throw "除0错误！";return a / b;
}void func()
{int* ptr1 = new int(1);int* ptr2 = new int(2);cout << div() << endl;delete ptr1;delete ptr2;
}
int main()
{int i = 2;while (i--) {try{func();}catch (const char* errs){cout << errs << endl;}catch (...){cout << "未知错误" << endl;}}return 0;
}

观察下以上代码的运行结果：

代码顺利执行，但是在报出除零错误前就已经发生了错误——内存泄露。div函数中抛出异常，由于func中没有将异常捕获，导致跳入主函数中才被捕捉，过程中delete释放空间的语句完全被忽视，从而导致内存泄露。

可能你会想，可以在func函数中提前捕获此异常，并在异常处理中单独释放资源，这样确实可以解决问题，但本案例代码只是个示例，实际中抛出大量异常的情况下，此想法极难实施。

我给出的解决方式是，用一个对象来管理指向某资源的指针，在执行语句跳出某函数体时，管理指针的对象会自动调用析构函数释放指针指向的资源，这种思想也就是本篇主题，智能指针的最基本的逻辑。

🔥智能指针的原理

RAII思想：
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

• 不需要显示的释放资源
• 对象所需的资源在其生命周期内始终保持有效

// 一个简单到极致的智能指针
template<class T>
class SmartPtr
{
public:SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){delete _ptr;}
private:T* _ptr;
};int div()
{int a, b;cin >> a >> b;if (b == 0)throw "除0错误！";return a / b;
}void func()
{SmartPtr<int> sp1(new int(1));SmartPtr<int> sp2(new int(2));cout << div() << endl;}int main()
{int i = 2;while (i--) {try{func();}catch (const char* errs){cout << errs << endl;}catch (...){cout << "未知错误" << endl;}}return 0;
}

此时再抛出除零异常时，就不会出现内存泄露了，因为再跳出func函数体时，会调用SmartPtr对象的析构函数，同时释放指针指向的资源。

🔥库中智能指针

库中的智能指针统一放在<memory>头文件里。

std::auto_ptr

auto_ptr文档
在C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：权限转移，当一个智能指针对象（auto_ptr类型）赋值给另一个智能指针对象（auto_ptr类型）时，赋值的一方悬空，资源访问权限转移给被复制的对象。

#include<iostream>
#include<memory>
using namespace std;int main()
{auto_ptr<int> ap1(new int(1));auto_ptr<int> ap2;cout << *ap1 << endl;ap2 = ap1;cout << *ap2 << endl;cout << *ap1 << endl;return 0;
}

考虑到auto_ptr在实际中容易因为使用不当而出错，所以一般都不会用。

std::unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr文档
unique_ptr的实现原理：简单粗暴的防止发生拷贝行为，下面模拟实现了一份用于理解此过程。

// 原理：简单粗暴--防止拷贝行为
namespace ForcibleBugMaker
{template<class T>class unique_ptr{public:unique_ptr(T* ptr = nullptr):_ptr(ptr){}~unique_ptr(){if (_ptr){delete _ptr;}}//支持像指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}unique_ptr(const unique_ptr<T>& up) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;private:T* _ptr;};
}

std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr文档
shared_ptr的原理：通过引用计数的方式来实现多个shared_ptr之间共享资源。当引用计数为0时（也就是最后一个维护指针的对象销毁时），自动释放资源。

// 简化版shared_ptr
// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace ForcibleBugMaker
{template<class T>class shared_ptr{public:shared_ptr(T* ptr):_ptr(ptr),_pcount(new int(1)){}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount){++(_pcount);}shared_ptr<T>& operator(const shared_ptr<T>& sp){if (_ptr == sp._ptr)return *this;_release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);return *this;}T& operator*(){return *_ptr;}T operator->(){return _ptr;}T* get() const{return _ptr;}int use_count(){return *_pcount;}~shared_ptr(){_release();}private:void _release(){if (_ptr && --(*_pcount) == 0){delete _ptr;delete _pcount;_ptr = _pcount = nullptr;}}private:T* _ptr;int* _pcount;};
}

shared_ptr的缺陷——循环引用导致内存泄露
如果使用shared_ptr用来维护双向链表的一个个结点，那么便会造成循环引用，见如下案例：

struct ListNode
{int _data;shared_ptr<ListNode> _prev;shared_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{shared_ptr<ListNode> node1(new ListNode);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;
}

从运行结果可以看出，并未调用析构函数，所以发生了内存泄露。

1. 当node1和node2两个智能指针对象分别指向两个结点，引用计数变成1，不需要我们手动delete。
2. node1的_next指向node2，node2的_prev指向node1时，两边智能指针对象的引用计数均变成2。
3. 这时候循环引用问题便出现了，当退出当前函数栈帧开始析构时：只有_next析构，node2才能释放；只有_prev析构，node1才能析构。
4. 但是_next属于node的成员，node1释放， _next才会析构；而node1由_prev管理，_prev属于node2的成员。
5. 结果是，node1释放，需要node2先释放；node2释放，又需要node1先释放，最终谁也释放不了，这就叫循环引用。

解决方案：引用计数的场景下，把节点中_prev和_next的智能指针类型改成weak_ptr即可。

std::weak_ptr

shared_ptr循环引用问题的解决方案，同时weak_ptr不支持RAII，不能单独管理资源。
weak_ptr文档
weak_ptr原理：weak_ptr可以作为循环引用解决方案的原因是，使用weak_ptr智能指针，不会增加shared_ptr的引用计数。

// 简化版本的weak_ptr实现
template<class T>
class weak_ptr
{
public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}weak_ptr<T>& operator=(const shared_ptr<T>& sp){_ptr = sp.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

struct ListNode
{int _data;weak_ptr<ListNode> _prev;weak_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{shared_ptr<ListNode> node1(new ListNode);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;
}

循环引用的问题便解决了。

定制删除器

如果不是new出来的对象如何通过智能指针管理呢？其实unique_ptr和shared_ptr分别提供了一种解决方式。

// 仿函数的删除器
template<class T>
struct FreeFunc {void operator()(T* ptr){cout << "free:" << ptr << endl;free(ptr);}
};
template<class T>
struct DeleteArrayFunc {void operator()(T* ptr){cout << "delete[]" << ptr << endl;delete[] ptr;}
};class A
{
public:int _a;
};int main()
{FreeFunc<int> freeFunc;shared_ptr<int> sp1((int*)malloc(4), freeFunc);DeleteArrayFunc<int> deleteArrayFunc;shared_ptr<int> sp2(new int[10], deleteArrayFunc);shared_ptr<A> sp4(new A[10], [](A* p) {delete[] p; });shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p) {fclose(p); });unique_ptr<int, FreeFunc<int>> up1((int*)malloc(4));unique_ptr<int, DeleteArrayFunc<int>> up2(new int[10]);return 0;
}

是的，如你所见，shared_ptr和unique_ptr应用删除器的方式有很大不同。shared_ptr需要将删除器对象传入参数列表当中；而unique_ptr需要将删除器的类型传入参数模板中。不过两者都提供了传入删除器的方式，可以更好的控制不同类型的资源。

🌈结语

C++11 引入的智能指针（std::unique_ptr、std::shared_ptr 和 std::weak_ptr）是自动内存管理的一个重要里程碑，它们通过RAII（Resource Acquisition Is Initialization）原则帮助开发者避免内存泄漏和其他资源管理问题。总的来说，C++11 智能指针通过提供自动内存管理和增强的安全性，极大地改善了C++程序的稳定性和可维护性。学好智能指针，也更有利于我们对C++的理解。