vector | stack | queue | set | map五类基础容器操作汇总

一、动态数组 (Dynamic Array) -> std::vector

• 核心概念：一个智能的、可以自动变长的数组。是 C++ 中最常用的容器。
• 头文件：#include <vector>

核心操作

std::vector<int> v = {10, 20};

// push_back(value): 在末尾添加元素
v.push_back(30); // v 现在是 {10, 20, 30}

// pop_back(): 移除末尾的元素
v.pop_back(); // v 现在是 {10, 20}

// v[index]: 访问元素 (快速但不安全)
int first_val = v[0]; // first_val 是 10

// at(index): 访问元素 (安全，会进行边界检查)
int second_val = v.at(1); // second_val 是 20

// front(): 访问第一个元素
int& front_ref = v.front(); // front_ref 是对 10 的引用
front_ref = 15; // v 现在是 {15, 20}

// back(): 访问最后一个元素
int& back_ref = v.back(); // back_ref 是对 20 的引用
back_ref = 25; // v 现在是 {15, 25}

// size(): 获取大小
size_t count = v.size(); // count 是 2

// empty(): 检查是否为空
bool is_empty = v.empty(); // is_empty 是 false

// clear(): 清空所有元素
v.clear(); // v 现在是 {}

二、栈 (Stack) -> std::stack

• 核心概念：一叠盘子，遵循 后进先出 (LIFO) 原则。它是一个容器适配器。
• 头文件：#include <stack>

核心操作

std::stack<std::string> s;

// push(value): 入栈 (添加元素到顶部)
s.push("apple");  // 栈: ["apple"]
s.push("banana"); // 栈: ["apple", "banana"]

// top(): 访问栈顶元素
std::string top_item = s.top(); // top_item 是 "banana"

// pop(): 出栈 (移除顶部元素，注意：它不返回值)
s.pop(); // 栈: ["apple"]

// size(): 获取大小
size_t count = s.size(); // count 是 1

// empty(): 检查是否为空
bool is_empty = s.empty(); // is_empty 是 false

三、队列 (Queue) -> std::queue

• 核心概念：一个排队的队伍，遵循 先进先出 (FIFO) 原则。它也是一个容器适配器。
• 头文件：#include <queue>

核心操作

std::queue<int> q;

// push(value): 入队 (添加元素到队尾)
q.push(10); // 队列: [10]
q.push(20); // 队列: [10, 20]

// front(): 访问队头元素
int head = q.front(); // head 是 10

// back(): 访问队尾元素
int tail = q.back(); // tail 是 20

// pop(): 出队 (移除队头元素，注意：它不返回值)
q.pop(); // 队列: [20]

// size(): 获取大小
size_t count = q.size(); // count 是 1

// empty(): 检查是否为空
bool is_empty = q.empty(); // is_empty 是 false

四、集合 (Set) -> std::set 和 std::unordered_set

• 核心概念：一个不允许有重复元素的数学集合。主要用于去重和快速查找。
• 区别：set 自动排序；unordered_set 无序但通常更快。
• 头文件：#include <set> 或 #include <unordered_set>

核心操作 (以 unordered_set 为例，用法基本相同)

std::unordered_set<int> s;

// insert(value): 添加元素
s.insert(100);
s.insert(200);
s.insert(100); // 重复插入，无效。s 中依然是 {100, 200}

// erase(value): 删除元素
s.erase(100); // s 中现在是 {200}

// find(value): 查找元素，返回迭代器
auto it = s.find(200);
if (it != s.end()) {
    // 找到了！ *it 的值是 200
    std::cout << "Found: " << *it << std::endl;
}

// count(value): 检查元素是否存在 (返回 0 或 1)
if (s.count(300)) {
    // 不存在
} else {
    std::cout << "300 not in set." << std::endl;
}

// size(): 获取大小
size_t count = s.size(); // count 是 1

// empty(): 检查是否为空
bool is_empty = s.empty(); // is_empty 是 false

// clear(): 清空集合
s.clear(); // s 现在是 {}

五、字典/映射 (Map) -> std::map 和 std::unordered_map

• 核心概念：通过唯一的“键”(key) 快速查找其“值”(value)。
• 区别：map 的键自动排序；unordered_map 的键无序但通常更快。
• 头文件：#include <map> 或 #include <unordered_map>

核心操作 (以 unordered_map 为例，用法基本相同)

std::unordered_map<std::string, int> fruit_prices;

// m[key] = value: 添加或修改元素
fruit_prices["apple"] = 5;
fruit_prices["banana"] = 10;
fruit_prices["apple"] = 6; // "apple" 的值被更新为 6

// erase(key): 根据键删除元素
fruit_prices.erase("banana"); // "banana" 键值对被移除

// find(key): 根据键查找，返回迭代器
auto it = fruit_prices.find("apple");
if (it != fruit_prices.end()) {
    // 找到了！ it->first 是键 "apple", it->second 是值 6
    std::cout << it->first << " costs " << it->second << std::endl;
}

// count(key): 检查键是否存在 (返回 0 或 1)
if (fruit_prices.count("orange")) {
    // 不存在
} else {
    std::cout << "Orange not in map." << std::endl;
}

// size(): 获取键值对的数量
size_t count = fruit_prices.size(); // count 是 1

// empty(): 检查是否为空
bool is_empty = fruit_prices.empty(); // is_empty 是 false

// clear(): 清空
fruit_prices.clear(); // map 现在是空的