---

SmartPtr.h

Go to the documentation of this file.

#ifndef __SMART_PTR_H__
#define __SMART_PTR_H__

#include "Debug.h"

template<class T> class SmartPtr
{
        struct DATAREF {
                T* pData;
                int nLinks;
                DATAREF() { nLinks = 1; }
        };

        DATAREF* ptr;

public:
        
        SmartPtr() { 
                ptr = new DATAREF;
                ptr->pData = NULL;
        }

        SmartPtr(T* p) { 
                ptr = new DATAREF; 
                ptr->pData = p; 
        }

        SmartPtr(const T* p) {
                ptr = new DATAREF;
                ptr->pData = (T*)p; //Supposely it's safe to discard 'const' here

                // There is someone else ponting at this object, so add one ref
                // s.t. we don't destroy the actual data in the destructor.
                ptr->nLinks++;
        }
        
        SmartPtr(const T& obj) {
                ptr = new DATAREF;
                ptr->pData = new T;
                *ptr->pData = obj; // Clone object
        }

        SmartPtr(const SmartPtr<T>& x)  { 
                x.ptr->nLinks++;
                ptr = x.ptr;
        }

        ~SmartPtr() { 
                if (--ptr->nLinks == 0) {
                        if (ptr->pData)
                                delete ptr->pData;
                        delete ptr;
                } 
        }       

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

        bool operator==(const SmartPtr<T>& rhs) const
        {
                return ptr->pData == rhs.ptr->pData;
        }

        bool IsNull() const
        {
                return ptr->pData == NULL;
        }

        T* operator->() {
                if (ptr->nLinks > 1) {
                        ptr->nLinks--;
                        T* p = ptr->pData->CreateObject();
                        *p = *ptr->pData;

                        ptr = new DATAREF;
                        ptr->pData = p;
                        
                        WARNING(true, "possible not desired copy of data");
                }

                return ptr->pData; 
        }

        SmartPtr<T>& operator=(const SmartPtr<T>& rhs) {
                rhs.ptr->nLinks++;      // protect against 'x = x'
                
                if (--ptr->nLinks == 0) {
                        delete ptr->pData;
                        delete ptr;
                }

                ptr = rhs.ptr;
                return *this;
        }

        SmartPtr<T>& operator=(T* rhs) {
        
                if (ptr->nLinks > 1)
                {
                        ptr->nLinks--;
                        ptr = new DATAREF;
                }
                else
                        delete ptr->pData;

                ptr->pData = rhs;
                return *this;
        }

        int Links() const { return ptr->nLinks; }

        operator const T*() const { return ptr->pData; }
        operator const T&() const { return *ptr->pData; }
        operator const unsigned long() const { return (const unsigned long) ptr->pData; }

        T& operator*()  { return *operator->(); }

#ifdef WIN32
        friend ostream& operator<<(ostream& os, const SmartPtr<T>& x);
        friend istream& operator>>(istream& is, SmartPtr<T>& x);
#else
        friend ostream& operator<< <>(ostream& os, const SmartPtr<T>& x);
        friend istream& operator>> <>(istream& is, SmartPtr<T>& x);
#endif //WIN32
};

template<class T>
ostream& operator<<(ostream& os, const SmartPtr<T>& x) { return os << *(x.ptr->pData); }

template<class T>
istream& operator>>(istream& is, SmartPtr<T>& x) { return is >> *(x.ptr->pData); }

#endif //__SMART_PTR_H__

---