Lambda捕获详解

1. 学习目标

本章节遵循 Bloom 认知分类法（Bloom’s Taxonomy）组织学习目标，使读者能够循序渐进地掌握 C++ Lambda 表达式的捕获机制（capture），并具备在生产环境中设计、分析、评估 Lambda 捕获方案的能力。Lambda 捕获是 C++ 中最易错、也最强大的语言特性之一——它决定了闭包对象如何”持有”外部世界，进而决定了异步代码、回调代码、并发代码的安全性。

1.1 Remember（记忆）

• R1：复述 Lambda 表达式的完整语法骨架：[capture-list] (parameter-list) mutable -> return-type { body }，并能说出每个组成部分的可省略性。
• R2：背出 C++ 标准中”闭包类型（closure type）“的定义位置：ISO/IEC 14882:2020 §7.5.5 [expr.prim.lambda.closure]。
• R3：列出至少 8 种捕获形式：[x]、[&x]、[=]、[&]、[=, &x]、[&, x]、[p = expr]、[this]、[*this]、[...captures = args]，并说明每种形式的语义。
• R4：记住 C++11/14/17/20/23 五代标准对 Lambda 捕获机制的主要增补：初始化捕获（C++14）、*this 捕获（C++17）、包展开捕获与模板 Lambda（C++20）、显式对象参数递归 Lambda（C++23）。
• R5：背出”[=] 隐式捕获 this”在 C++20 中被弃用的历史（P0806 提案），并说明替代写法。

1.2 Understand（理解）

• U1：解释”闭包类型”与”闭包对象”的区别：闭包类型是编译器为每个 Lambda 生成的匿名类类型，闭包对象是该类的具体实例。
• U2：阐明值捕获与引用捕获在底层实现上的差异：值捕获对应闭包类的非静态数据成员（拷贝构造），引用捕获对应引用成员（指针语义）。
• U3：描述 mutable 关键字对闭包类 operator() 签名的影响：去除 const 修饰，允许修改值捕获的成员。
• U4：解释”初始化捕获”为何能解决”无法移动捕获”的痛点——传统的 [=] / [&] 不支持 std::move，初始化捕获通过 p = std::move(x) 表达式显式控制。
• U5：阐明 [this] 与 [*this] 的本质区别：前者捕获指针（浅捕获），后者拷贝整个对象（深捕获），二者在异步回调场景下的安全性截然不同。

1.3 Apply（应用）

• A1：使用初始化捕获将 std::unique_ptr 移动捕获进闭包，实现独占所有权的异步任务。
• A2：使用 [*this] 捕获在异步线程中安全访问对象成员，避免对象析构导致的悬空指针。
• A3：使用 std::shared_ptr 捕获延长资源生命周期，并配合 std::weak_ptr 捕获打破循环引用。
• A4：使用 C++23 显式对象参数 this auto self 实现递归 Lambda，替代传统 std::function 包装模式。

1.4 Analyze（分析）

• An1：分析 [=] 与 [&] 的”默认捕获”在大型代码库中导致的隐式依赖问题，给出团队规范建议。
• An2：分析 [this] 捕获在异步回调中的悬空风险，画出对象生命周期与回调执行时间线。
• An3：对比值捕获与引用捕获在循环中的语义差异：值捕获对循环变量的快照、引用捕获对循环变量的最终值。
• An4：分析 std::function 与 Lambda 闭包类型在类型擦除开销上的差异（堆分配、虚调用、异常安全）。

1.5 Evaluate（评价）

• E1：评价给定 Lambda 代码在捕获安全性、生命周期正确性、性能开销上的表现，给出 1-10 分的工程化评分。
• E2：判断在异步场景下应选用 [this]、[*this]、[shared_ptr]、[weak_ptr] 中的哪一种，给出决策树。
• E3：评估”在头文件中使用 Lambda 捕获”对编译时间与代码膨胀的影响。

1.6 Create（创造）

• C1：设计一个基于 Lambda 的线程池任务系统，支持移动捕获、超时取消、异常传播，并保证捕获资源的安全释放。
• C2：实现一个 RAII 风格的”作用域退出（scope exit）“工具，使用初始化捕获在构造时保存清理函数。
• C3：设计一个观察者模式的事件总线，使用 std::weak_ptr 捕获避免订阅者生命周期影响发布者。

2. 历史动机与发展脉络

2.1 史前时代：函数对象与回调困境（pre-2011）

C++98 时代没有 Lambda 表达式，处理回调与本地函数依赖三种工具：

1. 函数指针（function pointer）：最古老，但无法携带状态，不能捕获局部变量。
2. 函数对象（functor）：通过重载 operator() 的类携带状态，但定义一个类只为一次性使用，代码冗长。
3. std::bind1st / std::bind2nd / Boost.Bind：组合器风格，但语法晦涩，类型推导能力弱。

一个典型的”按字段排序”场景在 C++98 时代需要这样写：

// C++98：定义一个完整的 functor 类
struct CompareByAge {
    bool operator()(const Person& a, const Person& b) const {
        return a.age < b.age;
    }
};

std::sort(persons.begin(), persons.end(), CompareByAge());

如果排序字段需要在运行期决定（例如根据用户输入选择按年龄还是按姓名排序），就需要为每种字段定义一个 functor 类，或者使用复杂的 std::bind 组合。

2.2 C++11：Lambda 表达式诞生

C++11（ISO/IEC 14882:2011，N2927 提案）引入 Lambda 表达式，从根本上解决了”本地函数”问题：

// C++11：Lambda 替代 functor
std::sort(persons.begin(), persons.end(), [](const Person& a, const Person& b) {
    return a.age < b.age;
});

C++11 的 Lambda 捕获机制：

1. 值捕获 [x]：拷贝 x 到闭包。
2. 引用捕获 [&x]：持有 x 的引用。
3. 默认值捕获 [=]：拷贝所有使用的变量。
4. 默认引用捕获 [&]：引用所有使用的变量。
5. 混合捕获 [=, &x]：默认值捕获，x 引用捕获。
6. this 捕获 [this]：捕获当前对象的指针。

C++11 的最大痛点：无法移动捕获。如果一个对象不可拷贝（如 std::unique_ptr），就无法用 [=] 捕获，只能借助 std::bind 的 workaround：

// C++11 的丑陋 workaround：用 std::bind 模拟移动捕获
auto ptr = std::make_unique<int>(42);
auto f = std::bind([](std::unique_ptr<int>& p) { return *p; }, std::move(ptr));

这种写法晦涩难懂，且语义与 Lambda 捕获不一致。

2.3 C++14：初始化捕获（移动捕获）

C++14（N3648 提案）引入初始化捕获（init-capture），从根本上解决了移动捕获问题：

// C++14：直接移动捕获
auto ptr = std::make_unique<int>(42);
auto f = [p = std::move(ptr)]() { return *p; };
// ptr 此后为 nullptr

初始化捕获的语法：[name = initializer]，其中 name 是闭包成员的名字，initializer 是捕获时计算的表达式。这一特性还能用于：

1. 计算捕获：[value = x * 2] 捕获表达式的结果。
2. 别名捕获：[&ref = some_long_name.x] 用短名引用长名。
3. 类型变换捕获：[p = static_cast<long>(x)] 捕获时强制类型转换。

