C++智能指针详解

1、概述

我们知道除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。

在C++中，动态内存的管理是用一对运算符完成的：new和delete。
new：在动态内存中为对象分配一块空间并返回一个指向该对象的指针;
delete：指向一个动态独享的指针，销毁对象，并释放与之关联的内存。

动态内存管理经常会出现两种问题：
（1）一种是忘记释放内存，会造成内存泄漏；
（2）一种是尚有指针引用内存的情况下就释放了它，就会产生引用非法内存的指针。

为了更加容易（更加安全）的使用动态内存，引入了智能指针的概念。智能指针的行为类似常规指针，重要的区别是它负责自动释放所指向的对象。

标准库提供的两种智能指针的区别在于管理底层指针的方法不同：shared_ptr和unique_ptr。
（1）shared_ptr允许多个指针指向同一个对象；
（2）unique_ptr则“独占”所指向的对象。

标准库还定义了一种名为weak_ptr的伴随类，它是一种弱引用，指向shared_ptr所管理的对象，这三种智能指针都定义在memory头文件中。

2、auto_ptr （不要使用的指针）

（1）内部大概实现：做成一个auto_ptr类，包含原始指针成员。
当auto_ptr类型的对象被释放时，利用析构函数，将拥有的原始指针delete掉。

//大概长这个样子（简化版）
template<class T>
class auto_ptr
{　　
    T* ptr;
};

（2）示例用法：

 void runGame()
{
  std::auto_ptr<Monster> monster1(new Monster());//monster1 指向 一个怪物
  monster1->doSomething();//怪物做某种事
}//runGame函数执行完时，monster1被释放，然后它的析构函数也把指向的一个怪物释放了

复制auto_ptr对象时，把指针指传给复制出来的对象，原有对象的指针成员随后重置为nullptr。
这说明auto_ptr是独占性的，不允许多个auto_ptr指向同一个资源。

void runGame()
{
     std::auto_ptr<Monster> monster1(new Monster());//monster1 指向 一个怪物
     monster1->doSomething();						//怪物做某种事
     std::auto_ptr<Monster> monster2 = monster1;	//转移指针
     monster2->doSomething();						//怪物做某种事
     monster1->doSomething();						//Oops!monster1智能指针指向了nullptr，运行期崩溃。
}

注意：
虽然本文简单介绍了auto_ptr。
但是不要用auto_ptr! 不要用auto_ptr!

虽然它是c++11以前的最原始的智能指针，但是在c++11中已经被弃用（使用的话会被警告）了。
它的替代品，也就是c++11新智能指针unique_ptr,shared_ptr,weak_ptr。

3、shared_ptr（一种强引用指针）

多个shared_ptr指向同一处资源，当所有shared_ptr都全部释放时，该处资源才释放。
（有某个对象的所有权（访问权，生命控制权） 即是 强引用，所以shared_ptr是一种强引用型指针）

（1）内部大概实现：每次复制，多一个共享同处资源的shared_ptr时，计数+1。每次释放shared_ptr时，计数-1。
当shared计数为0时，则证明所有指向同一处资源的shared_ptr们全都释放了，则随即释放该资源（哦，还会释放new出来的SharedPtrControlBlock）。

//shared计数放在这个结构体里面，实际上结构体里还应该有另一个weak计数。下文介绍weak_ptr时会解释。
struct SharedPtrControlBlock
{　　
  int shared_count;
};
//大概长这个样子（简化版）
template<class T>
class shared_ptr
{　　
  T* ptr;　　
  SharedPtrControlBlock* count;
};

（2）示例用法：

void runGame()
{　　
    std::shared_ptr<Monster> monster1(new Monster());　 //计数加到1
　do{
       std::shared_ptr<Monster> monster2 = monster1;　	//计数加到2　　
    }while(0);　　　　　　　　　　
　　//该栈退出后，计数减为1，monster1指向的堆对象仍存在
　　std::shared_ptr<Monster> monster3 = monster1;　　 	//计数加到2
}//该栈退出后，shared_ptr都释放了，计数减为0，它们指向的堆对象也能跟着释放.

缺陷：模型循环依赖(互相引用或环引用)时，计数会不正常

假如有这么一个怪物模型，它有2个亲人关系：

class Monster
{　　
    std::shared_ptr<Monster> m_father;　　
    std::shared_ptr<Monster> m_son;

public:　　
    void setFather(std::shared_ptr<Monster>& father);    　　
    void setSon(std::shared_ptr<Monster>& son);　　　 
    ~Monster(){std::cout << "A monster die!";}　　　　   
};

void runGame()
{
     std::shared_ptr<Monster> father = new Monster();
     std::shared_ptr<Monster> son = new Monster();
     father->setSon(son);
     son->setFather(father);
}

