Liquid XML Data Binder 2019
C++ - CSmartPtr
Liquid XML Data Binder (C++, Java, VB6) > Reference > C++ > Reference > C++ - CSmartPtr
CSmartPtr Template
Description
Base Classes:
Implemented interfaces:
  Members Description  
    CSmartPtr Constructor  
    Detach Removes the contained object from the control of the smart pointer  
    operator & Allows the smart pointer to be referenced  
    operator < determines if this pointer is greater than another  
    operator > determines if this pointer is less than another  
    operator * Allows the smart pointer to be dereferenced  
    operator T* Cast operator, automatically casts the smart pointer to the type of object T.  
    operator ! true if the pointer to an object is NULL  
    operator != false if the pointer pT is the same as the pointer held within this smart pointer  
    operator -> Allows access to the underlying object  
    operator = Copy operator  
    operator == Compares the value of the pointers.  
    Ptr A pointer to the object wrappered by this Smart pointer  
    Release Releases the underlying object.  
    _PtrClass typedef T _PtrClass;  

Class Definition

template <class T>
class CSmartPtr
{
public:
        typedef T _PtrClass;
        CSmartPtr()
        {
                p = NULL;
        }
        CSmartPtr(T* lp)
        {
                if ((p = lp) != NULL)
                        p->AddRef();
        }
        CSmartPtr(const CSmartPtr<T>& lp)
        {
                if ((p = lp.p) != NULL)
                        p->AddRef();
        }
        ~CSmartPtr()
        {
                if (p)
                        p->Release();
        }
        void Release()
        {
                if (p)
                {
                        p->Release();
                        p = NULL;
                }
        }
        operator T*()
        {
                return p;
        }
        operator const T*() const
        {
                return p;
        }
        T* operator->()
        {
                ASSERT(p!=NULL);
                return p;
        }
        const T* operator->() const
        {
                return p;
        }
        operator T*() const
        {
                return p;
        }
        T& operator*() const
        {
                ASSERT(p!=NULL);
                return *(p);
        }
        //The assert on operator& usually indicates a bug.  If this is really
        //what is needed, however, take the address of the p member explicitly.
        T** operator&()
        {
                ASSERT(p==NULL);
                return &(p);
        }
        T* operator=(T* lp)
        {
                if (lp != NULL)
                        lp->AddRef();
                if (p)
                        p->Release();
                p = lp;
                return p;
        }
        T* operator=(const CSmartPtr<T>& lp)
        {
                T* pTmp = p;
                p = lp.p;
                if (p != NULL)
                        p->AddRef();
                if (pTmp != NULL)
                        pTmp->Release();
                return p;
        }
        bool operator!() const
        {
                return (p == NULL);
        }
        bool operator<(T* pT) const
        {
                return p < pT;
        }
        bool operator==(T* pT) const
        {
                return p == pT;
        }
        bool operator!=(T* pT) const
        {
                return p != pT;
        }
        T* Ptr()
        {
                return dynamic_cast<T*>(p);
        }
        void Attach(T* p2)
        {
                if (p)
                        p->Release();
                p = p2;
        }
        T* Detach()
        {
                T* pt = p;
                p = NULL;
                return pt;
        }
protected:
        T* p;
};