C++智能指针

int main()
{shared_ptr<Date> sp1(new Date);shared_ptr<Date> sp2(sp1);shared_ptr<Date> sp3(sp2);cout << sp1.use_count() << endl; // 3shared_ptr<Date> sp4(move(sp1));return 0;
}

四、智能指针的原理

4.1 auto_ptr模拟实现

auto_ptr是需要把被拷贝对象的资源转移给拷贝对象，然后把被拷贝对象置空即可，赋值就先要把自己管理的资源释放了，再去指向其他的资源，如果不先释放再指向就内存泄漏了。

namespace hx
{template<class T>class auto_ptr{public:auto_ptr(T* ptr):_ptr(ptr){}auto_ptr(auto_ptr<T>& ap):_ptr(ap._ptr){ap._ptr = nullptr;}auto_ptr<T>& operator=(auto_ptr<T>& ap){if (this != &ap){if (_ptr)delete _ptr;_ptr = ap._ptr;ap._ptr = nullptr;}return *this;}~auto_ptr(){cout << "delete:" << _ptr << endl;delete _ptr;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}

4.2 unique_ptr模拟实现

拷贝构造和拷贝赋值直接禁掉，然后实现一个移动构造和移动赋值，也是直接转移资源即可。

namespace hx
{template<class T>class unique_ptr{public:unique_ptr(T* ptr):_ptr(ptr){}unique_ptr(const unique_ptr<T>& up) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;~unique_ptr(){cout << "delete:" << _ptr << endl;delete _ptr;}unique_ptr(unique_ptr<T>&& up):_ptr(up._ptr){up._ptr = nullptr;}unique_ptr<T>& operator=(unique_ptr<T>&& up){delete _ptr;_ptr = up._ptr;up._ptr = nullptr;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}

4.3 shared_ptr模拟实现

关于shared_ptr我们要先理解引用计数的设计，每一份资源都有一个配套的引用计数，只要有一个shared_ptr指管着这块资源，引用计数就++，shared_ptr出了作用域要去调用析构，引用计数先--，然后看引用计数是否是0，如果引用计数是0了，那就说明没有其它个shared_ptr指管着这块资源了，那我析构的时候就可以把这块空间释放了，但是如果引用计数不是0，就说明还有其它的shared_ptr指管着这块资源，我析构的时候就不能释放。

那我们来思考一下，我们自己设计的时候引用计数应该怎样设计呢？直接写成成员变量吗？显然不是，这样设计就是每个对象都有一个引用计数，就比如上面的sp1和sp2，我们想让它们共用一个引用计数，引用计数是2，而不是sp1和sp2都有一个引用计数。那设计成静态的？也不行，如果设计成静态的那就是所有对象都用这一个引用计数，显然也是不合理的，那上面的sp1和sp3肯定不能用同一个引用计数。所以引用计数真正实现的方法是要使用堆上动态开辟的方式，构造智能指针对象时来一份资源，就要new一个引用计数出来。

在赋值时判断是否是自己给自己赋值和之前不太一样，例如上面的例子，sp1 = sp1，sp1 = sp2，都叫自己给自己赋值，那在这里判断的方式就是看资源的地址相不相同，相同就是自己给自己赋值。而且也需要把删除的逻辑再判断一遍，如果当前指向的资源引用计数--完不是0，那我不需要释放，直接指向其它资源即可，如果当前指向的资源引用计数--完是0，那我就需要先释放，再指向其它资源。

同时我们也提供一个可以拿到指向的资源和引用计数的函数。

namespace hx
{template<class T>class shared_ptr{public:shared_ptr(T* ptr = nullptr):_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){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}_ptr = sp._ptr;_pcount = sp._pcount;(*_pcount)++;}return *this;}~shared_ptr(){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}int use_count() const{return *_pcount;}T* get() const{return _ptr;}private:T* _ptr;int* _pcount;};
}

4.4 定制删除器

到这里大家会发现，我们的智能指针析构函数中都是对应的new单个的情况，如果是new[]那析构时就会崩溃。所以智能指针支持在构造时给一个删除器，所谓删除器本质就是一个可调用对象，这个可调用对象中实现你想要的释放资源的方式，当构造智能指针时，给了定制的删除器，在智能指针析构时就会调用删除器去释放资源。因为new[]经常使用，所以为了简洁一点，unique_ptr和shared_ptr都特化了一份[]的版本，可以直接用。

int main()
{unique_ptr<Date[]> up(new Date[10]);shared_ptr<Date[]> sp(new Date[10]);return 0;
}

如果要传可调用对象的话，要注意的是：unique_ptr是在类模板参数支持的，shared_ptr是构造函数参数支持的。unique_ptr要显示实例化传类型给模版，shared_ptr只需要传对象过去让编译器自动推演类型。

下面来看一个示例：

template<class T>
void DeleteArrayFunc(T* ptr)
{delete[] ptr;
}template<class T>
class DeleteArray
{
public:void operator()(T* ptr){delete[] ptr;}
};class Fclose
{
public:void operator()(FILE* ptr){cout << "fclose:" << ptr << endl;fclose(ptr);}
};

int main()
{unique_ptr<Date, DeleteArray<Date>> up1(new Date[5]);shared_ptr<Date> sp1(new Date[5], DeleteArray<Date>());unique_ptr<Date, void(*)(Date*)> up2(new Date[5], DeleteArrayFunc<Date>);shared_ptr<Date> sp2(new Date[5], DeleteArrayFunc<Date>);auto delArrOBJ = [](Date* ptr) {delete[] ptr; };unique_ptr<Date, decltype(delArrOBJ)> up3(new Date[5], delArrOBJ);shared_ptr<Date> sp3(new Date[5], delArrOBJ);shared_ptr<FILE> sp4(fopen("Test.cpp", "r"), Fclose());shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), [](FILE* ptr) {cout << "fclose:" << ptr << endl;fclose(ptr);});return 0;
}

