相較於vector的連續線性空間，list就顯得複雜許多，它的好處是每次插入或刪除一個元素，就配置或釋放一個元素空間。因此，list對於空間的運用有絕對的精準，一點不浪費。Vector的插入操作可能造成記憶體的重新配置，但是List不會。

         List不再能夠像vector一樣以普通指標作為迭代器，因為其節點不保證在儲存空間在連續存在。由於list是一個雙向連結串列，迭代器必須具有前移、後移的能力，所以list提供的是Bidirectional iterators。

list的實現需要以下幾個檔案：

1.      globalConstruct.h，構造和解構函式檔案，位於//cghAllocator

2.      cghAlloc.h，空間配置器檔案，位於//cghAllocator/

4.      ListIterator.h，迭代器的實現，位於//cghList/

5.      ListNode.h，list雙向連結串列的實現，位於//cghList/

6.      test_cghList.cpp，測試檔案，位於/test/

先看第一個，globalConstruct.h建構函式檔案

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  
 
[email protected]
*
*  功能:全域性構造和析構的實現程式碼
******************************************************************/



#include "stdafx.h"
#include <new.h>
#include <type_traits>

#ifndef _CGH_GLOBAL_CONSTRUCT_
#define _CGH_GLOBAL_CONSTRUCT_

namespace CGH
{
	#pragma region 統一的構造解構函式
	template<class T1, class  T2>
	inline void construct(T1* p, const T2& value)
	{
		new (p)T1(value);
	}

	template<class T>
	inline void destroy(T* pointer)
	{
		pointer->~T();
	}

	template<class ForwardIterator>
	inline void destroy(ForwardIterator first, ForwardIterator last)
	{
		// 本來在這裡要使用特性萃取機（traits程式設計技巧）判斷元素是否為non-trivial
		// non-trivial的元素可以直接釋放記憶體
		// trivial的元素要做呼叫解構函式，然後釋放記憶體
		for (; first < last; ++first)
			destroy(&*first);
	}
	#pragma endregion 
}

#endif

 

按照STL的介面規範，正確的順序是先分配記憶體然後構造元素。建構函式的實現採用placement new的方式；為了簡化起見，我直接呼叫解構函式來銷燬元素，而在考慮效率的情況下一般會先判斷元素是否為non-trivial型別。

關於 trivial 和 non-trivial 的含義，參見：stack overflow

cghAlloc.h是空間配置器檔案，空間配置器負責記憶體的申請和回收。

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  [email protected]
*
*  功能:cghAllocator空間配置器的實現程式碼
******************************************************************/

#ifndef _CGH_ALLOC_
#define _CGH_ALLOC_

#include <new>
#include <cstddef>
#include <cstdlib>
#include <climits>
#include <iostream>


namespace CGH
{
	#pragma region 記憶體分配和釋放函式、元素的構造和解構函式
	// 記憶體分配
	template<class T>
	inline T* _allocate(ptrdiff_t size, T*)
	{
		set_new_handler(0);
		T* tmp = (T*)(::operator new((size_t)(size * sizeof(T))));
		if (tmp == 0)
		{
			std::cerr << "out of memory" << std::endl;
			exit(1);
		}
		return tmp;
	}

	// 記憶體釋放
	template<class T>
	inline void _deallocate(T* buffer)
	{
		::operator delete(buffer);
	}

	// 元素構造
	template<class T1, class  T2>
	inline void _construct(T1* p, const T2& value)
	{
		new(p)T1(value);
	}

	// 元素析構
	template<class T>
	inline void _destroy(T* ptr)
	{
		ptr->~T();
	}
	#pragma endregion

	#pragma region cghAllocator空間配置器的實現
	template<class T>
	class cghAllocator
	{
	public:
		typedef T		value_type;
		typedef T*		pointer;
		typedef const T*	const_pointer;
		typedef T&		reference;
		typedef const T&	const_reference;
		typedef size_t		size_type;
		typedef ptrdiff_t	difference_type;

		template<class U>
		struct rebind
		{
			typedef cghAllocator<U> other;
		};

		static pointer allocate(size_type n, const void* hint = 0)
		{
			return _allocate((difference_type)n, (pointer)0);
		}

		static void deallocate(pointer p, size_type n)
		{
			_deallocate(p);
		}

		static void deallocate(void* p)
		{
			_deallocate(p);
		}

