C++ - 分类 - 豆浆小屋

C++ 学习与面试资料导航

Fri, 09 Oct 2026 00:00:00 +0000

这份导航收集了一批公开可访问的 C++ 学习资料。它们各有侧重：有的适合建立知识地图，有的适合按题复习，有的则能直接跟着源码理解工程实现。

如果刚开始整理知识体系，建议先选一个综合站点作为主线，再用题库查漏补缺。项目源码更适合在掌握基础语法、CMake 和调试工具后动手。

1 一、系统知识库：用来建立主线

1.1 编程指北：C++ 面试题库

覆盖 C++ 基础、面向对象、内存管理和现代 C++ 等模块。分类清楚，适合先快速浏览目录，建立“还需要学什么”的整体地图。

1.2 huihut：C/C++ 技术面试知识库

除了 C/C++，还包含 STL、数据结构、操作系统、网络与链接装载等内容。适合把语言知识和计算机基础串起来。

对应的 GitHub 开源仓库

1.3 卡码笔记：面试知识库

覆盖语言、操作系统、网络和并发等常见方向，适合按模块复习，并顺着题目继续追问底层机制。

1.4 小林 coding：C++ 面试题

以问题为入口，配有较多图解。遇到内存管理、STL 或语言特性等问题时，可以用来辅助理解。

2 二、逐题练习：用来查漏补缺

2.1 面试鸭：C++ 基础面试题库

适合快速检查基础题覆盖情况。使用时不要只背结论，可以继续追问：为什么这样设计、底层如何实现、边界在哪里。

2.2 拾光小舟：C++ 基础面试集

按“回答重点”和扩展内容组织，适合把零散知识整理成能在面试中表达的答案。

2.3 程序厨：C++ 面试题库

题目覆盖面较广，可以当作复习清单使用。遇到没有完整展开的题目，再回到系统知识库补原理。

2.4 guaguaupup：C++ 后台开发面经

内容覆盖 C++、Linux、操作系统、网络、数据库和设计模式等方向，适合准备后端岗位时补齐关联知识。

3 三、作者公开资料：用来交叉验证

下面几处资料来自同一作者或同一资料体系，适合互相对照，不必重复通读。

部分入口可能要求登录。公开仓库与网站内容可以作为补充，但不代表其他配套内容也全部开放。

4 四、开源项目：从“会答”走到“会做”

4.1 BuriedPoint：埋点上报 SDK

仓库包含库实现、服务端、示例、测试和 CMake 配置，适合观察一个小型 C++ SDK 如何组织。阅读时可以沿着“初始化 → 启动 → 上报 → 持久化或发送”的调用链推进。

几个值得优先看的入口：

这个项目偏向 Windows/MSVC 环境。阅读源码时，可以重点检查对象生命周期、线程安全、失败重试，以及接口被错误调用时的边界处理。

5 五、推荐使用顺序

从“编程指北”或“huihut”选一个作为主线，先搭知识地图。
用面试鸭、拾光小舟和程序厨检查遗漏，但不要同时刷多个重复题库。
每遇到一道高频题，整理成“结论 → 机制 → 边界与取舍”三层回答。
最后选一个小项目跟调用链、编译运行，再脱离源码重写最小版本。

资料会变化或失效；如果某个入口打不开，可以优先检查它对应的 GitHub 仓库或站点首页。

C 字符串与内存操作函数速查

Fri, 17 Jul 2026 00:00:00 +0000

1 字符串/内存操作函数速查

函数	参数说明	作用
`strlen(str)`	`str` — 目标字符串	计算字符串长度，不包含 `'\0'`
`memmove(dst, src, n)`	`dst` — 目标地址（destination） `src` — 源地址（source） `n` — 要移动的字节数	移动 `n` 字节，允许内存区域重叠
`memcpy(dst, src, n)`	`dst` — 目标地址（destination） `src` — 源地址（source） `n` — 要复制的字节数	复制 `n` 字节，不允许内存区域重叠（重叠时行为未定义）
`memset(dst, value, n)`	`dst` — 目标地址（destination） `value` — 要填充的值（转为 unsigned char） `n` — 要填充的字节数	将一段内存的每个字节填充为指定值
`strcpy(dst, src)`	`dst` — 目标缓冲区（destination） `src` — 源字符串（source）	复制 C 风格字符串，包括结尾的 `'\0'`
`strcmp(a, b)`	`a` — 字符串 A `b` — 字符串 B	比较两个 C 风格字符串，相等返回 0
`strchr(str, ch)`	`str` — 被搜索的字符串 `ch` — 要查找的字符	在字符串中查找字符，返回首次出现的位置指针
`strstr(str, sub)`	`str` — 被搜索的字符串（haystack） `sub` — 要查找的子串（needle）	在字符串中查找子串，返回首次出现的位置指针

