智能指针

什么是智能指针

智能指针(smart pointer)的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。
提到智能指针就会想到RAII，但是要明白，智能指针并不等同于RAII，智能指针只是RAII的一种应用。而RAII则是一种规范。
是一种用来解决问题的思想，定义类来封装资源并进行分配和释放，构造函数完成资源的分配和初始化，析构函数完成资源的清理 智能指针不是指针，是一个类，可以实现：智能管理指针的释放，能够想一个指针一样使用，完成正常的复制拷贝。

早期的智能指针是auto_ptr，下面来模拟实现它。

template <class T>class AutoPtr{public:    T * _ptr;public:    AutoPtr(T* ptr)//构造函数        :_ptr(ptr)    {        cout<<"构造函数"<<endl;    }    AutoPtr(AutoPtr<T>&ap)//拷贝构造函数        :_ptr(ap._ptr)    {        cout<<"拷贝构造函数"<<endl;        ap._ptr = NULL;    }    ~AutoPtr()//析构函数    {        cout<<"析构函数"<<endl;        delete[]_ptr;    }    AutoPtr<T> & operator = (AutoPtr<T>&ap)//赋值运算符的重载    {        if(this!=&ap)        {            delete _ptr;//赋值前先释放它            _ptr = ap._ptr;            ap._ptr = NULL;//转移管理权        }        cout<<"赋值运算符的重载"<<endl;        return *this;    }    T &operator *()//*的重载    {        return *_ptr;    }    T *operator ->()//->的重载    {        return _ptr;    }};void test(){    AutoPtr<int> p1(new int (4));    AutoPtr<int> p2(new int);    p2 = p1;    }int main (){    test();    return 0;}

但是这个智能指针的设计是失败的，他是存在缺陷的。因为会有管理权的转移。也就是说只要我一赋值，或者拷贝构造就会出现管理权转移的情况。
所以我们又有了另一种智能指针，scoped_ptr，他的实现原理就是简单粗暴的，既然你会有拷贝和赋值的问题，那我就不让怒拷贝，也不让你赋值。下面我们来模拟实现一下它。

模拟实现scoped_ptr

template <class T>class ScopedPtr{protected:    T * _ptr;public:    ScopedPtr(T *ptr)//构造函数        :_ptr(ptr)    {        cout<<"构造函数"<<endl;    }    ~ScopedPtr()//析构函数    {        cout<<"析构函数"<<endl;        delete[]_ptr;    }    T &operator *()//*的重载    {        return *_ptr;    }    T *operator ->()//->的重载    {        return _ptr;    }private:    ScopedPtr(const ScopedPtr<T>&sp);//只声明，不定义    ScopedPtr<T> &operator = (const ScopedPtr<T>&);};struct A{    int _a;    int _b;};void test(){    ScopedPtr<int> sp1(new int(4));    //ScopedPtr<int> sp2(p1);//在这里是无法调用拷贝构造函数的，因为他并没有定义，而且还是一个私有的函数，这样又可以保证即使在类外也不会被修改。    ScopedPtr<A> sp2(new A);    sp2->_a = 10;    sp2->_b = 20;}int main(){    test();    return 0;}

显然scoped_ptr虽然解决了管理权转移的问题，但是，在实际应用中难免会用到拷贝构造函数，和赋值运算符的重载。所以，为了解决这个问题，我们又出现了一个更加强大的智能指针，shared_ptr.
shared_ptr 是用了共享引用计数的原理，它支持赋值运算符的重载，拷贝构造。下面我们来模拟实现一下它。

模拟实现shared_ptr

template<class T>//实现仿函数struct Delete//删除的是new出来的对象{    void operator ()(T* ptr)    {        delete ptr;    }};template<class T>//实现仿函数struct DeleteArray//删除数组{    void operator ()(T* ptr)    {        delete [] ptr;    }};template<class T,class D = Delete<T>>//传一个缺省的参数class SharedPtr{protected:    T * _ptr;    int * _countRef;    D _del;//定制一个删除器public:    SharedPtr(T * ptr)//构造函数        :_ptr(ptr)        ,_countRef(new int (1))    {        cout<<"构造函数"<<endl;    }    SharedPtr<T,D>(const SharedPtr<T,D>&sp)//拷贝构造函数        :_ptr(sp._ptr)        ,_countRef(sp._countRef)    {        cout<<"拷贝构造函数"<<endl;        ++(*_countRef);//既然调用了拷贝构造函数，肯定是拷贝构造了一个对象，所以直接引用计数加1    }    ~SharedPtr()//析构函数    {        cout<<"析构函数"<<endl;        Release();    }    SharedPtr<T,D>&operator = (SharedPtr<T,D> & sp)    {        if (_ptr != sp._ptr)//判断是否自己给自己赋值或者是指向同一块空间里的对象见得赋值。        {            Release();            _ptr = sp._ptr;            _countRef = sp._countRef;            ++(*_countRef);//进行了赋值后就指向了这个对象，所以当前对象的引用计数加1        }        return *this;    }    T &operator *()    {        return *_ptr    }    T *operator ->()    {        return _ptr;    }   private:    void Release()    {        if(--(_countRef)==0)//当引用计数的值为0时就说明已经没有对象在用这个空间了，就可以释放掉了。        {            cout<<_ptr<<endl;//这里主要是为了看一下是否调到了这个函数，，把它的地址打印一下。            _del(_ptr);//这里就用到了定制的删除器            delete _countRef;        }    }};void test(){    SharedPtr<int> sp1(new int(2) );    //这里构造了一个对象会调用一次构造函数    SharedPtr<int> sp2(sp1);    //sp2对象是用sp1对象拷贝构造出来的所以这里调用了一次拷贝构造函数    SharedPtr<int> sp3(new int(4));    SharedPtr<int> sp4(new int(5));    sp1 = sp4;    sp2 = sp3;    SharedPtr<string> sp5(new string);    SharedPtr<string,DeleteArray<string>> sp6(new string[10]); //这个主要是为了看是否解决了深浅拷贝的问题。因为string类有深浅拷贝的情况}int main(){    test();    return 0;}

从上面带代码中我们可以看到，这个职能制针可以实现拷贝构造，复制运算符的重载。而且不会有管理权转移或者说不能拷贝之类的情况。下面看一下它的运行结果。

这样的代码看起来是挺好的，但是他也有一个很严重的缺陷，那就是不能循环引用，如果循环引用的话就会出现内存泄露的问题了。为了解决这个问题我们又相应有了一个weak_ptr 智能指针，他就是专门来解决shared_ptr 中的循环引用的问题的，它不会增加引用计数。但是这个指针只能在shared_ptr中使用。

存在循环引用的shared_ptr

 #include <iostream> #include <boost/shared_ptr.hpp>  //这里用到了boost库，可以自己下载一下源代码 #include <boost/weak_ptr.hpp> using namespace std;      class parent;   class children;   typedef boost::shared_ptr<parent> parent_ptr;   typedef boost::shared_ptr<children> children_ptr;     class parent  {   public:       ~parent(){      std::cout <<"destroying parent\n"; }    public:       children_ptr children;   };   class children   {   public:       ~children() { std::cout <<"destroying children\n"; }   public:       parent_ptr parent;   };   void test()   {      parent_ptr father(new parent());       children_ptr son(new children);       father->children = son;       son->parent = father;   }   void main()   {       std::cout<<"begin test...\n";      test();       std::cout<<"end test.\n";  }  

运行该程序可以看到：即使退出了test函数后，由于parent和children对象互相引用，它们的引用计数都是1，不能自动释放，并且此时这两个对象再无法访问到
<1>一般来讲，解除这种循环引用有下面有三种可行的方法：
1. 当只剩下最后一个引用的时候需要手动打破循环引用释放对象。
2. 当parent的生存期超过children的生存期的时候，children改为使用一个普通指针指向parent。
3. 使用弱引用的智能指针打破这种循环引用。
虽然这三种方法都可行，但方法1和方法2都需要程序员手动控制，麻烦且容易出错。
下面主要介绍一下第三种方法和boost中的弱引用的智能指针boost::weak_ptr。
<2>什么是强引用和弱引用？
一个强引用是指当被引用的对象仍活着的话，这个引用也存在（也就是说，只要至少有一个强引用，那么这个对象就不会也不能被释放）。boost::share_ptr就是强引用。
相对而言，弱引用当引用的对象活着的时候不一定存在。仅仅是当它自身存在的时的一个引用。
弱引用并不修改该对象的引用计数，这意味这弱引用它并不对对象的内存进行管理。

在功能上类似于普通指针，然而一个比较大的区别是，弱引用能检测到所管理的对象是否已经被释放，从而避免访问非法内存。
boost::weak_ptr boost::weak_ptr 是boost提供的一个弱引用的智能指针，它的声明可以简化如下：

weak_ptr

 template<typename T>  class weak_ptr   {   public:     template <typename Y>     weak_ptr(const shared_ptr<Y>& r);     weak_ptr(const weak_ptr& r);           ~weak_ptr();         T* get() const;        bool expired() const;       shared_ptr<T> lock() const;   };     

可以看到，boost::weak_ptr必须从一个boost::share_ptr或另一个boost::weak_ptr转换而来，这也说明，进行该对象的内存管理的是那个强引用的boost::share_ptr。
boost::weak_ptr只是提供了对管理对象的一个访问手段。
boost::weak_ptr除了对所管理对象的基本访问功能（通过get()函数）外，还有两个常用的功能函数：
1. expired() 用于检测所管理的对象是否已经释放；
2. lock() 用于获取所管理的对象的强引用指针。
通过boost::weak_ptr来打破循环引用
由于弱引用不更改引用计数，类似普通指针，只要把循环引用的一方使用弱引用，即可解除循环引用。
对于上面的那个例子来说，只要把children的定义改为如下方式，即可解除循环引用：

解决循环引用的问题

class children   {      public:       ~children()    {     std::cout <<"destroying children\n";    }        public:     boost::weak_ptr<parent> parent;//这里改变为弱指针就好了。  };  

虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在程序员能预见会出现循环引用的情况下才能使用，也可以是说这个仅仅是一种编译期的解决方案。如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的。因此，不要认为只要使用了智能指针便能杜绝内存泄漏。我们在写代码的时候尽量避免循环引用。