template<class D>
shared_ptr(T* ptr, D del):_ptr(ptr), _pcount(new int(1))
{}

private:T* _ptr;int* _pcount;function<void(T*)> _del;

private:T* _ptr;int* _pcount;function<void(T*)> _del = [](T* ptr) {delete ptr; };
};

namespace hx
{template<class T>class shared_ptr{public:explicit shared_ptr(T* ptr = nullptr):_ptr(ptr), _pcount(new int(1)){}template<class D>shared_ptr(T* ptr, D del):_ptr(ptr), _pcount(new int(1)), _del(del){}shared_ptr(const shared_ptr<T>& sp):_ptr(sp._ptr), _pcount(sp._pcount), _del(sp.del){(*_pcount)++;}shared_ptr<T>& operator=(const shared_ptr<T>& sp){if (_ptr != sp._ptr){if (--(*_pcount) == 0){//delete _ptr;_del(_ptr);delete _pcount;}_ptr = sp._ptr;_pcount = sp._pcount;(*_pcount)++;}return *this;}~shared_ptr(){if (--(*_pcount) == 0){//delete _ptr;_del(_ptr);delete _pcount;}}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}int use_count() const{return *_pcount;}T* get() const{return _ptr;}private:T* _ptr;int* _pcount;function<void(T*)> _del = [](T* ptr) {delete ptr; };};

int main()
{shared_ptr<Date> sp1(new Date(2024, 9, 11));shared_ptr<Date> sp2 = make_shared<Date>(2024, 9, 11);auto sp3 = make_shared<Date>(2024, 9, 11);shared_ptr<Date> sp4;// if (sp1.operator bool())if (sp1)cout << "sp1 is not nullptr" << endl;if (!sp4)cout << "sp1 is nullptr" << endl;return 0;
}

struct ListNode
{int _data;ListNode* _next;ListNode* _prev~ListNode(){cout << "~ListNode()" << endl;}
};int main()
{shared_ptr<ListNode> n1(new ListNode);shared_ptr<ListNode> n2(new ListNode);cout << n1.use_count() << endl;cout << n2.use_count() << endl;n1->_next = n2;n2->_prev = n1;cout << n1.use_count() << endl;cout << n2.use_count() << endl;return 0;
}

struct ListNode
{int _data;shared_ptr<ListNode> _next;shared_ptr<ListNode> _prev;~ListNode(){cout << "~ListNode()" << endl;}
};int main()
{shared_ptr<ListNode> n1(new ListNode);shared_ptr<ListNode> n2(new ListNode);cout << n1.use_count() << endl;cout << n2.use_count() << endl;n1->_next = n2;n2->_prev = n1;cout << n1.use_count() << endl;cout << n2.use_count() << endl;return 0;
}