使用模板和STL实现对象池

在频繁申请和释放类的实例时，有两点值得考虑：【1】速度问题【2】对空间会变得七零八落。 这时候使用对象池是一个不错的注意，这会有效缓解上面两个现象。对象池的主要思想就是：事先申请一些内存单元由应用程序自身管理，知道整个程序结束。本人实现的一个模板类如下：

//JudeDeng 2011.1.18

//ObjectPool.h

#ifndef __OBJECTPOOL_H__
#define __OBJECTPOOL_H__

#include <list>
using namespace std;

#define DEFAULT_SIZE 10

//申请对象
#define NEW_OBJ(OBJ_MANAGER, CLASS_NAME, ArgList) (sizeof(CLASS_NAME)==OBJ_MANAGER.GetSizeOfType()? (new(OBJ_MANAGER.mallocObject()) CLASS_NAME ArgList) : NULL)

//释放对象
#define DEL_OBJ(OBJ_MANAGER, OBJ_POINTER) (OBJ_MANAGER.freeObject(OBJ_POINTER) ? (OBJ_POINTER=NULL, true) : false)

template<typename T>
class CObjectMgr_T
{
public:
CObjectMgr_T(int sizeOfObjectList=DEFAULT_SIZE);

//申请内存单元
virtual T* mallocObject();

//释放内存单元
virtual bool freeObject(T* object);

//回收空闲空间 rate回收比例 如0.5表示回收一半， 1表示全部回收。。返回值为具体回收的个数
virtual int reclaimIdelMem(double rate);

virtual ~CObjectMgr_T(void);
inline unsigned GetSizeOfType(){return sizeof(T);}

protected:

list<T *> m_ActiveObjectList, m_IdleObjectList;
};

#include "ObjectPoolImp.h"

#endif

//============================================================

//ObjectPoolImp.h

#ifndef __OBJECTPOOLIMP_H__
#define __OBJECTPOOLIMP_H__

#include "ObjectPool.h"

template<typename T>
CObjectMgr_T<T>::CObjectMgr_T(int sizeOfObjectList)
{
for(int i=0;i<sizeOfObjectList;i++)
{
T* pBuffer = (T*)malloc(sizeof(T));
m_IdleObjectList.push_back(pBuffer);
}
}

template<typename T>
T * CObjectMgr_T<T>::mallocObject()
{
T* pObject;

if(m_IdleObjectList.empty())
{
pObject = (T*)malloc(sizeof(T));
}
else
{
pObject = *(m_IdleObjectList.begin());
m_IdleObjectList.erase(m_IdleObjectList.begin());
}

if(pObject)
{
m_ActiveObjectList.push_back(pObject);

return pObject;
}

return NULL;
}

template<typename T>
bool CObjectMgr_T<T>::freeObject(T * pObject)
{
list<T *>::iterator ite;

for(ite=m_ActiveObjectList.begin(); ite!=m_ActiveObjectList.end(); ++ite)
{
if(pObject == *ite)
{
pObject->~T();
m_ActiveObjectList.erase(ite);
m_IdleObjectList.push_back(pObject);
return true;
}
}

return false;
}

template<typename T>
CObjectMgr_T<T>::~CObjectMgr_T()
{
list<T *>::iterator ite;

int c1=0, c2=0;
for(ite=m_ActiveObjectList.begin(); ite!=m_ActiveObjectList.end(); ++ite)
{
delete (*ite); c1++;
}

for(ite=m_IdleObjectList.begin(); ite!=m_IdleObjectList.end(); ++ite)
{
free (*ite); c2++;
}

printf("/nFor debug:: ActiveObjectList = %d ,, IdleObjectList = %d/n", c1, c2);

m_ActiveObjectList.clear();
m_IdleObjectList.clear();
}

template<typename T>
int CObjectMgr_T<T>::reclaimIdelMem(double rate)
{
if(0<rate && rate<=1)
{
int size = m_IdleObjectList.size();

size = (int)(size * rate);

for(int idx=0; idx<size; ++idx)
{
m_IdleObjectList.erase(m_IdleObjectList.begin());
}

return size;
}

return 0;
}

#endif

//========================================================

#include <stdlib.h>
#include <stdio.h>
#include "ObjectPool.h"

class CA
{
int m_Data;
double m_d2;
float m_d3;
char *p;
public:
CA(char ch){m_Data = ch;}
CA(int x=2){m_Data = 2;}
CA(CA& obj, double a1, void *a2){m_Data = 2;}
virtual ~CA(){

printf("CA::Destruction /n");
}

void doSth(...)
{
printf("/nCA::doSth..%d.", m_Data);
}

};

class CB
{
public:
virtual ~CB(){
printf("CB::Destruction /n");
}

void doSth(...)
{
printf("/nCB::doSth.___.");
}
};

void main()
{
{

//任何类都可以使用该对象池！
CObjectMgr_T<CA> mgr1(19);
CObjectMgr_T<CB> mgr2(0);

CA *pA1 = NEW_OBJ(mgr1, CA, ('A'));
CA *pA2 = NEW_OBJ(mgr1, CA, (2));
CA *pA3 = NEW_OBJ(mgr1, CA, (*pA1, 0.2, NULL));

mgr1.reclaimIdelMem(1);
pA2->doSth();

DEL_OBJ(mgr1, pA1);
DEL_OBJ(mgr1, pA2);
bool bret = DEL_OBJ(mgr1, pA3);

CB *pB1 = mgr2.mallocObject();
CB *pB2 = mgr2.mallocObject();
new (pB1) CB;
new (pB2) CB;

pB1->doSth();

mgr2.freeObject(pB1);
mgr2.freeObject(pB2);
}

system("pause");
}