網上有很多對於STL空間配置器原始碼的剖析，之所以這麼多人去剖析空間配置器，我覺得是真的設計的太好，而且剖析空間配置器的架構的設計對於C++學者來說是一個不錯的提高能力的專案，所以加入到這個解剖大軍中來。

      參照了侯捷的《STL原始碼剖析》，原本直接看原始碼不懂得東西，突然間豁然開朗。再次寫下自己對於STL空間配置器的一點點理解。

   要了解空間配置器，有一張圖是必看的：

    這張圖是一級空間配置器宇二級空間配置器的封裝方式與呼叫。從此圖我們們可以看到其實空間配置器是分為兩級的，而這裡所謂的兩級並沒有高低之分，它們之間的區別就是看你想要申請記憶體空間的大小。如果申請的記憶體大小超過128，那麼空間配置器就自動呼叫一級空間配置器。反之呼叫二級空間配置器。而且在這裡要說明的是空間配置器預設使用的是一級空間配置器。

 一.   一級空間配置器：

   一級空間配置器就比較簡單了，STL原始碼中的一級空間配置器命名為class __malloc_alloc_template ，它很簡單，就是對malloc，free，realloc等系統分配函式的一層封裝，我向這也是為什麼這麼取名的原因。

     原始碼中的一級空間配置器也不難看懂，懂了他的思想也就不難寫出如下的程式碼：   

<span style="font-family:Microsoft YaHei;font-size:14px;">template<int inst>//非型別模板引數
class MallocAllocTemplate//一級空間配置器(malloc,free,realloc)
{
public:
	static void* Allocate(size_t n)
	{
		void* ret = malloc(n);
		if (0 == ret)
			ret = OomMalloc(n);
		return ret;
	}
	static void Deallocate(void* p)
	{
		free(p);
	}
	static void* Reallocate(void* p, size_t newsize)
	{
		void* ret = realloc(p, newsize);
		if (ret == 0)
			ret = OomRealloc(p, newsize);
		return ret;
	}
private:
	static void* OomMalloc(size_t n)//呼叫自定義的控制代碼處理函式釋放並分配記憶體
	{
		ALLOC_FUN hander;
		void* ret;
		while (1)
		{
			hander = MallocAllocHander;
			if (0 == hander)
			{
				cout << "Out of memory" << endl;
				exit(-1);
			}
			hander();
			ret = malloc(n);
			if (ret)
			{
				rteurn (ret);
			}
		}
	}
	static void* OomRealloc(void* p, size_t newsize)//同上
	{
		ALLOC_FUN hander;
		void* ret;
		while (1)
		{
			hander = MallocAllocHander;
			if (0 == hander)
			{
				cout << "Out of memory" << endl;
				exit(-1);
			}
			hander();
			ret = realloc(p,newsize);
			if (ret)
			{
				rteurn(ret);
			}
		}
	}
	static void(*SetMallocHandler(void(*f)()))();//設定作業系統分配記憶體失敗時的控制代碼處理函式
	static ALLOC_FUN MallocAllocHander;

};
template<int inst>
ALLOC_FUN MallocAllocTemplate<inst>::MallocAllocHander = 0;//控制代碼函式初始化為0</span>
 

        malloc，free，realloc等庫函式是向系統申請記憶體並且操作的函式。平時我們並不太會遇到記憶體空間分配不出來的情況，但是如果這一套程式是執行在伺服器上的，各種各樣的程序都需要記憶體。這樣頻繁的分配記憶體，終有一個時候，伺服器再也分配不出記憶體，那麼空間配置器該怎麼辦呢？這個函式指標指向的控制代碼函式就是處理這種情況的設計。

       MallocAllocHander（）一般是自己設計的一種策略。這種策略想要幫助作業系統得到記憶體空間用以分配。所以，設計這個函式就是一個提升空間配置器效率的一個方法。一般是大牛去玩兒的。哈哈。如果並不像設計這個策略，就把控制代碼函式初始化為0.

二.    二級空間配置器：

    一級空間配置器說起來比較乏味，他只是一層系統函式封裝，真正酸爽的是二級空間配置器，裡面有很多很棒的設計。多的不說，先來看二級空間配置器的框架，上程式碼：