		void construct(pointer p, const T& value)
		{
			_construct(p, value);
		}

		void destroy(pointer p)
		{
			_destroy(p);
		}

		pointer address(reference x)
		{
			return (pointer)&x;
		}

		const_pointer const_address(const_reference x)
		{
			return (const_pointer)&x;
		}

		size_type max_size() const
		{
			return size_type(UINT_MAX / sizeof(T));
		}
	};
	#pragma endregion

	#pragma region 封裝STL標準的空間配置器介面
	template<class T, class Alloc = cghAllocator<T>>
	class simple_alloc
	{
	public:
		static T* allocate(size_t n)
		{
			return 0 == n ? 0 : (T*)Alloc::allocate(n*sizeof(T));
		}

		static T* allocate(void)
		{
			return (T*)Alloc::allocate(sizeof(T));
		}

		static void deallocate(T* p, size_t n)
		{
			if (0 != n)Alloc::deallocate(p, n*sizeof(T));
		}

		static void deallocate(void* p)
		{
			Alloc::deallocate(p);
		}
	};
	#pragma endregion
}

#endif

classcghAllocator是空間配置器類的定義，主要的四個函式的意義如下：allocate函式分配記憶體，deallocate函式釋放記憶體，construct構造元素，destroy析構元素。這四個函式最終都是通過呼叫_allocate、_deallocate、_construct、_destroy這四個行內函數實現功能。

我們自己寫的空間配置器必須封裝一層STL的標準介面，

	template<class T, class Alloc = cghAllocator<T>>
	class simple_alloc

         構造與解構函式、空間配置器是最最基本，最最底層的部件，把底層搭建好之後我們就可以著手設計list了。

         先看第一個，list的節點實現程式碼：

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  [email protected]
*
*  功能:_cghList中元素的實現程式碼
******************************************************************/

#ifndef _CGH_LIST_NODE_
#define _CGH_LIST_NODE_

namespace CGH{
	// 定義雙向連結串列節點型別
	template<typename T>
	struct __list_node
	{
		typedef void* void_pointer;
		void_pointer prev; // 指向前一個節點
		void_pointer next; // 指向後一個節點
		T data; // 節點的資料域
	};
}

#endif

         我們設計的是雙向list，每個節點包含了兩個指標，分別指向前一個節點和後一個節點，同時data代表節點的資料域。

         接下來設計list的迭代器：

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  [email protected]
*
*  功能:_cghList的迭代器的實現程式碼
******************************************************************/

#ifndef _CGH_LIST_ITERATOR_
#define _CGH_LIST_ITERATOR_

#include "ListNode.h"
#include <memory>

namespace CGH{
	template<class T, class Ref, class Ptr>
	struct __list_iterator
	{
		typedef __list_iterator<T, T&, T*>		iterator;
		typedef __list_iterator<T, Ref, Ptr>	self;

		typedef T					value_type;
		typedef Ptr					pointer;
		typedef Ref					reference;
		typedef __list_node<T>*		link_type;
		typedef size_t				size_type;
		typedef ptrdiff_t			difference_type;

		link_type node; // 聯絡迭代器和連結串列節點的紐帶

		#pragma region 建構函式

		__list_iterator(link_type x) : node(x){}
		__list_iterator(){}
		__list_iterator(const iterator& x) :node(x.node){}

		#pragma endregion

		#pragma region 迭代器的基本操作

		bool operator==(const self& x) const { return node == x.node; }
		bool operator!=(const self& x) const { return node != x.node; }
		reference operator*() const { return (*node).data; }
		reference operator->() const { return &(operator*()); }

		// 迭代器前進一個節點
		self& operator++()
		{
			node = (link_type)((*node).next);
			return *this;
		}
		self operator++(int)
		{
			self tmp = *this;
			++*this;
			return tmp;
		}

		// 迭代器遞減1，後退一個節點
		self& operator--()
		{
			node = (link_type)((*node).prev);
			return *this;
		}
		self operator--(int)
		{
			self tmp = *this;
			--*this;
			return tmp;
		}