C++14 同时引入 Generic Lambda（auto 参数），但还不支持模板参数与包展开捕获。

2.4 C++17：*this 捕获与 constexpr Lambda

C++17（P0189 提案）引入 [*this] 捕获，解决了 [this] 在异步场景下的悬空指针问题：

struct Worker {
    int data = 42;
    auto getCallback() {
        // [*this] 拷贝整个对象到闭包，安全
        return [*this]() { return data; };
    }
};

C++17 同时引入：

1. constexpr Lambda：Lambda 可在编译期求值。
2. *this 在默认捕获中的处理：[=] 隐式捕获 this 被标记为”已弃用”的过渡期开始。
3. 捕获 *this 的常见场景：异步任务、定时器、事件回调。

2.5 C++20：模板 Lambda 与包展开捕获

C++20 引入两项关键改进：

2.5.1 模板 Lambda（P0428）

允许 Lambda 显式声明模板参数：

auto f = []<typename T>(T x) { return x; };
auto g = []<typename T, std::size_t N>(const std::array<T, N>& arr) {
    return arr.size();
};

2.5.2 包展开捕获（P0780、P2095）

允许 Lambda 捕获参数包：

template<typename... Args>
auto make_callback(Args... args) {
    return [...captures = std::move(args)]() {
        return (captures + ... + 0);
    };
}

C++20 同时正式弃用 [=] 隐式捕获 this（P0806），要求显式写 [=, this] 或 [=, *this]：

struct S {
    int x;
    auto f() {
        // C++17：[=] 隐式捕获 this（已弃用）
        // return [=] { return x; };

        // C++20：必须显式捕获
        return [=, this] { return x; };     // 显式
        // 或
        return [=, *this] { return x; };   // 拷贝
    }
};

2.6 C++23：显式对象参数（递归 Lambda）

C++23（P0847）引入显式对象参数（deducing this），从根本上解决了 Lambda 不能递归的问题：

// C++23：递归 Lambda
auto fibonacci = [](this auto self, int n) -> int {
    return n <= 1 ? n : self(n - 1) + self(n - 2);
};

std::cout << fibonacci(10) << std::endl;  // 55

显式对象参数的额外用途：

1. 推导值类别：this Self&& self 可区分左值/右值调用。
2. CRTP 替代：简化静态多态的语法。
3. 链式调用：根据对象 const 性质选择不同重载。

C++23 同时引入 static operator()，使无状态 Lambda 可以作为函数指针更自然地传递。

2.7 C++26：反射与异步整合

C++26 提案中与 Lambda 捕获相关的方向：

1. 反射（P2996）：枚举闭包类型的成员，调试与分析闭包捕获。
2. 结构化绑定捕获：提案允许 [const auto& [k, v] = pair] 直接捕获结构化绑定。
3. 协程与 Lambda 整合：改进 Lambda 在协程上下文中的捕获语义。

2.8 时间线总结表

3. 形式化定义

3.1 ISO/IEC 14882 中的 Lambda 表达式定义

ISO/IEC 14882:2020 §7.5.5 [expr.prim.lambda] 给出 Lambda 表达式的形式化语法：

lambda-expression:
    lambda-introducer lambda-declarator compound-statement

lambda-introducer:
    [ lambda-capture ]

lambda-capture:
    capture-default
    capture-list
    capture-default , capture-list

capture-default:
    &
    =

capture-list:
    capture ...opt
    capture-list , capture ...opt

capture:
    simple-capture
    init-capture

simple-capture:
    identifier ...opt
    & identifier ...opt
    this
    * this

init-capture:
    identifier initializer ...opt
    & identifier initializer

3.2 闭包类型的形式化定义

ISO/IEC 14882:2020 §7.5.5.1 [expr.prim.lambda.closure] 第 1 段：

The type of a lambda-expression (which is also the type of the closure object) is a unique, unnamed non-union class type, called the closure type, whose properties are described below.

（Lambda 表达式的类型（也是闭包对象的类型）是一个唯一的、未命名的非联合类类型，称为闭包类型，其性质如下所述。）

关键性质：

1. 唯一性：每个 Lambda 表达式产生一个唯一的闭包类型，即使两个 Lambda 的代码完全相同。
2. 未命名：闭包类型无法用类型名直接引用，只能通过 decltype 或 auto 间接使用。
3. 非聚合：闭包类型不是聚合类型，不能使用聚合初始化。

3.3 闭包类型的成员构成

闭包类型的成员由 Lambda 的捕获方式决定：

int x = 10;
int y = 20;

auto f = [x, &y](int z) { return x + y + z; };

编译器生成的闭包类型等价于：

class __closure_unique_name {
private:
    int x_;        // 值捕获：拷贝成员
    int& y_;       // 引用捕获：引用成员（指针实现）

public:
    __closure_unique_name(int x, int& y) : x_(x), y_(y) {}

    auto operator()(int z) const {  // 默认 const
        return x_ + y_ + z;
    }
};

// 闭包对象创建
auto f = __closure_unique_name(x, y);

3.4 mutable 的形式化影响

不带 mutable 的 Lambda，其 operator() 是 const 成员函数：

class __closure {
public:
    auto operator()(int z) const { /* 不能修改 x_ */ }
};

带 mutable 的 Lambda，其 operator() 是非 const 成员函数：

class __closure {
public:
    auto operator()(int z) { /* 可以修改 x_ */ }
};

注意：mutable 仅影响值捕获的成员，不影响引用捕获的成员——引用本身是 const 的（不能重新绑定），但通过引用可以修改被引用对象。

3.5 值捕获的形式化语义

ISO/IEC 14882:2020 §7.5.5.2 [expr.prim.lambda.capture] 第 13 段：

An entity is captured by copy if it is implicitly captured and the capture-default is = or if it is explicitly captured with a capture that is not of the form & identifier or & this.

（如果实体被隐式捕获且默认捕获是 =，或者被显式捕获且捕获形式不是 & identifier 或 & this，则该实体被值捕获。）

值捕获的成员初始化等价于：

3.6 引用捕获的形式化语义

ISO/IEC 14882:2020 §7.5.5.2 第 14 段：

An entity is captured by reference if it is implicitly captured and the capture-default is & or if it is explicitly captured with a capture of the form & identifier, & this, or & identifier initializer.

（如果实体被隐式捕获且默认捕获是 &，或者被显式捕获且捕获形式是 & identifier、& this、& identifier initializer，则该实体被引用捕获。）

引用捕获的成员初始化等价于：

3.7 初始化捕获的形式化语义

ISO/IEC 14882:2020 §7.5.5.2 第 7 段：

An init-capture behaves as if it declares and explicitly captures a variable of the form auto init-capture-declarator; whose scope is the body of the lambda-expression.

（初始化捕获的行为就像声明并显式捕获了一个 auto init-capture-declarator; 形式的变量，其作用域是 Lambda 表达式的函数体。）

具体语义：

1. 在闭包类型中生成一个成员，类型由 auto 推导。
2. 在闭包对象构造时，用 initializer 初始化该成员。
3. 该成员的名字是 identifier。

例如 [p = std::move(ptr)] 等价于在闭包中：

class __closure {
    std::unique_ptr<int> p;  // 由 std::move(ptr) 初始化
public:
    // ...
};

