系统性学习C++-第九讲-list类

[1. list 的介绍及使用](#1. list 的介绍及使用)
- [1.1 list 的介绍](#1.1 list 的介绍)
- [1.2 list 的使用](#1.2 list 的使用)
- - [1.2.1 list 的构造](#1.2.1 list 的构造)
  - [1.2.2 list iterator 的使用](#1.2.2 list iterator 的使用)
  - [1.2.3 list capacity](#1.2.3 list capacity)
  - [1.2.4 list element access](#1.2.4 list element access)
  - [1.2.5 list modifiers](#1.2.5 list modifiers)
  - [1.2.6 list 的迭代器失效](#1.2.6 list 的迭代器失效)
[2. list 的模拟实现](#2. list 的模拟实现)
- [2.1 模拟实现 list](#2.1 模拟实现 list)
- [2.2 list 的反向迭代器](#2.2 list 的反向迭代器)
[3. list 与 vector 的对比](#3. list 与 vector 的对比)

1. list 的介绍及使用

1.1 list 的介绍

list的文档介绍

1.2 list 的使用

list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。

以下为 list 中一些常见的重要接口。

1.2.1 list 的构造

构造函数（(constructor)）	接口说明
list (size_type n, const value_type& val = value_type())	构造的 list 中包含 n 个值为 val 的元素
list()	构造空的 list
list (const list& x)	拷贝构造函数
list (InputIterator first, InputIterator last)	用[first, last)区间中的元素构造 list

1.2.2 list iterator 的使用

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

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

❗️注意：

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

1.2.3 list capacity

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

1.2.4 list element access

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

1.2.5 list modifiers

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

list 中还有一些操作，需要用到时大家可参阅 list 的文档说明。

1.2.6 list 的迭代器失效

前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。

因为 list 的底层结构为带头结点的双向循环链表，因此在 list 中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，

并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

cpp 复制代码

void TestListIterator1()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> 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<int> 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 的模拟实现

2.1 模拟实现 list

要模拟实现 list ，必须要熟悉 list 的底层结构以及其接口的含义，通过上面的学习，这些内容已基本掌握，现在我们来模拟实现 list 。

2.2 list 的反向迭代器

通过前面例子知道，反向迭代器的 ++ 就是正向迭代器的 -- ，反向迭代器的 -- 就是正向迭代器的 ++ ，因此反向迭代器的实现，

可以借助正向迭代器，即：反向迭代器内部可以包含一个正向迭代器，对正向迭代器的接口进行包装即可。

cpp 复制代码

template<class Iterator>
class ReverseListIterator
{
	// 注意：此处typename的作用是明确告诉编译器，Ref是Iterator类中的类型，而不是静态成员变量
	// 否则编译器编译时就不知道Ref是Iterator中的类型还是静态成员变量
	// 因为静态成员变量也是按照 类名::静态成员变量名 的方式访问的
	public:
		typedef typename Iterator::Ref Ref;
		typedef typename Iterator::Ptr Ptr;
		typedef ReverseListIterator<Iterator> Self;
	public:
		//////////////////////////////////////////////
		// 构造
		ReverseListIterator(Iterator it): _it(it){}
		//////////////////////////////////////////////
		// 具有指针类似行为
		Ref operator*(){
		Iterator temp(_it);
		--temp;
		return *temp;
		}
	
	Ptr operator->(){ return &(operator*());}
	
	//////////////////////////////////////////////
	// 迭代器支持移动
	
	Self& operator++(){
		--_it;
		return *this;
	}
	
	Self operator++(int){
		Self temp(*this);
		--_it;
		return temp;
	}
	
	Self& operator--(){
	++_it;
	return *this;
	}

	Self operator--(int)
	{
		Self temp(*this);
		++_it;
		return temp;
	}
	//////////////////////////////////////////////
	// 迭代器支持比较
	bool operator!=(const Self& l)const{ return _it != l._it;}
	bool operator==(const Self& l)const{ return _it != l._it;}
	Iterator _it;
};

3. list 与 vector 的对比

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

其主要不同如下：

	vector	list
底层结构	动态顺序表，一段连续空间	带头结点的双向循环链表
随机访问	支持随机访问，访问某个元素效率`O(1)`	不支持随机访问，访问某个元素效率`O(N)`
插入与删除	任意位置插入和删除效率低，需要搬移元素，时间复杂度为`O(N)`，插入时有可能需要增容，增容：开辟新空间，拷贝元素，释放旧空间，导致效率更低	任意位置插入和删除效率高，不需要搬移元素，时间复杂度为`O(1)`
空间利用率	底层为连续空间，不容易造成内存碎片，空间利用率高，缓存利用率高	底层节点动态开辟，小节点容易造成内存碎片，空间利用率低，缓存利用率低
迭代器	原生态指针	对原生态指针(节点指针)进行封装
迭代器失效	在插入元素时，要给所有的迭代器重新赋值，因为插入元素有可能会导致重新扩容，致使原来迭代器失效，删除时，当前迭代器需要重新赋值否则会失效	插入元素不会导致迭代器失效，删除元素时，只会导致当前迭代器失效，其他迭代器不受影响
使用场景	需要高效存储，支持随机访问，不关心插入删除效率	大量插入和删除操作，不关心随机访问