		#pragma endregion
	};
}
#endif

         根據功能，我把迭代器劃分成了兩個region，第一個region是迭代器的建構函式，第二個region是迭代器的基礎操作，比如前進後退，判斷是否相等…。遺憾的是CSDN的程式碼編輯器不給力，網頁上不能根據region摺疊程式碼，有些童鞋看到大量程式碼會產生畏懼感，我們平時寫程式碼要注意層次，劃分region，功能分明，這樣讀起來會好很多。

         現在我們有了list節點和list迭代器，接著把節點和迭代器組合在一起，構成list：

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  [email protected]
*
*  功能:_cghList的實現程式碼
******************************************************************/

#ifndef _CGH__LIST_
#define _CGH__LIST_

#include "ListNode.h"
#include "cghAlloc.h"
#include "globalConstruct.h"
#include "ListIterator.h"

namespace CGH{
	template<class T, class Alloc = cghAllocator<T>>
	class _cghList{
	protected:
		typedef __list_node<T>				list_node;
	public:
		typedef list_node*				link_type;
		typedef size_t					size_type;
		typedef typename __list_iterator<T, T&, T*>::iterator	iterator;

	#pragma region 記憶體控制、節點構造與析構
	protected:
		link_type node; // _cghList中唯一的節點指標，指向_cghList的尾部
		typedef simple_alloc<list_node, Alloc> list_node_allocator; // 定義空間配置器
		link_type get_node(){ return list_node_allocator::allocate(); } // 申請一個節點的記憶體空間
		void put_node(link_type p){ list_node_allocator::deallocate(p); } // 釋放一個節點的記憶體空間

		/*
			建立一個節點：
			1.呼叫get_node申請節點記憶體;
			2.呼叫construct構造節點
		*/ 
		link_type create_node(const T& x)
		{
			link_type p = get_node();
			construct(&p->data, x);
			return p;
		}

		/*
			銷燬一個節點：
			1.呼叫destroy析構節點;
			2.呼叫put_node釋放記憶體
		*/
		void destroy_node(link_type p)
		{
			destroy(&p->data);
			put_node(p);
		}

	public:
		/*
			建構函式：
			呼叫empty_initialize
		*/
		_cghList(){ empty_initialize(); }
	protected:
		/*
			構造一個空連結串列：
			1.申請一個節點記憶體
			2.初始化尾節點
		*/
		void empty_initialize()
		{
			node = get_node();
			node->next = node;
			node->prev = node;
		}
	#pragma endregion 

	public:
		#pragma region 連結串列的查詢操作

		/*
			返回頭節點：
			_cghList中的node成員變數儲存了連結串列的尾指標
			連結串列的尾指標不參與運算，僅標識連結串列結尾
		*/
		iterator begin()const { return (link_type)((*node).next); }

		/*
			返回尾節點：
			_cghList中的node成員變數儲存了連結串列的尾指標
			連結串列的尾指標不參與運算，僅標識連結串列結尾
		*/
		iterator end()const{ return node; }

		/*
			判斷連結串列是否為空：
			_cghList中的node成員變數儲存了連結串列的尾指標
			連結串列的尾指標不參與運算，僅標識連結串列結尾
		*/
		bool empty() const{ return node->next == node; }

		/*
			返回連結串列長度：
			_cghList中的node成員變數儲存了連結串列的尾指標
			連結串列的尾指標不參與運算，僅標識連結串列結尾
		*/
		size_type size()	const
		{
			size_type result = 0;
			iterator first = begin();
			iterator last = end();
			while (first != last)
			{
				++first;
				++result;
			}
			return result;
		}

		#pragma endregion

		#pragma region 插入連結串列元素，包括頭插和尾插

		/*
			插入到連結串列頭部
		*/
		void push_back(const T& x){ insert(end(), x); }

		/*
			插入到連結串列尾部
		*/
		void push_front(const T& x){ insert(begin(), x); }

		/*
			執行具體的插入操作
		*/
		iterator insert(iterator position, const T& x)
		{
			link_type tmp = create_node(x);
			tmp->next = position.node;
			tmp->prev = position.node->prev;
			(link_type(position.node->prev))->next = tmp;
			position.node->prev = tmp;
			return tmp;
		}

		#pragma endregion

		#pragma region 刪除連結串列元素

		/*
			刪除指定位置的連結串列節點
		*/
		iterator erase(iterator position)
		{
			link_type next_node = link_type(position.node->next);
			link_type prev_node = link_type(position.node->prev);
			prev_node->next = next_node;
			next_node->prev = prev_node;
			destroy_node(position.node);
			return iterator(next_node);
		}

