通用智能指針模板類及基礎對象類定義

    通過引用計數實現內存的智能管理的核心思想是通過記錄指向某塊已經申請的內存的地址，並記錄該內存被引用的次數；該內存每被引用一次，引用計數就需要添加一，相應的每減少一次引用，引用計數就要被減一，當引用計數爲零的時候就表示該內存已經不再使用，此內存可以被刪除，在進行智能指針類定義的時候需要重點考慮賦值和引用等傳遞類的操作，因爲這類操作是引發引用計數變化的關鍵，具體可以參見智能指針模版類定義部分詳細代碼。

• 基礎對象類定義

   /**
      * 基類
      * @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或其子類進行包裝可以獲得對指向被包裝類類型的指針所指向的內存進行自動維護的能力。