[特殊字符]️ STL 容器快速参考手册

🗃️ STL 容器快速参考手册

📌 一、序列式容器 (Sequence Containers)

1. vector (动态数组)

特点：在尾部插入/删除高效，随机访问快

cpp

#include <vector>
std::vector<int> vec;// 增
vec.push_back(10);       // 尾插
vec.emplace_back(20);    // 尾插(高效)
vec.insert(vec.begin() + 1, 30); // 指定位置插入// 删
vec.pop_back();          // 尾删
vec.erase(vec.begin());  // 删除指定位置
vec.clear();             // 清空// 查/访问
int val = vec[0];        // 无检查访问
int val2 = vec.at(1);    // 有检查访问(越界抛异常)
int first = vec.front(); // 第一个元素
int last = vec.back();   // 最后一个元素// 大小
bool empty = vec.empty();// 是否为空
size_t size = vec.size();// 元素个数
vec.resize(10);         // 调整大小

2. deque (双端队列)

特点：头尾插入/删除都高效

cpp

#include <deque>
std::deque<int> dq;// 增
dq.push_back(10);       // 尾插
dq.push_front(20);      // 头插
dq.emplace_back(30);
dq.emplace_front(40);// 删
dq.pop_back();          // 尾删
dq.pop_front();         // 头删// 访问 (同vector)
int val = dq[0];

3. list (双向链表)

特点：任意位置插入/删除快，不支持随机访问

cpp

#include <list>
std::list<int> lst;// 增
lst.push_back(10);
lst.push_front(20);
lst.insert(++lst.begin(), 30); // 在第二个位置插入// 删
lst.pop_back();
lst.pop_front();
lst.erase(lst.begin()); // 删除第一个元素// 特殊操作
lst.sort();             // 排序
lst.unique();           // 去重
lst.reverse();          // 反转

4. forward_list (单向链表)

特点：更节省内存，只能向前遍历

cpp

#include <forward_list>
std::forward_list<int> flst;// 增 (在指定位置后插入)
flst.insert_after(flst.before_begin(), 10);
flst.push_front(20);// 删
flst.erase_after(flst.before_begin()); // 删除第一个元素

5. array (固定数组)

特点：栈上分配，大小固定

cpp

#include <array>
std::array<int, 5> arr = {1, 2, 3, 4, 5}; // 必须指定大小// 访问
arr[0] = 10;
int size = arr.size();  // 固定大小

📌 二、关联式容器 (Associative Containers)

1. set (集合)

特点：元素唯一，自动排序

cpp

#include <set>
std::set<int> s;// 增
s.insert(30);
s.insert({10, 20, 30}); // 插入多个// 删
s.erase(20);            // 删除值为20的元素
s.erase(s.begin());     // 删除第一个元素// 查
auto it = s.find(20);   // 查找，返回迭代器
if (it != s.end()) {// 找到元素
}
bool exists = s.count(20) > 0; // 是否存在

2. multiset (多重集合)

特点：允许重复元素的set

cpp

#include <set>
std::multiset<int> ms;
ms.insert(10);
ms.insert(10); // 允许重复

3. map (映射)

特点：键值对，键唯一，自动按键排序

cpp

#include <map>
std::map<std::string, int> m;// 增/改
m["apple"] = 5;         // 不存在则创建，存在则修改
m.insert({"banana", 3});// 插入
m.emplace("orange", 8); // 原地构造// 删
m.erase("apple");       // 删除键为"apple"的元素// 查
auto it = m.find("banana");
if (it != m.end()) {std::string key = it->first;int value = it->second;
}// 遍历
for (const auto& pair : m) {std::cout << pair.first << ": " << pair.second << std::endl;
}

4. multimap (多重映射)

特点：允许重复键的map

cpp

#include <map>
std::multimap<std::string, int> mm;
mm.insert({"fruit", 5});
mm.insert({"fruit", 8}); // 允许重复键

📌 三、无序容器 (Unordered Containers)

1. unordered_set (哈希集合)

特点：元素唯一，基于哈希表，查找O(1)

cpp

#include <unordered_set>
std::unordered_set<int> us;
us.insert(10);
us.find(10); // 快速查找

2. unordered_map (哈希映射)

特点：键值对，基于哈希表，查找O(1)

cpp

#include <unordered_map>
std::unordered_map<std::string, int> um;
um["apple"] = 5;
auto it = um.find("apple");

3. unordered_multiset / unordered_multimap

特点：允许重复的无序容器

📌 四、容器适配器 (Container Adapters)

1. stack (栈)

特点：LIFO (后进先出)

cpp

#include <stack>
std::stack<int> st;st.push(10);            // 入栈
st.push(20);
int top = st.top();     // 查看栈顶
st.pop();               // 出栈(不返回元素)
bool empty = st.empty();// 是否为空

2. queue (队列)

特点：FIFO (先进先出)

cpp

#include <queue>
std::queue<int> q;q.push(10);             // 入队
q.push(20);
int front = q.front();  // 队首元素
int back = q.back();    // 队尾元素
q.pop();                // 出队

3. priority_queue (优先队列)

特点：元素按优先级出队

cpp

#include <queue>
std::priority_queue<int> pq; // 默认大顶堆pq.push(30);            // 插入
pq.push(10);
pq.push(20);
int top = pq.top();     // 获取最大元素
pq.pop();               // 删除最大元素// 小顶堆
std::priority_queue<int, std::vector<int>, std::greater<int>> min_pq;

📊 容器选择指南

🔄 通用操作 (所有容器都支持)

cpp

// 构造和赋值
Container<T> c1;               // 默认构造
Container<T> c2(c1);           // 拷贝构造
Container<T> c3 = c1;          // 拷贝赋值
Container<T> c4(std::move(c1));// 移动构造// 大小和容量
c.size();                      // 元素数量
c.empty();                     // 是否为空
c.clear();                     // 清空所有元素// 迭代器
auto it_begin = c.begin();     // 开始迭代器
auto it_end = c.end();         // 结束迭代器// C++11 遍历
for (const auto& element : c) {// 处理每个元素
}

这个参考手册覆盖了STL中所有主要容器的基本用法，应该能满足日常开发的大部分需求