此篇文章就从以下几个方面出发，带你了解智能指针的方方面面

1.为什么需要智能指针

当我们开辟内存并使用的时候，我们的顺序应该是这样：

开辟内存-》使用内存-》释放内存

问题就出现在第三步，开辟好了，也使用了，但是释放的时候出现了问题，可能是malloc没有释放，也可能是抛异常之后跳过了回收，不管怎样，此时就会发生内存泄漏。

2.内存泄漏之后

内存使用空间的减小，运行卡顿，死机等。

内存泄漏可以分为：

堆内存泄漏(Heap leak) 堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存， 用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那 么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏 指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统 资源的浪费，严重可导致系统效能减少，系统执行不稳定。

解决办法（知道即可）

通过内存泄漏的一些检查工具，这里可以参考其他博客，此篇不做详解。

3.如何避免内存泄漏

\1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状 态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。 2. 采用RAII思想或者智能指针来管理资源。 3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。 4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

简单可以分为内存泄漏之前的预防，事后的检查，这里要讲的就是事前的预防。

4.智能指针

我们知道，在类创建的时候会调用构造函数，在析构的时候会调用析构函数，所谓的智能指针，其实就是将创建的对象并不直接创建，而是交给一个模板类，通过这个模板类来帮助我们管理。

这里说三种智能指针的设计，

auto_ptr
// C++库中的智能指针都定义在memory这个头文件中
#include <memory>
class Date
{
public:Date() { cout << "Date()" << endl;}~Date(){ cout << "~Date()" << endl;}int _year;int _monthint _day;
};
int main()
{auto_ptr<Date> ap(new Date);auto_ptr<Date> copy(ap);ap->_year = 2018;return 0;
}

这是它的使用，下面看一下源代码：

template<class T> 
class auto_ptr 
{ T* p; 
public: auto_ptr(T* s) :p(s) {} ~auto_ptr() { delete p; } auto_ptr(auto_ptr& a) { p = a.p; a.p = NULL; } auto_ptr& operator=(auto_ptr& a) { delete p; p=a.p; a.p = NULL; return *this; } T& operator*() const { return *p; } T* operator->() const { return p; } 
}; 

可以看到，当它作为智能指针赋值的时候，会出现讲前面置空的情况，如果我们之后还需要使用前面一个，就会发生报错。

不过这里简单的模拟实现一个：

    template<class K>class auto_ptr{public:auto_ptr(K* ptr):_ptr(ptr){}
​~auto_ptr{if (_ptr){cout << "delate" << endl;delete _ptr;_ptr = nullptr;}}
​//auto k(auto k1)auto_ptr(auto_ptr<K>& k1):_ptr(k1._ptr){k1._ptr = nullptr;}
​//一些指针的操作K& operator&(){return *_ptr;}
​K* operator*(){return _ptr;}
​
​private:K* _ptr;};

不推荐，平时也不会用，看看就好。

shared_ptr

顾名思义，分享指针，相比上一个，它的原理就简单得多，首先接管一个对象，如果同时有多个对象一起管理，那就在这个对象的计数器上+1，在取消管理的时候计数器-1，如果为0，则没有对象需要管理，进行析构。

这里直接进行模拟实现，原理比较简单，就不再细说，看代码了解即可。

        shared_ptr(K* ptr):_ptr(ptr),_count(new int (1)){}
​~shared_ptr(){Release();}
​shared_ptr(const shared_ptr<K>& k1):_ptr(k1._ptr), _count(k1.count){(*_count)++;}
​shared_ptr operator=(const shared_ptr<K>& k1){if (k1._ptr != _ptr){Release();
​_ptr = k1._ptr;_count = k1._count;(*_count)++;}}
​K& operator&(){return *_ptr;}
​K* operator*(){return _ptr;}K* get(){
​return _ptr;}
​private:K* _ptr;int* _count;};

这里要注意的一点是：

shared_ptr并不是完全都是好的，比方说下面这种场景：

有一个双向链表的两个节点 K,K1

K的下一个节点是K1,也就是说现在K的计数应该为2。

K1的上一个节点是K,也就是说现在K1的计数也为2。

此时，如果我要析构K,K1,首先应该析构K，但是K的析构只会减一，因为它的地址还被K1保留，那我要析构就要先去析构K1，但是K1的节点也被K保留，就会出现循环引用导致报错。

为了解决这个问题，shared_ptr又加了一种指针——week_ptr,即弱指针，它使用的时候并不会将count++，也就解决了析构的时候出现的减不到零的情况。

模拟实现：

    template<class K>class weak_ptr{weak_ptr():_ptr(nullptr){}
​weak_ptr(const shared_ptr<K>& K1):_ptr(ptr){}
​weak_ptr operator(const shared_ptr<K>& K1){if (K1.get() != _ptr){_ptr = K1._ptr;}
​return *this;}
​K& operator&(){return *_ptr;}
​K* operator*(){return _ptr;}
​private:K* _ptr;};

这样就不会出现循环引用的问题，感谢观看，希望这篇文章能带你初步了解智能指针的思想和模拟实现。