函数退出时栈的shared_ptr对象陆续释放后的情形：
（1）一开始：father,son指向的堆对象 shared计数都是为2；
（2）son智能指针退出栈：son指向的堆对象 计数减为1，father指向的堆对象 计数仍为2。
（3）father智能指针退出栈：father指向的堆对象 计数减为1 , son指向的堆对象 计数仍为1。
（4）函数结束：所有计数都没有变0，也就是说中途没有释放任何堆对象。

为了解决这一缺陷的存在，弱引用指针weak_ptr的出现很有必要。

--------->
创建智能指针时必须提供额外的信息，指针可以指向的类型：

shared_ptr<string>p1;
shared_ptr<list<int>> p2;

默认初始化的智能指针中保存着一个空指针。
智能指针的使用方式和普通指针类似，解引用一个智能指针返回它指向的对象，在一个条件判断中使用智能指针就是检测它是不是空。

if(p1 && p1->empty())
  *p1 = "hi";

如下表所示是shared_ptr和unique_ptr都支持的操作：

如下表所示是shared_ptr特有的操作：

函数说明
1）make_share函数
最安全的分配和使用动态内存的方法就是调用一个名为make_shared的标准库函数，此函数在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr。头文件和share_ptr相同，在memory中 。

必须指定想要创建对象的类型，定义格式见下面例子：

shared_ptr<int> p3 = make_shared<int>(42);
shared_ptr<string> p4 = make_shared<string>(10,'9');
shared_ptr<int> p5 = make_shared<int>();

make_shared用其参数来构造给定类型的对象，如果我们不传递任何参数，对象就会进行值初始化。

2）shared_ptr的拷贝和赋值
当进行拷贝和赋值时，每个shared_ptr都会记录1有多少个其他shared_ptr都会记录有多少个其他shared_ptr指向相同的对象。

auto p = make_shared<int>(42);
auto q(p);

我们可以认为每个shared_ptr都有一个关联的计数器，通常称其为引用计数，无论何时我们拷贝一个shared_ptr，计数器都会递增。当我们给shared_ptr赋予一个新值或是shared_ptr被销毁（例如一个局部的shared_ptr离开其作用域）时，计数器就会递减，一旦一个shared_ptr的计数器变为0,它就会自动释放自己所管理的对象。

auto r = make_shared<int>(42); 	//r指向的int只有一个引用者

r=q;							//给r赋值，令它指向另一个地址
								//递增q指向的对象的引用计数
								//递减r原来指向的对象的引用计数
								//r原来指向的对象已没有引用者，会自动释放

3）shared_ptr自动销毁所管理的对象
当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象，它是通过另一个特殊的成员函数-析构函数完成销毁工作的，类似于构造函数，每个类都有一个析构函数。

析构函数控制对象销毁时做什么操作。析构函数一般用来释放对象所分配的资源。shared_ptr的析构函数会递减它所指向的对象的引用计数。如果引用计数变为0，shared_ptr的析构函数就会销毁对象，并释放它所占用的内存。

4）shared_ptr还会自动释放相关联的内存
当动态对象不再被使用时，shared_ptr类还会自动释放动态对象，这一特性使得动态内存的使用变得非常容易。如果你将shared_ptr存放于一个容器中，而后不再需要全部元素，而只使用其中一部分，要记得用erase删除不再需要的那些元素。

使用了动态生存期的资源的类，程序使用动态内存的原因：

• 程序不知道自己需要使用多少对象
• 程序不知道所需对象的准确类型
• 程序需要在多个对象间共享数据

5）不要混合使用普通指针和智能指针
如果混合使用的话，智能指针自动释放之后，普通指针有时就会变成悬空指针，当将一个shared_ptr绑定到一个普通指针时，我们就将内存的管理责任交给了这个shared_ptr。一旦这样做了，我们就不应该再使用内置指针来访问shared_ptr所指向的内存了。

也不要使用get初始化另一个智能指针或为智能指针赋值。

shared_ptr<int> p(new int(42));//引用计数为1
int *q = p.get();//正确：但使用q时要注意，不要让它管理的指针被释放
{
    //新程序块

    //未定义：两个独立的share_ptr指向相同的内存
    shared_ptr(q);
}//程序块结束，q被销毁，它指向的内存被释放

int foo = *p;//未定义，p指向的内存已经被释放了

6）其他shared_ptr操作
可以使用reset来将一个新的指针赋予一个shared_ptr:

p = new int(1024);//错误：不能将一个指针赋予shared_ptr
p.reset(new int(1024));//正确。p指向一个新对象

与赋值类似，reset会更新引用计数，如果需要的话，会释放p的对象。reset成员经常和unique一起使用，来控制多个shared_ptr共享的对象。在改变底层对象之前，我们检查自己是否是当前对象仅有的用户。如果不是，在改变之前要制作一份新的拷贝：

