智能指针

智能指针

#include  < iostream >
using   namespace  std;


template  < class  T >

class  RefObject
{
public:
    explicit RefObject(T* obj) : m_object(obj),  m_ref_number(1) { }

    ~RefObject()
    {
        DecreaseReference();
    }

    void IncreaseReference()
    {
        m_ref_number++;
    }

    void DecreaseReference()
    {
        if(--m_ref_number == 0)
        {
            Destroy();
        }
    }

    T* getPtr()
    {
        return m_object;
    }

     const unsigned int  getReferenceNum()
    {
        return m_ref_number;
    }
/**///////////////
private:
    void Destroy()
    {
        delete m_object;
        m_object = NULL;
        m_ref_number = 0;
        delete this;
    }

    // Do need to implment those two function, but need declear them 
    // here to avoid compiler generate them automatically.
    RefObject(const RefObject& obj);
    RefObject<T>& operator=(const RefObject& obj);



private:
    T* m_object;
    unsigned int m_ref_number;
} ;


/**/ /////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////


template  < class  T >

class  SmartPointer
{
public:
    // Constructor without param
    SmartPointer() : m_pRefObject(NULL) { }

    // Constructor with param, Do set as "explicit" to 
    // avoid type chansferred automatically.
    explicit SmartPointer(T* T_ptr)
    {
        m_pRefObject = new RefObject<T>(T_ptr);
    }

    // In this function, we just need to decrease the reference number
    ~SmartPointer()
    {
        if(m_pRefObject)
        {
            m_pRefObject->DecreaseReference();
        }
    }

    // In copying constructor function, we need to increase the number of reference
    SmartPointer(const SmartPointer& rhs) : m_pRefObject(rhs)
    {
        m_pRefObject->IncreaseReference();
    }

    // Overload operator =
    const SmartPointer<T>& operator=(const SmartPointer& other)
    {
        // We much check if other is this self 
        if(m_pRefObject == other.m_pRefObject)
        {
            return *this;
        }
        else
        {
            m_pRefObject = other.m_pRefObject;
            m_pRefObject->IncreaseReference();
            return *this;
        }
    }

    // Overload operator*
    T& operator*()
    {
        return *(m_pRefObject->getPtr());
    }
  
    // Overload operator*, so    "SmartPointer->"    is same as     "T->"    now.
    T* operator->()
    {
         return m_pRefObject->getPtr();
    }


protected:
    RefObject<T>*  m_pRefObject;
} ;


void  main()
{
    int *ptr1, *ptr2, *ptr3;
    
    {
    ptr1 = new int(99);

    // If comment following code, the cout outside of this block will be not mess.
    SmartPointer<int> sp1(ptr1);
    cout<<"The value of smart pointer is:     "<<*sp1<<endl;
    }

    cout<<"The value of smart pointer is:     "<<*ptr1<<endl;
}