C++智能指针

那怎么办呢？使用引用计数即可解决这个问题，但C++在最开始的时候并不是这么做的。在C++ 98中，第一次出现智能指针auto_ptr{};，在处理这方面的问题时，使用了“管理权转移”，认为“两个对象管理一份资源”是存在问题的，因此在上面代码sp_3 = sp_2中就会表现为：sp_2的资源转移给sp_3。

这种实现非常简单，但是不符合我们对指针的理解，容易出现对象悬空的问题（资源被别的对象掠夺了）。

因此auto_ptr{};这种智能指针在后来也被委员会标记为弃用，改用智能指针unique_ptr{};。

这个做得很极端，直接让智能指针对象禁用拷贝，这如何实现？两种方法：

1. 使用自定义的拷贝构造和赋值重载（而不是默认拷贝构造和默认赋值重载），但是限定为私有，并且只声明不实现
2. 使用C++11语义重载后的关键字delete（”删除“成员函数）禁止编译器生成默认的拷贝构造和赋值重载

但是unique_ptr{};这种做法有点逃避现实问题的意思，因此后面又出现了新的智能指针shared_ptr{};，支持引用计数后，智能指针就允许拷贝构造和赋值重载了，但是其具体实现有一些细节需要注意。

但是怎么计数呢？直接定义一个成员变量？不可以，这会导致多个成员计数不同步。那改成静态成员变量？依旧不行，会影响到同类型的指向其他资源的智能指针对象，这就更坑了。

那另辟蹊径，直接将引用计数存放到指向的资源处，但是更加麻烦了，还要考虑更多问题。

最后还有一种方案，每一个对象新增计数指针_pcount，单独指向的空间存储计数数据，指向同一块空间资源的智能指针对象，其内部的_pcount指针也需要指向同一块计数空间。

#include <iostream>
using namespace std;struct Data
{Data(): _data_1(1), _data_2(2), _data_3(2) {}int _data_1;int _data_2;int _data_3;
};template <typename Type>
class SmartPtr
{
public:SmartPtr(Type* ptr): _ptr(ptr), _pcount(new int(1)){cout << "deposit " << _ptr << '\n';}void _release(){if (--(*_pcount) == 0){cout << "delete  " << _ptr << '\n';delete _ptr;delete _pcount;}else{cout << "count-1 " << _ptr << '\n';}}~SmartPtr(){_release();}SmartPtr(const SmartPtr<Type>& sp): _ptr(sp._ptr), _pcount(sp._pcount){++(*_pcount);cout << "count+1 " << _ptr << '\n';}SmartPtr<Type>& operator=(const SmartPtr<Type>& sp)//这个代码需要注意一下{_release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);return *this;}Type& operator*(){return *_ptr;}Type* operator->(){return _ptr;}
private:Type* _ptr;int* _pcount;
};int main()
{SmartPtr<int> sp(new int[10]);//交给智能指针管理(*sp) = 5;SmartPtr<Data> sp1(new Data);sp1->_data_1 = 10;//完整写法为 sp_2.operator->()->_data_1sp1->_data_2 = 10;sp1->_data_3 = 10;SmartPtr<Data> sp2 = sp1;SmartPtr<Data> sp3(new Data);sp2 = sp3;return 0;
}

但是很遗憾，尽管shared_ptr{};已经很完美了，但实践中依旧出现了一个关于”循环引用“的问题，我们简单介绍一下什么是”循环引用“：