⚠️ 注意： memmove 和 memcpy 的区别——当 src 和 dst 的内存区域有重叠时，必须用 memmove，因为它会先拷贝到临时缓冲区再写入，保证正确性；memcpy 不处理重叠情况，可能导致数据损坏。

函数名	全称拆分	英文原意
strlen	str = string；len = length	string length 字符串长度
memmove	mem = memory；move	memory move 内存移动
memcpy	mem = memory；cpy = copy	memory copy 内存复制
memset	mem = memory；set	memory set 内存填充
strcpy	str = string；cpy = copy	string copy 字符串复制
strcmp	str = string；cmp = compare	string compare 字符串比较
strchr	str = string；chr = character	string character 在字符串查找字符
strstr	str = string；第二个 str = substring	string substring 在字符串查找子串

2 补充规律（方便记忆）

str 开头 → 只处理「C 风格字符串」，依赖 \0 结束标记；
mem 开头 → 纯粹操作内存块，不识别字符串结束符，按字节数量处理；
通用缩写约定：
- cpy = copy
- cmp = compare
- chr = character
- len = length
- sub = substring

C++ vector 深度解析

Fri, 17 Jul 2026 00:00:00 +0000

1 一、底层原理

vector 是动态数组，底层是一段连续的内存空间。

1
2
3
4


┌───┬───┬───┬───┬───┬───┬───┬───┐
│ 0 │ 1 │ 2 │ 3 │   │   │   │   │
└───┴───┴───┴───┴───┴───┴───┴───┘
  size = 4          capacity = 8

size：当前元素个数
capacity：实际分配的内存容量
当 size == capacity 时再插入，会触发扩容

2 二、扩容机制

2.1 扩容过程

重新分配一块更大的内存（通常 1.5 倍或 2 倍）
把旧元素全部拷贝/移动到新内存
释放旧内存
更新内部指针

GCC 是 2 倍扩容，VS 是 1.5 倍扩容。

2.2 时间复杂度

均摊 O(1)：大部分插入是 O(1)，偶尔扩容 O(n)，平均下来还是 O(1)

2.3 避免扩容的方法

1
2


vector<int> v;
v.reserve(1000);  // 提前分配 1000 容量，避免中途扩容

3 三、迭代器失效

3.1 什么情况会失效？

1. 插入操作（push_back, insert）

触发扩容 → 所有迭代器、引用、指针全部失效
没扩容 → 插入位置之后的迭代器失效

2. 删除操作（erase, pop_back）

删除位置及之后的迭代器失效
end() 永远失效

3. swap / clear

swap：两个 vector 的迭代器互换
clear：所有迭代器失效，但 capacity 不变

3.2 经典坑：erase 遍历

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// ❌ 错误写法：it 失效后 ++ 是未定义行为
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it == target) v.erase(it);
}

// ✅ 正确写法：erase 返回下一个有效迭代器
for (auto it = v.begin(); it != v.end(); ) {
    if (*it == target) {
        it = v.erase(it);
    } else {
        ++it;
    }
}

4 四、常用操作

4.1 构造函数

1
2
3
4
5


vector<int> v1;                // 空
vector<int> v2(10);            // 10 个元素，默认 0
vector<int> v3(10, 5);         // 10 个 5
vector<int> v4{1, 2, 3, 4};    // 列表初始化
vector<int> v5(v4.begin(), v4.end());  // 迭代器范围

4.2 卡点：构造时填了初值，push_back 从哪开始

我的疑问：vector v(5, 0) 之后再 push_back，新元素是不是插不进"前面"？

是的——v(n, 0) 是"先定长填 n 个 0"，size 已经是 n；之后 push_back 永远追加在末尾（下标 n 开始），不会从头插：
1
2
3
4
5
vector<int> v(5, 0);   // {0,0,0,0,0}，size = 5
v.push_back(7);        // {0,0,0,0,0,7}，7 在下标 5（第 6 位）

vector<int> w;         // 空，size = 0
w.push_back(7);        // {7}，7 在下标 0（第 1 位）

两种思路二选一，别混：

目的	正确写法
动态追加（数量不定）	初始化为空 `vector v;`，只 push_back
固定长度按下标填	`vector v(n, 0);` 然后 `v[i] = x;`（下标改，不是 push_back）

常见坑：先 v(n, 0) 又 push_back → 得到 n+1 个元素、前 n 个全是 0，数据全挤到后面；v[i] = x 越界是未定义行为（不会自动扩容，可能直接崩）。

4.3 增删改查