3.8 [this] 与 [*this] 的形式化语义

ISO/IEC 14882:2020 §7.5.5.2 第 16 段：

When this is captured, the closure type contains a member of type T* where T is the type of the enclosing class.

当 *this is captured, the closure type contains a member of type T (a copy of the object).

3.9 捕获查找规则

ISO/IEC 14882:2020 §7.5.5.2 第 9 段规定，Lambda 函数体中对捕获变量的访问遵循以下规则：

1. 优先查找闭包类型的成员（捕获产生的成员）。
2. 若未找到，再向外层作用域查找。

这一规则导致一个微妙的行为：Lambda 函数体中可以使用与外层同名的局部变量，但实际访问的是捕获的副本。

int x = 10;
auto f = [x]() {
    int x = 20;  // 局部变量遮蔽捕获的 x
    return x;     // 返回 20
};

4. 理论推导与原理解析

4.1 闭包类型的内存布局

闭包类型的内存布局由其捕获成员决定。考虑：

struct S {
    int a;
    double b;
    std::string c;
};

void f() {
    int x = 1;
    double y = 2.0;
    std::string z = "hello";

    auto lambda = [x, &y, z](int param) {
        return x + y + z.size() + param;
    };
}

编译器生成的闭包类型布局（伪代码）：

class __closure {
    int x_;           // 4 字节（值捕获）
    double& y_;       // 8 字节（指针实现引用）
    std::string z_;   // 24-32 字节（值捕获，包含 SSO 缓冲区）

public:
    __closure(int x, double& y, std::string z)
        : x_(x), y_(y), z_(std::move(z)) {}

    auto operator()(int param) const {
        return x_ + y_ + z_.size() + param;
    }
};

闭包对象的总大小约为 4 + 8 + 32 = 44 字节（加上对齐填充，实际可能是 48 或 56 字节）。

4.2 值捕获的快照语义

值捕获在 Lambda 创建时 拷贝变量的当前值，后续对原变量的修改不影响闭包：

int x = 10;
auto f = [x]() { return x; };  // 闭包内 x = 10
x = 20;                          // 修改原变量
std::cout << f() << std::endl;   // 输出 10（值捕获的快照）

这一语义在循环中尤为重要：

std::vector<std::function<int()>> callbacks;

// 反模式：值捕获循环变量的快照
for (int i = 0; i < 3; ++i) {
    callbacks.push_back([i]() { return i; });  // 捕获 i 的当前值
}

// 反模式：引用捕获循环变量（悬空引用！）
for (int i = 0; i < 3; ++i) {
    callbacks.push_back([&i]() { return i; });  // 危险：所有回调都引用同一个 i
}

for (const auto& cb : callbacks) {
    std::cout << cb() << " ";  // 第一种：0 1 2；第二种：3 3 3（UB：i 已超出作用域）
}

4.3 引用捕获的别名语义

引用捕获在闭包中持有原变量的引用，对闭包内变量的修改影响原变量：

int x = 10;
auto f = [&x]() { ++x; };
f();
std::cout << x << std::endl;  // 输出 11

引用捕获的潜在风险：

1. 悬空引用：被引用变量生命周期结束后，闭包仍持有引用。
2. 数据竞争：多线程并发访问被引用变量。
3. 意外修改：闭包意外修改了不该修改的变量。

// 危险示例：返回引用捕获局部变量的 Lambda
std::function<int()> makeBadLambda() {
    int local = 42;
    return [&local]() { return local; };  // local 离开作用域后悬空
}

auto f = makeBadLambda();
std::cout << f() << std::endl;  // UB：访问已销毁的 local

4.4 mutable 的语义分析

mutable 仅影响值捕获成员的 const 性质：

int count = 0;

// 不带 mutable：operator() 是 const，不能修改值捕获成员
auto f1 = [count]() {
    // ++count;  // 编译错误：operator() 是 const
    return count;
};

// 带 mutable：operator() 不是 const，可以修改值捕获成员
auto f2 = [count]() mutable {
    return ++count;  // 修改的是闭包中的副本
};

std::cout << f2() << std::endl;  // 1
std::cout << f2() << std::endl;  // 2
std::cout << count << std::endl;  // 0（原变量未改变）

每次调用 f2 时，闭包成员 count 被修改并保持状态。这是 Lambda 作为有状态闭包的核心机制。

4.5 初始化捕获的推导机制

初始化捕获 [name = initializer] 的语义：

1. 编译器在闭包类型中生成一个成员 name。
2. 成员的类型由 auto 推导（如同 auto name = initializer;）。
3. 成员在闭包对象构造时由 initializer 初始化。

auto ptr = std::make_unique<int>(42);
auto f = [p = std::move(ptr)]() { return *p; };

等价于：

class __closure {
    std::unique_ptr<int> p;  // 由 std::move(ptr) 初始化

public:
    __closure(std::unique_ptr<int> p) : p(std::move(p)) {}
    auto operator()() const { return *p; }
};

引用版本的初始化捕获 [&name = initializer]：

std::map<int, std::string> m = {{1, "one"}, {2, "two"}};
auto f = [&ref = m[1]]() { return ref; };  // ref 引用 m[1]

4.6 [this] 与 [*this] 的语义对比

[this] 捕获对象指针，闭包通过指针访问对象成员：

struct Worker {
    int data = 42;

    auto getCallback() {
        return [this]() { return data; };
        // 等价于：
        // return [this]() { return this->data; };
    }
};

Worker w;
auto f = w.getCallback();
std::cout << f() << std::endl;  // 42（依赖 w 存活）

[*this]（C++17）捕获对象副本，闭包独立持有对象：

struct Worker {
    int data = 42;

    auto getCallback() {
        return [*this]() { return data; };
        // 闭包内有一个 Worker 类型的成员，由 *this 拷贝构造
    }
};

Worker w;
auto f = w.getCallback();
// 即使 w 被销毁，f 仍可调用
std::cout << f() << std::endl;  // 42（独立持有副本）

4.7 异步场景下的捕获安全性

异步场景下，闭包的生命周期可能超过被捕获变量的生命周期。这是 Lambda 捕获最危险的场景：

// 反模式：异步任务引用捕获局部变量
void badAsync() {
    int local = 42;
    std::thread([&local]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << local << std::endl;  // UB：local 已销毁
    }).detach();
}  // local 离开作用域后被销毁

// 正确模式：值捕获
void goodAsync() {
    int local = 42;
    std::thread([local]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << local << std::endl;  // 安全：闭包持有副本
    }).detach();
}  // local 销毁，但闭包内仍有副本

4.8 std::function 与闭包类型的开销对比

std::function 是类型擦除的调用包装器，相比直接使用闭包类型有以下开销：

// 推荐：直接使用 auto
auto f1 = [x](int n) { return x + n; };  // 高效

// 仅在需要存储异构 Lambda 时使用 std::function
std::function<int(int)> f2 = [x](int n) { return x + n; };  // 有额外开销

5. 代码示例与实战详解

5.1 基础捕获示例

#include <iostream>
#include <string>

