## [$]一.容器的常用操作
### 1.成员类型
| 类型 | 含义 |
| ------------------------------ | -------------------------------------------- |
| `C<T>::iterator` | 迭代器类型。 |
| `C<T>::const_iterator` | 常迭代器类型。不可修改容器内元素。 |
| `C<T>::reverse_iterator` | 反向迭代器。 |
| `C<T>::const_reverse_iterator` | 常反向迭代器。不可修改容器内元素。 |
| `C<T>::size_type` | 无符号整数类型的别名。 |
| `C<T>::different_type` | 无符号整数类型的别名，两个迭代器之间的距离。 |
| `C<T>::value_type` | `T` 的别名，元素类型。 |
| `C<T>::reference` | `T&` 的别名，元素的引用。 |
| `C<T>::const_reference` | `const T&` 的别名，元素的常引用。 |
### 2.构造
+ 只有同类型的容器可以拷贝初始化。
+ 只有除 `array` 以外顺序容器才可以在构造函数中指定容器大小。
针对非 `array`的构造操作：
| 函数 | 不适用容器 | 含义 |
| ---------------------------------------- | ----------------- | ----------------------------------------------------------- |
| `C<T> c;` | `array` | 构造一个空容器。 |
| `C<T> c(const C<T> &c2);` | `array` | 将 `c2` 拷贝到 `c`。 |
| `C<T> c = c2;` | `array` | 将 `c2` 拷贝到 `c`。 |
| `C<T> c(size_type size);` | `array`和关联容器 | 定义初始大小为 `size` 的容器。 |
| `C<T> c(size_type size,const T &value);` | `array`和关联容器 | 定义初始大小为 `size` 的容器，并使用 `value` 填充所有元素。 |
| `C<T> c(b,e);` | `array` | 将迭代器 `b` 和 `e` 指定范围内的元素拷贝到 `c`。 |
| [11+]`C<T> c{a,b,c,...}` | `array` | 列表初始化 `c`。 |
| [11+]`C<T> c = {a,b,c,...}` | `array` | 列表初始化 `c`。 |
针对 `array`的构造操作，模板实参中需要添加额外的参数指明数组大小：
| 函数 | 适用容器 | 含义 |
| ----------------------------------- | -------- | ------------------------------------------------ |
| `C<T,Size> c;` | `array` | 构造一个空容器。 |
| `C<T,Size> c(const C<T,Size> &c2);` | `array` | 将 `c2` 拷贝到 `c`。 |
| `C<T,Size> c = c2;` | `array` | 将 `c2` 拷贝到 `c`。 |
| `C<T,Size> c(b,e);` | `array` | 将迭代器 `b` 和 `e` 指定范围内的元素拷贝到 `c`。 |
| [11+]`C<T,Size> c{a,b,c,...}` | `array` | 列表初始化 `c`。 |
| [11+]`C<T,Size> c = {a,b,c,...}` | `array` | 列表初始化 `c`。 |
### 3.赋值操作
+ 只有同类型的容器可以赋值和交换。
+ 赋值操作可能导致赋值号左边容器的迭代器失效。
+ 除了 `array`和 `string`，交换操作对迭代器没有影响。
+ 除了 `array`和 `string`，交换操作不会进行任何的拷贝、删除、插入操作。
| 函数 | 不适用容器 | 含义 |
| ------------------------ | ----------------- | ------------------------------------------------------------ |
| `c1=c2;` | 无 | 容器赋值。 |
| `c1={a,b,c,...};` | `array` | 用列表中的元素替换 `c1` 中的元素。 |
| `void c1.swap(c2);` | 无 | `c1` 与 `c2` 交换。 |
| [11+]`void swap(c1,c2);` | 无 | `c1` 与 `c2` 交换。 |
| `c.assign(b,e);` | 关联容器 | 将 `c` 中的元素替换为迭代器 `b` 和 `e` 所表示的范围中的元素。迭代器 `b` 和 `e` 不能指向 `c` 中的元素，因为旧元素会被替换。 |
| `c.assign({a,b,c,...});` | `array`和关联容器 | 用初始化列表中的元素替换 `c` 中的元素。 |
| `c.assign(n,t);` | 关联容器 | 将 `c` 中的元素替换为 `n` 个 `t` 表示的元素。 |
### 4.大小
| 函数 | 不适用容器 | 含义 |
| ------------------------- | -------------- | ------------------------------------------------------------ |
| `size_type c.size();` | `forward_list` | 容器的元素数。 |
| `size_type c.max_size();` | 无 | 容器的最大的元素数。（它的大小与 **系统和库实现** 有关，与自身的长度无关） |
| `bool c.empty();` | 无 | 容器是否为空。 |
### 5.增删
由于不同的容器操作接口不同，这里只列函数名，未列出参数和返回值。
| 函数 | 不适用容器 | 含义 |
| -------------- | ---------- | ---------------- |
| `c.insert();` | `array` | 容器插值。 |
| `c.emplace();` | `array` | 原位插值。 |
| `c.erase();` | `array` | 删除指定的元素。 |
| `c.clear();` | `array` | 清空元素。 |
### 6.比较
可以使用关系运算符对容器进行比较。
1. **条件**
+ 同种类型的容器
+ 由于容器的比较需要对元素使用关系运算符，因此需要保证可以使用关系运算符对元素进行比较。
2. **策略**
+ 如果两个容器具有相同大小且所有元素都两两对应相等，则这两个容器相等;否则两个容器不等。
+ 如果两个容器大小不同，但较小容器中每个元素都等于较大容器中的对应元素，则较小容器小于较大容器。
+ 如果两个容器都不是另一个容器的前缀子序列，则它们的比较结果取决于第一个不相等的元素的比较结果。
### 7.获取迭代器
| 函数 | 不适用容器 | 含义 |
| --------------------------------------- | ---------- | ---------------------------------------------------- |
| `C<T>::iterator c.begin();` | 无 | 返回第一个元素的迭代器。 |
| `C<T>::iterator c.end();` | 无 | 返回最后一个元素的下一个元素的迭代器。 |
| `C<T>::const_iterator c.begin() const;` | 无 | 容器是常量，返回第一个元素的常迭代器。 |
| `C<T>::const_iterator c.end() const;` | 无 | 容器是常量，返回最后一个元素的下一个元素的常迭代器。 |
| [11+]`C<T>::const_iterator c.cbegin();` | 无 | 返回第一个元素的常迭代器。 |
| [11+]`C<T>::const_iterator c.cend();` | 无 | 返回最后一个元素的下一个元素的常迭代器。 |
### 8.获取反向迭代器
| 函数 | 不适用容器 | 含义 |
| ------------------------------------------------ | -------------- | ------------------------------------------------------ |
| `C<T>::reverse_iterator c.rbegin();` | `forward_list` | 返回第一个元素的前一个元素的反向迭代器。 |
| `C<T>::reverse_iterator c.rend();` | `forward_list` | 返回最后一个元素的反向迭代器。 |
| `C<T>::const_reverse_iterator c.rbegin() const;` | `forward_list` | 容器是常量，返回第一个元素的前一个元素的常反向迭代器。 |
| `C<T>::const_reverse_iterator c.rend() const;` | `forward_list` | 容器是常量，返回最后一个元素的常反向迭代器。 |
| [11+]`C<T>::const_reverse_iterator c.crbegin();` | `forward_list` | 返回第一个元素的前一个元素的常反向迭代器。 |
| [11+]`C<T>::const_reverse_iterator c.crend();` | `forward_list` | 返回最后一个元素的常反向迭代器。 |
- 阅读说明
- 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 * 其他设施