大小不变的对象的内存管理类的使用

#ifndef _MEM_POOL_TEST_
#define _MEM_POOL_TEST_
/********************************************************************
 created: 2004/11/29
 created: 29:11:2004   15:27
 filename:  e:/复用/memory pool/test/cmempooltest.h
 file path: e:/复用/memory pool/test
 file base: cmempooltest
 file ext: h
 author:  David
 
 purpose: 这是一个测试内存池类的类，主要用到的类为：
   1.CMemPool－－CMemPool.h主要用于对内存池的管理(Allocate and Release)的
  template, 适用于每个节点的大小都相等的情况。
   2.CLock－－Lock.h主要被CMemPool内部所用，同步CMemPool内部inuse链表和free
  链表。
   3.CMemPoolTest CBuffer－－用于测试CMemPool的类。一个CMemPoolTest实例模拟
  一个网络session，因为该类实例有可能会频繁生成和释放，故需采用内存池，
  而每个实例管理自己的缓冲区列表，而缓冲区列表也有可能会频繁生成和释放
  掉，故也采用内存池，这样就有可能出现内存池嵌套现象，这两个类就是用来
  模拟CMemPool嵌套的情况的，试验结果良好。
   4.注意点：使用类CMemPool的类必须重装new和delete，在new中从内存池Allocate
  内存，
  而在delete中Release内存，归还给内存池。内存池应该属于类的资产，而不是
  对象的资产，故为static类型的成员。
   5.建议：对于同类对象频繁生成于释放的情况，建议使用内存池，这样可以防止内存
  碎片和有助于程序的稳定。
*********************************************************************/

#include "CMemPool.h"
#include "global.h"
#include  <list>

class CBuffer
{
public:
 CBuffer();
  virtual ~CBuffer();
 
 static void* operator new(size_t);
 static void operator delete(void*);
private:
 int m_nBufLen;
 char m_pBuffer[2048];
  static CMemPool<CBuffer> m_MemPool;
};

class CMemPoolTest
{
public:
 CMemPoolTest();
 virtual ~CMemPoolTest();

 static void* operator new(size_t);
 static void operator delete(void*);

  
 void SetBuffer();
 private:

 static CMemPool<CMemPoolTest> m_MemPool;

 list<CBuffer *> m_BufferList;
};

#endif

//.cpp
#include "CMemPoolTest.h"
CBuffer::CBuffer()
{
}

CBuffer::~CBuffer()
{
  cout << "~CBuffer" << endl;
}

void *CBuffer::operator new(size_t)
{
 CBuffer *p = NULL;
 
 p = static_cast<CBuffer*>(m_MemPool.Allocate());
 
 int m_nInuse, m_nFree;
 m_MemPool.GetInfo(m_nInuse, m_nFree);
 cout << "CBuffer Allocate m_nInuse is " << m_nInuse << " m_nFree is "<< m_nFree << endl;
 return p; 
}

void CBuffer::operator delete(void *deadobject)
{
 m_MemPool.Release((CBuffer *)deadobject);
 
 int m_nInuse, m_nFree;
 m_MemPool.GetInfo(m_nInuse, m_nFree);
 cout << "CBuffer Release m_nInuse is " << m_nInuse << " m_nFree is "<< m_nFree << endl; 
}

CMemPoolTest::CMemPoolTest()
{
  
}

CMemPoolTest::~CMemPoolTest()
{
 list<CBuffer*>::const_iterator pos;
 for(pos = m_BufferList.begin(); pos != m_BufferList.end(); ++pos){
  delete (CBuffer *)(*pos);
 } 
 m_BufferList.clear();
}

void *CMemPoolTest::operator new(size_t)
{
 CMemPoolTest *p = NULL;
 
 p = static_cast<CMemPoolTest*>(m_MemPool.Allocate());
 
/*
 int m_nInuse, m_nFree;
 m_MemPool.GetInfo(m_nInuse, m_nFree);
 cout << "Allocate m_nInuse is " << m_nInuse << " m_nFree is "<< m_nFree << endl;
*/
 return p; 
}

void CMemPoolTest::operator delete(void *deadobject)
{
 m_MemPool.Release((CMemPoolTest *)deadobject);
 
/*
 int m_nInuse, m_nFree;
 m_MemPool.GetInfo(m_nInuse, m_nFree);
 cout << "Release m_nInuse is " << m_nInuse << " m_nFree is "<< m_nFree << endl;
*/
 
}

void CMemPoolTest::SetBuffer()
{
 CBuffer *p = NULL;
 p = new CBuffer();

 m_BufferList.push_back(p);
}

//main()
#include "global.h"
#include  <list>
#include "CMemPoolTest.h"
#include "UnfixedMem_Pool.h"

CMemPool<CMemPoolTest> CMemPoolTest::m_MemPool;//fixed memory manager
CMemPool<CBuffer> CBuffer::m_MemPool;//fixed memory manager
CUnfixedMemPool g_MemPool;//unfixed memory manager

int main()
{
//test CMemPool 
 int i = 0;
 CMemPoolTest *test[1000];
 for(i = 0; i < 1000; i++){
  test[i] = new CMemPoolTest;
  test[i]->SetBuffer();
  test[i]->SetBuffer();
 }

 for(i = 0; i < 1000; i++){
  if (test[i] != NULL) {
   delete test[i];
   test[i] = NULL;
  }
 }
//end test CMemPool 

 return SUCCESS_CODE;
}