### C++ STL 使用例子大全：容器部分详解
#### Vector
**Vector** 是 C++ 标准模板库（STL）中的一个动态数组容器。它能够根据需要自动调整大小，并提供了许多方便的操作方法。
##### 构造函数
Vector 提供了多种构造函数来创建不同类型的向量：
1. **空向量构造**：
```cpp
vector<int> v1;
```
创建了一个空的 `vector` 对象 `v1`。
2. **指定长度的构造**：
```cpp
vector<int> v2(10);
```
创建了一个包含 10 个元素的 `vector`，这些元素的初始值未定义。
3. **指定长度及初值的构造**：
```cpp
vector<int> v3(10, 0);
```
创建了一个包含 10 个元素的 `vector`，所有元素的初始值均为 0。
4. **区间构造**：
```cpp
vector<string> v4(str + 0, str + 3);
```
从字符串数组 `str` 的前三个元素构造 `vector`。
5. **拷贝构造**：
```cpp
vector<string> v5(v4);
```
通过已存在的 `vector` 对象 `v4` 来初始化新的 `vector` 对象 `v5`。
6. **迭代器构造**：
```cpp
vector<int>::iterator sIt = v4.begin();
while (sIt != v4.end())
cout << *sIt++ << " ";
```
使用迭代器遍历 `vector` 并打印其中的每个元素。
7. **赋值操作**：
```cpp
int ary[] = {1, 2, 3, 4, 5};
vector<int> v;
// 将数组 `ary` 的内容赋给 `vector` v
v.assign(ary, ary + 5);
```
该示例演示了如何使用 `assign` 方法将数组中的元素赋给 `vector`。
8. **替换操作**：
```cpp
v.assign(3, 100);
```
使用 `assign` 方法将 `vector` 的内容替换为 3 个 100。
9. **访问操作**：
```cpp
vector<int> v(3, 0);
v[0] = 100;
v.at(1) = 200;
```
该示例展示了如何使用下标和 `at` 方法访问 `vector` 中的元素。注意 `at` 方法会在索引超出范围时抛出异常。
10. **获取最后一个元素**：
```cpp
int last_element = v.back();
```
使用 `back` 方法获取 `vector` 最后一个元素的值。
#### Deque
**Deque**（双端队列）与 **Vector** 类似，但支持在两端进行快速插入和删除操作。
##### 构造函数
1. **空 deque 构造**：
```cpp
deque<int> dq1;
```
2. **指定长度的构造**：
```cpp
deque<int> dq2(10);
```
3. **指定长度及初值的构造**：
```cpp
deque<int> dq3(10, 0);
```
4. **区间构造**：
```cpp
deque<int> dq4(ary, ary + 5);
```
5. **拷贝构造**：
```cpp
deque<int> dq5(dq4);
```
6. **赋值操作**：
```cpp
dq4.assign(ary, ary + 5);
```
7. **替换操作**：
```cpp
dq4.assign(3, 100);
```
8. **访问操作**：
```cpp
dq4[0] = 100;
dq4.at(1) = 200;
```
9. **获取最后一个元素**：
```cpp
int last_element = dq4.back();
```
10. **获取第一个元素**：
```cpp
int first_element = dq4.front();
```
#### List
**List** 实现为双向链表，适用于频繁插入和删除操作。
##### 构造函数
1. **空 list 构造**：
```cpp
list<int> lst1;
```
2. **指定长度的构造**：
```cpp
list<int> lst2(10);
```
3. **指定长度及初值的构造**：
```cpp
list<int> lst3(10, 0);
```
4. **区间构造**：
```cpp
list<int> lst4(ary, ary + 5);
```
5. **拷贝构造**：
```cpp
list<int> lst5(lst4);
```
6. **赋值操作**：
```cpp
lst4.assign(ary, ary + 5);
```
7. **替换操作**：
```cpp
lst4.assign(3, 100);
```
8. **访问操作**：
```cpp
lst4.front() = 100;
lst4.back() = 200;
```
9. **获取最后一个元素**：
```cpp
int last_element = lst4.back();
```
10. **获取第一个元素**：
```cpp
int first_element = lst4.front();
```
#### Set 和 Multiset
**Set** 和 **Multiset** 提供基于排序树的集合数据结构，允许用户高效地搜索、插入和删除元素。
##### 构造函数
1. **空 set 构造**：
```cpp
set<int> st1;
```
2. **拷贝构造**：
```cpp
set<int> st2(st1);
```
3. **插入操作**：
```cpp
st1.insert(10);
```
4. **查找操作**：
```cpp
auto it = st1.find(10);
if (it != st1.end()) {
// 元素存在
}
```
5. **删除操作**：
```cpp
st1.erase(10);
```
6. **获取最小元素**：
```cpp
int min_element = *st1.begin();
```
7. **获取最大元素**：
```cpp
int max_element = *st1.rbegin();
```
#### Map 和 Multimap
**Map** 和 **Multimap** 提供基于排序树的键值对数据结构。
##### 构造函数
1. **空 map 构造**：
```cpp
map<int, string> mp1;
```
2. **拷贝构造**：
```cpp
map<int, string> mp2(mp1);
```
3. **插入操作**：
```cpp
mp1.insert({10, "hello"});
```
4. **查找操作**：
```cpp
auto it = mp1.find(10);
if (it != mp1.end()) {
// 键存在
}
```
5. **删除操作**：
```cpp
mp1.erase(10);
```
6. **访问操作**：
```cpp
string value = mp1[10];
```
7. **获取最小键对应的值**：
```cpp
pair<int, string> min_pair = *mp1.begin();
```
8. **获取最大键对应的值**：
```cpp
pair<int, string> max_pair = *mp1.rbegin();
```
#### Stack, Queue 和 Priority_queue
**Stack**, **Queue** 和 **Priority_queue** 提供了基于容器的抽象数据类型，用于实现栈、队列和优先级队列。
##### Stack
1. **构造函数**：
```cpp
stack<int> st;
```
2. **压栈操作**：
```cpp
st.push(10);
```
3. **弹栈操作**：
```cpp
st.pop();
```
4. **获取栈顶元素**：
```cpp
int top = st.top();
```
5. **判断栈是否为空**：
```cpp
if (st.empty()) {
// 栈为空
}
```
##### Queue
1. **构造函数**：
```cpp
queue<int> q;
```
2. **入队操作**：
```cpp
q.push(10);
```
3. **出队操作**：
```cpp
q.pop();
```
4. **获取队首元素**：
```cpp
int front = q.front();
```
5. **获取队尾元素**：
```cpp
int back = q.back();
```
6. **判断队列是否为空**：
```cpp
if (q.empty()) {
// 队列为空
}
```
##### Priority_queue
1. **构造函数**：
```cpp
priority_queue<int> pq;
```
2. **压队操作**：
```cpp
pq.push(10);
```
3. **弹队操作**：
```cpp
pq.pop();
```
4. **获取队首元素**：
```cpp
int top = pq.top();
```
5. **判断队列是否为空**：
```cpp
if (pq.empty()) {
// 队列为空
}
```
### 总结
本篇文章通过多个示例介绍了 C++ 标准模板库（STL）中容器的基本用法，包括 `vector`, `deque`, `list`, `set`, `multiset`, `map`, `multimap`, `stack`, `queue`, 和 `priority_queue` 的基本操作。掌握这些容器对于编写高效、可维护的 C++ 程序至关重要。希望这些示例能帮助读者更好地理解和应用 C++ STL 中的各种容器。