1
2
3
4
5
6


v.push_back(10);     // 尾部插入 O(1) 均摊
v.pop_back();        // 尾部删除 O(1)
v.insert(it, 20);    // 指定位置插入 O(n)
v.erase(it);         // 删除指定位置 O(n)
v.clear();           // 清空所有元素，capacity 不变
v.shrink_to_fit();   // 释放多余空间，capacity = size

4.4 访问

1
2
3
4
5


v[0];          // 下标访问，不检查越界
v.at(0);       // 带越界检查，越界抛 out_of_range
v.front();     // 第一个元素
v.back();      // 最后一个元素
v.data();      // 底层数组指针

4.5 大小相关

1
2
3
4
5


v.size();       // 元素个数
v.capacity();   // 容量
v.empty();      // 是否为空
v.reserve(n);   // 预留容量
v.resize(n);    // 改变 size，多删少补

5 五、内存管理细节

5.1 clear() 不释放内存

1
2


vector<int> v(1000);
v.clear();          // size = 0，但 capacity 还是 1000

5.2 真正释放内存的方法

1
2
3
4
5
6


// 方法1：swap 空 vector
vector<int>().swap(v);

// 方法2：shrink_to_fit（C++11）
v.clear();
v.shrink_to_fit();

5.3 用 reserve 优化性能

知道大概要存多少元素时，提前 reserve：

1
2
3
4
5


vector<int> v;
v.reserve(10000);  // 一次分配到位
for (int i = 0; i < 10000; i++) {
    v.push_back(i);  // 不会触发扩容
}

6 六、常见坑点总结

坑点	说明
迭代器失效	插入删除后旧迭代器不能再用
引用失效	扩容后所有引用都悬空
`[]` 越界	不检查，越界是 UB，用 `at()` 更安全
resize vs reserve	resize 改 size，reserve 只改 capacity
空 vector 调用 front/back	UB，先判断 empty
vector	不是真正的 vector，是位压缩的特殊实现，尽量别用

7 七、性能对比

操作	时间复杂度
随机访问	O(1)
尾插 push_back	O(1) 均摊
尾删 pop_back	O(1)
中间插入	O(n)
中间删除	O(n)
扩容	O(n)

💡 能用 vector 就用 vector，连续内存缓存友好，是最快的序列容器。

C++14 新特性

Fri, 17 Jul 2026 00:00:00 +0000

C++14 是 C++11 的小版本更新，主要是完善和补充，核心特性不多但很实用。

1 一、函数返回值类型推导

C++11 只有 lambda 可以用 auto 推导返回值，C++14 扩展到所有函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// C++14：自动推导返回 int
auto add(int a, int b) {
    return a + b;
}

// 多个 return 必须类型一致
auto f(bool flag) {
    if (flag) return 1;    // int
    else return 2;         // OK，都是 int
    // return 3.14;        // ERROR，类型不一致
}

注意：

递归函数不能用 auto 返回值推导（除非先有前置声明）
有多个 return 语句时，所有 return 的类型必须相同

2 二、泛型 lambda（Generic Lambda）

C++11 的 lambda 参数必须写具体类型，C++14 可以用 auto：

1
2
3
4
5
6
7
8


// C++14：参数用 auto，相当于模板函数
auto add = [](auto a, auto b) {
    return a + b;
};

add(1, 2);       // int
add(1.5, 2.3);   // double
add(string("a"), string("b"));  // string

本质： 编译器自动生成一个模板函数对象。

3 三、变量模板（Variable Templates）

之前只有类模板、函数模板，C++14 新增变量模板：

1
2
3
4
5
6
7


// 定义一个 pi 变量模板
template<typename T>
constexpr T pi = T(3.1415926535897932385);

// 使用
float  r1 = pi<float>;
double r2 = pi<double>;

最经典的应用：std::is_same_v 就是 C++17 基于变量模板做的。

4 四、聚合初始化增强

C++14 允许聚合体中含有默认成员初始化器时，仍然可以用花括号初始化：

1
2
3
4
5
6
7


struct Point {
    int x = 0;
    int y = 0;
};

Point p1{1, 2};  // C++11 不允许，C++14 可以
Point p2{};      // x=0, y=0，用默认值

5 五、`decltype(auto)`

解决转发函数的返回值问题：

1
2
3
4
5


// 用 auto 会丢失引用
auto f1() -> decltype(expr) { return expr; }  // C++11 写法

// C++14 简化写法
decltype(auto) f2() { return expr; }

区别：

auto：会去掉引用和顶层 const
decltype(auto)：完美保留表达式的原始类型

1
2
3
4
5


int x = 42;
int& ref = x;

auto a = ref;            // int
decltype(auto) b = ref;  // int&