f(!p.unique())
	p.reset(new string(*p));//我们不是唯一用户，分配新的拷贝
*p+=newVal;//现在我们知道自己是唯一的用户，可以改变对象的值

7）智能指针和异常
如果使用智能指针，即使程序块过早结束，智能指针也能确保在内存不再需要时将其释放，sp是一个shared_ptr,因此sp销毁时会检测引用计数，当发生异常时，我们直接管理的内存是不会自动释放的。如果使用内置指针管理内存，且在new之后在对应的delete之前发生了异常，则内存不会被释放。

使用我们自己的释放操作：
默认情况下，shared_ptr假定他们指向的是动态内存，因此当一个shared_ptr被销毁时，会自动执行delete操作，为了用shared_ptr来管理一个connection，我们必须首先必须定义一个函数来代替delete。这个删除器函数必须能够完成对shared_ptr中保存的指针进行释放的操作。

8）智能指针陷阱：

• 不使用相同的内置指针值初始化（或reset）多个智能指针。
• 不delete get()返回的指针
• 不使用get()初始化或reset另一个智能指针
• 如果你使用get()返回的指针，记住当最后一个对应的智能指针销毁后，你的指针就变为无效了
• 如果你使用智能指针管理的资源不是new分配的内存，记住传递给它一个删除器。

4、weak_ptr（一种弱引用指针）

weak_ptr是为了辅助shared_ptr的存在，它只提供了对管理对象的一个访问手段，同时也可以实时动态地知道指向的对象是否存活。

（只有某个对象的访问权，而没有它的生命控制权 即是 弱引用，所以weak_ptr是一种弱引用型指针）

（1）内部大概实现

• 计数区域(SharedPtrControlBlock)结构体引进新的int变量weak_count，来作为弱引用计数。
• 每个weak_ptr都占指针的两倍空间，一个装着原始指针，一个装着计数区域的指针（和shared_ptr一样的成员）。
• weak_ptr可以由一个shared_ptr或者另一个weak_ptr构造。
• weak_ptr的构造和析构不会引起shared_count的增加或减少，只会引起weak_count的增加或减少。

被管理资源的释放只取决于shared计数，当shared计数为0，才会释放被管理资源，也就是说weak_ptr不控制资源的生命周期。
但是计数区域的释放却取决于shared计数和weak计数，当两者均为0时，才会释放计数区域。

//shared引用计数和weak引用计数
//之前的计数区域实际最终应该长这个样子
struct SharedPtrControlBlock
{　　
   int shared_count;　　
   int weak_count;
};
//大概长这个样子（简化版）
template<class T>
class weak_ptr
{　　
   T* ptr;　　
   SharedPtrControlBlock* count;
};

（2）针对空悬指针问题
空悬指针问题是指：无法知道指针指向的堆内存是否已经释放。

得益于引入的weak_count,weak_ptr指针可以使计数区域的生命周期受weak_ptr控制，

从而能使weak_ptr获取 被管理资源的shared计数，从而判断被管理对象是否已被释放。（可以实时动态地知道指向的对象是否被释放,从而有效解决空悬指针问题）

它的成员函数**expired()**就是判断指向的对象是否存活。

（3）针对循环引用问题

class Monster{
　　//尽管父子可以互相访问，但是彼此都是独立的个体，无论是谁都不应该拥有另一个人的所有权。
　　std::weak_ptr<Monster> m_father;　　　　//所以都把shared_ptr换成了weak_ptr
　　std::weak_ptr<Monster> m_son;　　　　　　//同上

public:
　　void setFather(std::shared_ptr<Monster>& father); //实现细节懒得写了
　　void setSon(std::shared_ptr<Monster>& son);　　　　//懒
　　~Monster(){std::cout << "A monster die!";}　　　　 //析构时发出死亡的悲鸣
};

然后执行下面的函数：

void runGame()
{　　
    std::shared_ptr<Monster> father(new Monster());　　
    std::shared_ptr<Monster> son(new Monster());　　
    father->setSon(son);　　
    son->setFather(father);
}

那么我们再来模拟一遍，函数退出时栈的shared_ptr对象陆续释放后的情形：

• 一开始：father指向的堆对象 shared计数为1,weak计数为1；son指向的堆对象 shared计数为1,weak计数为1；
• son智能指针退出栈：son指向的堆对象 shared计数减为0,weak计数为1,释放son的堆对象；father指向的堆对象 shared计数为1,weak计数减为0;
• father智能指针退出栈：father指向的堆对象 shared计数减为0,weak计数为0;释放father的堆对象和father的计数区域；son指向的堆对象 shared计数为0,weak计数减为0;释放son的计数区域。
• 函数结束，释放行为正确。

