前言

大家好久不见，今天来学习有关智能指针的内容~

为什么用智能指针

假如我们有如下场景：

double Div()
{int x, y;cin >> x >> y;if (y == 0)throw "div Exception cause div 0!!!";elsereturn (double)x / (double)y;
}int main()
{int* p1 = new int;int* p2 = new int;Div();delete p1;delete p2;
}

由于p1、p2、都需要释放，因此一旦在p2、p3出现了异常我们要手动释放前面的资源，这样的方式特别麻烦，这里还仅仅只是两个资源，一旦涉及更多new的资源会更麻烦，为了解决这个问题，c++引入了智能指针解决这个问题。

智能指针简单实现

一般而言智能指针要有三个问题：
1、利用对象的生命周期来控制程序资源，RAII的思想。
2、像指针一样使用。
3、考虑拷贝的问题。

unique_ptr

上面的例子中，如果p2、div出现了问题，前面的资源就无法释放，虽然可以通过重新抛出的方式来解决，但让代码可读性变得很差，同时也非常麻烦。使用智能指针可以解决这个问题，下面是一个智能指针的实例：

template<class T>
class SmartPtr
{
public://构造保存指针SmartPtr(T* ptr): _ptr(ptr){}//析构释放资源~SmartPtr(){if(_ptr)delete _ptr;cout << "delete _ptr success !" << endl;}//模拟指针的两个行为T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

这样完美地达到了控制资源释放的要求，但与此同时也引来了一个新的问题，即原生指针是可以拷贝的，但智能指针显然不可以拷贝，因为这里拷贝我们要求浅拷贝，那样对象在释放时同一份资源就会析构两次，这是非常可怕的。

为了解决这个问题，c++98库在实现auto_ptr的时候，使用了一种叫管理权转移的方式，如下代码，但其他这样效果非常不好。

//拷贝的悬空
SmartPtr(SmartPtr& sp): _ptr(sp._ptr)
{sp._ptr = nullptr;
}

在后来的c++准标准库中，boost设计了一种新的智能指针，在c++11中相当于unique_ptr，该指针直接明令禁止不允许拷贝。

禁止别人拷贝的方式有很多，这里介绍两种：
在c++98中，一般只声明不实现，为了防止有人在类外动手脚，需要再用private封死这两个函数；相比之下c++11就更加简单，只需要写上delete关键字即可。

//c++11拷贝赋值禁止unique_ptr(const unique_ptr<T>& up) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
//c++98禁止：
private:unique_ptr(const unique_ptr<T>& up);unique_ptr<T>& operator=(const unique_ptr<T>& up);

shared_ptr

可以看出上面解决拷贝问题的方式本质就是规避了这个问题，shared_ptr不同，他允许我们进行拷贝构造。

要解决拷贝问题，实际上就是要控制好对象何时释放资源、释放几次的问题，我们发现引用计数很适合解决这个问题。

template<class T>
class shared_ptr
{
public://构造保存指针shared_ptr(T* ptr): _ptr(ptr), _count(new int(1)), _pmtx(new mutex){}//拷贝shared_ptr(const shared_ptr<T>& sp): _ptr(sp._ptr){if (_ptr != sp._ptr){sp._count++;}}//析构释放资源~shared_ptr(){if ((--(*_count) == 0)){delete _ptr;delete _count;cout << "delete _ptr;" << " delete _count; " << endl;}cout << "delete _ptr success !" << endl;}//模拟指针的两个行为T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr = nullptr;int* _count;mutex* _pmtx;
};

上述代码简单模拟了shared_ptr，但我们发现一旦使用了引用计数，不可避免地会出现线程安全问题，为了解决线程安全的问题，我们要对这些地方加锁。

template<class T>
class shared_ptr
{
public://构造保存指针shared_ptr(T* ptr=nullptr): _ptr(ptr), _count(new int(1)), _pmtx(new mutex){}//	+void AddCount(){_pmtx->lock();++(*_count);_pmtx->unlock();}//	-void Release(){_pmtx->lock();bool deleteFlag = false;if (--(*_count) == 0){delete _ptr;delete _count;cout << "delete " << _ptr << endl;deleteFlag = true;}_pmtx->unlock();if (deleteFlag)delete _pmtx;}//拷贝构造shared_ptr(const shared_ptr<T>& sp): _ptr(sp._ptr), _count(sp._count), _pmtx(sp._pmtx){AddCount();}//赋值shared_ptr<T>& operator=(const shared_ptr<T>& sp){if (_ptr != sp._ptr){//这里是赋值之前的-Release();_ptr = sp._ptr;_count = sp._count;_pmtx = sp._pmtx;//注意这里加就是赋值之后的加了AddCount();}return *this;}//析构释放资源~shared_ptr(){Release();}//模拟指针的两个行为T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T* get() const{return _ptr;}int use_count(){return *_count;}private:T* _ptr;int* _count;mutex* _pmtx;
};

注意，shared_ptr本身是线程安全的，但管理的对象并不是线程安全的，需要加锁保护，在一些极端的场景下还会出现循环引用的问题。

循环引用和weak_ptr的引入

循环引用

struct ListNode
{int _val;nhy::shared_ptr<ListNode> _prev;nhy::shared_ptr<ListNode> _next;~ListNode(){cout << "~ListNode" << endl;}
};

如果链表的两个指针也使用shared_ptr，就会出现如图所示循环引用的问题，不仅仅p指向这个对象，还有一个next或prev也指向这个对象，这样双方会僵持不下，谁都无法释放。

weak_ptr

要解决这个问题，只需要将不必要的计数功能取消即可，其实weakptr本质就是sharedptr取消了计数功能。

template<class T>
class weak_ptr
{
public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp):_ptr(sp.get()){}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T* get(){return _ptr;}private:T* _ptr;
};

定制删除器

可以传入一个对象来管理释放资源。

template<class D>
shared_ptr(T* ptr, D del): _ptr(ptr), _count(new int(1)), _pmtx(new mutex), _del(del)
{}function<void(T*)> _del = [](T* ptr) {cout << "default delete" << endl;delete ptr;
};//  定制删除器 -- 可调用对象
template<class T>
struct DeleteArray
{void operator()(T* ptr){cout << "void operator()(T* ptr)" << endl;delete[] ptr;}
};class Date
{
private:int _year;int _month;int _day;
};void test_delete()
{nhy::shared_ptr<int> spa1(new int[10],DeleteArray<int>());nhy::shared_ptr<Date> spa2(new Date[10]);nhy::shared_ptr<Date> spa3(new Date[10],DeleteArray<Date>());
}