內存碎片是怎樣產生的

malloc/free或new/delete大量使用後回造成內存碎片，那麼這種碎片形成的機理是什麼？ 
    如果機理是申請的內存空間大小（太小）所形成的，那麼，申請多大的區域能夠最大限度的避免內存碎片呢？（這裏的避免不是絕對的避免，只是一種概率）
    內存碎片一般是由於空閒的連續空間比要申請的空間小，導致這些小內存塊不能被利用。產生內存碎片的方法很簡單，舉個例： 
    假設有一塊一共有100個單位的連續空閒內存空間，範圍是0~99。如果你從中申請一塊內存，如10個單位，那麼申請出來的內存塊就爲0~9區間。這時候你繼續申請一塊內存，比如說5個單位大，第二塊得到的內存塊就應該爲10~14區間。 
    如果你把第一塊內存塊釋放，然後再申請一塊大於10個單位的內存塊，比如說20個單位。因爲剛被釋放的內存塊不能滿足新的請求，所以只能從15開始分配出20個單位的內存塊。 
    現在整個內存空間的狀態是0~9空閒，10~14被佔用，15~24被佔用，25~99空閒。其中0~9就是一個內存碎片了。如果10~14一直被佔用，而以後申請的空間都大於10個單位，那麼0~9就永遠用不上了，造成內存浪費。 
    如果你每次申請內存的大小，都比前一次釋放的內村大小要小，那麼就申請就總能成功。 

    在C++中我們可以重寫operator new/operator delete來減少內存碎片出現的機會，並 在那些需要動態分配大量的但很小的對象的應用程序裏效率會很好，如以下的例子：

 

//FreeListBase.h
#define NULL 0
class FreeListBase
{
public:
	FreeListBase(void){}
	virtual ~FreeListBase(void){}
public:
	void* operator new(size_t size);
	void operator delete(void* p,size_t size);
private:
	static FreeListBase* freelist;
	FreeListBase* next;
};
//FreeListBase.cpp
void* FreeListBase::operator new(size_t size)
{
	if(freelist != NULL)
	{
		FreeListBase* p = freelist;
		freelist = freelist->next;
		return p;
	}
	else
		return ::operator new(size);
}
void FreeListBase::operator delete(void* vp,size_t size)
{
	FreeListBase* p = static_cast<FreeListBase*>(vp);
	p->next = freelist;
	freelist = p;
}
//TemperatureUsingFreeList.h
#include "freelistbase.h"
class TemperatureUsingFreeList :
	public FreeListBase
{
public:
	TemperatureUsingFreeList(void){}
	~TemperatureUsingFreeList(void){}
	inline int average() { return (maxTemp + minTemp)/2; }
private:
	int ID;
	int maxTemp;
	int minTemp;
	int currentTemp;
}; 

當然不一定要用繼承的形式，組合也是可以的。

    也有的人喜歡自己編寫內存管理模塊，程序一開始就申請一大塊內存（內存池），然後以後申請內存都在這個大內存中取，配合一定的技巧來減少內存碎片問題。 例如：

//BigChunkStack.H
#define NULL 0
#define INITSIZE 30
class BigChunkStack
{
	struct elem
	{
		int id;                 
		int previousElemSize;    //上一個元素的大小
		int namesize;            //name的大小
		char* name;
	};
public:
	BigChunkStack(void);
	~BigChunkStack(void);
public:
	void push(const char* s,const int nr);
	void pop(char* s,int& nr);
    int grow();
	int shrink();
private:
	int totalSize;
	int emptyElemSize;
	int lastElemSize;     //最後一個加入的元素的大小
	char* pool;           //內存池指針
	int MAXSIZE;          //內存池的大小
};
//BigChunkStack.cpp
BigChunkStack::BigChunkStack(void)
{
	totalSize = 0;
	emptyElemSize = sizeof(elem);
	lastElemSize = 0;
	pool = NULL;
	MAXSIZE = 0;
}
BigChunkStack::~BigChunkStack(void)
{
}
void BigChunkStack::push(const char* s,const int nr)
{
	assert(s != NULL);
	int newStringSize = strlen(s) + 1;
	int newElemSize = newStringSize + emptyElemSize;
	if((totalSize + newElemSize) > MAXSIZE)
	{
		if(!grow())
		{
			cerr<<"Error,Stack Overflow!"<<endl;
			return ;
		}
	}
	elem* newElem = (elem*)(pool+totalSize);
	newElem->name = (char*)(pool+totalSize+emptyElemSize);
	newElem->id = nr;
	newElem->namesize = newStringSize;
	newElem->previousElemSize = lastElemSize;
	strcpy(newElem->name,s);
	lastElemSize = newElemSize;
	totalSize += newElemSize;
}
void BigChunkStack::pop(char* s,int& nr)
{
	if(totalSize*4 <= MAXSIZE)
		shrink();
	if(totalSize != 0)
	{
		totalSize -= lastElemSize;
		elem* popElem = (elem*)(pool+totalSize);
		lastElemSize = popElem->previousElemSize;
		strcpy(s,popElem->name);
		nr = popElem->id;
	}
	else
	{
		cerr<<"Error,Stack Underflow!!"<<endl;
	}
}
int BigChunkStack::grow()
{
	if(MAXSIZE == 0)
	{
		pool = new char[INITSIZE];
		if(pool == NULL)
			return 0;
		MAXSIZE = INITSIZE;
		return 1;
	}
	else
	{
		MAXSIZE *= 2;
		char* tempPool = (char*)realloc(pool,MAXSIZE);
		if(tempPool == NULL)
			return 0;
		pool = tempPool;
		return 1;
	}
}
int BigChunkStack::shrink()
{
	if(MAXSIZE/2 >= INITSIZE)
	{
		char* tempPool = (char*)realloc(pool,MAXSIZE/2);
		if(tempPool == NULL) return 0;
		pool = tempPool;
		MAXSIZE /= 2;
		return 1;
	}
}