说明：本文仅供学习交流，转载请标明出处，欢迎转载！

        list的底层采用数据结构是环形的双向链表， 相对于vector容器，list容器插入和删除操作付出的代价要比vector容器小得多，但是list带有链表的天生弱点，就是不支持随机访问。从内置的迭代器角度分析，vector容器对应的迭代器为随机访问迭代器，而list容器内置的迭代器则为双向迭代器。

        我们也知道，STL中提供的很多算法都是基于随机访问迭代器的，如sort(b,e)函数，其所使用的迭代器就是随机访问迭代器，所以，list不能使用这类算法函数。为此，STL又在list容器中内置了其特有的算法，这些算法都是根据list容器的特点定身制造的。

        所以，要设计一个list容器，我们需要考虑这些问题：

        （1）结点设计。学过数据结构的都知道，链表就是将一个一个 的结点通过指针链接起来，结点是构成链表的元素。所以首先得考虑双链表结点的设计，对应的设计代码框架如下：

<pre name="code" class="cpp">/********底层结点的定义**********/
template<class T>
struct _list_node
{
	typedef _list_node<T> node_type;//指向本类结点的指针
	node_type *pre;//前驱指针
	node_type *next;//后继指针
	T data;
};

       （2）迭代器的设计。由于list容器对应的迭代器是双向迭代器，既然是双向迭代器，我们就必须为该迭代器提供++、--操作。而又由于链表并不一定是连续的空间分配，所以不能直接对原生的指针做++、--的操作，而应该利用迭代器对原生指针做封装，然后对迭代器重载++、--的操作，其中迭代器的++对应原生指针的p=p->next，迭代器的--则对应原生指针的p=p->pre。

/*******list迭代器的定义**********/
template<class T,class Ref=T &, class Ptr=T*>
struct _list_iterator
{
    typedef _list_node<T>* link_type;//指向底层结点的指针类型
	link_type p;//p表示一个原生指针，迭代器是一个智能指针，是对p的一个包装


	/******下面定义迭代器的一个常用属性*******/
	typedef T value_type;//元素类型
	typedef Ptr pointer;//指针类型
	typedef Ref reference;//引用类型
	typedef ptrdiff_t difference_type;//指针差值类型
	typedef bidirectional_iterator_tag iterator_category;//标记类型，属于双向迭代器，不支持随机访问
	typedef size_t size_type;//大小类型


	/******下面定义一个智能指针的常用操作**********/
	typedef _list_iterator<T,T&,T*> iterator_type;//名字太长了，给迭代器类定义一个别名


	_list_iterator(){}//无参构造函数
	_list_iterator(link_type p1):p(p1){};//单形参构造函数，参数为原生指针
	_list_iterator(const iterator_type & iter):p(iter.p){};//复制构造函数 
    
	bool operator==(iterator_type& iter)const;//判断两个迭代器的原生指针是否相等,即this->p是否等于iter.p
	bool operator!=(iterator_type& iter)const;//跟上相反
	
	reference operator*()const;//解引用,返回p->data
	pointer operator->()const;//箭头操作符，返回&(p->data)


	/******下面定义作为一个双向容器的应有操作********/
	iterator_type operator++();//定义++前置操作,++iter
	iterator_type operator++(int);//定义++后置操作，iter--
	iterator_type operator--();//定义--前置操作，--iter
	iterator_type operator--(int);//定义--后置操作，iter--
};

       （3）list容器的设计。list容器除了内部封装一个特殊的迭代器外，还需要提供一些特定算法，因为list容器的对象很多STL提供的算法都不能使用，所以需要其自身提供封装好相应的函数。

