C++侵入式智能指针的实现

简介

在现代C++编程中，智能指针给我们在资源管理上带来了很多好处，这里就不多说了。

在工作中，我们常常会用智能指针来管理资源，其中最常用的就是引用计数类智能指针了（shared_ptr）。

资源共享型的智能指针有两种实现，一种是侵入式，一种是非侵入式。

在教材里比较常见的是非侵入式的，它的实现完全放在智能指针模板里，模板类有一个用于保存资源类对象的指针变量，和一个用于记录资源对象使用计数的指针变量，这两个东西是所有的智能指针对象共享的，所以通过指针保存。

而侵入式则不同，它的实现分散在智能指针模板和使用智能指针模板的类中：模板类只有一个用于保存对象的指针变量，对象的计数放在了资源类中。

非侵入式智能指针，它的引用计数变量为了保证所有对象共享，需要用堆里的内存，所以需要用new，这个都一样，不一样的是使用new的次数。
侵入式智能指针的引用计数变量保存在对象里，因为对象是唯一的，所以引用计数也是唯一的。
相比非侵入式智能指针，它的好处是：
1、一个资源对象无论被多少个侵入式智能指针包含，从始至终只有一个引用计数变量，不需要在每一个使用智能指针对象的地方都new一个计数对象，这样子效率比较高，使用内存也比较少，也比较安全；
2、因为引用计数存储在对象本身，所以在函数调用的时候可以直接传递资源对象地址，而不用担心引用计数值丢失（非侵入式智能指针对象的拷贝，必须带着智能指针模板，否则就会出现对象引用计数丢失）。

缺点是：
1、资源类必须有引用计数变量，并且该变量的增减可以被侵入式智能指针模板基类操作，这显得麻烦；
2、如果该类并不想使用智能指针，它还是会带着引用计数变量。

另外，智能指针有一个无法避免的问题，就是循环引用。

侵入式智能指针实现

两个要点：

1.将引用计数变量从资源类中抽离出来，封装成一个基类，该基类包含了引用计数变量。如果一个类想使用智能指针，则只需要继承自该基类即可；

2.引用计数的基类，设计成模板类，接受引用计数类型作为参数，比如使用int类型或者原子计数类型作为引用计数变量。默认情况下应该使用原子计数类型作为引用计数变量。

3.引用计数基类的构造函数、拷贝构造函数、析构函数应为protected，即该类只能通过继承关系被使用。

4.拷贝构造函数并不拷贝引用计数基类的数据成员，而是重新将原子计数_atomic置为0——因为每个对象都有一个自己的引用计数，当发生对象拷贝构造时，新的对象的计数应该置为0，而不应该拷贝旧对象的计数。

5.赋值操作operator=，比如A=B，同上面一样，只对资源类的成员进行拷贝，而不拷贝其引用计数基类的数据成员。也就是说，将B的值赋给A，A的引用计数应该保持不变，而不能将B的引用计数拷贝过来——这是对象的拷贝，而不是智能指针的拷贝。

首先实现引用计数基类（注：Atomic的实现这里就不给出了）：

/** *  @brief 智能指针基类. *   *  所有需要智能指针支持的类都需要从该对象继承， *   *  内部采用引用计数Atomic实现，对象可以放在容器中； */template<class  T>class HandleBaseT{public:     /** 原子计数类型*/    typedef T atomic_type;    /**     * @brief 复制。引用计数不能被复制。     *     * @return HandleBase&     */    HandleBaseT& operator=(const HandleBaseT&)    {        return *this;    }    /**     * @brief 增加计数     */    void incRef() { _atomic.inc_fast(); }    /**     * @brief 减少计数, 当计数==0时, 且需要删除数据时, 释放对象     */    void decRef()    {        if(_atomic.dec_and_test() && !_bNoDelete)        {            _bNoDelete = true;            delete this;        }    }    /**     * @brief 获取计数.     *     * @return int 计数值     */    int getRef() const        { return _atomic.get(); }    /**     * @brief 设置不自动释放.      *       * @param b 是否自动删除,true or false     */    void setNoDelete(bool b)  { _bNoDelete = b; }protected:    /**     * @brief 构造函数     */    HandleBaseT() : _atomic(0), _bNoDelete(false)    {    }    /**     * @brief 拷贝构造，_atomic和_bNoDelete不能被拷贝，只能重置     */    HandleBaseT(const HandleBaseT&) : _atomic(0), _bNoDelete(false)    {    }    /**     * @brief 析构     */    virtual ~HandleBaseT()    {    }protected:    /**     * 计数     */    atomic_type   _atomic;    /**     * 是否自动删除     */    bool        _bNoDelete;};// 针对int类型计数变量的特化// 在类声明中定义的函数将自动inline，类外定义的函数需显式inlinetemplate<>inline void HandleBaseT<int>::incRef() {     ++_atomic; }template<> inline void HandleBaseT<int>::decRef(){    if(--_atomic == 0 && !_bNoDelete)    {        _bNoDelete = true;        delete this;    }}template<> inline int HandleBaseT<int>::getRef() const        {     return _atomic; } // 默认使用Atomic作为引用计数类型typedef HandleBaseT<Atomic> HandleBase;

以上实现了计数基类，所有需要使用智能指针的对象必须继承自该类。

智能指针模板类的实现需要关注的几个点：

1.初始化、赋值等操作需要考虑参数是原始指针、其他类型的智能指针初、用同一类型的智能指针三种情况。
2.需要重载<、=、!=几个操作（非成员函数），左右操作数使用两个模板参数。
3.赋值操作需要检查自我赋值。