6 六、标准库新增

6.1 6.1 `std::make_unique`

C++11 有 make_shared 但漏掉了 make_unique，C++14 补上：

1

auto p = std::make_unique<int>(42);  // 推荐，比 new 安全

6.2 6.2 `std::shared_timed_mutex`

读写锁的超时版本，C++17 又加了 shared_mutex。

6.3 6.3 整数序列 `std::integer_sequence`

模板元编程工具，用于展开参数包：

1
2


template<typename T, T... Is>
struct integer_sequence { ... };

日常开发用得少，库作者用得多。

6.4 6.4 `std::exchange`

赋值并返回旧值：

1
2
3


std::vector<int> v{1, 2, 3};
auto old = std::exchange(v, {4, 5, 6});
// old = {1,2,3}, v = {4,5,6}

7 七、其他小特性

特性	说明
二进制字面量	`0b1010` 表示十进制 10
数字分隔符	`1'000'000` 可读性更好
lambda 初始化捕获	C++14 可以在捕获列表里初始化新变量

1
2
3


// 初始化捕获（init capture）
int x = 10;
auto f = [y = x + 1]() { return y; };  // y = 11

8 总结

C++14 是一个过渡版本，特性不多但都很实用：

函数返回值 auto：写起来更简洁
泛型 lambda：配合 auto 参数，写算法更方便
decltype(auto)：完美转发返回值
make_unique：终于补上了
变量模板：为后续标准库简化铺路

C++17 新特性

Fri, 17 Jul 2026 00:00:00 +0000

C++17 是一个大版本，引入了很多实用特性，被称为「最舒服的 C++ 版本」。

1 一、结构化绑定（Structured Bindings）⭐

最常用的特性之一，一键解包 tuple/struct/数组：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


// 解包 pair
std::pair<int, std::string> getPerson() { return {25, "Tom"}; }
auto [age, name] = getPerson();

// 解包 tuple
auto [a, b, c] = std::make_tuple(1, 2.5, "hello");

// 解包 struct
struct Point { int x; int y; };
Point p{10, 20};
auto [x, y] = p;

// 解包数组
int arr[] = {1, 2, 3};
auto [a, b, c] = arr;

结合 map 遍历超好用：

1
2
3
4


std::map<int, std::string> m = {{1, "a"}, {2, "b"}};
for (const auto& [key, value] : m) {
    std::cout << key << ": " << value << std::endl;
}

实战（Q347 前 K 个高频元素）：

1
2
3
4
5
6
7
8
9


// 传统写法：p.first / p.second 访问键值对
for (auto& p : u_map) {
    vec.push_back({p.second, p.first});   // p.first 是数字，p.second 是次数
}

// 结构化绑定写法：一行解包，见名知意
for (auto& [num, cnt] : u_map) {
    vec.push_back({cnt, num});
}

注意：LeetCode 默认 C++17，可以直接用 auto [num, cnt]；本地老编译器（C++14 及以下）不支持。

2 二、`if` / `switch` 初始化语句

在 if 条件里定义变量，缩小作用域：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// C++17 写法
if (auto it = m.find(key); it != m.end()) {
    // 使用 it
}
// it 在这里已经不可见了

// switch 同理
switch (int val = getValue(); val) {
    case 1: ...
    case 2: ...
}

3 三、内联变量（Inline Variables）

解决了「全局变量在头文件里定义导致多重定义」的老问题：

1
2
3
4
5
6
7


// 头文件中，C++17 之前会报重复定义
inline constexpr int MAX_SIZE = 1024;

// 静态成员变量也可以直接在类内初始化
class MyClass {
    inline static int count = 0;  // C++17 不需要在 .cpp 里再定义一次
};

4 四、折叠表达式（Fold Expressions）

简化可变参数模板的展开：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 对所有参数求和
template<typename... Args>
auto sum(Args... args) {
    return (... + args);  // 一元右折叠：((a1 + a2) + a3) + ...
}

sum(1, 2, 3, 4);  // = 10

// 带初始值的折叠
template<typename... Args>
void printAll(Args... args) {
    (std::cout << ... << args) << std::endl;
}

四种折叠形式：

(... op args) 一元右折叠
(args op ...) 一元左折叠
(init op ... op args) 二元右折叠
(args op ... op init) 二元左折叠

5 五、`constexpr` 增强

C++17 中 constexpr 可以用的地方更多了：

5.1 5.1 constexpr if

编译期条件判断，替代部分 SFINAE 写法：

1
2
3
4
5
6
7
8


template<typename T>
auto getValue(T x) {
    if constexpr (std::is_integral_v<T>) {
        return x + 1;
    } else {
        return x;
    }
}

