AutoPointer

 

template<class T>
struct AutoPointerRef
{
    explicit AutoPointerRef(T* p_pRef):m_pRef(p_pRef){}
    ~AutoPointerRef(){}
    T* m_pRef;
};

template<typename T>
class AutoPointer
{
public:

    typedef T ElementType;

    explicit AutoPointer(T* p_pPtr = NULL):m_pPtr(p_pPtr){}

    AutoPointer(AutoPointer& rhs):m_pPtr(rhs->Release){}

    template<typename U> AutoPointer(AutoPointer<U>& rhs):m_pPtr(rhs->Release){}

    AutoPointer(const AutoPointerRef<T>& rhs):m_pPtr(rhs.m_pRef){}

    AutoPointer& operator=(AutoPointer& rhs)
    { 
        Reset(rhs->Release); 
        return (*this);
    }

    template<typename U> AutoPointer& operator=(AutoPointer<U>& rhs)
    {
        Reset(rhs->Release); 
        return (*this);
    }

    AutoPointer& operator=(const AutoPointerRef<T>& rhs)
    {
        Reset(rhs.m_pRef); 
        return (*this);
    }

    ~AutoPointer()
    {
        delete m_pPtr;
    }

    template<typename U> operator AutoPointer<U>()
    {
        return AutoPointer<U>(*this);
    }

    template<class U> operator AutoPointerRef<U>()
    {
        AutoPointerRef<U> aprTemp(m_pPtr);
        m_pPtr = NULL;
        return aprTemp;
    }

    T& operator*() const
    {
        return (*m_pPtr);
    }

    T* operator->() const
    {
        return m_pPtr;
    }

    T* Get() const
    {
        return m_pPtr;
    }

private:

    T* Release()
    {
        T* pTemp = m_pPtr;
        m_pPtr = NULL;
        return pTemp;
    }

    void Reset(T* p_pPtr = NULL)
    {
        if (m_pPtr != p_pPtr)
        {
            delete m_pPtr;
        }
        m_pPtr = p_pPtr;
    }

    T* m_pPtr;
};