单线程内存池

#include <boost/progress.hpp>

class NextOnFreeList
{
public:
	NextOnFreeList *next;
};

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

	inline void * operator new (size_t size);					//over load new and delete operator
	inline void  operator delete (void *doomed, size_t size);

	static void newMemPool() {expandTheFreeList();}
	static void deleteMemPool();
private:
	static NextOnFreeList * freelist;
	static void expandTheFreeList();
	enum {EXPANSION_SIZE = 32};

	int n;
	int d;
};


void * Rational::operator new( size_t size )
{
	if (0 == freelist)
	{
		expandTheFreeList(); //if not enough memory, expand.
	}

	NextOnFreeList *head = freelist;
	freelist = head->next;

	return head;
}

void Rational::operator delete( void *doomed, size_t size )
{
	NextOnFreeList *head = static_cast<NextOnFreeList *>(doomed);
	head->next = freelist;
	freelist = head;
}

void Rational::expandTheFreeList()
{
	size_t size = (sizeof(Rational) > sizeof(NextOnFreeList *)) ? sizeof(Rational) : sizeof(NextOnFreeList *);
	NextOnFreeList *runner = (NextOnFreeList *)( new char[size] );

	freelist = runner;
	for (int i = 0; i < EXPANSION_SIZE; ++i)
	{
		runner->next = (NextOnFreeList *)(new char[size]);
		runner = runner->next;
	}

	runner->next = 0;
}

void Rational::deleteMemPool()
{
    NextOnFreeList * nextPtr;
    for(nextPtr = freelist; nextPtr != NULL; nextPtr = freelist)
	{
		freelist = freelist->next;
		delete [](char *)nextPtr;
    }
}

NextOnFreeList * Rational::freelist =0;

int main()
{
	int s1 = sizeof(Rational) ;
	int s2 = sizeof(NextOnFreeList *);
	{
		boost::progress_timer t;//计时器
		
		Rational *array[1000];
		Rational::newMemPool();

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

		Rational::deleteMemPool();

	}// t析构时自动输出流逝时间

	return 0;
}