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;
};