16. 广义捕获（Init Capture）：C++14 引入，移动捕获和自定义捕获。

好，咱们来聊聊 C++14 引入的广义捕获。说实话，这个特性刚出来的时候，我眼前一亮。为什么？因为 C++11 的 lambda 捕获有个硬伤——它只能按值或按引用捕获外部变量。你想想看，有些对象根本不能拷贝，比如 std::unique_ptr。那怎么办？以前得用 std::bind 或者手动包装，麻烦得很。

广义捕获，说白了就是允许你在捕获列表里直接初始化一个新变量。语法长这样：[变量名 = 表达式]。这个表达式可以是任何东西，甚至可以是移动操作。我个人习惯叫它“捕获初始化”，因为它本质上就是在捕获阶段创建了一个新的局部变量。

16.1 为什么需要广义捕获？

先看一个我早年踩过的坑。那时候 C++11 刚普及，我想把一个 std::unique_ptr 传给 lambda 去异步执行。代码大概是这样：

std::unique_ptr<int> ptr = std::make_unique<int>(42);
auto lambda = [ptr]() { /* 使用 ptr */ };  // 编译错误！unique_ptr 不可拷贝

嗯，编译直接报错。因为 std::unique_ptr 删除了拷贝构造函数，而 C++11 的按值捕获本质上是拷贝。那用引用捕获呢？也不行，因为 lambda 可能比 ptr 活得久，引用会悬空。

C++14 的广义捕获完美解决了这个问题：

std::unique_ptr<int> ptr = std::make_unique<int>(42);
auto lambda = [p = std::move(ptr)]() { 
    if (p) std::cout << *p << std::endl; 
};

这里 p = std::move(ptr) 就是在捕获阶段创建了一个新变量 p，并通过移动构造初始化它。原来的 ptr 被置空，所有权转移到了 lambda 内部。干净利落。

核心要点：广义捕获允许你在捕获列表中定义新变量，并指定初始化方式。这为移动捕获、自定义捕获打开了大门。

16.2 广义捕获的两种形式

广义捕获其实有两种写法，我分别说一下。

16.2.1 按值初始化捕获

语法：[变量名 = 表达式]

这个表达式的结果会被拷贝（或移动）到 lambda 内部的新变量中。注意，这里的新变量类型由表达式推导，你也可以显式指定类型：

int x = 10;
auto lambda = [y = x + 5]() { 
    std::cout << y << std::endl;  // 输出 15
};
// 注意：x 仍然是 10，y 是 x+5 的副本

我在项目中经常用这个来“快照”某个变量的当前值。比如在循环中捕获索引：

for (int i = 0; i < 5; ++i) {
    auto lambda = [idx = i]() { 
        std::cout << "当前索引: " << idx << std::endl; 
    };
    // 如果这里直接捕获 i，那 lambda 执行时 i 可能已经变了
}

16.2.2 按引用初始化捕获

语法：[&变量名 = 表达式]

这个稍微少见一些，但有时候很有用。它创建的是一个引用变量：

int x = 10;
auto lambda = [&y = x]() { 
    y = 20;  // 修改的是 x
};
lambda();
std::cout << x << std::endl;  // 输出 20

你可能会问：这和直接捕获引用 [&x] 有什么区别？区别在于，你可以给这个引用起一个别名，或者绑定到一个子对象上。比如：

struct BigStruct {
    int data[1000];
    int& getFirst() { return data[0]; }
};

BigStruct s;
auto lambda = [&first = s.getFirst()]() {
    first = 42;  // 直接操作 s.data[0]
};

嗯，这里要注意，引用捕获的变量必须保证在 lambda 执行时仍然有效。否则就是悬空引用，后果很严重。

16.3 移动捕获：最常用的场景

移动捕获是广义捕获最典型的应用。我几乎每天都会用到。除了 std::unique_ptr，还有 std::vector、std::string 等可移动但拷贝开销大的对象，都可以用移动捕获来避免不必要的拷贝。

std::vector<int> bigData(1000000, 42);
auto lambda = [data = std::move(bigData)]() {
    // 现在 data 拥有这 100 万个整数
    std::cout << "size: " << data.size() << std::endl;
};
// bigData 现在是空的，所有权已转移

我曾经在一个网络库中处理过这样的场景：需要把接收到的数据包封装到 lambda 中异步处理。数据包是 std::vector<char>，如果按值拷贝，性能损失很大。用移动捕获，零拷贝就把数据传进去了。

