简单C++对象池实现

/ *ObjectPool.h */



#include <iostream>

#include <queue>

#include <vector>



template <typename T>

class ObjectPool

{

public:

	ObjectPool(size_t chunk_size = kdefault_size);

	~ObjectPool();



	T& acquire_object();

	void release_object(T& obj);



protected:

	void allocate_chunk();

	static void array_delete_object(T* obj);



private:

	std::queue<T*> free_list_;

	std::vector<T*> all_objects_;

	int chunk_size_;							//对象池中预分配对象个数

	static const size_t kdefault_size = 100;	//默认对象池大小



	ObjectPool(const ObjectPool<T>& src);

	ObjectPool<T>& operator=(const ObjectPool<T>& rhs);

};

　　

/* ObjectPool.cpp */



#include "ObjectPool.h"

#include <algorithm>



template <typename T>

const size_t ObjectPool<T>::kdefault_size;



template <typename T>

ObjectPool<T>::ObjectPool(size_t chunk_size /* = kdefault_size */) : chunk_size_ (chunk_size)

{

	if (chunk_size_ <= 0)

	{

		std::cout << "Object size invalid" << std::endl;

	}

	else

	{

		allocate_chunk();

	}

}



template <typename T>

void ObjectPool<T>::array_delete_object(T* obj)

{

	delete obj;

}



template <typename T>

ObjectPool<T>::~ObjectPool()

{

	std::for_each(all_objects_.begin(), all_objects_.end(), ObjectPool<T>::array_delete_object);

}



template <typename T>

void ObjectPool<T>::allocate_chunk()

{

	T* new_objects = new T(chunk_size_);

	for (int i = 0; i < chunk_size_; ++i)

	{

		all_objects_.push_back(&new_objects[i]);

		free_list_.push(&new_objects[i]);

	}

}



template <typename T>

T& ObjectPool<T>::acquire_object()

{

	if (free_list_.empty())

	{

		allocate_chunk();

	}

	T *obj = free_list_.front();

	free_list_.pop();

	return (*obj);

}



template <typename T>

void ObjectPool<T>::release_object(T& obj)

{

	free_list_.push(&obj);

}

　　

来自《Professional C++》