前言：在此之前我们已经学习到了异常的使用，虽然异常在大部分情况都还可以，但也存在太多缺陷，对于异常的问题，入内存泄漏，在复杂的场景下使用起来也是非常麻烦。为了更好的解决这些问题，c++11中引入了智能指针。

目录

一，什么是智能指针？

二，智能指针的使用

简化autoptr

简化uniqueptr

简化sharedptr

简化weakptr

定制删除器

---

一，什么是智能指针？

智能指针（RAII）是一种C++标准库提供的对象，用于管理动态分配的内存（用对象生命后期来控制程序资源）。智能指针本身是一个类对象，它封装了指向动态分配的内存的指针，并提供了自动释放内存的机制。智能指针的行为类似于常规指针，可以通过解引用操作符（*）和成员访问操作符（->）来访问内存中的数据。C++11引入了3个智能指针类型：
std::unique_ptr<T>：独占资源所有权的指针。
std::shared_ptr<T>：共享资源所有权的指针。
std::weak_ptr<T>：共享资源的观察者，需要和std::shared_ptr一起使用，不影响资源的生命周期。

二，智能指针的使用

我们还是先给一个例子，这里就是空间得不到释放。

//还是以分母不能为零为例
double Division(int x, int y)
{if (y == 0){throw invalid_argument("除零错误");//这里我们是直接使用库里异常(无效参数)}else{return double(x) / double(y);}
}//如果不采用异常的重新抛出，如何释放这里的arr？
void Func()
{int* arr = new int[10];int x; int y;cin >> x >> y;Division(x, y);delete []arr;arr = nullptr;cout << " reliszed delete arr" << endl;
}
int main()
{try{Func();}catch (exception& e){cout << e.what();}return 0;
}

 解决办法：我们封装一个指针，将我们的这个需要释放的指针给这个只针对想，只针对象在跳出生命周期后会自动调用析构函数来释放这里的空间。

而这里就是RAII----通过控制对象的生命周期来控制资源的释放

template<class T>class Smartptr
{
public:Smartptr(T *ptr):_ptr(ptr){}~Smartptr(){delete []_ptr;cout << "delete ptr" << endl;}
private:T* _ptr;
};
//还是以分母不能为零为例
double Division(int x, int y)
{if (y == 0){throw invalid_argument("除零错误");//这里我们是直接使用库里异常(无效参数)}else{return double(x) / double(y);}
}//如果不采用异常的重新抛出，如何释放这里的arr？
void Func()
{int* arr = new int[10];int x; int y;cin >> x >> y;//在此之前，使用一个指针对象来控制我的生命后期//无异常，正常使用，有异常，生命周期结束，释放空间Smartptr<int> p(arr);Division(x, y);/*delete []arr;arr = nullptr;cout << " reliszed delete arr" << endl;*/
}
int main()
{try{Func();}catch (exception& e){cout << e.what();}return 0;
}

但是智能指针并不是这么简单就完了，我们的目的是要把它当作指针一样使用。因此整体我们还要实现他的一些接口。

template<class T>class Smartptr
{
public:Smartptr(T* ptr) :_ptr(ptr){}~Smartptr(){delete _ptr;cout << "delete ptr" << endl;}//使它想指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

但此时的智能指针还存在问题，首先就是赋值，浅拷贝会释放两次，我们可能会想到再写一个拷贝构造不经行了吗，事实上这里使用深拷贝是解决不掉问题的。

这里的内存问题，不同于之前的容器，比如vector，我们实例化一个对象并初始化内容，系统就为对象分配该空间并初始化，拷贝给另一个对象，系统会为该对象分配资源并初始化。即他们的空间与资源是不一样的，但是对于智能指针，我们就是管理这一部分资源，无论拷贝给谁，谁管理这一部分资源，深拷贝的话，那我拷贝几次，有几份该资源，这并不属于(RAII)我们使用智能指针的理念。

那么如何解决这样的问题，这里我们就使用 引用计数的方法来进行拷贝与释放。

再此之前，根据c++的发展也是不断提出更新新的方案：

简化autoptr

template<class T>class Autoptr
{
public:Autoptr(T* ptr) :_ptr(ptr){}~Autoptr(){delete _ptr;cout << "delete ptr" << endl;_ptr = nullptr;}//通过管理权转移的方式实现拷贝// 把我拷贝给你Autoptr(Autoptr<T>& p):_ptr(p._ptr){//通过把我置空，将资源转移给你p._ptr = nullptr;}//使它想指针一样使用T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;
};

autoptr的原理很简单，给谁拷贝，就把"权限"给谁（原本资源的位置），再把自己置空，实现资源转移，但这种写法显而易见的就是，空指针的访问，若有人不熟悉这个指针的原理，去访问拷贝后的原指针，就会导致对象悬空。

使用autoptr使得很多人被坑，之后出现第二个版本

简化uniqueptr

uniqueptr的做法比较绝，既然拷贝有问题，那干脆不支持你拷贝赋值了，通过私有只申明不实现的方法使我们无法访问拷贝构造。

template<class T>class Uniqueptr
{
public:Uniqueptr(T* ptr) :_ptr(ptr){}~Uniqueptr(){delete _ptr;cout << "delete ptr" << endl;_ptr = nullptr;}//T& operator*(){return *_ptr;}T* operator->(){return _ptr;}//c++11做法/*Uniquetptr(Uniquetptr<T> p) = delete;Uniquetptr<T>& operator=(Uniquetptr<T> p) - delete;*/
private://只申明不实现 c++98做法Uniqueptr(Uniqueptr<T>& p);//拷贝构造Uniqueptr<T>& operator=(Uniqueptr<T> p);//赋值T* _ptr;
};

但是不能拷贝不能解决根本问题，总有要拷贝的情况，因此又出来第三代智能指针。

简化sharedptr

sharedptr就是金泰主要认识的智能指针，通过引用技术的方式，实现赋值。

在实现的时候，我们增加一个参数count,count再调用构造函数时会被初始化为1，在拷贝的时候，此时这里的_ptr与原来的指向同一空间，这里的count也与原来的count指向同一空间，且对于拷贝给的这个count++，再调用析构时，对应的count只有一份，count先--,若count==0，说明到达释放的条件。就实现了资源的转移。

但是对于赋值，是分两种情况的，一种是同类资源的赋值。

一种是一类资源的赋值。

template<class T>class Sharedptr
{
public:Sharedptr(T* ptr) :_ptr(ptr),count(new int (1)){}~Sharedptr(){(*count)--;release();}void release(){if ((*count)== 0){delete _ptr;delete count;cout << "finish released" << endl;_ptr = nullptr;count = nullptr;}}Sharedptr(const Sharedptr& ptr):_ptr(ptr._ptr),count(ptr.count){++(*ptr.count);//拷贝的时候次数加加}//重载赋值  this=ptrSharedptr<T> operator=(const Sharedptr& ptr){//赋值的时候表示 把我这份资源交给你,你的资源被覆盖掉//判断不是自身赋值if (ptr.count != this->count){//左边赋值给右边 因此右边被覆盖掉 先count--代表右边已经被析构一次*(this->count)--;//判断此时为空不if (*(ptr.count) == 0){release();}//不为空就进行覆盖this->count = ptr.count;this->_ptr = ptr._ptr;//覆盖后此时的ptr指向 左边的资源//因此左边的count++*(this->count)++;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;int* count;
};

计数是几就代表此时有多少个对象指向这里的资源。

此时的sharedptr已经基本实现我们的期望了，但在使用中又发现了一个无法解决的问题：循环引用。循环引用会导致死循环。

struct ListNode
{ListNode(){cout << "调用构造" << endl;}~ListNode(){cout << "调用析构" << endl;}int data;Sharedptr<ListNode> next;Sharedptr<ListNode> prev;
};
void test_sharedptr1()
{//假设害怕这里的节点得不到释放，我们用sharedptr来管理Sharedptr<ListNode> p1 = new ListNode();Sharedptr<ListNode> p2 = new ListNode();p1->next = p2;p2->prev = p1;}
int main()
{test_sharedptr1();return 0;
}

我们模拟一个双链表的节点的链接，此时运行这个程序就会崩掉，但是删除其中一个的链接，调用就会成功，这里主要原因就是析构死循环了。

若是有一次链接

若是如上代码的两次链接

即先释放两个对象，此时都为1，在释放两个其中的节点，而释放其中的一个节点是被牵制的，需要我们再次看 上一个牵制的。如此往上，就形成了一个死循环，导致资源没有被释放。

 库里加了explicet就不可以通过转换构造函数实现隐式类型转换的发生。

简化weakptr

为了专门解决也这个问题，再sharedptr的基础修改，引入了weakptr。这里的weakptr已经不属于RAII了,这里的已经不是智能指针了，使用weakptr,在这个地方不会引用计数。

template<class T>class Sharedptr
{
public:Sharedptr():_ptr(nullptr), count(new int(1)){}Sharedptr(T* ptr) :_ptr(ptr),count(new int (1)){}~Sharedptr(){(*count)--;release();}void release(){if ((*count)== 0){delete _ptr;delete count;//cout << "finish released" << endl;_ptr = nullptr;count = nullptr;}}Sharedptr(const Sharedptr& ptr):_ptr(ptr._ptr),count(ptr.count){++(*ptr.count);//拷贝的时候次数加加}//重载赋值  this=ptrSharedptr<T> operator=(const Sharedptr& ptr){//赋值的时候表示 把我这份资源交给你,你的资源被覆盖掉//判断不是自身赋值if (ptr.count != this->count){//左边赋值给右边 因此右边被覆盖掉 先count--代表右边已经被析构一次*(this->count)--;//判断此时为空不if (*(ptr.count) == 0){release();}//不为空就进行覆盖this->count = ptr.count;this->_ptr = ptr._ptr;//覆盖后此时的ptr指向 左边的资源//因此左边的count++*(this->count)++;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}int use_count()const{return *count;}T* get()const{return _ptr;}
private:T* _ptr;int* count;
};template<class T>class Weakptr
{
public://weakptr就不参与计数Weakptr() :_ptr(nullptr){}Weakptr(const Sharedptr<T>& p):_ptr(p.get()){}Weakptr& operator=(const Sharedptr<T>& p){_ptr = p.get();return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;
};

定制删除器

上述的我们都是针对单一的指针，若是指针数组，释放就不会正确释放，程序是崩溃的，为了使我们的释放要考虑周全，因此这里释放我们可以使用仿函数，lambda或者函数指针进行删除。

由于库中的删除器，实在构造里调用的，因此我们在实现时，通过在构造传参，增加一个包装器，来初始化，之后析构的时候调用包装器，并在默认情况下给缺省值。

template<class T>class Sharedptr
{public:Sharedptr() :_ptr(nullptr), count(new int(1)){}template<class DEL>Sharedptr(T* ptr, DEL del) :_ptr(ptr),count(new int (1)), del(del){}~Sharedptr(){(*count)--;release();}void release(){if ((*count)== 0){del(_ptr) ;delete count;//cout << "finish released" << endl;_ptr = nullptr;count = nullptr;}}Sharedptr(const Sharedptr& ptr):_ptr(ptr._ptr),count(ptr.count){++(*ptr.count);//拷贝的时候次数加加}//重载赋值  this=ptrSharedptr<T> operator=(const Sharedptr& ptr){//赋值的时候表示 把我这份资源交给你,你的资源被覆盖掉//判断不是自身赋值if (ptr.count != this->count){//左边赋值给右边 因此右边被覆盖掉 先count--代表右边已经被析构一次*(this->count)--;//判断此时为空不if (*(ptr.count) == 0){release();}//不为空就进行覆盖this->count = ptr.count;this->_ptr = ptr._ptr;//覆盖后此时的ptr指向 左边的资源//因此左边的count++*(this->count)++;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}int use_count()const{return *count;}T* get()const{return _ptr;}
private:T* _ptr;int* count;function<void(T*)> del = [](T* ptr) {delete ptr; };
};