		/*
			刪除連結串列頭節點
		*/
		void pop_front(){ erase(begin()); }

		/*
			刪除連結串列尾節點
		*/
		void pop_back()
		{
			iterator tmp = end();
			erase(--tmp);
		}

		/*
			清除整個連結串列
		*/
		void clear()
		{
			link_type cur = (link_type)node->next; //拿到頭結點
			while (cur != node)
			{
				iterator tmp = cur;
				cur = (link_type)cur->next;
				destroy_node(tmp.node);
			}
			node->next = node;
			node->prev = node;
		}

		/*
			移除節點值為 value 的連結串列節點
		*/
		void remove(const T& value)
		{
			iterator first = begin();
			iterator last = end();
			while (first != last)
			{
				iterator next = first;
				++next;
				if (*first == value)erase(first);
				first = next;
			}
		}

		/*
			清除連結串列中連續存放的有相同節點值的元素
		*/
		void unique(const T& value)
		{
			iterator first = begin();
			iterator last = end();
			if (first == last)return;
			iterator next = first;
			while (++next != last)
			{
				if (*first == *next)
				{
					erase(next);
				}
				else
				{
					first = next;
				}
				next = first;
			}
		}

		#pragma endregion
	};
}

#endif

         按照功能，我把list分為了4個region：

1.      記憶體控制、節點構造與析構；

2.      連結串列的查詢操作；

3.      插入連結串列元素，包括頭插和尾插；

4.      刪除連結串列元素；

註釋寫的很詳細，只是CSDN的程式碼編輯器太渣，網頁上不能根據region摺疊程式碼，有些童鞋看到大量程式碼會產生畏懼感，list的結構我截圖如下：

最後我們測試一下_cghList，測試程式碼如下：

/*******************************************************************
*  Copyright(c) 2016 Chen Gonghao
*  All rights reserved.
*
*  [email protected]
*
*  檔名稱:_cghList的測試程式碼
******************************************************************/

#include "stdafx.h"
#include "cghAlloc.h"
#include "globalConstruct.h"
#include "_cghList.h"
using namespace::std;

int _tmain(int argc, _TCHAR* argv[])
{
	using namespace::CGH;

	_cghList<int> list;
	int i = 0;
	list.push_back(1); // 在list尾部插入1
	list.push_back(2); // 在list尾部插入2
	list.push_back(2); // 在list尾部插入2
	list.push_back(2); // 在list尾部插入2
	list.push_front(3); // 在list頭部插入1

	std::cout << "-----------------插入元素----------------" << endl;
	std::cout << "在list尾部依次插入1、2、2、2，在list頭部插入3" << endl;
	// 取得list的長度
	std::cout << "list的長度：" << list.size() << endl;
	// 遍歷list
	for (_cghList<int>::iterator iter = list.begin(); iter != list.end(); iter++)
	{
		std::cout << "第" << i << "個元素：" << *iter << endl;
		i++;
	}

	std::cout << endl << endl << "-----------------值保留一個值等於2的元素----------------" << endl;
	// 值保留一個值等於2的元素
	list.unique(2);
	// 取得list的長度
	std::cout << "list的長度：" << list.size() << endl;
	// 遍歷list
	i = 0;
	for (_cghList<int>::iterator iter = list.begin(); iter != list.end(); iter++)
	{
		std::cout << "第" << i << "個元素：" << *iter << endl;
		i++;
	}

	std::cout << endl << endl << "-----------------刪除值等於2的元素----------------" << endl;
	list.remove(2);// 刪除值等於2的元素
	// 取得list的長度
	std::cout << "list的長度：" << list.size() << endl;
	// 遍歷list
	i = 0;
	for (_cghList<int>::iterator iter = list.begin(); iter != list.end(); iter++)
	{
		std::cout << "第" << i << "個元素：" << *iter << endl;
		i++;
	}

	std::cout << endl << endl << "-----------------清空list----------------" << endl;
	list.clear(); // 清空
	// 取得list的長度
	std::cout << "list的長度：" << list.size() << endl;
	// 遍歷list
	i = 0;
	for (_cghList<int>::iterator iter = list.begin(); iter != list.end(); iter++)
	{
		std::cout << "第" << i << "個元素：" << *iter << endl;
		i++;
	}

	system("pause");
	return 0;
}