9.2 容器库概览

所有容器的共性：

表格一：

类型别名	说明
iterator	迭代器
const_iterator	只读迭代器
size_type	无符号整型，类型可容纳最大容器大小
difference_type	带符号整型，类型可容纳最大两迭代器距离
value_type	元素类型
reference	引用,即value_type&
const_reference	常量引用

C为具体的容器，c为容器名：

表格二：

构造函数	说明
C c;	默认，构造空容器
C c1(c2);	构造c2的拷贝c1
C c1 = c2;	构造c2的拷贝c1
C c(b,e);	使用迭代器，将迭代器b~e范围内元素拷贝到c。（array不适用）
C c{a,b,c…}	列表初始化，注意使大括号，代表着类型要相匹配
C c = {a,b,c…}	列表初始化，注意使大括号，代表着类型要相匹配

表格三：

赋值与swap	说明
c1=c2	将c1当中的元素替换为c2当中的元素
c1={a,b,c······}	将c1当中的元素替换为列表当中的元素（array不适用）
a.swap(b)	交换a和b当中的元素
swap(a,b)	与上面等价

表格四：

大小	说明
c.size();	c当中元素的数目（不支持forward_list）
c.max_size()	c当中最大可以保存的容量
c.empty()	c是否为空容器，如果为空返回true，不为空返回false

表格五：

添加/删除元素（不适用于array）	说明
c.insert(args)	将args当中的元素拷贝到c当中
c.emplace(inits)	使用inits构造c当中的一个元素
c.erase(args)	删除args指定的元素
c.clear()	清空c当中的所有元素

表格六：

关系运算符	说明
==、!=	所有容器都支持相等不等运算符
<、<=、>、>=	关系运算符(无序关联容器不支持)

表格七：

获取迭代器
c.begin(),c.end()	返回c容器的首元素和尾元素后面的位置的迭代器
c.cbegin(),c.cend()	返回常量迭代器 const_iterator

表格八：

反向容器的额外成员(不支持forward_list)	说明
reverse_iterator	按逆序寻址元素的迭代器
const_reverse_iterator	不能修改元素的逆序元素的迭代器
c.rbegin(),c.rend()	返回指向尾元素位置和首元素前一位位置的迭代器
c.crbegin(),c.crend()	返回const_reverse_iterator

迭代器

迭代器具有公共接口，允许通过迭代器访问容器中的元素，以及递增递减，以及使用解引用进行访问容器中的元素。对于单向链表（forward_list）不能递减，迭代器支持的算术运算只应用于string、vector、deque和array。

迭代器的范围

1. 左闭右开区间[begin,end)
2. begin和end需要指向同一容器中的元素。
3. begin和end有多个版本，如cbegin、rbegin、crbegin等。带r为反向，带c为const。

容器类型成员

实际上见上表格一和表格八
主要用处：（后续会再继续讲解，下面只是举个例子，可以理解一下）

lsit<string>::reverse_iterator iter_beg = c.rbegin()

begin和end成员

只列出begin的例子，end同理

	list<string > list1 = { "hello"," ","world" };
	auto iter1 = list1.begin(); //list<stirng>::iterator
	auto iter2 = list1.cbegin();//list<string>::const_iterator
	auto iter3 = list1.crbegin();//list<string>::const_reverse_iterator
	auto iter4 = list1.rbegin();//list<string>::reverse_iterator

容器的定义和初始化

对于顺序容器（不包括array）来说除了上面表格二的共性，还有下面的两种方式：

构造	说明
C c(n,t)	包含n个初始值为t的元素
C c(n)	包含n个元素（string不适用）

当将一个容器初始化为另一个容器的拷贝时，两个容器的容器类型和元素类型都必须相同。

	list<string > l = { "hello"," ","world" };
	vector<const char* > v = { "a","an","the" };

	list<string> ll(v.begin(),v.end());//正确的，实际上是将迭代器之间的数据一个个传入，进行赋值操作，并且const char*是可以转换为string类型的，所以正确。
	list<string> lll(v);//错误的,v的类型是vector,lll的类型是list，类型不一致。
	list<int> llll(v);//错误const char*无法转化为int类型

由上得到，我们可以通过控制迭代器，进行相关数量的赋值操作：

	list<string> ll(v.begin(),iter);//通过控制iter所处的位置来进行操控复制的位次，相同的v.begin()也可以进行修改。

与顺序容器大小相关的构造函数

样例：

#include<iostream>
#include<list>
#include<vector>
#include<forward_list>
#include<deque>
#include<array>
#include<string>

using namespace std;

int main() 
{
	list<string > l = { "hello"," ","world" };//构造出含有三个指定元素的容器list
	vector<int> v(10, -1);//构造出含有10个-1的容器vector
	forward_list<int> f(10);//构造出含有10个默认0的容器forward_list
	deque<string> d(10);//构造出含有10个默认为空的容器deque

	//array需要显式的标出其内存大小,值得关注的是数组容器和内置数组不一样，内置数组不允许赋值，数组容器允许赋值，但是需要有相同的大小。

	array<int, 10> a = { 1 };//a[0]为1，其余9个位置为默认0的容器array
	array<int, 10> aa = a;//正确
	//array<int, 11> aaa = a;//错误对于拷贝赋值来说需要相同大小
	return 0;
}

注意点：标准库array需要有固定大小。

赋值和swap

上述表格三满足所有的容器都有的共性操作。

这边举一些具有的特性：

函数assign（不适用于关联容器和array）	说明
c.assign(b,e)	将c当中的元素替换成迭代器b~e之间的数据
c.assign(i1)	将c当中的元素替换成初始化列表i1当中的数据
c.assign(n,t)	将c当中的元素替换成n个t

assigned

样例：

#include<iostream>
#include<list>
#include<string>

using namespace std;

int main() 
{
	list<string > l = { "hello"," ","world" };//构造出含有三个指定元素的容器list
	l.assign(3, "hi");
	for (auto i = l.begin();i!=l.end();i++)
	{
		cout << *i << " ";
	}
	
	return 0;
}

输出结果：

swap

交换a、b，交换函数swap速度很快（常数时间），除array外，不对任何元素进行拷贝、删除、插入操作。交换两个array，array容量必须保持一致，会真正交换他们的元素。

对string进行swap，其指针、迭代器和引用会失效；对array进行swap，其指针、迭代器和引用会指向新交换后的值；对于其他容器，指向容器的指针、迭代器和引用等不会失效，会属于另一个容器。

容器大小操作

除了一个例外，每个容器类型都有三个与大小相关的操作。成员函数size返回容器中元素的数目; empty当size为0时返回布尔值true，否则返回false; max_size 返回一个大于或等于该类型容器所能容纳的最大元素数的值。forward_ list支持max_size 和empty，但不支持size,原因我们将在之后解释。

关系运算符

==、!=
<、>、<=、>= %支持有序容器，左右两边必须是相同类型容器

至于比较方式和string类似，这边不进行详细介绍