第20章移动语义与 lambda

课程目录第20章移动语义与 lambda

20、移动语义与 lambda：lambda 捕获中的移动语义、mutable lambda 与移动、泛型 lambda 中的转发

聊到 lambda 和移动语义，很多人第一反应是「lambda 不就是个匿名函数嘛，跟移动有什么关系？」

嗯，关系大了去了。

我在项目中遇到过好几次这样的 bug：lambda 捕获了一个 unique_ptr，结果编译报错，说 unique_ptr 不能拷贝。那时候我才真正意识到，lambda 捕获本质上是在创建闭包对象，而闭包对象里的成员变量怎么初始化、怎么传递，完全遵循 C++ 的构造和移动规则。

20.1 lambda 捕获中的移动语义

先看一个最基础的问题：lambda 怎么捕获一个只能移动的类型？

#include <memory>
#include <iostream>

int main() {
    auto ptr = std::make_unique<int>(42);
    
    // 错误：unique_ptr 不能拷贝
    // auto lambda = [ptr]() { std::cout << *ptr; };
    
    // 正确：使用移动捕获
    auto lambda = [p = std::move(ptr)]() {
        std::cout << *p << std::endl;
    };
    
    lambda();  // 输出 42
    // 此时 ptr 已经为空
    return 0;
}

这里的关键是 [p = std::move(ptr)] 这种写法。C++14 引入了「初始化捕获」，允许你在捕获列表里直接构造闭包成员。说白了，就是把移动操作写在了捕获的位置。

核心要点：初始化捕获的语法是 [变量名 = 表达式]，表达式的结果会直接用来初始化闭包中的成员。对于只能移动的类型，用 std::move 把资源转移进去。

我个人习惯在捕获 unique_ptr、fstream、thread 等资源句柄时，一律用初始化捕获。这样代码意图明确，也不会意外留下拷贝。

20.2 mutable lambda 与移动

默认情况下，lambda 的 operator() 是 const 的。这意味着你无法在 lambda 内部修改捕获的变量——即使你捕获的是非 const 的局部变量。

但移动语义来了之后，情况变得微妙了。

#include <iostream>

int main() {
    int x = 10;
    
    // 默认 lambda：不能修改捕获的 x
    auto lambda1 = [x]() {
        // x = 20;  // 编译错误
        std::cout << x << std::endl;
    };
    
    // mutable lambda：可以修改捕获的 x
    auto lambda2 = [x]() mutable {
        x = 20;  // 可以修改，但只影响闭包内的副本
        std::cout << x << std::endl;
    };
    
    lambda2();  // 输出 20
    std::cout << x << std::endl;  // 输出 10，原变量不变
    return 0;
}

那 mutable 和移动有什么关系呢？

你想想看，如果你捕获了一个只能移动的对象，比如 std::unique_ptr，默认的 const 限定会阻止你调用它的非 const 成员函数——包括 reset()、release() 等。这时候你就需要 mutable。

#include <memory>
#include <iostream>

int main() {
    auto ptr = std::make_unique<int>(100);
    
    // 必须加 mutable，否则无法调用 reset
    auto lambda = [p = std::move(ptr)]() mutable {
        p.reset(new int(200));
        std::cout << *p << std::endl;
    };
    
    lambda();  // 输出 200
    return 0;
}

注意：mutable 只影响闭包内部捕获的副本，不影响原始变量。如果你捕获的是引用（[&x]），那本来就能修改，不需要 mutable。mutable 只针对按值捕获的情况。

我曾经踩过一个坑：在 lambda 里移动了一个捕获的 unique_ptr，结果第二次调用 lambda 时指针已经空了。嗯，这里要注意——mutable lambda 可以修改捕获的变量，但如果你把资源移走了，后续调用就会出问题。

20.3 泛型 lambda 中的转发

C++14 引入了泛型 lambda，也就是参数类型用 auto 推导的 lambda。这本质上是一个模板化的 operator()。

auto generic_lambda = [](auto&& param) {
    // 这里 param 可能是左值引用，也可能是右值引用
    // 如何完美转发？
};

问题来了：在泛型 lambda 内部，你怎么把参数完美转发给另一个函数？

直接写 std::forward<decltype(param)>(param) 是可以的，但太啰嗦了。C++20 引入了 decltype(auto) 作为返回类型推导，但转发本身还是得靠 std::forward。

#include <utility>
#include <iostream>

void process(int& x) {
    std::cout << "左值: " << x << std::endl;
}

void process(int&& x) {
    std::cout << "右值: " << x << std::endl;
}

int main() {
    auto forwarder = [](auto&& param) {
        // 完美转发给 process
        process(std::forward<decltype(param)>(param));
    };
    
    int a = 42;
    forwarder(a);           // 输出 "左值: 42"
    forwarder(100);         // 输出 "右值: 100"
    forwarder(std::move(a)); // 输出 "右值: 42"
    
    return 0;
}

实用技巧：如果你经常写这种转发 lambda，可以定义一个别名：

template <typename T>
using forward_type = std::forward<T>;

// 然后可以写成
auto f = [](auto&& p) {
    process(forward_type<decltype(p)>(p));
};

不过我个人觉得这样反而降低了可读性，不如直接写 std::forward 来得清晰。

20.4 可变参数泛型 lambda 的转发

当泛型 lambda 接受可变参数时，转发模式稍微复杂一点，但原理相同。

#include <utility>
#include <iostream>

void print_all() {}

template <typename T, typename... Args>
void print_all(T&& first, Args&&... rest) {
    std::cout << std::forward<T>(first) << " ";
    print_all(std::forward<Args>(rest)...);
}

int main() {
    auto variadic_forwarder = [](auto&&... args) {
        // 完美转发所有参数
        print_all(std::forward<decltype(args)>(args)...);
    };
    
    variadic_forwarder(1, 2.5, "hello");  // 输出 "1 2.5 hello "
    return 0;
}

这里 std::forward<decltype(args)>(args)... 是包展开，对每个参数分别做完美转发。C++17 之后，你还可以用折叠表达式简化某些场景，但转发本身还是这套写法。

20.5 实际项目中的避坑指南

我在代码评审中见过不少 lambda 移动语义相关的问题，总结几个常见的：

捕获后忘记移动：写了 [ptr] 而不是 [p = std::move(ptr)]，导致编译失败。解决方案：对只能移动的类型，强制使用初始化捕获。
mutable lambda 的多次调用问题：lambda 内部移动了捕获的资源，第二次调用时资源已空。解决方案：如果 lambda 只调用一次，用 std::move 没问题；如果需要多次调用，考虑用 shared_ptr 或者重新设计逻辑。
泛型 lambda 中忘记转发：写了 [](auto&& x) { foo(x); }，结果 x 永远是左值，右值信息丢失。解决方案：始终用 std::forward<decltype(x)>(x)。
捕获引用时的生命周期问题：lambda 捕获了局部变量的引用，lambda 逃逸后引用悬空。解决方案：按值捕获或者用 shared_from_this。

一句话总结：lambda 的捕获列表就是闭包类的成员初始化列表。移动语义在这里完全适用——用初始化捕获处理只能移动的类型，用 mutable 允许修改捕获的副本，用 std::forward 在泛型 lambda 中保持值类别。

说实话，lambda 的移动语义一开始确实有点绕。但只要你记住「lambda 闭包就是一个普通的类对象，捕获列表就是成员初始化列表」，一切就豁然开朗了。移动捕获、mutable、完美转发，这些都不是 lambda 特有的新概念，而是 C++ 已有规则在 lambda 这个语法糖上的自然体现。