5.2 5.2 constexpr lambda

lambda 可以在编译期执行：

1
2


constexpr auto square = [](int n) { return n * n; };
static_assert(square(5) == 25);  // 编译期计算

6 六、类模板参数推导（CTAD）

构造模板类时不用写模板参数，编译器自动推导：

1
2
3
4
5
6
7


// C++11/14：必须写参数
std::pair<int, double> p1(1, 2.5);
std::vector<int> v1{1, 2, 3};

// C++17：自动推导
std::pair p2(1, 2.5);     // pair
std::vector v2{1, 2, 3};  // vector

7 七、标准库新增容器

7.1 7.1 `std::optional`

表示「可能有值，可能为空」，替代指针判空：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


std::optional<int> findNum(int x) {
    if (x > 0) return x;
    return std::nullopt;  // 空
}

auto res = findNum(5);
if (res) {
    std::cout << *res << std::endl;
}

// 有值返回，没值返回默认
int val = findNum(-1).value_or(0);

7.2 7.2 `std::variant`

类型安全的 union，访问时用 std::visit：

1
2
3
4
5
6
7
8


std::variant<int, double, std::string> v;
v = 42;
v = 3.14;
v = "hello";

std::visit([](auto&& arg) {
    std::cout << arg << std::endl;
}, v);

7.3 7.3 `std::any`

可以存任意类型的容器，类似 void* 但类型安全：

1
2
3
4
5
6


std::any a = 42;
a = std::string("hello");

if (a.type() == typeid(std::string)) {
    std::cout << std::any_cast<std::string>(a) << std::endl;
}

8 八、`std::string_view`

字符串的「视图」，不持有数据，零拷贝：

1
2
3
4
5
6


void print(std::string_view sv) {  // 传 const char* 或 std::string 都不用拷贝
    std::cout << sv << std::endl;
}

print("hello");           // OK
print(std::string("hi")); // OK

注意： string_view 不拥有数据，源字符串销毁后就悬空了。

9 九、文件系统库 `std::filesystem`

终于有了标准的文件操作库：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include 
namespace fs = std::filesystem;

// 创建目录
fs::create_directory("test");

// 遍历目录
for (auto& entry : fs::directory_iterator(".")) {
    std::cout << entry.path() << std::endl;
}

// 文件大小、路径操作
auto size = fs::file_size("test.txt");
auto ext = fs::path("test.txt").extension();

10 十、其他实用特性

特性	说明
`[[nodiscard]]`	标记返回值不能忽略，编译器会警告
`[[maybe_unused]]`	标记可能不用的变量，消除警告
`[[fallthrough]]`	switch 中显式标注故意 fall-through
十六进制浮点字面量	`0x1.2p3`
`std::as_const`	把左值转成 const 引用
`std::clamp`	把值限制在区间内 `clamp(val, min, max)`

1
2
3


// [[nodiscard]] 示例
[[nodiscard]] int compute() { return 42; }
compute();  // 警告：返回值被忽略

11 总结

C++17 是日常开发提升幸福感最多的版本：

结构化绑定 + if-init：代码更简洁
optional/variant/any：类型安全三件套
string_view：字符串处理性能提升
filesystem：终于不用自己写文件操作了
constexpr if：模板元编程变得可读

C++20 新特性

Fri, 17 Jul 2026 00:00:00 +0000

C++20 是继 C++11 以来最大的版本更新，四大天王：Concepts、Ranges、Coroutines、Modules。

1 一、概念（Concepts）⭐

给模板参数加约束，让模板报错不再是天书：

1.1 1.1 基础用法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 定义一个概念：T 必须是可加的
template<typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

// 使用概念约束模板参数
template<Addable T>
T add(T a, T b) {
    return a + b;
}

1.2 1.2 requires 表达式

四种约束形式：

简单约束：sizeof(T) == 4
类型约束：std::integral
复合约束：{ expr } -> 类型概念
嵌套约束：requires { ... }

1
2
3
4
5
6
7


template<typename T>
concept Container = requires(T c) {
    c.begin();       // 必须有 begin()
    c.end();         // 必须有 end()
    typename T::value_type;  // 必须有 value_type 类型
    { c.size() } -> std::convertible_to<size_t>;
};

1.3 1.3 标准库内置概念

头文件里提供了一堆：

std::same_as — 类型相同
std::derived_from — 派生关系
std::convertible_to — 可转换
std::integral — 整型
std::floating_point — 浮点型
std::ranges::range — 范围

2 二、范围库（Ranges）⭐

彻底改变 STL 算法的写法，支持链式调用：

2.1 2.1 管道式写法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include 