int main() {
    int x = 10;
    int y = 20;
    std::string name = "Alice";

    // 1. 值捕获
    auto f1 = [x]() { return x; };

    // 2. 引用捕获
    auto f2 = [&x]() { return ++x; };

    // 3. 全部值捕获
    auto f3 = [=]() { return x + y; };

    // 4. 全部引用捕获
    auto f4 = [&]() { return x + y; };

    // 5. 混合捕获
    auto f5 = [x, &y]() { return x + y; };

    // 6. 初始化捕获（C++14）
    auto f6 = [name_copy = name]() { return name_copy; };

    // 7. 移动捕获（C++14）
    auto f7 = [name_move = std::move(name)]() { return name_move; };
    std::cout << "name after move: " << (name.empty() ? "(empty)" : name) << std::endl;

    // 8. 计算捕获
    auto f8 = [sum = x + y]() { return sum; };

    return 0;
}

5.2 mutable 状态机示例

#include <iostream>
#include <functional>

int main() {
    // 状态机：累加器
    auto accumulator = [sum = 0](int x) mutable {
        sum += x;
        return sum;
    };

    std::cout << accumulator(10) << std::endl;  // 10
    std::cout << accumulator(20) << std::endl;  // 30
    std::cout << accumulator(30) << std::endl;  // 60

    // 状态机：ID 生成器
    auto idGen = [next = 1]() mutable {
        return next++;
    };

    std::cout << idGen() << std::endl;  // 1
    std::cout << idGen() << std::endl;  // 2
    std::cout << idGen() << std::endl;  // 3

    return 0;
}

5.3 异步回调安全捕获

#include <iostream>
#include <thread>
#include <memory>
#include <functional>

class AsyncWorker {
private:
    int data_ = 42;

public:
    // 危险：[this] 在异步场景下悬空
    void startBadAsync() {
        std::thread([this]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Bad: " << data_ << std::endl;  // 可能 UB
        }).detach();
    }

    // 安全：[*this] 拷贝对象（C++17）
    void startSafeAsyncCopy() {
        std::thread([*this]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Safe copy: " << data_ << std::endl;
        }).detach();
    }

    // 安全：[shared_ptr] 共享所有权
    void startSafeAsyncShared() {
        auto self = std::make_shared<decltype(*this)>(*this);
        std::thread([self]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << "Safe shared: " << self->data_ << std::endl;
        }).detach();
    }
};

