## [1]一.C++内置顺序容器
| 容器类型 | 位置 | 名称 | 访问 | 头部插入 | 尾部插入 | 中部插入 | 存储结构 |
| -------------------- | ---------------- | -------------- | ------------ | -------- | -------- | -------- | ------------------------------ |
| `vector` | `<vector>` | 向量 | 快速随机访问 | 慢 | 快 | 慢 | 动态数组 |
| `deque` | `<deque>` | 双端队列 | 快速随机访问 | 快 | 快 | 慢 | 通过指针数组连接的多个动态数组 |
| `list` | `<list>` | 双向链表 | 双向顺序访问 | 快 | 快 | 快 | 双向链表 |
| [11+] `forward_list` | `<forward_list>` | 单向链表 | 单向顺序访问 | 快 | 快 | 快 | 双向链表 |
| [11+] `array` | `<array>` | 固定大小的数组 | 快速随机访问 | 不支持 | 不支持 | 不支持 | 数组 |
| `string` | `<string>` | 字符串 | 快速随机访问 | 慢 | 快 | 慢 | 动态数组 |
## [$]二.顺序容器选择原则
1. 一般使用 `vector`.
2. 如果你的程序有很多小的元素,且空间的额外开销很重要,则不要使用 `list` 或 `forward list` 。
3. 如果程序要求随机访问元素,应使用 `vector` 或 `deque` .
4. 如果程序要求在容器的中间插入或删除元素,应使用 `list` 或 `forward_list`.
5. 如果程序需要在头尾位置插入或删除元素,但不会在中间位置进行插入或删除操作,则使用 `deque`。
## [$]三.顺序容器的特色操作
### 1.插入操作
+ 插入操作会使迭代器失效。
+ 将元素插入到 `vector` 、`deque` 和 `string` 中的任何位置可能会耗费较多时间。
+ C++11之前, `insert` 函数的返回值为 `void` 。
| 函数 | 不适用容器 | 含义 |
| ------------------------------------------------ | -------------- | ------------------------------------------------------ |
| `void c.push_back(const T &el);` | `forward_list`、`array` | 在末尾插入元素。 |
| [11+]`void c.emplace_back(const T &el1,const T &el2,...);` | `forward_list`、`array` | 在末尾插入多个元素。 |
| `void c.push_front(const T &el);` | `array`、`vector`、`string` | 在头部插入元素。 |
| [11+]`void c.emplace_front(const T &el1,const T &el2,...);` | `array`、`vector`、`string` | 在头部插入多个元素。 |
| `c.insert(p,const T &el);`| `array` | 在迭代器 `p` 指向的元素之前插入一个元素。返回指向新添加的元素的迭代器。 |
| `c.insert(p,size_type n,const T &el);`| `array` | 在迭代器 `p` 指向的元素之前插入`n`个元素,每个元素的值为 `t`。返回指向新添加的元素的迭代器。 |
| `c.insert(p,b,e);`| `array` | 在迭代器 `p` 指向的元素之前插入`b` 和 `e`之间的元素。`b`和`e`不能指向`c`中的元素。 |
| [11+]`c.insert(p,{a,b,c,...});`| `array` | 在迭代器 `p` 指向的元素之前插入花括号中的元素。返回指向新添加的元素的迭代器。 |
| [11+]`c.emplace(p,const T &el1,const T &el2,...);`| `array` | 在迭代器 `p` 指向的元素之前插入多个元素。返回指向新添加的元素的迭代器。 |
### 2.访问操作
+ 只有 `at` 越界访问时,才会抛出 `out_ of_ range` 的异常。
| 函数或语句| 不适用容器 | 含义|
| ------------------------------------------------ | -------------- | ------------------------------------------------------ |
| `c.at(n);` | `forward_list`、`list` | 返回下标为 `n`的元素的引用。|
| `c[n];` | `forward_list`、`list` | 返回下标为 `n`的元素的引用。|
| `c.back();` | `forward_list` | 返回尾元素的引用。|
| `c.front();` | 无 | 返回首元素的引用。|
### 3.删除操作
+ 删除操作会使迭代器失效。
+ 删除一个指向不存在的元素的迭代器是未定义的。
+ 删除空容器中的元素是未定义的。
| 函数 | 不适用容器 | 含义 |
| ------------------------------------------------ | -------------- | ------------------------------------------------------ |
| `void c.pop_back(const T &el);` | `forward_list`、`array` | 删除末尾元素。 |
| `void c.pop_front(const T &el);` | `array`、`vector`、`string` | 删除第一个元素。 |
| `c.erase(p);`| `forward_list`、`array` | 删除迭代器 `p` 指向的元素。返回下一个元素的迭代器。 |
| `c.erase(b,e);`| `forward_list`、`array` | 删除迭代器 [`b`,`e`] 之间的元素。返回下一个元素的迭代器。 |
- 阅读说明
- 1.1 概述
- C++基础
- 1.2 变量与常量
- 1.2.1 变量
- 1.2.2 字面值常量
- 字符型常量
- 数值型常量
- 1.2.3 cv限定符
- 1.3 作用域
- 1.3.1 标识符
- 1.3.2 *命名空间
- 1.3.3 作用域
- 1.3.4 可见性
- 1.4 数据类型
- 1.4.1 概述
- 1.4.2 处理类型
- 类型别名
- * auto说明符
- * decltype说明符
- 1.4.3 数组
- 1.4.4 指针
- 1.4.5 引用
- 1.5 表达式
- 1.5.1 概述
- 1.5.2 值的类别
- 1.5.3 *初始化
- 1.5.4 运算符
- 算术运算符
- 逻辑和关系运算符
- 赋值运算符
- 递增递减运算符
- 成员访问运算符
- 位运算符
- 其他运算符
- 1.5.5 *常量表达式
- 1.5.6 类型转换
- 第2章 面向过程编程
- 2.1 流程语句
- 2.1.1 条件语句
- 2.1.2 循环语句
- 2.1.3 跳转语句
- 2.1.4 *异常处理
- 2.2 函数
- 2.2.1 概述
- 2.2.2 函数参数
- 2.2.3 内置函数
- 2.2.4 函数重载
- 2.2.5 * 匿名函数
- 2.3 存储和生命期
- 2.3.1 生命周期与存储区域
- 2.3.2 动态内存
- 2.4 *预处理命令
- 第3章 面向对象编程
- 3.1 概述
- 3.2 类和对象
- 3.3 成员
- 3.3.1 访问限制
- 3.3.2 常成员
- 3.3.3 静态成员
- 3.3.4 成员指针
- 3.3.5 this指针
- 3.4 特殊的成员函数
- 3.4.1 概述
- 3.4.2 构造函数
- 3.4.3 析构函数
- 3.4.4 拷贝语义
- 3.4.5 * 移动语义
- 3.5 友元
- 3.6 运算符重载与类型转换
- 3.6.1 概述
- 3.6.2 重载方法
- 3.6.3 类型转换
- 3.7 继承与多态性
- 3.7.1 概述
- 3.7.2 派生类
- 3.7.3 子类型
- 3.7.4 虚基类
- 3.7.5 虚函数
- 3.7.6 抽象类
- 3.8 模板与泛型
- 3.8.1 概述
- 3.8.2 模板类型
- 3.8.3 *模板参数
- 3.8.4 *模板编译
- 3.8.5 *模板推断
- 3.8.6 *实例化与特例化
- 第4章 C++标准库
- 4.1 概述
- 4.2 输入输出流
- 4.2.1 概述
- 4.2.2 *流的状态
- 4.2.3 *常用流
- 4.2.4 *格式化I/O
- 4.2.5 *低级I/O
- 4.2.6 *随机访问
- 4.3 *C输入输出
- 4.3.1 *字符输入输出
- 4.3.2 *格式化输入输出
- 4.4 * 容器
- 4.4.1 * 概述
- 4.4.2 * 基本操作
- 4.4.3 * 顺序容器
- 4.4.4 * 迭代器
- 4.4.5 * 容器适配器
- 4.5 * 泛型算法
- 4.6 * 内存管理
- 4.6.1 * 自动指针
- 4.7 * 其他设施