C++之STL（标准模板库）介绍

￡神魔★判官ぃ 2023-01-23 14:49 4阅读 0赞

### C++之STL（标准模板库）介绍 ###

**一、C++ STL****概述**

1994 年，STL 被正式纳入 C++ 标准中。STL 是“Standard Template Library”（标准模板库）的缩写。STL 是 C++ 标准库的一部分，不用单独安装。

C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），list 的底层为双向链表，deque 的底层为循环队列，set 的底层为红黑树，hash\_set 的底层为哈希表。

标准模板库（STL），它的基本概念就是把数据和操作分离，含有容器（Container）、算法（Algorithm）、迭代器（Iterator）等组件。

通常认为，STL 是由容器、算法、迭代器、函数对象、适配器、内存分配器这 6 部分构成，其中后面 4 部分是为前 2 部分服务的，它们各自的含义如下表：

<table style="width:690px;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#ededed;border-color:#cccccc;width:113px;"> STL的组成 </td> 
 <td style="background-color:#ededed;border-color:#cccccc;width:574px;"> 含义 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;width:113px;"> 容器 </td> 
 <td style="background-color:#ffffff;width:574px;"> 一些封装数据结构的模板类，例如 vector 向量容器、list 列表容器等。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;width:113px;"> 算法 </td> 
 <td style="background-color:#ffffff;width:574px;"> STL 提供了非常多（大约 100 个）的数据结构算法，它们都被设计成一个个的模板函数，这些算法在 std 命名空间中定义，其中大部分算法都包含在头文件 &lt;algorithm&gt; 中，少部分位于头文件 &lt;numeric&gt; 中。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;width:113px;"> 迭代器 </td> 
 <td style="background-color:#ffffff;width:574px;"> 在 C++&nbsp;STL 中，对容器中数据的读和写，是通过迭代器完成的，扮演着容器和算法之间的胶合剂。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;width:113px;"> 函数对象（又称仿函数） </td> 
 <td style="background-color:#ffffff;width:574px;"> 如果一个类将 () 运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象（又称仿函数）。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;width:113px;"> 适配器 </td> 
 <td style="background-color:#ffffff;width:574px;"> 可以使一个类的接口（模板的参数）适配成用户指定的形式，从而让原本不能在一起工作的两个类工作在一起。值得一提的是，容器、迭代器和函数都有适配器。 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#cccccc;width:113px;"> 内存分配器 </td> 
 <td style="background-color:#ffffff;width:574px;"> 为容器类模板提供自定义的内存申请和释放功能，由于往往只有高级用户才有改变内存分配策略的需求，因此内存分配器对于一般用户来说，并不常用。 </td> 
 </tr> 
 </tbody> 
</table>

STL的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使得STL变得非常通用。例如，由于STL的sort()函数是完全通用的，你可以用它来操作几乎任何数据集合。

STL另一个重要特性是它不是面向对象的。为了具有足够通用性，STL主要依赖于模板而不是封装，继承和虚函数（多态性）——OOP的三个要素。你在STL中找不到任何明显的类继承关系。这好像是一种倒退，但这正好是使得STL的组件具有广泛通用性的底层特征。另外，由于STL是基于模板，内联函数的使用使得生成的代码短小高效；

从逻辑层次来看，在STL中体现了泛型（generic）化程序设计的思想，引入了诸多新的名词，比如像需求（requirements），概念（concept），模型（model），容器（container），算法（algorithmn），迭代器（iterator）等。与OOP（object-oriented programming）中的多态（polymorphism）一样，泛型也是一种软件的复用技术；泛型编程(Generic Programming) 指在多种数据类型上皆可操作，泛型算法是建立在语法一致性上。

从实现层次看，整个STL是以一种类型参数化的方式实现的，这种方式基于一个在早先C++标准中没有出现的语言特性——模板（template）。从根本上说，STL 是一些容器、算法和其他一些组件的集合，所有容器和算法都是总结了几十年来算法和数据结构的研究成果，汇集了许多计算机专家学者经验的基础上实现的，因此可以说，STL 基本上达到了各种存储方法和相关算法的高度优化。

**STL容器**