int main() {
    {
        AsyncWorker w;
        w.startSafeAsyncCopy();
        w.startSafeAsyncShared();
        // w 离开作用域，但闭包内仍持有副本或 shared_ptr
    }

    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

5.4 信号槽系统

#include <functional>
#include <vector>
#include <string>
#include <iostream>

class Signal {
public:
    using Slot = std::function<void(int)>;

    void connect(Slot slot) {
        slots_.push_back(std::move(slot));
    }

    void emit(int value) {
        for (const auto& slot : slots_) {
            slot(value);
        }
    }

private:
    std::vector<Slot> slots_;
};

class Observer {
public:
    Observer(Signal& sig, std::string name) : name_(std::move(name)) {
        // 安全捕获：拷贝 name_，不依赖 this 生命周期
        sig.connect([name = name_](int value) {
            std::cout << name << " received: " << value << std::endl;
        });
    }

private:
    std::string name_;
};

int main() {
    Signal signal;
    {
        Observer o1(signal, "Observer-1");
        Observer o2(signal, "Observer-2");
    }  // o1, o2 离开作用域，但闭包内仍持有 name 副本

    signal.emit(42);  // 输出：Observer-1 received: 42 / Observer-2 received: 42
    return 0;
}

5.5 移动捕获（C++14）

#include <memory>
#include <iostream>
#include <thread>

// 移动捕获 unique_ptr：异步任务独占所有权
void asyncTaskWithOwnership() {
    auto resource = std::make_unique<int>(100);

    std::thread([r = std::move(resource)]() {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "Resource value: " << *r << std::endl;
    }).detach();

    // resource 此处为 nullptr
    std::cout << "resource is null: " << (resource == nullptr) << std::endl;
}

// 移动捕获大对象：避免拷贝
void moveLargeObject() {
    std::vector<int> big_data(1'000'000, 42);

    std::thread([data = std::move(big_data)]() {
        std::cout << "Data size: " << data.size() << std::endl;
        std::cout << "First element: " << data[0] << std::endl;
    }).detach();

    // big_data 此处为空
    std::cout << "big_data size after move: " << big_data.size() << std::endl;
}

int main() {
    asyncTaskWithOwnership();
    moveLargeObject();
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}

5.6 *this 捕获（C++17）

#include <iostream>
#include <thread>
#include <vector>

class Worker {
private:
    std::string name_;
    std::vector<int> data_;

public:
    Worker(std::string name) : name_(std::move(name)), data_(100, 42) {}

    // [*this] 拷贝整个对象到闭包
    auto makeSafeCallback() const {
        return [*this]() {
            std::cout << name_ << " has " << data_.size() << " items" << std::endl;
        };
    }

    // [this] 依赖对象存活（危险）
    auto makeUnsafeCallback() const {
        return [this]() {
            std::cout << name_ << " has " << data_.size() << " items" << std::endl;
        };
    }
};

int main() {
    std::function<void()> safe_cb, unsafe_cb;

    {
        Worker w("Worker-1");
        safe_cb = w.makeSafeCallback();
        unsafe_cb = w.makeUnsafeCallback();
    }  // w 此处被销毁

    safe_cb();   // 安全：输出 Worker-1 has 100 items
    // unsafe_cb();  // UB：访问已销毁的 w 的成员
    return 0;
}

5.7 智能指针捕获模式

#include <memory>
#include <iostream>
#include <functional>

class Resource {
public:
    Resource() { std::cout << "Resource acquired" << std::endl; }
    ~Resource() { std::cout << "Resource released" << std::endl; }
    void use() { std::cout << "Resource used" << std::endl; }
};

// 模式 1：shared_ptr 捕获延长生命周期
std::function<void()> createSharedCallback() {
    auto res = std::make_shared<Resource>();
    return [res]() {  // 捕获 shared_ptr 副本，引用计数 +1
        res->use();
    };
}  // 原始 res 析构，但闭包内的副本仍持有

// 模式 2：weak_ptr 捕获避免循环引用
std::function<void()> createWeakCallback(std::shared_ptr<Resource> res) {
    std::weak_ptr<Resource> weak = res;
    return [weak]() {
        if (auto locked = weak.lock()) {
            locked->use();  // 资源仍存活
        } else {
            std::cout << "Resource already released" << std::endl;
        }
    };
}

// 模式 3：unique_ptr 移动捕获（C++14）
std::function<void()> createUniqueCallback() {
    auto res = std::make_unique<Resource>();
    return [r = std::move(res)]() mutable {  // mutable 才能修改 r
        if (r) r->use();
    };
}

int main() {
    auto cb1 = createSharedCallback();
    cb1();  // Resource used

    auto res = std::make_shared<Resource>();
    auto cb2 = createWeakCallback(res);
    cb2();  // Resource used
    res.reset();
    cb2();  // Resource already released

    auto cb3 = createUniqueCallback();
    cb3();  // Resource used

    return 0;
}

5.8 C++20 包展开捕获

#include <iostream>
#include <tuple>
#include <utility>

// C++20：在 Lambda 中捕获参数包
template<typename... Args>
auto makeCallback(Args... args) {
    return [...captures = std::move(args)]() {
        return (captures + ... + 0);  // 折叠表达式
    };
}

// C++20：移动捕获参数包
template<typename... Args>
auto makeMoveCallback(Args... args) {
    return [...captures = std::move(args)]() mutable {
        // 处理每个捕获的元素
        ((std::cout << captures << " "), ...);
        std::cout << std::endl;
    };
}

// C++20：引用捕获参数包
template<typename... Args>
auto makeRefCallback(Args&... args) {
    return [&...captures = args]() {
        return (captures + ... + 0);
    };
}

int main() {
    auto cb1 = makeCallback(1, 2, 3, 4, 5);
    std::cout << "Sum: " << cb1() << std::endl;  // 15

    auto cb2 = makeMoveCallback(1, "hello", 3.14);  // 输出：1 hello 3.14

    int a = 10, b = 20, c = 30;
    auto cb3 = makeRefCallback(a, b, c);
    a = 100;  // 修改原变量
    std::cout << "Sum ref: " << cb3() << std::endl;  // 150

    return 0;
}

5.9 C++23 递归 Lambda

#include <iostream>

// C++23：显式对象参数实现递归 Lambda
auto fibonacci = [](this auto self, int n) -> int {
    return n <= 1 ? n : self(n - 1) + self(n - 2);
};

// 通用递归：带记忆化
auto memoizedFib = [](this auto self, int n) -> int {
    static std::map<int, int> cache;
    auto it = cache.find(n);
    if (it != cache.end()) return it->second;
    int result = n <= 1 ? n : self(n - 1) + self(n - 2);
    cache[n] = result;
    return result;
};

// 树遍历
struct TreeNode {
    int value;
    std::vector<TreeNode> children;
};

auto sumTree = [](this auto self, const TreeNode& node) -> int {
    int total = node.value;
    for (const auto& child : node.children) {
        total += self(child);
    }
    return total;
};

int main() {
    std::cout << "fib(10) = " << fibonacci(10) << std::endl;  // 55
    std::cout << "memo_fib(50) = " << memoizedFib(50) << std::endl;  // 快速
    return 0;
}

5.10 泛型与模板 Lambda

#include <iostream>
#include <vector>
#include <algorithm>

// C++14：Generic Lambda（auto 参数）
auto add = [](auto a, auto b) { return a + b; };

// C++20：模板 Lambda（显式模板参数）
auto templateAdd = []<typename T, typename U>(T a, U b) {
    return a + b;
};

// C++20：模板 Lambda 与容器
auto sumElements = []<typename T, std::size_t N>(const std::array<T, N>& arr) {
    T sum{};
    for (const auto& elem : arr) sum += elem;
    return sum;
};

// C++14：完美转发 Lambda
auto makeWrapper = [](auto&& func) {
    return [f = std::forward<decltype(func)>(func)](auto&&... args) mutable {
        return f(std::forward<decltype(args)>(args)...);
    };
};

int main() {
    std::cout << add(1, 2) << std::endl;        // 3
    std::cout << add(1.5, 2.5) << std::endl;     // 4
    std::cout << add(std::string("a"), "b") << std::endl;  // ab

    std::array<int, 5> arr = {1, 2, 3, 4, 5};
    std::cout << "Sum: " << sumElements(arr) << std::endl;  // 15

    return 0;
}

6. 跨语言对比

6.1 与 Rust 闭包对比

Rust 的闭包机制与 C++ 在理念上相似，但在所有权与生命周期上更严格：

// Rust：Fn / FnMut / FnOnce 三种闭包类型
fn main() {
    let x = 10;

    // 不可变借用（对应 C++ 的 [x] 或 [=]）
    let f1 = || println!("{}", x);

    // 可变借用（对应 C++ 的 mutable [x]）
    let mut y = 0;
    let mut f2 = || { y += 1; println!("{}", y); };

    // 转移所有权（对应 C++14 的 [x = std::move(x)]）
    let s = String::from("hello");
    let f3 = move || println!("{}", s);  // s 所有权转移到闭包
}

6.2 与 Java Lambda 对比

Java 的 Lambda 只能捕获 final 或 effectively final 的局部变量，从根本上避免了悬空引用：

import java.util.*;
import java.util.function.*;

public class Main {
    public static void main(String[] args) {
        int x = 10;
        // x = 20;  // 错误：Lambda 捕获的变量必须是 effectively final

        Supplier<Integer> f = () -> x + 1;
        System.out.println(f.get());  // 11
    }
}

Java Lambda 的特点：

1. 只能值捕获（且变量必须 final）。
2. 不能引用捕获。
3. 闭包对象是 Object 子类，有装箱开销。
4. 通过函数式接口（Functional Interface）实现类型擦除。

6.3 与 Go 闭包对比

Go 的闭包默认引用捕获，但有垃圾回收机制保证安全：

package main

import "fmt"

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    c := counter()
    fmt.Println(c())  // 1
    fmt.Println(c())  // 2
    fmt.Println(c())  // 3
}

Go 闭包的特点：

1. 自动引用捕获（变量逃逸到堆）。
2. 垃圾回收避免悬空引用。
3. 性能略低（堆分配 + 间接访问）。

6.4 与 C# 闭包对比

C# 的闭包也是引用捕获，且变量在循环中共享：

using System;
using System.Collections.Generic;

class Program {
    static void Main() {
        var actions = new List<Action>();

        // C# 5.0+ 后每次迭代创建新变量
        for (int i = 0; i < 3; i++) {
            int local = i;  // 必须显式创建局部副本
            actions.Add(() => Console.WriteLine(local));
        }

        foreach (var a in actions) a();  // 输出：0 1 2
    }
}

6.5 综合对比表

C++ 的 Lambda 捕获机制在性能上最优（零开销），但在安全性上要求程序员自行管理生命周期。

7. 常见陷阱与反模式

7.1 悬空引用

// 反模式：返回引用捕获局部变量的 Lambda
std::function<int()> badFunction() {
    int local = 42;
    return [&local]() { return local; };  // local 离开作用域后悬空
}

auto f = badFunction();
std::cout << f() << std::endl;  // UB

修复：改为值捕获。

std::function<int()> goodFunction() {
    int local = 42;
    return [local]() { return local; };  // 值捕获，安全
}

7.2 循环中的引用捕获

// 反模式：循环中引用捕获
std::vector<std::function<void()>> callbacks;

for (int i = 0; i < 3; ++i) {
    callbacks.push_back([&i]() { std::cout << i << std::endl; });
}

for (const auto& cb : callbacks) {
    cb();  // 输出：3 3 3（如果 i 仍在作用域）或 UB
}

修复：值捕获。

for (int i = 0; i < 3; ++i) {
    callbacks.push_back([i]() { std::cout << i << std::endl; });
}
// 输出：0 1 2

7.3 [=] 隐式捕获 this（C++20 弃用）

struct S {
    int x;
    auto badLambda() {
        return [=] { return x; };  // C++20 弃用：[=] 隐式捕获 this
    }
};

修复：显式捕获。

auto goodLambda() {
    return [=, this] { return x; };  // 显式 [this]
    // 或
    return [=, *this] { return x; };  // 拷贝对象（C++17）
}

