C++ STL序列式容器（详解）
STL基础
C++ STL基本组成（6大组件+13个头文件）
通常认为，STL 是由容器、算法、迭代器、函数对象、适配器、内存分配器这 6 部分构成，其中后面 4 部分是为前 2 部分服务的，它们各自的含义如表 1 所示。
表 1 STL 组成结构
| STL的组成 | 含义 |
|---|---|
| 容器 | 一些封装数据结构的模板类，例如 vector 向量容器、list 列表容器等。 |
| 算法 | STL 提供了非常多（大约 100 个）的数据结构算法，它们都被设计成一个个的模板函数，这些算法在 std 命名空间中定义，其中大部分算法都包含在头文件 中，少部分位于头文件 中。 |
| 迭代器 | 在 C++ STL 中，对容器中数据的读和写，是通过迭代器完成的，扮演着容器和算法之间的胶合剂。 |
| 函数对象 | 如果一个类将 () 运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象（又称仿函数）。 |
| 适配器 | 可以使一个类的接口（模板的参数）适配成用户指定的形式，从而让原本不能在一起工作的两个类工作在一起。值得一提的是，容器、迭代器和函数都有适配器。 |
| 内存分配器 | 为容器类模板提供自定义的内存申请和释放功能，由于往往只有高级用户才有改变内存分配策略的需求，因此内存分配器对于一般用户来说，并不常用。 |
关于表 1 中罗列的 STL 的构成，初学者简单了解即可，后续章节将专门对它们做系统的深入讲解。
另外，在惠普实验室最初发行的版本中，STL 被组织成 48 个头文件；但在 C++ 标准中，它们被重新组织为 13 个头文件，如表 2 所示。
表 2 C++ STL头文件
关于这些头文件的作用和用法，本节不做过多赘述，后续章节会做详细介绍。
按照 C++ 标准库的规定，所有标准头文件都不再有扩展名。以 为例，此为无扩展名的形式，而 <vector.h> 为有扩展名的形式。
但是，或许是为了向下兼容，或许是为了内部组织规划，某些 STL 版本同时存储具备扩展名和无扩展名的两份文件（例如 Visual C++ 支持的 Dinkumware 版本同时具备 <vector.h> 和 ）；甚至有些 STL 版本同时拥有 3 种形式的头文件（例如 SGI 版本同时拥有 、<vector.h> 和 <stl_vector.h>）；但也有个别的 STL 版本只存在包含扩展名的头文件（例如 C++ Builder 的 RaugeWare 版本只有 <vector.h>）。
建议读者养成良好的习惯，遵照 C++ 规范，使用无扩展名的头文件。
如何衡量一个算法的执行效率？
学习 C++ 标准库，特别是 STL，经常需要考量算法和成员函数的效能（也就是运行效率，又称复杂度），因此每个学习 STL 的读者都需要掌握一种衡量算法（或成员函数）复杂度的方法，目前最常用的方法称为大 O 表示法（注意，不是数字 0，而是字母 O）。
使用大 O 表示法衡量某个算法的复杂度，其实就是将该算法的运行时间用输入量为 n 的函数表示出来。这里的输入量 n 在 STL 中通常指的是算法操作的元素个数。
举个例子，当算法运行时间随元素个数成线性增长时（即如果元素个数呈倍数增长，运行时间也呈倍数增长），该算法的复杂度用 O(n) 来表示；反之，如果算法的运行时间和输入量 n 无关，则该算法的复杂度就用 O(1) 来表示。
表 1 列出了常见的算法复杂度种类，以及使用大 O 表示法表示的复杂度。
表 1 常见的算法复杂度表示
| 算法复杂度种类 | 含义 | 大 O 表示法 |
|---|---|---|
| 常数阶 | 算法运行时间和所操作的元素个数无关 | O(1) |
| 对数阶 | 算法运行时间随所操作的元素个数呈对数增长 | O(log(n)) |
| 线性阶 | 算法运行时间随所操作的元素个数呈线性增长 | O(n) |
| 指数阶（m次方，m为数字） | 算法运行时间随所操作的元素个数呈 m 次方增长 O(nm) | 常见的有 O(n2)、O(n3) 等 |
值得注意的是，大 O 表示法并不关心算法运行所消耗的具体时间，换句话说，对于那些影响算法运行效率较小的因素，使用大 O 表示法表示时会直接将其忽略。例如，某个算法运行的复杂度为 O(n)，呈线性增长，但至于线性增长的具体程度（是 100n 还是 2n），在大 O 表示法看来，它们是一样的。也就是说，采用这种测量法则，任何两个线性算法都将被视为具有相同的复杂度。
采用大 O 表示法甚至会出现这种一种情况，即带有巨大常量的线性算法，很有可能会比小常量的指数算法更受欢迎，因为该方法无法显示出真实的运行时间。
所以请读者记住，大 O 表示法只是某种度量方法，它所显示的算法的最佳复杂度，并不一定就是真正的最佳（最快）算法。
表 2 复杂度随元素个数对照表
| 复杂度 | 元素个数 | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| 种类 | 大 O 表示 | 1 | 2 | 5 | 10 | 50 | 100 | 1 000 | 10 000 |
| 常量阶 | O(1) | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
| 对数阶 | O(log(n)) | 1 | 2 | 3 | 4 | 6 | 7 | 10 | 13 |
| 线性阶 | O(n) | 1 | 2 | 5 | 10 | 50 | 100 | 1 000 | 10 000 |
| 2次方 | O(n2) | 1 | 4 | 25 | 100 | 2500 | 10 000 | 1 000 000 | 100 000 000 |
表 2 列出了常用的复杂度随元素个数增长的变化程序。可以看到，当算法处理的元素较少时，各复杂度的差别很小，此时算法效率的优劣往往受被大 O 表示法忽略部分的影响更大。而当处理元素个数越多，各复杂度的差别越大，此时复杂度被忽略的部分就变得无关紧要了。
因此，在考量算法的复杂度时，输入量 n （操作元素的个数）的值必须足够大才有意义。
时间复杂度计算：https://blog.csdn.net/firefly_2002/article/details/8008987
STL序列式容器（详解版）
C++ STL容器是什么？
在实际的开发过程中，合理组织数据的存取与选择处理数据的算法同等重要，存取数据的方式往往会直接影响到对它们进行增删改查操作的复杂程度和时间消耗。事实上，当程序中存在对时耗要求很高的部分时，数据结构的选择就显得尤为重要，有时甚至直接影响程序执行的成败。
值得一提的是，之前我们一直在不断地重复实现一些诸如链表、集合等等这些常见的数据结构，这些代码使用起来往往都十分类似，只是为了适应不同数据的变化，可能需要在一些细节上做不同的处理。
那么大家有没有想过，是不是可以重复利用那些已有的实现来完成当前的任务呢？当然是可行的，有些读者已经亲自编写并实现了动态数组类、链表类、集合类等程序，并精心维护着。其实，STL 中提供了专家级的几乎我们所需要的各种容器，功能更好，复用性更高。
简单的理解容器，它就是一些模板类的集合，但和普通模板类不同的是，容器中封装的是组织数据的方法（也就是数据结构）。STL 提供有 3 类标准容器，分别是序列容器、排序容器和哈希容器，其中后两类容器有时也统称为关联容器。它们各自的含义如表 1 所示。
表 1 STL 容器种类和功能
| 容器种类 | 功能 |
|---|---|
| 序列容器 | 主要包括 vector 向量容器、list 列表容器以及 deque 双端队列容器。之所以被称为序列容器，是因为元素在容器中的位置同元素的值无关，即容器不是排序的。将元素插入容器时，指定在什么位置，元素就会位于什么位置。 |
| 排序容器 | 包括 set 集合容器、multiset多重集合容器、map映射容器以及 multimap 多重映射容器。排序容器中的元素默认是由小到大排序好的，即便是插入元素，元素也会插入到适当位置。所以关联容器在查找时具有非常好的性能。 |
| 哈希容器 | C++ 11 新加入 4 种关联式容器，分别是 unordered_set 哈希集合、unordered_multiset 哈希多重集合、unordered_map 哈希映射以及 unordered_multimap 哈希多重映射。和排序容器不同，哈希容器中的元素是未排序的，元素的位置由哈希函数确定。 |
注意，由于哈希容器直到 C++ 11 才被正式纳入 C++ 标准程序库，而在此之前，“民间”流传着 hash_set、hash_multiset、hash_map、hash_multimap 版本，不过该版本只能在某些支持 C++ 11 的编译器下使用（如 VS），有些编译器（如 gcc/g++）是不支持的。
另外，以上 3 类容器的存储方式完全不同，因此使用不同容器完成相同操作的效率也大不相同。所以在实际使用时，要善于根据想实现的功能，选择合适的容器。有关这些容器的具体用法，本章后续会逐个进行介绍。
迭代器是什么，C++ STL迭代器（iterator）用法详解
无论是序列容器还是关联容器，最常做的操作无疑是遍历容器中存储的元素，而实现此操作，多数情况会选用“迭代器（iterator）”来实现。那么，迭代器到底是什么呢？
我们知道，尽管不同容器的内部结构各异，但它们本质上都是用来存储大量数据的，换句话说，都是一串能存储多个数据的存储单元。因此，诸如数据的排序、查找、求和等需要对数据进行遍历的操作方法应该是类似的。
既然类似，完全可以利用泛型技术，将它们设计成适用所有容器的通用算法，从而将容器和算法分离开。但实现此目的需要有一个类似中介的装置，它除了要具有对容器进行遍历读写数据的能力之外，还要能对外隐藏容器的内部差异，从而以统一的界面向算法传送数据。
这是泛型思维发展的必然结果，于是迭代器就产生了。简单来讲，迭代器和 C++ 的指针非常类似，它可以是需要的任意类型，通过迭代器可以指向容器中的某个元素，如果需要，还可以对该元素进行读/写操作。
迭代器类别
STL 标准库为每一种标准容器定义了一种迭代器类型，这意味着，不同容器的迭代器也不同，其功能强弱也有所不同。
容器的迭代器的功能强弱，决定了该容器是否支持 STL 中的某种算法。
常用的迭代器按功能强弱分为输入迭代器、输出迭代器、前向迭代器、双向迭代器、随机访问迭代器 5 种。本节主要介绍后面的这 3 种迭代器。
输入迭代器和输出迭代器比较特殊，它们不是把数组或容器当做操作对象，而是把输入流/输出流作为操作对象。有关这 2 个迭代器，我们会在后续章节做详细介绍。
-
前向迭代器（forward iterator）
假设 p 是一个前向迭代器，则 p 支持 ++p，p++，*p 操作，还可以被复制或赋值，可以用 == 和 != 运算符进行比较。此外，两个正向迭代器可以互相赋值。 -
双向迭代器（bidirectional iterator）
双向迭代器具有正向迭代器的全部功能，除此之外，假设 p 是一个双向迭代器，则还可以进行 --p 或者 p-- 操作（即一次向后移动一个位置）。 -
随机访问迭代器（random access iterator）
随机访问迭代器具有双向迭代器的全部功能。除此之外，假设 p 是一个随机访问迭代器，i 是一个整型变量或常量，则 p 还支持以下操作：
- p+=i：使得 p 往后移动 i 个元素。
- p-=i：使得 p 往前移动 i 个元素。
- p+i：返回 p 后面第 i 个元素的迭代器。
- p-i：返回 p 前面第 i 个元素的迭代器。
- p[i]：返回 p 后面第 i 个元素的引用。
此外，两个随机访问迭代器 p1、p2 还可以用 <、>、<=、>= 运算符进行比较。另外，表达式 p2-p1 也是有定义的，其返回值表示 p2 所指向元素和 p1 所指向元素的序号之差（也可以说是 p2 和 p1 之间的元素个数减一）。
表 1 所示，是 C++ 11 标准中不同容器指定使用的迭代器类型。
| 容器 | 对应的迭代器类型 |
|---|---|
| array | 随机访问迭代器 |
| vector | 随机访问迭代器 |
| deque | 随机访问迭代器 |
| list | 双向迭代器 |
| set / multiset | 双向迭代器 |
| map / multimap | 双向迭代器 |
| forward_list | 前向迭代器 |
| unordered_map / unordered_multimap | 前向迭代器 |
| unordered_set / unordered_multiset | 前向迭代器 |
| stack | 不支持迭代器 |
| queue | 不支持迭代器 |
注意，容器适配器 stack 和 queue 没有迭代器，它们包含有一些成员函数，可以用来对元素进行访问。
迭代器的定义方式
尽管不同容器对应着不同类别的迭代器，但这些迭代器有着较为统一的定义方式，具体分为 4 种，如表 1 所示。
| 迭代器定义方式 | 具体格式 |
|---|---|
| 正向迭代器 | 容器类名::iterator 迭代器名; |
| 常量正向迭代器 | 容器类名::const_iterator 迭代器名; |
| 反向迭代器 | 容器类名::reverse_iterator 迭代器名; |
| 常量反向迭代器 | 容器类名::const_reverse_iterator 迭代器名; |
值得一提的是，表 2 中的反向迭代器全称为 “反向迭代器适配器”，后续章节会做详细讲解，这里读者只需要知道其用法即可。
通过定义以上几种迭代器，就可以读取它指向的元素，*迭代器名就表示迭代器指向的元素。其中，常量迭代器和非常量迭代器的分别在于，通过非常量迭代器还能修改其指向的元素。另外，反向迭代器和正向迭代器的区别在于：
- 对正向迭代器进行 ++ 操作时，迭代器会指向容器中的后一个元素；
- 而对反向迭代器进行 ++ 操作时，迭代器会指向容器中的前一个元素。
注意，以上 4 种定义迭代器的方式，并不是每个容器都适用。有一部分容器同时支持以上 4 种方式，比如 array、deque、vector；而有些容器只支持其中部分的定义方式，例如 forward_list 容器只支持定义正向迭代器，不支持定义反向迭代器。
具体容器支持定义迭代器的方式，讲具体容器时会详细说明。另外，读者也可以通过 C++ STL标准手册，查询具体容器迭代器支持的定义方式。
以上对迭代器做了很详细的介绍，下面就以 vector 容器为例，带领大家实际感受迭代器的用法和功能。通过前面的学习，vector 支持随机访问迭代器，因此遍历 vector 容器有以下几种做法。下面的程序中，每个循环演示了一种做法：
//遍历 vector 容器。
#include <iostream>
//需要引入 vector 头文件
#include <vector>
using namespace std;
int main()
{vector<int> v{1,2,3,4,5,6,7,8,9,10}; //v被初始化成有10个元素cout << "第一种遍历方法：" << endl;//size返回元素个数for (int i = 0; i < v.size(); ++i)cout << v[i] <<" "; //像普通数组一样使用vector容器//创建一个正向迭代器，当然，vector也支持其他 3 种定义迭代器的方式cout << endl << "第二种遍历方法：" << endl;vector<int>::iterator i;//用 != 比较两个迭代器for (i = v.begin(); i != v.end(); ++i)cout << *i << " ";cout << endl << "第三种遍历方法：" << endl;for (i = v.begin(); i < v.end(); ++i) //用 < 比较两个迭代器cout << *i << " ";cout << endl << "第四种遍历方法：" << endl;i = v.begin();while (i < v.end()) { //间隔一个输出cout << *i << " ";i += 2; // 随机访问迭代器支持 "+= 整数" 的操作}
}
运行结果为：
第一种遍历方法：
1 2 3 4 5 6 7 8 9 10
第二种遍历方法：
1 2 3 4 5 6 7 8 9 10
第三种遍历方法：
1 2 3 4 5 6 7 8 9 10
第四种遍历方法：
1 3 5 7 9
再举一个例子，我们知道，list 容器的迭代器是双向迭代器。假设 v 和 i 的定义如下：
//创建一个 v list容器
list<int> v;
//创建一个常量正向迭代器，同样，list也支持其他三种定义迭代器的方式。
list<int>::const_iterator i;
则以下代码是合法的：
for(i = v.begin(); i != v.end(); ++i)cout << *i;
以下代码则不合法，因为双向迭代器不支持用“<”进行比较：
for(i = v.begin(); i < v.end(); ++i)cout << *i;
以下代码也不合法，因为双向迭代器不支持用下标随机访问元素：
for(int i=0; i<v.size(); ++i)cout << v[i];
其实在 C++ 中，数组也是容器。数组的迭代器就是指针，而且是随机访问迭代器。例如，对于数组 int a[10]，int * 类型的指针就是其迭代器。则 a、a+1、a+2 都是 a 的迭代器。另外，以上有关 vector、list 容器的具体用法，后续章节会做详细讲解。
C++序列式容器（STL序列式容器）是什么
所谓序列容器，即以线性排列（类似普通数组的存储方式）来存储某一指定类型（例如 int、double 等）的数据，需要特殊说明的是，该类容器并不会自动对存储的元素按照值的大小进行排序。
需要注意的是，序列容器只是一类容器的统称，并不指具体的某个容器，序列容器大致包含以下几类容器：
- array<T,N>（数组容器）：表示可以存储 N 个 T 类型的元素，是 C++ 本身提供的一种容器。此类容器一旦建立，其长度就是固定不变的，这意味着不能增加或删除元素，只能改变某个元素的值；
- vector< T >（向量容器）：用来存放 T 类型的元素，是一个长度可变的序列容器，即在存储空间不足时，会自动申请更多的内存。使用此容器，在尾部增加或删除元素的效率最高（时间复杂度为 O(1) 常数阶），在其它位置插入或删除元素效率较差（时间复杂度为 O(n) 线性阶，其中 n 为容器中元素的个数）；
- deque< T >（双端队列容器）：和 vector 非常相似，区别在于使用该容器不仅尾部插入和删除元素高效，在头部插入或删除元素也同样高效，时间复杂度都是 O(1) 常数阶，但是在容器中某一位置处插入或删除元素，时间复杂度为 O(n) 线性阶；
- list< T >（链表容器）：是一个长度可变的、由 T 类型元素组成的序列，它以双向链表的形式组织元素，在这个序列的任何地方都可以高效地增加或删除元素（时间复杂度都为常数阶 O(1)），但访问容器中任意元素的速度要比前三种容器慢，这是因为 list 必须从第一个元素或最后一个元素开始访问，需要沿着链表移动，直到到达想要的元素。
- forward_list< T >（正向链表容器）：和 list 容器非常类似，只不过它以单链表的形式组织元素，它内部的元素只能从第一个元素开始访问，是一类比链表容器快、更节省内存的容器。
注意，其实除此之外，stack 和 queue 本质上也属于序列容器，只不过它们都是在 deque 容器的基础上改头换面而成，通常更习惯称它们为容器适配器，有关它们的介绍，会放到后续章节中。
图 1 说明了可供使用的序列容器以及它们之间的区别。
图 1 标准的序列容器
图 1 中每种类型容器的操作都可以高效执行，但进行除此之外的其他操作，效率会稍差一些。在本章的剩余部分，会详细介绍每一类序列容器的具体用法。
容器中常见的函数成员
序列容器包含一些相同的成员函数，它们的功能也相同，本教程会在某个容器的上下文中详细介绍下面的每个函数，但对于每种类型的容器不会重复介绍它们的细节。
表 2 展示了 array、vector 和 deque 容器的函数成员，它们中至少有两个容器实现了同样的函数成员。
| 函数成员 | 函数功能 | array<T,N> | vector | deque |
|---|---|---|---|---|
| begin() | 返回指向容器中第一个元素的迭代器。 | 是 | 是 | 是 |
| end() | 返回指向容器最后一个元素所在位置后一个位置的迭代器，通常和 begin() 结合使用。 | 是 | 是 | 是 |
| rbegin() | 返回指向最后一个元素的迭代器。 | 是 | 是 | 是 |
| rend() | 返回指向第一个元素所在位置前一个位置的迭代器。 | 是 | 是 | 是 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | 是 | 是 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | 是 | 是 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | 是 | 是 |
| crend() | 和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | 是 | 是 |
| assign() | 用新元素替换原有内容。 | - | 是 | 是 |
| operator=() | 复制同类型容器的元素，或者用初始化列表替换现有内容。 | 是 | 是 | 是 |
| size() | 返回实际元素个数。 | 是 | 是 | 是 |
| max_size() | 返回元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。 | 是 | 是 | 是 |
| capacity() | 返回当前容量。 | - | 是 | - |
| empty() | 判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。 | 是 | 是 | 是 |
| resize() | 改变实际元素的个数。 | - | 是 | 是 |
| shrink _to_fit() | 将内存减少到等于当前元素实际所使用的大小。 | - | 是 | 是 |
| front() | 返回第一个元素的引用。 | 是 | 是 | 是 |
| back() | 返回最后一个元素的引用。 | 是 | 是 | 是 |
| operator | 使用索引访问元素。 | 是 | 是 | 是 |
| at() | 使用经过边界检査的索引访问元素。 | 是 | 是 | 是 |
| push_back() | 在序列的尾部添加一个元素。 | - | 是 | 是 |
| insert() | 在指定的位置插入一个或多个元素。 | - | 是 | 是 |
| emplace() | 在指定的位置直接生成一个元素。 | - | 是 | 是 |
| emplace_back() | 在序列尾部生成一个元素。 | - | 是 | 是 |
| pop_back() | 移出序列尾部的元素。 | - | 是 | 是 |
| erase() | 移出一个元素或一段元素。 | - | 是 | 是 |
| clear() | 移出所有的元素，容器大小变为 0。 | - | 是 | 是 |
| swap() | 交换两个容器的所有元素。 | 是 | 是 | 是 |
| data() | 返回指向容器中第一个元素的指针。 | 是 | 是 | - |
列表中 - 表明对应的容器并没有定义这个函数。
list 和 forward_list 容器彼此非常相似，forward_list 中包含了 list 的大部分成员函数，而未包含那些需要反向遍历的函数。表 3 展示了 list 和 forward_list 的函数成员。
| 函数成员 | 函数功能 | list | forward_list |
|---|---|---|---|
| begin() | 返回指向容器中第一个元素的迭代器。 | 是 | 是 |
| end() | 返回指向容器最后一个元素所在位置后一个位置的迭代器。 | 是 | 是 |
| rbegin() | 返回指向最后一个元素的迭代器。 | 是 | - |
| rend() | 返回指向第一个元素所在位置前一个位置的迭代器。 | 是 | - |
| cbegin() | 和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | 是 |
| before_begin() | 返回指向第一个元素前一个位置的迭代器。 | - | 是 |
| cbefore_begin() | 和 before_begin() 功能相同，只不过在其基础上，增加了 const 属性，即不能用该指针修改元素的值。 | - | 是 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | 是 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | - |
| crend() | 和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 | 是 | - |
| assign() | 用新元素替换原有内容。 | 是 | 是 |
| operator=() | 复制同类型容器的元素，或者用初始化列表替换现有内容。 | 是 | 是 |
| size() | 返回实际元素个数。 | 是 | - |
| max_size() | 返回元素个数的最大值，这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。 | 是 | 是 |
| resize() | 改变实际元素的个数。 | 是 | 是 |
| empty() | 判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。 | 是 | 是 |
| front() | 返回容器中第一个元素的引用。 | 是 | 是 |
| back() | 返回容器中最后一个元素的引用。 | 是 | - |
| push_back() | 在序列的尾部添加一个元素。 | 是 | - |
| push_front() | 在序列的起始位置添加一个元素。 | 是 | 是 |
| emplace() | 在指定位置直接生成一个元素。 | 是 | - |
| emplace_after() | 在指定位置的后面直接生成一个元素。 | - | 是 |
| emplace_back() | 在序列尾部生成一个元素。 | 是 | - |
| cmplacc_front() | 在序列的起始位生成一个元索。 | 是 | 是 |
| insert() | 在指定的位置插入一个或多个元素。 | 是 | - |
| insert_after() | 在指定位置的后面插入一个或多个元素。 | - | 是 |
| pop_back() | 移除序列尾部的元素。 | 是 | - |
| pop_front() | 移除序列头部的元素。 | 是 | 是 |
| reverse() | 反转容器中某一段的元素。 | 是 | 是 |
| erase() | 移除指定位置的一个元素或一段元素。 | 是 | - |
| erase_after() | 移除指定位置后面的一个元素或一段元素。 | - | 是 |
| remove() | 移除所有和参数匹配的元素。 | 是 | 是 |
| remove_if() | 移除满足一元函数条件的所有元素。 | 是 | 是 |
| unique() | 移除所有连续重复的元素。 | 是 | 是 |
| clear() | 移除所有的元素，容器大小变为 0。 | 是 | 是 |
| swap() | 交换两个容器的所有元素。 | 是 | 是 |
| sort() | 对元素进行排序。 | 是 | 是 |
| merge() | 合并两个有序容器。 | 是 | 是 |
| splice() | 移动指定位置前面的所有元素到另一个同类型的 list 中。 | 是 | - |
| splice_after() | 移动指定位置后面的所有元素到另一个同类型的 list 中。 | - | 是 |
注意，大家没有必要死记这些表，它们仅供参考。在深入了解到容器是如何组织元素以后，你会本能地知道哪个容器能使用哪些成员函数。
C++ array(STL array)容器用法详解
array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全（原因后续会讲），且效率并没有因此变差。
和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。
STL 还提供有可动态扩展或收缩存储空间的 vector 容器，后续章节会对其做详细介绍。
array 容器以类模板的形式定义在 头文件，并位于命名空间 std 中，如下所示：
namespace std{template <typename T, size_t N>class array;
}
因此，在使用该容器之前，代码中需引入 头文件，并默认使用 std 命令空间，如下所示：
#include <array>
using namespace std;
在 array<T,N> 类模板中，T 用于指明容器中的存储的具体数据类型，N 用于指明容器的大小，需要注意的是，这里的 N 必须是常量，不能用变量表示。
array 容器有多种初始化方式，如下代码展示了如何创建具有 10 个 double 类型元素的 array 容器：
std::array<double, 10> values;
提示，如果程序中已经默认指定了 std 命令空间，这里可以省略 std::。
由此，就创建好了一个名为 values 的 array 容器，其包含 10 个浮点型元素。但是，由于未显式指定这 10 个元素的值，因此使用这种方式创建的容器中，各个元素的值是不确定的（array 容器不会做默认初始化操作）。
通过如下创建 array 容器的方式，可以将所有的元素初始化为 0 或者和默认元素类型等效的值：
std::array<double, 10> values {};
使用该语句，容器中所有的元素都会被初始化为 0.0。
当然，在创建 array 容器的实例时，也可以像创建常规数组那样对元素进行初始化：
std::array<double, 10> values {0.5,1.0,1.5,,2.0};
可以看到，这里只初始化了前 4 个元素，剩余的元素都会被初始化为 0.0。图 1 说明了这一点。
图 1 初始化 array 容器
除此之外，array 容器还提供有很多功能实用的成员函数，如表 2 所示。
表 2 array容器成员函数汇总
| 成员函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的随机访问迭代器。 |
| end() | 返回指向容器最后一个元素之后一个位置的随机访问迭代器，通常和 begin() 结合使用。 |
| rbegin() | 返回指向最后一个元素的随机访问迭代器。 |
| rend() | 返回指向第一个元素之前一个位置的随机访问迭代器。 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上增加了 const 属性，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| size() | 返回容器中当前元素的数量，其值始终等于初始化 array 类的第二个模板参数 N。 |
| max_size() | 返回容器可容纳元素的最大数量，其值始终等于初始化 array 类的第二个模板参数 N。 |
| empty() | 判断容器是否为空，和通过 size()==0 的判断条件功能相同，但其效率可能更快。 |
| at(n) | 返回容器中 n 位置处元素的引用，该函数自动检查 n 是否在有效的范围内，如果不是则抛出 out_of_range 异常。 |
| front() | 返回容器中第一个元素的直接引用，该函数不适用于空的 array 容器。 |
| back() | 返回容器中最后一个元素的直接应用，该函数同样不适用于空的 array 容器。 |
| data() | 返回一个指向容器首个元素的指针。利用该指针，可实现复制容器中所有元素等类似功能。 |
| fill(val) | 将 val 这个值赋值给容器中的每个元素。 |
| array1.swap(array2) | 交换 array1 和 array2 容器中的所有元素，但前提是它们具有相同的长度和类型。 |
除此之外，C++ 11 标准库还新增加了 begin() 和 end() 这 2 个函数，和 array 容器包含的 begin() 和 end() 成员函数不同的是，标准库提供的这 2 个函数的操作对象，既可以是容器，还可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；如果操作对象是普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针（注意不是最后一个元素）。
另外，在 头文件中还重载了 get() 全局函数，该重载函数的功能是访问容器中指定的元素，并返回该元素的引用。
正是由于 array 容器中包含了 at() 这样的成员函数，使得操作元素时比普通数组更安全。
例如代码演示了表 2 中一部分成员函数的用法和功能：
#include <iostream>
//需要引入 array 头文件
#include <array>
using namespace std;
int main()
{std::array<int, 4> values{};//初始化 values 容器为 {0,1,2,3}for (int i = 0; i < values.size(); i++) {values.at(i) = i;}//使用 get() 重载函数输出指定位置元素cout << get<3>(values) << endl;//如果容器不为空，则输出容器中所有的元素if (!values.empty()) {for (auto val = values.begin(); val < values.end(); val++) {cout << *val << " ";}}
}
注意，代码中的 auto 关键字，可以使编译器自动判定变量的类型。运行这段代码，输出结果为：
3
0 1 2 3
表 2 中其他成员函数的用法，这里不再给出具体实例，有兴趣的读者，可自行根据各个函数的功能描述编写实例代码进行测试。
C++ STL array随机访问迭代器（精讲版）
在《C++ STL迭代器（iterator）》一节中，已经对迭代器做了详细的介绍，STL 为 array 容器配备了随机访问迭代器，该类迭代器是功能最强大的迭代器。本节将详细介绍 array 容器的迭代器的用法。
在 array 容器的模板类中，和随机访问迭代器相关的成员函数如表 1 所示。
表 1 array 支持迭代器的成员函数
| 成员函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。 |
| end() | 返回指向容器最后一个元素之后一个位置的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。此函数通常和 begin() 搭配使用。 |
| rbegin() | 返回指向最后一个元素的反向迭代器；如果是 const 类型容器，在该函数返回的是常量反向迭代器。 |
| rend() | 返回指向第一个元素之前一个位置的反向迭代器。如果是 const 类型容器，在该函数返回的是常量反向迭代器。此函数通常和 rbegin() 搭配使用。 |
| cbegin() | 和 begin() 功能类似，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
除此之外，C++ 11 标准新增的 begin() 和 end() 函数，当操作对象为 array 容器时，也和迭代器有关，其功能分别和表 1 中的 begin()、end() 成员函数相同，具有用法本节后续会做详细介绍。
这些成员函数的具体功能如图 2 所示。
图 2 迭代器的具体功能示意图
可以看到，根据它们的功能并结合实际场景的需要，这些成员函数通常是成对使用的，即 begin()/end()、rbegin()/rend()、cbegin()/cend()、crbegin()/crend() 各自成对搭配使用。不仅如此，这 4 对中 begin()/end() 和 cbegin()/cend()、rbegin()/rend() 和 crbegin()/crend() 的功能大致是相同的（如图 2 所示），唯一的区别就在于其返回的迭代器能否用来修改元素值。
值得一提的是，以上函数在实际使用时，其返回值类型都可以使用 auto 关键字代替，编译器可以自行判断出该迭代器的类型。
begin()/end() 和 cbegin()/cend()
array 容器模板类中的 begin() 和 end() 成员函数返回的都是正向迭代器，它们分别指向「首元素」和「尾元素+1」 的位置。在实际使用时，我们可以利用它们实现初始化容器或者遍历容器中元素的操作。
例如，可以在循环中显式地使用迭代器来初始化 values 容器的值：
#include <iostream>
//需要引入 array 头文件
#include <array>
using namespace std;
int main()
{array<int, 5>values;int h = 1;auto first = values.begin();auto last = values.end();//初始化 values 容器为{1,2,3,4,5}while (first != last){*first = h;++first;h++;}first = values.begin();while (first != last){cout << *first << " ";++first;}return 0;
}
输出结果为：
1 2 3 4 5
可以看出，迭代器对象是由 array 对象的成员函数 begin() 和 end() 返回的。我们可以像使用普通指针那样上使用迭代器对象。比如代码中，在保存了元素值后，使用前缀 ++ 运算符对 first 进行自增，当 first 等于 end 时，所有的元素都被设完值，循环结束。
与此同时，还可以使用全局的 begin() 和 end() 函数来从容器中获取迭代器，因为当操作对象为 array 容器时，它们和 begin()/end() 成员函数是通用的。所以上面代码中，first 和 last 还可以像下面这样定义：
auto first = std::begin(values);
auto last = std::end (values);
这样，容器中的一段元素可以由迭代器指定，这让我们有了对它们使用算法的可能。
需要注意的是，STL 标准库，不是只有 array 容器，当迭代器指向容器中的一个特定元素时，它们不会保留任何关于容器本身的信息，所以我们无法从迭代器中判断，它是指向 array 容器还是指向 vector 容器（该容器后续会讲）。
除此之外，array 模板类还提供了 cbegin() 和 cend() 成员函数，它们和 begin()/end() 唯一不同的是，前者返回的是 const 类型的正向迭代器，这就意味着，有 cbegin() 和 cend() 成员函数返回的迭代器，可以用来遍历容器内的元素，也可以访问元素，但是不能对所存储的元素进行修改。
举个例子：
#include <iostream>
//需要引入 array 头文件
#include <array>
using namespace std;
int main()
{array<int, 5>values{1,2,3,4,5};int h = 1;auto first = values.cbegin();auto last = values.cend();//由于 *first 为 const 类型，不能用来修改元素//*first = 10;//遍历容器并输出容器中所有元素while (first != last){//可以使用 const 类型迭代器访问元素cout << *first << " ";++first;}return 0;
}
此程序的第 14 行代码中，我们尝试使用 first 迭代器修改 values 容器中的值，如果取消注释并运行此程序，编译器会提示你“不能给常量赋值”，即 *first 是 const 类型常量，所以这么做是不对的。但 17~22 行代码遍历并访问容器的行为，是允许的。
rbegin()/rend() 和 crbegin()/crend()
array 模板类中还提供了 rbegin()/rend() 和 crbegin()/crend() 成员函数，它们每对都可以分别得到指向最一个元素和第一个元素前一个位置的随机访问迭代器，又称它们为反向迭代器（如图 2 所示）。
需要注意的是，在使用反向迭代器进行 ++ 或 – 运算时，++ 指的是迭代器向左移动一位，-- 指的是迭代器向右移动一位，即这两个运算符的功能也“互换”了。
反向迭代器用于以逆序的方式处理元素。例如：
#include <iostream>
//需要引入 array 头文件
#include <array>
using namespace std;
int main()
{array<int, 5>values;int h = 1;auto first = values.rbegin();auto last = values.rend(); //初始化 values 容器为 {5,4,3,2,1}while (first != last){*first = h;++first;h++;}//重新遍历容器，并输入各个元素first = values.rbegin();while (first != last){cout << *first << " ";++first;}return 0;
}
运行结果为：
1 2 3 4 5
可以看到，从最后一个元素开始循环，不仅完成了容器的初始化，还遍历输出了容器中的所有元素。结束迭代器指向第一个元素之前的位置，所以当 first 指向第一个元素并 +1 后，循环就结朿了。
在反向迭代器上使用 ++ 递增运算符，会让迭代器用一种和普通正向迭代器移动方向相反的方式移动。
当然，在上面程序中，我们也可以使用 for 循环：
for (auto first = values.rbegin(); first != values.rend(); ++first) {cout << *first << " ";
}
crbegin()/crend() 组合和 rbegin()/crend() 组合的功能唯一的区别在于，前者返回的迭代器为 const 类型，即不能用来修改容器中的元素，除此之外在使用上和后者完全相同。
有关 crbegin()/crend() 成员函数，这里不再给出具体实例，有兴趣的读者，可自行编写代码进行测试。
C++ STL array容器访问元素的几种方式
当 array 容器创建完成之后，最常做的操作就是获取其中的元素，甚至有时还会通过循环结构获取多个元素。本节就对获取容器中元素的方法做个汇总。
访问array容器中单个元素
首先，可以通过容器名[]的方式直接访问和使用容器中的元素，这和 C++ 标准数组访问元素的方式相同，例如：
values[4] = values[3] + 2.O*values[1];
此行代码中，第 5 个元素的值被赋值为右边表达式的值。需要注意的是，使用如上这样方式，由于没有做任何边界检查，所以即便使用越界的索引值去访问或存储元素，也不会被检测到。
为了能够有效地避免越界访问的情况，可以使用 array 容器提供的 at() 成员函数，例如 :
values.at (4) = values.at(3) + 2.O*values.at(1);
这行代码和前一行语句实现的功能相同，其次当传给 at() 的索引是一个越界值时，程序会抛出 std::out_of_range 异常。因此当需要访问容器中某个指定元素时，建议大家使用 at()，除非确定索引没有越界。
读者可能有这样一个疑问，即为什么 array 容器在重载 [] 运算符时，没有实现边界检查的功能呢？答案很简单，因为性能。如果每次访问元素，都去检查索引值，无疑会产生很多开销。当不存在越界访问的可能时，就能避免这种开销。
除此之外，array 容器还提供了 get 模板函数，它是一个辅助函数，能够获取到容器的第 n 个元素。需要注意的是，该模板函数中，参数的实参必须是一个在编译时可以确定的常量表达式，所以它不能是一个循环变量。也就是说，它只能访问模板参数指定的元素，编译器在编译时会对它进行检查。
下面代码展示了如何使用 get 模板函数：
#include <iostream>
#include <array>
#include <string>
using namespace std;
int main()
{array<string, 5> words{ "one","two","three","four","five" };cout << get<3>(words) << endl; // Output words[3]//cout << get<6>(words) << std::endl; //越界，会发生编译错误return 0;
}
运行结果为：
four
另外，array 容器提供了 data() 成员函数，通过调用该函数可以得到指向容器首个元素的指针。通过该指针，我们可以获得容器中的各个元素，例如：
#include <iostream>
#include <array>
using namespace std;
int main()
{array<int, 5> words{1,2,3,4,5};cout << *( words.data()+1);return 0;
}
运行结果为：
2
访问array容器中多个元素
我们知道，array 容器提供的 size() 函数能够返回容器中元素的个数（函数返回值为 size_t 类型），所以能够像下面这样去逐个提取容器中的元素，并计算它们的和：
double total = 0;
for(size_t i = 0 ; i < values.size() ; ++i)
{total += values[i];
}
size() 函数的存在，为 array 容器提供了标准数组所没有的优势，即能够知道它包含多少元素。
并且，接受数组容器作为参数的函数，只需要通过调用容器的成员函数 size()，就能得到元素的个数。除此之外，通过调用 array 容器的 empty() 成员函数，即可知道容器中有没有元素（如果容器中没有元素，此函数返回 true），如下所示：
if(values.empty())std::cout << "The container has no elements.\n";
elsestd::cout << "The container has "<< values.size()<<"elements.\n";
然而，很少会创建空的 array 容器，因为当生成一个 array 容器时，它的元素个数就固定了，而且无法改变，所以生成空 array 容器的唯一方法是将模板的第二个参数指定为 0，但这种情况基本不可能发生。
array 容器之所以提供 empty() 成员函数的原因，对于其他元素可变或者元素可删除的容器（例如 vector、deque 等）来说，它们使用 empty() 时的机制是一样的，因此为它们提供了一个一致性的操作。
除了借助 size() 外，对于任何可以使用迭代器的容器，都可以使用基于范围的循环，因此能够更加简便地计算容器中所有元素的和，比如：
double total = 0;
for(auto& value : values)total += value;下面是一个示例，展示了本节关于如何获取 array 容器中元素所讲到的知识：
#include <iostream>
#include <iomanip>
#include <array>
using namespace std;
int main()
{array<int, 5> values1;array<int, 5> values2;//初始化 values1 为 {0,1,2,3,4}for (size_t i = 0; i < values1.size(); ++i){values1.at(i) = i;}cout << "values1[0] is : " << values1[0] << endl;cout << "values1[1] is : " << values1.at(1) << endl;cout << "values1[2] is : " << get<2>(values1) << endl;//初始化 values2 为{10，11，12，13，14}int initvalue = 10;for (auto& value : values2){value = initvalue;initvalue++;}cout << "Values1 is : ";for (auto i = values1.begin(); i < values1.end(); i++) {cout << *i << " ";}cout << endl << "Values2 is : ";for (auto i = values2.begin(); i < values2.end(); i++) {cout << *i << " ";}return 0;
}
运行结果为：
values1[0] is : 0
values1[1] is : 1
values1[2] is : 2
Values1 is : 0 1 2 3 4
Values2 is : 10 11 12 13 14
size_t数据类型
size_t 是一些C/C++标准在stddef.h中定义的，size_t 类型表示C中任何对象所能达到的最大长度，它是无符号整数。
它是为了方便系统之间的移植而定义的，不同的系统上，定义size_t 可能不一样。size_t在32位系统上定义为 unsigned int，也就是32位无符号整型。在64位系统上定义为 unsigned long ，也就是64位无符号整形。size_t 的目的是提供一种可移植的方法来声明与系统中可寻址的内存区域一致的长度。
size_t 在数组下标和内存管理函数之类的地方广泛使用。例如，size_t 用做sizeof 操作符的返回值类型，同时也是很多函数的参数类型，包括malloc 和strlen。
在声明诸如字符数或者数组索引这样的长度变量时用size_t 是好的做法。它经常用于循环计数器、数组索引，有时候还用在指针算术运算上。size_t 的声明是实现相关的。它出现在一个或多个标准头文件中，比如stdio.h 和stblib.h，典型的定义如下：
#ifndef __SIZE_T
#define __SIZE_T
typedef unsigned int size_t;
#endif
define 指令确保它只被定义一次。实际的长度取决于实现。通常在32 位系统上它的长度是32 位，而在64 位系统上则是64 位。一般来说，size_t 可能的最大值是SIZE_MAX。
打印size_t 类型的值时要小心。这是无符号值，如果选错格式说明符，可能会得到不可靠的结果。推荐的格式说明符是%zu。不过，某些情况下不能用这个说明符， 作为替代，可以考虑%u 或%lu。下面这个例子将一个变量定义为size_t，然后用两种不同的格式说明符来打印：
size_t sizet = -5;
printf("%d\n",sizet);
printf("%zu\n",sizet);
因为size_t 本来是用于表示正整数的，如果用来表示负数就会出问题。如果为其赋一个负数，然后用%d 和%zu 格式说明符打印，就得到如下结果：
-5
4294967291
%d 把size_t 当做有符号整数，它打印出-5 因为变量中存放的就是-5。%zu 把size_t 当做无符号整数。当-5 被解析为有符号数时，高位置为1，表示这个数是负数。当它被解析为无符号数时，高位的1 被当做2 的乘幂。所以在用%zu 格式说明符时才会看到那个大整数。
sizet = 5;
printf("%d\n",sizet); // 显示5
printf("%zu\n",sizet); // 显示5
因为size_t 是无符号的，一定要给这种类型的变量赋正数 。
C++ 的迭代器 中 != 与<
C++ 的迭代器，循环操作中，一般都是使用iterator iter != *.end(),而一般不使用 iterator iter < *.end(). 这是为何?是习惯问题还是会因此导致错误?
iterator并不是真正的指针！！！
iterator通过重载++运算符来实现对容器类中下一元素的访问，而且通过重载引用运算符(&)和解引用运算符(*)使iterator表现出指针的行为。
因此在语句
for(iterator iter=*.begin();iter < *.end();iter++)
{
…
}
中，
如果不是顺序容器，在iter未遍历完容器之前，iter++操作可能导致iter的值大于.end()，从而使得循环出乎意料的结束
所以迭代器在for循环中访问元素的时候最好判断条件用！=而不用> < >= <=
C++ array容器：普通数组的“升级版”
和 C++ 普通数组存储数据的方式一样，C++ 标准库保证使用 array 容器存储的所有元素一定会位于连续且相邻的内存中，通过如下代码也可以验证这一点：
#include <iostream>
#include <array>
using namespace std;
int main()
{array<int, 5>a{1,2,3};cout << &a[2] << " " << &a[0] + 2 << endl;return 0;
}
输出结果为：
004FFD58 004FFD58
可以看到，a 容器中 &a[2] 和 &a[0] + 2 是相等的。因此在实际编程过程中，我们完全有理由去尝试，在原本使用普通数组的位置，改由 array 容器去实现。
用 array 容器替换普通数组的好处是，array 模板类中已经封装好了大量实用的方法，在提高开发效率的同时，代码的运行效率也会大幅提高。
举个例子，我们完全可以使用 array 容器去存储 char* 或 const char* 类型的字符串：
#include <iostream>
#include <array>
using namespace std;
int main()
{array<char, 50>a{1,2,3};strcpy(&a[0], "http://c.biancheng.net/stl");printf("%s", &a[0]);return 0;
}
输出结果为：
http://c.biancheng.net/stl
注意，array 容器的大小必须保证能够容纳复制进来的数据，而且如果是存储字符串的话，还要保证在存储整个字符串的同时，在其最后放置一个\0作为字符串的结束符。此程序中，strcpy() 在拷贝字符串的同时，会自动在最后添加\0。
其实，代码中的 &a[0] 还可以用 array 模板类提供的 data() 成员函数来替换：
#include <iostream>
#include <array>
using namespace std;
int main()
{array<char, 50>a{1,2,3};strcpy(a.data(), "http://c.biancheng.net/stl");printf("%s", a.data());return 0;
}
此程序和上面程序的输出结果完全相同。
注意，容器的迭代器和指针是不能混用的，即上面代码中不能用 a.begin() 来代替 &a[0] 或者 a.data[]，这可能会引发错误。
文章前面提到，使用 array 容器代替普通数组，最直接的好处就是 array 模板类中已经为我们写好了很多实用的方法，可以大大提高我们编码效率。例如，array 容器提供的 at() 成员函数，可以有效防止越界操纵数组的情况；fill() 函数可以实现数组的快速初始化；swap() 函数可以轻松实现两个相同数组（类型相同，大小相同）中元素的互换。
#include <iostream>
#include <array>
using namespace std;
int main()
{array<char, 50>addr1{"http://c.biancheng.net"};array<char, 50>addr2{ "http://c.biancheng.net/stl" };addr1.swap(addr2);printf("addr1 is：%s\n", addr1.data());printf("addr2 is：%s\n", addr2.data());return 0;
}
运行结果为：
addr1 is：http://c.biancheng.net/stl
addr2 is：http://c.biancheng.net
另外，当两个 array 容器满足大小相同并且保存元素的类型相同时，两个 array 容器可以直接直接做赋值操作，即将一个容器中的元素赋值给另一个容器。比如：
#include <iostream>
#include <array>
using namespace std;
int main()
{array<char, 50>addr1{ "http://c.biancheng.net" };array<char, 50>addr2{ "http://c.biancheng.net/stl" };addr1 = addr2;printf("%s", addr1.data());return 0;
}
运行结果为：
http://c.biancheng.net/stl
不仅如此，在满足以上 2 个条件的基础上，如果其保存的元素也支持比较运算符，就可以用任何比较运算符直接比较两个 array 容器。示例如下：
#include <iostream>
#include <array>
using namespace std;
int main()
{array<char, 50>addr1{ "http://c.biancheng.net" };array<char, 50>addr2{ "http://c.biancheng.net/stl" };if (addr1 == addr2) {std::cout << "addr1 == addr2" << std::endl;}if (addr1 < addr2) {std::cout << "addr1 < addr2" << std::endl;}if (addr1 > addr2) {std::cout << "addr1 > addr2" << std::endl;}return 0;
}
运行结果为：
addr1 < addr2
两个容器比较大小的原理，和两个字符串比较大小是一样的，即从头开始，逐个取两容器中的元素进行大小比较（根据 ASCII 码表），直到遇到两个不相同的元素，那个元素的值大，则该容器就大。
总之，读者可以这样认为，array 容器就是普通数组的“升级版”，使用普通数组能实现的，使用 array 容器都可以实现，而且无论是代码功能的实现效率，还是程序执行效率，都比普通数组更高。
C++ STL vector容器详解
vector 容器是 STL 中最常用的容器之一，它和 array 容器非常类似，都可以看做是对 C++ 普通数组的“升级版”。不同之处在于，array 实现的是静态数组（容量固定的数组），而 vector 实现的是一个动态数组，即可以进行元素的插入和删除，在此过程中，vector 会动态调整所占用的内存空间，整个过程无需人工干预。
vector 常被称为向量容器，因为该容器擅长在尾部插入或删除元素，在常量时间内就可以完成，时间复杂度为O(1)；而对于在容器头部或者中部插入或删除元素，则花费时间要长一些（移动元素需要耗费时间），时间复杂度为线性阶O(n)。
vector 容器以类模板 vector（ T 表示存储元素的类型）的形式定义在 头文件中，并位于 std 命名空间中。因此，在创建该容器之前，代码中需包含如下内容：
#include <vector>
using namespace std;
注意，std 命名空间也可以在使用 vector 容器时额外注明，两种方式都可以。
创建vector容器的几种方式
创建 vector 容器的方式有很多，大致可分为以下几种。
- 如下代码展示了如何创建存储 double 类型元素的一个 vector 容器：
std::vector<double> values;
如果程序中已经默认指定了 std 命令空间，这里可以省略 std::。
注意，这是一个空的 vector 容器，因为容器中没有元素，所以没有为其分配空间。当添加第一个元素（比如使用 push_back() 函数）时，vector 会自动分配内存。
在创建好空容器的基础上，还可以像下面这样通过调用 reserve() 成员函数来增加容器的容量：
values.reserve(20);
这样就设置了容器的内存分配，即至少可以容纳 20 个元素。注意，如果 vector 的容量在执行此语句之前，已经大于或等于 20 个元素，那么这条语句什么也不做；另外，调用 reserve() 不会影响已存储的元素，也不会生成任何元素，即 values 容器内此时仍然没有任何元素。
还需注意的是，如果调用 reserve() 来增加容器容量，之前创建好的任何迭代器（例如开始迭代器和结束迭代器）都可能会失效，这是因为，为了增加容器的容量，vector 容器的元素可能已经被复制或移到了新的内存地址。所以后续再使用这些迭代器时，最好重新生成一下。
- 除了创建空 vector 容器外，还可以在创建的同时指定初始值以及元素个数，比如：
std::vector<int> primes {2, 3, 5, 7, 11, 13, 17, 19};
这样就创建了一个含有 8 个素数的 vector 容器。
- 在创建 vector 容器时，也可以指定元素个数：
std::vector<double> values(20);
如此，values 容器开始时就有 20 个元素，它们的默认初始值都为 0。
注意，圆括号 () 和大括号 {} 是有区别的，前者（例如 (20) ）表示元素的个数，而后者（例如 {20} ） 则表示 vector 容器中只有一个元素 20。
如果不想用 0 作为默认值，也可以指定一个其它值，例如：
std::vector<double> values(20, 1.0);
第二个参数指定了所有元素的初始值，因此这 20 个元素的值都是 1.0。
值得一提的是，圆括号 () 中的 2 个参数，既可以是常量，也可以用变量来表示，例如：
int num=20;
double value =1.0;
std::vector<double> values(num, value);
- 通过存储元素类型相同的其它 vector 容器，也可以创建新的 vector 容器，例如：
std::vector<char>value1(5, 'c');
std::vector<char>value2(value1);
由此，value2 容器中也具有 5 个字符 ‘c’。在此基础上，如果不想复制其它容器中所有的元素，可以用一对指针或者迭代器来指定初始值的范围，例如：
int array[]={1,2,3};
std::vector<int>values(array, array+2);//values 将保存{1,2}
std::vector<int>value1{1,2,3,4,5};
std::vector<int>value2(std::begin(value1),std::begin(value1)+3);//value2保存{1,2,3}
由此，value2 容器中就包含了 {1,2,3} 这 3 个元素。
vector容器包含的成员函数
相比 array 容器，vector 提供了更多了成员函数供我们使用，它们各自的功能如表 1 所示。
表 1 vector 容器的成员函数
| 函数成员 | 函数功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的迭代器。 |
| end() | 返回指向容器最后一个元素所在位置后一个位置的迭代器，通常和 begin() 结合使用。 |
| rbegin() | 返回指向最后一个元素的迭代器。 |
| rend() | 返回指向第一个元素所在位置前一个位置的迭代器。 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| size() | 返回实际元素个数。 |
| max_size() | 返回元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。 |
| resize() | 改变实际元素的个数。 |
| capacity() | 返回当前容量。 |
| empty() | 判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。 |
| reserve() | 增加容器的容量。 |
| shrink _to_fit() | 将内存减少到等于当前元素实际所使用的大小。 |
| operator[ ] | 重载了 [ ] 运算符，可以向访问数组中元素那样，通过下标即可访问甚至修改 vector 容器中的元素。 |
| at() | 使用经过边界检查的索引访问元素。 |
| front() | 返回第一个元素的引用。 |
| back() | 返回最后一个元素的引用。 |
| data() | 返回指向容器中第一个元素的指针。 |
| assign() | 用新元素替换原有内容。 |
| push_back() | 在序列的尾部添加一个元素。 |
| pop_back() | 移出序列尾部的元素。 |
| insert() | 在指定的位置插入一个或多个元素。 |
| erase() | 移出一个元素或一段元素。 |
| clear() | 移出所有的元素，容器大小变为 0。 |
| swap() | 交换两个容器的所有元素。 |
| emplace() | 在指定的位置直接生成一个元素。 |
| emplace_back() | 在序列尾部生成一个元素。 |
除此之外，C++ 11 标准库还新增加了 begin() 和 end() 这 2 个函数，和 vector 容器包含的 begin() 和 end() 成员函数不同，标准库提供的这 2 个函数的操作对象，既可以是容器，还可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；如果操作对象是普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针（注意不是最后一个元素）。
vector 容器还有一个 std::swap(x , y) 非成员函数（其中 x 和 y 是存储相同类型元素的 vector 容器），它和 swap() 成员函数的功能完全相同，仅使用语法上有差异。
如下代码演示了表 1 中部分成员函数的用法：
#include <iostream>
#include <vector>
using namespace std;
int main()
{//初始化一个空vector容量vector<char>value;//向value容器中的尾部依次添加 S、T、L 字符value.push_back('S');value.push_back('T');value.push_back('L');//调用 size() 成员函数容器中的元素个数printf("元素个数为：%d\n", value.size());//使用迭代器遍历容器for (auto i = value.begin(); i < value.end(); i++) {cout << *i << " ";}cout << endl;//向容器开头插入字符value.insert(value.begin(), 'C');cout << "首个元素为：" << value.at(0) << endl;return 0;
}
输出结果为：
元素个数为：3
S T L
首个元素为：C
表 1 中这些成员函数的具体用法，后续学习用到时会具体讲解，感兴趣的读者，也可以通过查阅 STL手册做详细了解。
C++ STL vector容器迭代器用法详解
在《STL array随机访问迭代器》一节中，详细介绍了 array 容器迭代器，vector 容器迭代器和前者有很多相同之处。比如，vector 容器的迭代器也是随机访问迭代器，并且 vector 模板类提供的操作迭代器的成员函数也和 array 容器一样（如表 1 所示）。
表 1 vector 支持迭代器的成员函数
| 成员函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。 |
| end() | 返回指向容器最后一个元素之后一个位置的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。此函数通常和 begin() 搭配使用。 |
| rbegin() | 返回指向最后一个元素的反向迭代器；如果是 const 类型容器，在该函数返回的是常量反向迭代器。 |
| rend() | 返回指向第一个元素之前一个位置的反向迭代器。如果是 const 类型容器，在该函数返回的是常量反向迭代器。此函数通常和 rbegin() 搭配使用。 |
| cbegin() | 和 begin() 功能类似，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
除此之外，C++ 11 新添加的 begin() 和 end() 全局函数也同样适用于 vector 容器。即当操作对象为 vector 容器时，其功能分别和表 1 中的 begin()、end() 成员函数相同，具体用法本节后续会做详细介绍。
表 1 中这些成员函数的具体功能如图 2 所示。
图 2 迭代器的具体功能示意图
从图 2 可以看出，这些成员函数通常是成对使用的，即 begin()/end()、rbegin()/rend()、cbegin()/cend()、crbegin()/crend() 各自成对搭配使用。其中，begin()/end() 和 cbegin/cend() 的功能是类似的，同样 rbegin()/rend() 和 crbegin()/crend() 的功能是类似的。
值得一提的是，以上函数在实际使用时，其返回值类型都可以使用 auto 关键字代替，编译器可以自行判断出该迭代器的类型。
vector容器迭代器的基本用法
vector 容器迭代器最常用的功能就是遍历访问容器中存储的元素。
首先来看 begin() 和 end() 成员函数，它们分别用于指向「首元素」和「尾元素+1」 的位置，下面程序演示了如何使用 begin() 和 end() 遍历 vector 容器并输出其中的元素：
#include <iostream>
//需要引入 vector 头文件
#include <vector>
using namespace std;
int main()
{vector<int>values{1,2,3,4,5};auto first = values.begin();auto end = values.end();while (first != end){cout << *first << " ";++first;}return 0;
}
输出结果为：
1 2 3 4 5
可以看到，迭代器对象是由 vector 对象的成员函数 begin() 和 end() 返回的。我们可以像使用普通指针那样上使用它们。比如代码中，在保存了元素值后，使用前缀++运算符对 first 进行自增，当 first 等于 end 时，所有的元素都被设完值，循环结束。
与此同时，还可以使用全局的 begin() 和 end() 函数来从容器中获取迭代器，比如将上面代码中第 8、9 行代码用如下代码替换：
auto first = std::begin(values);
auto end = std::end (values);
cbegin()/cend() 成员函数和 begin()/end() 唯一不同的是，前者返回的是 const 类型的正向迭代器，这就意味着，由 cbegin() 和 cend() 成员函数返回的迭代器，可以用来遍历容器内的元素，也可以访问元素，但是不能对所存储的元素进行修改。
举个例子：
#include <iostream>
//需要引入 vector 头文件
#include <vector>
using namespace std;
int main()
{vector<int>values{1,2,3,4,5};auto first = values.cbegin();auto end = values.cend();while (first != end){//*first = 10;不能修改元素cout << *first << " ";++first;}return 0;
}
程序第 12 行，由于 first 是 const 类型的迭代器，因此不能用于修改容器中元素的值。
vector 模板类中还提供了 rbegin() 和 rend() 成员函数，分别表示指向最后一个元素和第一个元素前一个位置的随机访问迭代器，又称它们为反向迭代器（如图 2 所示）。
需要注意的是，在使用反向迭代器进行 ++ 或 – 运算时，++ 指的是迭代器向左移动一位，-- 指的是迭代器向右移动一位，即这两个运算符的功能也“互换”了。
反向迭代器用于以逆序的方式遍历容器中的元素。例如：
#include <iostream>
//需要引入 vector 头文件
#include <vector>
using namespace std;
int main()
{vector<int>values{1,2,3,4,5};auto first = values.rbegin();auto end = values.rend();while (first != end){cout << *first << " ";++first;}return 0;
}
运行结果为：
5 4 3 2 1
可以看到，从最后一个元素开始循环，遍历输出了容器中的所有元素。结束迭代器指向第一个元素之前的位置，所以当 first 指向第一个元素并 +1 后，循环就结朿了。
当然，在上面程序中，我们也可以使用 for 循环：
for (auto first = values.rbegin(); first != values.rend(); ++first) {cout << *first << " ";
}
crbegin()/crend() 组合和 rbegin()/crend() 组合唯一的区别在于，前者返回的迭代器为 const 类型，即不能用来修改容器中的元素，除此之外在使用上和后者完全相同。
有关 crbegin()/crend() 成员函数，这里不再给出具体实例，有兴趣的读者，可自行编写代码进行测试。
vector容器迭代器的独特之处
和 array 容器不同，vector 容器可以随着存储元素的增加，自行申请更多的存储空间。因此，在创建 vector 对象时，我们可以直接创建一个空的 vector 容器，并不会影响后续使用该容器。
但这会产生一个问题，即在初始化空的 vector 容器时，不能使用迭代器。也就是说，如下初始化 vector 容器的方法是不行的：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>values;int val = 1;for (auto first = values.begin(); first < values.end(); ++first, val++) {*first = val;//初始化的同时输出值cout << *first;}return 0;
}
运行程序可以看到，什么也没有输出。这是因为，对于空的 vector 容器来说，begin() 和 end() 成员函数返回的迭代器是相等的，即它们指向的是同一个位置。
所以，对于空的 vector 容器来说，可以通过调用 push_back() 或者借助 resize() 成员函数实现初始化容器的目的。
除此之外，vector 容器在申请更多内存的同时，容器中的所有元素可能会被复制或移动到新的内存地址，这会导致之前创建的迭代器失效。
举个例子：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>values{1,2,3};cout << "values 容器首个元素的地址：" << values.data() << endl;auto first = values.begin();auto end = values.end();//增加 values 的容量values.reserve(20);cout << "values 容器首个元素的地址：" << values.data() << endl;while (first != end) {cout << *first;++first;}return 0;
}
运行程序，显示如下信息并崩溃：
values 容器首个元素的地址：0096DFE8
values 容器首个元素的地址：00965560
可以看到，values 容器在增加容量之后，首个元素的存储地址发生了改变，此时再使用先前创建的迭代器，显然是错误的。因此，为了保险起见，每当 vector 容器的容量发生变化时，我们都要对之前创建的迭代器重新初始化一遍：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>values{1,2,3};cout << "values 容器首个元素的地址：" << values.data() << endl;auto first = values.begin();auto end = values.end();//增加 values 的容量values.reserve(20);cout << "values 容器首个元素的地址：" << values.data() << endl;first = values.begin();end = values.end();while (first != end) {cout << *first ;++first;}return 0;
}
运行结果为：
values 容器首个元素的地址：0164DBE8
values 容器首个元素的地址：01645560
123
C++ STL vector容器访问元素的几种方式
学会如何创建并初始化 vector 容器之后，本节继续来学习如何获取（甚至修改）容器中存储的元素。
访问vector容器中单个元素
首先，vector 容器可以向普通数组那样访问存储的元素，甚至对指定下标处的元素进行修改，比如：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{1,2,3,4,5};//获取容器中首个元素cout << values[0] << endl;//修改容器中下标为 0 的元素的值values[0] = values[1] + values[2] + values[3] + values[4];cout << values[0] << endl;return 0;
}
运行结果为：
1
14
显然，vector 的索引从 0 开始，这和普通数组一样。通过使用索引，总是可以访问到 vector 容器中现有的元素。
值得一提的是，容器名[n]这种获取元素的方式，需要确保下标 n 的值不会超过容器的容量（可以通过 capacity() 成员函数获取），否则会发生越界访问的错误。幸运的是，和 array 容器一样，vector 容器也提供了 at() 成员函数，当传给 at() 的索引会造成越界时，会抛出std::out_of_range异常。
举个例子：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{1,2,3,4,5};//获取容器中首个元素cout << values.at(0) << endl;//修改容器中下标为 0 的元素的值values.at(0) = values.at(1) + values.at(2) + values.at(3) + values.at(4);cout << values.at(0) << endl;//下面这条语句会发生 out_of_range 异常//cout << values.at(5) << endl;return 0;
}
运行结果为：
1
14
读者可能有这样一个疑问，即为什么 vector 容器在重载 [] 运算符时，没有实现边界检查的功能呢？答案很简单，因为性能。如果每次访问元素，都去检查索引值，无疑会产生很多开销。当不存在越界访问的可能时，就能避免这种开销。
除此之外，vector 容器还提供了 2 个成员函数，即 front() 和 back()，它们分别返回 vector 容器中第一个和最后一个元素的引用，通过利用这 2 个函数返回的引用，可以访问（甚至修改）容器中的首尾元素。
举个例子：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{1,2,3,4,5};cout << "values 首元素为：" << values.front() << endl;cout << "values 尾元素为：" << values.back() << endl;//修改首元素values.front() = 10;cout <<"values 新的首元素为：" << values.front() << endl;//修改尾元素values.back() = 20;cout << "values 新的尾元素为：" << values.back() << endl;return 0;
}
输出结果为：
values 首元素为：1
values 尾元素为：5
values 新的首元素为：10
values 新的尾元素为：20
另外，vector 容器还提供了 data() 成员函数，该函数的功能是返回指向容器中首个元素的指针。通过该指针也可以访问甚至修改容器中的元素。比如：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{1,2,3,4,5};//输出容器中第 3 个元素的值cout << *(values.data() + 2) << endl;//修改容器中第 2 个元素的值*(values.data() + 1) = 10;cout << *(values.data() + 1) << endl;return 0;
}
运行结果为：
3
10
访问vector容器中多个元素
如果想访问 vector 容器中多个元素，可以借助 size() 成员函数，该函数可以返回 vector 容器中实际存储的元素个数。例如：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{1,2,3,4,5};//从下标 0 一直遍历到 size()-1 处for (int i = 0; i < values.size(); i++) {cout << values[i] << " ";}return 0;
}
运行结果为：
1 2 3 4 5
注意，这里不要使用 capacity() 成员函数，因为它返回的是 vector 容器的容量，而不是实际存储元素的个数，这两者是有差别的。
关于 vector 容器 capacity() 和 size() 的差别，可以阅读 《STL vector容量（capacity）和大小（size）的区别》一文。
或者也可以使用基于范围的循环，此方式将会逐个遍历容器中的元素。比如：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{1,2,3,4,5};for (auto&& value : values)cout << value << " ";return 0;
}
运行结果为：
1 2 3 4 5
另外还可以使用 vector 迭代器遍历 vector 容器，这里以 begin()/end() 为例：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{1,2,3,4,5};for (auto first = values.begin(); first < values.end(); ++first) {cout << *first << " ";}return 0;
}
运行结果为：
1 2 3 4 5
当然，这里也可以使用 rbegin()/rend()、cbegin()/cend()、crbegin()/crend() 以及全局函数 begin()/end() ，它们都可以实现对容器中元素的访问。
C++ vector容量（capacity）和大小（size）的区别
很多初学者分不清楚 vector 容器的容量（capacity）和大小（size）之间的区别，甚至有人认为它们表达的是一个意思。本节将对 vector 容量和大小各自的含义做一个详细的介绍。
vector 容器的容量（用 capacity 表示），指的是在不分配更多内存的情况下，容器可以保存的最多元素个数；而 vector 容器的大小（用 size 表示），指的是它实际所包含的元素个数。
对于一个 vector 对象来说，通过该模板类提供的 capacity() 成员函数，可以获得当前容器的容量；通过 size() 成员函数，可以获得容器当前的大小。例如：
#include <iostream>
#include <vector>
using namespace std;
int main()
{std::vector<int>value{ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47 };value.reserve(20);cout << "value 容量是：" << value.capacity() << endl;cout << "value 大小是：" << value.size() << endl;return 0;
}
程序输出结果为：
value 容量是：20
value 大小是：15
结合该程序的输出结果，图 1 可以更好的说明 vector 容器容量和大小之间的关系。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qfGfolYF-1692322969476)(file:///C:/Users/10789/Desktop/c%E8%AF%AD%E8%A8%80%E4%B8%AD%E6%96%87%E7%BD%91/STL/2.11C++%20vector%E5%AE%B9%E9%87%8F%EF%BC%88capacity%EF%BC%89%E5%92%8C%E5%A4%A7%E5%B0%8F%EF%BC%88size%EF%BC%89%E7%9A%84%E5%8C%BA%E5%88%AB_files/2-1P912104441553.jpg)]
显然，vector 容器的大小不能超出它的容量，在大小等于容量的基础上，只要增加一个元素，就必须分配更多的内存。注意，这里的“更多”并不是 1 个。换句话说，当 vector 容器的大小和容量相等时，如果再向其添加（或者插入）一个元素，vector 往往会申请多个存储空间，而不仅仅只申请 1 个。
一旦 vector 容器的内存被重新分配，则和 vector 容器中元素相关的所有引用、指针以及迭代器，都可能会失效，最稳妥的方法就是重新生成。
举个例子：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>value{ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47 };cout << "value 容量是：" << value.capacity() << endl;cout << "value 大小是：" << value.size() << endl;printf("value首地址：%p\n", value.data());value.push_back(53);cout << "value 容量是(2)：" << value.capacity() << endl;cout << "value 大小是(2)：" << value.size() << endl;printf("value首地址： %p", value.data());return 0;
}
运行结果为：
value 容量是：15
value 大小是：15
value首地址：01254D40
value 容量是(2)：22
value 大小是(2)：16
value首地址： 01254E80
可以看到，向“已满”的 vector 容器再添加一个元素，整个 value 容器的存储位置发生了改变，同时 vector 会一次性申请多个存储空间（具体多少，取决于底层算法的实现）。这样做的好处是，可以很大程度上减少 vector 申请空间的次数，当后续再添加元素时，就可以节省申请空间耗费的时间。
因此，对于 vector 容器而言，当增加新的元素时，有可能很快完成（即直接存在预留空间中）；也有可能会慢一些（扩容之后再放新元素）。
修改vector容器的容量和大小
另外，通过前面的学习我们知道，可以调用 reserve() 成员函数来增加容器的容量（但并不会改变存储元素的个数）；而通过调用成员函数 resize() 可以改变容器的大小，并且该函数也可能会导致 vector 容器容量的增加。比如说：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>value{ 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47 };cout << "value 容量是：" << value.capacity() << endl;cout << "value 大小是：" << value.size() << endl;value.reserve(20);cout << "value 容量是(2)：" << value.capacity() << endl;cout << "value 大小是(2)：" << value.size() << endl;//将元素个数改变为 21 个，所以会增加 6 个默认初始化的元素value.resize(21);//将元素个数改变为 21 个，新增加的 6 个元素默认值为 99。//value.resize(21,99);//当需要减小容器的大小时，会移除多余的元素。//value.resize(20);cout << "value 容量是(3)：" << value.capacity() << endl;cout << "value 大小是(3)：" << value.size() << endl;return 0;
}
运行结果为：
value 容量是：15
value 大小是：15
value 容量是(2)：20
value 大小是(2)：15
value 容量是(3)：30
value 大小是(3)：21
程序中给出了关于 resize() 成员函数的 3 种不同的用法，有兴趣的读者可自行查看不同用法的运行结果。
可以看到，仅通过 reserve() 成员函数增加 value 容器的容量，其大小并没有改变；但通过 resize() 成员函数改变 value 容器的大小，它的容量可能会发生改变。另外需要注意的是，通过 resize() 成员函数减少容器的大小（多余的元素会直接被删除），不会影响容器的容量。
vector容器容量和大小的数据类型
在实际场景中，我们可能需要将容器的容量和大小保存在变量中，要知道 vector 对象的容量和大小类型都是 vector::size_type 类型。因此，当定义一个变量去保存这些值时，可以如下所示：
vector<int>::size_type cap = value.capacity();
vector<int>::size_type size = value.size();
size_type 类型是定义在由 vector 类模板生成的 vecotr 类中的，它表示的真实类型和操作系统有关，在 32 位架构下普遍表示的是 unsigned int 类型，而在 64 位架构下普通表示 unsigned long 类型。
当然，我们还可以使用 auto 关键字代替 vector::size_type，比如：
auto cap = value.capacity();
auto size = value.size();
C++ vector（STL vector）底层实现机制（通俗易懂）
STL 众多容器中，vector 是最常用的容器之一，其底层所采用的数据结构非常简单，就只是一段连续的线性内存空间。
通过分析 vector 容器的源代码不难发现，它就是使用 3 个迭代器（可以理解成指针）来表示的：
//_Alloc 表示内存分配器，此参数几乎不需要我们关心
template <class _Ty, class _Alloc = allocator<_Ty>>
class vector{...
protected:pointer _Myfirst;pointer _Mylast;pointer _Myend;
};
其中，_Myfirst 指向的是 vector 容器对象的起始字节位置；_Mylast 指向当前最后一个元素的末尾字节；_myend 指向整个 vector 容器所占用内存空间的末尾字节。
图 1 演示了以上这 3 个迭代器分别指向的位置。
图 1 vector实现原理示意图
如图 1 所示，通过这 3 个迭代器，就可以表示出一个已容纳 2 个元素，容量为 5 的 vector 容器。
在此基础上，将 3 个迭代器两两结合，还可以表达不同的含义，例如：
- _Myfirst 和 _Mylast 可以用来表示 vector 容器中目前已被使用的内存空间；
- _Mylast 和 _Myend 可以用来表示 vector 容器目前空闲的内存空间；
- _Myfirst 和 _Myend 可以用表示 vector 容器的容量。
对于空的 vector 容器，由于没有任何元素的空间分配，因此 _Myfirst、_Mylast 和 _Myend 均为 null。
通过灵活运用这 3 个迭代器，vector 容器可以轻松的实现诸如首尾标识、大小、容器、空容器判断等几乎所有的功能，比如：
template <class _Ty, class _Alloc = allocator<_Ty>>
class vector{
public：iterator begin() {return _Myfirst;}iterator end() {return _Mylast;}size_type size() const {return size_type(end() - begin());}size_type capacity() const {return size_type(_Myend - begin());}bool empty() const {return begin() == end();}reference operator[] (size_type n) {return *(begin() + n);}reference front() { return *begin();}reference back() {return *(end()-1);}...
};
vector扩大容量的本质
另外需要指明的是，当 vector 的大小和容量相等（size==capacity）也就是满载时，如果再向其添加元素，那么 vector 就需要扩容。vector 容器扩容的过程需要经历以下 3 步：
- 完全弃用现有的内存空间，重新申请更大的内存空间；
- 将旧内存空间中的数据，按原有顺序移动到新的内存空间中；
- 最后将旧的内存空间释放。
这也就解释了，为什么 vector 容器在进行扩容后，与其相关的指针、引用以及迭代器可能会失效的原因。
由此可见，vector 扩容是非常耗时的。为了降低再次分配内存空间时的成本，每次扩容时 vector 都会申请比用户需求量更多的内存空间（这也就是 vector 容量的由来，即 capacity>=size），以便后期使用。
vector 容器扩容时，不同的编译器申请更多内存空间的量是不同的。以 VS 为例，它会扩容现有容器容量的 50%。
重新分配空间会导致运行效率降低，迭代器失效。此外vector往中间插入元素可能导致很多后续的元素要执行重新构造，析构。效率会非常之低。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WxDVmzmy-1692322969477)(D:/typora-user-images/image-20230815151738868.png)]
C++ STL vector添加元素（push_back()和emplace_back()）详解
要知道，向 vector 容器中添加元素的唯一方式就是使用它的成员函数，如果不调用成员函数，非成员函数既不能添加也不能删除元素。这意味着，vector 容器对象必须通过它所允许的函数去访问，迭代器显然不行。
在 《STL vector容器详解》一节中，已经给大家列出了 vector 容器提供的所有成员函数，在这些成员函数中，可以用来给容器中添加元素的函数有 2 个，分别是 push_back() 和 emplace_back() 函数。
有读者可能认为还有 insert() 和 emplace() 成员函数，严格意义上讲，这 2 个成员函数的功能是向容器中的指定位置插入元素，后续章节会对它们做详细的介绍。
push_back()
该成员函数的功能是在 vector 容器尾部添加一个元素，用法也非常简单，比如：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{};values.push_back(1);values.push_back(2);for (int i = 0; i < values.size(); i++) {cout << values[i] << " ";}return 0;
}
程序中，第 7 行代码表示向 values 容器尾部添加一个元素，但由于当前 values 容器是空的，因此新添加的元素 1 无疑成为了容器中首个元素；第 8 行代码实现的功能是在现有元素 1 的后面，添加元素 2。
运行程序，输出结果为：
1 2
emplace_back()
该函数是 C++ 11 新增加的，其功能和 push_back() 相同，都是在 vector 容器的尾部添加一个元素。
emplace_back() 成员函数的用法也很简单，这里直接举个例子：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int> values{};values.emplace_back(1);values.emplace_back(2);for (int i = 0; i < values.size(); i++) {cout << values[i] << " ";}return 0;
}
运行结果为：
1 2
读者可能会发现，以上 2 段代码，只是用 emplace_back() 替换了 push_back()，既然它们实现的功能是一样的，那么 C++ 11 标准中为什么要多此一举呢？
emplace_back()和push_back()的区别
emplace_back() 和 push_back() 的区别，就在于底层实现的机制不同。push_back() 向容器尾部添加元素时，首先会创建这个元素，然后再将这个元素拷贝或者移动到容器中（如果是拷贝的话，事后会自行销毁先前创建的这个元素）；而 emplace_back() 在实现时，则是直接在容器尾部创建这个元素，省去了拷贝或移动元素的过程。
为了让大家清楚的了解它们之间的区别，我们创建一个包含类对象的 vector 容器，如下所示：
#include <vector>
#include <iostream>
using namespace std;
class testDemo
{
public:testDemo(int num):num(num){std::cout << "调用构造函数" << endl;}testDemo(const testDemo& other) :num(other.num) {std::cout << "调用拷贝构造函数" << endl;}testDemo(testDemo&& other) :num(other.num) {std::cout << "调用移动构造函数" << endl;}
private:int num;
};
int main()
{cout << "emplace_back:" << endl;std::vector<testDemo> demo1;demo1.emplace_back(2); cout << "push_back:" << endl;std::vector<testDemo> demo2;demo2.push_back(2);
}
运行结果为：
emplace_back:
调用构造函数
push_back:
调用构造函数
调用移动构造函数
在此基础上，读者可尝试将 testDemo 类中的移动构造函数注释掉，再运行程序会发现，运行结果变为：
emplace_back:
调用构造函数
push_back:
调用构造函数
调用拷贝构造函数
由此可以看出，push_back() 在底层实现时，会优先选择调用移动构造函数，如果没有才会调用拷贝构造函数。
显然完成同样的操作，push_back() 的底层实现过程比 emplace_back() 更繁琐，换句话说，emplace_back() 的执行效率比 push_back() 高。因此，在实际使用时，建议大家优先选用 emplace_back()。
由于 emplace_back() 是 C++ 11 标准新增加的，如果程序要兼顾之前的版本，还是应该使用 push_back()。
C++ STL vector插入元素（insert()和emplace()）详解
vector容器提供了 insert() 和 emplace() 这 2 个成员函数，用来实现在容器指定位置处插入元素，本节将对它们的用法做详细的讲解。
另外，如果想实现在 vector 容器尾部添加元素，可阅读《vector添加元素》一节。
insert()：插入
insert() 函数的功能是在 vector 容器的指定位置插入一个或多个元素。该函数的语法格式有多种，如表 1 所示。
表 1 insert() 成员函数语法格式
| 语法格式 | 用法说明 |
|---|---|
| iterator insert(pos,elem) | 在迭代器 pos 指定的位置之前插入一个新元素elem，并返回表示新插入元素位置的迭代器。 |
| iterator insert(pos,n,elem) | 在迭代器 pos 指定的位置之前插入 n 个元素 elem，并返回表示第一个新插入元素位置的迭代器。 |
| iterator insert(pos,first,last) | 在迭代器 pos 指定的位置之前，插入其他容器（不仅限于vector）中位于 [first,last) 区域的所有元素，并返回表示第一个新插入元素位置的迭代器。 |
| iterator insert(pos,initlist) | 在迭代器 pos 指定的位置之前，插入初始化列表（用大括号{}括起来的多个元素，中间有逗号隔开）中所有的元素，并返回表示第一个新插入元素位置的迭代器。 |
下面的例子，演示了如何使用 insert() 函数向 vector 容器中插入元素。
#include <iostream>
#include <vector>
#include <array>
using namespace std;
int main()
{std::vector<int> demo{1,2};//第一种格式用法demo.insert(demo.begin() + 1, 3);//{1,3,2}//第二种格式用法demo.insert(demo.end(), 2, 5);//{1,3,2,5,5}//第三种格式用法std::array<int,3>test{ 7,8,9 };demo.insert(demo.end(), test.begin(), test.end());//{1,3,2,5,5,7,8,9}//第四种格式用法demo.insert(demo.end(), { 10,11 });//{1,3,2,5,5,7,8,9,10,11}for (int i = 0; i < demo.size(); i++) {cout << demo[i] << " ";}return 0;
}
运行结果为：
1 3 2 5 5 7 8 9 10 11
emplace():放置
emplace() 是 C++ 11 标准新增加的成员函数，用于在 vector 容器指定位置之前插入一个新的元素。
再次强调，emplace() 每次只能插入一个元素，而不是多个。
该函数的语法格式如下：
iterator emplace (const_iterator pos, args...);
其中，pos 为指定插入位置的迭代器；args… 表示与新插入元素的构造函数相对应的多个参数；该函数会返回表示新插入元素位置的迭代器。
简单的理解 args…，即被插入元素的构造函数需要多少个参数，那么在 emplace() 的第一个参数的后面，就需要传入相应数量的参数。
举个例子：
#include <vector>
#include <iostream>
using namespace std;
int main()
{std::vector<int> demo1{1,2};//emplace() 每次只能插入一个 int 类型元素demo1.emplace(demo1.begin(), 3);for (int i = 0; i < demo1.size(); i++) {cout << demo1[i] << " ";}return 0;
}
运行结果为：
3 1 2
既然 emplace() 和 insert() 都能完成向 vector 容器中插入新元素，那么谁的运行效率更高呢？答案是 emplace()。在说明原因之前，通过下面这段程序，就可以直观看出两者运行效率的差异：
#include <vector>
#include <iostream>
using namespace std;
class testDemo
{
public:testDemo(int num) :num(num) {std::cout << "调用构造函数" << endl;}testDemo(const testDemo& other) :num(other.num) {std::cout << "调用拷贝构造函数" << endl;}testDemo(testDemo&& other) :num(other.num) {std::cout << "调用移动构造函数" << endl;}testDemo& operator=(const testDemo& other);
private:int num;
};
testDemo& testDemo::operator=(const testDemo& other) {this->num = other.num;return *this;
}
int main()
{cout << "insert:" << endl;std::vector<testDemo> demo2{};demo2.insert(demo2.begin(), testDemo(1));cout << "emplace:" << endl;std::vector<testDemo> demo1{};demo1.emplace(demo1.begin(), 1);return 0;
}
运行结果为：
insert:
调用构造函数
调用移动构造函数
emplace:
调用构造函数
注意，当拷贝构造函数和移动构造函数同时存在时，insert() 会优先调用移动构造函数。
可以看到，通过 insert() 函数向 vector 容器中插入 testDemo 类对象，需要调用类的构造函数和移动构造函数（或拷贝构造函数）；而通过 emplace() 函数实现同样的功能，只需要调用构造函数即可。
简单的理解，就是 emplace() 在插入元素时，是在容器的指定位置直接构造元素，而不是先单独生成，再将其复制（或移动）到容器中。因此，在实际使用中，推荐大家优先使用 emplace()。
C++ STL vector删除元素的几种方式（超级详细）
前面提到，无论是向现有 vector 容器中访问元素、添加元素还是插入元素，都只能借助 vector 模板类提供的成员函数，但删除 vector 容器的元素例外，完成此操作除了可以借助本身提供的成员函数，还可以借助一些全局函数。
基于不同场景的需要，删除 vecotr 容器的元素，可以使用表 1 中所示的函数（或者函数组合）。
表 1 删除 vector 容器元素的几种方式
| 函数 | 功能 |
|---|---|
| pop_back() | 删除 vector 容器中最后一个元素，该容器的大小（size）会减 1，但容量（capacity）不会发生改变。 |
| erase(pos) | 删除 vector 容器中 pos 迭代器指定位置处的元素，并返回指向被删除元素下一个位置元素的迭代器。该容器的大小（size）会减 1，但容量（capacity）不会发生改变。 |
| swap(beg)、pop_back() | 先调用 swap() 函数交换要删除的目标元素和容器最后一个元素的位置，然后使用 pop_back() 删除该目标元素。 |
| erase(beg,end) | 删除 vector 容器中位于迭代器 [beg,end)指定区域内的所有元素，并返回指向被删除区域下一个位置元素的迭代器。该容器的大小（size）会减小，但容量（capacity）不会发生改变。 |
| remove() | 删除容器中所有和指定元素值相等的元素，并返回指向最后一个元素下一个位置的迭代器。值得一提的是，调用该函数不会改变容器的大小和容量。 |
| clear() | 删除 vector 容器中所有的元素，使其变成空的 vector 容器。该函数会改变 vector 的大小（变为 0），但不是改变其容量。 |
下面就表 1 中罗列的这些函数，一一讲解它们的具体用法。
pop_back() 成员函数的用法非常简单，它不需要传入任何的参数，也没有返回值。举个例子：
#include <vector>
#include <iostream>
using namespace std;
int main()
{vector<int>demo{ 1,2,3,4,5 };demo.pop_back();//输出 dmeo 容器新的sizecout << "size is :" << demo.size() << endl;//输出 demo 容器新的容量cout << "capacity is :" << demo.capacity() << endl;for (int i = 0; i < demo.size(); i++) {cout << demo[i] << " ";}return 0;
}
运行结果为：
size is :4
capacity is :5
1 2 3 4
可以发现，相比原 demo 容器，新的 demo 容器删除了最后一个元素 5，容器的大小减了 1，但容量没变。
如果想删除 vector 容器中指定位置处的元素，可以使用 erase() 成员函数，该函数的语法格式为：
iterator erase (pos);
其中，pos 为指定被删除元素位置的迭代器，同时该函数会返回一个指向删除元素所在位置下一个位置的迭代器。
下面的例子演示了 erase() 函数的具体用法：
#include <vector>
#include <iostream>
using namespace std;
int main()
{vector<int>demo{ 1,2,3,4,5 };auto iter = demo.erase(demo.begin() + 1);//删除元素 2//输出 dmeo 容器新的sizecout << "size is :" << demo.size() << endl;//输出 demo 容器新的容量cout << "capacity is :" << demo.capacity() << endl;for (int i = 0; i < demo.size(); i++) {cout << demo[i] << " ";}//iter迭代器指向元素 3cout << endl << *iter << endl;return 0;
}
运行结果为：
size is :4
capacity is :5
1 3 4 5
3
通过结果不能看出，erase() 函数在删除元素时，会将删除位置后续的元素陆续前移，并将容器的大小减 1。
另外，如果不在意容器中元素的排列顺序，可以结合 swap() 和 pop_back() 函数，同样可以实现删除容器中指定位置元素的目的。
注意，swap() 函数在头文件
<algorithm>和<utility>中都有定义，使用时引入其中一个即可。
例如：
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{vector<int>demo{ 1,2,3,4,5 };//交换要删除元素和最后一个元素的位置swap(*(std::begin(demo)+1),*(std::end(demo)-1));//等同于 swap(demo[1],demo[4])//交换位置后的demo容器for (int i = 0; i < demo.size(); i++) {cout << demo[i] << " ";}demo.pop_back();cout << endl << "size is :" << demo.size() << endl;cout << "capacity is :" << demo.capacity() << endl;//输出demo 容器中剩余的元素for (int i = 0; i < demo.size(); i++) {cout << demo[i] << " ";}return 0;
}
运行结果为：
1 5 3 4 2
size is :4
capacity is :5
1 5 3 4
当然，除了删除容器中单个元素，还可以删除容器中某个指定区域内的所有元素，同样可以使用 erase() 成员函数实现。该函数有 2 种基本格式，前面介绍了一种，这里使用另一种：
iterator erase (iterator first, iterator last);
其中 first 和 last 是指定被删除元素区域的迭代器，同时该函数会返回指向此区域之后一个位置的迭代器。
举个例子：
#include <vector>
#include <iostream>
using namespace std;
int main()
{std::vector<int> demo{ 1,2,3,4,5 };//删除 2、3auto iter = demo.erase(demo.begin()+1, demo.end() - 2);cout << "size is :" << demo.size() << endl;cout << "capacity is :" << demo.capacity() << endl;for (int i = 0; i < demo.size(); i++) {cout << demo[i] << " ";}return 0;
}
运行结果为：
size is :3
capacity is :5
1 4 5
可以看到，和删除单个元素一样，删除指定区域内的元素时，也会将该区域后续的元素前移，并缩小容器的大小。
如果要删除容器中和指定元素值相同的所有元素，可以使用 remove() 函数，该函数定义在 <algorithm> 头文件中。例如：
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{vector<int>demo{ 1,3,3,4,3,5 };//交换要删除元素和最后一个元素的位置auto iter = std::remove(demo.begin(), demo.end(), 3);cout << "size is :" << demo.size() << endl;cout << "capacity is :" << demo.capacity() << endl;//输出剩余的元素for (auto first = demo.begin(); first < iter;++first) {cout << *first << " ";}return 0;
}
运行结果为：
size is :6
capacity is :6
1 4 5
注意，在对容器执行完 remove() 函数之后，由于该函数并没有改变容器原来的大小和容量，因此无法使用之前的方法遍历容器，而是需要向程序中那样，借助 remove() 返回的迭代器完成正确的遍历。
remove() 的实现原理是，在遍历容器中的元素时，一旦遇到目标元素，就做上标记，然后继续遍历，直到找到一个非目标元素，即用此元素将最先做标记的位置覆盖掉，同时将此非目标元素所在的位置也做上标记，等待找到新的非目标元素将其覆盖。因此，如果将上面程序中 demo 容器的元素全部输出，得到的结果为
1 4 5 4 3 5。
另外还可以看到，既然通过 remove() 函数删除掉 demo 容器中的多个指定元素，该容器的大小和容量都没有改变，其剩余位置还保留了之前存储的元素。我们可以使用 erase() 成员函数删掉这些 “无用” 的元素。
比如，修改上面的程序：
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{vector<int>demo{ 1,3,3,4,3,5 };//交换要删除元素和最后一个元素的位置auto iter = std::remove(demo.begin(), demo.end(), 3);demo.erase(iter, demo.end());cout << "size is :" << demo.size() << endl;cout << "capacity is :" << demo.capacity() << endl;//输出剩余的元素for (int i = 0; i < demo.size();i++) {cout << demo[i] << " ";}return 0;
}
运行结果为：
size is :3
capacity is :6
1 4 5
remove()用于删除容器中指定元素时，常和 erase() 成员函数搭配使用。
如果想删除容器中所有的元素，则可以使用 clear() 成员函数，例如：
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{vector<int>demo{ 1,3,3,4,3,5 };//交换要删除元素和最后一个元素的位置demo.clear();cout << "size is :" << demo.size() << endl;cout << "capacity is :" << demo.capacity() << endl;return 0;
}
运行结果为：
size is :0
capacity is :6
如何避免vector容器进行不必要的扩容？
前面提到，我们可以将 vector 容器看做是一个动态数组。换句话说，在不超出 vector 最大容量限制（max_size() 成员方法的返回值）的前提下，该类型容器可以自行扩充容量来满足用户存储更多元素的需求。
值得一提的是，vector 容器扩容的整个过程，和 realloc() 函数的实现方法类似，大致分为以下 4 个步骤：
- 分配一块大小是当前 vector 容量几倍的新存储空间。注意，多数 STL 版本中的 vector 容器，其容器都会以 2 的倍数增长，也就是说，每次 vector 容器扩容，它们的容量都会提高到之前的 2 倍；
- 将 vector 容器存储的所有元素，依照原有次序从旧的存储空间复制到新的存储空间中；
- 析构掉旧存储空间中存储的所有元素；
- 释放旧的存储空间。
通过以上分析不难看出，vector 容器的扩容过程是非常耗时的，并且当容器进行扩容后，之前和该容器相关的所有指针、迭代器以及引用都会失效。因此在使用 vector 容器过程中，我们应尽量避免执行不必要的扩容操作。
要实现这个目标，可以借助 vector 模板类中提供的 reserve() 成员方法。不过在讲解如何用 reserve() 方法避免 vector 容器进行不必要的扩容操作之前，vector 模板类中还提供有几个和 reserve() 功能类似的成员方法，很容易混淆，这里有必要为读者梳理一下，如表 1 所示。
表 1 vector模板类中功能类似的成员方法
| 成员方法 | 功能 |
|---|---|
| size() | 告诉我们当前 vector 容器中已经存有多少个元素，但仅通过此方法，无法得知 vector 容器有多少存储空间。 |
| capacity() | 告诉我们当前 vector 容器总共可以容纳多少个元素。如果想知道当前 vector 容器有多少未被使用的存储空间，可以通过 capacity()-size() 得知。注意，如果 size() 和 capacity() 返回的值相同，则表明当前 vector 容器中没有可用存储空间了，这意味着，下一次向 vector 容器中添加新元素，将导致 vector 容器扩容。 |
| resize(n) | 强制 vector 容器必须存储 n 个元素，注意，如果 n 比 size() 的返回值小，则容器尾部多出的元素将会被析构（删除）；如果 n 比 size() 大，则 vector 会借助默认构造函数创建出更多的默认值元素，并将它们存储到容器末尾；如果 n 比 capacity() 的返回值还要大，则 vector 会先扩增，在添加一些默认值元素。 |
| reserve(n) | 强制 vector 容器的容量至少为 n。注意，如果 n 比当前 vector 容器的容量小，则该方法什么也不会做；反之如果 n 比当前 vector 容器的容量大，则 vector 容器就会扩容。 |
通过对以上几个成员方法功能的分析，我们可以总结出一点，即只要有新元素要添加到 vector 容器中而恰好此时 vector 容器的容量不足时，该容器就会自动扩容。
因此，避免 vector 容器执行不必要的扩容操作的关键在于，在使用 vector 容器初期，就要将其容量设为足够大的值。换句话说，在 vector 容器刚刚构造出来的那一刻，就应该借助 reserve() 成员方法为其扩充足够大的容量。
举个例子，假设我们想创建一个包含 1~1000 的 vector，通常会这样实现：
vector<int>myvector;
for (int i = 1; i <= 1000; i++) {myvector.push_back(i);
}
值得一提的是，上面代码的整个循环过程中，vector 容器会进行 2~10 次自动扩容（多数的 STL 标准库版本中，vector 容器通常会扩容至当前容量的 2 倍，而这里 1000≈2 10），程序的执行效率可想而知。
在上面程序的基础上，下面代码演示了如何使用 reserve() 成员方法尽量避免 vector 容器执行不必要的扩容操作：
vector<int>myvector;
myvector.reserve(1000);
cout << myvector.capacity();
for (int i = 1; i <= 1000; i++) {myvector.push_back(i);
}
相比前面的代码实现，整段程序在运行过程中，vector 容器的容量仅扩充了 1 次，执行效率大大提高。
当然在实际场景中，我们可能并不知道 vector 容器到底要存储多少个元素。这种情况下，可以先预留出足够大的空间，当所有元素都存储到 vector 容器中之后，再去除多余的容量。
关于怎样去除 vector 容器多余的容量，可以借助该容器模板类提供的 shrink_to_fit() 成员方法，另外后续还会讲解如何使用 swap() 成员方法去除 vector 容器多余的容量，两种方法都可以。
vector swap()成员方法还可以这样用！
《如何避免vector容器进行不必要的扩容》一节中，遗留了一个问题，即如何借助 swap() 成员方法去除 vector 容器中多余的容量？本节将就此问题给读者做详细的讲解。
我们知道，在使用 vector 容器的过程中，其容器会根据需要自行扩增。比如，使用 push_back()、insert()、emplace() 等成员方法向 vector 容器中添加新元素时，如果当前容器已满（即 size() == capacity()），则它会自行扩容以满足添加新元素的需求。当然，还可以调用 reserve() 成员方法来手动提升当前 vector 容器的容量。
举个例子（程序一）：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>myvector;cout << "1、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;//利用 myvector 容器存储 10 个元素for (int i = 1; i <= 10; i++) {myvector.push_back(i);}cout << "2、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;//手动为 myvector 扩容myvector.reserve(1000);cout << "3、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;return 0;
}
程序执行结果为：
1、当前 myvector 拥有 0 个元素，容量为 0
2、当前 myvector 拥有 10 个元素，容量为 13
3、当前 myvector 拥有 10 个元素，容量为 1000
除了可以添加元素外，vector 模板类中还提供了 pop_back()、erase()、clear() 等成员方法，可以轻松实现删除容器中已存储的元素。但需要注意得是，借助这些成员方法只能删除指定的元素，容器的容量并不会因此而改变。
例如在程序一的基础上，末尾（return 0 之前）添加如下语句：
myvector.erase(myvector.begin());
cout << "4、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;
myvector.pop_back();
cout << "5、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;
myvector.clear();
cout << "6、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;
此段代码的执行结果为：
4、当前 myvector 拥有 9 个元素，容量为 1000
5、当前 myvector 拥有 8 个元素，容量为 1000
6、当前 myvector 拥有 0 个元素，容量为 1000
显然，myvector 容器存储的元素个数在减少，但容量并不会减小。
幸运的是，myvector 模板类中提供有一个 shrink_to_fit() 成员方法，该方法的功能是将当前 vector 容器的容量缩减至和实际存储元素的个数相等。例如，在程序一的基础上，添加如下语句：
myvector.shrink_to_fit();
cout << "7、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;
该语句的执行结果为：
7、当前 myvector 拥有 10 个元素，容量为 10
显然，myvector 容器的容量由 1000 缩减到了 10。
利用swap()方法去除vector多余容量
除此之外，vector 模板类中还提供有 swap() 成员方法，该方法的基础功能是交换 2 个相同类型的 vector 容器（交换容量和存储的所有元素），但其也能用于去除 vector 容器多余的容量。
如果想用 swap() 成员方法去除当前 vector 容器多余的容量时，可以套用如下的语法格式：
vector<T>(x).swap(x);
其中，x 指当前要操作的容器，T 为该容器存储元素的类型。
下面程序演示了此语法格式的 swap() 方法的用法和功能：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>myvector;//手动为 myvector 扩容myvector.reserve(1000);cout << "1、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;//利用 myvector 容器存储 10 个元素for (int i = 1; i <= 10; i++) {myvector.push_back(i);}//将 myvector 容量缩减至 10vector<int>(myvector).swap(myvector);cout << "2、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;return 0;
}
程序执行结果为：
1、当前 myvector 拥有 0 个元素，容量为 1000
2、当前 myvector 拥有 10 个元素，容量为 10
显然，第 16 行代码成功将 myvector 容器的容量 1000 修改为 10，此行代码的执行流程可细分为以下 3 步：
\1) 先执行 vector(myvector)，此表达式会调用 vector 模板类中的拷贝构造函数，从而创建出一个临时的 vector 容器（后续称其为 tempvector）。
值得一提的是，tempvector 临时容器并不为空，因为我们将 myvector 作为参数传递给了复制构造函数，该函数会将 myvector 容器中的所有元素拷贝一份，并存储到 tempvector 临时容器中。
注意，vector 模板类中的拷贝构造函数只会为拷贝的元素分配存储空间。换句话说，tempvector 临时容器中没有空闲的存储空间，其容量等于存储元素的个数。
\2) 然后借助 swap() 成员方法对 tempvector 临时容器和 myvector 容器进行调换，此过程不仅会交换 2 个容器存储的元素，还会交换它们的容量。换句话说经过 swap() 操作，myvetor 容器具有了 tempvector 临时容器存储的所有元素和容量，同时 tempvector 也具有了原 myvector 容器存储的所有元素和容量。
\3) 当整条语句执行结束时，临时的 tempvector 容器会被销毁，其占据的存储空间都会被释放。注意，这里释放的其实是原 myvector 容器占用的存储空间。
经过以上 3 个步骤，就成功的将 myvector 容器的容量由 100 缩减至 10。
利用swap()方法清空vector容器
在以上内容的学习过程中，如果读者善于举一反三，应该不难想到，swap() 方法还可以用来清空 vector 容器。
当 swap() 成员方法用于清空 vector 容器时，可以套用如下的语法格式：
vector<T>().swap(x);
其中，x 指当前要操作的容器，T 为该容器存储元素的类型。
注意，和上面语法格式唯一的不同之处在于，这里没有为 vector() 表达式传递任何参数。这意味着，此表达式将调用 vector 模板类的默认构造函数，而不再是复制构造函数。也就是说，此格式会先生成一个空的 vector 容器，再借助 swap() 方法将空容器交换给 x，从而达到清空 x 的目的。
下面程序演示了此语法格式的 swap() 方法的用法和功能：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>myvector;//手动为 myvector 扩容myvector.reserve(1000);cout << "1、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;//利用 myvector 容器存储 10 个元素for (int i = 1; i <= 10; i++) {myvector.push_back(i);}//清空 myvector 容器vector<int>().swap(myvector);cout << "2、当前 myvector 拥有 " << myvector.size() << " 个元素，容量为 " << myvector.capacity() << endl;return 0;
}
程序执行结果为：
1、当前 myvector 拥有 0 个元素，容量为 1000
2、当前 myvector 拥有 0 个元素，容量为 0
切忌，vector< bool >不是存储bool类型元素的vector容器！
前面章节中，已经详细介绍了 vector 容器的功能和用法。特别需要提醒的是，在使用 vector 容器时，要尽量避免使用该容器存储 bool 类型的元素，即避免使用 vector。
具体来讲，不推荐使用 vector 的原因有以下 2 个：
- 严格意义上讲，vector 并不是一个 STL 容器；
- vector 底层存储的并不是 bool 类型值。
读者可能会感到有些困惑，别着急，继续往下读。
vector< bool >不是容器
值得一提的是，对于是否为 STL 容器，C++ 标准库中有明确的判断条件，其中一个条件是：如果 cont 是包含对象 T 的 STL 容器，且该容器中重载了 [ ] 运算符（即支持 operator[]），则以下代码必须能够被编译：
T *p = &cont[0];
此行代码的含义是，借助 operator[ ] 获取一个 cont< T > 容器中存储的 T 对象，同时将这个对象的地址赋予给一个 T 类型的指针。
这就意味着，如果 vector< bool > 是一个 STL 容器，则下面这段代码是可以通过编译的：
//创建一个 vector<bool> 容器
vector<bool>cont{0,1};
//试图将指针 p 指向 cont 容器中第一个元素
bool *p = &cont[0];
实际上，为了节省空间，vector 底层在存储各个 bool 类型值时，每个 bool 值都只使用一个比特位（二进制位）来存储。也就是说在 vector 底层，一个字节可以存储 8 个 bool 类型值。在这种存储机制的影响下，operator[ ] 势必就需要返回一个指向单个比特位的引用，但显然这样的引用是不存在的。
C++ 标准中解决这个问题的方案是，令 operator[] 返回一个代理对象（proxy object）。有关代理对象，由于不是本节重点，这里不再做描述，有兴趣的读者可自行查阅相关资料。
同样对于指针来说，其指向的最小单位是字节，无法另其指向单个比特位。综上所述可以得出一个结论，即上面第 2 行代码中，用 = 赋值号连接 bool *p 和 &cont[0] 是矛盾的。
由于 vector 并不完全满足 C++ 标准中对容器的要求，所以严格意义上来说它并不是一个 STL 容器。可能有读者会问，既然 vector 不完全是一个容器，为什么还会出现在 C++ 标准中呢？
这和一个雄心勃勃的试验有关，还要从前面提到的代理对象开始说起。由于代理对象在 C++ 软件开发中很受欢迎，引起了 C++ 标准委员会的注意，他们决定以开发 vector 作为一个样例，来演示 STL 中的容器如何通过代理对象来存取元素，这样当用户想自己实现一个基于代理对象的容器时，就会有一个现成的参考模板。
然而开发人员在实现 vector 的过程中发现，既要创建一个基于代理对象的容器，同时还要求该容器满足 C++ 标准中对容器的所有要求，是不可能的。由于种种原因，这个试验最终失败了，但是他们所做过的尝试（即开发失败的 vector）遗留在了 C++ 标准中。
至于将 vector 遗留到 C++ 标准中，是无心之作，还是有意为之，这都无关紧要，重要的是让读者明白，vector 不完全满足 C++ 标准中对容器的要求，尽量避免在实际场景中使用它！
如何避免使用vector< bool >
那么，如果在实际场景中需要使用 vector< bool > 这样的存储结构，该怎么办呢？很简单，可以选择使用 deque < bool > 或者 bitset 来替代 vector< bool >。
要知道，deque 容器几乎具有 vecotr 容器全部的功能（拥有的成员方法也仅差 reserve() 和 capacity()），而且更重要的是，deque 容器可以正常存储 bool 类型元素。
有关 deque 容器的具体用法，后续章节会做详细讲解。
还可以考虑用 bitset 代替 vector< bool >，其本质是一个模板类，可以看做是一种类似数组的存储结构。和后者一样，bitset 只能用来存储 bool 类型值，且底层存储机制也采用的是用一个比特位来存储一个 bool 值。
和 vector 容器不同的是，bitset 的大小在一开始就确定了，因此不支持插入和删除元素；另外 bitset 不是容器，所以不支持使用迭代器。
有关 bitset 的用法，感兴趣的读者可查阅 C++ 官方提供的 bitset使用手册。
C ++ vector :: assign()函数 (C++ vector::assign() function)
**vector :: assign()是“ vector”**标头的库函数，用于初始化矢量或将内容分配给矢量，将新内容分配给矢量，更新现有内容，并调整矢量的大小根据内容。
Note: To use vector, include header.
**注意：**要使用向量，请包含标头。
Syntax of vector::assign() function
vector :: assign()函数的语法
vector::assign(iterator_first, iterator_last);vector::assign(size_type n, value_type value);
Parameter(s):
参数：
In case of type 1: iterator_first, iterator_last – are the first and last iterators of a sequence with them we are going to assign the vector.
In case of type 2: n – is the size of the vector and value – is a constant value to be assigned.
在类型1的情况下， iterator_first和iterator_last –是序列的第一个和最后一个迭代器，我们将为其分配向量。
对于类型2： n –是向量的大小，而value –是要分配的常数。
Return value: void – In both of the cases it returns nothing.
返回值： void –在两种情况下均不返回任何内容。
Example:
例：
Input:vector<int> v1;vector<int> v2;//assigningv1.assign(5, 100);v2.assign(v1.begin(), v1.end());Output://if we print the valuev1: 100 100 100 100 100v2: 100 100 100 100 100
C ++程序演示vector :: assign()函数的示例 (C++ program to demonstrate example of vector::assign() function)
//C++ STL program to demonstrate example of
//vector::assign() function#include <iostream>
#include <vector>
using namespace std;int main()
{//declaring vectorsvector<int> v1;vector<int> v2;vector<int> v3;//an array that will be used to assign a vectorint arr[] = { 10, 20, 30, 40, 50 };//assigning vectors//assigning v1 with 5 elements and 100 as default valuev1.assign(5, 100);//assigning v1 with arrayv2.assign(arr + 0, arr + 5);//assigning v3 with vector v2v3.assign(v2.begin(), v2.end());//pritning the vectorscout << "v1: ";for (int x : v1)cout << x << " ";cout << endl;cout << "v2: ";for (int x : v2)cout << x << " ";cout << endl;cout << "v3: ";for (int x : v3)cout << x << " ";cout << endl;return 0;
}
Output
输出量
v1: 100 100 100 100 100
v2: 10 20 30 40 50
v3: 10 20 30 40 50
C++ STL deque容器（详解版）
deque 是 double-ended queue 的缩写，又称双端队列容器。
前面章节中，我们已经系统学习了 vector 容器，值得一提的是，deque 容器和 vecotr 容器有很多相似之处，比如：
- deque 容器也擅长在序列尾部添加或删除元素（时间复杂度为
O(1)），而不擅长在序列中间添加或删除元素。 - deque 容器也可以根据需要修改自身的容量和大小。
和 vector 不同的是，deque 还擅长在序列头部添加或删除元素，所耗费的时间复杂度也为常数阶O(1)。并且更重要的一点是，deque 容器中存储元素并不能保证所有元素都存储到连续的内存空间中。
当需要向序列两端频繁的添加或删除元素时，应首选 deque 容器。
deque 容器以模板类 deque（T 为存储元素的类型）的形式在 头文件中，并位于 std 命名空间中。因此，在使用该容器之前，代码中需要包含下面两行代码：
#include <deque>
using namespace std;
注意，std 命名空间也可以在使用 deque 容器时额外注明，两种方式都可以。
创建deque容器的几种方式
创建 deque 容器，根据不同的实际场景，可选择使用如下几种方式。
- 创建一个没有任何元素的空 deque 容器：
std::deque<int> d;
和空 array 容器不同，空的 deque 容器在创建之后可以做添加或删除元素的操作，因此这种简单创建 deque 容器的方式比较常见。
- 创建一个具有 n 个元素的 deque 容器，其中每个元素都采用对应类型的默认值：
std::deque<int> d(10);
此行代码创建一个具有 10 个元素（默认都为 0）的 deque 容器。
- 创建一个具有 n 个元素的 deque 容器，并为每个元素都指定初始值，例如：
std::deque<int> d(10, 5)
如此就创建了一个包含 10 个元素（值都为 5）的 deque 容器。
- 在已有 deque 容器的情况下，可以通过拷贝该容器创建一个新的 deque 容器，例如：
std::deque<int> d1(5);
std::deque<int> d2(d1);
注意，采用此方式，必须保证新旧容器存储的元素类型一致。
- 通过拷贝其他类型容器中指定区域内的元素（也可以是普通数组），可以创建一个新容器，例如：
//拷贝普通数组，创建deque容器
int a[] = { 1,2,3,4,5 };
std::deque<int>d(a, a + 5);
//适用于所有类型的容器
std::array<int, 5>arr{ 11,12,13,14,15 };
std::deque<int>d(arr.begin()+2, arr.end());//拷贝arr容器中的{13,14,15}
deque容器可利用的成员函数
基于 deque 双端队列的特点，该容器包含一些 array、vector 容器都没有的成员函数。
表 1 中罗列了 deque 容器提供的所有成员函数。
表 1 deque 容器的成员函数
| 函数成员 | 函数功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的迭代器。 |
| end() | 返回指向容器最后一个元素所在位置后一个位置的迭代器，通常和 begin() 结合使用。 |
| rbegin() | 返回指向最后一个元素的迭代器。 |
| rend() | 返回指向第一个元素所在位置前一个位置的迭代器。 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| size() | 返回实际元素个数。 |
| max_size() | 返回容器所能容纳元素个数的最大值。这通常是一个很大的值，一般是 232-1，我们很少会用到这个函数。 |
| resize() | 改变实际元素的个数。 |
| empty() | 判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。 |
| shrink _to_fit() | 将内存减少到等于当前元素实际所使用的大小。 |
| at() | 使用经过边界检查的索引访问元素。 |
| front() | 返回第一个元素的引用。 |
| back() | 返回最后一个元素的引用。 |
| assign() | 用新元素替换原有内容。 |
| push_back() | 在序列的尾部添加一个元素。 |
| push_front() | 在序列的头部添加一个元素。 |
| pop_back() | 移除容器尾部的元素。 |
| pop_front() | 移除容器头部的元素。 |
| insert() | 在指定的位置插入一个或多个元素。 |
| erase() | 移除一个元素或一段元素。 |
| clear() | 移出所有的元素，容器大小变为 0。 |
| swap() | 交换两个容器的所有元素。 |
| emplace() | 在指定的位置直接生成一个元素。 |
| emplace_front() | 在容器头部生成一个元素。和 push_front() 的区别是，该函数直接在容器头部构造元素，省去了复制移动元素的过程。 |
| emplace_back() | 在容器尾部生成一个元素。和 push_back() 的区别是，该函数直接在容器尾部构造元素，省去了复制移动元素的过程。 |
和 vector 相比，额外增加了实现在容器头部添加和删除元素的成员函数，同时删除了 capacity()、reserve() 和 data() 成员函数。
和 array、vector 相同，C++ 11 标准库新增的 begin() 和 end() 这 2 个全局函数也适用于 deque 容器。这 2 个函数的操作对象既可以是容器，也可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；如果操作对象是普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针（注意不是最后一个元素）。
deque 容器还有一个std::swap(x , y) 非成员函数（其中 x 和 y 是存储相同类型元素的 deque 容器），它和 swap() 成员函数的功能完全相同，仅使用语法上有差异。
如下代码演示了表 1 中部分成员函数的用法：
#include <iostream>
#include <deque>
using namespace std;
int main()
{//初始化一个空deque容量deque<int>d;//向d容器中的尾部依次添加 1，2,3d.push_back(1); //{1}d.push_back(2); //{1,2}d.push_back(3); //{1,2,3}//向d容器的头部添加 0 d.push_front(0); //{0,1,2,3}//调用 size() 成员函数输出该容器存储的字符个数。printf("元素个数为：%d\n", d.size());//使用迭代器遍历容器for (auto i = d.begin(); i < d.end(); i++) {cout << *i << " ";}cout << endl;return 0;
}
运行结果为：
元素个数为：4
0 1 2 3
表 1 中这些成员函数的具体用法，后续学习用到时会具体讲解，感兴趣的读者，也可以通过查阅 STL手册做详细了解。
C++ STL deque容器迭代器用法详解
deque 容器迭代器的类型为随机访问迭代器，deque 模板类提供了表 1 所示这些成员函数，通过调用这些函数，可以获得表示不同含义的随机访问迭代器。
有关迭代器及其类型的介绍，可以阅读《C++ STL迭代器（iterator）》一节，本节不再做具体介绍。
表 1 deque 支持迭代器的成员函数
| 成员函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。 |
| end() | 返回指向容器最后一个元素之后一个位置的正向迭代器；如果是 const 类型容器，在该函数返回的是常量正向迭代器。此函数通常和 begin() 搭配使用。 |
| rbegin() | 返回指向最后一个元素的反向迭代器；如果是 const 类型容器，在该函数返回的是常量反向迭代器。 |
| rend() | 返回指向第一个元素之前一个位置的反向迭代器。如果是 const 类型容器，在该函数返回的是常量反向迭代器。此函数通常和 rbegin() 搭配使用。 |
| cbegin() | 和 begin() 功能类似，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过其返回的迭代器类型为常量正向迭代器，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过其返回的迭代器类型为常量反向迭代器，不能用于修改元素。 |
C++ 11 新添加的 begin() 和 end() 全局函数也同样适用于 deque 容器。即当操作对象为 deque 容器时，其功能分别和表 1 中的 begin()、end() 成员函数相同，具体用法本节后续会做详细介绍。
表 1 中这些成员函数的具体功能如图 2 所示。
图 2 迭代器的具体功能示意图
从图 2 可以看出，这些成员函数通常是成对使用的，即 begin()/end()、rbegin()/rend()、cbegin()/cend()、crbegin()/crend() 各自成对搭配使用。其中，begin()/end() 和 cbegin/cend() 的功能是类似的，同样 rbegin()/rend() 和 crbegin()/crend() 的功能是类似的。
值得一提的是，以上函数在实际使用时，其返回值类型都可以使用 auto 关键字代替，编译器可以自行判断出该迭代器的类型。
deque容器迭代器的基本用法
deque 容器迭代器常用来遍历容器中存储的各个元素。
begin() 和 end() 分别用于指向「首元素」和「尾元素+1」 的位置，下面程序演示了如何使用 begin() 和 end() 遍历 deque 容器并输出其中的元素：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int>d{1,2,3,4,5};//从容器首元素，遍历至最后一个元素for (auto i = d.begin(); i < d.end(); i++) {cout << *i << " ";}return 0;
}
运行结果为：
1 2 3 4 5
前面提到，STL 还提供有全局的 begin() 和 end() 函数，当操作对象为容器时，它们的功能是上面的 begin()/end() 成员函数一样。例如，将上面程序中的第 8~10 行代码可以用如下代码替换：
for (auto i = begin(d); i < end(d); i++) {cout << *i << " ";
}
重新编译运行程序，会发现输出结果和上面一致。
cbegin()/cend() 成员函数和 begin()/end() 唯一不同的是，前者返回的是 const 类型的正向迭代器，这就意味着，由 cbegin() 和 cend() 成员函数返回的迭代器，可以用来遍历容器内的元素，也可以访问元素，但是不能对所存储的元素进行修改。
举个例子：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int>d{1,2,3,4,5};auto first = d.cbegin();auto end = d.cend();//常量迭代器不能用来修改容器中的元素值//*(first + 1) = 6;//尝试修改容器中元素 2 的值//*(end - 1) = 10;//尝试修改容器中元素 5 的值//常量迭代器可以用来遍历容器、访问容器中的元素while(first<end){cout << *first << " ";++first;}return 0;
}
运行结果：
1 2 3 4 5
程序中，由于 first 和 end 都是常量迭代器，因此第 10、11 行修改容器内元素值的操作都是非法的。
deque 模板类中还提供了 rbegin() 和 rend() 成员函数，它们分别表示指向最后一个元素和第一个元素前一个位置的随机访问迭代器，又常称为反向迭代器（如图 2 所示）。
需要注意的是，在使用反向迭代器进行 ++ 或 – 运算时，++ 指的是迭代器向左移动一位，-- 指的是迭代器向右移动一位，即这两个运算符的功能也“互换”了。
反向迭代器用于以逆序的方式遍历容器中的元素。例如：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int>d{1,2,3,4,5};for (auto i = d.rbegin(); i < d.rend(); i++) {cout << *i << " ";}return 0;
}
运行结果为：
5 4 3 2 1
crbegin()/crend() 组合和 rbegin()/crend() 组合唯一的区别在于，前者返回的迭代器为 const 类型迭代器，不能用来修改容器中的元素，除此之外在使用上和后者完全相同。
deque容器迭代器的使用注意事项
首先需要注意的一点是，迭代器的功能是遍历容器，在遍历的同时可以访问（甚至修改）容器中的元素，但迭代器不能用来初始化空的 deque 容器。
例如，如下代码中注释部分是错误的用法：
#include <iostream>
#include <vector>
using namespace std;
int main()
{vector<int>values;auto first = values.begin();//*first = 1;return 0;
}
对于空的 deque 容器来说，可以通过 push_back()、push_front() 或者 resize() 成员函数实现向（空）deque 容器中添加元素。
除此之外，当向 deque 容器添加元素时，deque 容器会申请更多的内存空间，同时其包含的所有元素可能会被复制或移动到新的内存地址（原来占用的内存会释放），这会导致之前创建的迭代器失效。
举个例子：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int>d;d.push_back(1);auto first = d.begin();cout << *first << endl;//添加元素，会导致 first 失效d.push_back(1);cout << *first << endl;return 0;
}
程序中第 12 行代码，会导致程序运行崩溃，其原因就在于在创建 first 迭代器之后，deque 容器做了添加元素的操作，导致 first 失效。
在对容器做添加元素的操作之后，如果仍需要使用之前以创建好的迭代器，为了保险起见，一定要重新生成。
深度剖析deque容器底层实现原理
事实上，STL 中每个容器的特性，和它底层的实现机制密切相关，deque 自然也不例外。《C++ STL deque容器》一节中提到，deque 容器擅长在序列的头部和尾部添加或删除元素。本节将介绍 deque 容器的底层实现机制，探究其拥有此特点的原因。
想搞清楚 deque 容器的实现机制，需要先了解 deque 容器的存储结构以及 deque 容器迭代器的实现原理。
deque容器的存储结构
和 vector 容器采用连续的线性空间不同，deque 容器存储数据的空间是由一段一段等长的连续空间构成，各段空间之间并不一定是连续的，可以位于在内存的不同区域。
为了管理这些连续空间，deque 容器用数组（数组名假设为 map）存储着各个连续空间的首地址。也就是说，map 数组中存储的都是指针，指向那些真正用来存储数据的各个连续空间（如图 1 所示）。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ce55ZVvh-1692322969479)(file:///C:/Users/10789/Desktop/c%E8%AF%AD%E8%A8%80%E4%B8%AD%E6%96%87%E7%BD%91/STL/2.21%E6%B7%B1%E5%BA%A6%E5%89%96%E6%9E%90deque%E5%AE%B9%E5%99%A8%E5%BA%95%E5%B1%82%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86_files/2-191213161305R5.gif)]
图 1 deque容器的底层存储机制
通过建立 map 数组，deque 容器申请的这些分段的连续空间就能实现“整体连续”的效果。换句话说，当 deque 容器需要在头部或尾部增加存储空间时，它会申请一段新的连续空间，同时在 map 数组的开头或结尾添加指向该空间的指针，由此该空间就串接到了 deque 容器的头部或尾部。
有读者可能会问，如果 map 数组满了怎么办？很简单，再申请一块更大的连续空间供 map 数组使用，将原有数据（很多指针）拷贝到新的 map 数组中，然后释放旧的空间。
deque 容器的分段存储结构，提高了在序列两端添加或删除元素的效率，但也使该容器迭代器的底层实现变得更复杂。
deque容器迭代器的底层实现
由于 deque 容器底层将序列中的元素分别存储到了不同段的连续空间中，因此要想实现迭代器的功能，必须先解决如下 2 个问题：
- 迭代器在遍历 deque 容器时，必须能够确认各个连续空间在 map 数组中的位置；
- 迭代器在遍历某个具体的连续空间时，必须能够判断自己是否已经处于空间的边缘位置。如果是，则一旦前进或者后退，就需要跳跃到上一个或者下一个连续空间中。
为了实现遍历 deque 容器的功能，deque 迭代器定义了如下的结构：
template<class T,...>
struct __deque_iterator{...T* cur;T* first;T* last;map_pointer node;//map_pointer 等价于 T**
}
可以看到，迭代器内部包含 4 个指针，它们各自的作用为：
- cur：指向当前正在遍历的元素；
- first：指向当前连续空间的首地址；
- last：指向当前连续空间的末尾地址；
- node：它是一个二级指针，用于指向 map 数组中存储的指向当前连续空间的指针。
借助这 4 个指针，deque 迭代器对随机访问迭代器支持的各种运算符进行了重载，能够对 deque 分段连续空间中存储的元素进行遍历。例如：
//当迭代器处于当前连续空间边缘的位置时，如果继续遍历，就需要跳跃到其它的连续空间中，该函数可用来实现此功能
void set_node(map_pointer new_node){node = new_node;//记录新的连续空间在 map 数组中的位置first = *new_node; //更新 first 指针//更新 last 指针，difference_type(buffer_size())表示每段连续空间的长度last = first + difference_type(buffer_size());
}
//重载 * 运算符
reference operator*() const{return *cur;}
pointer operator->() const{return &(operator *());}
//重载前置 ++ 运算符
self & operator++(){++cur;//处理 cur 处于连续空间边缘的特殊情况if(cur == last){//调用该函数，将迭代器跳跃到下一个连续空间中set_node(node+1);//对 cur 重新赋值cur = first;}return *this;
}
//重置前置 -- 运算符
self& operator--(){//如果 cur 位于连续空间边缘，则先将迭代器跳跃到前一个连续空间中if(cur == first){set_node(node-1);cur == last;}--cur;return *this;
}
deque容器的底层实现
了解了 deque 容器底层存储序列的结构，以及 deque 容器迭代器的内部结构之后，接下来看看 deque 容器究竟是如何实现的。
deque 容器除了维护先前讲过的 map 数组，还需要维护 start、finish 这 2 个 deque 迭代器。以下为 deque 容器的定义：
//_Alloc为内存分配器
template<class _Ty,class _Alloc = allocator<_Ty>>
class deque{...
protected:iterator start;iterator finish;map_pointer map;
...
}
其中，start 迭代器记录着 map 数组中首个连续空间的信息，finish 迭代器记录着 map 数组中最后一个连续空间的信息。另外需要注意的是，和普通 deque 迭代器不同，start 迭代器中的 cur 指针指向的是连续空间中首个元素；而 finish 迭代器中的 cur 指针指向的是连续空间最后一个元素的下一个位置。
因此，deque 容器的底层实现如图 2 所示。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BPixgYUJ-1692322969479)(file:///C:/Users/10789/Desktop/c%E8%AF%AD%E8%A8%80%E4%B8%AD%E6%96%87%E7%BD%91/STL/2.21%E6%B7%B1%E5%BA%A6%E5%89%96%E6%9E%90deque%E5%AE%B9%E5%99%A8%E5%BA%95%E5%B1%82%E5%AE%9E%E7%8E%B0%E5%8E%9F%E7%90%86_files/2-19121316430U40.gif)]
借助 start 和 finish，以及 deque 迭代器中重载的诸多运算符，就可以实现 deque 容器提供的大部分成员函数，比如：
//begin() 成员函数
iterator begin() {return start;}
//end() 成员函数
iterator end() { return finish;}
//front() 成员函数
reference front(){return *start;}
//back() 成员函数
reference back(){iterator tmp = finish;--tmp;return *tmp;
}
//size() 成员函数
size_type size() const{return finish - start;}//deque迭代器重载了 - 运算符
//enpty() 成员函数
bool empty() const{return finish == start;}
C++ STL deque容器访问元素（4种方法）
通过《STL deque容器》一节，详细介绍了如何创建一个 deque 容器，本节继续讲解如何访问（甚至修改）deque 容器存储的元素。
和 array、vector 容器一样，可以采用普通数组访问存储元素的方式，访问 deque 容器中的元素，比如：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int>d{ 1,2,3,4 };cout << d[1] << endl;//修改指定下标位置处的元素d[1] = 5;cout << d[1] << endl;return 0;
}
运行结果为：
2
5
可以看到，容器名[n]的这种方式，不仅可以访问容器中的元素，还可以对其进行修改。但需要注意的是，使用此方法需确保下标 n 的值不会超过容器中存储元素的个数，否则会发生越界访问的错误。
如果想有效地避免越界访问，可以使用 deque 模板类提供的 at() 成员函数，由于该函数会返回容器中指定位置处元素的引用形式，因此利用该函数的返回值，既可以访问指定位置处的元素，如果需要还可以对其进行修改。
不仅如此，at() 成员函数会自行判定访问位置是否越界，如果越界则抛出std::out_of_range异常。例如：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int>d{ 1,2,3,4 };cout << d.at(1) << endl;d.at(1) = 5;cout << d.at(1) << endl;//下面这条语句会抛出 out_of_range 异常//cout << d.at(10) << endl;return 0;
}
运行结果为：
2
5
读者可能有这样一个疑问，即为什么 deque 容器在重载 [] 运算符时，没有实现边界检查的功能呢？答案很简单，因为性能。如果每次访问元素，都去检查索引值，无疑会产生很多开销。当不存在越界访问的可能时，就能避免这种开销。
除此之外，deque 容器还提供了 2 个成员函数，即 front() 和 back()，它们分别返回 vector 容器中第一个和最后一个元素的引用，通过利用它们的返回值，可以访问（甚至修改）容器中的首尾元素。
举个例子：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int> d{ 1,2,3,4,5 };cout << "deque 首元素为：" << d.front() << endl;cout << "deque 尾元素为：" << d.back() << endl;//修改首元素d.front() = 10;cout << "deque 新的首元素为：" << d.front() << endl;//修改尾元素d.back() = 20;cout << "deque 新的尾元素为：" << d.back() << endl;return 0;
}
运行结果为：
deque 首元素为：1
deque 尾元素为：5
deque 新的首元素为：10
deque 新的尾元素为：20
注意，和 vector 容器不同，deque 容器没有提供 data() 成员函数，同时 deque 容器在存储元素时，也无法保证其会将元素存储在连续的内存空间中，因此尝试使用指针去访问 deque 容器中指定位置处的元素，是非常危险的。
另外，结合 deque 模板类中和迭代器相关的成员函数，可以实现遍历 deque 容器中指定区域元素的方法。例如：
#include <iostream>
#include <deque>
using namespace std;
int main()
{deque<int> d{ 1,2,3,4,5 };//从元素 2 开始遍历auto first = d.begin() + 1;//遍历至 5 结束（不包括 5）auto end = d.end() - 1;while (first < end) {cout << *first << " ";++first;}return 0;
}
运行结果为：
2 3 4
当然，deque 模板类中和迭代器相关的成员函数，还有很多，大家可以阅读《STL deque容器迭代器》做详细了解。
C++ STL deque容器添加和删除元素方法完全攻略
deque 容器中，无论是添加元素还是删除元素，都只能借助 deque 模板类提供的成员函数。表 1 中罗列的是所有和添加或删除容器内元素相关的 deque 模板类中的成员函数。
表 1 和添加或删除deque容器中元素相关的成员函数
| 成员函数 | 功能 |
|---|---|
| push_back() | 在容器现有元素的尾部添加一个元素，和 emplace_back() 不同，该函数添加新元素的过程是，先构造元素，然后再将该元素移动或复制到容器的尾部。 |
| pop_back() | 移除容器尾部的一个元素。 |
| push_front() | 在容器现有元素的头部添加一个元素，和 emplace_back() 不同，该函数添加新元素的过程是，先构造元素，然后再将该元素移动或复制到容器的头部。 |
| pop_front() | 移除容器尾部的一个元素。 |
| emplace_back() | C++ 11 新添加的成员函数，其功能是在容器尾部生成一个元素。和 push_back() 不同，该函数直接在容器头部构造元素，省去了复制或移动元素的过程。 |
| emplace_front() | C++ 11 新添加的成员函数，其功能是在容器头部生成一个元素。和 push_front() 不同，该函数直接在容器头部构造元素，省去了复制或移动元素的过程。 |
| insert() | 在指定的位置直接生成一个元素。和 emplace() 不同的是，该函数添加新元素的过程是，先构造元素，然后再将该元素移动或复制到容器的指定位置。 |
| emplace() | C++ 11 新添加的成员函数，其功能是 insert() 相同，即在指定的位置直接生成一个元素。和 insert() 不同的是，emplace() 直接在容器指定位置构造元素，省去了复制或移动元素的过程。 |
| erase() | 移除一个元素或某一区域内的多个元素。 |
| clear() | 删除容器中所有的元素。 |
在实际应用中，常用 emplace()、emplace_front() 和 emplace_back() 分别代替 insert()、push_front() 和 push_back()，具体原因本节后续会讲。
以上这些成员函数中，除了 insert() 函数的语法格式比较多，其他函数都只有一种用法（erase() 有 2 种语法格式），下面这段程序演示了它们的具体用法：
#include <deque>
#include <iostream>
using namespace std;
int main()
{deque<int>d;//调用push_back()向容器尾部添加数据。d.push_back(2); //{2}//调用pop_back()移除容器尾部的一个数据。d.pop_back(); //{}//调用push_front()向容器头部添加数据。d.push_front(2);//{2}//调用pop_front()移除容器头部的一个数据。d.pop_front();//{}//调用 emplace 系列函数，向容器中直接生成数据。d.emplace_back(2); //{2}d.emplace_front(3); //{3,2}//emplace() 需要 2 个参数，第一个为指定插入位置的迭代器，第二个是插入的值。d.emplace(d.begin() + 1, 4);//{3,4,2}for (auto i : d) {cout << i << " ";}//erase()可以接受一个迭代器表示要删除元素所在位置//也可以接受 2 个迭代器，表示要删除元素所在的区域。d.erase(d.begin());//{4,2}d.erase(d.begin(), d.end());//{}，等同于 d.clear()return 0;
}
运行结果为：
3 4 2
这里重点讲一下 insert() 函数的用法。insert() 函数的功能是在 deque 容器的指定位置插入一个或多个元素。该函数的语法格式有多种，如表 2 所示。
表 2 insert() 成员函数语法格式
| 语法格式 | 功能 |
|---|---|
| iterator insert(pos,elem) | 在迭代器 pos 指定的位置之前插入一个新元素elem，并返回表示新插入元素位置的迭代器。 |
| iterator insert(pos,n,elem) | 在迭代器 pos 指定的位置之前插入 n 个元素 elem，并返回表示第一个新插入元素位置的迭代器。 |
| iterator insert(pos,first,last) | 在迭代器 pos 指定的位置之前，插入其他容器（不仅限于vector）中位于 [first,last) 区域的所有元素，并返回表示第一个新插入元素位置的迭代器。 |
| iterator insert(pos,initlist) | 在迭代器 pos 指定的位置之前，插入初始化列表（用大括号{}括起来的多个元素，中间有逗号隔开）中所有的元素，并返回表示第一个新插入元素位置的迭代器。 |
下面的程序演示了 insert() 函数的这几种用法：
#include <iostream>
#include <deque>
#include <array>
using namespace std;
int main()
{std::deque<int> d{ 1,2 };//第一种格式用法d.insert(d.begin() + 1, 3);//{1,3,2}//第二种格式用法d.insert(d.end(), 2, 5);//{1,3,2,5,5}//第三种格式用法std::array<int, 3>test{ 7,8,9 };d.insert(d.end(), test.begin(), test.end());//{1,3,2,5,5,7,8,9}//第四种格式用法d.insert(d.end(), { 10,11 });//{1,3,2,5,5,7,8,9,10,11}for (int i = 0; i < d.size(); i++) {cout << d[i] << " ";}return 0;
}
运行结果为：
1,3,2,5,5,7,8,9,10,11
emplace系列函数的优势
有关 emplace()、emplace_front() 和 emplace_back() 分别和 insert()、push_front() 和 push_back() 在运行效率上的对比，可以通过下面的程序体现出来：
#include <deque>
#include <iostream>
using namespace std;
class testDemo
{
public:testDemo(int num) :num(num) {std::cout << "调用构造函数" << endl;}testDemo(const testDemo& other) :num(other.num) {std::cout << "调用拷贝构造函数" << endl;}testDemo(testDemo&& other) :num(other.num) {std::cout << "调用移动构造函数" << endl;}testDemo& operator=(const testDemo& other);
private:int num;
};
testDemo& testDemo::operator=(const testDemo& other) {this->num = other.num;return *this;
}
int main()
{//emplace和insertcout << "emplace:" << endl;std::deque<testDemo> demo1;demo1.emplace(demo1.begin(), 2);cout << "insert:" << endl;std::deque<testDemo> demo2;demo2.insert(demo2.begin(), 2);//emplace_front和push_frontcout << "emplace_front:" << endl;std::deque<testDemo> demo3;demo3.emplace_front(2);cout << "push_front:" << endl;std::deque<testDemo> demo4;demo4.push_front(2);//emplace_back()和push_back()cout << "emplace_back:" << endl;std::deque<testDemo> demo5;demo5.emplace_back(2);cout << "push_back:" << endl;std::deque<testDemo> demo6;demo6.push_back(2);return 0;
}
运行结果为：
emplace:
调用构造函数
insert:
调用构造函数
调用移动构造函数
emplace_front:
调用构造函数
push_front:
调用构造函数
调用移动构造函数
emplace_back:
调用构造函数
push_back:
调用构造函数
调用移动构造函数
可以看到，相比和它同功能的函数，emplace 系列函数都只调用了构造函数，而没有调用移动构造函数，这无疑提高了代码的运行效率。
C++ list（STL list）容器完全攻略（超级详细）
STL list 容器，又称双向链表容器，即该容器的底层是以双向链表的形式实现的。这意味着，list 容器中的元素可以分散存储在内存空间里，而不是必须存储在一整块连续的内存空间中。
图 1 展示了 list 双向链表容器是如何存储元素的。
图 1 list 双向链表容器的存储结构示意图
可以看到，list 容器中各个元素的前后顺序是靠指针来维系的，每个元素都配备了 2 个指针，分别指向它的前一个元素和后一个元素。其中第一个元素的前向指针总为 null，因为它前面没有元素；同样，尾部元素的后向指针也总为 null。
基于这样的存储结构，list 容器具有一些其它容器（array、vector 和 deque）所不具备的优势，即它可以在序列已知的任何位置快速插入或删除元素（时间复杂度为O(1)）。并且在 list 容器中移动元素，也比其它容器的效率高。
使用 list 容器的缺点是，它不能像 array 和 vector 那样，通过位置直接访问元素。举个例子，如果要访问 list 容器中的第 6 个元素，它不支持容器对象名[6]这种语法格式，正确的做法是从容器中第一个元素或最后一个元素开始遍历容器，直到找到该位置。
实际场景中，如何需要对序列进行大量添加或删除元素的操作，而直接访问元素的需求却很少，这种情况建议使用 list 容器存储序列。
list 容器以模板类 list（T 为存储元素的类型）的形式在<list>头文件中，并位于 std 命名空间中。因此，在使用该容器之前，代码中需要包含下面两行代码：
#include <list>
using namespace std
注意，std 命名空间也可以在使用 list 容器时额外注明，两种方式都可以。
list容器的创建
根据不同的使用场景，有以下 5 种创建 list 容器的方式供选择。
- 创建一个没有任何元素的空 list 容器：
std::list<int> values;
和空 array 容器不同，空的 list 容器在创建之后仍可以添加元素，因此创建 list 容器的方式很常用。
- 创建一个包含 n 个元素的 list 容器：
std::list<int> values(10);
通过此方式创建 values 容器，其中包含 10 个元素，每个元素的值都为相应类型的默认值（int类型的默认值为 0）。
- 创建一个包含 n 个元素的 list 容器，并为每个元素指定初始值。例如：
std::list<int> values(10, 5);
如此就创建了一个包含 10 个元素并且值都为 5 个 values 容器。
- 在已有 list 容器的情况下，通过拷贝该容器可以创建新的 list 容器。例如：
std::list<int> value1(10);
std::list<int> value2(value1);
注意，采用此方式，必须保证新旧容器存储的元素类型一致。
- 通过拷贝其他类型容器（或者普通数组）中指定区域内的元素，可以创建新的 list 容器。例如：
//拷贝普通数组，创建list容器
int a[] = { 1,2,3,4,5 };
std::list<int> values(a, a+5);
//拷贝其它类型的容器，创建 list 容器
std::array<int, 5>arr{ 11,12,13,14,15 };
std::list<int>values(arr.begin()+2, arr.end());//拷贝arr容器中的{13,14,15}
list容器可用的成员函数
表 2 中罗列出了 list 模板类提供的所有成员函数以及各自的功能。
表 2 list 容器可用的成员函数
| 成员函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的双向迭代器。 |
| end() | 返回指向容器中最后一个元素所在位置的下一个位置的双向迭代器。 |
| rbegin() | 返回指向最后一个元素的反向双向迭代器。 |
| rend() | 返回指向第一个元素所在位置前一个位置的反向双向迭代器。 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| empty() | 判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。 |
| size() | 返回当前容器实际包含的元素个数。 |
| max_size() | 返回容器所能包含元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。 |
| front() | 返回第一个元素的引用。 |
| back() | 返回最后一个元素的引用。 |
| assign() | 用新元素替换容器中原有内容。 |
| emplace_front() | 在容器头部生成一个元素。该函数和 push_front() 的功能相同，但效率更高。 |
| push_front() | 在容器头部插入一个元素。 |
| pop_front() | 删除容器头部的一个元素。 |
| emplace_back() | 在容器尾部直接生成一个元素。该函数和 push_back() 的功能相同，但效率更高。 |
| push_back() | 在容器尾部插入一个元素。 |
| pop_back() | 删除容器尾部的一个元素。 |
| emplace() | 在容器中的指定位置插入元素。该函数和 insert() 功能相同，但效率更高。 |
| insert() | 在容器中的指定位置插入元素。 |
| erase() | 删除容器中一个或某区域内的元素。 |
| swap() | 交换两个容器中的元素，必须保证这两个容器中存储的元素类型是相同的。 |
| resize() | 调整容器的大小。 |
| clear() | 删除容器存储的所有元素。 |
| splice() | 将一个 list 容器中的元素插入到另一个容器的指定位置。 |
| remove(val) | 删除容器中所有等于 val 的元素。 |
| remove_if() | 删除容器中满足条件的元素。 |
| unique() | 删除容器中相邻的重复元素，只保留一个。 |
| merge() | 合并两个事先已排好序的 list 容器，并且合并之后的 list 容器依然是有序的。 |
| sort() | 通过更改容器中元素的位置，将它们进行排序。 |
| reverse() | 反转容器中元素的顺序。 |
除此之外，C++ 11 标准库还新增加了 begin() 和 end() 这 2 个函数，和 list 容器包含的 begin() 和 end() 成员函数不同，标准库提供的这 2 个函数的操作对象，既可以是容器，还可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；如果操作对象是普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针（注意不是最后一个元素）。
list 容器还有一个std::swap(x , y)非成员函数（其中 x 和 y 是存储相同类型元素的 list 容器），它和 swap() 成员函数的功能完全相同，仅使用语法上有差异。
如下代码演示了表 2 中部分成员函数的用法：
#include <iostream>
#include <list>
using namespace std;
int main()
{//创建空的 list 容器std::list<double> values;//向容器中添加元素values.push_back(3.1);values.push_back(2.2);values.push_back(2.9);cout << "values size：" << values.size() << endl;//对容器中的元素进行排序values.sort();//使用迭代器输出list容器中的元素for (std::list<double>::iterator it = values.begin(); it != values.end(); ++it) {std::cout << *it << " ";}return 0;
}
运行结果为：
values size：3
2.2 2.9 3.1
表 2 中这些成员函数的具体用法，后续学习用到时会具体讲解，感兴趣的读者，也可以通过查阅 STL手册做详细了解。
C++ STL list迭代器及用法（详解版）
只有运用迭代器，才能访问 list 容器中存储的各个元素。list 模板类提供了如表 1 所示的这些迭代器函数。
表 1 list 容器迭代器函数
| 迭代器函数 | 功能 |
|---|---|
| begin() | 返回指向容器中第一个元素的双向迭代器（正向迭代器）。 |
| end() | 返回指向容器中最后一个元素所在位置的下一个位置的双向迭代器。（正向迭代器）。 |
| rbegin() | 返回指向最后一个元素的反向双向迭代器。 |
| rend() | 返回指向第一个元素所在位置前一个位置的反向双向迭代器。 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上，正向迭代器增加了 const 属性，即不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过在其基础上，正向迭代器增加了 const 属性，即不能用于修改元素。 |
| crbegin() | 和 rbegin() 功能相同，只不过在其基础上，反向迭代器增加了 const 属性，即不能用于修改元素。 |
| crend() | 和 rend() 功能相同，只不过在其基础上，反向迭代器增加了 const 属性，即不能用于修改元素。 |
除此之外，C++ 11 新添加的 begin() 和 end() 全局函数也同样适用于 list 容器。即当操作对象为 list 容器时，其功能分别和表 1 中的 begin()、end() 成员函数相同。
表 1 中各个成员函数的功能如图 2 所示。
图 2 list 容器迭代器的功能示意图
注意，list 容器的底层实现结构为双向链表，图 2 这种表示仅是为了方便理解各个迭代器函数的功能。
从图 2 可以看出，这些成员函数通常是成对使用的，即 begin()/end()、rbegin()/rend()、cbegin()/cend()、crbegin()/crend() 各自成对搭配使用。其中，begin()/end() 和 cbegin/cend() 的功能是类似的，同样 rbegin()/rend() 和 crbegin()/crend() 的功能是类似的。
前面章节已经详细介绍了 array、vector、deque 容器的迭代器，和它们相比，list 容器迭代器最大的不同在于，其配备的迭代器类型为双向迭代器，而不再是随机访问迭代器。
这意味着，假设 p1 和 p2 都是双向迭代器，则它们支持使用 ++p1、 p1++、 p1–、 p1++、 *p1、 p1==p2 以及 p1!=p2 运算符，但不支持以下操作（其中 i 为整数）：
- p1[i]：不能通过下标访问 list 容器中指定位置处的元素。
- p1-=i、 p1+=i、 p1+i 、p1-i：双向迭代器 p1 不支持使用 -=、+=、+、- 运算符。
- p1<p2、 p1>p2、 p1<=p2、 p1>=p2：双向迭代器 p1、p2 不支持使用 <、 >、 <=、 >= 比较运算符。
有关迭代器类别和功能的具体介绍，可阅读 《C++ STL迭代器》一节。
下面这个程序演示了如何使用表 1 中的迭代器遍历 list 容器中的各个元素。
#include <iostream>
#include <list>
using namespace std;
int main()
{//创建 list 容器std::list<char> values{'h','t','t','p',':','/','/','c','.','b','i','a','n','c','h','e','n','g','.','n','e','t'};//使用begin()/end()迭代器函数对输出list容器中的元素for (std::list<char>::iterator it = values.begin(); it != values.end(); ++it) {std::cout << *it;}cout << endl;//使用 rbegin()/rend()迭代器函数输出 lsit 容器中的元素for (std::list<char>::reverse_iterator it = values.rbegin(); it != values.rend();++it) {std::cout << *it;}return 0;
}
输出结果为：
http://c.biancheng.net
ten.gnehcnaib.c//:ptth
注意，程序中比较迭代器之间的关系，用的是 != 运算符，因为它不支持 < 等运算符。另外在实际场景中，所有迭代器函数的返回值都可以传给使用 auto 关键字定义的变量，因为编译器可以自行判断出该迭代器的类型。
值得一提的是，list 容器在进行插入（insert()）、接合（splice()）等操作时，都不会造成原有的 list 迭代器失效，甚至进行删除操作，而只有指向被删除元素的迭代器失效，其他迭代器不受任何影响。
举个例子：
#include <iostream>
#include <list>
using namespace std;
int main()
{//创建 list 容器std::list<char> values{'h','t','t','p',':','/','/','c','.','b','i','a','n','c','h','e','n','g','.','n','e','t'};//创建 begin 和 end 迭代器std::list<char>::iterator begin = values.begin();std::list<char>::iterator end = values.end();//头部和尾部插入字符 '1'values.insert(begin, '1');values.insert(end, '1');while (begin != end){std::cout << *begin;++begin;}return 0;
}
运行结果为：
http://c.biancheng.net1
可以看到，在进行插入操作之后，仍使用先前创建的迭代器遍历容器，虽然程序不会出错，但由于插入位置的不同，可能会遗漏新插入的元素。
C++ list容器底层存储结构（详解版）
前面在讲 STL list 容器时提到，该容器的底层是用双向链表实现的，甚至一些 STL 版本中（比如 SGI STL），list 容器的底层实现使用的是双向循环链表。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aMHVAm30-1692322969481)(file:///C:/Users/10789/Desktop/c%E8%AF%AD%E8%A8%80%E4%B8%AD%E6%96%87%E7%BD%91/STL/2.26C++%20list%E5%AE%B9%E5%99%A8%E5%BA%95%E5%B1%82%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84%EF%BC%88%E8%AF%A6%E8%A7%A3%E7%89%88%EF%BC%89_files/2-19121Q62J3329.gif)]
图 1 双向链表（ a) ）和双向循环链表（ b) ）
图 1 中，node 表示链表的头指针。
如图 1 所示，使用链表存储数据，并不会将它们存储到一整块连续的内存空间中。恰恰相反，各元素占用的存储空间（又称为节点）是独立的、分散的，它们之间的线性关系通过指针（图 1 以箭头表示）来维持。
list 容器节点结构
通过图 1 可以看到，双向链表的各个节点中存储的不仅仅是元素的值，还应包含 2 个指针，分别指向前一个元素和后一个元素。
通过查看 list 容器的源码实现，其对节点的定义如下：
template<typename T,...>
struct __List_node{//...__list_node<T>* prev;__list_node<T>* next;T myval;//...
}
注意，为了方便读者理解，此代码以及本节后续代码，都省略了和本节核心内容不相关的内容，如果读者对此部分感兴趣，可查看 list 容器实现源码。
可以看到，list 容器定义的每个节点中，都包含 *prev、*next 和 myval。其中，prev 指针用于指向前一个节点；next 指针用于指向后一个节点；myval 用于存储当前元素的值。
list容器迭代器的底层实现
和 array、vector 这些容器迭代器的实现方式不同，由于 list 容器的元素并不是连续存储的，所以该容器迭代器中，必须包含一个可以指向 list 容器的指针，并且该指针还可以借助重载的 *、++、–、==、!= 等运算符，实现迭代器正确的递增、递减、取值等操作。
因此，list 容器迭代器的实现代码如下：
template<tyepname T,...>
struct __list_iterator{__list_node<T>* node;//...//重载 == 运算符bool operator==(const __list_iterator& x){return node == x.node;}//重载 != 运算符bool operator!=(const __list_iterator& x){return node != x.node;}//重载 * 运算符，返回引用类型T* operator *() const {return *(node).myval;}//重载前置 ++ 运算符__list_iterator<T>& operator ++(){node = (*node).next;return *this;}//重载后置 ++ 运算符__list_iterator<T>& operator ++(int){__list_iterator<T> tmp = *this;++(*this);return tmp;}//重载前置 -- 运算符__list_iterator<T>& operator--(){node = (*node).prev;return *this;}//重载后置 -- 运算符__list_iterator<T> operator--(int){__list_iterator<T> tmp = *this;--(*this);return tmp;}//...
}
可以看到，迭代器的移动就是通过操作节点的指针实现的。
list容器的底层实现
本节开头提到，不同版本的 STL 标准库中，list 容器的底层实现并不完全一致，但原理基本相同。这里以 SGI STL 中的 list 容器为例，讲解该容器的具体实现过程。
SGI STL 标准库中，list 容器的底层实现为双向循环链表，相比双向链表结构的好处是在构建 list 容器时，只需借助一个指针即可轻松表示 list 容器的首尾元素。
如下是 SGI STL 标准库中对 list 容器的定义：
template <class T,...>
class list
{//...//指向链表的头节点，并不存放数据__list_node<T>* node;//...以下还有list 容器的构造函数以及很多操作函数
}
另外，为了更方便的实现 list 模板类提供的函数，该模板类在构建容器时，会刻意在容器链表中添加一个空白节点，并作为 list 链表的首个节点（又称头节点）。
使用双向链表实现的 list 容器，其内部通常包含 2 个指针，并分别指向链表中头部的空白节点和尾部的空白节点（也就是说，其包含 2 个空白节点）。
比如，我们经常构造空的 list 容器，其用到的构造函数如下所示：
list() { empty_initialize(); }
// 用于空链表的建立
void empty_initialize()
{node = get_node();//初始化节点node->next = node; // 前置节点指向自己node->prev = node; // 后置节点指向自己
}
显然，即便是创建空的 list 容器，它也包含有 1 个节点。
除此之外，list 模板类中还提供有带参的构造函数，它们的实现过程大致分为以下 2 步：
- 调用 empty_initialize() 函数，构造带有头节点的空 list 容器链表；
- 将各个参数按照次序插入到空的 list 容器链表中。
由此可以总结出，list 容器实际上就是一个带有头节点的双向循环链表。如图 2 所示，此为存有 2 个元素的 list 容器：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BNSskGoH-1692322969481)(file:///C:/Users/10789/Desktop/c%E8%AF%AD%E8%A8%80%E4%B8%AD%E6%96%87%E7%BD%91/STL/2.26C++%20list%E5%AE%B9%E5%99%A8%E5%BA%95%E5%B1%82%E5%AD%98%E5%82%A8%E7%BB%93%E6%9E%84%EF%BC%88%E8%AF%A6%E8%A7%A3%E7%89%88%EF%BC%89_files/2-19121Q6445Q07.gif)]
图 1 list 容器底层存储示意图
在此基础上，通过借助 node 头节点，就可以实现 list 容器中的所有成员函数，比如：
//begin()成员函数
__list_iterator<T> begin(){return (*node).next;}
//end()成员函数
__list_iterator<T> end(){return node;}
//empty()成员函数
bool empty() const{return (*node).next == node;}
//front()成员函数
T& front() {return *begin();}
//back()成员函数
T& back() {return *(--end();)}
//...
以上也只是罗列了 list 容器中一部分成员函数的实现方法，其它成员函数的具体实现，这里不再具体描述，感兴趣的读者，可下载 list 容器的实现源码。
C++ list（STL list）访问元素的几种方法
不同于之前学过的 STL 容器，访问 list 容器中存储元素的方式很有限，即要么使用 front() 和 back() 成员函数，要么使用 list 容器迭代器。
list 容器不支持随机访问，未提供下标操作符 [] 和 at() 成员函数，也没有提供 data() 成员函数。
通过 front() 和 back() 成员函数，可以分别获得 list 容器中第一个元素和最后一个元素的引用形式。举个例子：
#include <iostream>
#include <list>
using namespace std;
int main()
{std::list<int> mylist{ 1,2,3,4 };int &first = mylist.front();int &last = mylist.back();cout << first << " " << last << endl;first = 10;last = 20;cout << mylist.front() << " " << mylist.back() << endl;return 0;
}
输出结果为：
1 4
10 20
可以看到，通过 front() 和 back() 的返回值，我们不仅能分别获取当前 list 容器中的首尾元素，必要时还能修改它们的值。
除此之外，如果想访问 list 容存储的其他元素，就只能使用 list 容器的迭代器。例如：
#include <iostream>
#include <list>
using namespace std;
int main()
{const std::list<int> mylist{1,2,3,4,5};auto it = mylist.begin();cout << *it << " ";++it;while (it!=mylist.end()){cout << *it << " ";++it; }return 0;
}
运行结果为：
1 2 3 4 5
值得一提的是，对于非 const 类型的 list 容器，迭代器不仅可以访问容器中的元素，也可以对指定元素的值进行修改。
当然，对于修改容器指定元素的值，list 模板类提供有专门的成员函数 assign()，感兴趣的读者可自行查找该成员函数的用法。
C++ STL list添加（插入）元素方法详解
前面章节介绍了如何创建 list 容器，在此基础上，本节继续讲解如何向现有 list 容器中添加或插入新的元素。
list 模板类中，与“添加或插入新元素”相关的成员方法有如下几个：
- push_front()：向 list 容器首个元素前添加新元素；
- push_back()：向 list 容器最后一个元素后添加新元素；
- emplace_front()：在容器首个元素前直接生成新的元素；
- emplace_back()：在容器最后一个元素后直接生成新的元素；
- emplace()：在容器的指定位置直接生成新的元素；
- insert()：在指定位置插入新元素；
- splice()：将其他 list 容器存储的多个元素添加到当前 list 容器的指定位置处。
以上这些成员方法中，除了 insert() 和 splice() 方法有多种语法格式外，其它成员方法都仅有 1 种语法格式，下面程序演示了它们的具体用法。
#include <iostream>
#include <list>
using namespace std;
int main()
{std::list<int> values{1,2,3};values.push_front(0);//{0,1,2,3}values.push_back(4); //{0,1,2,3,4}values.emplace_front(-1);//{-1,0,1,2,3,4}values.emplace_back(5); //{-1,0,1,2,3,4,5}//emplace(pos,value),其中 pos 表示指明位置的迭代器，value为要插入的元素值values.emplace(values.end(), 6);//{-1,0,1,2,3,4,5,6}for (auto p = values.begin(); p != values.end(); ++p) {cout << *p << " ";}return 0;
}
输出结果为：
-1,0,1,2,3,4,5,6
list insert()成员方法
insert() 成员方法的语法格式有 4 种，如表 1 所示。
表 1 insert() 成员方法语法格式
| 语法格式 | 用法说明 |
|---|---|
| iterator insert(pos,elem) | 在迭代器 pos 指定的位置之前插入一个新元素 elem，并返回表示新插入元素位置的迭代器。 |
| iterator insert(pos,n,elem) | 在迭代器 pos 指定的位置之前插入 n 个元素 elem，并返回表示第一个新插入元素位置的迭代器。 |
| iterator insert(pos,first,last) | 在迭代器 pos 指定的位置之前，插入其他容器（例如 array、vector、deque 等）中位于 [first,last) 区域的所有元素，并返回表示第一个新插入元素位置的迭代器。 |
| iterator insert(pos,initlist) | 在迭代器 pos 指定的位置之前，插入初始化列表（用大括号 { } 括起来的多个元素，中间有逗号隔开）中所有的元素，并返回表示第一个新插入元素位置的迭代器。 |
下面的程序演示了如何使用 insert() 方法向 list 容器中插入元素。
#include <iostream>
#include <list>
#include <array>
using namespace std;
int main()
{std::list<int> values{ 1,2 };//第一种格式用法values.insert(values.begin() , 3);//{3,1,2}//第二种格式用法values.insert(values.end(), 2, 5);//{3,1,2,5,5}//第三种格式用法std::array<int, 3>test{ 7,8,9 };values.insert(values.end(), test.begin(), test.end());//{3,1,2,5,5,7,8,9}//第四种格式用法values.insert(values.end(), { 10,11 });//{3,1,2,5,5,7,8,9,10,11}for (auto p = values.begin(); p != values.end(); ++p){cout << *p << " ";}return 0;
}
输出结果为：
3 1 2 5 5 7 8 9 10 11
学到这里，读者有没有发现，同样是实现插入元素的功能，无论是 push_front()、push_back() 还是 insert()，都有以 emplace 为名且功能和前者相同的成员函数。这是因为，后者是 C++ 11 标准新添加的，在大多数场景中，都可以完全替代前者实现同样的功能。更重要的是，实现同样的功能，emplace 系列方法的执行效率更高。
有关 list 模板类中 emplace 系列函数执行效率更高的原因，前面在讲解 deque 容器模板类中的 emplace 系列函数时已经讲过，读者可阅读《C++ STL deque容器添加和删除元素》一节做详细了解。
list splice()成员方法
和 insert() 成员方法相比，splice() 成员方法的作用对象是其它 list 容器，其功能是将其它 list 容器中的元素添加到当前 list 容器中指定位置处。
splice() 成员方法的语法格式有 3 种，如表 2 所示。
表 2 splice() 成员方法的用法
| 语法格式 | 功能 |
|---|---|
| void splice (iterator position, list& x); | position 为迭代器，用于指明插入位置；x 为另一个 list 容器。 此格式的 splice() 方法的功能是，将 x 容器中存储的所有元素全部移动当前 list 容器中 position 指明的位置处。 |
| void splice (iterator position, list& x, iterator i); | position 为迭代器，用于指明插入位置；x 为另一个 list 容器；i 也是一个迭代器，用于指向 x 容器中某个元素。 此格式的 splice() 方法的功能是将 x 容器中 i 指向的元素移动到当前容器中 position 指明的位置处。 |
| void splice (iterator position, list& x, iterator first, iterator last); | position 为迭代器，用于指明插入位置；x 为另一个 list 容器；first 和 last 都是迭代器，[fist,last) 用于指定 x 容器中的某个区域。 此格式的 splice() 方法的功能是将 x 容器 [first, last) 范围内所有的元素移动到当前容器 position 指明的位置处。 |
我们知道，list 容器底层使用的是链表存储结构，splice() 成员方法移动元素的方式是，将存储该元素的节点从 list 容器底层的链表中摘除，然后再链接到当前 list 容器底层的链表中。这意味着，当使用 splice() 成员方法将 x 容器中的元素添加到当前容器的同时，该元素会从 x 容器中删除。
下面程序演示了 splice() 成员方法的用法：
#include <iostream>
#include <list>
using namespace std;
int main()
{//创建并初始化 2 个 list 容器list<int> mylist1{ 1,2,3,4 }, mylist2{10,20,30};list<int>::iterator it = ++mylist1.begin(); //指向 mylist1 容器中的元素 2//调用第一种语法格式mylist1.splice(it, mylist2); // mylist1: 1 10 20 30 2 3 4// mylist2:// it 迭代器仍然指向元素 2，只不过容器变为了 mylist1//调用第二种语法格式，将 it 指向的元素 2 移动到 mylist2.begin() 位置处mylist2.splice(mylist2.begin(), mylist1, it); // mylist1: 1 10 20 30 3 4// mylist2: 2// it 仍然指向元素 2//调用第三种语法格式，将 [mylist1.begin(),mylist1.end())范围内的元素移动到 mylist.begin() 位置处 mylist2.splice(mylist2.begin(), mylist1, mylist1.begin(), mylist1.end());//mylist1://mylist2:1 10 20 30 3 4 2cout << "mylist1 包含 " << mylist1.size() << "个元素" << endl;cout << "mylist2 包含 " << mylist2.size() << "个元素" << endl;//输出 mylist2 容器中存储的数据cout << "mylist2:";for (auto iter = mylist2.begin(); iter != mylist2.end(); ++iter) {cout << *iter << " ";}return 0;
}
程序执行结果为：
mylist1 包含 0个元素
mylist2 包含 7个元素
mylist2:1 10 20 30 3 4 2
empty()和size()都可以判断容器是否为空，谁更好？
到目前为止，我们已经了解了 C++ STL 标准库中 vector、deque 和 list 这 3 个容器的功能和具体用法。学习过程中，读者是否想过一个问题，即这些容器的模板类中都提供了 empty() 成员方法和 size() 成员方法，它们都可以用来判断容器是否为空。
换句话说，假设有一个容器 cont，则此代码：
if(cont.size() == 0)
本质上和如下代码是等价的：
if(cont.empty())
那么，在实际场景中，到底应该使用哪一种呢？
建议使用 empty() 成员方法。理由很简单，无论是哪种容器，只要其模板类中提供了 empty() 成员方法，使用此方法都可以保证在 O(1) 时间复杂度内完成对“容器是否为空”的判断；但对于 list 容器来说，使用 size() 成员方法判断“容器是否为空”，可能要消耗 O(n) 的时间复杂度。
注意，这个结论不仅适用于 vector、deque 和 list 容器，后续还会讲解更多容器的用法，该结论也依然适用。
那么，为什么 list 容器这么特殊呢？这和 list 模板类提供了独有的 splice() 成员方法有关。
深度剖析选用empty()的原因
做一个大胆的设想，假设我们自己就是 list 容器的设计者。从始至终，我们的目标都是让 list 成为标准容器，并被广泛使用，因此打造“高效率的 list”成为我们奋斗的目标。
在实现 list 容器的过程中我们发现，用户经常需要知道当前 list 容器中存有多少个元素，于是我们想让 size() 成员方法的执行效率达到 O(1)。为了实现这个目的，我们必须重新设计 list，使它总能以最快的效率知道自己含有多少个元素。
要想令 size() 的执行效率达到 O(1)，最直接的实现方式是：在 list 模板类中设置一个专门用于统计存储元素数量的 size 变量，其位于所有成员方法的外部。与此同时，在每一个可用来为容器添加或删除元素的成员方法中，添加对 size 变量值的更新操作。由此，size() 成员方法只需返回 size 这个变量即可（时间复杂度为 O(1)）。
不仅如此，由于 list 容器底层采用的是链式存储结构（也就是链表），该结构最大的特点就是，某一链表中存有元素的节点，无需经过拷贝就可以直接链接到其它链表中，且整个过程只需要消耗 O(1) 的时间复杂度。考虑到很多用户之所以选用 list 容器，就是看中了其底层存储结构的这一特性。因此，作为 list 容器设计者的我们，自然也想将 splice() 方法的时间复杂度设计为 O(1)。
这里就产生了一个矛盾，即如果将 size() 设计为 O(1) 时间复杂度，则由于 splice() 成员方法会修改 list 容器存储元素的个数，因此该方法中就需要添加更新 size 变量的代码（更新方式无疑是通过遍历链表来实现），这也就意味着 splice() 成员方法的执行效率将无法达到 O(1)；反之，如果将 splice() 成员方法的执行效率提高到 O(1)，则 size() 成员方法将无法实现 O(1) 的时间复杂度。
也就是说，list 容器中的 size() 和 splice() 总有一个要做出让步，即只能实现其中一个方法的执行效率达到 O(1)。
值得一提的是，不同版本的 STL 标准库，其底层解决此冲突的抉择是不同的。以本教程所用的 C++ STL 标准模板库为例，其选择将 splice() 成员方法的执行效率达到 O(1)，而 size() 成员方法的执行效率为 O(n)。当然，有些版本的 STL 标准库中，选择将 size() 方法的执行效率设计为 O(1)。
但不论怎样，选用 empty() 判断容器是否为空，效率总是最高的。所以，如果程序中需要判断当前容器是否为空，应优先考虑使用 empty()。
C++ STL list删除元素详解
对 list 容器存储的元素执行删除操作，需要借助该容器模板类提供的成员函数。幸运的是，相比其它 STL 容器模板类，list 模板类提供了更多用来实现此操作的成员函数（如表 1 所示）。
表 1 实现 list 容器删除元素的成员函数
| 成员函数 | 功能 |
|---|---|
| pop_front() | 删除位于 list 容器头部的一个元素。 |
| pop_back() | 删除位于 list 容器尾部的一个元素。 |
| erase() | 该成员函数既可以删除 list 容器中指定位置处的元素，也可以删除容器中某个区域内的多个元素。 |
| clear() | 删除 list 容器存储的所有元素。 |
| remove(val) | 删除容器中所有等于 val 的元素。 |
| unique() | 删除容器中相邻的重复元素，只保留一份。 |
| remove_if() | 删除容器中满足条件的元素。 |
其中，pop_front()、pop_back() 和 clear() 的用法非常简单，这里仅给出一个样例，不再过多解释：
#include <iostream>
#include <list>
using namespace std;
int main()
{list<int>values{ 1,2,3,4 };//删除当前容器中首个元素values.pop_front();//{2,3,4}//删除当前容器最后一个元素values.pop_back();//{2,3}//清空容器，删除容器中所有的元素values.clear(); //{}for (auto begin = values.begin(); begin != values.end(); ++begin){cout << *begin << " ";}return 0;
}
运行程序，可以看到输出结果为“空”。
erase() 成员函数有以下 2 种语法格式：
iterator erase (iterator position);
iterator erase (iterator first, iterator last);
利用第一种语法格式，可实现删除 list 容器中 position 迭代器所指位置处的元素，例如：
#include <iostream>
#include <list>
using namespace std;
int main()
{list<int>values{ 1,2,3,4,5 };//指向元素 1 的迭代器auto del = values.begin();//迭代器右移，改为指向元素 2++del;values.erase(del); //{1,3,4,5}for (auto begin = values.begin(); begin != values.end(); ++begin){cout << *begin << " ";}return 0;
}
运行结果为：
1 3 4 5
利用第二种语法格式，可实现删除 list 容器中 first 迭代器和 last 迭代器限定区域内的所有元素（包括 first 指向的元素，但不包括 last 指向的元素）。例如：
#include <iostream>
#include <list>
using namespace std;
int main()
{list<int>values{ 1,2,3,4,5 };//指定删除区域的左边界auto first = values.begin();++first;//指向元素 2//指向删除区域的右边界auto last = values.end();--last;//指向元素 5//删除 2、3 和 4values.erase(first, last);for (auto begin = values.begin(); begin != values.end(); ++begin){cout << *begin << " ";}return 0;
}
运行结果为：
1 5
erase() 成员函数是按照被删除元素所在的位置来执行删除操作，如果想根据元素的值来执行删除操作，可以使用 remove() 成员函数。例如：
#include <iostream>
#include <list>
using namespace std;
int main()
{list<char>values{'a','b','c','d'};values.remove('c');for (auto begin = values.begin(); begin != values.end(); ++begin){cout << *begin << " ";}return 0;
}
运行结果为：
a b d
unique() 函数也有以下 2 种语法格式：
void unique()
void unique（BinaryPredicate）//传入一个二元谓词函数
以上 2 种格式都能实现去除 list 容器中相邻重复的元素，仅保留一份。但第 2 种格式的优势在于，我们能自定义去重的规则，例如：
#include <iostream>
#include <list>
using namespace std;
//二元谓词函数
bool demo(double first, double second)
{return (int(first) == int(second));
}
int main()
{list<double> mylist{ 1,1.2,1.2,3,4,4.5,4.6 };//删除相邻重复的元素，仅保留一份mylist.unique();//{1, 1.2, 3, 4, 4.5, 4.6}for (auto it = mylist.begin(); it != mylist.end(); ++it)cout << *it << ' ';cout << endl;//demo 为二元谓词函数，是我们自定义的去重规则mylist.unique(demo);for (auto it = mylist.begin(); it != mylist.end(); ++it)std::cout << *it << ' ';return 0;
}
运行结果为：
1 1.2 3 4 4.5 4.6
1 3 4
注意，除了以上一定谓词函数的方式，还可以使用 lamba表达式以及函数对象的方式定义。
可以看到，通过调用无参的 unique()，仅能删除相邻重复（也就是相等）的元素，而通过我们自定义去重的规则，可以更好的满足在不同场景下去重的需求。
除此之外，通过将自定义的谓词函数（不限定参数个数）传给 remove_if() 成员函数，list 容器中能使谓词函数成立的元素都会被删除。举个例子：
#include <iostream>
#include <list>
using namespace std;
int main()
{std::list<int> mylist{ 15, 36, 7, 17, 20, 39, 4, 1 };//删除 mylist 容器中能够使 lamba 表达式成立的所有元素。mylist.remove_if([](int value) {return (value < 10); }); //{15 36 17 20 39}for (auto it = mylist.begin(); it != mylist.end(); ++it)std::cout << ' ' << *it;return 0;
}
运行结果为：
15 36 17 20 39
谓词函数
谓词函数是一个判断式，一个返回bool值的函数或者仿函数。
C++ STL forward_list容器完全攻略
forward_list 是 C++ 11 新添加的一类容器，其底层实现和 list 容器一样，采用的也是链表结构，只不过 forward_list 使用的是单链表，而 list 使用的是双向链表（如图 1 所示）。
图 1 单链表（ a) ）和双向链表（ b) ）
图 1 中，H 表示链表的表头。
通过图 1 不难看出，使用链表存储数据最大的特点在于，其并不会将数据进行集中存储（向数组那样），换句话说，链表中数据的存储位置是分散的、随机的，整个链表中数据的线性关系通过指针来维持。
因此，forward_list 容器具有和 list 容器相同的特性，即擅长在序列的任何位置进行插入元素或删除元素的操作，但对于访问存储的元素，没有其它容器（如 array、vector）的效率高。
另外，由于单链表没有双向链表那样灵活，因此相比 list 容器，forward_list 容器的功能受到了很多限制。比如，由于单链表只能从前向后遍历，而不支持反向遍历，因此 forward_list 容器只提供前向迭代器，而不是双向迭代器。这意味着，forward_list 容器不具有 rbegin()、rend() 之类的成员函数。
有关迭代器的具体分类以及各种迭代器的具体功能，可以阅读《C++ STL迭代器》一节。
那么，既然 forward_list 容器具有和 list 容器相同的特性，list 容器还可以提供更多的功能函数，forward_list 容器有什么存在的必要呢？
当然有，forward_list 容器底层使用单链表，也不是一无是处。比如，存储相同个数的同类型元素，单链表耗用的内存空间更少，空间利用率更高，并且对于实现某些操作单链表的执行效率也更高。
效率高是选用 forward_list 而弃用 list 容器最主要的原因，换句话说，只要是 list 容器和 forward_list 容器都能实现的操作，应优先选择 forward_list 容器。
forward_list容器的创建
由于 forward_list 容器以模板类 forward_list（T 为存储元素的类型）的形式被包含在<forward_list>头文件中，并定义在 std 命名空间中。因此，在使用该容器之前，代码中需包含下面两行代码：
#include <forward_list>
using namespace std;
std 命名空间也可以在使用 forward_list 容器时额外注明，两种方式都可以。
创建 forward_list 容器的方式，大致分为以下 5 种。
- 创建一个没有任何元素的空 forward_list 容器：
std::forward_list<int> values;
由于 forward_list 容器在创建后也可以添加元素，因此这种创建方式很常见。
- 创建一个包含 n 个元素的 forward_list 容器：
std::forward_list<int> values(10);
通过此方式创建 values 容器，其中包含 10 个元素，每个元素的值都为相应类型的默认值（int类型的默认值为 0）。
- 创建一个包含 n 个元素的 forward_list 容器，并为每个元素指定初始值。例如：
std::forward_list<int> values(10, 5);
如此就创建了一个包含 10 个元素并且值都为 5 个 values 容器。
- 在已有 forward_list 容器的情况下，通过拷贝该容器可以创建新的 forward_list 容器。例如：
std::forward_list<int> value1(10);
std::forward_list<int> value2(value1);
注意，采用此方式，必须保证新旧容器存储的元素类型一致。
- 通过拷贝其他类型容器（或者普通数组）中指定区域内的元素，可以创建新的 forward_list 容器。例如：
//拷贝普通数组，创建forward_list容器
int a[] = { 1,2,3,4,5 };
std::forward_list<int> values(a, a+5);
//拷贝其它类型的容器，创建forward_list容器
std::array<int, 5>arr{ 11,12,13,14,15 };
std::forward_list<int>values(arr.begin()+2, arr.end());//拷贝arr容器中的{13,14,15}
forward_list容器支持的成员函数
表 2 中罗列出了 forward_list 模板类提供的所有成员函数以及各自的功能。
表 2 forward_list 容器可用的成员函数
| 成员函数 | 功能 |
|---|---|
| before_begin() | 返回一个前向迭代器，其指向容器中第一个元素之前的位置。 |
| begin() | 返回一个前向迭代器，其指向容器中第一个元素的位置。 |
| end() | 返回一个前向迭代器，其指向容器中最后一个元素之后的位置。 |
| cbefore_begin() | 和 before_begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| cbegin() | 和 begin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| cend() | 和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素。 |
| empty() | 判断容器中是否有元素，若无元素，则返回 true；反之，返回 false。 |
| max_size() | 返回容器所能包含元素个数的最大值。这通常是一个很大的值，一般是 232-1，所以我们很少会用到这个函数。 |
| front() | 返回第一个元素的引用。 |
| assign() | 用新元素替换容器中原有内容。 |
| push_front() | 在容器头部插入一个元素。 |
| emplace_front() | 在容器头部生成一个元素。该函数和 push_front() 的功能相同，但效率更高。 |
| pop_front() | 删除容器头部的一个元素。 |
| emplace_after() | 在指定位置之后插入一个新元素，并返回一个指向新元素的迭代器。和 insert_after() 的功能相同，但效率更高。 |
| insert_after() | 在指定位置之后插入一个新元素，并返回一个指向新元素的迭代器。 |
| erase_after() | 删除容器中某个指定位置或区域内的所有元素。 |
| swap() | 交换两个容器中的元素，必须保证这两个容器中存储的元素类型是相同的。 |
| resize() | 调整容器的大小。 |
| clear() | 删除容器存储的所有元素。 |
| splice_after() | 将某个 forward_list 容器中指定位置或区域内的元素插入到另一个容器的指定位置之后。 |
| remove(val) | 删除容器中所有等于 val 的元素。 |
| remove_if() | 删除容器中满足条件的元素。 |
| unique() | 删除容器中相邻的重复元素，只保留一个。 |
| merge() | 合并两个事先已排好序的 forward_list 容器，并且合并之后的 forward_list 容器依然是有序的。 |
| sort() | 通过更改容器中元素的位置，将它们进行排序。 |
| reverse() | 反转容器中元素的顺序。 |
除此之外，C++ 11 标准库还新增加了 begin() 和 end() 这 2 个函数，和 forward_list 容器包含的 begin() 和 end() 成员函数不同，标准库提供的这 2 个函数的操作对象，既可以是容器，还可以是普通数组。当操作对象是容器时，它和容器包含的 begin() 和 end() 成员函数的功能完全相同；如果操作对象是普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针（注意不是最后一个元素）。
forward_list 容器还有一个std::swap(x , y)非成员函数（其中 x 和 y 是存储相同类型元素的 forward_list 容器），它和 swap() 成员函数的功能完全相同，仅使用语法上有差异。
下面的样例演示了表 2 中部分成员函数的用法：
#include <iostream>
#include <forward_list>
using namespace std;
int main()
{std::forward_list<int> values{1,2,3};values.emplace_front(4);//{4,1,2,3}values.emplace_after(values.before_begin(), 5); //{5,4,1,2,3}values.reverse();//{3,2,1,4,5}for (auto it = values.begin(); it != values.end(); ++it) {cout << *it << " ";}return 0;
}
运行结果为：
3 2 1 4 5
表 2 中这些成员函数的具体用法，后续学习用到时会具体讲解，感兴趣的读者，也可以通过查阅 STL手册做详细了解。
和使用forward_list容器相关的函数
通过表 2 我们知道，forward_list 容器中是不提供 size() 函数的，但如果想要获取 forward_list 容器中存储元素的个数，可以使用头文件 中的 distance() 函数。举个例子：
#include <iostream>
#include <forward_list>
#include <iterator>
using namespace std;
int main()
{std::forward_list<int> my_words{1,2,3,4};int count = std::distance(std::begin(my_words), std::end(my_words));cout << count;return 0;
}
运行结果为：
4
并且，forward_list 容器迭代器的移动除了使用 ++ 运算符单步移动，还能使用 advance() 函数，比如：
#include <iostream>
#include <forward_list>
using namespace std;
int main()
{std::forward_list<int> values{1,2,3,4};auto it = values.begin();advance(it, 2);while (it!=values.end()){cout << *it << " ";++it;}return 0;
}
运行结果为：
3 4
相关文章：
C++ STL序列式容器（详解）
STL基础 C STL基本组成（6大组件13个头文件） 通常认为，STL 是由容器、算法、迭代器、函数对象、适配器、内存分配器这 6 部分构成，其中后面 4 部分是为前 2 部分服务的，它们各自的含义如表 1 所示。 表 1 STL 组成…...
C++获取map最小值算法,STL---std::min_element()！
std::min_element 定义于头文件 <algorithm> 以下是API文档说明！ 寻找范围 [first, last) 中的最小元素。 1) 用 operator< 比较元素。 3) 用给定的二元比较函数 comp 比较元素。 2,4) 同 (1,3) ，但按照 policy 执行。这些重载仅若 std::is…...
如何在Java实现TCP方式发送和接收Socket消息（多线程模式）
目录 导言：正文：1. 创建Server端：2. 创建Client端：3. 多线程模式： 代码示例Server端代码示例：Client端代码示例：同步模式发送TCP消息异步模式 结论： 导言： 在Java编程中…...
SYBASE查询全量字段及对应的表名方法
SELECT COLUMN_name,table_name,user_type,COLUMN_type,width FROM syscolumn a,systable b WHERE a.table_idb.table_id AND COLUMN_name...
Alions 8.6 下 Redis 7.2.0 集群搭建和配置
Redis 7.2.0 搭建和集群配置 一.Redis 下载与单机部署1.Redis 下载2.虚拟机配置3.Redis 单机源码安装和测试4.Java 单机连接测试1.Pom 依赖2.配置文件3.启动类4.配置类5.单元测试6.测试结果 二.Redis 集群部署1.主从1.从节点配置2.Java 测试 2.哨兵1.哨兵节点配置2.复制一个哨兵…...
Android Retrofit 使用及原理详解~
简介 在 Android 开发中，网络请求是一个极为关键的部分。Retrofit 作为一个强大的网络请求库，能够简化开发流程，提供高效的网络请求能力。本文将深入介绍 Retrofit 的高级使用与原理，帮助读者更全面地理解和应用这一库。 什么是…...
三种主要的云交付服务和安全模型
对于许多企业来说，当今的数字化转型之旅包括一个关键决策：采用符合其需求的云交付服务。 云计算已成为现代 IT 基础设施的主要组成部分，具有从可扩展性到成本效率等诸多优势。然而，与所有技术一样，云也有其自身的网络…...
python爬虫实战(3)--爬取某乎热搜
1. 分析爬取地址 打开某乎首页，点击热榜 这个就是我们需要爬取的地址，取到地址某乎/api/v3/feed/topstory/hot-lists/total?limit50&desktoptrue 定义好请求头，从Accept往下的请求头全部复制，转换成json headers {Accep…...
IPv4，IPv6，TCP，路由
主要回顾一下TCP／IP的传输过程，在这个过程中，做了什么事情 ip : 网际协议,IP协议能让世界上任意两台计算机之间进行通信。 IP协议的三大功能： 寻址和路由传递服务：不可靠（尽最大努力交付传输数据包&…...
Java 计算文本相似度
接受一个字符串和一个字符串列表作为参数的 Java 方法，用于计算两个字符串之间的相似度。 方法 import java.util.HashSet; import java.util.List; import java.util.Set;public class StringSimilarity {/*** 计算两个字符串之间的相似度* param str1 第一个字符…...
MySQL 视图
目录 一、视图概述 二、视图的作用和优点 三、视图的使用规则 四、视图操作 1、创建视图 2、查看视图 1）查看视图基本信息 2）查看视图详细信息 3、修改视图 4、更新视图 5、删除视图 一、视图概述 视图是数据库中的一个虚拟表，同真…...
深入理解回调函数qsort：从入门到模拟实现
🍁博客主页：江池俊的博客 💫收录专栏：C语言进阶之路 💡代码仓库：江池俊的代码仓库 🎪我的社区：GeekHub 🎉欢迎大家点赞👍评论📝收藏⭐ 文章目录 前…...
【Git基础】获取远程仓库
我们通常从远程服务器克隆一个Git仓库或者将本地仓库初始化为Git仓库。 1 从远程服务器克隆一个Git仓库 $ git clone https://github.com/your-username/your-repo-name你可以自定义其仓库名称： $ git clone https://github.com/your-username/your-repo-name cu…...
chatGPT界面
效果图： 代码： <!DOCTYPE html> <html> <head><title>复选框样式示例</title> </head> <style>* {padding:0;margin: 0;}.chatpdf{display: flex;height: 100vh;flex-direction: row;}.chatpdf .pannel{widt…...
windows一键启动jupyter
windows一键启动jupyter jupyter简介 Jupyter是一个开源的交互式计算环境，主要用于数据分析、数据可视化和科学计算。它的名字来源于三种编程语言的缩写：Julia、Python和R，这三种语言都可以在Jupyter环境中运行。如果您想进行数据分析、科学…...
树形结构的快速生成
背景 相信大家都遇到过树形结构，像是文件列表、多级菜单、评论区的设计等等，我们都发现它有很多层级，第一级可以有多个，下边的每一个层级也可以有多个；有的可以设计成无限层级的，有的只能设计成两级。那么…...
Android笔记(二十七)：自定义Dialog实现居中Toast
背景 记录实现符合项目需求的Toast弹窗 具体实现 class MyTipDialog private constructor(val context: Activity): Dialog(context, R.style.MyTipTheme) {val resId ObservableField(0)private val mainHandler Handler(Looper.getMainLooper())init {setCanceledOnTouc…...
css实现文字的渐变，适合大屏
1 在全局写一个全局样式，文字渐变 2 在组件中使用 CSS3利用-webkit-background-clip: text;实现文字渐变效果_css如何把盒子底部的文字变成透明渐变_I俩月亮的博客-CSDN博客 CSS 如何实现文字渐变色 ？_css字体颜色渐变_一个水瓶座程序猿.的博客-CSDN博客…...
软考高级系统架构设计师系列论文八十七：论企业应用集成
软考高级系统架构设计师系列论文八十七：论企业应用集成 一、企业应用集成相关知识点二、摘要三、正文四、总结一、企业应用集成相关知识点 软考高级系统架构设计师系列之：企业集成平台技术的应用和架构设计二、摘要 本文讨论了某公司的应用系统集成项目。某公司为了应对市场变…...
C++设计模式之适配器模式
一、适配器模式 适配器模式（Adapter Pattern）是一种结构型设计模式，用于将一个类的接口转换成另一个类所期望的接口，以便两个类能够协同工作。 适配器模式可以解决现有类接口与所需接口不匹配的问题，使得原本因接口不…...
山西电力市场日前价格预测【2023-08-24】
日前价格预测 预测明日（2023-08-24）山西电力市场全天平均日前电价为319.98元/MWh。其中，最高日前电价为370.78元/MWh，预计出现在19: 30。最低日前电价为272.42元/MWh，预计出现在12: 45。 价差方向预测 1： 实…...
一文速学-让神经网络不再神秘，一天速学神经网络基础（一）
前言 思索了很久到底要不要出深度学习内容，毕竟在数学建模专栏里边的机器学习内容还有一大半算法没有更新，很多坑都没有填满，而且现在深度学习的文章和学习课程都十分的多，我考虑了很久决定还是得出神经网络系列文章，…...
百度Q2财报：营收341亿元实现加速增长，净利润高速增长44%，增长强劲全线重构
北京时间8月22日，百度发布了截至2023年6月30日的第二季度未经审计的财务报告。第二季度，百度实现营收341亿元，同比增长15%；归属百度的净利润（non-GAAP）达到80亿元，同比增长44%。营收和利润双双实…...
ARM DIY（二）配置晶振频率
文章目录 前言串口乱码问题定位内核修改晶振频率uboot 修改晶振频率番外篇 前言 上篇文章《ARM DIY 硬件调试》介绍了 DIY ARM 板的基础硬件焊接，包括电源、SOC、SD 卡座等，板子已经可以跑起来了。 但是发现串口乱码，今天就来解决串口乱码问…...
高等数学：线性代数-第三章
文章目录 第3章 矩阵的初等变换与线性方程组3.1 矩阵的初等变换3.2 矩阵的秩3.3 方程组的解 第3章 矩阵的初等变换与线性方程组 3.1 矩阵的初等变换 矩阵的初等变换 下面三种变换称为矩阵的初等变换 对换两行（列），记作 r i ↔ r j ( c i …...
深入理解 SQL 注入攻击原理与防御措施
系列文章目录 文章目录 系列文章目录前言一、SQL 注入的原理二、防御 SQL 注入攻击的措施1. 使用参数化查询2.输入验证与过滤3.最小权限原则4.不要动态拼接 SQL5.ORM 框架6.转义特殊字符三、实例演示总结前言 SQL 注入是一种常见的网络攻击方式，攻击者通过在输入框等用户交互…...
QT5.12.12通过ODBC连接到GBase 8s数据库（CentOS）
本示例使用的环境如下： 硬件平台：x86_64（amd64）操作系统：CentOS 7.8 2003数据库版本（含CSDK）：GBase 8s V8.8 3.0.0_1 为什么使用QT 5.12.10？该版本包含QODBC。 1&#…...
爱校对发布全新PDF校对工具，为用户带来更为便捷的校正体验
随着数字化文档使用的普及，PDF格式已经成为最为广泛使用的文件格式之一。为满足广大用户对于高效、准确PDF文档校对的需求，爱校对团队经过深入研发，正式推出全新的PDF校对工具！ 这一全新工具针对PDF文件格式进行了深度优化&#…...
记录protocol buffers Mac安装
使用brew安装最新的protobuf 在Mac 上安装，使用brew 可以安装最新的protobuf。这个也比较简单，简单说一下。 首先先检查一下是否安装了brew。如果没有安装brew的话，请先安装brew.可以通过brew --version来检查 使用brew install protobuf 来…...
基于Jenkins自动打包并部署docker、PHP环境，ansible部署-------从小白到大神之路之学习运维第86天
第四阶段提升 时 间：2023年8月23日 参加人：全班人员 内 容： 基于Jenkins部署docker、PHP环境 目录 一、环境部署 （一）实验环境，服务器设置 （二）所有主机关闭防火墙和selinu…...
浙江省城乡与住房建设厅网站/企业网站营销的实现方式
公粽号：黒掌 一个专注于分享渗透测试、黑客圈热点、黑客工具技术区博主！ 前言 今天介绍一种走私技术，HTML Smuggling，这不是一种特别新的攻击方法，但是它确实在越来越多的攻击场景中出现，其中就包括网络钓…...
wordpress 静态html/手机维修培训班学校
一个小问题，够你折腾半天。 天天对着电脑，眼睛永远是熊猫眼 程序员封闭的世界里，缺乏与外界的交流 程序员每天都在超负荷运转，偶尔能休息一下都是莫大的幸福。 但是，这就是程序员。 看到别人玩着苹果，三星&…...
网站全屏视频怎么做/东莞seo优化排名
引子 最近有个虚拟练习项目，涉及到系统安全保障的设计，于是对安全保障这块做了一些更深入的了解。发现了很多有趣的东西，开阔了眼界。中间查了一些资料，于是我打算重新整理，用更加循序渐进，大家都能懂的方式…...
大学生创新创业大赛的意义/广州百度搜索排名优化
如前一节所述，通过训练确定滤波器矩阵的值。 As addressed in the previous section, thevalues of the filter matrix are determined through the training process. 因此，这些值在整个训练过程中不断训练。 Therefore, these values are continuou…...
招商网站建设服务商/seoul怎么读
PythonJS 详细介绍PythonJS 是一个用 Python 写的转换器，用来将 Python 代码转成快速的 JavaScript，可运行于 Node.js 平台上。PythonJS 的设计思路的快速和易于集成现有的 JavaScript 代码。 使用方法： var pythonjs require(python-js); v…...
网站建设是设计师吗/武汉网站排名提升
git cherry-pick可以选择某一个分支中的一个或几个commit(s)来进行操作。例如，假设我们有个稳定版本的分支，叫v2.0，另外还有个开发版本的分支v3.0，我们不能直接把两个分支合并，这样会导致稳定版本混乱，但是…...