list ：《list的介绍和使用》《list的深度剖析和模拟实现》《list与vector的对比》

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

2 List的使用
List的接口是非常的多的，我们可以在网页上面查找它使用的接口，下面是常用的使用接口
1.2.1list的构造：

看看下面的代码：

int main()
{
	list<int>l1;   //构造空的l1;
	list<int>l2(4, 100);     //l2中放4个值为100 的元素

	list<int>l3(l2.begin(), l2.end());    //用l2的[begin(),end())左闭右开的区间构造l3
	list<int>l4(l3);     //用l3拷贝构造l4

	//以数组为迭代器区间构造l5
	int array[] = { 16, 2, 77, 29 };
	list <int>l5(array, array + sizeof(array) / sizeof(int));

	//用迭代器的方式打印l5中的元素
	for (list<int>::iterator it = l5.begin(); it != l5.end(); it++)
		cout << *it << " ";
	cout << endl;

	//c++11范围for的方式遍历
	for (auto& e : l5)
		cout << e << " ";
	cout << endl;
	return 0;
}

2.list iterator的使用
**此处可以暂时的将迭代器理解为一个指针，该指针指向list中的某个节点。
**

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

void print_list(const list<int>& l)
{
	for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it)
	{
		cout << *it << " ";
		//*it = 10;  编译不通过
	}
	cout << endl;
}

int main()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list <int>l(array, array + sizeof(array) / sizeof(int));
	//使用正向迭代器正向list中的元素
	for (list<int>::iterator it = l.begin(); it != l.end(); ++it)

		cout << *it << " ";
	cout << endl;
	//使用反向迭代器逆向打印list中的元素
	for (list<int>::reverse_iterator it = l.rbegin(); it != l.rend(); ++it)
		cout << *it << " ";
	cout << endl;
	return 0;
}

1.2.3 list capacity

int main()
{
	int arr[] = { 1, 2, 3, 5, 6, 9, 8, 7, 4, 0 };
	list<int> l(arr, arr + sizeof(arr) / sizeof(int));

//答应该字符里面的个数
	cout << l.size() << endl;
//判断是否为空
	if (l.empty())
	{
		cout << "list = nullptr" << endl;
	}
	else
	{
		for (auto& e : l)
		{
			cout << e << " ";
		}
		cout << endl;
	}
	return 0;
}

1.2.4 list element access

int main()
{
	int arr[] = { 1, 2, 3, 5, 6, 9, 8, 7, 4, 0 };
	list<int> l(arr, arr + sizeof(arr) / sizeof(int));

	

 l.front() = 10;
	 l.back() = 10;
	 
	for (auto& e : l)
	{
		cout << e << " ";
	}
	cout << endl;

	const list<int> l1(arr, arr + sizeof(arr) / sizeof(int));
	//int&cl = l1.front(); //这里会报错，我们可以看上面为const的类型，所以我们需要使用const; 

	const int&cl = l1.front(); //我们可以看到，这里可以编过；

return 0;
}

1.2.5list modifiers

void printlist(list<int>& l)
{
	for (auto& e : l)
		cout << e << " ";
	cout << endl;
}
void Testlist1()
{
	int array[] = { 1, 2, 3 };
	list <int>l(array, array + sizeof(array) / sizeof(array[0]));

	//在list的尾部插入4，头部插入0
	l.push_back(4);
	l.push_front(0);
	printlist(l);
	//删除list尾部节点和头部节点
	l.pop_back();
	l.pop_front();
	printlist(l);
}


void Testlist2()
{
	int array1[] = { 1, 2, 3 };
	list<int>l(array1, array1 + sizeof(array1) / sizeof(array1[0]));

	//获取链表中第二个节点
	auto pos = ++l.begin();
	cout << *pos << endl;

	//在pos前插入值为4的元素
	l.insert(pos, 4);
	printlist(l);

	//在pos前插入5个值为5的元素
	l.insert(pos, 5, 5);
	printlist(l);

	//在pos前插入[v.begin(),v.end()]区间中的元素
	vector<int>v{ 7, 8, 9 };
	l.insert(pos, v.begin(), v.end());
	printlist(l);

	//删除pos位置的元素
	l.erase(pos);
	printlist(l);

	//删除list中[begin,end]区间中的元素,即删除list中所有元素
	l.erase(l.begin(), l.end());
	printlist(l);


}
//resize/swap/clear
void Testlist4()
{
	//用数组来构造list
	int array1[] = { 1, 2, 3 };
	list<int>l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));
	printlist(l1);


	//交换了l1和l2中的元素

	l1.swap(l2);
	printlist(l1);
	printlist(l2);


	//将l2中的元素清空
	l2.clear();
	cout << l2.size() << endl;
}

1.2.6迭代器失效问题：
迭代器失效即迭代器所指向的节点的无效，即该节点被删除了，因为list的底层结构为带头节点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

由执行程序，我们可以看出，程序出现了崩溃，为什么崩溃，下来我们就分析一下：

回答一：删除pos位置的数据，导致pos迭代器失效；
回答二：insert会导致迭代器失效，是因为insert可能会导致增容，增容后pos还指向原来的空间，而原来的空间已经释放了。

两者是相互存在，相互制约的，所以我们在使用的时候，一定要先插入数据，然后在释放此处的数据。

void Testlistiterator()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int>l(arr, arr + sizeof(arr) / sizeof(arr[0]));

	auto it = l.begin();
	while (it != l.end())
	{
		//erase()函数执行后，it所指向的节点已经被删除，因此it无效，在下一次使用it时，必须先给其赋值
		l.erase(it);
		++it;
	}
}

//改正
void Testlistiterator1()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int>l(arr1, arr1+sizeof(arr1) / sizeof(arr1[0]));
	auto it = l.begin();
	while (it != l.end())
	{
		l.erase(it++);      //it=l.erase(it)
	}
}
int main()
{
	Testlistiterator1();
	system("pause");
	return 0;
}

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