smartptr.hpp

一个智能指针的实现

#ifndef _SMARTPTR_INCLUDED
#define _SMARTPTR_INCLUDED
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <windows.h>
#include <stdio.h>

//	I disabled this warning because if you wrap a non-class with the CSmartPtr 
//		class, you will receive this warning.  It is a warning you may ignore.
//
//	What the compiler is complaining about is having the member selection 
//		operator (->) working on a type with no methods or members.  
//		i.e.  int, short, etc...
//
#pragma warning( disable : 4284 )

class SmartPtrLock
{
public:
	LONG ref;
	HANDLE hMutex;
};

template <class T> class SmartPtr
{
	T *obj;
	SmartPtrLock *lock;

public:
	SmartPtr()
	{
		obj=NULL;
		lock=NULL;
	}

	~SmartPtr()
	{
		if(obj)
		{
			if(InterlockedDecrement(&lock->ref)==0)
			{
				delete obj;
				obj=NULL;
				CloseHandle(lock->hMutex);
				delete lock;
				lock=NULL;
			}
		}
	}

	SmartPtr( T* o )
	{
		obj=o;
		lock=new SmartPtrLock();
		lock->hMutex=CreateMutex(NULL,0,NULL);
		lock->ref=1;
	}
	SmartPtr( SmartPtr<T> & p )
	{
		obj=NULL;
		lock=NULL;
		if(p.obj)
		{
			InterlockedIncrement(&p.lock->ref);
			lock=p.lock;
			obj=p.obj;
		}
	}

	SmartPtr<T> & operator = ( T* o )
	{
		if(obj)
		{
			if(InterlockedDecrement(&lock->ref)==0)
			{
				delete obj;
				obj=NULL;
				CloseHandle(lock->hMutex);
				delete lock;
				lock=NULL;
			}
		}

		obj=NULL;
		lock=NULL;
		if(p.obj)
		{
			InterlockedIncrement(&p.lock->ref);
			lock=p.lock;
			obj=p.obj;
		}

		return *this;
	}

	SmartPtr<T> & operator = ( SmartPtr<T> & p )
	{
		if(obj)
		{
			if(InterlockedDecrement(&lock->ref)==0)
			{
				delete obj;
				obj=NULL;
				CloseHandle(lock->hMutex);
				delete lock;
				lock=NULL;
			}
		}
		obj=new T(*o);
		lock=new SmartPtrLock();
		lock->hMutex=CreateMutex(NULL,0,NULL);
		lock->ref=1;

		return *this;
	}

	SmartPtr<T> & Clone(T* o)
	{
		if(obj)
		{
			if(InterlockedDecrement(&lock->ref)==0)
			{
				delete obj;
				obj=NULL;
				CloseHandle(lock->hMutex);
				delete lock;
				lock=NULL;
			}
		}

		obj=NULL;
		lock=NULL;
		if(p.obj)
		{
			lock=new SmartPtrLock();
			lock->hMutex=CreateMutex(NULL,0,NULL);
			lock->ref=1;
			obj=new T(*p.obj);
		}

		return *this;
	}

	SmartPtr<T> & Clone(SmartPtr<T> & p)
	{
		if(obj)
		{
			if(InterlockedDecrement(&lock->ref)==0)
			{
				delete obj;
				obj=NULL;
				CloseHandle(lock->hMutex);
				delete lock;
				lock=NULL;
			}
		}
		obj=o;
		lock=new SmartPtrLock();
		lock->hMutex=CreateMutex(NULL,0,NULL);
		lock->ref=1;

		return *this;
	}

	inline void Lock()
	{
		if(lock)
			WaitForSingleObject(lock->hMutex);
	}

	inline void UnLock()
	{
		if(lock)
			ReleaseMutex(lock->hMutex);
	}

	inline T* GetObject()
	{
		return obj;
	}

	inline T* operator ->()
	{
		return obj;
	}

	inline operator T* ()
	{
		return obj;
	}

	inline operator const T& ()
	{
		return *obj;
	}

	inline operator== ( const SmartPtr<T>& p )
	{
		return obj==p.obj;
	}

	inline bool operator!= ( const SmartPtr<T>& p )
	{
		return obj!=p.obj;
	}

	inline operator== ( const T* o )
	{
		return obj==o;
	}

	inline bool operator!= ( const T* o )
	{
		return obj!=o;
	}

	inline bool IsNull()
	{
		return obj==NULL;
	}
};

#endif