【STL】list

list相关文档：
http://www.cplusplus.com/reference/list/list/?kw=list

一、使用

  list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

构造函数（constructor）	说明
list()	构造空的list
list (size_type n, const value_type& val = value_type())	构造的list中包含n个值为val的元素
list (const list& x)	拷贝构造函数
list (InputIterator first, InputIterator last)	用[first, last)区间中的元素构造list

list iterator

函数	说明
begin + end	返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代
rbegin + rend	返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置

下面代码是，反向迭代器，反向打印，反向迭代器遍历仍然是++

template<class T>
void printListIterator(const list<T>& l) {
	auto lit = l.rbegin();
	while (lit != l.rend()) {
		cout << *lit << " ";
		++lit;
	}
	cout << endl;
}

函数	说明
empty	检测list是否为空，是返回true，否则返回false
size	返回list中有效节点的个数
front	返回list的第一个节点中值的引用
back	返回list的最后一个节点中值的引用
push_front	在list首元素前插入值为val的元素
pop_front	删除list中第一个元素
push_back	在list尾部插入值为val的元素
pop_back	删除list中最后一个元素
insert	在list position 位置中插入值为val的元素
erase	删除list position位置的元素
swap	交换两个list中的元素
clear	清空list中的有效元素
emplace_back	在末尾构造并插入元素
spice	将元素从参数的list转移到本list
unique	删除重复值
merge	合并排序列表

注意：

1. unique使用的前提一定是该链表已经有序，merge使用的前提一定是两个链表都有序。
2. spice和merge函数掉用后，作为这两个函数参数的两个list都将被清空。

※迭代器失效

  此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行 插入时是不会导致list的迭代器失效的， 只有在删除时才会失效 ，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

二、模拟list

结点类

// List的节点类
template<class T>
struct ListNode {
	ListNode(const T& val = T())
		: _pPre(nullptr)
		, _pNext(nullptr)
		, _val(val) {}
	ListNode<T>* _pPre;
	ListNode<T>* _pNext;
	T _val;
};

List 的迭代器
迭代器有两种实现方式，具体应根据容器底层数据结构实现：

1. 原生态指针，比如：vector
2. 将原生态指针进行封装，因迭代器使用形式与指针完全相同，因此在自定义的类中必须实现以下方法：
   1. 指针可以解引用，迭代器的类中必须重载operator*()
   2. 指针可以通过->访问其所指空间成员，迭代器类中必须重载oprator->()
   3. 指针可以++向后移动，迭代器类中必须重载operator++()与operator++(int)
      至于operator–()/operator–(int)释放需要重载，根据具体的结构来抉择，双向链表可以向前
      移动，所以需要重载，如果是forward_list就不需要重载–
   4. 迭代器需要进行是否相等的比较，因此还需要重载operator==()与operator!=()

template<class T, class Ref, class Ptr>
class ListIterator {
	typedef ListNode<T>* PNode;
	typedef ListIterator<T, Ref, Ptr> Self;
public:
	ListIterator(PNode pNode = nullptr) : _pNode(pNode) {}
	ListIterator(const Self& l)
		: _pNode(l._pNode) {}
	T& operator*() {return _pNode->_val;}
	T* operator->() {return &(operator*());}
	Self& operator++() {
		_pNode = _pNode->_pNext;
		return *this;
	}
	Self operator++(int) {
		Self temp(*this);
		_pNode = _pNode->_pNext;
		return temp;
	}
	Self& operator--();
	Self& operator--(int);
	bool operator!=(const Self& l) {return _pNode != l._pNode;}
	bool operator==(const Self& l) {return _pNode != l._pNode;}
	
	PNode _pNode;
};

注：以下代码并没有写全，利用到了代码复用，如果读者有兴趣可以具体实现，

template<class T>
class list {
	typedef ListNode<T> Node;
	typedef Node* PNode;
public:
	typedef ListIterator<T, T&, T*> iterator;
	typedef ListIterator<T, const T&, const T&> const_iterator;
public:
	// List的构造
	list() {
		CreateHead();
	}
	list(int n, const T& value = T()) {
		CreateHead();
		for (int i = 0; i < n; ++i)
			push_back(value);
	}
	template <class Iterator>
	list(Iterator first, Iterator last) {
		CreateHead();
		while (first != last) {
			push_back(*first);
			++first;
		}
	}
	list(const list<T>& l) {
		CreateHead();
		// 用l中的元素构造临时的temp,然后与当前对象交换
		list<T> temp(l.cbegin(), l.cend());
		this->swap(temp);
	}
	list<T>& operator=(const list<T> l) {
		this->swap(l);
		return *this;
	}
	~list() {
		clear();
		delete _pHead;
		_pHead = nullptr;
	}
		……
		……
private:
	void CreateHead() {
		_pHead = new Node;
		_pHead->_pPre = _pHead;
		_pHead->_pNext = _pHead;
	}
private:
	PNode _pHead;
};