1）序列式容器（Sequence containers），每个元素都有固定位置——取决于插入时机和地点，和元素值无关，vector、deque、list；

Vectors：将元素置于一个动态数组中加以管理，可以随机存取元素（用索引直接存取），数组尾部添加或移除元素非常快速。但是在中部或头部安插元素比较费时；

Deques：是“double-ended queue”的缩写，可以随机存取元素（用索引直接存取），数组头部和尾部添加或移除元素都非常快速。但是在中部或头部安插元素比较费时；

Lists：双向链表，不提供随机存取（按顺序走到需存取的元素，O(n)），在任何位置上执行插入或删除动作都非常迅速，内部只需调整一下指针；

2）关联式容器（Associated containers），元素位置取决于特定的排序准则，和插入顺序无关，set、multiset、map、multimap；

Sets/Multisets：内部的元素依据其值自动排序，Set内的相同数值的元素只能出现一次，Multisets内可包含多个数值相同的元素，内部由二叉树实现（实际上基于红黑树(RB-tree）实现），便于查找；

Maps/Multimaps：Map的元素是成对的键值/实值，内部的元素依据其值自动排序，Map内的相同数值的元素只能出现一次，Multimaps内可包含多个数值相同的元素，内部由二叉树实现（实际上基于红黑树(RB-tree）实现），便于查找；

另外有其他容器hash\_map,hash\_set,hash\_multiset,hash\_multimap。

容器的比较：

<table style="width:483.4pt;"> 
 <tbody> 
 <tr> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:85.3pt;"> &nbsp; &nbsp; </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:57.1pt;"> Vector </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:53.25pt;"> Deque </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:63.6pt;"> List </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:47.95pt;"> Set </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:57.35pt;"> MultiSet </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:55.45pt;"> Map </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;width:63.4pt;"> MultiMap </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:85.3pt;"> 内部结构 </td> 
 <td style="width:57.1pt;"> dynamic array </td> 
 <td style="width:53.25pt;"> array of arrays </td> 
 <td style="width:63.6pt;"> double linked&nbsp;&nbsp;list </td> 
 <td style="width:47.95pt;"> binary tree </td> 
 <td style="width:57.35pt;"> binary tree </td> 
 <td style="width:55.45pt;"> binary tree </td> 
 <td style="width:63.4pt;"> binary tree </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:85.3pt;"> 随机存取 </td> 
 <td style="width:57.1pt;"> Yes </td> 
 <td style="width:53.25pt;"> Yes </td> 
 <td style="width:63.6pt;"> No </td> 
 <td style="width:47.95pt;"> No </td> 
 <td style="width:57.35pt;"> No </td> 
 <td style="width:55.45pt;"> Yes(key) </td> 
 <td style="width:63.4pt;"> No </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:85.3pt;"> 搜索速度 </td> 
 <td style="width:57.1pt;"> 慢 </td> 
 <td style="width:53.25pt;"> 慢 </td> 
 <td style="width:63.6pt;"> 很慢 </td> 
 <td style="width:47.95pt;"> 快 </td> 
 <td style="width:57.35pt;"> 快 </td> 
 <td style="width:55.45pt;"> 快 </td> 
 <td style="width:63.4pt;"> 快 </td> 
 </tr> 
 <tr> 
 <td style="border-color:#c0c0c0;width:85.3pt;"> 快速插入移除 </td> 
 <td style="width:57.1pt;"> 尾部 </td> 
 <td style="width:53.25pt;"> 首尾 </td> 
 <td style="width:63.6pt;"> 任何位置 </td> 
 <td style="width:47.95pt;"> -- </td> 
 <td style="width:57.35pt;"> -- </td> 
 <td style="width:55.45pt;"> -- </td> 
 <td style="width:63.4pt;"> -- </td> 
 </tr> 
 </tbody> 
</table>

【STL通用容器分三类：顺序性容器、关联式容器和容器适配器。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70][]

简单的理解，容器适配器其就是将不适用的序列式容器（包括 vector、deque 和 list）变得适用。

容器适配器本质上还是容器，只不过此容器模板类的实现，利用了大量其它基础容器模板类中已经写好的成员函数。当然，如果必要的话，容器适配器中也可以自创新的成员函数。】

**STL****迭代器**

无论是序列容器还是关联容器，最常做的操作无疑是遍历容器中存储的元素，而实现此操作，多数情况会选用“迭代器（iterator）”来实现。尽管不同容器的内部结构各异，但它们本质上都是用来存储大量数据的，换句话说，都是一串能存储多个数据的存储单元。因此，诸如数据的排序、查找、求和等需要对数据进行遍历的操作方法应该是类似的。

Iterator（迭代器）又称Cursor（游标），用于提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。或者这样说可能更容易理解：Iterator模式是运用于聚合对象的一种模式，通过运用该模式，使得我们可以在不知道对象内部表示的情况下，按照一定顺序（由iterator提供的方法）访问聚合对象中的各个元素。

STL 标准库为每一种标准容器定义了一种迭代器类型，这意味着，不同容器的迭代器也不同，其功能强弱也有所不同。

容器的迭代器的功能强弱，决定了该容器是否支持 STL 中的某种算法。

常用的迭代器按功能强弱分为输入迭代器、输出迭代器、前向迭代器（forward iterator）、双向迭代器（bidirectional iterator）、随机访问迭代器 5 种。

<table> 
 <tbody> 
 <tr> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;"> 迭代器类别&nbsp;&nbsp; </td> 
 <td style="background-color:#eeece1;border-color:#c0c0c0;"> 说明 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#c0c0c0;"> 输入 </td> 
 <td style="background-color:#ffffff;"> 从容器中读取元素。输入迭代器只能一次读入一个元素向前移动， 输入迭代器只支持一遍算法，同一个输入迭代器不能两遍遍历一个序列 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#c0c0c0;"> 输出 </td> 
 <td style="background-color:#ffffff;"> 向容器中写入元素。输出迭代器只能一次一个元素向前移动。 输出迭代器只支持一遍算法，统一输出迭代器不能两次遍历一个序列 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#c0c0c0;"> 正向 </td> 
 <td style="background-color:#ffffff;"> 组合输入迭代器和输出迭代器的功能，并保留在容器中的位置 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#c0c0c0;"> 双向 </td> 
 <td style="background-color:#ffffff;"> 组合正向迭代器和逆向迭代器的功能，支持多遍算法 </td> 
 </tr> 
 <tr> 
 <td style="background-color:#ffffff;border-color:#c0c0c0;"> 随机访问 </td> 
 <td style="background-color:#ffffff;"> 组合双向迭代器的功能与直接访问容器中任何元素的功能， 即可向前向后跳过任意个元素 </td> 
 </tr> 
 </tbody> 
</table>

迭代器遍历访问的大致思路是，创建容器的迭代器，让迭代器指向第一个元素，逐步向后移动并最终指向最后一个元素结束。

遍历示例代码：

vector<int> v(10,5);    //创建一个向量v，其已开辟10个元素的空间并全部赋值为5

vector<int>::iterator it;   //用迭代器（iterator）访问

for(it=v.begin();it!=v.end();it++)\{

cout<<\*it<<' ';

当然，遍历也可以直接使用下标访问：

for(int i=0;i<v.size();i++)\{

cout<<v\[i\]<<' ';

**算法**

STL提供了大约100个实现算法的模版函数，比如算法for\_each将为指定序列中的每一个元素调用指定的函数，stable\_sort以你所指定的规则对序列进行稳定性排序等等。只要我们熟悉了STL之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要的功能并大大地提升效率。

算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。

<algorithm>是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。

<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。

<functional>中则定义了一些模板类，用以声明函数对象。

STL中算法大致分为四类：

非可变序列算法：指不直接修改其所操作的容器内容的算法。

可变序列算法：指可以修改它们所操作的容器内容的算法。

排序算法：对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作。

数值算法：对容器内容进行数值计算。

**二、C++ STL几个常见****容器的使用**

**★Vector****（向量）容器**

Vector是最简单的序列是容器，就像数组一样，向量使用连续的存储位置作为元素，这意味着它们的元素也可以使用常量指向其元素的偏移来访问，与数组一样有效。但与数组不同，它们的大小可以动态变化，其存储由容器自动处理。

Vector就是一个动态创建空间，且预先加载了常用的数组操作的数组。

相关文件

头文件：\#include <vector>

格式为：vector<Data\_Types> name;

如：

vector<int> v1;          //创建一个空的向量v1

vector<int> v2(10);      //创建一个向量v2，其已开辟10个元素的空间，相当于int v\[10\];

vector<int> v3(10,5);    //创建一个向量v3，其已开辟10个元素的空间并全部赋值为5

下面给出一个完整示例：

#include<iostream>
 #include<vector>
 using namespace std;
 int main()
 {
 vector<string> v1;
 //添加 2个值到向量中
 v1.push_back("一民");
 v1.push_back("，你好啊！");
 // 使用迭代器 iterator 访问值
 for(vector<string>::iterator itr=v1.begin();itr!=v1.end();++itr){
 cout<<*itr;
 }
 return 0; 
 }

运行输出：  
一民，你好啊！

vector的遍历有多种方式：

\[\]方式，如果越界或出现其他错误，不会抛出异常，可能会崩溃，可能数据随机出现；

at方式，如果越界或出现其他错误，会抛出异常，需要捕获异常并处理；

迭代器提供了逆向遍历，可以通过迭代器来实现逆向遍历，当然上面两种方式也可以。

如：

#include<iostream>
 #include<vector>
 using namespace std;
 int main()
 {
 //创建vector
 vector<int> v1;
 
 //插入元素
 for (int i = 0; i < 10; i++) {
 v1.push_back(i);
 }
 
 //遍历-[]取值
 for (int i = 0; i < v1.size(); i++) {
 cout << v1[i] << " ";
 }
 cout << endl;
 
 //遍历-at取值
 for (int i = 0; i < v1.size(); i++) {
 cout << v1.at(i) << " ";
 }
 cout << endl;
 
 //遍历-迭代器遍历
 for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {
 cout << *it << " ";
 }
 cout << endl;
 
 //遍历-迭代器逆向遍历
 for (vector<int>::reverse_iterator it = v1.rbegin(); it != v1.rend(); it++) {
 cout << *it << " ";
 }
 cout << endl;
 
 //测试越界
 cout << "[]越界:" << v1[20] << endl; //不会抛出异常，可能会崩溃，可能会乱码
 cout << "at越界:" << v1.at(20) << endl; //会抛出异常，需要捕获异常
 
 return 0;
 }

运行输出：

0 1 2 3 4 5 6 7 8 9  
0 1 2 3 4 5 6 7 8 9  
0 1 2 3 4 5 6 7 8 9  
9 8 7 6 5 4 3 2 1 0  
\[\]越界:1596032  
terminate called after throwing an instance of 'std::out\_of\_range'  
  what():  vector::\_M\_range\_check: \_\_n (which is 20) >= this->size() (which is 10)

关于上面实例中所使用的begin() 、end()函数见下面。

C ++ Vector（向量）常见的成员函数：

函数  描述

at(idx)      传回索引idx所指的数据，如果idx越界，抛出out\_of\_range。

back()       返回最后一个原始，不检查这个数据是否存在。

front()      返回第一个元素。

swap()      交换两个Vector。

push\_back()     在Vector最后添加一个元素。

pop\_back()      它从向量中删除最后一个元素。

empty()    判断Vector是否为空（返回true时为空）

insert()     它将在指定位置插入新元素。

erase()     删除指定的元素。

resize()     它修改向量的大小。

clear()      它从向量中删除所有元素。

size()        返回Vector元素数量的大小。

capacity() 返回vector所能容纳的元素数量(在不重新分配内存的情况下）

assign()    它将新值分配给向量。

operator=()      它将新值分配给向量容器。

operator\[\]()     它访问指定的元素。

end()        返回最末元素的迭代器(实指向最末元素的下一个位置)

emplace()        它将在位置pos之前插入一个新元素。

emplace\_back()      它在末尾插入一个新元素。

rend()       它指向向量的第一个元素之前的元素。

rbegin()    它指向向量的最后一个元素。

begin()     返回第一个元素的迭代器。

max\_size()       返回Vector所能容纳元素的最大数量（上限）。

cend()      它指向量中的last-last-element。

cbegin()   它指向量的第一个元素。

crbegin()  它指的是向量的最后一个字符。

crend()     它指的是向量的第一个元素之前的元素。

data()       它将向量的数据写入数组。

shrink\_to\_fit() 它减少了容量并使它等于向量的大小。

★**Deque****（双端队列）**

所谓的deque是”double ended queue”的缩写，双端队列不论在尾部或头部插入元素，都十分迅速。而在中间插入元素则会比较费时，因为必须移动中间其他的元素。双端队列是一种随机访问的数据类型，提供了在序列两端快速插入和删除操作的功能，它可以在需要的时候改变自身大小，完成了标准的C++数据结构中队列的所有功能。

双端队列表示双端队列。它概括了队列数据结构，即可以从前端或后端的两端进行插入和删除。

![20210718192046627.png][]

相关文件

头文件：\#include<deque>

创建语法格式为：deque<object\_type> deque\_name;

如：

deque<type> deq;  // 声明一个元素类型为type的双端队列que

deque<type> deq(size);  //声明一个类型为type、含有size个默认值初始化元素的的双端队列que

deque<type> deq(size, value);  //声明一个元素类型为type、含有size个value元素的双端队列que

deque<type> deq(mydeque);  // deq是mydeque的一个副本

deque<type> deq(first, last);  // 使用迭代器first、last范围内的元素初始化deq

实例

#include<iostream>
 #include<deque>
 using namespace std;
 int main(void)
 {
 	int i;
 	int a[10] = { 0,1,2,3,4,5,6,7,8,9 };
 	deque<int> q;
 	for (i = 0; i <= 9; i++)
 	{
 		if (i % 2 == 0)
 			q.push_front(a[i]);
 		else
 			q.push_back(a[i]);
 	} //此时队列里的内容是: {8,6,4,2,0,1,3,5,7,9}
 	q.pop_front();
 	cout << q.front()<< endl; //清除第一个元素后输出第一个(6)
 	q.pop_back();
 	cout << q.back() << endl; //清除最后一个元素后输出最后一个(7)
 	deque<int>::iterator it;
 	for (it = q.begin(); it != q.end(); it++) {
 		cout << *it << '\t';
 	}
 	cout << endl;
 	system("pause");
 	return 0;
 }

运行输出：

6  
7  
6       4       2       0       1       3       5       7

C ++ Deque（双端队列）常见的成员函数：

函数/方法       描述

assign()    它分配新内容并替换旧内容。

emplace()        它将在指定位置添加一个新元素。

emplace\_back()      它在末尾添加一个新元素。

emplace\_front()      它在双端队列的开头添加一个新元素。

insert()     它在指定位置之前添加一个新元素。

push\_back()     它在容器的末尾添加一个新元素。

push\_front()    它在容器的开头添加一个新元素。

pop\_back()      它从双端队列中删除最后一个元素。

pop\_front()      它从双端队列中删除第一个元素。

swap()      它交换两个双端队列的内容。

clear()      它将删除双端队列的所有内容。

empty()    它检查容器是否为空。

erase()     它删除元素。

max\_size()       它确定双端队列的最大大小。

resize()     它改变了双端队列的大小。

shrink\_to\_fit() 它减少了内存以适合双端队列的大小。

size()        它返回元素数。

at()   它访问位置pos处的元素。

operator\[\]()     它访问位置pos处的元素。

operator=()      它将新的内容分配给容器。

back()       它访问最后一个元素。

begin()     它将迭代器返回到双端队列的开头。

cbegin()   它向双端队列的开头返回一个常量迭代器。

end()        它将迭代器返回到末尾。

cend()      它将常量迭代器返回到末尾。

rbegin()    它将反向迭代器返回到开头。

crbegin()  它将常量反向迭代器返回到开头。

rend()       它将反向迭代器返回到末尾。

crend()     它将常量反向迭代器返回到末尾。

front()      它访问最后一个元素。

**★List****（列表）容器**

list是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的 。list支持双向，并为插入和删除操作提供了一种有效的方法。在列表中遍历速度很慢，因为列表元素是按顺序访问的。

相关文件

头文件：\#include<list>

创建语法格式为：list <object\_type> list \_name;

如：

list<int> l1;           //创建一个空链表

list<int> l2(10);       //创建一个链表其有10个空元素

list<int> l3(5,20);     //创建一个链表其有5个元素内容为20

实例

#include<iostream>
 #include<list>
 using namespace std;
 int cmp(const int &a,const int &b){ 
 //简单的自定义降序序列
 return a>b;
 }
 int main(){
 list<int> li; //创建一个空链表
 for(int i=10;i>=6;i--){
 li.push_back(i);
 }
 li.push_front(3);
 li.push_back(20);
 list<int> li2(li);
 for(list<int>::iterator it=li.begin();it!=li.end();it++){
 cout<<*it<<' ';
 }
 cout<<endl;
 //排序前3 10 9 8 7 6 20//
 li.sort();
 
 for(list<int>::iterator it=li.begin();it!=li.end();it++){
 cout<<*it<<' ';
 }
 cout<<endl;
 //默认排序后 3 6 7 8 9 10 20//
 li2.sort(cmp);
 for(list<int>::iterator it=li2.begin();it!=li2.end();it++){
 cout<<*it<<' ';
 }
 cout<<endl;
 //自定义排序后 20 10 9 8 7 6 3//
 return 0;
 }

运行输出：

3 10 9 8 7 6 20

3 6 7 8 9 10 20

20 10 9 8 7 6 3

list容器具有如下特性：

可以在头部和尾部插入和删除元素；

不能随机访问元素，也就是迭代器只能只能++,不能一次性跳转。

如：

#include<iostream>
 #include<list>
 using namespace std;
 int main()
 {
 	//创建list对象
 list<int> l;
 
 //尾部添加元素
 for (int i = 0; i < 10; i++) {
 l.push_back(i);
 }
 
 //头部添加元素
 l.push_front(22);
 
 //遍历
 for (list<int>::iterator it = l.begin(); it != l.end(); it++) {
 cout << *it << " ";
 }
 cout << endl;
 
 //list不能随机访问
 list<int>::iterator it = l.begin();
 it++;
 it++;
 cout << *it <<endl;
 
 // it = it + 5; //编译报错，不能随机访问
 
 return 0;
 }

运行输出：

22 0 1 2 3 4 5 6 7 8 9  
1

List（列表）常见的成员函数：

函数/方法        描述

insert()     它将新元素插入到迭代器指向的位置之前。

push\_back()      它在容器的末尾添加了一个新元素。

push\_front()     它在前面增加了一个新元素。

pop\_back()       删除最后一个元素。

pop\_front()       删除第一个元素。

empty()    它检查列表是否为空。

size()         它查找列表中存在的元素数。

max\_size()        它找到列表的最大大小。

front()       它返回列表的第一个元素。

back()       它返回列表的最后一个元素。

swap()      当两个列表的类型相同时，它将交换两个列表。

reverse()  它反转了列表的元素。

sort()         它以递增的顺序对列表中的元素进行排序。

merge()    它合并两个排序的列表。

splice()      它将新列表插入到调用列表中。

unique()   它从列表中删除所有重复的元素。

resize()     它更改列表容器的大小。

assign()     它将一个新元素分配给列表容器。

emplace()         它将在指定位置插入一个新元素。

emplace\_back()        它将在容器的末尾插入一个新元素。

emplace\_front()       它将在列表的开头插入一个新元素。

**★set****（集合）/multiset****（多重集合）容器**

set/multiset属于关联式容器，底层结构是用二叉树实现。

set和multiset区别：

set不允许容器中有重复的元素，其中每个键都是唯一的，可以插入或删除但不能更改。

multiset允许容器中有重复的元素。

相关文件

头文件：\#include <set>

创建语法格式为：set| multiset <object\_type> name;

如：

set<int> set1; //创建默认的从小到大的int类型的集合

set<int,less<int> > set2; //创建一个从小打到大的int类型的集合，注意> >之间有空格。

set<int,greater<int> > set3; //创建一个从大到小的int类型的集合，注意> >之间有空格。

特别提示：set/multiset容器是有序的集合，默认的顺序是从小到大的。

Set示例：

#include<iostream>
 #include<set>
 using namespace std;
 int main()
 {
 set<int> s;
 s.insert(1);
 s.insert(2);
 s.insert(3);
 s.insert(1);
 //输出结果按照从小到大的顺序排序
 for (set<int>::iterator x = s.begin(); x != s.end(); x++)
 {
 	cout << *x << endl;
 	}
 cout << endl;
 s.erase(2); //删除一个元素
 for (set<int>::iterator x = s.begin(); x != s.end(); x++)
 {
 	cout << *x << endl;
 	}
 //判断一个元素是否存在
 if (s.count(1))
 cout << "存在\n";
 else
 cout << "不存在\n";
 
 return 0; 
 }

运行输出：

1  
2  
3

1  
3  
存在

Multiset示例：

#include<iostream>
 #include<set>
 using namespace std;
 int main()
 {
 multiset<int> s;
 s.insert(1);
 s.insert(2);
 s.insert(3);
 s.insert(1);
 //输出结果按照从小到大的顺序排序
 for (multiset<int>::iterator x = s.begin(); x != s.end(); x++)
 {
 	cout << *x << endl;
 	}
 cout << endl;
 s.erase(2); //删除一个元素
 for (multiset<int>::iterator x = s.begin(); x != s.end(); x++)
 {
 	cout << *x << endl;
 	}
 //判断一个元素是否存在
 if (s.count(1))
 cout << "存在\n";
 else
 cout << "不存在\n";
 
 return 0; 
 }

运行输出：

1  
1  
2  
3

1  
1  
3  
存在

set（集合）/multiset（多重集合）常见成员函数的列表：

函数/方法       描述

begin()  返回指向第一个元素的迭代器

clear()  清除所有元素

count()  返回某个值元素的个数

empty()  如果集合为空，返回true

end()  返回指向最后一个元素的迭代器

equal\_range()  返回集合中与给定值相等的上下限的两个迭代器

erase()  删除集合中的元素

find()  返回一个指向被查找到元素的迭代器

get\_allocator()  返回集合的分配器

insert()  在集合中插入元素

lower\_bound()  返回指向大于（或等于）某值的第一个元素的迭代器

key\_comp()  返回一个用于元素间值比较的函数

max\_size()  返回集合能容纳的元素的最大限值

rbegin()  返回指向集合中最后一个元素的反向迭代器

rend()  返回指向集合中第一个元素的反向迭代器

size()  集合中元素的数目

swap()  交换两个集合变量

upper\_bound()  返回大于某个值元素的迭代器

value\_comp()  返回一个用于比较元素间的值的函数

**★map****（映射）/multimap（多重映射）容器**

map和multimap都是键值对（key-value），每一个元素都有一个键，唯一的不同是，map的键值key不可重复，而multimap可以，也正是由于这种区别，map支持\[ \]运算符，multimap不支持\[ \]运算符。在用法上没什么区别。map和multimap都需要\#include<map>。

相关文件

头文件：\#include <map>

创建语法格式为：map| multimap <object\_type> name;

如：

map<int, string> mapName;

map示例：

#include <iostream>
 #include <map> //map
 using namespace std; 
 int main()
 {
 //创建并初始化 multimap 容器
 map<char, int>mymap{ {'a',10},{'b',20},{'b',15}, {'c',30} };
 //输出 mymap 容器存储键值对的数量
 cout << mymap.size() << endl;
 //输出 mymap 容器中存储键为 'b' 的键值对的数量
 cout << mymap.count('b') << endl;
 for (auto iter = mymap.begin(); iter != mymap.end(); ++iter) {
 cout << iter->first << " " << iter->second << endl;
 }
 return 0;
 }

运行输出：

3  
1  
a 10  
b 20  
c 30

multimap示例：

#include <iostream>
 #include <map> //map
 using namespace std; 
 int main()
 {
 //创建并初始化 multimap 容器
 multimap<char, int>mymultimap{ {'a',10},{'b',20},{'b',15}, {'c',30} };
 //输出 mymultimap 容器存储键值对的数量
 cout << mymultimap.size() << endl;
 //输出 mymultimap 容器中存储键为 'b' 的键值对的数量
 cout << mymultimap.count('b') << endl;
 for (auto iter = mymultimap.begin(); iter != mymultimap.end(); ++iter) {
 cout << iter->first << " " << iter->second << endl;
 }
 return 0;
 }

运行输出：

4  
2  
a 10  
b 20  
b 15  
c 30

Map（映射）/multimap（多重映射）常见成员函数的列表：

函数/方法       描述

begin()    返回指向map头部的迭代器

clear(）   删除所有元素

count()    返回指定元素出现的次数

empty()    如果map为空则返回true

end() 返回指向map末尾的迭代器

equal\_range()   返回特殊条目的迭代器对

erase()    删除一个元素

find()查找一个元素

get\_allocator() 返回map的配置器

insert()   插入元素

key\_comp() 返回比较元素key的函数

lower\_bound()   返回键值>=给定元素的第一个位置

max\_size() 返回可以容纳的最大元素个数

rbegin()   返回一个指向map尾部的逆向迭代器

rend()返回一个指向map头部的逆向迭代器

size()返回map中元素的个数

swap() 交换两个map

upper\_bound()    返回键值>给定元素的第一个位置

value\_comp()返回比较元素value的函数

**★array容器**

array 容器是 C++ 11 标准中新增的序列容器，简单地理解，它就是在 C++ 普通数组的基础上，添加了一些成员函数和全局函数。在使用上，它比普通数组更安全。和其它容器不同，array 容器的大小是固定的，无法动态的扩展或收缩，这也就意味着，在使用该容器的过程无法借由增加或移除元素而改变其大小，它只允许访问或者替换存储的元素。

array 容器以类模板的形式定义在 <array> 头文件，并位于命名空间 std 中，因此，在使用该容器之前，代码中需引入 <array> 头文件，并默认使用 std 命令空间，如下所示：

\#include <array>

using namespace std;

array 容器有多种初始化方式，如下代码展示了如何创建具有 10 个 double 类型元素的 array 容器：

std::array<double, 10> values;

【提示，如果程序中已经默认指定了 std 命令空间，这里可以省略 std::】

由此，就创建好了一个名为 values 的 array 容器，其包含 10 个浮点型元素。但是，由于未显式指定这 10 个元素的值，因此使用这种方式创建的容器中，各个元素的值是不确定的。

std::array<double, 10> values \{\};

使用该语句，容器中所有的元素都会被初始化为 0.0。

在创建 array 容器的实例时，也可以像创建常规数组那样对元素进行初始化：

std::array<double, 10> values \{0.5,1.0,1.5,,2.0\};

可以看到，这里只初始化了前 4 个元素，剩余的元素都会被初始化为 0.0。如下图所示：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25oqA5pyv5a2m5Lmg5byA5Y-R54ix5aW96ICF_size_9_color_FFFFFF_t_70_g_se_x_16][]

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 容器中的所有元素，但前提是它们具有相同的长度和类型。

示例：

#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 << " ";
 }
 }
 }

运行之输出结果为：

3  
0 1 2 3

**附录、参考资料**

[https://blog.csdn.net/u010183728/article/details/81913729][https_blog.csdn.net_u010183728_article_details_81913729]

[https://www.nhooo.com/cpp/cpp-stl-tutorial.html][https_www.nhooo.com_cpp_cpp-stl-tutorial.html]

[https://blog.csdn.net/acceptedday/article/details/118529280][https_blog.csdn.net_acceptedday_article_details_118529280]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NuZHMxMjM_size_16_color_FFFFFF_t_70]: /images/20221004/6bdb50cec56f42cc959fe40157d20653.png
[20210718192046627.png]: /images/20221004/8b6e5cc3ba864553ba74454cbb34eec9.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA6L2v5Lu25oqA5pyv5a2m5Lmg5byA5Y-R54ix5aW96ICF_size_9_color_FFFFFF_t_70_g_se_x_16]: /images/20221004/dfb2b66fc0304d63834aaa9050297f1e.png
[https_blog.csdn.net_u010183728_article_details_81913729]: https://blog.csdn.net/u010183728/article/details/81913729
[https_www.nhooo.com_cpp_cpp-stl-tutorial.html]: https://www.nhooo.com/cpp/cpp-stl-tutorial.html
[https_blog.csdn.net_acceptedday_article_details_118529280]: https://blog.csdn.net/acceptedday/article/details/118529280