7.4 异步 [this] 悬空

// 反模式：异步任务 [this] 捕获
struct Worker {
    int data = 42;

    void startAsync() {
        std::thread([this]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::cout << data << std::endl;  // 可能 UB：this 悬空
        }).detach();
    }
};

修复：使用 [*this]（C++17）或 shared_ptr 捕获。

7.5 mutable 滥用

// 反模式：不必要的 mutable
auto f = [x]() mutable {
    return x + 1;  // 不修改 x，但声明了 mutable
};

mutable 仅在确实需要修改值捕获成员时使用。不必要的 mutable 会让编译器无法将闭包对象视为 const，影响优化。

7.6 默认捕获 [&] 隐式依赖

// 反模式：[&] 隐式捕获所有变量
void processData(int a, int b, int c) {
    auto f = [&]() { return a + b + c; };
    // 难以判断 a, b, c 是否都被引用
    // 修改 a, b, c 会影响闭包行为
}

修复：显式列出每个捕获。

auto f = [&a, &b, &c]() { return a + b + c; };

7.7 捕获大对象导致闭包膨胀

// 反模式：值捕获大对象
std::vector<int> big_data(1'000'000, 42);
auto f = [big_data]() {  // 拷贝 4MB 数据到闭包
    return big_data[0];
};

修复：移动捕获或引用捕获（视场景）。

auto f = [data = std::move(big_data)]() {  // 移动捕获
    return data[0];
};
// 或
auto f = [&big_data]() {  // 引用捕获（确保生命周期安全）
    return big_data[0];
};

7.8 std::function 与不可复制闭包

// 反模式：将不可复制的闭包赋给 std::function
auto ptr = std::make_unique<int>(42);
std::function<int()> f = [p = std::move(ptr)]() { return *p; };  // 编译错误

std::function 要求可复制构造，而 unique_ptr 成员使闭包不可复制。

修复：使用 std::move_only_function（C++23）或直接用 auto。

// C++23
std::move_only_function<int()> f = [p = std::move(ptr)]() { return *p; };

// 或直接 auto
auto f = [p = std::move(ptr)]() { return *p; };

7.9 捕获与异常安全

// 反模式：捕获异常对象
try {
    throw std::runtime_error("error");
} catch (const std::exception& e) {
    auto f = [&e]() { return e.what(); };  // 危险：e 离开 catch 块后销毁
    // ... 异步使用 f ...
}

修复：值捕获或拷贝异常。

try {
    throw std::runtime_error("error");
} catch (std::exception e) {  // 值捕获异常
    auto f = [e]() { return e.what(); };
}

7.10 递归 Lambda 的旧 workaround

// C++11/14 的丑陋递归 Lambda workaround
std::function<int(int)> fib;
fib = [&fib](int n) {
    return n <= 1 ? n : fib(n - 1) + fib(n - 2);
};

// 问题：
// 1. 必须用 std::function，有额外开销
// 2. 引用捕获 fib 自身，潜在悬空
// 3. 性能差（虚调用）

修复：使用 C++23 显式对象参数。

auto fib = [](this auto self, int n) -> int {
    return n <= 1 ? n : self(n - 1) + self(n - 2);
};

8. 工程实践

8.1 团队规范建议

1. 禁止使用 [=] 和 [&] 默认捕获：显式列出每个捕获变量，提高可读性与可维护性。
2. 异步场景必须使用值捕获或智能指针捕获：禁止引用捕获，避免悬空。
3. 优先使用初始化捕获（C++14）：替代 [=] / [&]，显式控制捕获语义。
4. [this] 捕获需文档说明：异步场景下必须用 [*this] 或 shared_ptr。
5. 避免在头文件中暴露复杂 Lambda：可能导致编译时间膨胀。
6. mutable 仅在必要时使用：默认不带 mutable，需要状态修改时显式声明。

8.2 性能优化建议

1. 优先使用 auto 而非 std::function：避免类型擦除开销。
2. 小对象优先值捕获：避免引用带来的间接访问。
3. 大对象使用移动捕获或引用捕获：根据所有权语义选择。
4. 避免在热路径构造 Lambda：闭包对象构造有开销。
5. noexcept Lambda：标记 noexcept 帮助编译器优化。

8.3 异步捕获模式决策树

异步任务需要捕获对象？
├── 否 → 值捕获简单类型
└── 是 → 需要修改原对象？
    ├── 是 → shared_ptr 捕获（共享所有权）
    └── 否 → 只读访问？
        ├── 是 → 拷贝对象（[*this] 或 [shared_ptr]）
        └── 否 → weak_ptr 捕获（避免延长生命周期）

8.4 编译期检查技巧

// 编译期检查闭包类型大小
auto f = [x = 42, y = 3.14]() { return x + y; };
static_assert(sizeof(f) <= 16, "Closure too large");  // 编译期断言

// 检查闭包是否可拷贝
static_assert(std::is_copy_constructible_v<decltype(f)>);
static_assert(std::is_trivially_copyable_v<decltype(f)>);  // 可能失败

8.5 调试技巧

// 使用 typeinfo 查看闭包类型
#include <typeinfo>
#include <cxxabi.h>

auto f = [x = 42]() { return x; };
int status;
char* name = abi::__cxa_demangle(typeid(f).name(), 0, 0, &status);
std::cout << "Closure type: " << name << std::endl;  // 输出匿名类型名
free(name);

// 使用 static_assert 检查闭包成员
static_assert(std::is_class_v<decltype(f)>);

8.6 测试策略

1. 单元测试 Lambda 行为：测试闭包的状态变化、捕获正确性。
2. 生命周期测试：异步场景下验证捕获对象的安全释放。
3. 性能基准：对比 auto 与 std::function 的调用开销。
4. 并发测试：多线程场景下验证捕获对象的线程安全。

8.7 与 std::function 的协作

#include <functional>
#include <vector>
#include <memory>

// 异构 Lambda 存储必须用 std::function
std::vector<std::function<void(int)>> callbacks;

callbacks.push_back([x = 10](int n) { std::cout << x + n << std::endl; });
callbacks.push_back([name = "Alice"](int n) { std::cout << name << ": " << n << std::endl; });

for (const auto& cb : callbacks) {
    cb(42);
}

// C++23：move_only_function 支持不可复制闭包
std::vector<std::move_only_function<void()>> unique_callbacks;
unique_callbacks.push_back([p = std::make_unique<int>(42)]() {
    std::cout << *p << std::endl;
});

8.8 与协程整合

#include <coroutine>
#include <iostream>

// 协程中的 Lambda 捕获需要特别小心
Task<void> asyncWork() {
    auto state = std::make_shared<int>(0);

    // 协程 Lambda 必须值捕获，不能引用捕获局部变量
    auto lambda = [state]() -> Task<void> {
        co_await std::suspend_always{};
        ++(*state);
        std::cout << "State: " << *state << std::endl;
    };

    co_await lambda();
}

9. 案例分析

9.1 案例：线程池任务系统

#include <functional>
#include <future>
#include <queue>
#include <thread>
#include <vector>
#include <memory>

