智能指针剖析（下）boost::shared_ptr&其他

1. boost::shared_ptr

前面我已经讲解了两个比较简单的智能指针，它们都有各自的优缺点。由于 boost::scoped_ptr 独享所有权，当我们真真需要复制智能指针时，需求便满足不了了，如此我们再引入一个智能指针，专门用于处理复制，参数传递的情况，这便是如下的boost::shared_ptr。

boost::shared_ptr 也属于 boost 库，定义在 namespace boost 中，包含头文件#include<boost/smart_ptr.hpp> 便可以使用。在上面我们看到 boost::scoped_ptr 独享所有权，不允许赋值、拷贝，boost::shared_ptr 是专门用于共享所有权的，由于要共享所有权，其在内部使用了引用计数。boost::shared_ptr 也是用于管理单个堆内存对象的。

这是比较完善的一个智能指针，他是通过指针保持某个对象的共享拥有权的智能指针。若干个shared_ptr对象可以拥有同一个对象，该对象通过维护一个引用计数，记录有多少个shared_ptr指针指向该对象，最后一个指向该对象的shared_ptr被销毁或重置时，即引用计数变为0时，该对象被销毁。销毁对象时使用的是delete表达式或是在构造shared_ptr时传入的自定义删除器（delete），这后面会有详细讲解，但是shared_ptr指针同样拥有缺陷，那就是循环引用，和线程安全问题，这也在后面讲解。先来模拟实现一下shared_ptr指针。

 template <class T>
 class SharedPtr
 {
 public:
     SharedPtr(T* ptr = NULL)
         :_ptr(ptr)
         ,_count(new int()){
         if (_ptr != NULL) {
             ++(*_count);
         }
     }
     SharedPtr(const SharedPtr<T>& sp)
         :_ptr(sp._ptr)
         ,_count(sp._count){
         if (_ptr != NULL) {
             ++(*_count);
         }
     }
     SharedPtr<T>& operator=(const SharedPtr<T>& sp) {
         if (this != &sp) { //排除对象本身自己给自己赋值
             if (--(*_count) <= ) {
                 delete[]_ptr;
                 delete[]_count;
             }
             else //指向同一个对象的指针互相赋值
             { }
             _ptr = sp._ptr;
             _count = sp._count;
             *(_count)++;
         }
         return *this;
     }
     ~SharedPtr() {
         if (--(*count) == ) {
             delete[] _ptr;
             delete[] _count;
         }
     }
     T& operator*(){
         return *_ptr;
     }
     T* operator->() {
         return _ptr;
     }
     bool operator ==(const SharedPtr<T>& sp) {
         return (_ptr == sp._ptr);
     }
     bool operator !=(const SharedPtr<T>& sp) {
         return (_ptr != sp._ptr);
     }

51      int UseCount() {
  52         return *_count;
  53     }

 private:
     T* _ptr;
     int* _count;
 };

1.1 问题1：线程安全

因为使用引用计数值位判定指标，所以在多线程的环境下是不安全的。会因线程调用的先后顺序不同导致错误产生。对于这种问题，解决方法一般是加锁，对引用计数进行加锁，保证操作是互斥的。

1.2 问题2：循环引用

针对循环引用，从实际的例子来大分析问题，以便能更好的理解。看下面代码：

 struct ListNode
 {
     int _data;
     SharedPtr<ListNode> _next;
     SharedPtr<ListNode> _prev;

     ListNode(int x)
         :_data(x), _next(NULL), _prev(NULL)
     {}
     ~ListNode()
     {
         cout << "~ListNode()" << endl;
     }
 };

 void test()
 {
     SharedPtr<ListNode> A(new ListNode());
     SharedPtr<ListNode> B(new ListNode());

     if (A && B) {
         A->_next = B;
         B->_prev = A;
     }

     cout << "A._count:" << A.UseCount() << endl;
     cout << "B._count:" << B.UseCount() << endl;
 }

 int main()
 {
     test();
     getchar();
     return ;
 }

输出结果：

从结果可以看出两个节点的引用计数都是2，且一直没有调用析构函数，这将造成内存泄漏，下面我将图解原理：

而要解决循环引用的问题，就需要用boost库的另一个智能指针，即boost::weak_ptr。后面在详细讲解。

