## [$]一.容器的常用操作
### 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 * 其他設施