<span style="font-family:Microsoft YaHei;font-size:14px;">template<bool threads,int inst>
class DefaultAllocTemplate//二級空間配置器
{
private:
	enum{ ALIGN = 8 };
	enum{ MAX_BYTES = 128 };
	enum{ FREELISTSIZE = MAX_BYTES / ALIGN };
public:
	static void* Allocate(size_t n)
	{
		if (n > MAX_BYTES)
		{
			return MallocAllocTemplate<inst>::Allocate(n);
		}
		void* ret = NULL;
		size_t index = GetFreeListIndex(n);

		if (FreeList[index])//自由連結串列上有記憶體塊
		{
			obj* cur = FreeList[index];
			ret = cur;
			FreeList[index] = cur->listLink;
		}
		else   //呼叫refill從記憶體池填充自由連結串列並返回記憶體池的第一個記憶體塊
		{
			size_t bytes = GetRoundUpNum(n);
			return Refill(bytes);
		}
		return ret;
	}
	static void* Reallocate(void* p, size_t oldsize, size_t newsize)
	{
		void* ret = NULL;
		if (oldsize > (size_t)MAX_BYTES&&newsize > (size_t)MAX_BYTES)
			return (realloc(p, newsize));
		if (GetRoundUpNum(oldsize) == GetRoundUpNum(newsize))
			return p;
		ret = Allocate(newsize);
		size_t copysize = oldsize > newsize ? newsize : oldsize;
		memcopy(ret, p, copysize);
		DeAllocate(p, oldsize);
		return ret;
	}
	static void Deallocate(void* p, size_t n)
	{
		if (n > MAX_BYTES)//如果大於MAX_BYTES直接交還給一級空間配置器釋放
			return MallocAllocTemplate<inst>::Deallocate(p, n);
		else//放回二級空間配置器的自由連結串列
		{
			size_t index = GetFreeListIndex(n);
			obj* tmp = (obj*)p;
			tmp->listLink = FreeList[index];
			Freelist[index] = tmp;
		}
	}
public:
	union obj
	{
		union obj* listLink;//自由連結串列中指向下一個記憶體快的指標
		char clientData[1];//除錯用
	};
	static size_t GetFreeListIndex(size_t bytes)//得到所需記憶體塊在自由連結串列中的下標
	{
		return ((bytes + ALIGN - 1) / ALIGN - 1);
	}
	static size_t GetRoundUpNum(size_t bytes)//得到記憶體塊大小的向上對齊數
	{
		return (bytes + ALIGN - 1)&~(ALIGN - 1);
	}

	static void* Refill(size_t n)//從記憶體池拿出記憶體填充自由連結串列
	{
		int nobjs = 20;//申請20個n大小的記憶體塊
		char* chunk = ChunkAlloc(n, nobjs);
		if (nobj == 1)//只分配到一個記憶體
		{
			return chunk;
		}
		obj* ret = NULL;
		obj* cur = NULL;
		size_t index = GetFreeListIndex(n);
		ret = (obj*)chunk;
		cur = (obj*)(chunk + n);

		//將nobj-2個記憶體塊掛到自由連結串列上
		FreeList[index] = cur;
		for (int i = 2; i < nobjs; ++i)
		{
			cur->listLink = (obj*)(chunk + n*i);
			cur = cur->listLink;
		}
		cur->listLink = NULL;
		return ret;
	}
	static char* ChunkAlloc(size_t size, int& nobjs)
	{
		char* ret = NULL;
		size_t Leftbytes = endFree - startFree;
		size_t Needbytes = size * nobjs;
		if (Leftbytes >= Needbytes)
		{
			ret = startFree;
			startFree += Needbytes;
		}
		else if (Leftbytes >= size)//至少能分配到uoge記憶體塊
		{
			ret = startFree;
			nobjs = Leftbytes / size;
			startFree += nobjs*size;
		}
		else     //一個記憶體塊都分配不出來
		{
			if (Leftbytes > 0)
			{
				size_t index = GetFreeListIndex(Leftbytes);
				((obj*)startFree)->listLink = FreeList[index];
				FreeList[index] = (obj*)startFree;
				startFree = NULL;
			}
			//向作業系統申請2倍Needbytes加上已分配的heapsize/8的記憶體到記憶體池
			size_t getBytes = 2 * Needbytes + GetRoundUpNum(heapSize >> 4);
			startFree = (char*)malloc(getBytes);
			if (startFree == NULL)//從系統堆中分配記憶體失敗
			{
				for (int i = size; i < MAX_BYTES; i += ALIGN)
				{
					obj* head = FreeList[GetFreeListIndex(i)];
					if (head)
					{
						startFree = (char*)head;
						head = head->listLink;
						endFree = startFree + i;
						return ChunkAlloc(size, nobjs);
					}
				}
				//最後的一根救命稻草，找一級空間配置器分配記憶體
				//（其他程序歸還記憶體，呼叫自定義的控制代碼處理函式釋放記憶體）
				startFree = MallocAllocTemplate<inst>::Allocate(getBytes);
			}
			heapSize += getBytes;//從系統堆分配的總位元組數（可以用於下次分配時進行調節）
			endFree = startFree + getBytes;

			return ChunkAlloc(size, nobjs);//遞迴呼叫獲取記憶體
		}
		return ret;
	}