/*** @brief 空指针异常*/struct Shared_PtrNull_Exception : public Exception{    Shared_PtrNull_Exception(const string &buffer) : Exception(buffer){};    ~Shared_PtrNull_Exception() throw(){};};/** * @brief 智能指针模板类.  *   * 可以放在容器中,且线程安全的智能指针.  *   * 通过它定义智能指针，该智能指针通过引用计数实现，  *   * 可以放在容器中传递.  *   * template<typename T> T必须继承于HandleBase  */template<typename T>class Shared_Ptr{public:    /**     * 元素类型     */    typedef T element_type;    /**     * @brief 用原生指针初始化, 计数+1.      *       * @param p     */    Shared_Ptr(T* p = 0)    {        _ptr = p;        if(_ptr)        {            _ptr->incRef();        }    }    /**     * @brief 用其他智能指针r的原生指针初始化, 计数+1.      *       * @param Y     * @param r     */    template<typename Y>    Shared_Ptr(const Shared_Ptr<Y>& r)    {        _ptr = r._ptr;        if(_ptr)        {            _ptr->incRef();        }    }    /**     * @brief 拷贝构造, 计数+1.      *       * @param r     */    Shared_Ptr(const Shared_Ptr& r)    {        _ptr = r._ptr;        if(_ptr)        {            _ptr->incRef();        }    }    /**     * @brief 析构     */    ~Shared_Ptr()    {        if(_ptr)        {            _ptr->decRef();        }    }    /**     * @brief 赋值, 普通指针.      *       * @param p      * @return Shared_Ptr&     */    Shared_Ptr& operator=(T* p)    {        if(_ptr != p)        {            if(p)            {                p->incRef();            }            T* ptr = _ptr;            _ptr = p;            if(ptr)            {                ptr->decRef();            }        }        return *this;    }    /**     * @brief 赋值, 其他类型智能指针.      *       * @param Y     * @param r      * @return Shared_Ptr&     */    template<typename Y>    Shared_Ptr& operator=(const Shared_Ptr<Y>& r)    {        if(_ptr != r._ptr)        {            if(r._ptr)            {                r._ptr->incRef();            }            T* ptr = _ptr;            _ptr = r._ptr;            if(ptr)            {                ptr->decRef();            }        }        return *this;    }    /**     * @brief 赋值, 该类型其他执政指针.      *       * @param r      * @return Shared_Ptr&     */    Shared_Ptr& operator=(const Shared_Ptr& r)    {        if(_ptr != r._ptr)        {            if(r._ptr)            {                r._ptr->incRef();            }            T* ptr = _ptr;            _ptr = r._ptr;            if(ptr)            {                ptr->decRef();            }        }        return *this;    }    /**     * @brief 将其他类型的智能指针换成当前类型的智能指针.      *       * @param Y     * @param r      * @return Shared_Ptr     */    template<class Y>    static Shared_Ptr dynamicCast(const Shared_Ptr<Y>& r)    {        return Shared_Ptr(dynamic_cast<T*>(r._ptr));    }    /**     * @brief 将其他原生类型的指针转换成当前类型的智能指针.      *       * @param Y     * @param p      * @return Shared_Ptr     */    template<class Y>    static Shared_Ptr dynamicCast(Y* p)    {        return Shared_Ptr(dynamic_cast<T*>(p));    }    /**     * @brief 获取原生指针.     *     * @return T*     */    T* get() const    {        return _ptr;    }    /**     * @brief 调用.     *     * @return T*     */    T* operator->() const    {        if(!_ptr)        {            throwNullHandleException();        }        return _ptr;    }    /**     * @brief 引用.     *     * @return T&     */    T& operator*() const    {        if(!_ptr)        {            throwNullHandleException();        }        return *_ptr;    }    /**     * @brief 是否有效.     *     * @return bool     */    operator bool() const    {        return _ptr ? true : false;    }    /**     * @brief  交换指针.      *       * @param other     */    void swap(Shared_Ptr& other)    {        std::swap(_ptr, other._ptr);    }protected:    /**     * @brief 抛出异常     */    void throwNullHandleException() const;public:    T*          _ptr;};/** * @brief 抛出异常.  *   * @param T * @param file * @param line */template<typename T> inline voidShared_Ptr<T>::throwNullHandleException() const{    throw Shared_PtrNull_Exception("shared_ptr null handle error");}/** * @brief ==判断.  *   * @param T * @param U * @param lhs * @param rhs * * @return bool */template<typename T, typename U>inline bool operator==(const Shared_Ptr<T>& lhs, const Shared_Ptr<U>& rhs){    T* l = lhs.get();    U* r = rhs.get();    if(l && r)    {        return *l == *r;    }    else    {        return !l && !r;    }}/** * @brief 不等于判断.  *   * @param T * @param U * @param lhs * @param rhs * * @return bool */template<typename T, typename U>inline bool operator!=(const Shared_Ptr<T>& lhs, const Shared_Ptr<U>& rhs){    T* l = lhs.get();    U* r = rhs.get();    if(l && r)    {        return *l != *r;    }    else    {        return l || r;    }}/** * @brief 小于判断, 用于放在map等容器中.  *   * @param T * @param U * @param lhs * @param rhs * * @return bool */template<typename T, typename U>inline bool operator<(const Shared_Ptr<T>& lhs, const Shared_Ptr<U>& rhs){    T* l = lhs.get();    U* r = rhs.get();    if(l && r)    {        return *l < *r;    }    else    {        return !l && r;    }}

使用示例

class Test: public HandleBase{    // ...};Shared_Ptr<Test> myTestClass = new Test();