Skip to content

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(去引用)
去掉顶层 constconst int ci = 1; auto a = ci;a 是 int(去顶层 const)
保留底层 constconst 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)
autodecltype
推导依据初始化表达式的值类别表达式的声明类型
保留引用?否(除非加 &)是
保留顶层 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?

NULLnullptr(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++1190%
shared_ptr共享(引用计数)C++119%
weak_ptr观察者(不影响引用计数)C++111%
auto_ptr已废弃(拷贝会转移所有权)C++980%(禁止使用)

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 resetrelease 只交还指针不释放;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_ptrshared_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 + 1relaxed只是计数,不需要与其他内存操作同步
析构时 use_count - 1acq_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_countweak_count触发动作
new 出第一个 shared_ptr11分配对象 + 控制块
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();

典型应用场景:

  1. 打破 shared_ptr 循环引用
  2. 观察者模式:Subject 持有 Observer 的 weak_ptr,Observer 可以不通知 Subject 就销毁
  3. 缓存系统:持有对象的 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() 或重新赋值后可指向新对象继续观察:

    cpp
    std::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_ptr

6. 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 扩容退化为拷贝!
};
移动操作是否 noexceptvector 扩容行为
声明了 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::movestd::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);  // 返回 15

C++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);     // -5

C++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 个实参 2

bind vs Lambda 如何选择:

对比std::bindLambda
可读性占位符晦涩,重排参数难读直观清晰(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 能做哪些事?(高频)

constconstexpr
含义运行期不可修改编译期就能确定值
初始化可在运行期初始化必须在编译期初始化
函数无可在编译期执行(传入编译期参数时)
变量位置可在只读数据段可在只读数据段或代码段
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 的好处:

  1. 编译期计算 → 运行时零开销
  2. 类型安全 的编译期常量(替代宏)
  3. 配合 static_assert 做编译期断言

容易混淆的关键点(追问):

  • const int C = 42; 用常量表达式初始化时,C 同样可用于数组大小等编译期场景——const 是"只读"承诺,constexpr 是"编译期可求值"承诺;区别在保证:constexpr 不满足编译期求值就直接编译错误,const 宽松得多
  • constexpr 函数传入运行期参数时,调用完全合法、退化为普通函数——"编译期执行"只在所有实参都是编译期常量时发生
  • 判断变量能否用于编译期场景,看它是否是常量表达式(constexpr 变量 ✓;const 变量需满足"常量表达式初始化 + 非 volatile")

十、其他 C++11 重要特性 ​

1. enum class —— 强类型枚举 ​

Q: enum class 和传统 enum 的区别?(高频)

传统 enumenum 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_guardC++11最简单的 RAII 锁,不可手动 unlock
unique_lockC++11可手动 unlock、延迟锁、try_lock,可与 condition_variable 搭配
scoped_lockC++17可同时锁多个 mutex(防死锁)
shared_lockC++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自旋锁(互斥锁的挂起开销远大于操作本身)
PageCachemmap 系统调用、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::atomicstd::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 有什么问题?

为什么需要内存序?—— 两个前提:

  1. 指令重排:编译器和 CPU 都会重排指令(流水线、乱序执行)——你以为的"先写 a 再写 b",在别的核看来可能是反的
  2. 缓存不可见:每个核心有自己的缓存,一个核的写入对另一个核不是立即可见的

原子操作只保证"操作本身不可分割"(原子性),不保证顺序。顺序保证由内存序指定——它规定:一个线程的写入,何时、以什么顺序对另一个线程可见。

核心钥匙: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_relacquire + 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::threadstd::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 的区别?

普通 ifif 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 + padding8 字节(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);     // 指针版,失败返回 nullptr
std::anystd::variantstd::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 constexprinline 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:

ConceptsSFINAEstatic_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 的优势:

  1. 懒求值:中间结果不分配内存
  2. 可组合:管道式链式调用
  3. 语法简洁:不再需要 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_viewstd::vector<T>&
元素类型任意 Tchar任意 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 InitializersC99 风格,Point{.x=1, .y=2}
using enumusing enum Color; 将枚举值引入当前作用域
likely/unlikelyif (x) [[likely]], 分支预测提示
std::source_location代替 __FILE__/__LINE__ 宏
contains()m.contains(key) 检查关联容器(终于有了!)
starts_with / ends_withs.starts_with("pre")(string / string_view)

十四、各版本特性速查 ​

C++11 核心新增 ​

类别特性一句话
类型auto、decltype编译期类型推导
空指针nullptr类型安全的空指针
智能指针unique_ptr, shared_ptr, weak_ptrRAII 管理内存
移动语义&&、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
Coroutinesco_await/co_yield/co_return 协程基础设施
<=>三路比较运算符,一个替代六个
consteval / constinit强制编译期函数 / 编译期初始化变量
span非拥有数据视图
format类型安全的格式化字符串
Modules替代 #include(编译加速)
Designated InitializersC 风格指定成员名初始化
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 有什么不能做的事? ​

答:

  1. Lambda 不能是模板(但 C++14 泛型 Lambda 变相支持了参数类型推导)
  2. C++20 前不能有模板参数列表(C++20 []<typename T>(T a){})
  3. 捕获的变量生命周期需自行管理(引用捕获不会延长变量生命周期)
  4. 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++11 enum 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 decltypeauto 去引用/顶层const,decltype 保留全部;decltype(auto) 兼得两者
nullptr vs NULLnullptr 是 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 constconstexpr 强制编译期求值,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