好非主流的内存池用法，参考了某大牛的写法改造了一下。

namespace DL
{

template<typename T, typename MUTEX = DL::MutexLock, typename ALLOC = DL::QS::Allocator<T> >
class Memory
{
public:

        static void *operator new(size_t size);
        static void operator delete(void *ptr);
private:

        static MUTEX __mutex;
        static ALLOC __allocator;
};

template<typename T, typename MUTEX, typename ALLOC>
MUTEX Memory<T, MUTEX, ALLOC>::__mutex;

template<typename T, typename MUTEX, typename ALLOC>
ALLOC Memory<T, MUTEX, ALLOC>::__allocator(32);

template<typename T, typename MUTEX, typename ALLOC>
void *Memory<T, MUTEX, ALLOC>::operator new(size_t size)
{
        MutexLockGuard<MUTEX> lock(__mutex);
        assert(size == sizeof(T) && size >= 8);
        void *ptr = __allocator.malloc();
        return ptr;
}

template<typename T, typename MUTEX, typename ALLOC>
void Memory<T, MUTEX, ALLOC>::operator delete(void *ptr)
{
        MutexLockGuard<MUTEX> lock(__mutex);
        assert(ptr != NULL);
        __allocator.free(ptr);
}
}

用template方式让Memory变得可配置，若要加锁,用默认的DL::MutexLock,若不加锁用DL::NullLock，而内存配置策略也彩用template方式，这用内存配置方法也可以配置。

要想让类从内存池里拿来出来，就把你的类继承于Memory,如下。

#ifdef MEMROY
#ifdef ACE
#define MEMORY_POOL(CLASS) : public DL::Memory<CLASS,DL::NullLock,ACE_Cached_Allocator<CLASS,ACE_Null_Mutex> >
#else
#define MEMORY_POOL(CLASS) : public DL::Memory<CLASS,DL::NullLock,DL::QS::Allocator<CLASS> >
#endif
#else
#define MEMORY_POOL(CLASS)
#endif

class EngineMonitor MEMORY_POOL(EngineMonitor)
{

public:
	EngineMonitor()
	{
	}
	virtual ~EngineMonitor()
	{
	}

private:
	int __service;
	int __monitor;
};

Memroy重载了C++类的new跟delete,成员都是static的，这样，同一个最终类经模块化后，都共用一个allocator，这样就可以实现内存池了。在new的时候从allocator预先分配的内存中，拿出一块符合类的内存块大小，在不用的时候delete掉，把内存块放回到allocator中。不过Memroy每一次new后，都调用了最终类的构造函数，增加了时间开销。最后我用ACE_Cached_Allocator和DL::QS::Allocator<T>做了一次测试比较，感觉都差不多，嘿嘿，不错。