详解C++各种智能指针： auto_ptr, shared_ptr, weak_ptr, scoped_ptr

C++ 中经常被问到的一个问题就是如何分辨各种智能指针。 

先归纳起来做一个综合的比较： 

转载于： http://blog.csdn.net/qingcaichongchong/article/details/7554617

auto_ptr

auto_ptr是现在标准库里面一个轻量级的智能指针的实现，存在于头文件 memory中，之所以说它是轻量级，是因为它只有一个成员变量（拥有对象的指针），相关的调用开销也非常小。auto_ptr在03标准中出现，是最早的C++标准库里的智能指针，主要是通过将指针通过对象管理，通过对象实例的生命周期来实现对被管理指针的自动释放。

先来看一下auto_ptr在源码中的一些代码：

                 

我们可以看到除了构造函数，拷贝构造函数，赋值函数，析构函数和两个重载操作符（*，->）外，还有get，release和reset三个函数，它们的作用分别是：

1. get，获得内部对象的指针
2. release，放弃内部对象的所有权，将内部指针置为空
3. reset，销毁内部对象并接受新的对象的所有权（如果使用缺省参数的话，也就是没有任何对象的所有权）
4. 
   

auto_ptr的使用很简单，通过构造函数拥有一个动态分配对象的所有权，然后就可以被当作对象指针来使用，当auto_ptr对象被销毁的时候，它也会自动销毁自己拥有所有权的对象（嗯，标准的RAAI做法），release可以用来手动放弃所有权，reset可用于手动销毁内部对象。

但实际上，auto_ptr是一个相当容易被误用并且在实际中常常被误用的类。原因是由于它的对象所有权占用的特性和它非平凡的拷贝行为。

auto_ptr 拷贝构造函数是会修改引用参数的，因此不能使用在STL中，STL容器要求拷贝构造函数中对源对象保持不变，auto_ptr会将源对象的指针拥有转移到自身，导致源对象为空（不再指向被创建的对象）

void  f()
{
     auto_ptr<T> pt1( new T );
     auto_ptr<T> pt2;

     pt2 = pt1; // now pt2 owns the pointer, and

              // pt1 does not
     pt1->DoSomething();

              // error: following a null pointer
}

auto_ptr的几点注意事项：
1、auto_ptr不能共享所有权

2、auto_ptr不能指向数组

3、auto_ptr不能作为容器的成员

4、不能通过复制操作来初始化auto_ptr

std::auto_ptr p(new int(42)); //OK

std::atuo_ptrp = new int(42);//Error

这是因为auto_ptr的构造函数被定义了explicit

5、不要把auto_ptr放入容器

shared_ptr

shared_ptr是Boost库所提供的一个智能指针的实现，正如其名字所蕴意的一样：

没错，shared_ptr就是为了解决auto_ptr在对象所有权上的局限性（auto_ptr是独占的），在使用引用计数的机制上提供了可以共享所有权的智能指针，当然这不会没有任何额外的代价……

  首先一个shared_ptr对象除了包括一个所拥有对象的指针（px）外，还必须包括一个引用计数代理对象（ shared_count）的指针（pn）。而这个引用计数代理对象包括一个真正的多态的引用计数对象（ sp_counted_base）的指针（_pi）,真正的引用计数对象在使用VC编译器的情况下包括一个虚表，一个虚表指针，和两个计数器。

Boost库里面有很多shared_ptr的使用例程，文档里面也列举了许许多多shared_ptr的用途，其中最有用也最常用的莫过于传递动态分配对象，有了引用计数机制，我们现在可以安全地将动态分配的对象包裹在shared_ptr里面跨越模块，跨越线程的边界传递。shared_ptr为我们自动管理对象的生命周期，嗯，C++也可以体会到Java里面使用引用的美妙之处了。

 

另外，还记得Effective C++里面（或者其它的C++书籍），Scott Meyer告诉你的：在一个由多个模块组成的系统里面，一个模块不用试图自己去释放另外一个模块分配的资源，而应该遵循谁分配谁释放的原则。正确的原则但是有时难免有时让人忽略（过于繁琐），将资源包装在shared_ptr里面传递，而shared_ptr保证了在资源不再被拥有的时候，产生资源的模块的delete语句会被调用。

 

shared_ptr是可以拷贝和赋值的，拷贝行为也是等价的，并且可以被比较，这意味这它可被放入标准库的一般容器（vector，list）和关联容器中（map）。

 

shared_ptr可以用来容纳多态对象，比如所下面的例子：

 

class  Base
{
}

class  Derived :  public  Base
{
}
 

shared_ptr < Base >  sp_base( new  Derived);

 

 

甚至shared_ptr也具备多态的行为：

 

Derived *  pd  =   new  Derived;
 
shared_ptr < Derived >  sp_derived(pd);
shared_ptr < Base >  sp_base2(sp_derived);

 

上面的语句是合法的，shared_ptr会完成所需的类型转换，当shared_ptr的模版参数Base的确是Derived的基类的时候。

 

 

