【C++】list容器的基本操作

list的介绍

1、list是可以在常数范围内在任意位置进行插入和删除的序列式容器（STL的容器有序列式容器和关联式容器两种，序列式容器就是有顺序，关联式容器没有顺序），并且该容器可以前后双向迭代。
2、list的底层实现是双向循环链表，双向链表中每个元素都存储在互不相关的独立节点中。
3、list与forword_list非常相似，最主要的区别是forword_list是单链表，只能朝前迭代。
4、与其他序列式容器相比，list通常在任意位置进行插入、移除元素的执行效率更好。
5、与其他的序列式容器相比，list最大的缺陷是不支持随机访问，要访问list的某一个元素，必须从已知的位置向前或者向后进行迭代，迭代需要线性的时间开销。

list的使用

list的构造

构造函数	接口说明
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

代码演示：

void main()
{
	list<int> lt;
	listPrint(lt);//Over.
	list<int> lt2(3, 666);
	listPrint(lt2);//666-->666-->666-->Over.

	int arr[] = { 1,2,3,4 };
	list<int> lt3(arr, arr + sizeof(arr) / sizeof(arr[0]));
	listPrint(lt3);//1-->2-->3-->4-->Over.
	list<int> lt4 = lt3;
	listPrint(lt4);//1-->2-->3-->4-->Over.
}

list iterator的使用

iterator就是迭代器，迭代器可以暂时浅显的理解为一个指针，指向list当中的某个节点.

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

list的底层实现是双向循环链表并且带头节点，对list来说，begin指向第一个真正的节点，也就是头节点的下一个节点，end指向最后一个元素下一个位置，也就是头节点了。

代码演示：

void listPrint(list<int> lt)
{
	list<int>::iterator it = lt.begin();
	while (it != lt.end())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "Over." << endl;
}
void listPrint1(list<int> lt)
{
	list<int>::reverse_iterator it = lt.rbegin();
	while (it != lt.rend())
	{
		cout << *it << "-->";
		++it;
	}
	cout << "Over." << endl;
}
void main()
{
	list<int> lt;
	listPrint(lt);//Over.
	list<int> lt2(3, 666);
	listPrint(lt2);//666-->666-->666-->Over.

	int arr[] = { 1,2,3,4 };
	list<int> lt3(arr, arr + sizeof(arr) / sizeof(arr[0]));
	listPrint(lt3);//1-->2-->3-->4-->Over.
	list<int> lt4 = lt3;
	listPrint1(lt4);//4-->3-->2-->1-->Over.
}

begin和end是正向迭代器，对迭代器执行++操作，迭代器向后移动；
rbegin(end)和rend(begin)是反向迭代器，对迭代器执行++操作，迭代器向前移动。

list capacity

函数声明	接口说明
empty	检测list是否为空
size	返回list中有效节点的个数

代码演示：

void main()
{
	int arr[] = { 1,2,3,4 };
	list<int> lt(arr, arr + sizeof(arr) / sizeof(arr[0]));
	listPrint(lt);//1-->2-->3-->4-->Over.
	cout << "empty ? " << lt.empty() << endl;//empty ? 0
	cout << "size = " << lt.size() << endl;//size = 4
}

list element access

函数声明	接口说明
front	返回list的第一个节点中值的引用
back	返回list最后一个节点中值的引用

代码演示：

void main()
{
	int arr[] = { 1,2,3,4 };
	list<int> lt(arr, arr + sizeof(arr) / sizeof(arr[0]));
	listPrint(lt);//1-->2-->3-->4-->Over.
	cout << "front = " << lt.front() << endl;//front = 1
	cout << "back = " << lt.back() << endl;//back = 4
}

list modifiers

函数声明	接口说明
push_front	在list首元素前插入值为val的元素
pop_front	删除链表中第一个元素
push_back	在list尾部插入值为val的元素
pop_back	删除链表中最后一个元素
insert	在list position位置插入值为val的元素
erase	删除list position位置的元素
swap	交换两个list中的元素
clear	清空list中的有效元素

另外我们还有一个不成文的规定，就是当在迭代器所指的位置插入节点，是在迭代器所指节点的前面插入。

代码演示：

void main()
{
	int arr[] = { 1,2,3,4 };
	list<int> lt(arr, arr + sizeof(arr) / sizeof(arr[0]));
	listPrint(lt);//1-->2-->3-->4-->Over.
	
	lt.push_front(999);
	listPrint(lt);//999-->1-->2-->3-->4-->Over.
	lt.pop_front();
	listPrint(lt);//1-->2-->3-->4-->Over.

	lt.push_back(888);
	listPrint(lt);//1-->2-->3-->4-->888-->Over.
	lt.pop_back();
	listPrint(lt);//1-->2-->3-->4-->Over.

	auto pos = ++lt.begin();//获取链表中第二个节点
	lt.insert(pos, 777);
	listPrint(lt);//1-->777-->2-->3-->4-->Over.
	lt.erase(--pos);
	listPrint(lt);//1-->2-->3-->4-->Over.

	list<int> lt1(5, 666);
	swap(lt, lt1);
	listPrint(lt);//666-->666-->666-->666-->666-->Over.
	listPrint(lt1);//1-->2-->3-->4-->Over.

	lt.clear();
	listPrint(lt);//Over.
}

list的迭代器失效

代码演示：

void main()
{
	int arr[] = { 1,2,3,4 };
	list<int> lt(arr, arr + sizeof(arr) / sizeof(arr[0]));
	auto pos = ++lt.begin();//获取链表中第二个节点
	lt.erase(pos);
	listPrint(lt);//1-->2-->3-->4-->Over.
	cout << *pos << endl;//迭代器已经失效了
}

执行结果：

我们之前说，可以把迭代器暂时理解为迭代器，迭代器失效即迭代器所指的节点的无效，即该节点被删除了，因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是包含导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。