std::vector<int> nums = {1, 2, 3, 4, 5, 6};

// C++17：嵌套调用，可读性差
// C++20：管道式，从左到右读
auto result = nums
    | std::views::filter([](int n) { return n % 2 == 0; })
    | std::views::transform([](int n) { return n * 2; })
    | std::views::take(3);

for (int x : result) {
    std::cout << x << " ";  // 4 8 12
}

2.2 2.2 常用视图适配器

适配器	作用
`views::filter`	过滤
`views::transform`	转换映射
`views::take(n)`	取前 n 个
`views::drop(n)`	跳过前 n 个
`views::reverse`	反转
`views::keys` / `values`	取 pair 的 key/value
`views::join`	扁平化
`views::split`	分割

2.3 2.3 惰性求值

views 不会立即计算，只有在迭代时才生成元素，性能更好。

3 三、协程（Coroutines）

函数可以暂停和恢复，异步编程神器：

3.1 3.1 三个新关键字

1
2
3


co_await   // 暂停，等待异步操作
co_return  // 返回值并结束
co_yield   // 返回一个值并暂停，下次从这里继续

3.2 3.2 生成器示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


generator<int> fibonacci(int n) {
    int a = 0, b = 1;
    for (int i = 0; i < n; ++i) {
        co_yield b;   // 返回 b，暂停在这里
        int next = a + b;
        a = b;
        b = next;
    }
}

// 使用
for (int x : fibonacci(10)) {
    std::cout << x << " ";
}

3.3 3.3 异步任务

1
2
3
4


task<int> fetchData() {
    auto data = co_await asyncLoad();  // 暂停，不阻塞线程
    co_return data.size();
}

注意：标准库只提供了协程机制，没有提供具体的协程类型（task/generator），需要自己实现或用第三方库（如 cppcoro）。C++23 才补了 std::generator。

4 四、模块（Modules）

告别 #include，解决头文件地狱：

4.1 4.1 定义模块

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// math.ixx （模块接口文件）
export module math;

export int add(int a, int b) {
    return a + b;
}

export namespace math_utils {
    int mul(int a, int b) { return a * b; }
}

4.2 4.2 导入模块

1
2
3
4
5
6


import math;

int main() {
    add(1, 2);
    math_utils::mul(3, 4);
}

优点：

编译速度大幅提升（只编译一次）
没有宏污染
模块内部的东西默认不导出，封装更好

5 五、三路比较运算符 `<=>`

俗称「飞船运算符」，一次比较得出大小关系：

1
2
3
4
5
6
7
8
9


struct Point {
    int x, y;
    auto operator<=>(const Point&) const = default;  // 自动生成所有比较运算符
};

Point a{1, 2}, b{3, 4};
a < b;   // OK，自动生成
a >= b;  // OK
a == b;  // OK

返回类型有三种：

std::strong_ordering — 强序（完全可比）
std::weak_ordering — 弱序
std::partial_ordering — 偏序（可能不可比，比如 NaN）

6 六、指定初始化（Designated Initializers）

像 C 语言那样按名字初始化结构体成员：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


struct Point {
    int x = 0;
    int y = 0;
    int z = 0;
};

Point p {
    .x = 10,
    .z = 30
    // y 用默认值 0
};

注意：顺序必须和声明顺序一致，不能跳着来。

7 七、`consteval` 与 `constinit`

7.1 7.1 consteval — 立即函数

必须在编译期执行，否则报错：

1
2
3
4
5
6
7


consteval int sqr(int n) {
    return n * n;
}

constexpr int a = sqr(10);  // OK，编译期
int b = sqr(20);            // OK，编译期常量
// int x = 5; sqr(x);       // ERROR，x 不是编译期常量

7.2 7.2 constinit — 常量初始化

保证变量在编译期初始化，避免静态初始化顺序问题：

1

constinit int global = compute_at_compile_time();

8 八、`std::format`

Python 风格的格式化字符串，终于不用 printf 或 stringstream 了：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


#include 

std::string s = std::format("Hello, {}! You are {} years old.", "Tom", 25);
// "Hello, Tom! You are 25 years old."

// 按位置
std::format("{1} {0}", "world", "Hello");  // "Hello world"

// 格式说明
std::format("{:>10}", 42);    // 右对齐，占10位
std::format("{:08b}", 42);    // 8位二进制，前导零
std::format("{:.2f}", 3.14159);  // 保留2位小数

9 九、`std::span`

连续内存的视图，类似 string_view 但是通用的：

1
2
3
4
5
6
7
8
9


void printArray(std::span<int> arr) {
    for (int x : arr) std::cout << x << " ";
}

int a[] = {1, 2, 3};
printArray(a);              // 原生数组

