【C++】STL小总结

大致分类

类别	特点	代表容器
顺序容器（Sequence Containers）	按插入顺序存储元素	vector, deque, list, array, forward_list
关联容器（Associative Containers）	根据键自动排序	set, map, multiset, multimap
无序关联容器（Unordered Associative Containers）	哈希表实现，查找快	unordered_set, unordered_map, unordered_multiset, unordered_multimap
容器适配器（Container Adapters）	封装其他容器提供特定接口	stack, queue, priority_queue

如何选择

场景	推荐容器
需要动态数组、随机访问	vector
两端操作频繁	deque
中间插入删除频繁	list
键值映射（自动排序）	map
键值映射（高速查找）	unordered_map
唯一集合	set / unordered_set
允许重复元素	multiset / unordered_multiset
堆或优先级队列	priority_queue
栈操作	stack
队列操作	queue

vector

动态数组容器，自动管理内存大小，在元素增删时自动扩展或收缩容量。

构造函数

函数	说明	示例
vector<T> v;	默认构造一个空 vector	vector<int> v;
vector<T> v(n);	构造一个大小为 n 的 vector，元素默认值初始化	vector<int> v(5);
vector<T> v(n, value);	构造一个大小为 n 的 vector，所有元素为 value	vector<int> v(5, 10);
vector<T> v(begin, end);	用迭代器范围构造	vector<int> v(a, a+5);
vector<T> v2(v1);	拷贝构造	vector<int> v2(v1);

容量与大小函数

函数	返回类型	说明
size()	size_t	返回当前元素数量
capacity()	size_t	返回当前容量（不一定等于 size）
empty()	bool	判断是否为空
resize(n)	void	调整大小，扩大会初始化新元素
reserve(n)	void	预留容量，避免频繁扩容

元素访问

函数	说明
operator[]	不检查越界，直接访问
at(i)	检查越界的安全访问方式
front()	返回首元素引用
back()	返回尾元素引用

增删改查

函数	说明
push_back(x)	尾部插入元素
pop_back()	删除尾部元素
insert(pos, x)	在指定位置插入
erase(pos)	删除指定位置元素
erase(first, last)	删除区间元素
clear()	清空所有元素
assign(n, value)	重新赋值
emplace(pos, args...)	原地构造插入（C++11）
emplace_back(args...)	原地构造尾插（C++11）
swap(v2)	与另一 vector 交换内容

迭代器

函数	返回类型	说明
begin() / end()	迭代器	范围 [begin, end)
rbegin() / rend()	反向迭代器	反向遍历
cbegin() / cend()	常量迭代器
crbegin() / crend()	常量反向迭代器

示例

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;int main() {int array[5] = {1,2,3,4,5};vector<int> v(array, array + 5);vector<int> v2(5,0);// 容量cout<< v.size()<<endl;cout<< v2.capacity() << endl;cout<< v.at(0) << endl;// 增删改v.push_back(7);v.pop_back();v.insert(v.begin() + 1, 42);v.erase(v.begin() + 2);// v.clear();// 迭代器for (auto it = v.begin(); it != v.end(); ++it)cout << *it << " " ;cout << endl;for (auto it = v.rbegin(); it != v.rend(); ++it)cout << *it << " ";// 常用算法sort(v.begin(), v.end());reverse(v.begin(), v.end());find(v.begin(), v.end(), 5);
}

map

有序关联容器，通过平衡二叉搜索树实现

初始化

#include <map>
using namespace std;// 声明
map<int, string> m; // 默认升序（less<int>）// 初始化
map<int, string> m1 = { {1, "one"}, {2, "two"} };// 拷贝构造
map<int, string> m2(m1);// 使用比较函数
map<int, string, greater<int>> m3; // 降序

查找与访问

函数	说明
find(key)	返回指向键的迭代器，不存在则返回 end()
count(key)	返回键出现次数（map 中为 0 或 1）
at(key)	安全访问（若不存在会抛异常）
operator[]	若键不存在，会自动插入默认值

增删改查

函数	说明	示例
insert({key, value})	插入键值对（若键已存在则无效）	m.insert({1, "A"});
emplace(key, value)	原地构造插入，更高效（C++11）	m.emplace(2, "B");
operator[]	访问或插入键（不存在则默认构造 value）	m[3] = "C";

函数	说明
erase(it)	删除指定迭代器
erase(key)	删除指定键
erase(first, last)	删除指定范围
clear()	清空 map

容量与大小

