list

• list的介绍及使用
• list的深度剖析及模拟实现
• vector和list的对比

1.list的介绍及使用
1.1 list的介绍

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

1.2 list的使用
1.2.1 list的构造

1.2.2 list iterator的使用
此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。

注意：

iterator和 const_iterator唯一不同的地方在于：操作符* 和->返回值不同
iterator的* 和->操作都是可读可写的操作，返回值不加const
const_iterator的* 和->操作只是可读的操作，返回值加const
反向和正向迭代器的唯一区别在于++和- -
反向迭代器的–类似于正向迭代器的++
正向迭代器的++类似于反向迭代器的- -

1.2.3 list capacity

1.2.4 list element access

1.2.5 list modifiers

1.2.6 list的迭代器失效

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

list的迭代器失效是因为在进行erase()之后,节点被释放，但是当前迭代器还是指向该节点，node 节点已经被释放，node->next和node->prev都指向一块随机地址，我们也成为野指针，是不允许访问的。但是在循环中进行++操作时，其实是执行了node=node->next，访问非法地址，程序会崩掉。

代码实现：

void TestListIterator1()
{
 int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list l(array, array+sizeof(array)/sizeof(array[0]));
auto it = l.begin();
while (it != l.end())
{
 // erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给其赋
值
 l.erase(it); 
 ++it;
}
}
// 改正
void TestListIterator()
{
 int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list l(array, array+sizeof(array)/sizeof(array[0]));
auto it = l.begin();
while (it != l.end())
{
 l.erase(it++); // it = l.erase(it);
}
}

2. list的模拟实现

#include 
using namespace std;

// List的节点类
template
struct ListNode
{
	ListNode(const T& val = T())
	: _pPre(nullptr)
	, _pNext(nullptr)
	, _val(val)
	{}
	ListNode* _pPre;
	ListNode* _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 ListIterator
{
	typedef ListNode* PNode;
	typedef ListIterator 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;
	}
	bool operator!=(const Self& l)
	{
		return _pNode != l._pNode;
	}
	bool operator==(const Self& l)
	{
		return _pNode != l._pNode;
	}
	PNode _pNode;
};

