C++——STL（list类）

1.list的介绍

1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。

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

3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。

4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。

5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问。

2.list的使用

2.1 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构造函数模拟实现：

//无参构造
List()
{
	CreateHead();
}
//构造
List(int n, const T& val = T())
{
	CreateHead();
	for (int i = 0; i < n; i++)
	{
		push_back(val);
	}
}
//参数为迭代器的构造
template<class iterator>
List(iterator first, iterator last)
{
	CreateHead();
	iterator it = first;
	while (it != last)
	{
		push_back(*it);
		++it;
	}
}
//拷贝构造
List(const List<T>& l)
{
	CreateHead();
	List<T> tmp(l.begin(), l.end());
	this->swap(tmp);
}

//析构
~List()
{
	clear();
	delete _head;
	_head = nullptr;
}

2.2 list iterator的使用

begin  + end ：返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器

rbegin +  rend ：返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置

注意：

1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动 

 list iterator的模拟实现：

template<class T,class Ref,class Ptr>
struct ListIterator
{
	typedef ListNode<T> Node;
	typedef ListIterator<T, Ref, Ptr> Self;
	//构造
	ListIterator(Node* node=nullptr)
		:_node(node)
	{}
	//迭代器的解引用
	Ref operator*()
	{
		return _node->_val;
	}

	Ptr operator->()
	{
		return &(_node->_val);
	}
	//迭代器的移动
	Self operator++()
	{
		_node = _node->_next;
		return *this;
	}

	Self operator++(int)
	{
		Self tmp(*this);
		_node = _node->_next;
		return tmp;
	}

	Self operator--()
	{
		_node = _node->_prev;
		return *this;
	}
	
	Self operator--(int)
	{
		Self tmp(*this);
		_node = _node->_prev;
		return tmp;
	}
	//迭代器的比较
	bool operator!=(const Self& it) const
	{
		return _node != it._node;
	}

	bool operator==(const Self& it) const
	{
		return _node == it._node;
	}
	Node* _node; //迭代器本质是节点指针
};

2.3 list capacity