主题
C++11/14/17/20 新特性
一、类型推导
1. auto(C++11)
Q: auto 的作用和使用场景?有什么注意事项?
auto 让编译器根据初始化表达式自动推导变量类型。
cpp
auto i = 42; // int
auto d = 3.14; // double
auto s = "hello"; // const char*
// 最实用的场景
std::vector<int> v = {1, 2, 3};
for (auto it = v.begin(); it != v.end(); ++it) { ... } // 省略冗长类型
for (auto& x : v) { ... } // 范围 for 遍历
auto ptr = std::make_unique<Foo>(args...); // 智能指针
// 函数返回类型推导(C++14)
auto add(int a, int b) { return a + b; } // 返回 int注意事项:
| 陷阱 | 示例 | 结果 |
|---|---|---|
| 去掉引用 | int& r = x; auto a = r; | a 是 int(去引用) |
| 去掉顶层 const | const int ci = 1; auto a = ci; | a 是 int(去顶层 const) |
| 保留底层 const | const int* p = &ci; auto a = p; | a 是 const int* |
需要引用用 auto& | auto& r = x; | r 是 int& |
万能引用用 auto&& | auto&& u = expr; | 根据 expr 推导 |
记忆:
auto推导规则与模板参数推导一致,去掉引用和顶层 const。需要保留时用auto&、const auto&或auto&&。
两个易错点(常挖):
- auto 不能作函数形参(C++11;C++20 起才允许
void f(auto x))——形参类型必须显式或模板化 - decltype 不执行表达式:
decltype(add(3,4))只分析类型,不会真的调用add(编译期操作,零运行时开销)
2. decltype(C++11)
Q: decltype 和 auto 的区别?什么场景用 decltype?
decltype(expr) 获取表达式的确切类型,不做任何修改(保留引用和 const)。
cpp
int x = 0;
int& r = x;
const int ci = 10;
decltype(x) a = 1; // int(不丢)
decltype(r) b = x; // int&(保留引用)
decltype(ci) c = 10; // const int(保留 const)auto | decltype | |
|---|---|---|
| 推导依据 | 初始化表达式的值类别 | 表达式的声明类型 |
| 保留引用? | 否(除非加 &) | 是 |
| 保留顶层 const? | 否 | 是 |
| 需要初始值? | 是 | 否 |
| 典型场景 | 变量声明 | 模板、泛型编程、后置返回类型 |
核心应用 —— 后置返回类型(C++11):
cpp
// 返回类型依赖参数类型时,用 decltype + 后置返回
template<typename T1, typename T2>
auto add(T1 a, T2 b) -> decltype(a + b) {
return a + b;
}
// C++14 简化:直接用 decltype(auto)
template<typename T1, typename T2>
decltype(auto) add(T1 a, T2 b) { // 保留表达式的完整类型
return a + b;
}选型:声明变量用
auto(简洁);需要完美转发返回值、推迟返回类型判断用decltype。
追问:decltype((x)) 和 decltype(x) 的区别:
cpp
int x = 0;
decltype(x) a = 1; // int(作用于变量名 → 返回声明类型)
decltype((x)) b = x; // int&!(作用于表达式 → 按表达式值类别推导)
// 规则:作用于"变量名" → 声明类型;
// 作用于"表达式" → 左值表达式得 T&,右值得 T,xvalue 得 T&&
// (x) 加了括号就是一个左值表达式 → 推导出 int&一句话:
decltype(x)看声明,decltype((x))看值类别——括号是最容易挖的陷阱。
3. decltype(auto)(C++14)
Q: decltype(auto) 有什么用?
结合 auto 的简洁和 decltype 的精确——自动推导,但保留引用和 const。
cpp
int x = 10;
int& r = x;
auto a = r; // int(丢了引用)
decltype(r) b = r; // int&
decltype(auto) c = r; // int&(保留引用)
// 完美转发返回值
template<typename F, typename... Args>
decltype(auto) invoke(F&& f, Args&&... args) {
return f(std::forward<Args>(args)...); // 保留返回类型的引用性
}二、空指针 —— nullptr(C++11)
Q: nullptr 和 NULL 的区别?为什么推荐 nullptr?
NULL | nullptr(C++11) | |
|---|---|---|
| 本质 | 宏,通常 #define NULL 0 或 (void*)0 | 关键字,类型为 std::nullptr_t |
| 类型 | 整型 int 或 void* | 明确的空指针类型 |
| 重载歧义 | ❌ 可能被当作整数 | ✅ 永远被识别为指针 |
cpp
void f(int);
void f(int*);
f(NULL); // 可能调用 f(int),不符合预期!
f(nullptr); // 明确调用 f(int*),类型安全
// 可隐式转为任意类型空指针
int* p = nullptr;
char* c = nullptr;
// 但不能转为 int
int n = nullptr; // ❌ 编译错误三、范围 for 循环(C++11)
Q: 范围 for 的用法和注意事项?
cpp
std::vector<int> v = {1, 2, 3, 4, 5};
// 只读遍历(推荐 const auto& 避免拷贝)
for (const auto& x : v) { std::cout << x; }
// 修改元素
for (auto& x : v) { x *= 2; }
// 值拷贝(不推荐大对象)
for (auto x : v) { /* x 是副本,修改不影响原容器 */ }
// 原理:编译器展开为
// for (auto it = begin(v); it != end(v); ++it) { auto x = *it; ... }陷阱:遍历过程中不能改变容器大小(添加/删除元素),否则迭代器失效!
四、智能指针
智能指针是一种封装了原始指针的类模板。
它利用 RAII 机制,通过对象的生命周期自动管理动态内存,确保在不再需要内存时自动释放,从而避免内存泄漏。
1. 为什么需要智能指针?
Q: 智能指针解决了什么问题?
C++ 中最常见的 Bug 来源:忘记 delete → 内存泄漏;已 delete 又访问 → 悬空指针;多次 delete → double free。
智能指针 = RAII 思想的体现:构造时获取资源,析构时自动释放。
| 智能指针 | 所有权 | C++ 版本 | 使用场景占比 |
|---|---|---|---|
unique_ptr | 独占 | C++11 | 90% |
shared_ptr | 共享(引用计数) | C++11 | 9% |
weak_ptr | 观察者(不影响引用计数) | C++11 | 1% |
auto_ptr | 已废弃(拷贝会转移所有权) | C++98 | 0%(禁止使用) |
2. unique_ptr(独占所有权)
Q: unique_ptr 的特点和使用场景?
核心特点:独占所有权——不可拷贝,只能移动。
cpp
#include <memory>
// 1. 创建(优先用 make_unique,C++14)
auto p = std::make_unique<int>(42);
auto arr = std::make_unique<int[]>(100); // 数组
// 2. 所有权转移
auto p1 = std::make_unique<Foo>();
auto p2 = std::move(p1); // p1 变为 nullptr,p2 拥有对象
// auto p3 = p2; // ❌ 编译错误:不可拷贝
// 3. 释放 / 重置
p2.reset(); // 手动释放
p2.reset(new Foo()); // 释放旧对象,接管新对象
Foo* raw = p2.release(); // 放弃所有权,返回裸指针(需手动 delete)
// 4. 获取裸指针
Foo* raw = p.get(); // 不转移所有权,仅读取| 特性 | 说明 |
|---|---|
| 大小 | 默认删除器下与裸指针相同(零开销) |
| 移动 | ✅ 可移动 |
| 拷贝 | ❌ 不可拷贝 |
| 自定义删除器 | std::unique_ptr<T, Deleter> |
使用场景:
- 工厂函数返回对象(转移所有权给调用方)
- 容器中存放多态对象
- Pimpl 惯用法(隐藏实现细节)
- 任何不需要共享所有权的场景(绝大多数场景)
2.1 make_unique 的异常安全性(容易被忽略的细节)
Q: 为什么推荐用 make_unique 而不是 new + unique_ptr?除了代码简洁外还有什么原因?
核心理由:异常安全。C++ 中函数参数的计算顺序是不确定的:
cpp
// ❌ 危险写法
void process(std::unique_ptr<A> ptr, int result);
process(std::unique_ptr<A>(new A()), get_result());
// 如果编译器按以下顺序执行:
// 1. new A() → 堆上分配成功
// 2. get_result() → 抛出异常!
// 3. unique_ptr 构造 → 永远执行不到
// 结果:A 对象泄漏!cpp
// ✅ 安全写法
process(std::make_unique<A>(), get_result());
// make_unique 将 new + unique_ptr 包装成原子操作
// get_result() 抛异常时,unique_ptr 要么已接管要么还没创建 → 不会泄漏线程池项目中的实际使用:
cpp
// ThreadPool::start 中创建线程对象
auto ptr = std::make_unique<Thread>(
std::bind(&ThreadPool::threadFunc, this, std::placeholders::_1)
);
// 1. 堆上分配 Thread 对象
// 2. 调用构造函数(传入 bind 产生的函数对象)
// 3. 将地址交给 unique_ptr 管理
// 三步打包为原子操作,异常安全现代 C++ 原则:代码中尽量不出现裸
new和delete。make_unique/make_shared是实现这一原则的核心工具。
2.2 unique_ptr 的底层实现(为什么零开销)
Q: unique_ptr 底层是怎么实现的?为什么说它零开销?
核心:只有一个裸指针成员,所有机制都在类型系统层面。
cpp
// 简化版 unique_ptr 实现 —— 抓住本质
template<typename T, typename Deleter = std::default_delete<T>>
class unique_ptr {
T* ptr_; // 唯一成员:一个裸指针
public:
explicit unique_ptr(T* p = nullptr) noexcept : ptr_(p) {}
// 析构:直接调删除器 —— 没有计数、没有控制块
~unique_ptr() noexcept { if (ptr_) Deleter()(ptr_); }
// 拷贝:= delete —— 编译期就禁止复制
unique_ptr(const unique_ptr&) = delete;
unique_ptr& operator=(const unique_ptr&) = delete;
// 移动:指针"偷"过来,源对象必须置空(否则析构时 double delete)
unique_ptr(unique_ptr&& u) noexcept : ptr_(u.ptr_) { u.ptr_ = nullptr; }
unique_ptr& operator=(unique_ptr&& u) noexcept {
if (this != &u) reset(u.release()); // 释放旧的,接管新的
return *this;
}
T* release() noexcept {
T* p = ptr_;
ptr_ = nullptr;
return p;
} // 交还所有权
void reset(T* p = nullptr) noexcept { // 换新对象
T* old = ptr_;
ptr_ = p;
if (old) Deleter()(old);
}
T* get() const noexcept { return ptr_; }
T& operator*() const { return *ptr_; }
T* operator->() const { return ptr_; }
};| 设计点 | 说明 |
|---|---|
| 内存布局 | 唯一成员是裸指针 → sizeof(unique_ptr) == sizeof(T*)(默认删除器),零开销 |
| 为什么不能拷贝 | 拷贝构造/赋值被 = delete,所有权转移只能走移动 |
| 移动为什么置空源 | 析构会 delete,不置空 → 同一块内存被 delete 两次 |
| release vs reset | release 只交还指针不释放;reset 释放旧的、接管新的 |
| 删除器是模板参数 | 默认 default_delete 是空类,靠 EBO(空基类优化) 不占空间;换成函数指针/有状态对象时,对象会变大 |
| 为什么比 shared_ptr 快 | 析构直接调删除器,无计数、无控制块、无原子操作 |
一句话:
unique_ptr的"独占"不是运行时保证的,是编译期通过删除拷贝实现的——所以它可以没有计数器,只装一个裸指针。
2.3 auto_ptr 为什么被废弃?unique_ptr 如何取代它?(C++98 → C++11)
Q: auto_ptr 为什么被废弃?unique_ptr 和它是什么关系?
废弃原因(三个致命缺陷):
- 拷贝即转移所有权:拷贝构造/赋值会悄悄置空源对象——
auto_ptr<int> q = p;之后p变空,再使用p就是空指针访问。语义反直觉,是经典 Bug 来源 - 不能进标准容器:容器拷贝元素时会转移所有权,元素"凭空消失"(
vector<auto_ptr<T>>是未定义行为级别的坑) - 数组支持不佳:内部
delete而非delete[],管理数组会漏释放
unique_ptr 如何取代它:
- C++11 用移动语义重新设计:
auto_ptr的"拷贝即转移" →unique_ptr的"移动即转移、拷贝禁止"——隐式转移变成编译期显式操作,杜绝误用 - 迁移改动很小:
auto_ptr<T> q = p;(转移)→unique_ptr<T> q = std::move(p);(转移);reset()/release()/get()接口完全一致 - 容器:
vector<unique_ptr<T>>只支持移动插入(emplace_back/push_back(std::move(x))),安全且语义明确
一句话:auto_ptr 的教训是"拷贝不该悄悄转移所有权"——unique_ptr 把转移规范为移动,并在编译期禁止拷贝,从语言层面消灭了这类坑。
3. shared_ptr(共享所有权 + 引用计数)
Q: shared_ptr 与 unique_ptr 的区别?(高频)
| 对比维度 | unique_ptr | shared_ptr |
|---|---|---|
| 所有权 | 独占(编译期强制) | 共享(运行期计数) |
| 对象大小 | 1 个指针(8B) | 2 个指针(16B) |
| 额外开销 | 零 | 控制块堆分配 + 原子计数 |
| 拷贝 | ❌ 禁止 | ✅ 计数 +1 |
| 移动 | ✅ O(1) | ✅ O(1)(计数不动) |
| 析构 | 直接 delete | 计数 -1,归零才 delete |
| 线程安全 | 不涉及 | 计数原子安全,对象需外部同步 |
| 适用场景 | 90% 的场景 | 确实需要共享所有权时 |
unique_ptr把"独占"做成编译期约束 → 零开销;
shared_ptr把"共享"做成运行期计数 → 有开销。能用前者就不用后者。
Q: shared_ptr 的底层原理?引用计数怎么管理的?
核心特点:多个 shared_ptr 可共享同一对象,引用计数控制生命周期。
cpp
auto p1 = std::make_shared<int>(42); // 引用计数 = 1
auto p2 = p1; // 引用计数 = 2
auto p3 = p1; // 引用计数 = 3
p1.reset(); // 计数 = 2
p2.reset(); // 计数 = 1
p3.reset(); // 计数 = 0 → 自动释放对象底层内存布局(make_shared 优化):
make_shared<T>():
┌────────────────────────────┐
│ 控制块(引用计数+弱计数+删除器)│
│ 对象内存 │
└────────────────────────────┘
一次分配,两块紧邻 → 缓存友好
shared_ptr<T>(new T):
两次分配:对象一块 + 控制块一块 → 两次 malloc控制块内部到底存了什么:
控制块(Control Block):
┌──────────────────────────────────┐
│ use_count 强引用计数 │ ← shared_ptr 的个数
│ weak_count 弱引用计数 │ ← weak_ptr 的个数(+1 隐含引用)
│ deleter 删除器(类型擦除) │ ← 支持自定义删除器,运行时调用
│ allocator 分配器 │ ← 控制块自己的释放规则
└──────────────────────────────────┘为什么 sizeof(shared_ptr) 是两个指针大小:
每个 shared_ptr 的成员:
┌─────────────┐ ┌─────────────────────────────┐
│ ptr_ (T*) │─────▶│ 对象(堆上) │
│ cb_(控制块*)│─┐ │ 控制块(堆上,所有 │
└─────────────┘ │ │ shared_ptr 共享一份) │
└──▶ │ use_count / weak_count / … │
└──────────────────────────────┘
→ 64 位下 sizeof(shared_ptr) == 16 字节(2 个指针)对比:
unique_ptr只有 8 字节(1 个指针)——不需要控制块,因为没有共享者,计数毫无意义。
Q: make_shared 有什么优势?
| 对比项 | std::make_shared<T>(args) | std::shared_ptr<T>(new T(args)) |
|---|---|---|
| 内存分配次数 | 1 次(对象+控制块合一块) | 2 次(对象 + 控制块分两次) |
| 异常安全 | ✅ 安全 | ❌ 可能泄漏(new 和 shared_ptr 构造之间可能异常) |
| 缓存性能 | ✅ 更好(两块紧邻) | 较差 |
| weak_ptr 存活时内存释放 | ❌ 对象内存和控制块一起延迟释放 | ✅ 对象先释放,控制块后释放 |
进阶加分点:
- 两个计数都是
std::atomic;lock()靠 CAS 把强计数从 0 变 1 失败来检测"对象刚死",从而保证线程安全、不会竞争(详见 §4.1)
引用计数的线程安全:引用计数的增减是原子操作,线程安全。
但被指向对象的数据访问不是线程安全的,需要外部同步。
计数操作的底层内存序(进阶加分点):计数增减并非默认的 seq_cst(最重),而是更轻的内存序:
| 操作 | 内存序 | 原因 |
|---|---|---|
拷贝时 use_count + 1 | relaxed | 只是计数,不需要与其他内存操作同步 |
析构时 use_count - 1 | acq_rel | 若归零要 delete 对象——必须先"看到"其他线程对对象的访问全部完成(acquire);对象释放前的写入也要对别人可见(release) |
一句话:引用计数不需要
seq_cst的全局顺序,relaxed+acq_rel就够了——只有"最后一个析构者"需要与所有其他线程同步。
不要用同一个裸指针构造多个 shared_ptr:
cpp
int* raw = new int(1);
auto p1 = std::shared_ptr<int>(raw); // 计数 = 1
auto p2 = std::shared_ptr<int>(raw); // ❌ 计数 = 1(新的控制块!)
// 引用计数是指被引用的次数,raw是原始指针,没有引用计数
// p1、p2 各自独立计数 → double free!use_count() 的陷阱(加分点):
use_count()只能用于调试,绝不能用于业务逻辑判断(如if (sp.use_count() == 1))- 多线程下读到的不是原子快照——另一个线程随时可能在读的瞬间 +1/-1,结果必然不准确
- 在跨线程传递、异步回调中判断"我是否是最后一个引用"是不可靠的
与裸指针混用的陷阱(get() 的风险):
cpp
std::shared_ptr<int> sp = std::make_shared<int>(42);
int* raw = sp.get(); // 取出裸指针(只是"借看",不转移所有权)
// ... sp 析构(或被 reset)...
*raw = 100; // ❌ 悬垂访问:对象已被释放,UB!get()返回的裸指针不参与生命周期,外部持有它时必须保证 shared_ptr 还活着- 绝不能让外部通过
get()拿到指针后自己delete——会和 shared_ptr 双重释放 - 需要把裸指针交给"不持有所有权"的第三方(如 C 接口)时,必须保证调用期间 shared_ptr 存活
循环引用陷阱 — shared_ptr 最常见的坑:
cpp
class Node {
public:
std::shared_ptr<Node> next; // 导致循环引用
std::shared_ptr<Node> prev;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b; // b 计数 = 2(a->next 持有一个引用)
b->prev = a; // a 计数 = 2(b->prev 持有一个引用)
// a, b 离开作用域后:计数都 = 1(互相持有)→ 永远不会释放!3.1 手写一个简化版 shared_ptr(验证底层理解)
Q: 你能手写一个 shared_ptr 吗?
手撕题:控制块 + 双计数 + 原子操作,30 行以内。
cpp
#include <atomic>
#include <utility>
// 控制块:对象和控制块分离管理
struct ControlBlock {
std::atomic<int> use_count; // 强引用计数(shared_ptr 数量)
std::atomic<int> weak_count; // 弱引用计数(weak_ptr 数量)
ControlBlock() : use_count(1), weak_count(1) {}
// 初始 weak_count = 1:代表"对象还活着"这个隐含引用
// 保证 use_count 归零后控制块不会立刻消失(weak_ptr 还能安全访问)
};
template<typename T>
class shared_ptr {
T* ptr_ = nullptr;
ControlBlock* cb_ = nullptr;
public:
explicit shared_ptr(T* p) : ptr_(p), cb_(new ControlBlock()) {}
// 拷贝:共享控制块,use_count + 1
shared_ptr(const shared_ptr& o) noexcept
: ptr_(o.ptr_), cb_(o.cb_) {
if (cb_) cb_->use_count.fetch_add(1, std::memory_order_relaxed);
}
// 移动:指针搬运,计数不动(O(1))
shared_ptr(shared_ptr&& o) noexcept
: ptr_(o.ptr_), cb_(o.cb_) { o.ptr_ = nullptr; o.cb_ = nullptr; }
// 析构:use_count - 1,归零 → 删对象;weak_count - 1,归零 → 删控制块
~shared_ptr() {
if (!cb_) return;
if (cb_->use_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
delete ptr_; // 最后一个 shared_ptr:释放对象
if (cb_->weak_count.fetch_sub(1, std::memory_order_acq_rel) == 1)
delete cb_; // 最后一个 weak_ptr(含隐含引用):释放控制块
}
}
shared_ptr& operator=(const shared_ptr& o) noexcept {
if (this != &o) { shared_ptr tmp(o); swap(tmp); } // copy-and-swap
return *this;
}
shared_ptr& operator=(shared_ptr&& o) noexcept {
if (this != &o) { shared_ptr tmp(std::move(o)); swap(tmp); }
return *this;
}
void swap(shared_ptr& o) noexcept { std::swap(ptr_, o.ptr_); std::swap(cb_, o.cb_); }
int use_count() const noexcept {
return cb_ ? cb_->use_count.load(std::memory_order_relaxed) : 0;
}
T* get() const noexcept { return ptr_; }
T& operator*() const { return *ptr_; }
T* operator->() const { return ptr_; }
};计数变化总表(这张表能回答 90% 的引用计数题):
| 操作 | use_count | weak_count | 触发动作 |
|---|---|---|---|
| new 出第一个 shared_ptr | 1 | 1 | 分配对象 + 控制块 |
| shared_ptr 拷贝 | +1 | — | 共享同一控制块 |
| shared_ptr 析构 | -1 | — | 归零 → delete 对象 |
| weak_ptr 构造 | — | +1 | 登记观察者 |
| weak_ptr 析构 | — | -1 | 归零 → delete 控制块 |
| weak_ptr.lock() 成功 | +1 | — | 临时提升为 shared_ptr |
为什么 weak_count 初始是 1(隐含引用)? "对象还活着"本身算一个弱引用。它保证:最后一个
shared_ptr析构、对象被delete之后,控制块不会立刻消失——weak_ptr还能安全地expired()/lock()判断对象已死。只有最后一个weak_ptr也析构,控制块才释放。
和 make_shared 的连锁:
make_shared把对象和控制块放同一块内存。对象释放(use_count=0)时,只要 weak_count 还 > 0,整块内存就不能归还系统 → 对象内存"延迟释放"。这就是上面 §3 表格里"weak_ptr 存活时内存释放"一行的原因。
4. weak_ptr(打破循环引用)
std::weak_ptr 是 C++11 提供的一种非拥有型智能指针,用于"观测"由 shared_ptr 管理的对象
- 不增加强引用计数 —— 它不延长对象的生命周期
- 对象是否存活,取决于还有没有 shared_ptr 指向它
- 对象死亡后,weak_ptr 自动"感知"到(变成 expired),且不会悬垂(不会解引用已释放的内存)
Q: weak_ptr 的作用?为什么需要它?
**weak_ptr 不增加引用计数,**只是"观察者"——指向 shared_ptr 管理的对象,但不影响其生命周期。
cpp
// 修复上面的循环引用
class Node
{
public:
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // 将其中一个换成 weak_ptr
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b; // b 计数 = 2(b 自己 + a->next 各持一份)
b->prev = a; // a 计数仍 = 1(weak_ptr 不增加强引用计数)
// 离开作用域(逆序析构:先 b 后 a)→ 两个对象都被释放,无泄漏 ✅逐步推演(为什么这样写就对了):
初始:a:use_count=1(只有 a 自己) b:use_count=2(b 自己 + a->next)
a 的 weak_count=2(隐含引用 + b->prev)
① b 析构(后声明的先析构):b 计数 2→1,未归零 → b 对象暂不释放(a->next 还指着)
② a 析构:a 计数 1→0 → 释放 a 对象
→ a->next 随 a 一起析构 → b 计数 1→0 → 释放 b 对象 ✅
全部释放干净,无泄漏、无 double free对比修复前(见 四.3):两边都是 shared_ptr 时,a、b 计数各 = 2;离开作用域后各剩 1(对方持有)→ 永远不归零 → 都泄漏。
为什么能释放:
b->prev换成weak_ptr后,b 对 a 不再计强引用 → a 的计数只有自己 → a 可独立释放 → a 释放带走a->next→ b 的引用被顺带断开 → 多米诺骨牌式释放。
使用方式:
cpp
auto sp = std::make_shared<int>(42);
std::weak_ptr<int> wp = sp;
// 1. lock():尝试获取 shared_ptr
if (auto tmp = wp.lock()) // 如果对象还活着
{
// tmp 是一个 shared_ptr,安全使用
std::cout << *tmp;
}
else
{
// 对象已被销毁
}
// 2. expired():检查对象是否已销毁
if (wp.expired()) { /* 对象已死 */ }
// 3. use_count():获取引用计数
std::cout << wp.use_count();典型应用场景:
- 打破
shared_ptr循环引用 - 观察者模式:Subject 持有 Observer 的
weak_ptr,Observer 可以不通知 Subject 就销毁 - 缓存系统:持有对象的
weak_ptr,对象在其他地方释放后自动感知
4.1 weak_ptr 的底层实现(lock 为什么必须原子)
Q: weak_ptr 底层是怎么实现的?lock() 为什么必须原子?
weak_ptr 不碰 use_count,只在控制块里登记自己的数量:
cpp
template<typename T>
class weak_ptr {
T* ptr_ = nullptr;
ControlBlock* cb_ = nullptr;
public:
// 从 shared_ptr 构造:只取指针,weak_count + 1(use_count 不动!)
weak_ptr(const shared_ptr<T>& o) noexcept : ptr_(o.get()), cb_(o.cb_) {
if (cb_) cb_->weak_count.fetch_add(1, std::memory_order_relaxed);
}
~weak_ptr() { if (cb_) cb_->weak_count.fetch_sub(1, std::memory_order_acq_rel); }
bool expired() const noexcept {
return !cb_ || cb_->use_count.load(std::memory_order_relaxed) == 0;
}
};lock() 的本质:原子地"检查 + 提升"——这是 weak_ptr 最容易考到的地方:
cpp
std::shared_ptr<T> lock() const noexcept {
// 错误写法(有竞态):
// if (!expired()) return shared_ptr<T>(ptr_, cb_); // ❌
// 竞态:检查通过后,另一线程的最后一个 shared_ptr 析构 → 对象被 delete
// 此时再构造 shared_ptr 就是"引用已死的对象" → UB
// 正确写法:CAS 循环 —— 读计数,>0 则尝试 +1,成功才算提升
int n = cb_->use_count.load(std::memory_order_relaxed);
while (n > 0) {
if (cb_->use_count.compare_exchange_weak(
n, n + 1, std::memory_order_relaxed)) {
return shared_ptr<T>(ptr_, cb_); // 提升成功,共享控制块
}
// 失败:计数被别的线程改了(可能正在销毁)→ 用新值 n 重试
}
return nullptr; // use_count == 0:对象已销毁,返回空
}expired() 与 lock() 的最佳实践(高频追问):
cpp
// ❌ 先 expired 再 lock:两步之间有竞态(对象可能恰好在这两步之间被销毁)
if (!wp.expired()) { auto sp = wp.lock(); ... }
// ✅ 直接 if (auto sp = wp.lock()):一次原子操作,非空 = 对象活着
if (auto sp = wp.lock()) { ... } // 推荐写法两个计数器的生命周期分工(必答):
use_count 归零 → 释放对象(执行 deleter),但控制块还在
weak_count 归零 → 释放控制块(整个 shared_ptr 体系终结)一句话:
expired()是"看一眼"(非原子,只做判断);lock()是"伸手拿"(原子,要么拿到有效引用、要么拿到空)。weak_ptr 自己永远不 delete 对象,它只是判断对象是否还活着。
4.2 weak_ptr 存活时,内存何时释放
高频考点:对象内存和控制块内存是两回事,释放时机不同
- 对象内存(T 本身)在强引用计数归零的那一刻释放:触发条件是最后一个
shared_ptr析构 /reset()——此时调用析构函数;若对象与控制块分两块分配(裸new构造),内存立即归还,不等 weak_ptr。原因:最后一个强引用消失,对象已无人使用。 - 控制块内存(引用计数等元数据)则要等强计数和弱计数都归零时才释放:最后一个
weak_ptr销毁后它才被释放。原因:weak_ptr没有对象指针,只持有指向控制块的指针,需要靠控制块判断"对象是否还活着"——只要还有 weak_ptr 存活,控制块就必须保留,否则expired()/lock()无从查起。
分构造方式看(make_shared vs 裸 new):
make_shared:对象和控制块在同一块堆内存紧挨着分配 → 强计数归零只调用析构函数(内存块还占着),弱计数归零才delete整块内存。所以对象即使"已死",只要 weak_ptr 存活,这块内存就不会归还系统——这是 weak_ptr 存在的必要代价(大对象 + 长命 weak_ptr 会长期占用内存,此时裸new构造更优)。- 裸
new构造:对象和控制块分两块 → 强计数归零时对象内存立即释放;但控制块仍等弱计数归零,weak_ptr 存活期间会有"控制块悬挂在堆上"的小开销。
Q: 为什么分两块分配时,对象内存能"立即释放"?make_shared 为什么做不到?
释放对象只需要对象指针,不需要控制块配合;而 weak_ptr 从不直接访问对象内存,判断生死靠的是控制块里的 use_count:
- 谁负责释放对象:最后一个
shared_ptr析构时use_count归零 →deleter(ptr_)(默认delete ptr_)——只需要对象地址,和控制块毫无关系,所以对象立刻归还堆。 - weak_ptr 为什么不受影响:weak_ptr 内部只有
T* ptr_和ControlBlock* cb_,从不直接解引用对象——想访问必须lock():读控制块的use_count,归零则返回空,碰都不碰对象内存。所以对象内存释放后,weak_ptr 依然能靠控制块判断"对象已死"。 - 核心(最重要):
make_shared是同一块内存(对象+控制块),delete只能整块删——删了整块,控制块就没了,存活的 weak_ptr 就失去了判断依据,所以必须等弱计数也归零,才能执行这唯一一次delete。分两块 = 两次释放互相独立,才解耦出了"对象先走、控制块殿后"的时序。
4.3 强引用归零后,weak_ptr 还有意义吗
Q: shared_ptr 强引用计数为 0 时,weak_ptr 虽然存在,是不是就无意义了?
不完全对,要分两层看:
① 对这个已死的对象,监测功能确实失效:强计数归零后,expired() 恒为 true,lock() 恒返回空 shared_ptr,再也无法访问那个对象——"失去了监测目标"。
② 但它依然有意义:
保留"检测死亡"的能力——这正是弱引用的核心价值:对比悬垂裸指针(对象死后访问是 UB,可能崩溃或读到被复用的垃圾数据),weak_ptr 在对象死后
lock()只是安全地返回空,expired()能明确确认对象已死。"不悬垂地检测悬垂"——强计数归零后lock()返回空不是 bug,而是它被设计出来的理由。可以复用:weak_ptr 本身是普通对象,
reset()或重新赋值后可指向新对象继续观察:cppstd::weak_ptr<T> w = p; // 观察对象 A p.reset(); // A 死亡,w 变为 expired w = std::make_shared<T>(); // w 重新观察新对象,继续工作并发场景下仍是共享观测点:另一个线程可能正在对它
lock()——强计数为 0 时 CAS 失败返回空,这正是线程安全地发现"对象刚死"的机制(见 §4.1 的 CAS 实现)。
③ 唯一代价:只要 weak_ptr 还活着,控制块就不会释放(weak_count > 0)。确认对象已死、且不再需要监测时,应尽快销毁或 reset() 该 weak_ptr,否则控制块会长期占用堆内存(见 §4.2 的释放时机)。
一句话:weak_ptr 的价值不在对象死后,而在"对象将死未死"之时——非拥有地观察 + 安全地发现死亡。对象已死后它退化为一个"死亡探测器"(
expired() == true),且可复用,但确实不再指向任何活对象。
5. 智能指针选型决策
需要管理所有权?── 否 ──→ 裸指针 / 引用
│
└─ 是 ──→ 独占所有权?── 是 ──→ unique_ptr
│
└─ 否 ──→ 共享所有权?── 是 ──→ 可能出现循环引用?
│
├─ 是 ──→ shared_ptr + weak_ptr
└─ 否 ──→ shared_ptr6. enable_shared_from_this(底层原理)
Q: 为什么不能把 this 直接塞进 shared_ptr?enable_shared_from_this 是怎么工作的?
先看错误做法:
cpp
class Foo {
public:
std::shared_ptr<Foo> getSelf() {
return std::shared_ptr<Foo>(this); // ❌ 灾难
}
};
auto sp = std::make_shared<Foo>(); // 控制块 A
auto self = sp->getSelf(); // 用裸 this 构造 → 控制块 B
// 现在同一对象有两个独立控制块、两套独立计数
// 两个控制块各自归零时都会 delete 对象 → double free!为什么这里一定出错?——与前面 §3"不要用同一个裸指针构造多个 shared_ptr"同源:
这里的 this 和 §3 的 raw 本质都是裸指针。shared_ptr 构造函数拿到的只有地址,无法反查这个地址是否已被某个控制块管理——对象和控制块之间没有反向链接,"已被管理"这个信息不在对象身上。所以每次用裸指针构造,唯一的选择就是 new 一个新控制块:
- 控制块是"按构造次数"创建的,不是"按对象"创建的
- 两套独立计数各自从 1 开始、互不知情 → 各自归零时都执行
delete→ double free - §3 的
raw和这里的this是同一个坑的两种表现:外部裸指针 vs 内部裸指针
正确做法——继承 enable_shared_from_this:
cpp
class Foo : public std::enable_shared_from_this<Foo> {
public:
std::shared_ptr<Foo> getSelf() { return shared_from_this(); }
};
auto sp = std::make_shared<Foo>();
auto self = sp->getSelf(); // ✅ 与 sp 共享同一控制块,计数 +1注意:
self拿到的是 shared_ptr(不是 weak_ptr)——shared_from_this()返回类型就是shared_ptr<T>。那内部成员为什么用weak_ptr而不是shared_ptr?如果内部存shared_ptr,对象就强引用自己 → 强计数永远 ≥1 → 永远不会归零 → 自我循环引用,泄漏。weak_ptr 平时只"登记"控制块、不干预对象生死,调用时才lock()临时提升。
底层原理(三步):
cpp
// 简化版实现
template<typename T>
class enable_shared_from_this {
mutable std::weak_ptr<T> weak_this_; // ① 内部藏着一个 weak_ptr 成员
protected:
enable_shared_from_this() = default;
public:
std::shared_ptr<T> shared_from_this() { return weak_this_.lock(); } // ③ 提升
// ② shared_ptr 构造时检测到 T 继承自本类,会调用:
// weak_this_ = 自己(与当前 shared_ptr 共享同一控制块)
};| 步骤 | 谁在做 | 干什么 |
|---|---|---|
| ① | 继承机制 | 类内部隐式多了一个 weak_ptr<T> 成员(空基类优化后零成本) |
| ② | shared_ptr<T> 构造时 | 检测到 T 继承自 enable_shared_from_this,把内部 weak_ptr 初始化为当前控制块 |
| ③ | shared_from_this() 调用 | weak_this_.lock() 提升 → 与现有 shared_ptr 共享同一控制块 |
为什么这样一定安全:
- 走的是"现有控制块"的 lock 提升 → 永远不会创建第二个控制块
- 对象活着 → lock 成功;对象死了 → lock 返回空(
shared_from_this在对象未被管理时调用会抛std::bad_weak_ptr)
经典陷阱:构造函数里不能调用 shared_from_this():
cpp
class Foo : public std::enable_shared_from_this<Foo> {
public:
Foo() { auto sp = shared_from_this(); } // ❌ 抛 bad_weak_ptr(C++17 前是 UB)
};原因:构造时 shared_ptr<Foo> 还没构造完成,内部 weak_this_ 尚未被注入(上表步骤 ② 没执行)——等价于"未被管理的对象调用"。
一句话:
shared_from_this的本质是"从控制块反查自己"——类里藏一个 weak_ptr,shared_ptr 构造时注入自己的控制块,要用时 lock 提升。直接shared_ptr(this)则会 new 出第二个控制块 → double free。返回的是 shared_ptr;内部必须用 weak_ptr,否则对象自我强引用、永不释放。
不能直接把 this 塞进 shared_ptr,因为 this 只是裸指针——shared_ptr 构造时从裸指针上无法得知这个对象是否已被管理(对象与控制块之间没有反向链接),所以每次用裸指针构造都会 new 一个全新控制块、计数从 1 重新开始;而对象通常已经有一个控制块(比如被 make_shared 管理),于是同一对象出现两套互不知情的独立计数,各自归零时都会 delete 一次 → double free。这和前面"不要用同一个裸指针构造多个 shared_ptr"是同一个坑:控制块按构造次数创建,不按对象创建。正确做法是继承 enable_shared_from_this:对象内部藏一个 weak_ptr,shared_ptr 构造时把当前控制块注入进去,需要 self 时调用 shared_from_this() 从控制块 lock() 提升——永远复用已有控制块、绝不新建;内部用 weak_ptr 还避免了对象自我强引用、永不释放。一句话概括:shared_ptr(this) 是"绕过账本另记一笔账",shared_from_this() 是"从现有账本查自己"。
五、移动语义与右值引用(C++11)
1. 左值 vs 右值 vs 将亡值
Q: 什么是左值、右值?右值引用怎么理解?
左值(lvalue):可以取地址、有具体名字的表达式——如变量 int a; a、解引用 *p、a[0]。生命周期持续到作用域结束,可以出现在 = 左边。
右值(rvalue):无法取地址的临时对象/字面量——如 42、a + b、std::string("hello")。生命周期在表达式结束就销毁,不能出现在 = 左边(C++11 后可被右值引用绑定)。
**右值引用(T&&)是 C++11 引入的,用来绑定"即将销毁的临时对象"**的引用,它是移动语义和完美转发的基础。如:int&& r = 5;
cpp
int a = 10;
int b = 20;
a; // 左值
a + b; // 右值(临时结果)
42; // 右值(字面量)
int& ref = a; // 左值引用,绑定左值
int&& rref = 42; // 右值引用,绑定右值
// 有名右值引用本身是左值!
int&& rref = 42;
int& ref = rref; // ✅ rref 有名字,是左值将亡值 (xvalue, C++11 引入):即将被销毁的值,如 std::move(x) 的返回值。
右值不是原子概念:右值 = 纯右值 (prvalue) + 将亡值 (xvalue),区别在有没有身份:
- 纯右值 (prvalue):真正新建的临时对象/字面量,无身份(无法取地址),表达式结束就销毁——如
42、a + b、std::string("hello") - 将亡值 (xvalue):有身份的真实对象被标记为"可移动"——如
std::move(x)的返回值。std::move只是static_cast<T&&>(x),什么都没搬:对象还在、能取地址,只是被标记为可移动,从而触发移动而非拷贝
一句话:将亡值 = 有身份(真实存在的对象)但被标记为可移动的右值;纯右值 = 没身份的临时对象。
std::move(x)什么都没搬,只是让对象"看起来快死了"。
2. 移动构造 / 移动赋值
Q: 移动语义解决了什么问题?为什么能提升性能?
解决了什么问题:C++没有移动语义时,函数返回/传参临时对象、push_back 临时对象,编译器只能深拷贝(O(N)),而临时对象用一次就销毁,等于"复制一份、立刻扔一份",白白浪费"分配 + 拷贝 + 释放"。对持有堆资源的类型(string、vector)代价尤其大。
为什么能提升性能:C++11 引入右值引用 T&&,让编译器能区分"左值(后面还要用)"和"右值(马上销毁)"。对右值调用移动构造——不复制内容,只搬运所有权:把内部指针"偷"过来(O(1)),原对象置空。资源自始至终只有一份,省掉深拷贝整份数据的开销。
拷贝: 分配新内存 → 逐字节复制(O(N))→ 原对象不变
移动: 不分配、不复制,指针换手(O(1))→ 原对象置空核心思想:"窃取"资源而非"复制"——把临时对象的内部指针"偷"过来,原对象置空。
cpp
// move移动语义的具体实现
class MyString {
char* data;
size_t len;
public:
// 移动构造
MyString(MyString&& other) noexcept
: data(other.data), len(other.len)
{
other.data = nullptr; // 将原对象置为有效但未指定状态
other.len = 0;
}
// 移动赋值
MyString& operator=(MyString&& other) noexcept {
if (this != &other) {
delete[] data; // 释放旧资源
data = other.data; // 窃取
len = other.len;
other.data = nullptr; // 置空
other.len = 0;
}
return *this;
}
~MyString() { delete[] data; }
};| 拷贝 | 移动 | |
|---|---|---|
| 代价 | O(N) 深拷贝 | O(1) 指针交换 |
| 原对象状态 | 不变 | 资源被"窃取",变为"有效但未指定状态" |
| 适用对象 | const 左值 | 临时对象(右值) |
2.1 为什么移动操作要加 noexcept?(高频)
noexcept 是 C++11 引入的异常说明符——告诉编译器"这个函数保证不抛异常"。
Q: 移动构造/移动赋值为什么要 noexcept?vector 扩容时会怎样?
std::vector 扩容时,需要把旧内存的元素搬到新内存。标准规定:只有移动构造被标记 noexcept 时,容器才敢用移动;否则退化为拷贝——因为移动搬走一半时若抛异常,元素处于半毁状态,容器无法回滚恢复原状。
cpp
struct Good {
std::string s;
Good(Good&&) noexcept = default; // ✅ 显式 noexcept:vector 扩容用移动
};
struct Bad {
std::string s;
Bad(Bad&&) = default; // ❌ 未标注:vector 扩容退化为拷贝!
};| 移动操作 | 是否 noexcept | vector 扩容行为 |
|---|---|---|
| 声明了 noexcept | ✅ | 移动:O(1) 指针搬运 |
| 未声明 | ❌ | 拷贝:O(N) 深拷贝(为强异常保证) |
为什么必须 noexcept:扩容的强异常保证要求"要么全部成功、要么全部保持原状"。移动构造若抛异常,旧元素已被搬走一半,无法回滚;拷贝则可以先拷贝完再销毁旧的,异常安全。所以标准库用
std::is_nothrow_move_constructible判断。
经验:所有移动构造/移动赋值都应写
noexcept(标准库的 string/vector/智能指针的移动全部标了 noexcept)。
移动语义的典型受益场景:
cpp
// 例如STL里的string,它内部就是实现了移动语义;但对于自创的类,需要手动实现,如上
std::vector<std::string> v;
v.push_back("A very very very long string..."); // 利用了移动语义,自动移动临时对象
// 如果没有移动语义,每次 push_back 临时对象都是深拷贝
// 扩容时也受益:
// 旧元素移动到新内存,而非深拷贝
// 但是push_back和emplace_back本质是不同的
// push_back:传对象 ,构造临时对象 + 移动/拷贝
// emplace_back:传构造函数所需的参数,直接在容器内存中构造3. std::move 和 std::forward
Q: std::move 做了什么?它和 std::forward 有什么区别?(高频)
std::move | std::forward<T> | |
|---|---|---|
| 作用 | 无条件将左值强制转为右值引用 | 根据 T 类型有条件转发(左值→左值,右值→右值) |
| 场景 | 明确要转移所有权 | 完美转发(模板中转发参数) |
| 本质 | static_cast<T&&>(x) | 条件性的 static_cast |
cpp
// std::move 实现
// move 先用 remove_reference 把类型剥得精光(变成原始类型),然后强行在后面贴上两个 &&。
template<typename T>
typename std::remove_reference<T>::type&& move(T&& x) noexcept // (type后面的&&是指返回类型,&&右值)
{
// 1. T&& 是“万能引用”:
// - 如果传入左值 int a,T 变成 int&,x 变成 int&
// - 如果传入右值 10,T 变成 int,x 变成 int&&
// 2. std::remove_reference<T>::type
// - 它的作用是去掉 T 里面的所有 &。
// - 无论 T 是 int, int& 还是 int&&,结果都是 int。
// 3. static_cast<...&&>(x):
// - 这一步把 x 强制转换成 int&&。
return static_cast<typename std::remove_reference<T>::type&&>(x);
}
// std::forward 实现(简化)
template<typename T>
T&& forward(std::remove_reference_t<T>& x) noexcept
{
// 1. 注意返回类型是 T&& 万能引用
// 2. 利用引用折叠规则:
// 情况 A:外层传入的是【左值】
// 此时 T 被推导为 int&
// 返回类型 T&& 变成 int& &&,折叠后还是 int&
// 结果:依然是左值引用,没变。
// 情况 B:外层传入的是【右值】
// 此时 T 被推导为 int(或者 int&&)
// 返回类型 T&& 变成 int&&
// 结果:成功恢复为右值引用!
return static_cast<T&&>(x);
}完美转发 = 参数性质不变地转发:
cpp
template<typename T, typename Arg>
std::unique_ptr<T> factory(Arg&& arg) {
return std::unique_ptr<T>(new T(std::forward<Arg>(arg)));
// 如果 arg 是左值传入 → 拷贝构造 T
// 如果 arg 是右值传入 → 移动构造 T
}引用折叠规则:
外层 T | 实参类型 | 折叠结果 | 含义 |
|---|---|---|---|
T& | & | & & → & | 左值引用 |
T& | && | & && → & | 左值引用 |
T&& | & | && & → & | 左值引用 |
T&& | && | && && → && | 右值引用 |
完美转发返回类型是T&&,它可以根据传入类型完全返回
但是move返回类型是std::remove_reference<T>::type&&,它不直接把 T 丢进折叠规则,而是先通过 remove_reference 强行把 T 里的引用去掉,变成纯粹的 int,
4. =default 和 =delete(C++11)
C++11 引入了两个新的函数定义语法,让程序员能精确控制编译器何时生成、何时禁用特殊成员函数。
4.1 编译器自动生成规则("Rule of Five" 编译器视角)
这是 C++ 最复杂也最重要的隐式规则之一。下面以表格呈现"你写了一个 → 编译器就不再自动生成什么":
| 你显式定义了 | 默认构造 | 拷贝构造 | 拷贝赋值 | 移动构造 | 移动赋值 | 析构函数 |
|---|---|---|---|---|---|---|
| 什么都不写 | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| 任意构造函数 | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
| 析构函数 | ✅ | ✅ | ✅ | ❌ (deprecated) | ❌ (deprecated) | 自己写 |
| 拷贝构造 | ❌ | 自己写 | ✅ | ❌ | ❌ | ✅ |
| 拷贝赋值 | ✅ | ✅ | 自己写 | ❌ | ❌ | ✅ |
| 移动构造 | ❌ | ❌ | ❌ | 自己写 | ❌ | ✅ |
| 移动赋值 | ✅ | ❌ | ❌ | ❌ | 自己写 | ✅ |
写了拷贝,移动就没了;写了移动,拷贝就没了;写了析构,默认构造还在,但移动被废弃(C++11 deprecated,不要依赖)。
实际影响示例:
cpp
class A {
public:
virtual ~A() = default; // 自定义析构 → 移动函数不会自动生成!
// 此时 A 没有移动构造和移动赋值
};
A a1;
A a2 = std::move(a1); // ⚠️ 没有移动构造 → 退化为拷贝构造(静默降级!)
class B {
public:
virtual ~B() = default;
B(B&&) = default; // 显式要回移动构造
B& operator=(B&&) = default; // 显式要回移动赋值
};4.2 项目中的实际应用总结
| 项目 | 使用方式 | 目的 |
|---|---|---|
| 线程池 | ThreadPool 四连 = delete | 禁止拷贝+移动,防止线程/锁/条件变量双析 |
| 线程池 | Result 禁用拷贝,允许移动 | 数据所有权唯一,但支持 get() 中转移 Any |
| 内存池 | 单例类 = delete 拷贝+移动 | 全局唯一实例,禁止复制 |
| 通用 | 基类 virtual ~Base() = default | 明确析构语义,同时保留 Trivial 可能 |
六、Lambda 表达式(C++11)
1. 基础语法
Q: Lambda 的基本语法和捕获列表怎么用?(高频)
cpp
// 完整语法
[捕获列表](参数列表) mutable -> 返回类型 { 函数体 }
// 简化(省略 mutable 和返回类型)
[capture](params) { body }
// 最简
[]{ std::cout << "Hello"; }捕获列表(核心):
| 写法 | 含义 | 说明 |
|---|---|---|
[] | 不捕获任何外部变量 | 只能访问参数和静态变量 |
[=] | 值捕获所有外部变量 | 捕获的是副本 |
[&] | 引用捕获所有外部变量 | 确保 Lambda 执行时变量还活着 |
[x] | 值捕获 x | 只捕获 x |
[&x] | 引用捕获 x | 只引用捕获 x |
[this] | 捕获当前对象的 this 指针 | 可访问类成员 |
[*this](C++17) | 捕获 *this 的副本 | 异步场景安全 |
[=, &x] | 默认值捕获,x 引用捕获 | 混合捕获 |
[&, x] | 默认引用捕获,x 值捕获 | 混合捕获 |
cpp
int a = 1, b = 2;
auto f1 = [=] { return a + b; }; // 值捕获,f1() = 3
auto f2 = [&] { a++; b++; }; // 引用捕获,修改外部变量
auto f3 = [a, &b] { return a + b; }; // a 值捕获(副本),b 引用捕获
a = 100; b = 200;
f1(); // 3(捕获时的副本值)
f2(); // 修改外部的 a 和 b
f3(); // 1 + 200(a 是旧的副本值, b 是引用)陷阱:值捕获 + 指针:
cpp
int* p = new int(42);
auto f = [=] { delete p; }; // p 是值捕获的——但只捕获了指针值
// 外部 p 和 Lambda 内的 p 指向同一块内存!值捕获的是变量值,但如果变量是指针,捕获的是指针值而不是指针指向的内容。
陷阱:[=] 捕获"成员变量",实际捕获的是 this(高频):
cpp
class Widget {
int value_ = 42;
public:
auto getLambda() {
return [=] { return value_; }; // 你以为捕获了 value_ 的副本?
// 实际等价于 [this] { return this->value_; } —— 捕获的是 this 指针!
}
};
Widget* w = new Widget();
auto f = w->getLambda();
delete w;
f(); // ❌ this 已悬垂,访问 value_ 是 UB("值捕获"并没有真的捕获值)本质:
[=]捕获的成员变量是通过this访问的,所以捕获的是 this 指针而不是成员副本。修复方案:C++17[*this]真正按值捕获整个对象,或显式[this]并保证对象存活。
2. mutable 关键字
Q: Lambda 的 mutable 有什么用?
默认情况下,Lambda 的 operator() 是 const,值捕获的变量不可修改。加 mutable 移除 const。
cpp
int a = 42;
auto f1 = [a] { a++; }; // ❌ 编译错误:a 是只读的
auto f2 = [a]() mutable { a++; return a; }; // ✅ 可以修改副本
f2(); // 43
f2(); // 44(改了 Lambda 内部保存的副本)
std::cout << a; // 42(外部不受影响)3. 泛型 Lambda(C++14)
cpp
// 参数类型用 auto
auto add = [](auto a, auto b) { return a + b; };
add(1, 2); // int + int
add(1.5, 2.5); // double + double
add(std::string("Hello "), std::string("World")); // string + string
// C++20 还可以显式模板参数
auto lambda = []<typename T>(std::vector<T> v) { ... };4. Lambda 底层原理
Q: Lambda 的底层是怎么实现的?
编译器将 Lambda 展开为带有 operator() 的匿名类:
cpp
// Lambda 写法
int m = 10;
auto f = [m](int x) { return m + x; };
// 编译器展开(等价)
class __AnonymousLambda {
int m; // 值捕获的成员变量
public:
__AnonymousLambda(int val) : m(val) {}
auto operator()(int x) const { return m + x; }
};
__AnonymousLambda f(m);无捕获的 Lambda 可转为函数指针:
cpp
auto f = [](int x) { return x * 2; };
int (*fp)(int) = f; // ✅ 无捕获时可转为函数指针七、可变参数模板(C++11)
Q: 可变参数模板是什么?如何展开参数包?
允许模板接收任意数量、任意类型的参数。
cpp
// 递归展开(基础情形)
template<typename T>
T sum(T t) { return t; }
// 递归展开(展开一个,递归处理剩余)
template<typename T, typename... Args>
T sum(T first, Args... rest) {
return first + sum(rest...);
}
sum(1, 2, 3, 4, 5); // 返回 15C++17 折叠表达式(更简洁):
| 折叠方式 | 表达式 | 展开结果 |
|---|---|---|
| 一元左折 | (... + args) | ((x1 + x2) + x3) + x4 |
| 一元右折 | (args + ...) | x1 + (x2 + (x3 + x4)) |
| 二元左折 | (0 + ... + args) | (((0 + x1) + x2) + x3) + x4 |
| 二元右折 | (args + ... + 0) | x1 + (x2 + (x3 + (x4 + 0))) |
cpp
template<typename... Args>
auto sum(Args... args) {
return (args + ...); // C++17 折叠表达式
}
template<typename... Args>
auto sum0(Args... args) {
return (args + ... + 0); // 支持空参数包
}参数包语法三要素(手写的基础):
| 语法 | 含义 |
|---|---|
template<typename... Args> | 模板参数包——任意数量的类型 |
Args... args | 函数参数包——与类型一一对应的参数列表 |
args... / Args... | 包展开——在展开位置把整个包"摊开" |
sizeof...(Args)获取参数个数(编译期常量)- 参数包只能整体展开,不能直接取出第 N 个——想访问单个参数只能靠递归逐层剥离(这就是为什么必须有"基础情形"收尾)
- 空参数包合法;递归展开时若没有基础情形,编译会无限递归报错
非表达式场景的展开技巧(逗号折叠):折叠表达式只能产生"一个值";当需要对每个参数执行一条语句时(如逐个打印),用 initializer_list + 逗号表达式:
cpp
template<typename... Args>
void print_all(Args... args) {
// 包展开成逗号表达式序列:{ (cout<<a<<" ",0), (cout<<b<<" ",0), ... }
std::initializer_list<int>{ (std::cout << args << " ", 0)... };
}与完美转发结合(emplace_back 的底层形态,手撕):
cpp
template<typename... Args>
void emplace_back(Args&&... args) { // 万能引用包
::new (ptr_) T(std::forward<Args>(args)...); // 包展开 + 逐个完美转发
}核心应用:emplace_back、make_shared、make_unique 等 STL 函数都是可变参数模板 + 完美转发的产物。
八、std::function 和 std::bind(C++11)
1. std::function
Q: std::function 解决了什么问题?
统一的"可调用对象"包装器——可存储函数、Lambda、仿函数、成员函数等。
cpp
#include <functional>
std::function<int(int, int)> func;
// 可接收:函数、Lambda、仿函数、函数对象
func = [](int a, int b) { return a + b; }; // Lambda
func = std::plus<int>{}; // 仿函数
// 存储成员函数
struct Foo {
int bar(int x) { return x * 2; }
};
std::function<int(Foo&, int)> memfn = &Foo::bar;开销:
std::function使用类型擦除 + 小对象优化,小型可调用对象存在内部缓冲区,大型对象可能堆分配。有虚函数调用的开销(一次间接跳转)。
类型擦除的底层原理(为什么有间接调用):
cpp
// std::function 的简化实现骨架
class function_int {
struct CallableBase { // 抽象基类:统一接口
virtual int operator()(int) const = 0;
};
template<class F> // 模板派生类:塞进统一接口
struct Callable final : CallableBase {
F f;
int operator()(int x) const override { return f(x); }
};
CallableBase* impl_; // 调用必须经虚表 → 间接跳转
public:
template<class F> function_int(F f) : impl_(new Callable<F>(std::move(f))) {}
int operator()(int x) const { return (*impl_)(x); }
};开销清单(回答要点):
| 开销 | 原因 |
|---|---|
| 间接调用 | 运行时经虚表跳转 → 无法内联(热路径性能损失) |
| 可能堆分配 | 可调用对象超过 SBO 缓冲(通常 16~32 字节)时 new |
| 拷贝较贵 | 复制整个包装器;move-only 类型(如捕获 move-only 对象的 Lambda)无法直接存储 |
| 无比较/哈希 | 两个 function 不能 == 比较 |
一句话:
std::function用"抽象基类 + 模板派生类 + 小对象优化"把任意可调用对象装进统一接口;代价是间接调用(无法内联)+ 可能堆分配。性能敏感的热路径用模板参数或裸函数指针替代。
空 std::function 调用 → 抛出 std::bad_function_call 异常(使用时先判空或 try-catch)。
2. std::bind
Q: std::bind 的用法和占位符?
部分应用——预先绑定部分参数,生成新的可调用对象。
cpp
#include <functional>
using namespace std::placeholders; // _1, _2, ...
int sub(int a, int b) { return a - b; }
auto dec = std::bind(sub, _1, 1); // dec(x) = x - 1
auto neg = std::bind(sub, 0, _1); // neg(x) = 0 - x = -x
dec(10); // 9
neg(5); // -5C++14 / C++17 起,Lambda 通常比
bind更直观、更推荐:"能用 Lambda 就不用 bind"。
bind 的传参语义(高频追问):
- 已绑定的实参按值存储(拷贝一份)——想按引用传参必须显式
std::ref(x) - 占位符
_1, _2, ...对应调用时传入的实参,位置可任意排布
cpp
void show(int a, int b, int c) { /* ... */ }
int x = 10;
auto f = std::bind(show, std::ref(x), _2, _1);
f(1, 2); // 等价于 show(x, 2, 1):_1 取第 1 个实参 1,_2 取第 2 个实参 2bind vs Lambda 如何选择:
| 对比 | std::bind | Lambda |
|---|---|---|
| 可读性 | 占位符晦涩,重排参数难读 | 直观清晰(C++14 泛型 Lambda 更通用) |
| 捕获方式 | 按值存储,引用需 std::ref | [&] / [=] / [x] 天然支持 |
| 性能 | 多层包装,难内联 | 编译器直接生成类,内联更好 |
| 结论 | 老代码 / 绑 this 传线程 | 现代 C++ 首选 |
唯一保留 bind 的常见场景:需把
this+ 成员函数延迟绑定成普通可调用对象传给线程/回调(如上线程池实战),此时 Lambda 需捕获this后自己转成员调用,bind 更省事。
实战场景:绑定成员函数 + this 传给线程(线程池项目)
在线程池中,ThreadFunc 是 ThreadPool 的非静态成员函数,它隐含 this 参数。要把它传给 std::thread,必须先用 bind 把 this "填进去":
cpp
// ThreadPool 中启动线程
void ThreadPool::start(int threadCount) {
for (int i = 0; i < threadCount; i++) {
// threadFunc 是成员函数:void ThreadPool::threadFunc(int threadId)
// bind 将 this 与成员函数绑定 → 变成 void(int) 的可调用对象
auto func = std::bind(&ThreadPool::threadFunc, this, std::placeholders::_1);
threads_.emplace_back(std::make_unique<Thread>(func));
}
}设计考量:
threadFunc定义在ThreadPool中而非Thread中,是为了职责解耦——Thread只管"创建线程并运行一个函数",不关心任务队列在哪。bind在这里充当了胶水层。
九、constexpr(编译期计算,C++11 起逐步增强)
Q: constexpr 和 const 的区别?constexpr 能做哪些事?(高频)
const | constexpr | |
|---|---|---|
| 含义 | 运行期不可修改 | 编译期就能确定值 |
| 初始化 | 可在运行期初始化 | 必须在编译期初始化 |
| 函数 | 无 | 可在编译期执行(传入编译期参数时) |
| 变量位置 | 可在只读数据段 | 可在只读数据段或代码段 |
cpp
// constexpr 变量:编译期常量
constexpr int N = 100;
int arr[N]; // ✅ N 是编译期常量,数组大小合法
const int X = get_runtime_value(); // ✅ 运行期初始化的 const
// constexpr int Y = get_runtime_value(); // ❌ 运行时函数,不能编译期求值
int arr2[X]; // ❌ 不是标准 C++(VLA 是编译器扩展)
// constexpr 函数(C++11:只能一条 return)
constexpr int square(int x) { return x * x; }
static_assert(square(5) == 25); // 编译期断言
// C++14:constexpr 函数内可以有分支、循环
constexpr int factorial(int n) {
int result = 1;
for (int i = 2; i <= n; ++i) result *= i;
return result;
}
// C++17:constexpr lambda
auto f = [](int x) constexpr { return x * x; };
// C++20:constexpr vector、string!
constexpr std::vector<int> v = {1, 2, 3};constexpr 的好处:
- 编译期计算 → 运行时零开销
- 类型安全 的编译期常量(替代宏)
- 配合
static_assert做编译期断言
容易混淆的关键点(追问):
const int C = 42;用常量表达式初始化时,C 同样可用于数组大小等编译期场景——const是"只读"承诺,constexpr是"编译期可求值"承诺;区别在保证:constexpr 不满足编译期求值就直接编译错误,const 宽松得多constexpr函数传入运行期参数时,调用完全合法、退化为普通函数——"编译期执行"只在所有实参都是编译期常量时发生- 判断变量能否用于编译期场景,看它是否是常量表达式(constexpr 变量 ✓;const 变量需满足"常量表达式初始化 + 非 volatile")
十、其他 C++11 重要特性
1. enum class —— 强类型枚举
Q: enum class 和传统 enum 的区别?(高频)
传统 enum | enum class(C++11) | |
|---|---|---|
| 作用域 | 枚举值泄漏到外层作用域 | 枚举值属于枚举类型,必须 State::OK 访问 |
| 隐式转换 | 可隐式转 int | 禁止,必须 static_cast<int> |
| 底层类型 | 编译器自选 | 可指定 : uint8_t |
cpp
enum Color { RED, GREEN }; // RED 污染外层作用域
enum Size { BIG }; // 若也有 RED 则命名冲突!
enum class State : uint8_t { OK, ERROR }; // 指定底层类型
State s = State::OK;
// int n = s; // ❌ 不能隐式转换
int n = static_cast<int>(s); // ✅ 显式转换要点:避免作用域污染 + 防止隐式转换 bug,现代 C++ 首选。
补充考点:
- 前置声明:传统
enum不能前置声明(底层类型由编译器自选、大小未知);enum class E : uint8_t;指定底层类型后可以前置声明,减少头文件耦合——这是底层类型选项最重要的实用意义 - 位运算:传统
enum可直接A | B(隐式转 int 后运算);enum class禁止隐式转换,位运算需static_cast<int>后做,或自己重载operator| - 取值:
static_cast<int>(s);C++23 提供std::to_underlying - 遍历:
enum class无自增/算术运算,不能++e遍历;常用std::array存全部值配合遍历
2. 统一初始化 / initializer_list
Q: 花括号初始化解决了什么问题?什么是 most vexing parse?
cpp
int a{42}; // 统一初始化
std::vector<int> v{1, 2, 3}; // initializer_list 构造
// 解决的问题 1:most vexing parse(最令人烦恼的解析)
Widget w(); // ❌ 这是声明了一个返回 Widget 的函数!不是对象
Widget w{}; // ✅ 明确是对象
// 解决的问题 2:禁止窄化转换
int x = 3.14; // 静默截断(可能只有警告)
int y{3.14}; // ❌ 编译错误:窄化转换被禁止
// 陷阱:{} vs () 构造差异
std::vector<int> v1(10, 5); // 10 个 5
std::vector<int> v2{10, 5}; // {10, 5} 两个元素!要点:
{}优先匹配 initializer_list 构造函数——vector(10,5)和vector{10,5}语义完全不同。
initializer_list 的本质:std::initializer_list<T> 内部就是一块 const T 数组 + begin/end 两个指针,元素位于只读区(不可修改),生命周期与花括号表达式一致。
{} 空列表与优先匹配陷阱(高频):
cpp
std::vector<int> v1{}; // 空 vector —— 空花括号 {} 特例:优先走默认构造
std::vector<int> v2{0}; // 1 个元素:{0}
std::vector<int> v3{0, 0}; // 2 个元素
std::vector<int> v4(0); // 空 vector(0 个元素,size 构造)- 类同时存在 initializer_list 构造和普通构造时,花括号永远优先 initializer_list(仅当元素类型不匹配时才 fallback 到普通构造)
聚合初始化:无自定义构造函数的 struct/数组可以直接 {} 按成员顺序初始化:
cpp
struct Point { int x, y; };
Point p{1, 2}; // 聚合初始化,按声明顺序
std::array<int, 3> a{1, 2, 3}; // C++11 之前 std::array 无法这样初始化一句话:
{}解决了 most vexing parse + 禁止窄化转换;代价是 initializer_list 构造优先——vector(10,5)是 10 个 5,vector{10,5}是 2 个元素。
十一、并发支持(C++11 引入,后续版本增强)
1. std::thread
cpp
#include <thread>
void worker(int id) { /* ... */ }
std::thread t1(worker, 1); // 传递函数 + 参数
std::thread t2([] { /* ... */ }); // Lambda
std::thread t3(&Foo::bar, &obj); // 成员函数
t1.join(); // 阻塞等待线程结束,回收资源
t2.detach(); // 分离,线程转入后台独立运行,脱离管控
std::thread::hardware_concurrency(); // 获取硬件并发数务必注意:
thread对象在析构前必须调用.join()或.detach(),否则std::terminate!
为什么不 join 会 terminate?
std::thread 析构时,如果线程还处于 joinable(既没 join 也没 detach)状态,析构函数直接调用 std::terminate() 终止程序。
原因:
析构时线程仍 joinable(即既没调 join() 也没调 detach())就会 terminate——标准库无法安全处置:
标准库如果隐式 join(): 主线程会阻塞等待,主线程与子线程共享资源可能造成死锁
标准库如果隐式 detach():子线程可能还在访问已销毁的资源
既然两种选择都可能出错,标准直接终止程序。
另外 join() 只能调用一次。
实战场景:线程池中线程的创建与生命周期管理
在线程池项目中,线程的创建、启动和销毁遵循明确的生命周期:
cpp
// 1. 创建线程池 → 初始化(不启动线程)
ThreadPool pool;
pool.setMode(PoolMode::MODE_CACHED);
// 2. start() → 批量创建 std::thread,分两阶段:
void ThreadPool::start(int threadCount) {
// 阶段一:先创建所有 Thread 对象(稳定内存)
for (int i = 0; i < threadCount; i++) {
threads_.emplace_back(i, std::make_unique<Thread>(...));
}
// 阶段二:再逐个启动线程(此时所有对象已就绪,避免竞态)
for (auto& [id, t] : threads_) {
t->start(); // 内部调用 std::thread 构造 + detach 或 joinable 管理
}
}
// 3. 析构时 → 逐个 join,等待所有工作线程退出
~ThreadPool() {
for (auto& [id, t] : threads_) {
t->join(); // 确保每个线程正常退出后再销毁资源
}
}设计要点:
- 为什么析构用
join而非detach?detach后线程脱离管控,若线程还在访问已析构的任务队列等成员,会崩溃。join保证安全退出。
2. std::mutex 与锁
cpp
#include <mutex>
std::mutex mtx;
int shared = 0;
// RAII 锁(推荐)
void safe_increment() {
std::lock_guard<std::mutex> lock(mtx); // C++11 构造加锁,析构解锁
shared++;
}
// 更灵活的锁(支持手动 unlock / 尝试锁 / 延迟锁)
void flexible() {
std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
if (lock.try_lock()) {
// 获取到了锁
}
}
// C++17:scoped_lock 可同时锁多个 mutex(防死锁)
std::mutex m1, m2;
std::scoped_lock lock(m1, m2); // 原子地锁两个| 锁类型 | 版本 | 特点 |
|---|---|---|
lock_guard | C++11 | 最简单的 RAII 锁,不可手动 unlock |
unique_lock | C++11 | 可手动 unlock、延迟锁、try_lock,可与 condition_variable 搭配 |
scoped_lock | C++17 | 可同时锁多个 mutex(防死锁) |
shared_lock | C++14 | 共享读锁,配合 shared_mutex(C++17)实现读写锁 |
2.0 三种锁详解
lock_guard —— 最简单、最快
最轻量级的包装器,没有任何多余功能:构造时加锁,析构时解锁。
- 不可手动解锁:一旦锁定,必须等到生命周期结束(出作用域)
- 不可复制、不可移动
- 性能最高:没有任何内部状态维护的开销
- 适用场景:绝大多数简单场景——只想保护一段简单的代码,用它
cpp
{
std::lock_guard<std::mutex> lock(mtx);
// 执行一些受保护的操作
} // 出作用域自动解锁unique_lock —— 最灵活、功能最强
lock_guard 的增强版,支持更多操作,但性能略微逊色(它需要记录当前锁的状态)。
- 可手动解锁/再加锁:支持
.lock()/.unlock() - 延迟加锁:构造时传
std::defer_lock,先不锁,后面手动锁 - 支持移动:锁的所有权可以从一个函数转移到另一个函数
- 配合条件变量:使用
std::condition_variable时必须配合unique_lock - 适用场景:需要提前解锁 / 条件变量等待 /
try_lock或带超时的try_lock_for
cpp
std::unique_lock<std::mutex> lock(mtx);
// 做一些事...
lock.unlock(); // 手动解锁
// 做一些不需要锁的事...
lock.lock(); // 再次锁定shared_lock —— 读写锁中的"读"锁
C++14 引入,专门配合 std::shared_mutex(C++17)使用,实现**"多读单写"**模型。
- 共享锁定:多个线程可以同时持有一个
shared_lock指向同一个互斥量(大家都读,不冲突) - 互斥性:一旦有一个线程拿到排他锁(通过
unique_lock或lock_guard),所有shared_lock都会被阻塞 - 适用场景:读多写少——数据经常被读取但很少被修改,能极大提高并发性能
cpp
std::shared_mutex smtx;
// 读者线程
void reader() {
std::shared_lock<std::shared_mutex> lock(smtx); // 多个线程可以同时进到这里
// 读取数据...
}
// 写者线程
void writer() {
std::lock_guard<std::shared_mutex> lock(smtx); // 只能有一个写者,且不能与读者同时存在
// 修改数据...
}选型一句话:简单保护用
lock_guard(最快);需要手动解锁/条件变量用unique_lock(最灵活);读多写少用shared_mutex+shared_lock(并发读);多把锁防死锁用scoped_lock(C++17)。
2.1 实战:自旋锁 vs 互斥锁 —— 如何选择?
Q: 什么时候用自旋锁,什么时候用互斥锁?
内存池项目中,CentralCache 使用自旋锁,PageCache 使用互斥锁。这不是随意选择,而是由临界区长度决定的。
| 对比维度 | std::mutex(互斥锁) | 自旋锁(std::atomic_flag) |
|---|---|---|
| 等待方式 | 线程挂起,进入内核调度队列 | 用户态循环,不进入内核 |
| 上下文切换 | 有(保存/恢复寄存器、切换页表) | 无 |
| 单次操作开销 | 挂起/唤醒各约几微秒 | 每次 CAS 约几十纳秒 |
| 适用场景 | 临界区长(毫秒级,如系统调用) | 临界区极短(微秒级,几行代码) |
自旋锁的简单实现:
cpp
std::atomic_flag lock = ATOMIC_FLAG_INIT;
// 获取锁
while (lock.test_and_set(std::memory_order_acquire)) {
std::this_thread::yield(); // 让出 CPU,避免纯空转
}
// ... 临界区(必须极短!)...
lock.clear(std::memory_order_release); // 释放锁test_and_set:原子地读取标志位 → 设置为 true → 返回旧值。如果返回 false,说明获取到锁。
内存池中的选择逻辑:
| 层级 | 临界区操作 | 耗时 | 锁选择 |
|---|---|---|---|
| CentralCache | 从链表头取/挂一个指针 | 几十 ns | 自旋锁(互斥锁的挂起开销远大于操作本身) |
| PageCache | mmap 系统调用、Span 合并遍历 | 毫秒级 | std::mutex(自旋等待会严重浪费 CPU) |
选型原则:临界区 ≤ 几行指针操作 → 自旋锁;临界区含系统调用/遍历 → 互斥锁。
2.2 实战:条件变量 + 信号量模式(在线程池中的应用)
Q:
condition_variable::wait为什么必须配合unique_lock?notify_all和notify_one怎么选?
在线程池的 Semaphore 类中,封装了 mutex + condition_variable 实现带状态记忆的信号量,用于工作线程→用户线程的异步通知:
cpp
class Semaphore {
std::mutex mtx_;
std::condition_variable cond_;
int resLimit_ = 0; // 资源计数器:0=未就绪,1=已写入
public:
// 用户线程调用:获取结果(若未就绪则阻塞)
void wait() {
std::unique_lock<std::mutex> lock(mtx_);
// Lambda 防止虚假唤醒:只有 resLimit_ > 0 才真正苏醒
cond_.wait(lock, [&] { return resLimit_ > 0; });
resLimit_--;
}
// 工作线程调用:结果写入后通知
void post() {
std::unique_lock<std::mutex> lock(mtx_);
resLimit_++;
cond_.notify_all(); // 唤醒所有等待线程
}
};为什么封装信号量而非直接用条件变量?
条件变量不记录通知——如果工作线程先 notify,用户线程后 wait,通知会丢失,用户线程永久阻塞(死锁)。信号量用一个计数器 resLimit_ 记住了"通知发生过",即使 post 先于 wait,计数器 > 0,用户线程也能直接通过。
执行流:
1. Result 创建,内部 Semaphore(0)
2. 主线程调用 get() → sem.wait() → resLimit_==0 → 阻塞休眠
3. 工作线程完成任务 → setVal() → sem.post() → resLimit_=1 → notify_all
4. 主线程被唤醒 → wait 判断 resLimit_>0 → 通过 → 拿到数据
wait必须用unique_lock,因为condition_variable::wait需要在阻塞期间释放锁(让工作线程能获取锁写入),被唤醒后重新获取锁。lock_guard不支持手动 unlock,无法满足这个需求。
3. std::atomic
Q: atomic 和 mutex 的区别?什么时候用 atomic?
| 特性 | std::atomic | std::mutex |
|---|---|---|
| 底层原理 | 硬件级指令(如 CAS - Compare And Swap) | 操作系统级锁机制 |
| 性能 | 极高(无上下文切换) | 较低(可能导致线程挂起/唤醒) |
| 粒度 | 只能保护单个变量 | 可以保护一段复杂的代码逻辑 |
| 死锁风险 | 无死锁 | 有死锁风险(如果嵌套加锁) |
| 等待方式 | 忙等(Spin)或硬件锁定 | 阻塞(线程休眠,让出 CPU) |
cpp
#include <atomic>
std::atomic<int> counter(0);
counter++; // 原子自增
counter.fetch_add(1); // 等价
std::atomic<bool> flag(false);
// 内存序
counter.load(std::memory_order_relaxed); // 最弱,仅保证原子性
counter.store(5, std::memory_order_release);
counter.fetch_add(1, std::memory_order_acq_rel); // 最强,默认(顺序一致)3.0 内存序(Memory Order)—— 六种内存序详解
Q: 六种内存序分别用在什么场景?默认的 seq_cst 有什么问题?
为什么需要内存序?—— 两个前提:
- 指令重排:编译器和 CPU 都会重排指令(流水线、乱序执行)——你以为的"先写 a 再写 b",在别的核看来可能是反的
- 缓存不可见:每个核心有自己的缓存,一个核的写入对另一个核不是立即可见的
原子操作只保证"操作本身不可分割"(原子性),不保证顺序。顺序保证由内存序指定——它规定:一个线程的写入,何时、以什么顺序对另一个线程可见。
核心钥匙:acquire / release 必须成对使用
这是理解全部内存序的钥匙。类比 mutex:
写线程: 读线程:
shared_data = x; lock(acquire) ← 读到锁标志后,
unlock(release) ──────────────▶ 读 shared_data → 一定能看到写线程的所有修改release(写端):发布——我在此之前的所有写入,对后续读到该值的线程全部可见acquire(读端):接收——我读到此值之后,之前被release发布的所有写入都可见- 单独使用没有同步意义:release 不配对 acquire = 发布了没人接;acquire 不配对 release = 接收了个寂寞
六种内存序总表:
| 内存序 | 含义 | 强度 | 典型场景 |
|---|---|---|---|
relaxed | 只保证原子性,无任何顺序保证 | 最弱 | 计数器、统计信息;不关心顺序的读 |
consume | 只保证数据依赖相关的顺序 | 弱 | 链表指针读(理论场景);实际被提升为 acquire,不推荐使用 |
acquire | 读屏障:之后的操作不能重排到它之前 | 中 | 锁获取、消费者读 |
release | 写屏障:之前的操作不能重排到它之后 | 中 | 锁释放、生产者写 |
acq_rel | acquire + release 组合 | 强 | Read-Modify-Write(fetch_add、CAS) |
seq_cst | 全局顺序一致(单全序,默认) | 最强 | 需要跨线程严格一致的全局顺序 |
逐一详解:
① relaxed —— 只保证原子性
cpp
counter.fetch_add(1, std::memory_order_relaxed); // 只要"加对了",先后无所谓- 不提供任何顺序保证:其他线程可能看到乱序,但每次操作本身不可分割
- 适用:计数器、统计信息、不依赖顺序的标志位。内存池中
centralFreeList_[i].load(relaxed)只是"读指针看是否为空",读到稍旧的值无所谓(后面有锁保护)
② consume —— 依赖关系
- 只保证数据依赖顺序:如果读 A 的结果被用来访问 B,那么 B 的访问不会被重排到读 A 之前
- 理论上适合无锁链表(读头指针 → 再通过头指针访问节点数据),但几乎所有编译器都把它提升为 acquire,C++17 起官方不推荐使用——知道概念即可,写代码用 acquire
③ acquire / ④ release —— 最常用的配对
acquire是读屏障:它之后的所有读写,不能重排到它之前release是写屏障:它之前的所有读写,不能重排到它之后- 适用:锁的获取/释放、生产者/消费者模式。自旋锁就是最典型的例子(见下方实战)
⑤ acq_rel —— 读写屏障组合
- 用于**读-改-写(RMW)**操作:
fetch_add、compare_exchange等——这类操作同时"读旧值"和"写新值",需要双向屏障 - 记法:单纯 load 用 acquire,单纯 store 用 release;又读又写 → acq_rel
⑥ seq_cst —— 全局顺序一致(默认)
- 所有线程对所有原子操作看到的是同一个全局顺序(单全序),绝无乱序
- 适用:需要严格全局顺序的算法;拿不准时用默认值最安全
为什么默认的 seq_cst 通常不是最优选择?
seq_cst 要求所有 CPU 核心对所有原子操作的执行顺序达成全局一致——硬件必须跨核同步这个顺序(x86 上 seq_cst 的 store 需要 lock/xchg 类指令,ARM 上需要 dmb 屏障),代价很高;而 relaxed 在 x86 上零额外开销(x86 硬件自带较强的一致性)。
在内存分配器的热路径上,acquire-release 已提供足够同步,seq_cst 是徒增开销。
怎么选(决策路径):
只要原子性、顺序无所谓?── 是 ──→ relaxed
│
└─ 否 ──→ 需要"写完让别人看见"?── 是 ──→ 写端 release + 读端 acquire(配对)
│
└─ 否 ──→ 读-改-写操作?── 是 ──→ acq_rel
│
└─ 否 / 拿不准 ──→ seq_cst(默认,写对优先)记忆钩子:
- 强度:
relaxed < consume < acquire/release < acq_rel < seq_cst- "acquire 管后面(之后的操作不能往前跑),release 管前面(之前的操作不能往后跑)"
- 箭头记忆:生产者
release发布 → 消费者acquire接收- 默认用
seq_cst写对,性能敏感路径按需降级
实战案例:自旋锁的 acquire-release 配对
cpp
// 获取锁 —— acquire:确保临界区内的读操作能看到 release 之前的所有写入
while (lock.test_and_set(std::memory_order_acquire))
std::this_thread::yield();
// ... 临界区 ...
lock.clear(std::memory_order_release); // release:确保临界区内的写入对后续 acquire 可见实战案例:非关键状态的 relaxed 加载
cpp
// 只是读取指针看是否为空,即使读到"稍旧"的值也无所谓——后面有锁保护
void* result = centralFreeList_[index].load(std::memory_order_relaxed);
if (!result) {
// 走慢路径,有锁保护
}原则:默认用
seq_cst写对,性能敏感路径按需降级。
经验:单个计数/标志 →
atomic;多个变量的复杂临界区 →mutex。
实战案例:compare_exchange_weak 实现无锁自由链表
内存池V1 中利用 CAS 实现了无锁的自由链表(FreeList)压栈/弹栈,是高并发内存池的核心。
cpp
// 无锁入队(归还内存块到空闲链表)
bool pushFreeList(Slot* slot) {
while (true) {
Slot* oldHead = freeList_.load(std::memory_order_relaxed); // ① 读当前头节点
slot->next.store(oldHead, std::memory_order_relaxed); // ② 新节点指向旧头
// ③ CAS:如果 freeList_ 仍等于 oldHead,则原子更新为 slot
if (freeList_.compare_exchange_weak(oldHead, slot,
std::memory_order_release, std::memory_order_relaxed))
return true; // 成功
// 失败:其他线程已修改 freeList_ → 重试
}
}
// 无锁出队(从空闲链表取走内存块)
Slot* popFreeList() {
while (true) {
Slot* oldHead = freeList_.load(std::memory_order_acquire);
if (oldHead == nullptr) return nullptr; // 链表为空
Slot* newHead = oldHead->next.load(std::memory_order_relaxed);
// CAS:尝试将链表头从 oldHead 切换到 newHead
if (freeList_.compare_exchange_weak(oldHead, newHead,
std::memory_order_acquire, std::memory_order_relaxed))
return oldHead; // 成功
// 失败 → 重试
}
}compare_exchange_weak 详解:
| 参数 | 含义 |
|---|---|
oldHead(引用) | 预期的旧值。CAS 失败时会被更新为当前实际值 |
slot | 希望设置的新值 |
| 成功内存序 | 操作成功时的内存序(release 对应入队,acquire 对应出队) |
| 失败内存序 | 操作失败时的内存序(通常用 relaxed) |
weak vs strong:
weak:允许"伪失败"(即使值相等也可能返回 false),但在循环中性能更好(x86 上 weak = strong)strong:保证只有值不等时才失败,但指令更多
要点:无锁编程的核心模式 = ① 读当前值 → ② 基于当前值准备新值 → ③ CAS 原子切换 → ④ 失败则重试。这就是经典的 CAS Loop。
3.1 实战:thread_local —— 比 atomic 更彻底的无锁方案
Q: thread_local 是什么?它如何实现无锁并发?
thread_local(C++11)是存储类说明符,被修饰的变量每个线程拥有独立副本,互不干扰。
cpp
// 内存池 ThreadCache 的单例获取
static ThreadCache* getInstance() {
static thread_local ThreadCache instance; // 每个线程一个独立实例
return &instance;
}| 特性 | 说明 |
|---|---|
| 线程独立 | 每个线程拥有变量的独立副本,线程 A 修改自己的数据时线程 B 完全感知不到 |
| 生命周期 | 随线程创建而构造,随线程销毁而析构 |
| 静态行为 | 配合 static 使用时,每个线程只在首次执行到该行时构造一次 |
内存布局示意:
线程A的TLS区域: [ ThreadCache实例A | freeList_[0..32767] ]
线程B的TLS区域: [ ThreadCache实例B | freeList_[0..32767] ]
线程C的TLS区域: [ ThreadCache实例C | freeList_[0..32767] ]
// 线程 A 修改 freeList_ 时,线程 B 完全不受影响为什么说 thread_local 是比 CAS 更彻底的无锁方案?
| 方案 | 原理 | 开销 |
|---|---|---|
std::mutex | 阻塞竞争线程 | 上下文切换(微秒级) |
std::atomic (CAS) | 原子指令重试 | CAS 失败时重试(几十 ns/次) |
thread_local | 物理隔离,从根本上消除竞争 | 零同步开销 |
内存池中的应用:ThreadCache 是线程本地缓存,95%+ 的内存分配请求在 ThreadCache 完成——不需要任何锁,不需要 CAS,不需要跨线程通信。这就是 TCMalloc 在多线程环境下比标准 malloc 快数倍的根本原因。
代价:每个线程的 ThreadCache 约 512KB(32768 × 8 字节 × 2 数组)。100 个线程 ≈ 50MB。相比 pthread 默认 8MB 栈空间是可接受的。
核心理念:最好的并发控制不是"有效地竞争",而是"根本不需要竞争"。
3.2 实战:std::chrono 时钟选择
Q: system_clock 和 steady_clock 有什么区别?什么时候用哪个?
内存池项目的延迟归还机制中使用了 std::chrono::steady_clock 来测量时间间隔。
| 时钟类型 | 特点 | 适合场景 |
|---|---|---|
system_clock | 系统时间,可被管理员/NTP 修改,可能回退 | 需要显示给用户的时间(如日志时间戳) |
steady_clock | 单调递增,永远不会倒退 | 性能计时、间隔测量 |
high_resolution_clock | 最高精度(通常就是 steady_clock 的别名) | 微基准测试 |
关键陷阱:为什么间隔测量不能用 system_clock?
cpp
// ❌ 危险:如果 NTP 校时回拨,得到负的时间差!
auto start = std::chrono::system_clock::now();
// ... 执行操作 ...
auto end = std::chrono::system_clock::now();
auto duration = end - start; // 可能是负数!
// ✅ 正确:steady_clock 保证单调递增
auto start = std::chrono::steady_clock::now();
// ... 执行操作 ...
auto end = std::chrono::steady_clock::now();
auto duration = end - start; // 一定是 ≥ 0内存池中的实际使用——延迟归还机制的定时触发:
cpp
// 双重条件:累积次数够了 OR 距上次归还超过 1 秒
static const std::chrono::milliseconds DELAY_INTERVAL{1000};
auto currentTime = std::chrono::steady_clock::now();
if (currentTime - lastReturnTime >= DELAY_INTERVAL) {
// 执行归还
}原则:测量时间间隔用
steady_clock,显示时间用system_clock。
4. future / async / promise
cpp
#include <future>
// 异步任务
auto fut = std::async(std::launch::async, [] { return 42; });
int result = fut.get(); // 阻塞等待结果
// promise - future 手动配对
std::promise<int> p;
std::future<int> f = p.get_future();
std::thread([&] { p.set_value(10); }).detach();
int val = f.get(); // 10| 机制 | 用途 |
|---|---|
std::async | 启动异步任务,返回 future |
std::future | 获取异步结果 |
std::promise | 手动设值给 future |
std::packaged_task | 包装可调用对象 |
实战场景:线程池 submitTask 的异步通道(现代线程池项目)
std::packaged_task 是连接"任务提交"和"结果获取"的桥梁——它把任意可调用对象包装成 future 的生产者:
cpp
template<typename Func, typename... Args>
auto submitTask(Func&& func, Args&&... args) -> std::future<decltype(func(args...))> {
using RetType = decltype(func(args...));
// 1. packaged_task 包装用户函数 → 建立异步通道
auto task = std::make_shared<std::packaged_task<RetType()>>(
std::bind(std::forward<Func>(func), std::forward<Args>(args)...)
);
// 2. 立即返回 future 作为"凭证"给用户(非阻塞)
std::future<RetType> result = task->get_future();
// 3. 任务入队(工作线程稍后执行 (*task)(),自动填充 future)
taskQue_.emplace([task] { (*task)(); });
return result;
}
// 用户端:
auto future = pool.submitTask(heavyComputation, arg1, arg2);
// ... 主线程做其他事 ...
int result = future.get(); // 未完成则阻塞,已完成则立即返回设计要点:
submitTask立即返回future(非阻塞)→ 用户可在需要时才get()- 工作线程执行
(*task)()→ 结果自动写入共享状态 →future变为 ready - 任务抛异常:异常被
packaged_task捕获存入future,get()时重新抛出
5. C++20 并发新增
| 特性 | 说明 |
|---|---|
std::jthread | 析构时自动 join,不会 terminate |
std::stop_token | 协作式线程取消 |
std::latch | 一次性倒计数器 |
std::barrier | 可复用的多线程同步点 |
std::semaphore | 信号量 |
5.0 jthread vs thread 的区别
Q: jthread 和 thread 有什么区别?为什么推荐 jthread?
std::jthread(C++20)= 自动 join 的线程:析构时自动 request_stop() + join(),不会 terminate。
std::thread | std::jthread(C++20) | |
|---|---|---|
| 析构行为 | joinable 时必须手动 join() / detach(),否则 std::terminate | 析构时自动 join(),不会 terminate |
| 取消机制 | 无 | 自带 stop_token,支持协作式线程取消 |
| 适用场景 | 需要完全手动控制生命周期 | 默认推荐,生命周期管理更安全 |
协作式取消(stop_token 是核心新特性):
cpp
std::jthread t([](std::stop_token token) {
while (!token.stop_requested()) { // 主动检查停止请求
// ... 工作 ...
}
});
// 主线程:请求停止(协作式,不强制杀线程)
t.request_stop();
// t 析构时:自动 request_stop() + join(),无需手动调用- 协作式:线程不会被强制杀掉,只是收到"停止请求",由工作函数主动检查
stop_token决定何时退出 request_stop()线程安全、可多次调用;也可用t.get_stop_token()获取 token
一句话:
jthread是thread的安全版——析构自动 join 消灭 terminate,额外带stop_token实现优雅的协作式取消,适合需要"平滑退出"的场景(如线程池、后台服务)。
5.1 实战:线程池"自毁"死锁与回收队列模式
Q: 线程池 Cached 模式下,空闲线程退出时为何不能自己删除自己?
这是线程池项目中遇到的经典并发设计问题。
问题现象:线程执行 threads_.erase(myId) → 触发 unique_ptr<Thread> 析构 → ~Thread() 调用 join() → 自己等自己 → 永久死锁。
cpp
// ❌ 死锁路径
ThreadFunc() {
// ... 超时退出 ...
pool->threads_.erase(myId); // 触发 ~Thread() → join() → 等自己 → 死锁!
}解决方案:回收队列模式——将"线程逻辑结束"与"线程资源回收(join)"解耦。
cpp
// ① 线程退出时只登记,不自毁
ThreadFunc() {
// ... 工作循环 ...
{
std::lock_guard lk(exitMtx_);
exitedThreadIds_.push_back(myId); // 只登记
}
exitCond_.notify_all();
}
// ② 由别人回收(创建新线程时 / 析构时)
void cleanExitedThreads() {
std::lock_guard lk(exitMtx_);
for (int id : exitedThreadIds_) {
threads_.erase(id); // 安全!此处 join 的是"别人"的线程
}
exitedThreadIds_.clear();
}设计要点:
| 时机 | 操作 | 安全性 |
|---|---|---|
| 线程退出时 | 仅将 ID 登记到回收队列 | ✅ 不涉及 join |
| 创建新线程时 | 顺手清理回收队列 | ✅ 当前线程 join 旧线程 |
| 线程池析构时 | 统一回收全部 | ✅ 主线程 join 所有工作线程 |
核心原则:"谁创建,谁回收"。线程池创建了线程,就该由线程池的主控逻辑来清理,而不是让线程"自杀"。
十二、C++17 重要新特性
1. 结构化绑定
Q: 结构化绑定怎么用?底层是怎么实现的?
一次性解包 pair/tuple/struct 到多个变量。
cpp
// map 遍历(最常用)
std::map<int, std::string> m = {{1, "hello"}, {2, "world"}};
for (const auto& [key, value] : m) { // 再也不需要 it->first / it->second
std::cout << key << " -> " << value << std::endl;
}
// pair / tuple
auto [x, y] = std::make_pair(1, 2.5);
auto [a, b, c] = std::make_tuple(1, "hi", 3.14);
// struct(按成员声明顺序)
struct Point { int x; int y; };
Point p{3, 4};
auto [px, py] = p; // px=3, py=4
// 数组
int arr[] = {1, 2, 3};
auto [e1, e2, e3] = arr; // e1=1, e2=2, e3=3底层原理:编译器生成一个匿名变量 __tmp = expr;,然后将每个绑定名作为该匿名变量的成员的引用/别名。
项目中的实际应用(内存池 与 线程池):
cpp
// 内存池:performDelayedReturn 中遍历 spanFreeCounts
for (const auto& [tracker, newFreeBlocks] : spanFreeCounts) {
// tracker 是 SpanTracker&,newFreeBlocks 是 size_t
tracker->freeBlocks += newFreeBlocks;
}
// 线程池:遍历 threads_ 时解包 id 和 Thread 指针
for (const auto& [threadId, threadPtr] : threads_) {
threadPtr->join();
}
auto [key, value]替代了.first/.second的模式,在处理容器遍历时大幅提升可读性。
2. if constexpr(编译期条件分支)
Q: if constexpr 和普通 if 的区别?
普通 if | if constexpr | |
|---|---|---|
| 求值时机 | 运行时 | 编译时 |
| 分支代码 | 两份代码都编译 | 只编译满足条件的分支 |
| 条件限制 | 运行时表达式 | 编译期常量表达式 |
| 省运行时开销 | 否 | 是(不满足的分支不参与编译) |
cpp
// 模板中代替 SFINAE / 特化
template<typename T>
auto process(const T& value) {
if constexpr (std::is_integral_v<T>) {
return value * 2; // 整数路径
} else if constexpr (std::is_floating_point_v<T>) {
return value * 1.5; // 浮点路径
} else {
static_assert(sizeof(T) == 0, "Unsupported type"); // 编译期报错
}
}3. std::optional —— 可能不存在的值
Q: optional 解决了什么问题?和指针有什么区别?
语义明确:一个值"可能有、也可能没有",替代用 -1、nullptr 等魔法值的做法。
cpp
#include <optional>
std::optional<int> find_user(const std::string& name) {
if (name == "admin") return 42;
return std::nullopt; // 明确表示"没有值"
}
auto result = find_user("admin");
if (result) { // 检查是否有值
std::cout << result.value(); // 获取值
}
std::cout << result.value_or(-1); // 有值返回值,无值返回 -1
// 风险操作
result.value(); // 无值时抛 std::bad_optional_access
*result; // 无值时 UB!std::optional<T> | 裸指针 T* | |
|---|---|---|
| 语义 | 明确的"可能有/无" | 可以是空,也可以是地址(多重语义) |
| 所有权 | 值语义(栈上或作为成员) | 可能指向堆内存 |
| 内存开销 | sizeof(T) + 1 + padding | 8 字节(64位) |
| std::nullopt | ✅ 明确的无值 | ❌ nullptr 和 0 有时混用 |
4. std::variant —— 类型安全的 Union
Q: variant 和 union 的区别?
union 的问题:不知道当前存的是什么类型,访问错误类型是 UB。
std::variant = 类型安全的 union,知道当前存的是什么,错误访问会抛异常。
cpp
#include <variant>
std::variant<int, double, std::string> v;
v = 42; // 存 int
v = 3.14; // 存 double
v = std::string("hello"); // 存 string
// 访问方式一:std::get
std::cout << std::get<std::string>(v); // 类型匹配 → OK
// std::get<int>(v); // 类型不匹配 → 抛 std::bad_variant_access
// 访问方式二:std::get_if
if (auto* p = std::get_if<int>(&v)) {
// 是 int
} else if (auto* p = std::get_if<double>(&v)) {
// 是 double
}
// 访问方式三:std::visit(最推荐)
std::visit([](auto&& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, int>)
std::cout << "int: " << arg;
else if constexpr (std::is_same_v<T, double>)
std::cout << "double: " << arg;
// ...
}, v);5. std::any —— 任意类型容器
cpp
#include <any>
std::any a = 42;
a = std::string("hello");
a = 3.14;
// 获取值
if (a.type() == typeid(int)) { /* 是 int */ }
std::any_cast<int>(a); // 类型不对抛 std::bad_any_cast
int* p = std::any_cast<int>(&a); // 指针版,失败返回 nullptrstd::any | std::variant | std::optional | |
|---|---|---|---|
| 可存类型 | 任意类型 | 提前列出的有限类型 | 单个类型的有/无 |
| 类型检查 | 运行时(typeid) | 编译期 | 编译期 |
| 访问方式 | any_cast(可能抛异常) | get/visit(类型安全) | value/* |
| 适用场景 | 脚本绑定、插件系统 | 已知类型的多态 | 可选返回值 |
6. string_view(C++17)
Q: string_view 是什么?和 string 有什么区别?
非拥有的、只读的字符串视图。不分配内存,不拷贝数据。
cpp
#include <string_view>
void process(std::string_view sv) {
if (sv.starts_with("http")) { ... } // C++20
if (sv.ends_with(".jpg")) { ... } // C++20
}
process("literal"); // 零开销,无需构造临时 string
process(std::string("hello")); // 隐式转换
// substr 也是 O(1)(只是移动指针和长度,不分配新内存)
std::string_view sv = "Hello World";
auto sub = sv.substr(0, 5); // O(1),sub = "Hello"致命陷阱:
cpp
std::string_view func() {
std::string s = "hello";
return s; // ❌ s 被销毁,sv 变成悬空指针!
}
// 临时 string 的 string_view 也危险
std::string_view sv = std::string("temp"); // ❌ 临时对象这一行就被销毁
sv.substr(0, 2); // UB!
string_view= 裸指针 + 长度,不拥有数据。使用 string_view 时务必保证原数据存活。
7. 类模板参数推导(CTAD, C++17)
cpp
// C++14 之前必须写模板参数
std::pair<int, double> p = {1, 2.5};
std::vector<int> v = {1, 2, 3};
std::unique_ptr<int> up(new int(42));
// C++17:编译器自动推导
std::pair p = {1, 2.5}; // pair<int, double>
std::vector v = {1, 2, 3}; // vector<int>
std::unique_ptr up(new int(42)); // unique_ptr<int>
std::lock_guard lk(mtx); // lock_guard<std::mutex>
std::array arr = {1, 2, 3, 4}; // array<int, 4>8. 初始化语句中的 if/switch(C++17)
cpp
// 在 if 条件中初始化变量,生命周期限定在 if-else 块内
if (auto it = m.find(key); it != m.end()) {
// 使用 it
} else {
// it 不可见
}
// switch 也可以
switch (auto val = compute(); val) {
case 0: /* ... */
}9. 内联变量(C++17)
Q: inline 变量解决了什么问题?和普通变量有什么区别?
9.1 背景:C++17 之前的问题
在 C++17 之前,inline 关键字只能用于函数,不能用于变量。这导致了两个长期痛点:
痛点一:静态成员变量必须在类外定义
cpp
// C++14/11:头文件 MyClass.h
class MyClass {
public:
static const int N = 100; // ✅ 整数常量可以在类内初始化(特例)
static const double PI; // ❌ 非整数只能在类内声明
static std::string name; // ❌ 也只能声明
static std::map<int, std::string> config; // ❌ 也只能声明
};
// 必须在 .cpp 中定义(分离编译)
const double MyClass::PI = 3.14159;
std::string MyClass::name = "default";
std::map<int, std::string> MyClass::config = {{1, "one"}, {2, "two"}};
// 问题:
// 1. 定义和声明分离——容易忘记在 cpp 中定义,链接错误
// 2. Header-only 库无法直接使用静态成员(必须让用户自己在某处定义)
// 3. 维护两处代码,心智负担大痛点二:头文件中不能定义全局变量(ODR 违规)
cpp
// ❌ C++14 以前:以下代码放在 .h 文件中,被多个 .cpp 包含会多重定义!
// constants.h
const int MAX_THREADS = 16; // ✅ 特例:const 有内部链接
extern const char* APP_NAME = "MyApp"; // ❌ 多重定义!
int globalCounter = 0; // ❌ 多重定义!
// 解决办法:在每个 .cpp 里 extern + 单独在一个 .cpp 里定义 → 极其繁琐这些痛点的根源是 C++ 的 ODR 规则(One Definition Rule):每个非内联变量在整个程序中只能有一个定义。
9.2 核心:inline 变量的意义
C++17 将 inline 扩展到变量,核心语义是:
被标记为
inline的变量允许多个编译单元包含同一个定义,链接器只保留一份,行为与inline函数一致。
cpp
// MyHeader.h —— 可以被任意多个 .cpp 包含
inline int globalCounter = 0; // ✅ 链接器合并为一份
inline const char* APP_NAME = "MyApp"; // ✅ 安全
inline std::vector<int> defaultValues = {1, 2, 3}; // ✅ 也安全(注意初始化顺序)9.3 四大核心作用
作用一:静态成员变量类内初始化(最常用)
这是 inline 变量最高频的使用场景。C++17 之前,非 constexpr 的静态成员必须在类外定义;现在 inline static 让一切都在类内完成。
cpp
// Header-only 库终于可以拥有静态成员变量了!
class ThreadPool {
public:
// 配置参数 —— 直接在类内定义
inline static int maxThreadCount = std::thread::hardware_concurrency();
inline static std::chrono::milliseconds keepAliveTime{1000};
inline static std::string namePrefix = "worker_";
// 计数器
inline static std::atomic<size_t> activeInstances{0};
// 复杂容器也没问题
inline static std::map<std::string, std::function<void()>> globalHooks;
};
// C++14:需要在 .cpp 里分别定义每一条 → 维护两处
// C++17:全部在类内初始化 → 声明即定义,一目了然与 constexpr 静态成员的区分:
static constexpr | inline static | |
|---|---|---|
| 适用类型 | 字面类型(整数、浮点、枚举等) | 任意类型(string、map、自定义类…) |
| 初始化时机 | 编译期 | 首次使用前(懒初始化) |
| 能否运行期求值 | ❌ 必须编译期常量 | ✅ 可调用函数/构造对象 |
| 是否隐式 inline | ✅ C++17 起 constexpr 静态成员隐式 inline | 显式声明 |
cpp
class Foo {
static constexpr int N = 100; // 隐式 inline(C++17)
inline static std::string name = "foo"; // 显式 inline,运行时初始化
inline static std::vector<int> v = {1, 2, 3}; // 运行时初始化
// static std::string bad = "bar"; // ❌ C++17 前:非 constexpr 不能类内初始化
};作用二:Header-Only 库的基石
Header-only 库(只需 #include 即可使用,无需链接 .cpp)在 C++ 社区越来越流行(如 Catch2、nlohmann/json、Eigen 等)。inline 变量让包含静态/全局数据的 header-only 库成为可能。
cpp
// 一个 header-only 的日志库 —— Logger.hpp
#pragma once
#include <string>
#include <vector>
#include <fstream>
class Logger {
public:
// 全部在头文件中定义,无需 .cpp
inline static std::string logFilePath = "app.log";
inline static std::vector<std::string> modules = {"core", "network", "ui"};
inline static bool enableConsole = true;
static void log(const std::string& msg) {
// ...
}
};
// 使用者只需:
#include "Logger.hpp"
Logger::logFilePath = "/var/log/myapp.log"; // 可直接赋值
Logger::log("Hello");作用三:头文件中的全局常量替代方案
C++17 以前,头文件中定义全局常量依赖于 const 的内部链接规则(隐式 static)。inline 提供了更明确的语义和更广的适用性。
cpp
// ❌ C++14:const 有内部链接——每个编译单元各有一份独立副本
// config.h
const int MAX_SIZE = 1024; // 每个 .cpp 拷贝一份(取地址会不同!)
const std::string APP_NAME = "MyApp"; // ⚠️ 每个 .cpp 构造一次 string(浪费!)
// 如果你在 a.cpp 和 b.cpp 中分别取 &APP_NAME,得到不同的地址!
// 对于 int 还好,对于 string 这种有堆分配的类,每个编译单元一份 = 多份堆内存!
// ✅ C++17:inline 变量——全局唯一一份
// config.h
inline const int MAX_SIZE = 1024; // 唯一一份,地址一致
inline const std::string APP_NAME = "MyApp"; // 只构造一次,一份堆内存| 头文件中的变量声明方式 | 链接属性 | 每个 .cpp 的副本数 | 地址是否全局一致 |
|---|---|---|---|
int x = 1; | 外部链接 | ❌ 编译错误(多重定义) | — |
const int x = 1; | 内部链接(隐式 static) | 每个 .cpp 一份 | ❌ 不一致 |
inline int x = 1; | 外部链接 + inline | 全局唯一一份 | ✅ 一致 |
inline const int x = 1; | 外部链接 + inline + const | 全局唯一一份 | ✅ 一致 |
作用四:线程安全的懒初始化保证
inline 变量与局部 static 变量享有同样的线程安全初始化保证——C++ 标准规定:如果多个线程同时首次访问一个 inline 变量,只有一个线程执行初始化,其他线程阻塞等待。
cpp
// ThreadSafeConfig.h
inline std::map<std::string, int>& getGlobalConfig() {
// inline 变量保证:多线程首次调用时只有一个线程初始化,零开销同步
inline static std::map<std::string, int> config = [] {
std::map<std::string, int> m;
m["timeout"] = 30;
m["retries"] = 3;
m["poolSize"] = 16;
return m;
}();
return config;
}9.4 inline、static、inline static 的链接属性对比
这是容易被混淆的点,这里一次性梳理清楚:
cpp
// 全局/命名空间作用域
inline int a = 1; // 外部链接 + inline(所有编译单元共享一份)
static int b = 2; // 内部链接(每个编译单元独立一份)
int c = 3; // 外部链接(.h 中会导致多重定义!)
const int d = 4; // 内部链接(const 默认内部链接,每个 .cpp 一份)
inline const int e = 5; // 外部链接 + inline + const(全局唯一一份)
// 类内静态成员
class X {
static int x; // 声明(需要在类外定义)
static const int y = 10; // 整数常量特例(类内可初始化,但仍是声明)
inline static int z = 20; // 类内定义 + 初始化(C++17,一条搞定)
static constexpr int w = 30; // 编译期常量(C++17 起隐式 inline)
};| 声明方式 | 链接属性 | ODR | 地址全局一致 | 适用场景 |
|---|---|---|---|---|
static 全局变量 | 内部链接 | 每个 .cpp 独立 | ❌ | 仅当前 .cpp 使用的内部状态 |
const 全局变量 | 内部链接 | 每个 .cpp 独立 | ❌ | 小类型常量(int, double 等) |
inline 全局变量 | 外部链接 + inline | 全局唯一 | ✅ | Header-only 库、全局共享配置 |
inline const 全局变量 | 外部链接 + inline + const | 全局唯一 | ✅ | 全局常量(string, map 等大对象) |
inline static 类成员 | 属于类 | 类内唯一定义 | ✅ | 类级别的共享状态 / 配置 |
9.5 使用场景速查
| 场景 | 推荐写法 | 说明 |
|---|---|---|
| 类内的运行时常量成员 | inline static const std::string NAME = "…" | 类内一条完成,不需类外定义 |
| 类内的计数器/状态 | inline static std::atomic<size_t> counter{0} | 所有实例共享,线程安全 |
| Header-only 库的配置项 | inline static int timeout = 30 | 用户可直接 Library::timeout = 60 |
| 全局共享的配置对象 | inline Config globalConfig{} | 所有编译单元同一份 |
| 全局大常量 | inline const std::map<int, Str> MAP = {…} | x 只构造一次,不重复开辟堆内存 |
| 仅当前 .cpp 的内部状态 | static int localState = 0(或匿名 namespace) | 不需要 inline |
9.6 注意事项与陷阱
① 初始化顺序问题(Static Initialization Order Fiasco)
inline 变量不能解决跨编译单元的初始化顺序依赖。
cpp
// a.h
inline int x = [] { return 42; }();
// b.h
inline int y = x + 1; // ⚠️ 危险!b.h 被包含时 x 可能还未初始化
// 解决方案:用函数包装(Meyers' Singleton)
inline int& getX() {
static int x = 42; // 首次调用时才初始化
return x;
}
inline int y = getX() + 1; // 安全:y 初始化时必定先触发 getX()② inline 变量 + 动态库(.so / .dll)的符号可见性
cpp
// 跨动态库边界时,inline 变量可能产生两份实例(取决于平台和符号可见性策略)
// 解决办法:使用 __attribute__((visibility("default"))) 或 __declspec(dllexport)③ constexpr 静态成员已是隐式 inline
cpp
class Foo {
static constexpr int N = 100; // C++17 起:隐式 inline
// 不需要再加 inline!
// inline static constexpr int N = 100; // 多余的 inline(虽不报错)
};④ inline 不改变生命周期,只改变链接规则
cpp
// inline 变量的生命周期与普通外部变量一样:程序启动时构造,结束时析构
// inline 不是"内联展开"到每个使用点——只是让链接器合并符号定义
inline std::vector<int> data = {1, 2, 3}; // main 之前构造,main 之后析构9.7 项目中的实际应用
| 项目 | 使用方式 | 目的 |
|---|---|---|
| 线程池 | inline static 默认线程数、超时参数 | 配置参数类内一条搞定 |
| 内存池 | inline static 各级缓存桶大小表 | Header-only 组件,无需 .cpp 定义 |
| 通用 | inline const 全局常量表(错误码映射等) | 替换宏和 extern const 模式 |
cpp
// 线程池中的典型应用
class ThreadPool {
public:
enum class PoolMode { CACHED, FIXED };
// C++17:所有配置参数都在类内直接定义
inline static PoolMode defaultMode = PoolMode::CACHED;
inline static int defaultThreadCount = std::thread::hardware_concurrency();
inline static std::chrono::milliseconds idleTimeout{60'000};
// 状态计数器
inline static std::atomic<uint64_t> totalTasksSubmitted{0};
inline static std::atomic<uint64_t> totalTasksCompleted{0};
};一句话总结:C++17
inline变量 = 让变量拥有inline函数的链接语义——可以在头文件中定义,链接器自动合并成一份,适用于任意类型。最核心的应用是inline static类成员初始化,让 header-only 库终于可以自包含静态数据。
10. 文件系统(C++17)
cpp
#include <filesystem>
namespace fs = std::filesystem;
fs::path p = "/home/user/data.txt";
p.filename(); // "data.txt"
p.extension(); // ".txt"
p.parent_path(); // "/home/user"
p.stem(); // "data"
fs::exists(p);
fs::is_directory(p);
fs::file_size(p);
// 遍历目录
for (const auto& entry : fs::directory_iterator("/home/user")) {
std::cout << entry.path() << std::endl;
}
// 递归遍历
for (const auto& entry : fs::recursive_directory_iterator("/home/user")) { }
fs::create_directory("new_dir");
fs::remove("old_file.txt");
fs::copy(src, dst);十三、C++20 重要新特性
1. Concepts(概念)
Q: Concepts 解决了什么问题?
对模板参数添加编译期约束,替代繁冗的 SFINAE 和 static_assert,让模板错误信息可读。
cpp
#include <concepts>
// 定义概念
template<typename T>
concept Addable = requires(T a, T b) {
a + b; // 要求 T 支持 operator+
};
// 用法 1:requires 子句
template<typename T>
requires Addable<T> && std::copyable<T>
T sum(T a, T b) { return a + b; }
// 用法 2:概念代替 typename
template<Addable T>
T sum(T a, T b) { return a + b; }
// 用法 3:简洁语法
auto sum(Addable auto a, Addable auto b) { return a + b; }
// 标准库概念
template<std::integral T> // T 必须是整数
T add(T a, T b) { return a + b; }概念 vs SFINAE vs static_assert:
| Concepts | SFINAE | static_assert | |
|---|---|---|---|
| 检查时机 | 重载解析之前 | 模板实例化时 | 模板实例化之后 |
| 错误信息 | 清晰、可读 | 晦涩 | 可自定义消息 |
| 重载选择 | ✅ 参与重载决策 | ✅ | ❌ |
2. Ranges(范围库)
Q: Ranges 和传统 STL 算法有什么区别?
管道式编程,直接对容器操作,不再需要 begin()/end()。
cpp
#include <ranges>
namespace rv = std::views;
std::vector<int> v = {1, 4, 2, 8, 5, 3, 7, 6, 9};
// 传统方式
std::vector<int> result;
std::copy_if(v.begin(), v.end(), std::back_inserter(result),
[](int x) { return x % 2 == 0; });
std::sort(result.begin(), result.end());
for (auto& x : result) x *= x;
// C++20 Ranges 管道
auto result = v
| rv::filter([](int x) { return x % 2 == 0; }) // 偶数
| rv::transform([](int x) { return x * x; }) // 平方
| rv::take(3); // 前 3 个
// result 是 lazy view,遍历时才真正计算Ranges 适配器(Views):
| View | 作用 |
|---|---|
filter | 过滤不满足条件的元素 |
transform | 对每个元素做映射 |
take / take_while | 取前 n 个 / 满足条件就取 |
drop / drop_while | 丢弃前 n 个 / 满足条件就丢弃 |
reverse | 逆序 |
iota | 生成递增序列 |
join | 扁平化嵌套范围 |
split | 按分隔符拆分 |
Ranges 的优势:
- 懒求值:中间结果不分配内存
- 可组合:管道式链式调用
- 语法简洁:不再需要
begin()/end()
3. 协程(C++20)
Q: C++20 协程是什么?解决了什么问题?
C++20 提供了无栈协程基础设施——编译器帮你生成状态机,suspend/resume 自动管理。
核心关键词:co_await、co_yield、co_return。
cpp
// 生成器(最简单的协程示例)
#include <coroutine>
#include <iostream>
template<typename T>
struct Generator {
struct promise_type {
T current_value;
Generator get_return_object() { return Generator{this}; }
std::suspend_always initial_suspend() { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
std::suspend_always yield_value(T value) {
current_value = value;
return {};
}
void return_void() {}
void unhandled_exception() { std::terminate(); }
};
struct iterator {
std::coroutine_handle<promise_type> h;
T operator*() const { return h.promise().current_value; }
iterator& operator++() { h.resume(); return *this; }
bool operator!=(std::default_sentinel_t) const { return !h.done(); }
};
iterator begin() { h.resume(); return {h}; }
std::default_sentinel_t end() { return {}; }
~Generator() { if (h) h.destroy(); }
private:
explicit Generator(promise_type* p) : h(std::coroutine_handle<promise_type>::from_promise(*p)) {}
std::coroutine_handle<promise_type> h;
};
Generator<int> fibonacci() {
int a = 0, b = 1;
while (true) {
co_yield a;
auto next = a + b;
a = b;
b = next;
}
}
// 使用
for (int v : fibonacci() | std::views::take(10)) {
std::cout << v << ' '; // 0 1 1 2 3 5 8 13 21 34
}协程 vs 线程:
| 线程 | 协程 | |
|---|---|---|
| 调度 | OS 内核抢占式 | 用户态协作式 |
| 切换开销 | 微秒级 | 纳秒级 |
| 内存占用 | ~1MB 栈 | 按需分配 |
| 并发模型 | 1 个任务 1 个线程 | 成千上万协程共享少数线程 |
注意:C++20 只提供了协程的底层基础设施(编译器支持 +
<coroutine>头文件),使用层面需要库封装(如cppcoro、asio等)。
4. 三路比较运算符 <=>(太空船运算符)
Q: operator<=> 解决了什么问题?
一个 operator<=> 代替六个比较运算符(< <= > >= == !=)。
cpp
#include <compare>
struct Point {
int x, y;
auto operator<=>(const Point&) const = default; // 编译器自动生成全部比较
};
Point a{1, 2}, b{3, 4};
a < b; // ✅ 自动生成,按 x 再 y 比较
// 返回值类型
std::strong_ordering r1 = 1 <=> 2; // 强序(整数)
std::weak_ordering r2; // 弱序(如不区分大小写的字符串)
std::partial_ordering r3 = 0.0 <=> -0.0; // 偏序(浮点,含 NaN)| 比较类别 | 含义 | 典型类型 | 可否等价替换? |
|---|---|---|---|
strong_ordering | 完全可排序,等价值可互相替代 | int、char* | ✅ |
weak_ordering | 可排序,等价值不可互相替代 | 不区分大小写的比较 | ❌ |
partial_ordering | 存在不可比较的值 | double(有 NaN) | ❌ |
5. consteval 与 constinit(C++20)
cpp
// consteval:必须编译期执行
consteval int square(int x) { return x * x; }
int a = square(5); // ✅
// int b = square(argc); // ❌ argc 不是编译期常量
// constinit:确保变量在编译期初始化(防止 static order fiasco)
constinit int global = 42; // 编译期初始化,线程安全6. std::span(C++20)
Q: span 是什么?和 vector/array 有什么区别?
非拥有的只读/可读写视图——不分配内存,不管理生命周期。
cpp
#include <span>
void process(std::span<int> data) { // 替代 void process(int* data, size_t len)
for (auto& x : data) { x *= 2; } // 可范围 for 遍历
}
int arr[] = {1, 2, 3, 4, 5};
process(arr); // 数组自动推导
std::vector<int> v = {1, 2, 3, 4, 5};
process(v); // vector 也可以
process({v.data(), 3}); // 子范围(前 3 个元素)
// 比裸指针 int* + size_t 安全,比 vector& 灵活(不约束容器类型)std::span<T> | std::string_view | std::vector<T>& | |
|---|---|---|---|
| 元素类型 | 任意 T | char | 任意 T |
| 所有权 | 无 | 无 | 无(引用) |
| 可修改 | 是(不 const) | 否 | 是 |
| 接受数组 | ✅ | ❌ | ❌ |
7. std::format(C++20)
cpp
#include <format>
// 替代 iostream / sprintf,类型安全 + 易读
auto s = std::format("Hello, {}! You have {} messages.", "Alice", 5);
// 带序号
std::format("{1} - {0}", 10, 20); // "20 - 10"
// 格式化选项
std::format("{:.2f}", 3.14159); // "3.14"
std::format("{:#x}", 255); // "0xff"
std::format("{:*^10}", "hi"); // "****hi****"8. 其他 C++20 值得关注的特性
| 特性 | 说明 |
|---|---|
| Modules | 替代 #include,import std;,加快编译(编译器支持仍在完善中) |
| Designated Initializers | C99 风格,Point{.x=1, .y=2} |
using enum | using enum Color; 将枚举值引入当前作用域 |
likely/unlikely | if (x) [[likely]], 分支预测提示 |
std::source_location | 代替 __FILE__/__LINE__ 宏 |
contains() | m.contains(key) 检查关联容器(终于有了!) |
starts_with / ends_with | s.starts_with("pre")(string / string_view) |
十四、各版本特性速查
C++11 核心新增
| 类别 | 特性 | 一句话 |
|---|---|---|
| 类型 | auto、decltype | 编译期类型推导 |
| 空指针 | nullptr | 类型安全的空指针 |
| 智能指针 | unique_ptr, shared_ptr, weak_ptr | RAII 管理内存 |
| 移动语义 | &&、std::move、移动构造 | O(1) 窃取资源 |
| Lambda | [capture](params){body} | 就地定义匿名可调用对象 |
| 模板 | 可变参数模板 Args... | 任意数量模板参数 |
| 可调用 | std::function、std::bind | 统一包装可调用对象 |
| 常量 | constexpr | 编译期计算 |
| 容器 | unordered_map, unordered_set, array, forward_list | 哈希表、固定大小数组 |
| 枚举 | enum class | 强类型枚举,不污染作用域 |
| 线程 | std::thread, mutex, atomic, future | 标准线程库 |
| 其他 | 范围 for、=delete/=default、override/final、static_assert、初始化列表、委托构造、继承构造、noexcept |
C++14 核心新增
| 特性 | 一句话 |
|---|---|
auto 返回类型推导 | 函数返回类型可写 auto |
decltype(auto) | 保留引用和 const 的 auto |
| 泛型 Lambda | [](auto a, auto b) { return a + b; } |
make_unique | 创建 unique_ptr 的 factory |
constexpr 放宽 | 支持分支、循环 |
| 二进制字面量 | 0b1010 |
| 数字分隔符 | 1'000'000 |
C++17 核心新增
| 特性 | 一句话 |
|---|---|
| 结构化绑定 | auto [key, val] = *it; |
if constexpr | 编译期分支,模板代码精简 |
optional / variant / any | 三件套:可能无值 / 类型安全 union / 任意类型 |
string_view | 零拷贝字符串视图 |
| CTAD | 类模板参数自动推导,pair p{1, 2.5} |
| 折叠表达式 | (args + ...) 展开可变参数包 |
if/switch 初始化语句 | if (auto it = m.find(k); it != end()) |
| 内联变量 | inline 变量,static inline 成员 |
filesystem | 标准文件系统操作 |
| 并行算法 | std::sort(std::execution::par, v.begin(), v.end()) |
C++20 核心新增
| 特性 | 一句话 |
|---|---|
| Concepts | 模板参数编译期约束,可读错误信息 |
| Ranges | 管道式范围操作,v | filter | transform |
| Coroutines | co_await/co_yield/co_return 协程基础设施 |
<=> | 三路比较运算符,一个替代六个 |
consteval / constinit | 强制编译期函数 / 编译期初始化变量 |
span | 非拥有数据视图 |
format | 类型安全的格式化字符串 |
| Modules | 替代 #include(编译加速) |
| Designated Initializers | C 风格指定成员名初始化 |
jthread | 自动 join 的线程 |
starts_with / ends_with | 字符串前后缀判断 |
contains() | 关联容器检查 key 是否存在 |
附:C++11 Magic Statics —— 线程安全的懒汉单例
Q: C++11 之后为什么不需要双重检查锁定(DCLP)来实现线程安全单例了?
C++11 标准明确规定:如果多个线程同时进入一个函数,函数内的 static 局部变量正在初始化中,则只有一个线程执行初始化,其他线程阻塞直到初始化完成。
cpp
// 线程安全的懒汉单例 —— 不需要任何手动加锁!
static CentralCache& getInstance() {
static CentralCache instance; // C++11 保证线程安全初始化
return instance;
}编译器会自动在初始化前后插入内存屏障(类似 acquire-release 配对),程序员无需手动同步。
thread_local + static 组合:
cpp
static ThreadCache* getInstance() {
static thread_local ThreadCache instance; // 每个线程独立实例
return &instance;
}static:每个线程内只初始化一次thread_local:每个线程拥有独立副本
内存池和线程池中的应用:ThreadCache、CentralCache、PageCache 全部使用这种模式实现单例。
十五、高频追问
Q1:C++11 中最重要的特性是什么?为什么?
答:移动语义。它从根本上改变了 C++ 的性能模型——从"万物皆拷贝"到"能不拷贝就不拷贝"。unique_ptr、Lambda(含移动捕获)、STL 容器元素移动、完美转发等全部依赖于右值引用和移动语义。
Q2:C++17 和 C++14 哪个版本更重要?
答:C++17 被称为"实用特性版"。结构化绑定、if constexpr、optional/variant/string_view 在日常编码中高频出现,对代码质量和可读性提升极大。
Q3:C++20 在实际项目中能用吗?
答:部分可用,取决于编译器和项目约束。GCC 10+、Clang 10+、MSVC 2022 对 C++20 支持良好。Concepts、<=>、Ranges、format、span 已被广泛使用。Modules 和 Coroutines 的主流库支持仍在成熟中。
Q4:什么时候用 unique_ptr 而不是 shared_ptr?
答:90% 的场景用 unique_ptr。只有当确实需要多个对象共享所有权时才用 shared_ptr(有循环引用风险还要配合 weak_ptr)。unique_ptr 零开销、语义清晰、不会额外分配控制块。
Q5:Lambda 有什么不能做的事?
答:
- Lambda 不能是模板(但 C++14 泛型 Lambda 变相支持了参数类型推导)
- C++20 前不能有模板参数列表(C++20
[]<typename T>(T a){}) - 捕获的变量生命周期需自行管理(引用捕获不会延长变量生命周期)
- Lambda 不能递归调用自身(需配合
std::function或 Y-combinator)
Q6:什么时候用 emplace_back 而不是 push_back?
答:构造参数不是目标类型本身时优先用 emplace_back。它将参数完美转发后原地构造,省去中间临时对象的构造和移动开销。
Q7:C++ 中如何优雅地处理错误?不用异常行不行?
答:
- C++17
std::optional:可能不存在的值(查找操作) - C++23
std::expected:带错误信息的结果(类似 Rust 的Result) std::variant<T, Error>:C++17 中可以表示"值或错误"- 异常:C++ 标准错误处理方式,但需要 RAII 配合,不能滥用
Q8:std::atomic 能替代 mutex 吗?
答:不能完全替代。atomic 只保证单个变量的原子访问,无法保护涉及多个变量的复杂临界区。例如转账操作(扣 A、加 B)必须用 mutex 保护整个事务。atomic 的定位是无锁的简单标志/计数器。
十六、命名空间(C++98 基础,常考)
1. 作用与三种访问方式
Q: 命名空间是什么?为什么要用命名空间?
命名空间是一种作用域机制,用来组织代码、避免命名冲突(名字污染)——不同库/模块的同名类型可以共存,用 :: 限定访问。
cpp
namespace libA { class Logger {}; }
namespace libB { class Logger {}; } // ✅ 同名不冲突
libA::Logger a;三种访问方式:
cpp
std::cout << "hi"; // ① 限定名:最安全、最明确
using std::cout; // ② using 声明:只引入单个名字
using namespace std; // ③ using 指令:引入整个命名空间| 限定名 | using std::cout(声明) | using namespace std(指令) | |
|---|---|---|---|
| 引入范围 | 单次访问 | 单个名字 | 整个命名空间 |
| 冲突风险 | 无 | 低 | 高 |
记忆:限定名 > using 声明 > using 指令,作用范围越大冲突风险越高。头文件中绝不写
using namespace std(会污染所有包含者);命名空间不能定义在函数内部。关联考点:C++11enum class就是"枚举值的命名空间",不污染外层作用域。
2. 匿名命名空间
Q: 匿名命名空间的作用?和 static 全局变量有什么区别?
不给名字的命名空间,其中名字只在当前编译单元内可见(内部链接),用于隐藏本文件内部实现,比 static 更语义化:
cpp
namespace { // 相当于 static,仅供本文件使用
int internalCounter = 0;
void helper() {}
}3. 内联命名空间(C++11)
Q: inline namespace 是干什么的?
其中的名字可被外层命名空间直接访问,仿佛不存在这层封装。用于库的版本管理 / ABI 兼容——升级 API 时旧代码无需改动:
cpp
namespace MyLib {
inline namespace v1 { void api() {} } // 默认版本:MyLib::api() 直接命中
namespace v2 { void api() {} } // 新版本:MyLib::v2::api() 显式访问
}4. 嵌套命名空间与别名
cpp
namespace fs = std::filesystem; // C++17 起常用:给冗长命名空间起别名
namespace A::B::C { } // C++17 嵌套简写(C++11 需逐层嵌套 namespace A { namespace B {...} })5. ADL(实参依赖查找)—— 加分点
Q: 为什么
std::cout << x不用写std::operator<<?
ADL:调用函数时,若实参的类型定义在某个命名空间,编译器会自动去那里查找匹配函数,无需 using:
cpp
namespace mymath {
struct Point { int x, y; };
Point operator+(const Point& a, const Point& b) { return {a.x+b.x, a.y+b.y}; }
}
auto c = a + b; // ✅ 自动找到 mymath::operator+std::cout << 42 能编译正是靠 ADL——operator<< 与 std::cout 的类型都在 std。这也是运算符重载必须与类型放在同一命名空间的原因。
一句话总结:命名空间解决命名冲突、代码组织、可见性三大问题。考点:三种访问方式、匿名命名空间(内部链接)、inline namespace(版本管理)、ADL。
十七、低频但重要(进阶补充)
以下考点在出现频率低于前 16 节,但大厂手撕题和实际开发中会用,时间充裕时准备。
1. 手写一个简化版 unique_ptr(手撕题)
完整实现见 §四.2.2。手撕时记住最小骨架:
cpp
template<typename T>
class unique_ptr {
T* ptr_;
public:
explicit unique_ptr(T* p = nullptr) : ptr_(p) {}
~unique_ptr() { delete ptr_; }
unique_ptr(const unique_ptr&) = delete; // 禁拷贝
unique_ptr& operator=(const unique_ptr&) = delete;
unique_ptr(unique_ptr&& o) noexcept : ptr_(o.ptr_) { o.ptr_ = nullptr; } // 移动置空
unique_ptr& operator=(unique_ptr&& o) noexcept {
if (this != &o) { delete ptr_; ptr_ = o.ptr_; o.ptr_ = nullptr; }
return *this;
}
T* release() noexcept { T* p = ptr_; ptr_ = nullptr; return p; } // 只交还
void reset(T* p = nullptr) noexcept { delete ptr_; ptr_ = p; } // 换新
T* get() const noexcept { return ptr_; }
T& operator*() const { return *ptr_; }
T* operator->() const { return ptr_; }
};考察点:
= delete禁拷贝、移动后源置空防 double-free、release只交还不释放、reset释放旧接管新。
2. std::array —— 栈上固定大小数组(C++11)
C 风格数组 int a[4] | std::array<int, 4> | std::vector<int> | |
|---|---|---|---|
| 存储 | 栈 | 栈 | 堆 |
| 大小固定 | ✅ | ✅ | ❌(可扩容) |
| STL 接口(begin/end/size/at) | ❌ | ✅ | ✅ |
| 越界检查 | 无 | at() 有 | at() 有 |
| 传参 | 退化为指针 | 值语义(不退化) | 引用传递 |
cpp
std::array<int, 4> a = {1, 2, 3, 4};
a.at(0); // 越界抛 std::out_of_range
// 作为函数参数时保持完整类型,不丢失长度信息要点:C 数组作为函数参数会退化为指针(丢失长度信息),
std::array不会。
3. 委托构造与继承构造(C++11)
cpp
class A {
int x_, y_;
public:
A(int x) : A(x, 0) {} // 委托构造:转发给另一个构造函数
A(int x, int y) : x_(x), y_(y) {}
};
class B : public A {
public:
using A::A; // 继承构造:直接继承基类构造函数
};
B b(1); // ✅ C++11 之前做不到注意:继承构造不会继承基类的拷贝/移动构造;委托构造不能形成环(编译器报错)。
4. using 类型别名(C++11)—— 能做 typedef 做不到的事
cpp
using IntPtr = int*; // 等价 typedef int* IntPtr;
// typedef 无法做的事:别名模板
template<typename T>
using Vec = std::vector<T>;
Vec<int> v; // = std::vector<int>
// 实际应用:简化冗长类型
template<typename T>
using Result = std::function<T()>;要点:
using可以定义别名模板,typedef不行——这是两者本质区别。
附录:速查总表
| 高频问题 | 答案要点 |
|---|---|
| auto vs decltype | auto 去引用/顶层const,decltype 保留全部;decltype(auto) 兼得两者 |
| nullptr vs NULL | nullptr 是 std::nullptr_t 类型,避免重载歧义 |
| unique_ptr vs shared_ptr | 独占 vs 共享;unique_ptr 零开销,shared_ptr 有引用计数控制块 |
| weak_ptr 作用 | 不增加引用计数,打破循环引用,观察者模式 |
| make_shared 优劣 | 1次分配缓存好,但 weak_ptr 存在时内存延迟释放 |
| 移动语义 | 右值引用 &&,"窃取"资源 O(1),原对象置空 |
| std::move vs std::forward | 无条件转右值 vs 完美转发(条件 cast) |
| Lambda 捕获 | [=] 值捕获,[&] 引用捕获,[] 不捕获,mutable 允许修改值捕获副本 |
| Lambda 底层 | 编译器生成匿名类 + operator();无捕获可转函数指针 |
| 可变参数模板 | Args... + 递归展开;C++17 折叠表达式 (args + ...) |
| constexpr vs const | constexpr 强制编译期求值,const 只保证不可修改 |
| if constexpr | 编译期分支,不满足条件的代码不参与编译 |
| 结构化绑定 | auto [a, b] = pair/tuple/struct,map 遍历神器 |
| optional vs 指针 | 语义明确的"可能有/无",值语义,不涉及所有权 |
| variant vs union | 类型安全的 union,知道当前存的是哪个类型 |
| string_view | 非拥有只读视图,零拷贝,注意生命周期 |
| CTAD | 类模板参数自动推导,pair{1, 2.5} |
| Ranges | 管道式懒求值,v | filter | transform |
| Concepts | 模板约束,清晰错误信息,替代 SFINAE |
| <=> | 三路比较,一个替代六个比较运算符 |
| span | 非拥有数据视图,比裸指针安全,比 vector& 灵活 |
| std::format | 类型安全格式化,替代 printf / iostream |
| 协程 | co_await/yield/return,用户态协作式,纳秒级切换 |
| 命名空间 | 避免命名冲突/组织代码;限定名 > using 声明 > using 指令;匿名命名空间=内部链接;inline namespace 管版本;ADL 实参依赖查找 |
| C++17/20 实用特性 | optional/variant/string_view/format/span/contains/starts_with |