单线程不固定大小对象的内存池实现

内存块类头文件：

//MemoryChunk.h

class MemoryChunk
{
public:
	MemoryChunk(MemoryChunk* nextChunk,size_t chunkSize);
	~MemoryChunk() {delete[] mem;}

	void * alloc(size_t size);
	void free(void* someElement);

	MemoryChunk* nextMemChunk() {return next;}
	size_t spaceAvailable() {return chunkSize-bytesAlreadyAllocated;}

	enum  
	{
		DEFAULT_CHUNK_SIZE=4096
	};
private:
	void* mem;
	MemoryChunk* next;
	size_t chunkSize;
	size_t bytesAlreadyAllocated;
};

内存块类实现文件：

#include "MemoryChunk.h"

MemoryChunk::MemoryChunk(MemoryChunk* nextChunk,size_t reqSize)
{
	chunkSize=(reqSize>DEFAULT_CHUNK_SIZE)?reqSize:DEFAULT_CHUNK_SIZE;
	next=nextChunk;
	bytesAlreadyAllocated=0;
	mem=new char[chunkSize];
}

void* MemoryChunk::alloc(size_t requestSize)
{
	void* addr=reinterpret_cast<void*>(reinterpret_cast<size_t>(mem)+bytesAlreadyAllocated);
	bytesAlreadyAllocated+=requestSize;
	return addr;
}

void MemoryChunk::free(void* deoomed) {}

内存池类头文件：

#include "MemoryChunk.h"

class ByteMemoryPool
{
public:
	ByteMemoryPool(size_t initSize=MemoryChunk::DEFAULT_CHUNK_SIZE);
	~ByteMemoryPool(void);

	void* alloc(size_t size);
	void free(void* someElement);
private:
	MemoryChunk* listOfMemoryChunks;
	void expandStorage(size_t reqSize);
};

内存池类实现文件：

#include "ByteMemoryPool.h"

ByteMemoryPool::ByteMemoryPool(size_t initSize)
{
	expandStorage(initSize);
}


ByteMemoryPool::~ByteMemoryPool(void)
{
	MemoryChunk* memChunk=listOfMemoryChunks;
	while(memChunk)
	{
		listOfMemoryChunks=memChunk->nextMemChunk();
		delete memChunk;
		memChunk=listOfMemoryChunks;
	}
}

void* ByteMemoryPool::alloc(size_t requestSize)
{
	size_t space=listOfMemoryChunks->spaceAvailable();
	if(space<requestSize)
		expandStorage(requestSize);

	return listOfMemoryChunks->alloc(requestSize);
}

void ByteMemoryPool::free(void* doomed)
{
	listOfMemoryChunks->free(doomed);
}

void ByteMemoryPool::expandStorage(size_t reqSize)
{
	listOfMemoryChunks=new MemoryChunk(listOfMemoryChunks,reqSize);
}

使用内存池的类：

class Rational
{
public:
	Rational(int a=0,int b=1):n(a),d(b) {}

	void *operator new(size_t size) 
	{
		return memPool->alloc(size);
	}
	void operator delete(void* doomed,size_t size) 
	{
		memPool->free(doomed);
	}

	static void newMemPool() {memPool=new ByteMemoryPool;}
	static void deleteMemPool() {delete memPool;}
private:
	int n;
	int d;

	static ByteMemoryPool *memPool;
};
ByteMemoryPool* Rational::memPool=nullptr;

调用代码：

int _tmain(int argc, char* argv[])
{
	Rational *rarray[1000];

	Rational::newMemPool();

	for(int j=0;j<500;j++)
	{
		for(int i=0;i<1000;i++)
			rarray[i]=new Rational(i);
		for(int i=0;i<1000;i++)
			delete rarray[i];
	}

	Rational::deleteMemPool();
	
	_CrtDumpMemoryLeaks();

	return 0;
}

 经测试，没有内存泄露，效率比固定大小内存池的实现要慢，这就是以时间换灵活性。