	static obj* volatile FreeList[FREELISTSIZE];
	static char* startFree;
	static char* endFree;
	static size_t heapSize;

};


//typename表示DefaultAllocTemplate<threads, inst>是一個型別，
//如果不標識，編譯器對此模板一無所知
template<bool threads, int inst>
typename DefaultAllocTemplate<threads, inst>::obj* volatile   
           DefaultAllocTemplate<threads, inst>::FreeList[FREELISTSIZE] = { 0 };

template<bool threads, int inst>
char* DefaultAllocTemplate<threads, inst>::startFree = 0;

template<bool threads, int inst>
char* DefaultAllocTemplate<threads, inst>::endFree = 0;

template<bool threads, int inst>
size_t DefaultAllocTemplate<threads, inst>::heapSize = 0;</span>

   首先需要說明的是二級空間配置器是由一個記憶體池和自由連結串列配合實現的。

<span style="font-family:Microsoft YaHei;font-size:14px;">	static obj* volatile FreeList[FREELISTSIZE];//維護自由連結串列
	static char* startFree;//維護記憶體池
	static char* endFree;</span>

     srartFree就相當於水位線的一種東西，它標誌著記憶體池的大小。

     自由連結串列中其實是一個大小為16的指標陣列，間隔為8的倍數。各自管理大小分別為8，16，24，32，40，48，56，64，72，80，88，96，104， 112，120，128 位元組的小額區塊。在每個下標下掛著一個連結串列，把同樣大小的記憶體塊連結在一起。此處特別像雜湊桶。

自由連結串列結構：

<span style="font-family:Microsoft YaHei;font-size:14px;">	union obj
	{
		union obj* listLink;//自由連結串列中指向下一個記憶體快的指標
		char clientData[1];//除錯用
	};</span>

     這個結構可以看做是從一個記憶體塊中摳出4個位元組大小來，當這個記憶體塊空閒時，它儲存了下個空閒塊，當這個記憶體塊交付給使用者時，它儲存的時使用者的資料。因此，allocator中的空閒塊連結串列可以表示成：
    obj* free_list[16];

     obj* 是4個位元組那麼大，但是大部分記憶體塊大於4。我們想要做的只是將一塊塊記憶體連結起來，我們不用看到記憶體裡所有的東西，所以我們可以只用強轉為obj*就可以實現大記憶體塊的連結。

   二級空間配置器是為頻繁分配小記憶體而生的一種演算法。其實就是消除一級空間配置器的外碎片問題。

作業系統頻繁分配記憶體和回收記憶體的時候。這些6M，4M的小記憶體無法利用造成了外部碎片。

二級空間配置器就比較複雜了，現在我們來分析他的那些重要的函式：

 Allocate()中:

<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="white-space:pre">	</span>static size_t GetFreeListIndex(size_t bytes)//得到所需記憶體塊在自由連結串列中的下標
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>return ((bytes + ALIGN - 1) / ALIGN - 1);
<span style="white-space:pre">	</span>}</span>

<span style="font-family:Microsoft YaHei;font-size:14px;">	static size_t GetRoundUpNum(size_t bytes)//得到記憶體塊大小的向上對齊數
	{
		return (bytes + ALIGN - 1)&~(ALIGN - 1);
	}</span>