函数	返回类型	说明
size()	size_t	返回元素数量
empty()	bool	判断是否为空
max_size()	size_t	返回可容纳最大元素数

迭代器

函数	说明
begin() / end()	正向迭代器
rbegin() / rend()	反向迭代器
cbegin() / cend()	常量迭代器（只读）

unordered_map

无序关联容器，快速查找，删除，不在意排序

特性	map	unordered_map
底层结构	红黑树（有序）	哈希表（无序）
查找/插入复杂度	O(log n)	平均 O(1)，最坏 O(n)
键是否有序	✅ 有序（默认升序）	❌ 无序（由哈希决定）
可自定义比较规则	✅ Compare	❌ 使用哈希函数
迭代遍历顺序	固定（按键排序）	不确定，每次运行可能不同

初始化

#include <unordered_map>
using namespace std;unordered_map<int, string> um;  // 空哈希表
unordered_map<int, string> um2 = { {1,"A"}, {2,"B"} };

增删改查

分类	map	unordered_map
插入	insert(), emplace(), operator[]	同上
查找	find(), count(), at()	同上
删除	erase()	同上
清空	clear()	同上
大小	size(), empty()	同上
遍历	迭代器按键顺序	迭代器无序
其它	lower_bound, upper_bound	❌ 不支持（因为无序）
额外接口	❌	✅ bucket_count(), load_factor(), rehash() 等哈希相关函数

set

自动排序、元素唯一，不可修改，查找效率高

初始化

set<int> s1;                  // 空 set
set<int> s2 = {3, 1, 4, 2};   // 初始化列表
set<int> s3(s2);              // 拷贝构造
set<int, greater<int>> s4;    // 自定义比较器（降序）

增删改查

函数	说明
insert(value)	插入元素（若已存在则无效）
emplace(value)	原地构造插入（比 insert 更高效，C++11）
insert(hint, value)	给出插入位置提示（加速）

函数	说明
erase(value)	删除指定值
erase(iterator)	删除指定迭代器位置元素
erase(first, last)	删除范围内元素
clear()	清空所有元素

函数	返回值	说明
find(value)	迭代器	返回指向该值的迭代器，不存在则返回 end()
count(value)	size_t	返回指定值出现次数（set 中为 0 或 1）
lower_bound(value)	迭代器	返回第一个 ≥ value 的元素
upper_bound(value)	迭代器	返回第一个 > value 的元素
equal_range(value)	pair<iterator, iterator>	同时返回上下界范围

大小与状态

函数	返回类型	说明
size()	size_t	元素个数
empty()	bool	是否为空
max_size()	size_t	最大可容纳数量

deque

双端队列

初始化

deque<int> d1;                      // 空 deque
deque<int> d2 = {1, 2, 3};          // 初始化列表
deque<int> d3(5, 10);               // 5 个元素，每个为 10
deque<int> d4(d2);                  // 拷贝构造
deque<int> d5(d2.begin(), d2.end()); // 迭代器构造

增删改查

函数	说明
push_back(val)	在尾部插入
push_front(val)	在头部插入
pop_back()	删除尾部元素
pop_front()	删除头部元素
insert(pos, val)	在指定位置插入
erase(pos)	删除指定位置
erase(first, last)	删除区间
clear()	清空所有元素

priority_queue

优先队列，堆结构，默认是一个最大堆

初始化

priority_queue<int> pq;  // 默认：最大堆
priority_queue<int, vector<int>, greater<int>> min_pq; // 最小堆

增删改查

函数	说明
push(x)	插入元素
emplace(args...)	原地构造元素（C++11）
pop()	删除堆顶元素
top()	访问堆顶（最大或最小）元素
empty()	判断是否为空
size()	元素个数

自定义排序

#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;struct Node {int a;int b;int d;
};// 升序：先按 a，再按 b，最后按 d
bool cmpAsc(const Node& x, const Node& y) {if (x.a != y.a) return x.a < y.a;if (x.b != y.b) return x.b < y.b;return x.d < y.d;
}int main() {vector<Node> v = {{1,2,3}, {1,1,9}, {0,5,6}, {1,1,2}};sort(v.begin(), v.end(), cmpAsc);for (auto& t : v)cout << t.a << ' ' << t.b << ' ' << t.d << '\n';
}

lambda

sort(v.begin(), v.end(),[](const Node& x, const Node& y){if (x.a != y.a) return x.a < y.a;if (x.b != y.b) return x.b < y.b;return x.d < y.d;});