本文共 15843 字，大约阅读时间需要 52 分钟。

文章目录

0.前言

C++ 标准模板库 STL（Standard Template Library） 一共给我们提供了四种智能指针：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，其中 auto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_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 ] ^{[6]} [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 过期时。要避免这种问题，方法有多种：

（a）定义陚值运算符，使之执行深复制。这样两个指针将指向不同的对象，其中的一个对象是另一个对象的副本，缺点是浪费空间，所以智能指针都未采用此方案。 （b）建立所有权（ownership）概念。对于特定的对象，只能有一个智能指针可拥有，这样只有拥有对象的智能指针的析构函数会删除该对象。然后让赋值操作转让所有权。这就是用于 auto_ptr 和 unique_ptr 的策略，但 unique_ptr 的策略更严格。 （c）创建智能更高的指针，跟踪引用特定对象的智能指针数。这称为引用计数。例如，赋值时，计数将加 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 不能完成的功能。

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

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

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

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

（c）自定义资源删除操作（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.1 简介

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）为基础对象类实现智能指针类

引用计数是实现智能指针的一种通用方法。智能指针将一个计数器与类指向的对象相关联，引用计数跟踪共有多少个类对象共享同一指针。它的具体做法如下： （a）当创建智能指针类的新对象时，初始化指针，并将引用计数设置为1； （b）当能智能指针类对象作为另一个对象的副本时，拷贝构造函数复制副本的指向辅助类对象的指针，并增加辅助类对象对基础类对象的引用计数（加1）； （c）使用赋值操作符对一个智能指针类对象进行赋值时，处理复杂一点：先使左操作数的引用计数减 1（为何减 1：因为指针已经指向别的地方），如果减1后引用计数为 0，则释放指针所指对象内存。然后增加右操作数所指对象的引用计数（为何增加：因为此时做操作数指向对象即右操作数指向对象）； （d）完成析构函数：调用析构函数时，析构函数先使引用计数减 1，如果减至 0 则 delete 对象。

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

class SmartPtr {public:	//构造函数	SmartPtr() { rp = nullptr; }	SmartPtr(Point *ptr):rp(new RefPtr(ptr)) {}	SmartPtr(const SmartPtr &sp):rp(sp.rp) { 		++rp->count;		cout << "in copy constructor" <
   
    count;		if (rp != nullptr && --rp->count == 0) {			delete rp;		}		rp = rhs.rp;		cout << "in assignment operator" << endl;		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:" << sptr1->getX() << "," << sptr1->getY() <
   
    getX() << "," << sptr2->getY() <
    
     getX() << endl;    return 0;}
    
   

运行结果：

sptr1:10,20in copy constructorsptr2:10,20in assignment operatorsptr3:10,20还有2个指针指向基础对象还有1个指针指向基础对象-572662307

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

（5）对智能指针的改进

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

//模板类作为友元时要先有声明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<