Allocate中最重要的兩個函式static void* Refill(size_t n)和static char* ChunkAlloc(size_t size, int& nobjs)：

<span style="font-family:Microsoft YaHei;font-size:14px;">static void* Refill(size_t n)//從記憶體池拿出記憶體填充自由連結串列
	{
		int nobjs = 20;//申請20個n大小的記憶體塊
		char* chunk = ChunkAlloc(n, nobjs);
		if (nobj == 1)//只分配到一個記憶體
		{
			return chunk;
		}
		obj* ret = NULL;
		obj* cur = NULL;
		size_t index = GetFreeListIndex(n);
		ret = (obj*)chunk;
		cur = (obj*)(chunk + n);

		//將nobj-2個記憶體塊掛到自由連結串列上
		FreeList[index] = cur;
		for (int i = 2; i < nobjs; ++i)
		{
			cur->listLink = (obj*)(chunk + n*i);
			cur = cur->listLink;
		}
		cur->listLink = NULL;
		return ret;
	}</span>

<span style="font-family:Microsoft YaHei;font-size:14px;">static char* ChunkAlloc(size_t size, int& nobjs)
	{
		char* ret = NULL;
		size_t Leftbytes = endFree - startFree;
		size_t Needbytes = size * nobjs;
		if (Leftbytes >= Needbytes)
		{
			ret = startFree;
			startFree += Needbytes;
		}
		else if (Leftbytes >= size)//至少能分配到一個記憶體塊
		{
			ret = startFree;
			nobjs = Leftbytes / size;
			startFree += nobjs*size;
		}
		else     //一個記憶體塊都分配不出來
		{
			if (Leftbytes > 0)
			{
				size_t index = GetFreeListIndex(Leftbytes);
				((obj*)startFree)->listLink = FreeList[index];
				FreeList[index] = (obj*)startFree;
				startFree = NULL;
			}
			//向作業系統申請2倍Needbytes加上已分配的heapsize/8的記憶體到記憶體池
			size_t getBytes = 2 * Needbytes + GetRoundUpNum(heapSize >> 4);
			startFree = (char*)malloc(getBytes);
			if (startFree == NULL)//從系統堆中分配記憶體失敗
			{
				for (int i = size; i < MAX_BYTES; i += ALIGN)
				{
					obj* head = FreeList[GetFreeListIndex(i)];
					if (head)
					{
						startFree = (char*)head;
						head = head->listLink;
						endFree = startFree + i;
						return ChunkAlloc(size, nobjs);
					}
				}
				//最後的一根救命稻草，找一級空間配置器分配記憶體
				//（其他程序歸還記憶體，呼叫自定義的控制代碼處理函式釋放記憶體）
				startFree = MallocAllocTemplate<inst>::Allocate(getBytes);
			}
			heapSize += getBytes;//從系統堆分配的總位元組數（可以用於下次分配時進行調節）
			endFree = startFree + getBytes;

			return ChunkAlloc(size, nobjs);//遞迴呼叫獲取記憶體
		}
		return ret;
	}</span>

ChunkAlloc要做的就是去找作業系統要記憶體，依次性要20個，但是我們要考慮很多情況：

1. 記憶體池裡有足夠20塊大的記憶體
2. 記憶體池裡有小於20塊大於等於1塊的記憶體大小
3. 記憶體池裡1塊記憶體那麼大都沒有

1. 空間配置器裡所有的成員都是靜態的。是為了在外面通過作用域就可以呼叫，而不需要構造物件。
2. 空間配置器可以使用於大部分的資料結構，如List，vector等。
3. 對於自由連結串列的初始化時特別容易錯的。
   template<bool threads, int inst>
   typename DefaultAllocTemplate<threads, inst>::obj* volatile  
           DefaultAllocTemplate<threads, inst>::FreeList[FREELISTSIZE] = { 0 };
   注意到typename了嗎。它就為了完成一個功能，到蘇編譯器DefaultAllocTemplate<threads, inst>是一個型別，不然會出現如下錯誤：

這是難以發現的錯誤，編譯器認識DefaultAllocTemplate<threads, inst>，報一個搞不懂的錯誤。