目录
前言
智能指针是c++11中很好用的一个东西，很好的解决的资源泄露的问题。
智能指针的使用
RAII
Resource Acquisition Is Initialization ,获取资源的最好的时机就是初始化。
就是利用对象的生命周期来进行资源的管理。
重新理解下获取资源的最好的时机就是初始化，当申请好资源，立即将资源放到对象里进行管理。妈妈再也不用担心忘记释放内存啦，因为当对象生命周期到了的时候，调用其析构函数自动将资源释放。
demo
auto_ptr
cpp
#include<iostream>
#include<memory>
using namespace std;
int main()
{
auto_ptr<int> ptr1 (new int[5]);
auto_ptr<int> ptr2 = ptr1;//ptr1 = nullptr
return 0;
}注意：auto_ptr有一个很坑的地方就是，若将ptr1赋值给ptr2，这时候ptr1就会为空。
unique_ptr
与auto_ptr的区别就是禁止拷贝。
shared_ptr
shared_ptr，没有了auto_ptr的赋值问题，因为shared_ptr多了一个引用计数，每次拷贝和赋值时，引用计数都会++，析构时--，当引用计数为0时，析构释放资源。
cpp
#include<iostream>
#include<memory>
using namespace std;
int main()
{
shared_ptr<int> ptr1 (new int[5]);
shared_ptr<int> ptr2 = ptr1;
shared_ptr<int> ptr3(ptr2);
return 0;
}
注意：shared_ptr也有一个地方需要注意，环形指针的循环引用。
在循环引用的情况下，shared_ptr会导致资源的泄露。
cpp
template<class T>
struct ListNode
{
ListNode(T dt)
:data(dt)
{}
T data;
shared_ptr<ListNode<T>> next = nullptr;
shared_ptr<ListNode<T>> prev = nullptr;
};
int main()
{
//环形引用问题
shared_ptr<ListNode<int>> ptr1 = new ListNode<int>(1);
shared_ptr<ListNode<int>> ptr2 = new ListNode<int>(2);
ptr1->next = ptr2;
ptr2->prev = ptr1;
return 0;
}
在main结束的时候，ptr2先销毁，ptr2的count--，目前ptr2的count = 1。
ptr1再销毁，ptr1的count--，目前ptr1的count = 1。
程序结束，资源并没有释放，引用计数没有减为0，因为ptr1.next还指向ptr2，ptr2.prev指向ptr1。
weak_ptr
weak_ptr并不是一个RAII，weak_ptr不析构资源，weak_ptr可以解决shared_ptr环形引用的问题，环形引用不能析构的主要原因不就是引用计数的锅吗？
cpp
template<class T>
struct ListNode
{
ListNode(T dt)
:data(dt)
{}
T data;
sp::weak_ptr<ListNode<T>> next = sp::shared_ptr<ListNode<T>>(nullptr);
sp::weak_ptr<ListNode<T>> prev = sp::shared_ptr<ListNode<T>>(nullptr);
};
int main()
{
//环形引用问题
sp::shared_ptr<ListNode<int>> ptr1 = new ListNode<int>(1);
sp::shared_ptr<ListNode<int>> ptr2 = new ListNode<int>(2);
ptr1->next = ptr2;
ptr2->prev = ptr1;
return 0;
}使用weak_ptr之后，next和prev就不再引用计数了，
智能指针的原理
我只写的一个最难的shared_ptr，其他的都一样的。
cpp
template<class T>
class shared_ptr
{
private:
void release()
{
if (--(*_count) == 0)
{
cout << "delete " << endl;
delete _ptr;
delete _count;
}
}
public:
shared_ptr()
:_ptr(nullptr)
{
_count = new int(0);
}
shared_ptr(T * ptr)
:_ptr(ptr)
{
if(ptr != nullptr)
{
_count = new int(1);
}
else
{
_count = new int(0);
}
}
//拷贝构造
shared_ptr(const shared_ptr<T> &ptr)
{
_ptr = ptr._ptr;
_count = ptr._count;
(*_count)++;
}
shared_ptr<T>& operator=(const shared_ptr<T>& ptr)
{
//先将当前对象释放，在赋值
//处理自我赋值
if (ptr._ptr != _ptr)
{
release();
_ptr = ptr._ptr;
_count = ptr._count;
(*_count)++;
}
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
~shared_ptr()
{
release();
}
T* get() const
{
return _ptr;
}
private:
T * _ptr;//
int* _count;//引用计数
};我总结下来主要有3️⃣点值得注意
1.引用计数是不可以使用，静态的变量的，这是一个误区，静态变量属于所有的对象，
如果想统计有多少个对象，使用静态没毛病，但是想要统计这块资源，有多少个smart_ptr指向，是不可以的，引用计数必须是动态开辟的。
2.operator=()时需要处理自我赋值，如果判断语句使用ptr != this是不够好的，因为间接的自我赋值，这个是查不出来的，直接使用原生指针判断是最好的办法。
3..operator=()一定要，先将当前对象析构，因为赋值不像拷贝构造，拷贝构造一定是一个未初始化的对象，但是赋值不一定啊，当前对象可能也会指向其他的资源呢，不调用析构，引用计数不--，资源就又泄露了