/***************list容器的定义*************************/
template<class T,class Alloc=alloc>
class list
{
	protected:
		typedef _list_node<T> node_type;//定义底层结点类型别名
		typedef _list_node<T>* link_type;//连接底层结点的指针类型别名
		typedef simple_alloc<Node_type,Alloc> node_allocator;//定义结点空间分配器类
		Node_type empty_Node;//定义一个带空节点值的结点
		void init();//创建一个空环形双向链表
	public:
		/**************定义公有访问属性****************/
		typedef T value_type;//底层结点内含的data所对应的数据类型
		typedef value_type* pointer;//指针类型
		typedef value_type& reference;//引用类型
		typedef ptrdiff_t difference_type;//迭代器差值类型
		typedef size_t size_type;//大小类型
		typedef _list_iterator<T,T&,T*> iterator;//迭代器类型
		typedef const iterator const_iterator;//指向常量的迭代器类型 

		/*************构造函数/析构函数**************/
		list();//无参构造函数，仅调用init()来初始化链表
		list(InputIterator b,InputIterator e);//用[b,e)去初始化容器
		list(size_type n);//创建一个含有n个元素的容器
		list(size_type n,const T &t);//用n个值为t的元素去创建容器
		~list();//析构函数

		/*************插入操作********************/
		void push_back(const T & t);//后插入
		void push_front(const T & t);//前插入
		iterator insert(interator iter,const T &t);//在iter前插入值t的元素，返回新添加元素的迭代器
		void insert(iterator iter,size_type n,const T &t);//在iter前插入n个值为t的元素
		void insert(iterator iter,iterator b,iterator e);//在iter前插入[b,e)范围的元素

		/***********删除操作*********************/
		iterator erase(iterator iter);//删除iter所指向的元素，返回所删除元素的下一个元素对应的迭代器
		iterator erase(iterator b,iterator e);//删除[b,e)范围内的元素，返回原先e
		void clear();//删除容器内的所有元素
		void pop_back();//删除容器内最后一个有效的元素
		void pop_front();//删除容器内第一个有效的元素

		/***********大小操作*********************/
		size_type size()const;//返回容器内元素的个数
		size_type max_size()const;//返回容器可容纳的最多元素的个数
		bool empty()const;//判断容器是否为空
		void resize(size_type n);//将容器的大小设置为n
		void resize(size_type n,T t);//将容器的大小设置为n，若需要需要新添加新的元素之，则其值为t

		/***********访问操作*******************/
		iterator begin();//返回头指针
		iterator end();//返回末端元素的下一个位置
		iterator rbegin();//返回最后一个元素
		iterator rend();//返回头指针的前一个位置
		reference front();//返回第一个元素的引用
		reference back();//返回最后一个元素的引用

		/**********list特有的算法操作************/
		void remove(const T& t);//删除之为t的元素
		void remove_if(bool preFun);//将满足特定条件的值删除
		void unique();//将容器中重复的元素删除，只留下第一次出现的那个元素集
		void unique(bool preFun);//将满足条件的重复值删除
		void reverse();//将容器的元素逆转，通过依次将尾部的元素剪切插入到首部
		void sort();//将容器内的元素排序，内部是采用归并排序
		/////使用merge函数必须保证连个list是有序的，否则会运行时出错，默认为升序，也可以自己定义降序///////////////
		typedef list<T,alloc> List;//定义本类的类型别名，太长了
		void merge(List &list2);//将list2中的元素剪切后再归并待本链表,升序
		void merge(List &list2,int cmp);//将list归并到本链表,cmp指定排序方式
		void splice(iterator iter,List list2);//将list2的元素剪切到本链表中的iter之前，注意：list2不同于*this
		void splice (iterator iter,List & list2,iterator iter2);//将list2中iter2指向的那一个元素（只有1个哈）剪切到本链表的iter之前，list2可以等于*this
		void splice(iterator iter,List & list2,iterator b,iterator e);//将list2中的[b,e)内的元素剪切到本链表的iter之前，list可以等于*this 
};

        上面的代码中，指的一提是sort函数，该sort函数采用的是归并排序的非递归算法，还有就是reverse函数，reverse函数的实现思路是将原链表中的结点从头到尾依次剪切到头部，这样就可以将链表逆转。

参考文献

[1]《C++primer 第4版》

[2]《STL源码剖析 侯捷》