#include <iostream>
using namespace std;template <typename Type>
class SmartPtr
{
public:SmartPtr(Type* ptr = nullptr): _ptr(ptr), _pcount(new int(1)){}void _release(){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}}~SmartPtr(){_release();}SmartPtr(const SmartPtr<Type>& sp): _ptr(sp._ptr), _pcount(sp._pcount){++(*_pcount);}SmartPtr<Type>& operator=(const SmartPtr<Type>& sp)//这个代码需要注意一下{if (_ptr != sp._ptr)//防止给自己赋值{_release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}Type& operator*(){return *_ptr;}Type* operator->(){return _ptr;}
private:Type* _ptr;int* _pcount;
};struct ListNode
{int val;SmartPtr<ListNode> next;SmartPtr<ListNode> prev;~ListNode(){cout << "~ListNode()" << '\n';}
};int main()
{SmartPtr<ListNode> n1 = new ListNode;SmartPtr<ListNode> n2 = new ListNode;//发生循环引用n1->next = n2;n2->prev = n1;//析构顺序是先析构 n2，再析构 n1//但是这里的析构是“引用析构”，不会真的调用 delete 释放资源，//仅仅只是 (*pcount)-- //然后就导致：n2 的 prev 依旧指向 n1 的资源，n1 的 next 依旧指向 n2 的资源//想要析构 n1 的 next，就需要 n1 先析构//想要 n1 先析构，就需要 prev 先析构//想要 prev 先析构，就需要 n2 先析构//想要 n2 先析构，就需要 next 先析构//想要 next 先析构，就需要 n1 先析构//ok 想要 n1 析构？这不又回到开头了？return 0;
}

这就比较尴尬了，这种问题还是比较大的，我们经常会使用到类似链表的结构，一旦使用智能指针，那必然造成内存泄漏，并且是不可逆转的内存泄漏，用户即便知道这一循环引用，也无力释放…

由此诞生了weak_ptr{};，严格来说这不是智能指针，而是专门为了解决“循环引用”而生的。因此在库中，上述代码就会类似写成：

#include <iostream>
#include <memory>
using namespace std;struct ListNode
{int val;//shared_ptr<ListNode> next;//shared_ptr<ListNode> prev;weak_ptr<ListNode> next;weak_ptr<ListNode> prev;~ListNode(){cout << "~ListNode()" << '\n';}
};int main()
{shared_ptr<ListNode> n1(new ListNode);shared_ptr<ListNode> n2(new ListNode);cout << n1.use_count() << " " << n2.use_count() << '\n';//输出 1n1->next = n2;n2->prev = n1;cout << n1.use_count() << " " << n2.use_count() << '\n';//使用了 weak_ptr 还是 1，这和之前不同return 0;
}

什么原理呢？实际上weak_ptr{};在指向别的shared_ptr{};时不会进行计数，我们可以尝试简单实现一下weak_ptr{};。

#include <iostream>
using namespace std;template <typename Type>
class SmartPtr
{
public:SmartPtr(Type* ptr = nullptr): _ptr(ptr), _pcount(new int(1)){}void _release(){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}}~SmartPtr(){_release();}SmartPtr(const SmartPtr<Type>& sp): _ptr(sp._ptr), _pcount(sp._pcount){++(*_pcount);}SmartPtr<Type>& operator=(const SmartPtr<Type>& sp)//这个代码需要注意一下{if (_ptr != sp._ptr)//防止给自己赋值{_release();_ptr = sp._ptr;_pcount = sp._pcount;++(*_pcount);}return *this;}Type& operator*(){return *_ptr;}Type* operator->(){return _ptr;}int use_count() const{return *_pcount;}Type* get() const{return _ptr;}private:Type* _ptr;int* _pcount;
};template <typename Type>
class WeakPtr
{
public:WeakPtr(): _ptr(nullptr){}WeakPtr(SmartPtr<Type>& sp): _ptr(sp.get()){}WeakPtr<Type>& operator=(const SmartPtr<Type>& sp){_ptr = sp.get();return *this;}Type& operator*(){return *_ptr;}Type* operator->(){return _ptr;}private:Type* _ptr;
};struct ListNode
{int val;WeakPtr<ListNode> next;WeakPtr<ListNode> prev;~ListNode(){cout << "~ListNode()" << '\n';}
};int main()
{SmartPtr<ListNode> n1(new ListNode);SmartPtr<ListNode> n2(new ListNode);cout << n1.use_count() << " " << n2.use_count() << '\n';n1->next = n2;n2->prev = n1;cout << n1.use_count() << " " << n2.use_count() << '\n';return 0;
}