1.3 定制删除器（仿函数）

经上面分析，我们可以看到，上面的指针不能用于文件的关闭，也不能用于管理malloc和new[]开辟的动态内存的释放，所以我们可以运用仿函数来定制删除器。如下：

 template<class T>
 struct DeleteArray  //用于new[]开辟的动态内存释放
 {
     void operator()(T* ptr)
     {
         cout << "A" << endl;
         delete[] ptr;
     }
 };
 struct Fclose  //用于文件关闭
 {
     void operator()(FILE* ptr)
     {
         cout << "B" << endl;

         fclose(ptr);
     }
 };
 template<class T>
 struct Free     //用于malloc开辟的动态内存的释放
 {
     void operator()(T* ptr)
     {
         cout << "C" << endl;
         free(ptr);
     }
 };
 int main（）
 {
     shared_ptr<string> ap1(new string[], DeleteArray<string>());
     shared_ptr<FILE> ap2(fopen("test.txt", "w"),Fclose());
     shared_ptr<int> ap3((int*)malloc(sizeof(int)), Free<int>());
     return ；
 }

2. boost::weak_ptr

boost::weak_ptr 属于 boost 库，定义在 namespace boost 中，包含头文件#include<boost/smart_ptr.hpp> 便可以使用。

在讲 boost::weak_ptr 之前，让我们先回顾一下前面讲解的内容。似乎boost::scoped_ptr、boost::shared_ptr 这两个智能指针就可以解决所有单个对象内存的管理了，这儿还多出一个 boost::weak_ptr，是否还有某些情况我们没纳入考虑呢？答案是有。首先 boost::weak_ptr 是专门为 boost::shared_ptr 而准备的。有时候，我们只关心能否使用对象，并不关心内部的引用计数。boost::weak_ptr 是 boost::shared_ptr 的观察者（Observer）对象，观察者意味着 boost::weak_ptr 只对 boost::shared_ptr 进行引用，而不改变其引用计数，当被观察的 boost::shared_ptr 失效后，相应的 boost::weak_ptr 也相应失效。weak_ptr其实是一个辅助性的智能指针，结合shared_ptr指针使用，它的本质就是弱引用，并不增加引用计数值。他没有实现->和*运算符的重载，所以不能直接用它访问对象。针对循环引用这个问题，就是因为不会引起引用计数值的改变，所以我们可以将_next和_prev定义为weak_ptr指针，这样就很好地解决了循环引用的问题。

 struct ListNode
 {
     int _data;
     weak_ptr<ListNode> _next;  //定义为weak_ptr指针
     weak_ptr<ListNode> _prev;

     ListNode(int x)
         :_data(x), _next(NULL), _prev(NULL)
     {}
     ~ListNode()
     {
         cout << "~ListNode()" << endl;
     }
 };

其实 boost::weak_ptr 主要用在软件架构设计中，可以在基类（此处的基类并非抽象基类，而是指继承于抽象基类的虚基类）中定义一个 boost::weak_ptr，用于指向子类的boost::shared_ptr，这样基类仅仅观察自己的 boost::weak_ptr 是否为空就知道子类有没对自己赋值了，而不用影响子类 boost::shared_ptr 的引用计数，用以降低复杂度，更好的管理对象。

boost库剩余的两个指针：auto_arr和shared_arr.这两个都是管理数组的，因为之前几个指针的析构函数中都是delete，不能对数组进行释放，所以我们自己定制删除器，而这两个指针就是专门管理指针的。下面也来模拟实现一下。

3. 模拟实现auto_arr

 template<class T>
 class AutoArr
 {
 public:
     AutoArr(T* ptr = NULL)
         :_ptr(ptr)
     {}

     ~AutoArr()
     {
         delete[] _ptr;
     }

     AutoArr(const AutoArr<T>& s)
     {
         _ptr = s._ptr;
         s._ptr = NULL;
     }

     AutoArr<T>& operator=(const AutoArr<T>& s)
     {
         if (this != &s)
         {
             _ptr = s._ptr;
             s._ptr = NULL;
         }
         return *this;
     }

     T& operator[](size_t pos)
     {
         if (_ptr == NULL)
         {
             throw a;
         }
             return *(_ptr+pos);
     }

     void set(T* ptr)
     {
         int i = ;
         while (*(ptr + i))
         {
             *(_ptr + i) = *(ptr + i);
             i++;
         }
     }

 protected:
     T* ptr;
 };