最后是一个小小的提醒，无论是使用auto_ptr还是shared_ptr，都永远不要写这样的代码：

 

A *  pa  =   new  A;
xxx_ptr < A >  ptr_a_1(pa);
xxx_ptr < A >  ptr_a_2(pa);

 

很明显，在ptr_a_1和ptr_a_2生命周期结束的时候都会去删除pa，pa被删除了两次，这肯定会引起你程序的崩溃。

可能有人会疑问，假如使用shared_ptr,第二次引用pa的时候，计数会加一。知道ptr_a_1和ptr_a_2的生命周期全部结束时才会删除，怎么会崩溃呢。

实际上，shared_ptr的构造函数是不一样的

template  explicit shared_ptr(Y* p);

这个构造函数获得给定指针p的所有权。参数 p 必须是指向Y 的有效指针。构造后引用计数设为1。唯一从这个构造函数抛出的异常是std::bad_alloc (仅在一种很罕见的情况下发生，即不能获得引用计数器所需的自由空间)。

shared_ptr(const shared_ptr& r);

r中保存的资源被新构造的shared_ptr所共享，引用计数加一。这个构造函数不会抛出异常。

因此，直接用指针作为构造形参传入shared_ptr，计数是不会加一的，当它生命周期结束时，就会去删除指针，因此，上面的例子实际上删除了两次。

当然，这个误用的例子比较明显，但是在某种情况下，可能会一不小心就写出如下的代码（嗯，我承认我的确做过这样的事情）：

 

void  DoSomething(xxx_ptr < A > )
{

         //do something
}
 
class  A
{
         doSomething()
         {

                 xxx_ptr<A> ptr_a(this);
                 DoSomething(ptr_a);
         }
} ;
 
int  main()
{

         A a;
         a.doSomething();

         //continue do something with a, but it was already destory
}

 

在函数a.doSomething()里面发生了什么事情，它为了调用DoSomething所以不得不把自己包装成一个xxx_ptr，但是忘记在函数结束的时候，xxx ptr_a被销毁的同时也销毁了自己，程序或者立刻崩溃或者在下面的某个时间点上崩溃！

 

所以你在使用智能指针做为函数参数的时候请小心这样的误用，有时候使用智能指针作为函数参数不一定是一个好注意。比如请遵循下面的建议，请不要在属于类型A的接口的一部分的非成员函数或者跟A有紧密联系的辅助函数里面使用xxx_ptr作为函数的参数类型。

weak_ptr

weak_ptr是为配合shared_ptr而引入的一种智能指针来协助shared_ptr工作，它可以从一个shared_ptr或另一个weak_ptr对象构造，它的构造和析构不会引起引用记数的增加或减少。没有重载*和->但可以使用lock获得一个可用的shared_ptr对象

 template<class T> class weak_ptr
 {
 public:
     weak_ptr();

     template<class Y> weak_ptr(shared_ptr const & r);
     weak_ptr(weak_ptr const & r);

     ~weak_ptr();
     weak_ptr & operator=(weak_ptr const & r);

     long use_count()const;
     //判断是否过期
     bool expired()const;
     //得到一个空的或者被协助的shared_ptr
     shared_ptr lock()const;

     void reset();
     void swap(weak_ptr & b);
 };

 #include
 #include
 #include
 using namespace std;
 using namespace boost;

 int main()
 {
     shared_ptr<int> p(new int(10));
     weak_ptr<int> w(p);
     while(!w.expired()){
         cout << w.use_count() << endl;
         shared_ptr<int> t = w.lock();
         cout << *t << endl;
         cout << w.use_count() << endl;
         if(w.use_count()==2){
             break;
         }
     }
     w.reset();
     cout << w.expired() << endl;
 }

 1
 10
 2
 1

weak_ptr的一个重要用途是通过lock获得this指针的shared_ptr,使对象自己能够生产shared_ptr来管理自己，但助手类enable_shared_from_this的shared_from_this会返回this的shared_ptr，只需要让想被shared_ptr管理的类从它继承即可

 #include
 #include
 #include
 using namespace boost;
 using namespace std;

 class testWeak:public enable_shared_from_this{//
 public:
     int i;
     testWeak(int ii):i(ii){}
     void print(){
         cout << i << endl;
     }
 };

 int main()
 {
     shared_ptr sp = make_shared(100);
     shared_ptr tw = sp->shared_from_this();
     tw->print();
 }

scoped_ptr

头文件: "boost/scoped_ptr.hpp"

boost::scoped_ptr 用于确保动态分配的对象能够被正确地删除。scoped_ptr 有着与std::auto_ptr类似的特性，而最大的区别在于它不能转让所有权而auto_ptr可以。事实上，scoped_ptr永远不能被复制或被赋值！scoped_ptr 拥有它所指向的资源的所有权，并永远不会放弃这个所有权。scoped_ptr的这种特性提升了我们的代码的表现，我们可以根据需要选择最合适的智能指针(scoped_ptr 或 auto_ptr)。

