C++：基于RAII思想的智能指针

前言

C++没有垃圾回收机制，new或者malloc的资源都需要我们手动进行释放。但有时也会发生忘记释放的问题，这就会造成内存泄漏或异常安全的问题。

C++就引入了智能指针对上述问题进行解决。

一：RAII

RAII 是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。我们实际上把管理一份资源的责任托管给了一个对象。

不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效。

代码演示：

#include<iostream>
using namespace std;// 类型不确定
template<class T>
class SmartPtr{// 帮我们管理资源的释放
public:SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){if (_ptr){cout << "delete：" << _ptr << endl;delete _ptr;}}
private:T* _ptr;
};int div(){int a, b;cin >> a >> b;if (b == 0){throw invalid_argument("除0错误");}return a / b;
}void func(){int* ptr = new int;// 无论函数是正常结束还是抛异常，都会导致sp对象生命周期到了之后，调用析构函数。SmartPtr<int> sp(ptr);cout << div() << endl;
}int main(){try{func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

二：智能指针

RAII 是一种资源托管的思想，智能指针是依靠RAII 的思想实现的。

2.1 智能指针的原理

RAII特性
具有像指针一样的行为，重载了operator* 和 operator->

2.2 std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。

代码示例：

#include<iostream>
using namespace std;namespace WJL{template<class T>class auto_ptr{// 帮我们管理资源的释放public:// 构造函数保存资源auto_ptr(T* ptr):_ptr(ptr){}// 析构函数释放资源~auto_ptr(){if (_ptr){cout << "delete：" << _ptr << endl;delete _ptr;_ptr = nullptr;}}// 管理权转移auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}// 赋值 s1 = s2auto_ptr<T>& operator=(const auto_ptr<T>& ap){if (this != &ap){auto_ptr<T> PtrTemp(ap);T* pTemp = PtrTemp._ptr;PtrTemp._ptr = _ptr;_ptr = pTemp;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}int main(){WJL::auto_ptr<int> sp1(new int);WJL::auto_ptr<int> sp2 = sp1;return 0;
}

auto_ptr的实现原理：管理权转移的思想，若发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系。

这样就解决了一块空间被多个对象使用而造成程序奔溃问题。

但是我们再从原理层面分析，拷贝后将ap对象的指针置为空，会导致ap对象悬空，通过ap对象访问资源的时候就会出现问题。

2.3 std::unique_ptr

C++11中开始提供更靠谱的unique_ptr智能指针。

unique_ptr对应boost的scoped_ptr，并且实现原理是参考boost中的实现的。

代码示例：

#include<iostream>
using namespace std;namespace WJL{// 防拷贝（简单粗暴）template<class T>class unique_ptr{// 帮我们管理资源的释放public:// 构造函数保存资源unique_ptr(T* ptr):_ptr(ptr){}// 析构函数释放资源~unique_ptr(){if (_ptr){cout << "delete：" << _ptr << endl;delete _ptr;_ptr = nullptr;}}unique_ptr(unique_ptr<T>& up) = delete;unique_ptr<T>& operator = (unique_ptr<T>& up) = delete;T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}int main(){WJL::unique_ptr<int> up1(new int);// WJL::unique_ptr<int> up2 = up1;return 0;
}

unique_ptr的设计思路非常的简单粗暴：unique_ptr防拷贝，也就是不让拷贝和赋值。

但是，在需要拷贝的场景下使用就会有问题。

2.4 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr智能指针。

#include<iostream>
using namespace std;namespace WJL{// 支持拷贝的智能指针，shared_ptr。template<class T>class shared_ptr{// 帮我们管理资源的释放public:// 构造函数保存资源shared_ptr(T* ptr):_ptr(ptr), p_count(new int(1)){}shared_ptr(shared_ptr<T>& sp):_ptr(sp._ptr), p_count(sp.p_count){++(*p_count);}shared_ptr<T>& operator=(shared_ptr<T>& sp){if (this != &sp){if (--(*p_count) == 0){delete _ptr;delete p_count;}_ptr = sp._ptr;p_count = sp.p_count;++(*p_count);}return *this;}// 析构函数释放资源~shared_ptr(){if (--(*p_count) == 0 && _ptr){cout << "delete：" << _ptr << endl;delete _ptr;_ptr = nullptr;delete p_count;p_count = nullptr;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;int* p_count; // 引用计数（记录有多少个对象一起共享管理资源）};
}int main(){WJL::shared_ptr<int> sp1(new int);WJL::shared_ptr<int> sp2 = sp1;return 0;
}

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

shared_ptr在其内部，给每个资源都维护了着一个计数器，用来记录该份资源被几个对象共享。在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

三：std::shared_ptr的线程安全问题

shared_ptr线程安全分为两个方面：

智能指针对象中引用计数是多个智能指针对象共享的，两个线程对智能指针的引用计数同时加或减，这个操作不是原子的，可能导致资源未被释放或程序崩溃的问题。
智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

代码示例:

对引用计数加减进行加锁操作，来保证线程安全。

namespace WJL{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_ptr(ptr), _pcount(new int(1)), _pmtx(new mutex){}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount), _pmtx(sp._pmtx){add_ref_count();}// sp1 = sp4shared_ptr<T>& operator=(const shared_ptr<T>& sp){if (this != &sp){// 减减引用计数，如果我是最后一个管理资源的对象，则释放资源release();// 我开始跟你一起管理资源_ptr = sp._ptr;_pcount = sp._pcount;_pmtx = sp._pmtx;add_ref_count();}return *this;}void add_ref_count(){_pmtx->lock();++(*_pcount);_pmtx->unlock();}void release(){bool flag = false;_pmtx->lock();if (--(*_pcount) == 0){if (_ptr){cout << "delete:" << _ptr << endl;delete _ptr;_ptr = nullptr;}delete _pcount;_pcount = nullptr;flag = true;}_pmtx->unlock();if (flag == true){delete _pmtx;_pmtx = nullptr;}}~shared_ptr(){release();}int use_count(){return *_pcount;}T* get_ptr() const{return _ptr;}T& operator*(){return *_ptr;}T* operator->() {return _ptr;}private:T* _ptr;// 记录有多少个对象一起共享管理资源，最后一个析构释放资源int* _pcount;mutex* _pmtx;};
}

四：std::shared_ptr的循环引用问题

循环引用的分析：

node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
_next析构了，node2就释放了，_prev析构了，node1就释放了。
_next属于node1的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员。

这就叫循环引用，谁也不会释放。

4.1 循环引用的解决方案

解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了。

原理剖析：node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数

代码演示：

namespace WJL{// 严格来说weak_ptr不是智能指针，因为他没有RAII资源管理机制// 专门解决shared_ptr的循环引用问题template<class T>class weak_ptr{public:weak_ptr() = default;weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get_ptr()){}weak_ptr<T>& operator = (const shared_ptr<T>& sp){_ptr = sp.get_ptr();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}

小结

C++没有垃圾回收机制，申请的资源需要释放是一个问题，尤其遇到异常安全问题，稍不注意就会出现内存泄漏的问题。内存泄露会导致程序可用的内存越来越少，使程序处于瘫痪状态，所以我们应该尽量避免内存泄漏的问题。

这就发展出来基于RAII思想的智能指针。