STL源码剖析---list

      相较于vector的连续线性空间，list就显得复杂许多，它的好处是每次插入或删除一个元素，就配置或释放一个元素空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素移除，list永远是常数时间。
      list不仅是一个双向链表，而且还是一个环状双向链表。另外，还有一个重要性质，插入操作和接合操作都不会造成原有的list迭代器失效，这在vector是不成立的。因为vector的插入操作可能造成记忆体重新配置，导致原有的迭代器全部失效。甚至list的元素删除操作（erase），也只有“指向被删除元素”的那个迭代器失效，其他迭代器不受任何影响。
以下是list的节点、迭代器数据结构设计以及list的源码剖析：

// list结点, 提供双向访问能力

//  --------           --------           --------           --------
//  | next |---------->| next |---------->| next |---------->| next |
//  --------           --------           --------           --------
//  | prev |<----------| prev |<----------| prev |<----------| prev |
//  --------           --------           --------           --------
//  | data |           | data |           | data |           | data |
//  --------           --------           --------           --------


template <class T>
struct __list_node
{
	typedef void* void_pointer;
	void_pointer next;
	void_pointer prev;
	T data;
};

// 至于为什么不使用默认参数, 这个是因为有一些编译器不能提供推导能力,
// 而作者又不想维护两份代码, 故不使用默认参数
template<class T, class Ref, class Ptr>
struct __list_iterator
{
	typedef __list_iterator<T, T&, T*>             iterator;   // STL标准强制要求
	typedef __list_iterator<T, Ref, Ptr>           self;

	typedef bidirectional_iterator_tag iterator_category;
	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;   //迭代器内部当然要有一个普通指针，指向list的节点

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

	// 在STL算法中需要迭代器提供支持
	bool operator==(const self& x) const { return node == x.node; }
	bool operator!=(const self& x) const { return node != x.node; }

	// 以下对迭代器取值（dereference）,取的是节点的数据值
	reference operator*() const { return (*node).data; }

	// 以下是迭代器的成员存取运算子的标准做法
	pointer operator->() const { return &(operator*()); }

	// 前缀自加，对迭代器累加1，就是前进一个节点
	self& operator++()
	{
		node = (link_type)((*node).next);
		return *this;
	}

	// 后缀自加, 需要先产生自身的一个副本, 然会再对自身操作, 最后返回副本
	self operator++(int)
	{
		self tmp = *this;
		++*this;
		return tmp;
	}

	// 前缀自减
	self& operator--()
	{
		node = (link_type)((*node).prev);
		return *this;
	}

	self operator--(int)
	{
		self tmp = *this;
		--*this;
		return tmp;
	}
};


// list不仅是个双向链表, 而且还是一个环状双向链表

//       end()              头结点             begin()
//         ↓                  ↓                  ↓
//      --------           ----