cmempool.h

内存池

/********************************************************************
	created:	2006/10/31
	created:	31:10:2006   21:10
	filename: 	d:\Gs\mempool\mempool\CMemPool.h
	file path:	d:\Gs\mempool\mempool
	file base:	CMemPool
	file ext:	h
	author:		Zhang Li
	
	purpose:	
*********************************************************************/

#ifndef CMEMPOOL_H
#define CMEMPOOL_H

#include <cstdlib>
#include <new.h>
#include <windows.h>

using namespace std;

class CMemPool
{

public:
	
	template<typename T>
	inline T *AllocMemory()
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T();
		return p;
	}

	template<typename T, typename T1>
	inline T *AllocMemory(const T1 &t1)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1);
		return p;
	}

	template<typename T, typename T1, typename T2>
	inline T *AllocMemory(const T1 &t1, const T2 &t2)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2);
		return p;
	}

	template<typename T, typename T1, typename T2, typename T3>
	inline T *AllocMemory(const T1 &t1, const T2 &t2, const T3 &t3)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2, t3);
		return p;
	}

	template<typename T, typename T1, typename T2, typename T3, typename T4>
	inline T *AllocMemory(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2, t3, t4);
		return p;
	}

	template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5>
	inline T *AllocMemory(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2, t3, t4, t5);
		return p;
	}

	template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
	inline T *AllocMemory(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2, t3, t4, t5, t6);
		return p;
	}

	template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
		typename T7>
	inline T *AllocMemory(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6,
	const T7 &t7)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2, t3, t4, t5, t6, t7);
		return p;
	}

	template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
		typename T7, typename T8>
	inline T *AllocMemory(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6,
	const T7 &t7, const T8 &t8)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2, t3, t4, t5, t6, t7, t8);
		return p;
	}

	template<typename T, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6,
		typename T7, typename T8, typename T9>
	inline T *AllocMemory(const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6,
		const T7 &t7, const T8 &t8, const T9 &t9)
	{
		T *p = (T*)_alloc(sizeof(T));		
		new(p) T(t1, t2, t3, t4, t5, t6, t7, t8, t9);
		return p;
	}

	template<typename T>
	inline void FreeMemory(T *&p)
	{
		p->~T();
		_free((void*&)p, sizeof(T));
	}

	inline static CMemPool *GetInstance()
	{
		if (m_MemPool == NULL)
		{
			InitializeCriticalSection(&cs);
			m_MemPool = new CMemPool();
		}
		return m_MemPool;
	}

	void Release();

private:

	void *_alloc(unsigned int size);
	void _free(void *&p, unsigned int size);

	//内存块结构
	template<int mem_size>
	class memBlock
	{
		typedef unsigned char byte;
	public:
		byte mem[mem_size - 4];
		memBlock<mem_size> *m_prev;
	};

	static bool m_bInited;
	static CMemPool *m_MemPool;
	static CRITICAL_SECTION cs;

	class Lock
	{
	public:
		Lock(){ EnterCriticalSection(&cs); }
		~Lock(){ LeaveCriticalSection(&cs); }
	};

	CMemPool();
	~CMemPool(){};

	memBlock<32> *m_currentBlock32;
	memBlock<64> *m_currentBlock64;
	memBlock<96> *m_currentBlock96;
	memBlock<128> *m_currentBlock128;
	memBlock<160> *m_currentBlock160;
	memBlock<192> *m_currentBlock192;
	memBlock<224> *m_currentBlock224;
	memBlock<256> *m_currentBlock256;

	memBlock<32> *m_memHead32;
	memBlock<64> *m_memHead64;
	memBlock<96> *m_memHead96;
	memBlock<128> *m_memHead128;
	memBlock<160> *m_memHead160;
	memBlock<192> *m_memHead192;
	memBlock<224> *m_memHead224;
	memBlock<256> *m_memHead256;
};

#endif