/*
List 的反向迭代器，反向迭代器与正向迭代器刚好是相反的，反向迭代器++，迭代器往前移动，反向迭代
器--， 迭代器往后移动，因此反向迭代器可以在正向迭代器的基础之上来实现
*/
template
class ListReverseIterator
{
	typedef ListReverseIterator Self;
public:
	ListReverseIterator(const Iterator& it)
		: _it(it)
	{}
	ListReverseIterator(const Self& s)
		: _it(s._it)
	{}
	Ref operator*()
	{
		Iterator temp = _it;
		return *(--temp);
	}
	Ptr operator->()
	{
		return &operator*();
	}
	// 反向迭代器的++，就是正向迭代器的--
	Self& operator++()
	{
		--_it;
		return *this;
	}
	Self operator++(int)
	{
		Iterator temp(_it);
		--_it;
		return temp;
	}
	// 反向迭代器的--，就是正向迭代器的++
	Self& operator--()
	{
		++_it;
		return *this;
	}
	Self operator--(int)
	{
		Iterator temp(_it);
		++_it;
		return temp;
	}
	bool operator!=(const Self& s)
	{
		return _it != s._it;
	}
	bool operator==(const Self& s)
	{
		return _it == s._it;
	}

private:
	Iterator _it;
};
template
class List
{
	typedef ListNode Node;
	typedef Node* PNode;
public:
	typedef ListIterator Iterator;
	typedef ListIterator ConstIterator;
	typedef ListReverseIterator ReverseIterator;
	typedef ListReverseIterator
		ConstReverseIterator;
public:
	///////////////////////////////////////////////////////////////
	// List的构造
	List()
	{
		CreateHead();
	}
	List(int n, const T& value = T())
	{
		CreateHead();
		for (int i = 0; i < n; ++i)
			PushBack(value);
	}
	template 
	List(Iterator first, Iterator last)
	{
		CreateHead();
		while (first != last)
		{
			PushBack(*first);
			++first;
		}
	}
	List(const List& l)
	{
		CreateHead();
		// 用l中的元素构造临时的temp,然后与当前对象交换
		List temp(l.CBegin(), l.CEnd());
		this->Swap(temp);
	}
	List& operator=(const List& l)
	{
		if (this != &l)
		{
			List temp(l);
			this->Swap(temp);
		}
		return *this;
	}
	~List()
	{
		Clear();
		delete _pHead;
		_pHead = nullptr;
	}
	///////////////////////////////////////////////////////////////
	// List Iterator
	Iterator Begin()
	{
		return Iterator(_pHead->_pNext);
	}
	Iterator End()
	{
		return Iterator(_pHead);
	}
	ReverseIterator RBegin()
	{
		return ReverseIterator(End());
	}
	ReverseIterator REnd()
	{
		return ReverseIterator(Begin());
	}
	ConstIterator CBegin()const
	{
		return ConstIterator(_pHead->_pNext);
	}
	ConstIterator CEnd()const
	{
		return ConstIterator(_pHead);
	}
	ConstReverseIterator CRBegin()const
	{
		return ConstReverseIterator(CEnd());
	}
	ConstReverseIterator CREnd()const
	{
		return ConstReverseIterator(CBegin());
	}
	///////////////////////////////////////////////////////////////
	// List Capacity
	size_t Size()const
	{
		size_t count = 0;
		PNode pCur = _pHead->_pNext;
		while (pCur != _pHead)
		{
			++count;
			pCur = pCur->_pNext;
		}
		return count;
	}
	bool Empty()const
	{
		return _pHead->_pNext == _pHead;
	}
	void ReSize(size_t newSize, const T& val = T())
	{
		size_t oldSize = Size();
		if (oldSize <= newSize)
		{
			for (size_t i = oldSize; i < newSize; ++i)
				PushBack(val);
		}
		else
		{
			for (size_t i = newSize; i < oldSize; ++i)
				PopBack();
		}
	}
	////////////////////////////////////////////////////////////
	// List Access
	T& Front()
	{
		return _pHead->_pNext->_val;
	}
	const T& Front()const
	{
		return _pHead->_pNext->_val;
	}
	T& Back()
	{
		return _pHead->_pPre->_val;
	}
	const T& Back()const
	{
		return _pHead->_pPre->_val;
	}
	////////////////////////////////////////////////////////////
	// List Modify
	void PushBack(const T& val)
	{
		PNode pNewNode = new Node(val);
		// 先把新节点尾插进去
		pNewNode->_pNext = _pHead;
		pNewNode->_pPre = _pHead->_pPre;
		// 再链接剩余两个指针
		_pHead->_pPre = pNewNode;
		pNewNode->_pPre->_pNext = pNewNode;
	}
	// 尾删
	void PopBack()
	{
		// 找到待删除节点
		PNode pDel = _pHead->_pPre;
		if (pDel != _pHead)
		{
			_pHead->_pPre = pDel->_pPre;
			pDel->_pPre->_pNext = _pHead;
			delete pDel;
		}
	}
	// 头插
	void PushFront(const T& val)
	{
		PNode pNewNode = new Node(val);
		// 先把新节点尾插进去
		pNewNode->_pNext = _pHead->_pNext;
		pNewNode->_pPre = _pHead;
		// 再链接剩余两个指针
		_pHead->_pNext = pNewNode;
		pNewNode->_pNext->_pPre = pNewNode;
	}
	// 头删
	void PopFront()
	{
		// 找到待删除节点
		PNode pDel = _pHead->_pNext;
		if (pDel != _pHead)
		{
			_pHead->_pNext = pDel->_pNext;
			pDel->_pNext->_pPre = _pHead;
			delete pDel;
		}
	}
	// 在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()
	{
		PNode pCur = _pHead->_pNext;
		while (pCur != _pHead)
		{
			_pHead->_pNext = pCur->_pNext;
			delete pCur;
			pCur = _pHead->_pNext;
		}
		_pHead->_pNext = _pHead;
		_pHead->_pPre = _pHead;
	}
	void Swap(List& l)
	{
		swap(_pHead, l._pHead);
	}
private:
	void CreateHead()
	{
		_pHead = new Node;
		_pHead->_pPre = _pHead;
		_pHead->_pNext = _pHead;
	}
private:
	PNode _pHead;
};

3. list与vector的对比
vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：