4. 模拟实现shared_arr

 template<class T>

 class SharedArr
 {
 public:
     SharedArr(T* ptr = NULL)
         :_ptr(ptr),_count(new int())
     {
         (*_count)++;
     }

     ~SharedArr()
     {
         delete[] _ptr;
     }

     SharedArr(const SharedArr<T>& s)
     {
         _ptr = s._ptr;
         (*_count)++;
     }

     SharedArr<T>& operator=(const SharedArr<T>& s)
     {
         if (this != &s)
         {
             if (--(*_count) <= )
             {
                 delete _ptr;
                 delete _count;
             }
             else
             { }
             _ptr = s._ptr;
             _count = s._count;
             (*_count)++;
         }
     }

     T& operator[](size_t pos)
     {
         if (_ptr == NULL)
         {
             throw ;
         }
         return *(_ptr + pos);
     }

 protected:
     T* _ptr;
     int* _count;
 };

5. 如何选择智能指针？

在掌握了这几种智能指针后，大家可能会想另一个问题：在实际应用中，应使用哪种智能指针呢？下面给出几个使用指南。

（1）如果程序要使用多个指向同一个对象的指针，应选择shared_ptr。这样的情况包括：

• 有一个指针数组，并使用一些辅助指针来标示特定的元素，如最大的元素和最小的元素；
• 两个对象都包含指向第三个对象的指针；
• STL容器包含指针。很多STL算法都支持复制和赋值操作，这些操作可用于shared_ptr，但不能用于unique_ptr（编译器发出warning）和auto_ptr（行为不确定）。如果你的编译器没有提供shared_ptr，可使用Boost库提供的shared_ptr。

（2）如果程序不需要多个指向同一个对象的指针，则可使用unique_ptr。如果函数使用new分配内存，并返还指向该内存的指针，将其返回类型声明为unique_ptr是不错的选择。这样，所有权转让给接受返回值的unique_ptr，而该智能指针将负责调用delete。可将unique_ptr存储到STL容器在那个，只要不调用将一个unique_ptr复制或赋给另一个算法（如sort()）。例如，可在程序中使用类似于下面的代码段。

 unique_ptr<int> make_int(int n)
 {
     return unique_ptr<int>(new int(n));
 }
 void show(unique_ptr<int> &p1)
 {
     cout << *a << ' ';
 }
 int main()
 {
     ...
     vector<unique_ptr<int> > vp(size);
     for(int i = ; i < vp.size(); i++)
         vp[i] = make_int(rand() % );              // copy temporary unique_ptr
     vp.push_back(make_int(rand() % ));     // ok because arg is temporary
     for_each(vp.begin(), vp.end(), show);           // use for_each()
     ...
 }

其中push_back调用没有问题，因为它返回一个临时unique_ptr，该unique_ptr被赋给vp中的一个unique_ptr。另外，如果按值而不是按引用给show()传递对象，for_each()将非法，因为这将导致使用一个来自vp的非临时unique_ptr初始化pi，而这是不允许的。前面说过，编译器将发现错误使用unique_ptr的企图。

在unique_ptr为右值时，可将其赋给shared_ptr，这与将一个unique_ptr赋给一个需要满足的条件相同。与前面一样，在下面的代码中，make_int()的返回类型为unique_ptr<int>：

 unique_ptr<int> pup(make_int(rand() % ));   // ok
 shared_ptr<int> spp(pup);                       // not allowed, pup as lvalue
 shared_ptr<int> spr(make_int(rand() % ));   // ok

模板shared_ptr包含一个显式构造函数，可用于将右值unique_ptr转换为shared_ptr。shared_ptr将接管原来归unique_ptr所有的对象。

在满足unique_ptr要求的条件时，也可使用auto_ptr，但unique_ptr是更好的选择。如果你的编译器没有unique_ptr，可考虑使用Boost库提供的scoped_ptr，它与unique_ptr类似。