初步了解list容器

一、list的介绍
1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素。
二、list的使用

1.list的接口：

接口名	接口功能
begin	返回第一个元素的迭代器
end	返回最后一个元素下一个位置的迭代器
rbegin	返回第一个元素的reverse_iterator,即end位置
rend	返回最后一个元素下一个位置的reverse_iterator,即begin位置
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中的所有元素

2.关于list的迭代器失效问题：
这个问题跟vector的迭代器失效很像，但list在插入的时候不会造成迭代器失效问题，而在删除一个节点的时候就会出现这个问题，这是由于在删除之后这个节点不存在内存中，迭代器无法访问到这里
三、模拟实现list容器

namespace bite
{

	template<class T>
	struct ListNode
	{
		ListNode(const T& val = T())
		: _pPre(nullptr)
		, _pNext(nullptr)
		, _val(val)
		{}
		ListNode<T>* _pPre;
		ListNode<T>* _pNext;
		T _val;
	};
	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()
		{
			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();

			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;
		}

		// List Iterator
		iterator begin(){ return iterator(_pHead->_pNext); }
		iterator end(){ return iterator(_pHead); }
		const_iterator begin(){ return const_iterator(_pHead->_pNext); }
		const_iterator end(){ return const_iterator(_pHead); }

		// List Capacity
		size_t size()const;
		bool empty()const;

		// List Access
		T& front();
		const T& front()const;
		T& back();
		const T& back()const;
		
		// List Modify
		void push_back(const T& val){ insert(begin(), val); }
		void pop_back(){ erase(--end()); }
		void push_front(const T& val){ insert(begin(), val); }
		void pop_front(){ erase(begin()); }
		// 在pos位置前插入值为val的节点
		iterator insert(iterator pos, const T& val)
		{
			PNode pNewNode = new Node(val);
			PNode pCur = pos._pNode;
			// 先将新节点插入
			pNewNode->_pPre = pCur->_pPre;
			pNewNode->_pNext = pCur;
			pNewNode->_pPre->_pNext = pNewNode;
			pCur->_pPre = pNewNode;
			return iterator(pNewNode);
		}
		// 删除pos位置的节点，返回该节点的下一个位置
		iterator erase(iterator pos)
		{
			// 找到待删除的节点
			PNode pDel = pos._pNode;
			PNode pRet = pDel->_pNext;
			// 将该节点从链表中拆下来并删除
			pDel->_pPre->_pNext = pDel->_pNext;
			pDel->_pNext->_pPre = pDel->_pPre;
			delete pDel;
			return iterator(pRet);
		}
		void clear();
		void swap(List<T>& l);
	private:
		void CreateHead()
		{
			_pHead = new Node;
			_pHead->_pPre = _pHead;
			_pHead->_pNext = _pHead;
		}
	private:
		PNode _pHead;
	};
}