heap.h

可能是能找到的处理速度最快

//: HEAP.H	--- the declare of a memory manager
#ifndef HEAP_H_
#define HEAP_H_
#include <assert.h>
class CHeap
{
	class CHeapUnit
	{
		char *pointer;
		char *nextspace;
		size_t size;
		size_t remain;
		CHeapUnit()
		{
			pointer=NULL;
			nextspace=NULL;
			size=0;
			remain=0;
		}
		void FreeTemp(char *p)
		{
			assert(IsHere(p));
			nextspace=p;
			remain=size-(p-pointer);
		}
		bool GetMem(size_t s)
		{
			if (pointer)
				return false;
			char *p=(char *)malloc(s);
			if (p)
			{
				size=s;
				remain=s;
				pointer=p;
				nextspace=p;
				return true;
			}
			else
				return false;
		}
		void FreeMem()
		{
			if (pointer)
				free(pointer);
			size=0;
			remain=0;
			pointer=NULL;
			nextspace=NULL;
		}
		~CHeapUnit()
		{
			if (pointer)
				free(pointer);
		}
		char *alloc(size_t s)
		{
			if (remain>=s)
			{
				char *p=nextspace;
				nextspace+=s;
				remain-=s;
				return p;
			}
			else
				return NULL;
		}
		bool IsHere(void *s)
		{
			return (s>=pointer)&&(s<nextspace);
		}
		friend class CHeap;
		size_t Remain()
		{
			return remain;
		}
	};
	enum {MIN_SPACE=5,MAX_HEAP=64,HEAP_UNIT=16777216};

	static CHeapUnit heap[MAX_HEAP];		// a heap pointer array
	static unsigned HeapCount;					// how many heap existing in the array
	static unsigned HaveSpace;					// the last pointer that have no more space
	unsigned TempStartUnit;
	char *TempStartLocation;
	bool TempLocationSetted;
public:
	static bool MemUseUp;
	CHeap(size_t t=HEAP_UNIT);
	void StartTemp()
	{
		TempStartUnit=HaveSpace;
		TempStartLocation=heap[HaveSpace].nextspace;
		TempLocationSetted=true;
	}
	void FreeTemp()
	{
		assert(TempLocationSetted);
		for (unsigned i=HeapCount-1;i>TempStartUnit;i--)
		{
			heap[i].FreeMem();
		}
		HeapCount=i+1;
		heap[i].FreeTemp(TempStartLocation);
		HaveSpace=TempStartUnit;
	}
	void HeapReset();
	void FreeAll();
	~CHeap();
	void *operator new(size_t s);
	void *operator new[](size_t s)
	{
		return operator new(s);
	}
	void operator delete(void  *);
	void operator delete[](void *p)
	{
		operator delete(p);
	}
};

#ifndef LOCALHEAP
extern  CHeap GlobalHeap;

inline 	void *operator new(size_t s)
{
	return GlobalHeap.operator new(s);
}

inline	void operator delete(void  *s)
{
	GlobalHeap.operator delete(s);
}
#endif
#endif // HEAP_H_