std::vector v = {4, 5, 6};
printArray(v);              // vector

10 十、其他特性速览

特性	说明
`std::jthread`	自动 join 的线程，支持停止令牌
`std::stop_token`	协作式线程中断
`std::source_location`	获取当前代码位置（文件名、行号）
`std::bit_cast`	安全的类型双关，替代 memcpy
`std::midpoint` / `std::lerp`	中点和线性插值
`[[likely]]` / `[[unlikely]]`	给编译器分支预测提示
范围 for 初始化语句	`for (auto it = v.begin(); auto x : v)`

1
2
3
4
5
6


// likely/unlikely 示例
if (likely(n > 0)) {
    // 大概率走这里，编译器优化
} else {
    // 小概率
}

11 总结

C++20 是改变编程范式的大版本：

Concepts：模板终于好用了，报错终于能看懂了
Ranges：STL 算法的现代写法，链式调用爽
Coroutines：异步编程基础设施
Modules：告别头文件，编译起飞
format / span / jthread：各种小确幸

STL 常用容器速查表

Fri, 17 Jul 2026 00:00:00 +0000

1 一、序列容器

1.1 vector — 动态数组 ⭐

操作	用法	时间
尾插	`v.push_back(x)`	O(1) 均摊
尾删	`v.pop_back()`	O(1)
插入	`v.insert(it, x)`	O(n)
删除	`v.erase(it)`	O(n)
访问	`v[i]` / `v.at(i)`	O(1)
大小	`v.size()` / `v.capacity()`	O(1)
清空	`v.clear()`	O(n)
预留	`v.reserve(n)`	O(n)

特点： 连续内存，随机访问快，中间插入慢，尾插最快

1.2 deque — 双端队列

操作	用法
头插	`dq.push_front(x)`
头删	`dq.pop_front()`
尾插	`dq.push_back(x)`
尾删	`dq.pop_back()`
访问	`dq[i]`

特点： 头尾都能 O(1) 插入删除，随机访问比 vector 慢一点

1.3 list — 双向链表

操作	用法
插入	`lst.insert(it, x)`
删除	`lst.erase(it)`
头插	`lst.push_front(x)`
尾插	`lst.push_back(x)`
排序	`lst.sort()`
反转	`lst.reverse()`

特点： 任意位置 O(1) 插入删除，但不能随机访问，用得少

2 二、关联容器

2.1 map / unordered_map — 字典 ⭐

特性	map	unordered_map
底层	红黑树	哈希表
有序	✅ 按 key 排序	❌ 无序
插入	O(log n)	O(1) 均摊
查询	O(log n)	O(1) 均摊
遍历	有序输出	无序

常用操作：

1
2
3
4
5


mp[key] = val;       // 插入/修改
mp.count(key);       // 是否存在
mp.find(key);        // 返回迭代器
mp.erase(key);       // 删除
for (auto& [k, v] : mp) { }  // C++17 结构化绑定

2.2 set / unordered_set — 集合

特性	set	unordered_set
底层	红黑树	哈希表
有序	✅	❌
去重	✅	✅

常用操作：

1
2
3
4


st.insert(x);
st.erase(x);
st.count(x);    // 0 或 1
st.size();

2.3 multiset / multimap

允许重复 key 的版本，用法基本一样。

multiset 注意： erase(val) 会删掉所有等于 val 的元素，删单个要用 erase(iterator)

1
2


auto it = ms.find(val);
if (it != ms.end()) ms.erase(it);  // 只删一个

3 三、容器适配器

3.1 stack — 栈（后进先出）

1
2
3
4
5
6


stack<int> st;
st.push(x);    // 压栈
st.pop();      // 弹栈（无返回值）
st.top();      // 栈顶
st.empty();
st.size();

底层默认是 deque。

3.2 queue — 队列（先进先出）

1
2
3
4
5
6
7


queue<int> q;
q.push(x);     // 入队
q.pop();       // 出队（无返回值）
q.front();     // 队首
q.back();      // 队尾
q.empty();
q.size();

3.3 priority_queue — 优先队列（堆）⭐

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 默认大顶堆
priority_queue<int> pq;

// 小顶堆
priority_queue<int, vector<int>, greater<int>> minHeap;

pq.push(x);    // 插入
pq.pop();      // 弹出堆顶
pq.top();      // 堆顶元素
pq.empty();
pq.size();

默认是大顶堆，用 less 比较。

4 四、容器选择指南

需求	推荐容器
随机访问多，尾插尾删	vector
头尾都要插入删除	deque
频繁中间插入删除	list（很少用）
key-value 查找，需要有序	map
key-value 查找，追求速度	unordered_map
去重 + 有序	set
去重 + 速度	unordered_set
栈操作	stack
队列操作	queue
求最大/最小值	priority_queue