（可以说，当生命控制权没有彼此互相掌握时，才能正确解决循环引用问题，而弱引用的使用可以使生命控制权互相掌握的情况消失）

此外：
weak_ptr没有重载 * 和 -> ，所以并不能直接使用资源。但可以使用lock()获得一个可用的shared_ptr对象，如果对象已经死了，lock()会失败，返回一个空的shared_ptr。

void runGame()
{　　
  std::shared_ptr<Monster> monster1(new Monster());　　 
  std::weak_ptr<Monster> r_monster1 = monster1;　　
  r_monster1->doSomething();//Error! 编译器出错！weak_ptr没有重载* 和 -> ，无法直接当指针用　　   		      std::shared_ptr s_monster1 = r_monster1.lock();//OK!可以通过weak_ptr的lock方法获得shared_ptr。
}

5、unique_ptr（一种强引用）

正如它的名字，独占 是它最大的特点。

（1）内部大概实现
它其实算是auto_ptr的翻版(都是独占资源的指针,内部实现也基本差不多).

但是unique_ptr的名字能更好的体现它的语义，而且在语法上比auto_ptr更安全（尝试复制unique_ptr时会编译期出错，而auto_ptr能通过编译期从而在运行期埋下出错的隐患）

假如你真的需要转移所有权（独占权），那么你就需要用std::move(std::unique_ptr对象)语法，尽管转移所有权后 还是有可能出现原有指针调用（调用就崩溃）的情况。
但是这个语法能强调你是在转移所有权，让你清晰的知道自己在做什么，从而不乱调用原有指针。

（2）示例用法

void runGame()
{　　
  std::unique_ptr<Monster> monster1(new Monster());//monster1 指向 一个怪物　　
  std::unique_ptr<Monster> monster2 = monster1;//Error!编译期出错，不允许复制指针指向同一个资源。　　   	std::unique_ptr monster3 = std::move(monster1);//转移所有权给monster3.　　
  monster1->doSomething();//Oops!monster1指向nullptr，运行期崩溃 
}

（额外：boost库的boost::scoped_ptr也是一个独占性智能指针，但是它不允许转移所有权，从始而终都只对一个资源负责，它更安全谨慎，但是应用的范围也更狭窄。）

虽然我们不能拷贝或者赋值unique_ptr，但是可以通过调用release或reset将指针所有权从一个（非const）unique_ptr转移给另一个unique。

//将所有权从p1（指向string Stegosaurus）转移给p2
unique_ptr<string> p2(p1.release());//release将p1置为空
unique_ptr<string>p3(new string("Trex"));

//将所有权从p3转移到p2
p2.reset(p3.release());//reset释放了p2原来指向的内存

release成员返回unique_ptr当前保存的指针并将其置为空。因此，p2被初始化为p1原来保存的指针，而p1被置为空。

reset成员接受一个可选的指针参数，令unique_ptr重新指向给定的指针。

调用release会切断unique_ptr和它原来管理的的对象间的联系。release返回的指针通常被用来初始化另一个智能指针或给另一个智能指针赋值。

不能拷贝unique_ptr有一个例外：我们可以拷贝或赋值一个将要被销毁的unique_ptr。
最常见的例子是从函数返回一个unique_ptr：

unique_ptr<int> clone(int p)
{
  //正确：从int*创建一个
  unique_ptr<int> return unique_ptr<int>(new int(p));
}

还可以返回一个局部对象的拷贝：

unique_ptr<int> clone(int p)
{
  unique_ptr<int> ret(new int(p));
  return ret;
}

向后兼容：auto_ptr
标准库的较早版本包含了一个名为auto_ptr的类，它具有uniqued_ptr的部分特性，但不是全部。

用unique_ptr传递删除器
unique_ptr默认使用delete释放它指向的对象，我们可以重载一个unique_ptr中默认的删除器

我们必须在尖括号中unique_ptr指向类型之后提供删除器类型。在创建或reset一个这种unique_ptr类型的对象时，必须提供一个指定类型的可调用对象删除器。

6、小结

1）不要使用std::auto_ptr
2）当你需要一个独占资源所有权（访问权+生命控制权）的指针，且不允许任何外界访问，请使用std::unique_ptr
3）当你需要一个共享资源所有权（访问权+生命控制权）的指针，请使用std::shared_ptr
4）当你需要一个能访问资源，但不控制其生命周期的指针，请使用std::weak_ptr

推荐用法：一个shared_ptr和n个weak_ptr搭配使用 而不是n个shared_ptr。
逻辑上，大部分模型的生命在直观上总是受某一样东西直接控制而不是多样东西共同控制。
程序上，能够完全避免生命周期互相控制引发的 循环引用问题。

下一篇：C++内存管理-详谈