小技巧：如果你想让 lambda 可复制，但内部包含 move-only 类型，可以把它包装在 std::shared_ptr 中。不过我个人更推荐直接用移动捕获，语义更清晰。

16.4 自定义捕获：更灵活的初始化

广义捕获的表达式可以是任意复杂的。你可以调用函数、创建临时对象、甚至写一个 lambda 来初始化捕获变量。这就是“自定义捕获”的含义。

举个例子，假设你想捕获一个经过某种变换的值：

std::string name = "Hello, World!";
auto lambda = [upperName = [](const std::string& s) {
    std::string result = s;
    for (auto& c : result) c = std::toupper(c);
    return result;
}(name)]() {
    std::cout << upperName << std::endl;  // 输出 "HELLO, WORLD!"
};

这里我在捕获列表中直接定义并调用了一个 lambda，把 name 转成大写后再捕获。虽然写法有点花哨，但有时候确实能减少代码行数。

另一个常见场景是捕获一个互斥锁：

std::mutex mtx;
int sharedData = 0;

auto lambda = [&mtx, &sharedData]() {
    std::lock_guard<std::mutex> lock(mtx);
    sharedData++;
};

用广义捕获可以更简洁：

auto lambda = [lock = std::lock_guard<std::mutex>(mtx), &sharedData]() {
    sharedData++;
};
// 注意：lock 在 lambda 构造时就已经锁住了 mtx

嗯，这里要小心。上面的写法是在 lambda 创建时加锁，而不是在调用时。如果你需要每次调用都加锁，那还是用传统方式比较好。

16.5 广义捕获与可变 lambda

默认情况下，lambda 的 operator() 是 const 的，所以捕获的按值变量不能修改。但如果你加上 mutable 关键字，就可以修改了。广义捕获的变量也一样：

int x = 10;
auto lambda = [y = x]() mutable {
    y++;  // 可以修改，因为 lambda 是 mutable 的
    std::cout << y << std::endl;
};
lambda();  // 输出 11
lambda();  // 输出 12（y 在两次调用间保持状态）

这个特性在实现状态机或者计数器时特别有用。我记得有一次写一个网络重连逻辑，就用 mutable lambda 配合广义捕获来记录重试次数：

auto reconnect = [retries = 0, maxRetries = 5]() mutable {
    if (retries < maxRetries) {
        std::cout << "重试第 " << ++retries << " 次" << std::endl;
        // 执行重连逻辑
    } else {
        std::cout << "重试次数已达上限" << std::endl;
    }
};

16.6 避坑指南

广义捕获虽然强大，但也有一些容易踩的坑。我根据自己的经验总结了几点：

  • 不要混淆捕获和参数：捕获列表中的变量是在 lambda 创建时初始化的，而参数是在调用时传入的。两者生命周期不同。
  • 小心悬空引用：如果你用 [&ref = someObject]，确保 someObject 在 lambda 执行时还活着。我曾经在回调中吃过这个亏，排查了半天。
  • 移动后原对象状态：用 std::move 捕获后，原对象处于“有效但未指定”的状态。不要再使用它，除非你重新赋值。
  • 避免在捕获中做耗时操作：捕获列表中的表达式是在 lambda 构造时执行的。如果表达式很耗时（比如打开文件、分配大内存），那每次创建 lambda 都会卡一下。

警告：不要在广义捕获中使用 std::move 对左值引用。比如 [&ref = std::move(someObj)] 是不对的，因为 std::move 返回的是右值引用，不能绑定到左值引用上。正确的做法是用 [ref = std::move(someObj)]（按值捕获）。

16.7 知识体系图

下面这张图总结了广义捕获的核心知识点和它们之间的关系：

广义捕获（Init Capture）知识体系 广义捕获 语法形式 按值初始化 按引用初始化 应用场景 移动捕获 自定义捕获 注意事项 生命周期管理 移动后状态 与 mutable 结合 常见陷阱 核心思想：在捕获阶段创建新变量，灵活控制初始化方式

16.8 总结

广义捕获是 C++14 给 lambda 带来的一个非常实用的增强。它解决了 C++11 中无法移动捕获的问题，也让我们可以在捕获时做更复杂的初始化。我个人觉得，掌握好这个特性，能让你的 lambda 代码更简洁、更高效。

最后说一句：如果你还在用 C++11，可以考虑升级到 C++14 了。广义捕获带来的便利，值得你花这点升级成本。

← 上一章 📖 返回目录 下一章 →