class ThreadPool {
public:
    ThreadPool(size_t threads) : stop_(false) {
        for (size_t i = 0; i < threads; ++i) {
            workers_.emplace_back([this]() {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex_);
                        condition_.wait(lock, [this]() {
                            return stop_ || !tasks_.empty();
                        });
                        if (stop_ && tasks_.empty()) return;
                        task = std::move(tasks_.front());
                        tasks_.pop();
                    }
                    task();
                }
            });
        }
    }

    template<typename F, typename... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<decltype(f(args...))> {
        using ReturnType = decltype(f(args...));
        auto task = std::make_shared<std::packaged_task<ReturnType()>>(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );

        auto result = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            tasks_.emplace([task]() { (*task)(); });  // 捕获 shared_ptr
        }
        condition_.notify_one();
        return result;
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            stop_ = true;
        }
        condition_.notify_all();
        for (auto& worker : workers_) {
            worker.join();
        }
    }

private:
    std::vector<std::thread> workers_;
    std::queue<std::function<void()>> tasks_;
    std::mutex queue_mutex_;
    std::condition_variable condition_;
    bool stop_;
};

分析：

• 工作线程 Lambda 捕获 [this] 访问线程池成员，依赖线程池对象存活。
• 任务队列使用 std::function<void()>，通过 shared_ptr 捕获 packaged_task 实现移动语义。
• 这种设计确保任务可以包含 unique_ptr 等不可复制资源。

9.2 案例：作用域退出工具

#include <functional>
#include <utility>

// C++17：作用域退出工具
class ScopeExit {
public:
    template<typename F>
    explicit ScopeExit(F&& f) : f_(std::forward<F>(f)) {}

    ~ScopeExit() { if (active_) f_(); }

    void release() { active_ = false; }

    ScopeExit(const ScopeExit&) = delete;
    ScopeExit& operator=(const ScopeExit&) = delete;

private:
    std::function<void()> f_;
    bool active_ = true;
};

// 使用宏简化
#define SCOPE_EXIT(expr) ScopeExit _scope_exit_##__LINE__([&]() { expr; })

// 用法
void processData() {
    auto* resource = acquireResource();
    SCOPE_EXIT(releaseResource(resource););

    // 即使异常也会调用 releaseResource
    if (error) throw std::runtime_error("error");
}

分析：

• 使用初始化捕获 [&]() { expr; } 延迟执行清理代码。
• 即使抛出异常也能保证资源释放。
• 简化 RAII 模式的样板代码。

9.3 案例：事件总线系统

#include <functional>
#include <unordered_map>
#include <vector>
#include <memory>
#include <string>

class EventBus {
public:
    using Handler = std::function<void(const std::string&)>;

    // 订阅事件，返回订阅 ID（用于取消订阅）
    size_t subscribe(const std::string& event, Handler handler) {
        size_t id = next_id_++;
        handlers_[event].push_back({id, std::move(handler)});
        return id;
    }

    // 发布事件
    void publish(const std::string& event, const std::string& data) {
        auto it = handlers_.find(event);
        if (it == handlers_.end()) return;
        for (const auto& [id, handler] : it->second) {
            handler(data);
        }
    }

    // 取消订阅
    void unsubscribe(const std::string& event, size_t id) {
        auto it = handlers_.find(event);
        if (it == handlers_.end()) return;
        auto& handlers = it->second;
        handlers.erase(
            std::remove_if(handlers.begin(), handlers.end(),
                [id](const auto& pair) { return pair.first == id; }),
            handlers.end()
        );
    }

private:
    struct Entry {
        size_t id;
        Handler handler;
    };

    std::unordered_map<std::string, std::vector<Entry>> handlers_;
    size_t next_id_ = 0;
};

// 使用示例：weak_ptr 捕获避免延长订阅者生命周期
class Subscriber {
public:
    Subscriber(std::shared_ptr<EventBus> bus, std::string name)
        : name_(std::move(name)), bus_(bus) {
        auto self = std::make_shared<decltype(*this)>(*this);  // 错误：不能 shared_from_this 在构造函数
        // 实际应在 init() 方法中订阅
    }

    void init() {
        auto bus = bus_.lock();
        if (!bus) return;

        // weak_ptr 捕获避免循环引用
        std::weak_ptr<Subscriber> weak = self_;
        subscription_id_ = bus->subscribe("event", [weak, bus](const std::string& data) {
            if (auto sub = weak.lock()) {
                sub->onEvent(data);
            }
        });
    }

    void onEvent(const std::string& data) {
        std::cout << name_ << " received: " << data << std::endl;
    }

private:
    std::string name_;
    std::weak_ptr<EventBus> bus_;
    std::shared_ptr<Subscriber> self_;
    size_t subscription_id_;
};

分析：

• 使用 std::function 存储异构 Lambda。
• 订阅者使用 weak_ptr 捕获避免循环引用。
• 发布者与订阅者解耦，通过 ID 管理订阅。

9.4 案例：异步加载与回调

#include <future>
#include <memory>
#include <iostream>

class DataLoader {
public:
    // 异步加载数据，回调在加载完成后执行
    void loadAsync(const std::string& url, std::function<void(const std::string&)> callback) {
        std::thread([url, callback]() {
            // 模拟网络请求
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::string data = "Data from " + url;
            callback(data);
        }).detach();
    }

    // 安全版本：使用 shared_ptr 保证回调对象存活
    template<typename Callback>
    void loadAsyncSafe(const std::string& url, Callback callback) {
        auto callback_ptr = std::make_shared<Callback>(std::move(callback));
        std::thread([url, callback_ptr]() {
            std::this_thread::sleep_for(std::chrono::seconds(1));
            std::string data = "Data from " + url;
            (*callback_ptr)(data);
        }).detach();
    }
};

int main() {
    DataLoader loader;

    // 危险：如果回调引用局部变量，可能在异步执行前销毁
    std::string result;
    loader.loadAsync("http://example.com", [&result](const std::string& data) {
        result = data;  // 危险：result 可能在回调前销毁
    });

    // 安全：使用值捕获 + 智能指针
    auto result_ptr = std::make_shared<std::string>();
    loader.loadAsyncSafe("http://example.com", [result_ptr](const std::string& data) {
        *result_ptr = data;
    });

    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Result: " << *result_ptr << std::endl;
    return 0;
}

分析：

• 异步加载场景下，回调的生命周期必须超过加载过程。
• 使用 shared_ptr 捕获确保回调对象存活。
• 使用模板参数（Callback）避免 std::function 的类型擦除开销。

9.5 案例：观察者模式的安全实现

#include <memory>
#include <vector>
#include <algorithm>
#include <iostream>

template<typename T>
class Observable {
public:
    void addObserver(std::shared_ptr<T> observer) {
        observers_.push_back(observer);
    }

    void notifyAll(const std::string& event) {
        // 使用 weak_ptr 遍历，自动跳过已销毁的观察者
        for (auto it = observers_.begin(); it != observers_.end(); ) {
            if (auto obs = it->lock()) {
                obs->onEvent(event);
                ++it;
            } else {
                it = observers_.erase(it);  // 移除已销毁的观察者
            }
        }
    }

private:
    std::vector<std::weak_ptr<T>> observers_;
};

class ConcreteObserver : public std::enable_shared_from_this<ConcreteObserver> {
public:
    ConcreteObserver(std::string name) : name_(std::move(name)) {}

