通用智能指针模板类及基础对象类定义

    通过引用计数实现内存的智能管理的核心思想是通过记录指向某块已经申请的内存的地址，并记录该内存被引用的次数；该内存每被引用一次，引用计数就需要添加一，相应的每减少一次引用，引用计数就要被减一，当引用计数为零的时候就表示该内存已经不再使用，此内存可以被删除，在进行智能指针类定义的时候需要重点考虑赋值和引用等传递类的操作，因为这类操作是引发引用计数变化的关键，具体可以参见智能指针模版类定义部分详细代码。

• 基础对象类定义

   /**  
      * 基类   
      * @versiont     v 1.0.0  
      * @author       顺 哥 
      */  
    class  Object  
    {  
    private:  
        /**引用计数*/  
        volatile long m_nRefCount;  
  
    public:  
        Object();  
        virtual ~Object();  
  
    public:  
      /**  
        * 增加引用计数  
        * @versiont     v 1.0.0  
        * @author       顺 哥 
        */  
      virtual void Object::AddRef() 
     ｛ 
        InterlockedIncrement(&m_nRefCount);  
      ｝ 
      /**  
        * 减少引用计数，当引用计数为0 的时候删除自身  
        * @versiont     v 1.0.0  
        * @author       顺 哥 
        */  
      virtual void Object::Release() 
     ｛ 
 
          if( InterlockedDecrement(&m_nRefCount) == 0 )  
          { 
             delete this; 
          } 
      ｝ 
 
  
    };  

• 智能指针类定义如下

   /** 
      * 智能指针模版类声明，通过引用技术自动管理指针所指向的内 
      * @versiont     v 1.0.0 
      * @author       顺 哥
      */ 
    template<typename T> 
    class  Pointer  
    { 
    private: 
        T *m_ptrObject; 
 
    public: 
        Pointer() 
        { 
            m_ptrObject = NULL; 
        } 
        Pointer(T *t) 
        { 
            if( t!= NULL) 
            { 
                _Bind(t); 
            } 
            else 
            { 
                m_ptrObject = NULL; 
            } 
        } 
        template<typename U> 
        Pointer(U *p) 
        { 
            if(p!= NULL) 
            { 
                _Bind(p); 
            } 
        } 
 
        Pointer(const Pointer<T> &t) 
        { 
            _Bind(t.Get()); 
        } 
        template<typename U> 
        Pointer(const Pointer<U> &u) 
        { 
            _Bind(u.Get()); 
        } 
 
        ~Pointer() 
        {        
            _Unbind(); 
        } 
 
        Pointer<T> &operator=(T *t) 
        { 
            if( t!= NULL) 
            { 
                _Unbind(); 
                _Bind(t); 
            } 
            return *this; 
        } 
        template<typename U> 
        Pointer<T> &operator=(U *p) 
        { 
            if(p!=NULL) 
            { 
                _Unbind(); 
                _Bind(p); 
            } 
            return *this; 
        } 
 
        Pointer<T> & operator=(const Pointer<T> &t) 
        { 
            if(t.Get() != NULL) 
            { 
                _Unbind(); 
                _Bind(t.Get()); 
            } 
            return *this; 
        } 
        template<typename U> 
        Pointer<T> & operator=(const Pointer<U> &u) 
        { 
            if( m_ptrObject != u.Get() )  
            { 
                _Unbind(); 
                _Bind(u.Get()); 
            } 
 
            return *this; 
        } 
 
        T &operator*() 
        { 
            return *m_ptrObject; 
        } 
        T &operator*() const 
        { 
            return *m_ptrObject; 
        } 
        T *operator->() 
        { 
            return m_ptrObject; 
        } 
        T *operator->() const 
        { 
            return m_ptrObject; 
        } 
 
        T *Get() 
        { 
            return m_ptrObject; 
        } 
        T *Get() const 
        { 
            return m_ptrObject; 
        } 
 
        bool operator==(const Pointer<T> &t) const 
        { 
            return m_ptrObject == t.Get(); 
        } 
 
        bool operator!=(const Pointer<T> &t) const 
        { 
            return m_ptrObject != t.Get(); 
        } 
 
        template<typename U> 
        bool operator==(const Pointer<U> &u) const 
        { 
            return m_ptrObject == u.Get(); 
        } 
 
        template<typename U> 
        bool operator!=(const Pointer<U> &u) const 
        { 
            return m_ptrObject != u.Get(); 
        } 
 
    private: 
        void _Bind(T *p) 
        { 
            if(p!=NULL) 
            { 
                p->AddRef(); 
                m_ptrObject = p; 
            } 
            else 
            { 
                m_ptrObject = NULL; 
            } 
        } 
        template<typename U> 
        void _Bind(U *p) 
        { 
            if(p != NULL) 
            { 
                p->AddRef(); 
                m_ptrObject = reinterpret_cast<T *>(p); 
            } 
            else 
            { 
                m_ptrObject = NULL; 
            } 
 
        } 
 
        void _Unbind() 
        {        
            if(m_ptrObject != NULL) 
            { 
                m_ptrObject->Release(); 
            } 
        } 
 
    }; 

•  使用方式如下

  /**  
    * VC 属性扩展，保证类的静态成员变量在头文件中链接正常  
    * @versiont     v 1.0.0  
    * @author       顺 哥 
    */  
   __declspec(selectany) ObjectPtr nothing(new Object);  
  /** 
    * 智能指针类型宏定义  
    * @versiont     v 1.0.0  
    * @author       顺 哥 
    */  
   typedef Pointer<Object>  ObjectPtr;  
   /**  
     * 可以如此放肆的 new 而不用 自己去 delete 
     * @versiont     v 1.0.0  
     * @author       顺 哥 
     */  
    ObjectPtr = new Object();  

    在应用中通过继承Object使得子类继承 AddRef  和 Release 方法，根据需要可以在子类将此二方法重写；通过采用Pointer 对 Object或其子类进行包装可以获得对指向被包装类类型的指针所指向的内存进行自动维护的能力。