5 五、常用算法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#include 

sort(v.begin(), v.end());           // 排序
sort(v.rbegin(), v.rend());         // 降序
reverse(v.begin(), v.end());        // 反转
swap(a, b);                         // 交换
*max_element(v.begin(), v.end());   // 最大值
*min_element(v.begin(), v.end());   // 最小值
accumulate(v.begin(), v.end(), 0);  // 求和（需 include ）
lower_bound(v.begin(), v.end(), x); // 第一个 >= x
upper_bound(v.begin(), v.end(), x); // 第一个 > x
next_permutation(v.begin(), v.end()); // 下一个排列
fill(v.begin(), v.end(), val);      // 填充

6 六、迭代器失效速记

容器	插入	删除
vector	扩容全部失效；否则插入点之后失效	删除点及之后失效
deque	头尾插入只失效所有迭代器，引用不失效；中间插入全部失效	中间删除全部失效；头尾删除对应端失效
list / map / set	不失效	只有被删的失效

C++ - 分类 - 豆浆小屋

C++ 学习与面试资料导航

1 一、系统知识库：用来建立主线

1.1 编程指北：C++ 面试题库

1.2 huihut：C/C++ 技术面试知识库

1.3 卡码笔记：面试知识库

1.4 小林 coding：C++ 面试题

2 二、逐题练习：用来查漏补缺

2.1 面试鸭：C++ 基础面试题库

2.2 拾光小舟：C++ 基础面试集

2.3 程序厨：C++ 面试题库

2.4 guaguaupup：C++ 后台开发面经

3 三、作者公开资料：用来交叉验证

4 四、开源项目：从“会答”走到“会做”

4.1 BuriedPoint：埋点上报 SDK

5 五、推荐使用顺序

C 字符串与内存操作函数速查

1 字符串/内存操作函数速查

2 补充规律（方便记忆）

C++ vector 深度解析

1 一、底层原理

2 二、扩容机制

2.1 扩容过程

2.2 时间复杂度

2.3 避免扩容的方法

3 三、迭代器失效

3.1 什么情况会失效？

3.2 经典坑：erase 遍历

4 四、常用操作

4.1 构造函数

4.2 卡点：构造时填了初值，push_back 从哪开始

4.3 增删改查

4.4 访问

4.5 大小相关

5 五、内存管理细节

5.1 clear() 不释放内存

5.2 真正释放内存的方法

5.3 用 reserve 优化性能

6 六、常见坑点总结

7 七、性能对比

C++14 新特性

1 一、函数返回值类型推导

2 二、泛型 lambda（Generic Lambda）

3 三、变量模板（Variable Templates）

4 四、聚合初始化增强

5 五、decltype(auto)

6 六、标准库新增

6.1 6.1 std::make_unique

6.2 6.2 std::shared_timed_mutex

6.3 6.3 整数序列 std::integer_sequence

6.4 6.4 std::exchange

7 七、其他小特性

8 总结

C++17 新特性

1 一、结构化绑定（Structured Bindings）⭐

2 二、if / switch 初始化语句

3 三、内联变量（Inline Variables）

4 四、折叠表达式（Fold Expressions）

5 五、constexpr 增强

5.1 5.1 constexpr if

5.2 5.2 constexpr lambda

6 六、类模板参数推导（CTAD）

7 七、标准库新增容器

7.1 7.1 std::optional

7.2 7.2 std::variant

7.3 7.3 std::any

8 八、std::string_view

9 九、文件系统库 std::filesystem

10 十、其他实用特性

11 总结

C++20 新特性

1 一、概念（Concepts）⭐

1.1 1.1 基础用法

1.2 1.2 requires 表达式

1.3 1.3 标准库内置概念

2 二、范围库（Ranges）⭐

2.1 2.1 管道式写法

2.2 2.2 常用视图适配器

2.3 2.3 惰性求值

3 三、协程（Coroutines）

5 五、`decltype(auto)`

6.1 6.1 `std::make_unique`

6.2 6.2 `std::shared_timed_mutex`

6.3 6.3 整数序列 `std::integer_sequence`

6.4 6.4 `std::exchange`

2 二、`if` / `switch` 初始化语句

5 五、`constexpr` 增强

7.1 7.1 `std::optional`

7.2 7.2 `std::variant`

7.3 7.3 `std::any`

8 八、`std::string_view`

9 九、文件系统库 `std::filesystem`

5 五、三路比较运算符 `<=>`

7 七、`consteval` 与 `constinit`

8 八、`std::format`

9 九、`std::span`