    void onEvent(const std::string& event) {
        std::cout << name_ << " got event: " << event << std::endl;
    }

private:
    std::string name_;
};

int main() {
    Observable<ConcreteObserver> observable;
    {
        auto obs1 = std::make_shared<ConcreteObserver>("Observer-1");
        auto obs2 = std::make_shared<ConcreteObserver>("Observer-2");
        observable.addObserver(obs1);
        observable.addObserver(obs2);

        observable.notifyAll("Hello");  // 两个观察者都收到
    }  // obs1, obs2 离开作用域

    observable.notifyAll("World");  // 无观察者收到，但不会崩溃
    return 0;
}

分析：

• 观察者使用 weak_ptr 捕获，避免延长观察者生命周期。
• 发布事件时自动清理已销毁的观察者。
• 解决了观察者模式中”发布者持有订阅者引用”导致的循环引用问题。

10. 练习与参考答案

10.1 基础题

练习 1：写一个 Lambda，捕获局部变量 x（值捕获）和 y（引用捕获），返回 x + y。

int x = 10;
int y = 20;
// 在此处写 Lambda

参考答案：

auto f = [x, &y]() { return x + y; };

10.2 中级题

练习 2：使用初始化捕获（C++14）实现一个移动捕获 std::unique_ptr<int> 的 Lambda。

参考答案：

auto ptr = std::make_unique<int>(42);
auto f = [p = std::move(ptr)]() { return *p; };
// ptr 此后为 nullptr

10.3 异步安全题

练习 3：以下代码有什么问题？如何修复？

struct Worker {
    int data = 42;
    auto getCallback() {
        return [this]() { return data; };
    }
};

void useAsync() {
    std::function<int()> cb;
    {
        Worker w;
        cb = w.getCallback();
    }  // w 销毁
    std::cout << cb() << std::endl;  // UB
}

参考答案：

问题：[this] 捕获对象指针，w 离开作用域后 this 悬空。

修复方案 1：使用 [*this]（C++17）。

auto getCallback() const {
    return [*this]() { return data; };  // 拷贝对象
}

修复方案 2：使用 shared_ptr 捕获。

struct Worker : std::enable_shared_from_this<Worker> {
    int data = 42;
    auto getCallback() {
        return [self = shared_from_this()]() { return self->data; };
    }
};
// 使用：auto w = std::make_shared<Worker>();

10.4 综合题

练习 4：实现一个累加器 Lambda，每次调用累加一个数并返回当前累加值。

参考答案：

auto accumulator = [sum = 0](int x) mutable {
    sum += x;
    return sum;
};

std::cout << accumulator(10) << std::endl;  // 10
std::cout << accumulator(20) << std::endl;  // 30
std::cout << accumulator(30) << std::endl;  // 60

10.5 设计题

练习 5：设计一个线程安全的计数器类，使用 Lambda 作为回调通知机制。

参考答案：

#include <atomic>
#include <functional>
#include <mutex>
#include <vector>

class ThreadSafeCounter {
public:
    using Callback = std::function<void(int)>;

    void increment() {
        int new_value = ++counter_;
        notifyCallbacks(new_value);
    }

    int get() const {
        return counter_.load();
    }

    void addCallback(Callback cb) {
        std::lock_guard<std::mutex> lock(mutex_);
        callbacks_.push_back(std::move(cb));
    }

private:
    void notifyCallbacks(int value) {
        std::lock_guard<std::mutex> lock(mutex_);
        for (const auto& cb : callbacks_) {
            cb(value);
        }
    }

    std::atomic<int> counter_{0};
    std::mutex mutex_;
    std::vector<Callback> callbacks_;
};

// 用法
ThreadSafeCounter counter;
counter.addCallback([](int v) { std::cout << "Counter: " << v << std::endl; });
counter.increment();  // 输出：Counter: 1
counter.increment();  // 输出：Counter: 2

10.6 高级题

练习 6：使用 C++23 显式对象参数实现一个递归 Lambda，计算阶乘。

参考答案：

auto factorial = [](this auto self, int n) -> int {
    return n <= 1 ? 1 : n * self(n - 1);
};

std::cout << factorial(5) << std::endl;  // 120

10.7 错误诊断题

练习 7：以下代码有何错误？如何修复？

std::vector<std::function<int()>> callbacks;

for (int i = 0; i < 3; ++i) {
    callbacks.push_back([&i]() { return i; });
}

for (const auto& cb : callbacks) {
    std::cout << cb() << " ";
}

参考答案：

问题：[&i] 引用捕获循环变量 i，所有 Lambda 共享同一个 i，且 i 在循环结束后超出作用域（UB）。

修复：值捕获。

for (int i = 0; i < 3; ++i) {
    callbacks.push_back([i]() { return i; });
}
// 输出：0 1 2

10.8 性能优化题

练习 8：以下代码性能问题在哪？如何优化？

std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
auto f = [names]() {
    for (const auto& n : names) {
        std::cout << n << std::endl;
    }
};

参考答案：

问题：值捕获会拷贝整个 vector，开销大。

优化 1：移动捕获。

auto f = [names = std::move(names)]() {
    for (const auto& n : names) {
        std::cout << n << std::endl;
    }
};
// names 此后为空

优化 2：引用捕获（如果生命周期安全）。

auto f = [&names]() {
    for (const auto& n : names) {
        std::cout << n << std::endl;
    }
};

优化 3：shared_ptr 捕获（共享所有权）。

auto names_ptr = std::make_shared<std::vector<std::string>>(std::move(names));
auto f = [names_ptr]() {
    for (const auto& n : *names_ptr) {
        std::cout << n << std::endl;
    }
};

10.9 综合应用题

练习 9：实现一个通用的”延迟执行”工具，接受任意可调用对象和参数，在 operator() 时执行。

参考答案：

#include <functional>
#include <tuple>
#include <utility>

template<typename F, typename... Args>
class LazyExecutor {
public:
    LazyExecutor(F&& f, Args&&... args)
        : func_(std::forward<F>(f)),
          args_(std::forward<Args>(args)...) {}

    auto operator()() {
        return std::apply(func_, args_);
    }

private:
    F func_;
    std::tuple<Args...> args_;
};

template<typename F, typename... Args>
auto makeLazy(F&& f, Args&&... args) {
    return LazyExecutor<std::decay_t<F>, std::decay_t<Args>...>(
        std::forward<F>(f), std::forward<Args>(args)...
    );
}

// 用法
int main() {
    auto lazy = makeLazy([](int a, int b) { return a + b; }, 3, 4);
    std::cout << lazy() << std::endl;  // 7
    return 0;
}

10.10 异步场景题

练习 10：以下代码在多线程环境下有何风险？如何修复？

void processData() {
    std::vector<int> data = {1, 2, 3, 4, 5};

    std::thread([&data]() {
        for (int x : data) {
            std::cout << x << std::endl;
        }
    }).detach();
}  // data 离开作用域后销毁，但线程仍在运行

参考答案：

风险：[&data] 引用捕获，data 在函数返回后销毁，线程访问悬空引用。

修复 1：值捕获。

std::thread([data]() {  // 拷贝 data
    for (int x : data) {
        std::cout << x << std::endl;
    }
}).detach();