一个简单的对象池

从书上直接摘抄下来的对象池，以后别给忘了
template <typename T>
class ObjectPool
{
public:
	ObjectPool(int chunkSize = kDefaultChunkSize)
		throw(std::invalid_argument, std::bad_alloc);
	~ObjectPool();

	T& acquireObject();

	void releaseObject(T& obj);
protected:
	queue<T*> mFreeList;
	vector<T*> mAllObjects;
	int mChunkSize;
	static const int kDefaultChunkSize = 10;
	void allocateChunk();
	static void arrayDeleteObject(T* obj);
private:
	ObjectPool(const ObjectPool<T>& src);
	ObjectPool<T>& operator=(const ObjectPool<T>& rhs);
};


template <typename T>
ObjectPool<T>::ObjectPool(int chunkSize) throw(std::invalid_argument,
											   std::bad_alloc) : mChunkSize(chunkSize)
{
	if (mChunkSize <= 0) {
		throw std::invalid_argument(“chunk size must be positive”);
	}
	allocateChunk();
}
template <typename T>
void ObjectPool<T>::allocateChunk()
{
	T* newObjects = new T[mChunkSize];
	mAllObjects.push_back(newObjects);
	for (int i = 0; i < mChunkSize; i++) {
		mFreeList.push(&newObjects[i]);
	}
}

template<typename T>
void ObjectPool<T>::arrayDeleteObject(T* obj)
{
	delete [] obj;
}
template <typename T>
ObjectPool<T>::~ObjectPool()
{
// 	vector<T*>::iterator it;
// 	for(it=mAllObjects.begin();it<mAllObjects.end();it++)
// 		delete **it;
	for_each(mAllObjects.begin(), mAllObjects.end(), arrayDeleteObject);
}


template <typename T>
T& ObjectPool<T>::acquireObject()
{
	if (mFreeList.empty()) {
		allocateChunk();
	}
	T* obj = mFreeList.front();
	mFreeList.pop();
	return (*obj);
}

template <typename T>
void ObjectPool<T>::releaseObject(T& obj)
{
	mFreeList.push(&obj);
}