List容器是STL最基础也是最常用的两大容器之一。相比于vector来说，List在设计上与其有巨大差异，首先是内部结构，List在其内部维护一个环形链表的头节点(在概念上并不属于链表中的一节)；其次是迭代器设计，List的迭代器实现在链表中的移动操作，也就是递增时上一个节点、递减时指向下一个节点，而不是单纯的指针值(地址)的加减；还有List以链表节点存储元素的单元，而不是数组，这也导致了List在内存分配上的精准性。总而言之，List与Vector等其他容器有着完全不同的特性。(对于链表的概念，在此不做多余叙述)。
我们依旧从不同角度将List解剖，逐个击破。List实现主要体现在以下几个点：
1.迭代器操作
2.内存操作
3.元素操作
在认识List迭代器之前我们先认识List的节点：
class _list_node
{
public:
_list_node<T>* next;
_list_node<T>* prev;
T data;
};List节点实际上是只是一个普通的链表节点。但我们要清楚一个概念，我们应将链表结点视作vector中数组中的一个节点，也就是链表的首节点相当于a[0] (start)。他们都是容器存储元素的单元，而迭代器的实现就是建立于这些单元之上。
那我们如何在List中维护一个链表呢？我们在Vector中使用了三个表示界限的指针来勾勒出了一个数组的轮廓，由此可以想到，我们也可以使用某个具有代表性的节点的指针来表示一个链表，其余的节点都可以通过它到达。最容易想到的是维护一个首节点的指针，但我们还有另外一个难题，我们如何满足STL规范中的前闭后开区间的要求？
因为我们的链表是一个环形链表，所以可以选择在尾节点之后(同时也是首节点之前)放置一个空节点作为缓冲，即可满足最后一个元素之后为无意义空间的要求。
解决了链表结构问题后，我们将视线转回迭代器上来。List迭代器需要单独设计，不仅因为其移动操作的独特性，还因为对元素进行的取值(*)、存取(->)等操作也通过迭代器进行，而这些都因元素存储单元的独特性而需特别设计。
下面是迭代器的实现：
//list迭代器
template <typename T, typename Ref, typename Ptr>
class _list_iterator
{
friend class stl_list < T, alloc > ;
typedef _list_iterator<T, T&, T*> iterator;
typedef _list_iterator<T, Ref, Ptr> self;
typedef stl_bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr Pointer;
typedef const Ptr const_Pointer;
typedef Ref Reference;
typedef const Ref const_Reference;
typedef ptrdiff_t Distance;
typedef _list_node<T>* link_type;
typedef size_t size_type;
protected:
link_type node;//内部维护一个指向节点的指针
public:
_list_iterator(){}
_list_iterator(link_type lint) :node(lint){}
_list_iterator(const _list_iterator& rhs) :node(rhs.node){}
//使用合成的copy assignment
bool operator==(const self& rhs)const{ return node == rhs.node; }
bool operator!=(const self& rhs)const{ return !(*this == rhs); }
//元素取值、成员存取操作
Reference operator*(){ return (*node).data; }
const_Reference operator*()const { return (*node).data; }
Pointer operator->(){ return &(operator*()); }
const_Pointer operator->()const{ return &(operator*()); }
//迭代器移动操作
self& operator++()
{
node = node->next;
return *this;
}
self operator++(int)
{
self temp = *this;
++*this;
return temp;
}
self& operator--()
{
node = node->prev;
return *this;
}
self operator--(int)
{
self temp = *this;
--*this;
return temp;
}
};List迭代器内部维护一个指向节点的指针，在构造操作中将为指针设定初值。其余操作围绕这个指针来进行。
下面进入到内存配置环节。List内存操作分为：
1.节点空间的配置与释放
2.节点的创建与移除
3.链表的初始化
protected:
link_type get_node(){ return list_node_allocator::allocate(); } //在内存中分配一个节点大小的空间
void put_node(link_type p){ return list_node_allocator::deallocate(p); } //释放节点空间
link_type create_node(const T& ); //创建节点（get_node+构造节点中元素）
void empty_initialize();//初始化链表
void destroy_node(link_type );//移除一个节点（元素的析构+put_node）
节点空间的配置与释放我们直接用STL通用的空间配置器完成，其主要为创建与移除节点服务。
创建一个节点分为两步：配置空间+构造节点中的元素。类似的，移除一个节点也分为两步：元素的析构+释放空间
template <typename T, typename Alloc>
typename stl_list<T, Alloc>::link_type stl_list<T, Alloc>::create_node(const T& value)
{
link_type p = get_node();
construct(&p->data, value);
return p;
}
template <typename T, typename Alloc>
void stl_list<T, Alloc>::destroy_node(link_type p)
{
destroy(&(p->data));
put_node(p);
}
链表的初始化也分为两步：为特殊的尾后空节点分配一个空间+设置指针使链表成为空链表
template <typename T,typename Alloc>
void stl_list<T, Alloc>::empty_initialize()
{
node = get_node();
node->next = node;
node->prev = node;
}将node的前向、后向指针全部指向自己，这样就满足了空链表的验证条件：
iterator begin(){ return (*node).next; }
iterator end(){ return node; }
bool empty(){ return node->next == node; }
这里要特殊说下size()操作，如果容器使用的是RandomAccessIterator(随机存取迭代器)，那我们可以简单的用finish-start来完成。但List使用的是:
typedef stl_bidirectional_iterator_tag iterator_category;那这就很尴尬了，因为我们不能使用随机迭代器所特有的加减操作计算距离。我们只能通过遍历来记录大小，但是对于一个size()操作使用复杂度为N的实现很浪费。尤其是容器的大小也是其他复杂操作经常使用的一个值，这样会很隐蔽的增加了其余操作的时间。
所以我们再List中为维护一个标志大小的数据成员：
protected:
size_type mysize=0;并设其默认值为0，这样虽增加了类的大小，但与通过遍历来知道一个大小信息来说，这太微不足道了。我们只需在一些改变链表大小的操作之后记得更新它就好了。
List内部链表可以带来一个其他容器所不容易实现的操作：接合。
所谓接合，就是将一段链表插入到另一端链表的内部。这个操作在有些容器那里(如vector、deque)，将是个打代码量的工作，且时间复杂度还很糟糕。但对于链表来说，由于其特殊的元素之间的连接方式，则很容易实现一个(一些元素)放到另一些元素之间的操作，并且复杂度为O(1)。下面为接合操作的实现：
template <typename T,typename Alloc>
void stl_list<T, Alloc>::transfer(iterator position, iterator first, iterator last)
{
if (position != last)
{
(first.node->prev)->next = last.node;
(last.node->prev)->next = position.node;
(position.node->prev)->next = first.node;
link_type temp = position.node->prev;
position.node->prev = last.node->prev;
last.node->prev = first.node->prev;
first.node->prev = temp;
}
}
对于指针之间的操作，光看代码很容易混乱，建议大家画一下图，就会发现实际上很简单。(写类似代码时也是一样)
我们将接合操作扩展一下，就可以实现很多其他更通用的操作：
template <typename T, typename Alloc>
typename stl_list<T, Alloc>::iterator stl_list<T, Alloc>::insert(iterator position, const T& value)
{
link_type temp = create_node(value);
temp->next = position.node;
temp->prev = position.node->prev;
(link_type(position.node->prev))->next = temp;
position.node->prev = temp;
++mysize;
return temp;
}
template<typename T, typename Alloc>
typename stl_list<T, Alloc>::iterator stl_list<T, Alloc>::erase(iterator position)
{
link_type prev_node = position.node->prev;
link_type next_node = position.node->next;
prev_node->next = position.node->next;
next_node->prev = prev_node;
destroy_node(position.node);
--mysize;
return iterator(next_node);//返回被移除元素的下一个元素
}
template <typename T, typename Alloc>
void stl_list<T, Alloc>::remove(const T& value)
{//清除所有相邻且值相同的元素，在对链表排序之后可使用
iterator first = begin();
iterator last = end();
while (first != last)
{//因为有可能清除first指向的对象，所以保存first->next的信息
iterator temp = first.node->next;
if (*first == value)
erase(first);
first = temp;
}
}
template <typename T, typename Alloc>
void stl_list<T, Alloc>::splice(iterator position, stl_list<T, Alloc>& rhs)
{//将rhs中的所有元素放置到position之前
if (!rhs.empty())
transfer(position, rhs.begin(), rhs.end());
mysize += rhs.mysize;
rhs.mysize = 0;
}
template <typename T, typename Alloc>
void stl_list<T, Alloc>::splice(iterator position, stl_list<T, Alloc>& rhs, iterator first, iterator last)
{//将rhs中的first到last之间的元素放到position之前
if (this != &rhs)
{
if (first == rhs.begin() && last == rhs.end())
mysize += rhs.mysize;
else
mysize += count(first, last);
}
if (first != last)
transfer(position, first, last);
}
template <typename T, typename Alloc>
void stl_list<T, Alloc>::splice(iterator position, iterator i)
{//将i放到position之前
iterator j = i;
++j;
if (position == j || position == i)
return;
transfer(position, i, j);
++mysize;
}注意，transfer操作为剪贴性质。
以上就是List最特殊的操作，其他常规操作下面一并贴出：
iterator begin(){ return (*node).next; }
iterator end(){ return node; }
bool empty(){ return node->next == node; }
void push_back(const T& value){ insert(end(), value); }
void push_front(const T& value){ insert(begin(), value); }
void pop_back();
void pop_front(){ erase(begin()); };
void clear();
template <typename T, typename Alloc>
void stl_list<T, Alloc>::pop_back()
{
iterator temp = end();
erase(--temp);
}
template <typename T, typename Alloc>
void stl_list<T, Alloc>::clear()
{
iterator cur = begin();
iterator temp;
while (cur != node)
{
temp = cur;
cur = cur.node->next;
destroy_node(temp);
}
node->next = node;
node->prev = node;
mysize = 0;
}
