autoptr.h

一个内存受限系统内存分配的源代码。

#ifndef AutoPtr_h
#define AutoPtr_h

#include "BREWAllocator.h"




template <class K>
union POD_DISCRIMINANT
{
	K t;
	int i;
};



template <class T, class A=Allocator>
class AutoPtr
{
public:
	explicit AutoPtr(T * p , A* allocator = 0): owns_( p != 0 ), 
		allocator_(allocator),  ptr_( p ) , sz_(0)
	{  }
	explicit AutoPtr(size_t sz, A* allocator=0): owns_(false),
		allocator_(allocator),  ptr_( 0 ) , sz_(sz)
	{  
		if (allocator_)
		{
			ptr_ = (T*)allocator_->allocate(sizeof(T) * sz_);
			if (ptr_)
			{
				for (int i = 0 ;i < sz_; ++i)
					new (&ptr_[i]) T;
			}
		}
		else
			ptr_ = new T[sz_];
		owns_ = (ptr_!=0);
	}
	~AutoPtr()
	{
		kill();
	}
	T& operator*() 
	{
		return *ptr_;
	}
	T* operator->() 
	{
		return ptr_;
	}
	T* get() 
	{
		return ptr_;
	}
	bool operator !() const
	{
		return ptr_!=0;
	}
	T& operator[](size_t i) 
	{
		if (sz_)
			return ptr_[i];
		else
			return *ptr_;
	}
	T* release() 
	{
		owns_ = false;
		return ptr_;
	}
	AutoPtr& set (T * inPtr, size_t sz = 0)
	{
		if (ptr_ != inPtr)
		{
			kill();
			owns_ = (inPtr != 0);
			sz_ = sz;
			ptr_ = inPtr;
		}
		return *this;
	}
private:
	void kill()
	{
		if (owns_)
		{
			if (allocator_)
			{
				if (allocator_->isInPool(ptr_))
				{
					if (sz_)
					{
						for (size_t h=0; h < sz_; ++h)
							ptr_[h].~T();
					}
					else
					{
						ptr_->~T();
					}
					allocator_->deallocate(ptr_);
				}
				else 
				{
					killPD();
				}
			}
			else
			{
				killPD();
			}
		}
		owns_ = false;
		sz_ = 0;
		ptr_ = 0;
	}
	void killPD()
	{
		if (sz_)
			delete[] ptr_;
		else
			delete ptr_;
	}
private:
	AutoPtr(const AutoPtr<T,A>& rhs) ;
	const AutoPtr& operator=(const AutoPtr<T,A>&);
private:
	bool owns_;
	A* allocator_;
	T *	 ptr_;
	size_t sz_;
};


template <class T, class A=Allocator>
class AutoPtrPOD
{
	enum {IS_POD=sizeof(POD_DISCRIMINANT<T>)};
public:
	explicit AutoPtrPOD(size_t sz, A* allocator=0): owns_(false), 
	allocator_(allocator), ptr_(0)
	{
		if (allocator_)
			ptr_ =  static_cast<T*>(allocator_->allocate(sz*sizeof(T)));
		else
			ptr_ = static_cast<T*>(MALLOC(sz*sizeof(T)));
		owns_ = (ptr_!=0);
	}
	explicit AutoPtrPOD(T * p) : owns_( p != 0 ),  
		allocator_(0), ptr_(p)
	{  }
	explicit AutoPtrPOD(void * p) : owns_( p != 0 ),  
		allocator_(0), ptr_(static_cast<T*>(p))
	{  }
	~AutoPtrPOD()
	{
		kill();
	}
	T& operator*() 
	{
		return *ptr_;
	}
	T* operator->() 
	{
		return ptr_;
	}
	bool operator !() const
	{
		return ptr_!=0;
	}
	T* get() 
	{
		return ptr_;
	}
	operator T*() 
	{
		return ptr_;
	}
	T* release() 
	{
		owns_ = false;
		return ptr_;
	}
	AutoPtrPOD &
		set (T * inPtr)
	{
		if (ptr_ != inPtr)
		{
			kill();
			owns_ = (inPtr != NULL);
			ptr_ = inPtr;
		}
		return *this;
	}
private:
	void kill()
	{
		if (owns_)
		{
			if (allocator_)
			{
				if (allocator_->isInPool(ptr_))
				{
					allocator_->deallocate(ptr_);
				}
				else
				{
					FREE(ptr_);
				}
			}
			else
			{
				FREE(ptr_);
			}
		}
		owns_ = false;
		ptr_ = 0;
	}
private:
	AutoPtrPOD(const AutoPtrPOD<T,A>& rhs) ;
	const AutoPtrPOD& operator=(const AutoPtrPOD<T,A>&);
private:   
	bool owns_;
	A* allocator_;
	T *	 ptr_;
};







#endif