转自： https://blog.csdn.net/k346k346/article/details/81478223 

STL一共给我们提供了四种智能指针：auto_ptr、unique_ptr、shared_ptr和weak_ptr，auto_ptr是C++98提供的解决方案，C+11已将其摒弃，并提出了unique_ptr作为auto_ptr替代方案。虽然auto_ptr已被摒弃，但在实际项目中仍可使用，但建议使用较新的unique_ptr，因为unique_ptr比auto_ptr更加安全，后文会详细叙述。shared_ptr和weak_ptr则是C+11从准标准库Boost中引入的两种智能指针。此外，Boost库还提出了boost::scoped_ptr、boost::scoped_array、boost::intrusive_ptr 等智能指针，虽然尚未得到C++标准采纳，但是实际开发工作中可以使用。

1.unique_ptr

unique_ptr由C++11引入，旨在替代不安全的auto_ptr。unique_ptr是一种定义在< memory>中的智能指针。它持有对对象的独有权——两个unique_ptr不能指向一个对象，即unique_ptr不共享它的所管理的对象。它无法复制到其他unique_ptr，无法通过值传递到函数，也无法用于需要副本的任何标准模板库 （STL）算法。只能移动 unique_ptr，即对资源管理权限可以实现转移。这意味着，内存资源所有权可以转移到另一个unique_ptr，并且原始 unique_ptr 不再拥有此资源。实际使用中，建议将对象限制为由一个所有者所有，因为多个所有权会使程序逻辑变得复杂。因此，当需要智能指针用于纯 C++ 对象时，可使用 unique_ptr，而当构造 unique_ptr 时，可使用 make_unique Helper 函数。

下图演示了两个 unique_ptr 实例之间的所有权转换。

这里写图片描述

unique_ptr与原始指针一样有效，并可用于 STL 容器。将 unique_ptr 实例添加到 STL 容器很有效，因为通过 unique_ptr 的移动构造函数，不再需要进行复制操作。unique_ptr指针与其所指对象的关系：在智能指针生命周期内，可以改变智能指针所指对象，如创建智能指针时通过构造函数指定、通过reset方法重新指定、通过release方法释放所有权、通过移动语义转移所有权，unique_ptr还可能没有对象，这种情况被称为empty。[6]

unique_ptr的基本操作有：

//智能指针的创建  unique_ptr
     
       u_i; //创建空智能指针u_i.reset(new int(3)); //"绑定”动态对象  unique_ptr
      
        u_i2(new int(4));//创建时指定动态对象unique_ptr
       
         u(d);    //创建空unique_ptr,执行类型为T的对象，用类型为D的对象d来替代默认的删除器delete//所有权的变化  int *p_i = u_i2.release(); //释放所有权  unique_ptr
        
          u_s(new string("abc"));  unique_ptr
         
           u_s2 = std::move(u_s); //所有权转移(通过移动语义)，u_s所有权转移后，变成“空指针”u_s2.reset(u_s.release());//所有权转移u_s2=nullptr;//显式销毁所指对象，同时智能指针变为空指针。与u_s2.reset()等价
         
        
       
      
     

2.auto_ptr

auto_ptr 同样是STL中智能指针家族的成员之一，由C++98引入，定义在头文件<memory>。其功能和用法类似于unique_ptr，由 new expression 获得对象，在 auto_ptr 对象销毁时，他所管理的对象也会自动被 delete 掉。

auto_ptr从C++98使用至今，为何从C++11开始，引入unique_ptr来替代auto_ptr呢？原因主要有如下几点：

（1）基于安全考虑

先来看下面的赋值语句:

auto_ptr< string> ps (new string ("I reigned lonely as a cloud.”）;auto_ptr
     
       vocation;vocaticn = ps;
     

 上述赋值语句将完成什么工作呢？如果ps和vocation是常规指针，则两个指针将指向同一个string对象。这是不能接受的，因为程序将试图删除同一个对象两次，一次是ps过期时，另一次是vocation过期时。要避免这种问题，方法有多种：

（1）定义陚值运算符，使之执行深复制。这样两个指针将指向不同的对象，其中的一个对象是另一个对象的副本，缺点是浪费空间，所以智能指针都未采用此方案。

（2）建立所有权（ownership）概念。对于特定的对象，只能有一个智能指针可拥有，这样只有拥有对象的智能指针的析构函数会删除该对象。然后让赋值操作转让所有权。这就是用于auto_ptr和unique_ptr 的策略，但unique_ptr的策略更严格。

（3）创建智能更高的指针，跟踪引用特定对象的智能指针数。这称为引用计数。例如，赋值时，计数将加1，而指针过期时，计数将减1,。当减为0时才调用delete。这是shared_ptr采用的策略。

当然，同样的策略也适用于复制构造函数，即auto_ptr<string> vocation(ps)时也需要上面的策略。每种方法都有其用途，但为何要摒弃auto_ptr呢？

下面举个例子来说明。

#include 
     
      #include 
      
       #include 
       
        using namespace std;int main(){    auto_ptr
        
          films[5] ={    auto_ptr
         
           (new string("Fowl Balls")),    auto_ptr
          
            (new string("Duck Walks")), auto_ptr
           
             (new string("Chicken Runs")), auto_ptr
            
              (new string("Turkey Errors")), auto_ptr
             
               (new string("Goose Eggs")) }; auto_ptr
              
                pwin; pwin = films[2]; // films[2] loses ownership. 将所有权从films[2]转让给pwin，此时films[2]不再引用该字符串从而变成空指针 cout << "The nominees for best avian baseballl film are\n"; for(int i = 0; i < 5; ++i) { cout << *films[i] << endl; } cout << "The winner is " << *pwin << endl; return 0;}
              
             
            
           
          
         
        
       
      
     

 运行下发现程序崩溃了，原因在上面注释已经说的很清楚，films[2]已经是空指针了，下面输出访问空指针当然会崩溃了。但这里如果把auto_ptr换成shared_ptr或unique_ptr后，程序就不会崩溃，原因如下：

使用shared_ptr时运行正常，因为shared_ptr采用引用计数，pwin和films[2]都指向同一块内存，在释放空间时因为事先要判断引用计数值的大小因此不会出现多次删除一个对象的错误。

使用unique_ptr时编译出错，与auto_ptr一样，unique_ptr也采用所有权模型，但在使用unique_ptr时，程序不会等到运行阶段崩溃，而在编译期因下述代码行出现错误：

unique_ptr
     
       pwin;pwin = films[2];                     //films[2] loses ownership
     

指导你发现潜在的内存错误。这就是为何要摒弃auto_ptr的原因，一句话总结就是：避免因潜在的内存问题导致程序崩溃。

从上面可见，unique_ptr比auto_ptr更加安全，因为auto_ptr有拷贝语义，拷贝后原象变得无效，再次访问原对象时会导致程序崩溃；unique_ptr则禁止了拷贝语义，但提供了移动语义，即可以使用std::move()进行控制权限的转移，如下代码所示：

unique_ptr
     
       upt(new string("lvlv"));unique_ptr
      
        upt1(upt);    //编译出错，已禁止拷贝unique_ptr
       
         upt1=upt;    //编译出错，已禁止拷贝unique_ptr
        
          upt1=std::move(upt);  //控制权限转移auto_ptr
         
           apt(new string("lvlv"));auto_ptr
          
            apt1(apt); //编译通过auto_ptr
           
             apt1=apt; //编译通过
           
          
         
        
       
      
     

 这里要注意，在使用std::move将unique_ptr的控制权限转移后，不能够再通过unique_ptr来访问和控制资源了，否则同样会出现程序崩溃。我们可以在使用unique_ptr访问资源前，使用成员函数get()进行判空操作。

unique_ptr
     
       upt1=std::move(upt);                              //控制权限转移if(upt.get()!=nullptr)                                                                //判空操作更安全{    //do something}
     

 （2）unique_ptr不仅安全，而且灵活

如果unique_ptr 是个临时右值，编译器允许拷贝语义。参考如下代码：

unique_ptr
     
       demo(const char * s){    unique_ptr
      
        temp (new string (s))；    return temp；}//假设编写了如下代码：unique_ptr
       
         ps;ps = demo('Uniquely special")；
       
      
     

 demo()返回一个临时unique_ptr，然后ps接管了临时对象unique_ptr所管理的资源，而返回时临时的 unique_ptr 被销毁，也就是说没有机会使用 unique_ptr 来访问无效的数据，换句话来说，这种赋值是不会出现任何问题的，即没有理由禁止这种赋值。实际上，编译器确实允许这种赋值。相对于auto_ptr任何情况下都允许拷贝语义，这正是unique_ptr更加灵活聪明的地方。

（3）扩展auto_ptr不能完成的功能

（3.1）unique_ptr可放在容器中，弥补了auto_ptr不能作为容器元素的缺点。

//方式一：vector
     
      
       > vs { new string{“Doug”}, new string{“Adams”} };  //方式二：vector
       
        
         >v;  unique_ptr
         
           p1(new string("abc"));
         
        
       
      
     

（3.2）管理动态数组，因为unique_ptr有unique_ptr<X[]>重载版本，销毁动态对象时调用delete[]。

unique_ptr
     
       p (new int[3]{1,2,3});  p[0] = 0;// 重载了operator[]
     

 （3.3）自定义资源删除操作(Deleter)。unique_ptr默认的资源删除操作是delete/delete[]，若需要，可以进行自定义：

void end_connection(connection *p) { disconnect(*p); } //资源清理函数  //资源清理器的“类型”unique_ptr
     
       p(&c, end_connection);// 传入函数名，会自动转换为函数指针
     

 综上所述，基于unique_ptr的安全性和扩充的功能，unique_ptr成功的将auto_ptr取而代之。

3.shared_ptr

3.1shared_ptr简介

shared_ptr 是一个标准的共享所有权的智能指针，允许多个指针指向同一个对象，定义在 memory 文件中，命名空间为 std。shared_ptr最初实现于Boost库中，后由C++11引入到C++ STL。shared_ptr利用引用计数的方式实现了对所管理的对象的所有权的分享，即允许多个shared_ptr共同管理同一个对象。像shared_ptr这种智能指针，《Effective C++》称之为“引用计数型智能指针”（reference-counting smart pointer，RCSP）。

shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的)，在使用引用计数的机制上提供了可以共享所有权的智能指针，当然这需要额外的开销：

（1）shared_ptr 对象除了包括一个所拥有对象的指针外，还必须包括一个引用计数代理对象的指针；

（2）时间上的开销主要在初始化和拷贝操作上， *和->操作符重载的开销跟auto_ptr是一样；

（3）开销并不是我们不使用shared_ptr的理由,，永远不要进行不成熟的优化，直到性能分析器告诉你这一点。

3.2通过辅助类模拟实现shared_ptr

（1）基础对象类

首先，我们来定义一个基础对象类Point类，为了方便后面我们验证智能指针是否有效，我们为Point类创建如下接口：

class Point{private:    int x, y;public:    Point(int xVal = 0, int yVal = 0) :x(xVal), y(yVal) { }    int getX() const { return x; }    int getY() const { return y; }    void setX(int xVal) { x = xVal; }    void setY(int yVal) { y = yVal; }};

（2）辅助类

在创建智能指针类之前，我们先创建一个辅助类。这个类的所有成员皆为私有类型，因为它不被普通用户所使用。为了只为智能指针使用，还需要把智能指针类声明为辅助类的友元。这个辅助类含有两个数据成员：计数count与基础对象指针。也即辅助类用以封装使用计数与基础对象指针。

class RefPtr{private:    friend class SmartPtr;          RefPtr(Point *ptr):p(ptr),count(1){ }    ~RefPtr(){delete p;}        int count;       Point *p;                                                      };

（3）为基础对象类实现智能指针类

引用计数是实现智能指针的一种通用方法。智能指针将一个计数器与类指向的对象相关联，引用计数跟踪共有多少个类对象共享同一指针。它的具体做法如下：

（3.1）当创建智能指针类的新对象时，初始化指针，并将引用计数设置为1；

（3.2）当能智能指针类对象作为另一个对象的副本时，拷贝构造函数复制副本的指向辅助类对象的指针，并增加辅助类对象对基础类对象的引用计数（加1）；

（3.3）使用赋值操作符对一个智能指针类对象进行赋值时，处理复杂一点：先使左操作数的引用计数减1（为何减1：因为指针已经指向别的地方），如果减1后引用计数为0，则释放指针所指对象内存。然后增加右操作数所指对象的引用计数（为何增加：因为此时做操作数指向对象即右操作数指向对象）。

（3.4）完成析构函数：调用析构函数时，析构函数先使引用计数减1，如果减至0则delete对象。

做好前面的准备后，我们可以为基础对象类Point书写一个智能指针类了。根据引用计数实现关键点，我们可以写出如下智能指针类：

class SmartPtr{public:    SmartPtr(Point *ptr) :rp(new RefPtr(ptr)){}    SmartPtr(const SmartPtr &sp):rp(sp.rp){++rp->count;}    //重载赋值运算符SmartPtr& operator=(const SmartPtr& rhs){        ++rhs.rp->count;            if (--rp->count == 0)                delete rp;        rp = rhs.rp;        return *this;    }    //重载->操作符    Point* operator->()    {        return rp->p;    }    //重载*操作符    Point& operator*()    {        return *(rp->p);    }        ~SmartPtr()    {               if (--rp->count == 0)               delete rp;        else            cout << "还有" << rp->count << "个指针指向基础对象" << endl;    }    private:    RefPtr *rp;  };

（4）智能指针类的使用与测试

至此，我们的智能指针类就完成了，我们可以来看看如何使用。

int main(){    //定义一个基础对象类指针    Point *pa = new Point(10, 20);    //定义三个智能指针类对象，对象都指向基础类对象pa    //使用花括号控制三个智能指针的生命周期，观察计数的变化    {        SmartPtr sptr1(pa);//此时计数count=1        cout <<"sptr1:"<
     
      getX()<<","<
      
       getY()<
       
        getX()<<","<
        
         getY()<
         
          getX ()<< endl;    system("pause");    return 0;}
         
        
       
      
     

 运行结果：

sptr1:10,20sptr2:10,20sptr3:10,20还有2个指针指向基础对象还有1个指针指向基础对象7244864

 如期，在离开大括号后，共享基础对象的指针从3->2->1->0变换，最后计数为0时，pa对象被delete，此时使用getX()已经获取不到原来的值。

（5）对智能指针的改进

目前这个智能指针智能用于管理Point类的基础对象，如果此时定义了个矩阵的基础对象类，那不是还得重新写一个属于矩阵类的智能指针类吗？但是矩阵类的智能指针类设计思想和Point类一样啊，就不能借用吗？答案当然是能，那就是使用模板技术。为了使我们的智能指针适用于更多的基础对象类，我们有必要把智能指针类通过模板来实现。这里贴上上面的智能指针类的模板版：

//模板类作为友元时要先有声明template 
     
       class SmartPtr;   //辅助类template 
      
        class RefPtr{private:    //该类成员访问权限全部为private，因为不想让用户直接使用该类    friend class SmartPtr
       
        ;      //定义智能指针类为友元，因为智能指针类需要直接操纵辅助类        //构造函数的参数为基础对象的指针    RefPtr(T *ptr) :p(ptr), count(1) { }        //析构函数    ~RefPtr() { delete p; }    //引用计数    int count;           //基础对象指针    T *p;                                                      };//智能指针类template 
        
          class SmartPtr{public:    SmartPtr(T *ptr) :rp(new RefPtr
         
          (ptr)) { }      //构造函数    SmartPtr(const SmartPtr
          
            &sp) :rp(sp.rp) { ++rp->count; } //复制构造函数 SmartPtr& operator=(const SmartPtr
           
            & rhs) //重载赋值操作符 { ++rhs.rp->count; //首先将右操作数引用计数加1， if (--rp->count == 0) //然后将引用计数减1，可以应对自赋值 delete rp; rp = rhs.rp; return *this; } T & operator *() //重载*操作符 { return *(rp->p); } T* operator ->() //重载->操作符 { return rp->p; } ~SmartPtr() //析构函数 { if (--rp->count == 0) //当引用计数减为0时，删除辅助类对象指针，从而删除基础对象 delete rp; else { cout << "还有" << rp->count << "个指针指向基础对象" << endl; } }private: RefPtr
            
              *rp; //辅助类对象指针};
            
           
          
         
        
       
      
     

现在使用智能指针类模板来共享其它类型的基础对象，以int为例：

int main(){    //定义一个基础对象类指针    int* ia = new int(10);    {        SmartPtr
     
       sptr1(ia);        cout <<"sptr1:"<<*sptr1<
      

sptr2(sptr1); cout <<"sptr2:"<<*sptr2<