使用模板和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");
}