要决定使用std::auto_ptr还是boost::scoped_ptr, 就要考虑转移所有权是不是你想要的智能指针的一个特性。如果不是，就用scoped_ptr. 它是一种轻量级的智能指针；使用它不会使你的程序变大或变慢。它只会让你的代码更安全，更好维护。

下面是scoped_ptr的摘要，以及其成员的简要描述：

namespace boost {

  template class scoped_ptr : noncopyable {
  public:
    explicit scoped_ptr(T* p = 0); 
    ~scoped_ptr(); 

    void reset(T* p = 0); 

    T& operator*() const; 
    T* operator->() const; 
    T* get() const; 
   
    void swap(scoped_ptr& b); 
  };

  template 
    void swap(scoped_ptr & a, scoped_ptr & b); 
}

成员函数

explicit scoped_ptr(T* p=0)

构造函数，存储p的一份拷贝。注意，p 必须是用operator new分配的，或者是null. 在构造的时候，不要求T必须是一个完整的类型。当指针p是调用某个分配函数的结果而不是直接调用new得到的时候很有用：因为这个类型不必是完整的，只需要类型T的一个前向声明就可以了。这个构造函数不会抛出异常。

~scoped_ptr()

删除被指物。类型T在被销毁时必须是一个完整的类型。如果scoped_ptr在它被析构时并没有保存资源，它就什么都不做。这个析构函数不会抛出异常。

void reset(T* p=0);

重置一个 scoped_ptr 就是删除它已保存的指针，如果它有的话，并重新保存 p. 通常，资源的生存期管理应该完全由scoped_ptr自己处理，但是在极少数时候，资源需要在scoped_ptr的析构之前释放，或者scoped_ptr要处理它原有资源之外的另外一个资源。这时，就可以用reset，但一定要尽量少用它。(过多地使用它通常表示有设计方面的问题) 这个函数不会抛出异常。

T& operator*() const;

返回一个到被保存指针指向的对象的引用。由于不允许空的引用，所以解引用一个拥有空指针的scoped_ptr将导致未定义行为。如果不能肯定所含指针是否有效，就用函数get替代解引用。这个函数不会抛出异常。

T* operator->() const;

返回保存的指针。如果保存的指针为空，则调用这个函数会导致未定义行为。如果不能肯定指针是否空的，最好使用函数get。这个函数不会抛出异常。

T* get() const;

返回保存的指针。应该小心地使用get，因为它可以直接操作裸指针。但是，get使得你可以测试保存的指针是否为空。这个函数不会抛出异常。get通常在调用那些需要裸指针的函数时使用。

operator unspecified_bool_type() const

返回scoped_ptr是否为非空。返回值的类型是未指明的，但这个类型可被用于Boolean的上下文中。在if语句中最好使用这个类型转换函数，而不要用get去测试scoped_ptr的有效性

void swap(scoped_ptr& b)

交换两个scoped_ptr的内容。这个函数不会抛出异常。

普通函数

template void swap(scoped_ptr& a,scoped_ptr& b)

这个函数提供了交换两个scoped pointer的内容的更好的方法。之所以说它更好，是因为 swap(scoped1,scoped2)可以更广泛地用于很多指针类型，包括裸指针和第三方的智能指针。scoped1.swap(scoped2) 则只能用于它的定义所在的智能指针，而不能用于裸指针。

你可为那些不够智能，没有提供它们自己的交换函数的智能指针创建你的普通swap函数。

scoped_ptr 的用法与普通的指针没什么区别；最大的差别在于你不必再记得在指针上调用 delete ，还有复制是不允许的。典型的指针操作( operator*  和  operator-> )都被重载了，并提供了和裸指针一样的语法。用 scoped_ptr 和用裸指针一样快，也没有大小上的增加，因此它们可以广泛使用。使用 boost::scoped_ptr 时，包含头文件 "boost/scoped_ptr.hpp" . 在声明一个 scoped_ptr 时，用被指物的类型来指定类模板的参数。例如，以下是一个包含 std::string 指针的 scoped_ptr ：

boost::scoped_ptr p(new std::string("Hello"));

当scoped_ptr被销毁时，它对它所拥有的指针调用delete 。

留心的读者可能已经注意到auto_ptr可以几乎象scoped_ptr一样地工作，只要把auto_ptr声明为const：

const auto_ptr no_transfer_of_ownership(new A);

它们很接近，但不是一样。最大的区别在于scoped_ptr可以被reset, 在需要时可以删除并替换被指物。而对于const auto_ptr这是不可能的。另一个小一点的区别是，它们的名字不同：尽管const auto_ptr意思上和scoped_ptr一样，但它更冗长，也更不明显。当你的词典里有了scoped_ptr，你就应该使用它，因为它可以更清楚地表明你的意图。如果你想说一个资源是要被限制在作用域里的，并且不应该有办法可以放弃它的所有权，你就应该用 boost::scoped_ptr.