c++单线程可变大小内存管理器代码 from 提高c++性能的编程技术

#include <stdio.h> 
class MemoryChunk {
   	public:
	   	MemoryChunk(MemoryChunk *next_chunk, size_t chunk_size);
	   	~MemoryChunk(); 
		
		inline void *alloc(size_t size); 
		inline void free(void * some_element);

		MemoryChunk *next_mem_chunk() { return next; }
		
		size_t space_available() 
			{ return chunk_size - bytes_already_allocated; }

		enum { DEFAULT_CHUNK_SIZE  = 4096 };
		
	private:
		MemoryChunk *next;
		void *mem;
		
		size_t chunk_size;
		size_t bytes_already_allocated;
};

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

		inline void *alloc(size_t size);
		inline void free(void *some_element);
	private:
		MemoryChunk *list_of_memory_chunks;
		void expand_storage(size_t req_size);
};

MemoryChunk::MemoryChunk(MemoryChunk *next_chunk, size_t req_size) 
{
	chunk_size = ( req_size > DEFAULT_CHUNK_SIZE) ?
		req_size : DEFAULT_CHUNK_SIZE;
	
	next = next_chunk;
	bytes_already_allocated = 0;
	mem = new char [chunk_size];
}

MemoryChunk::~MemoryChunk() 
{
	delete [] static_cast<char* >(mem);
}

void* MemoryChunk::alloc(size_t request_size) 
{
	void *addr = static_cast<void*> (static_cast<char *>(mem) + bytes_already_allocated);
	bytes_already_allocated += request_size;

	return addr;
}

inline void MemoryChunk::free(void *doomed) {}

ByteMemoryPool::ByteMemoryPool(size_t init_size) 
{
	expand_storage(init_size);
}

ByteMemoryPool::~ByteMemoryPool()
{
	MemoryChunk *mem_chunk = list_of_memory_chunks;

	while (mem_chunk) {
		list_of_memory_chunks = mem_chunk->next_mem_chunk();
		delete mem_chunk;
		mem_chunk = list_of_memory_chunks;
	}
}

void *ByteMemoryPool::alloc(size_t request_size)
{
	size_t space = list_of_memory_chunks->space_available();
	if (space < request_size) {
		expand_storage(request_size);
	}

	return list_of_memory_chunks->alloc(request_size);
}

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

void ByteMemoryPool::expand_storage(size_t req_size)
{
	list_of_memory_chunks = 
		new MemoryChunk(list_of_memory_chunks, req_size);
}

class Rational {
	public:
		Rational(int a = 0, int b = 1): n(a), d(b) {}
		void *operator new(size_t size) { return mem_pool->alloc(size); }
		void operator delete(void *doomed) { mem_pool->free(doomed); }
		static void new_mem_pool() { mem_pool = new ByteMemoryPool;}
		static void delete_mem_pool() { delete mem_pool; }

	private:
		int n;
		int d;

		static ByteMemoryPool *mem_pool;
};

ByteMemoryPool* Rational::mem_pool = 0;

int main()
{
	Rational *array[10000];
	Rational::new_mem_pool();
	for (int j = 0; j < 10000; j++) {
		array[j] = new Rational(j);
	}
	for (int j = 0; j < 10000; j++) {
		delete array[j];
	}
	Rational::delete_mem_pool();
	return 0;
}