对象池的实现

为了提高new对象的速度，工程师们提出了对象池的解决方案。即一次性分配大量的空间，供开发者创建对象使用；当分配的大量空间不够时，再次分配大量的空间。

嗯，这种方式，在内存池中是没有问题的。但是，由于对象构造时需要执行构造函数，析构时需要执行析构函数，这时就需要一种特殊的方式来解决在已经分配了的空间上执行构造函数。

这，就是placement new。

示例：

char * p = new char [sizeof(Object)];

Object * pObject = new (p) Object();

对应的，在析构对象时，需要：

pObject->~Object();

delete [] p;

下面给出我实现的ObjectPool

#ifndef __OBJECT_POOL_H__
#define __OBJECT_POOL_H__

#include "memorypool.h"

template<typename TO>
class CObjectPool
{
public:
	CObjectPool()
	{
	}

	~CObjectPool()
	{
	}

	/**
    * @brief
    * 初始化对象分配器
    * @param dwGrowCount : 每次增长的分配数量
    * @return  创建成功返回true，失败返回false
    **/
    bool PPAPI Create(unsigned int dwGrowCount = 1)
	{
		unsigned int dwUnitSize = sizeof(TO);
		bool ret = false;
		ret = m_Pool.Create(dwUnitSize, dwGrowCount * dwUnitSize);
		return ret;
	}

    /**
    * @brief
    * 构造一个新的对象
    * @return  void*
    **/
    TO* PPAPI New()
	{
		return new (Malloc()) TO;
	}

	template<typename P1>
	TO* PPAPI New(P1 p1)
	{
		return new (Malloc()) TO(p1);
	}

	template<typename P1, typename P2>
	TO* PPAPI New(P1 p1, P2 p2)
	{
		return new (Malloc()) TO(p1, p2);
	}

	template<typename P1, typename P2, typename P3>
	TO* PPAPI New(P1 p1, P2 p2, P3 p3)
	{
		return new (Malloc()) TO(p1, p2, p3);
	}

	template<typename P1, typename P2, typename P3, typename P4>
	TO* PPAPI New(P1 p1, P2 p2, P3 p3, P4 p4)
	{
		return new (Malloc()) TO(p1, p2, p3, p4);
	}

	template<typename P1, typename P2, typename P3, typename P4, typename P5>
	TO* PPAPI New(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
	{
		return new (Malloc()) TO(p1, p2, p3, p4, p5);
	}

    /**
    * @brief
    * 释放一个对象
    * @param p : 指向对象的指针
    * @return  void
    **/
    void PPAPI Delete(TO* p)
	{
		p->~TO();
		Free(p);
	}

private:
    void* Malloc()
	{
		return m_Pool.Malloc();
	}

    void Free(void* p)
	{
		m_Pool.Free(p);
	}

private:
	CFixMemoryPool m_Pool;
};

#endif

其中的memorypool.h请见http://blog.csdn.net/huyiyang2010/article/details/7262315