Lambda 底层原理全解析

是否好奇过，这样一行代码，编译器背后做了什么？

auto lambda = [](int x) { return x * 2; };

本文将带你深入 Lambda 的底层

一、Lambda回顾

ini 复制代码

    auto lambda = [](int x) { return x + 1; };
    int result = lambda(5);

lambda我们很熟悉，是一个对象。

完整语法:[捕获列表] (参数列表) mutable 异常说明->返回类型{函数体}

基本的用法就不说，说几个用的时候注意的点

& 捕获要注意悬垂引用，不要让捕获的引用，被销毁了还在使用
this指针捕获，引起的悬垂指针

cpp 复制代码

class MyClass {
    int value = 42;
public:
    auto getLambda() {
        return [this]() { return value; };  //捕获 this 指针
    }
};

MyClass* obj = new MyClass();
auto lambda = obj->getLambda();
delete obj;
lambda();  //this 指针悬垂

C++17解决:*this捕获，直接拷贝整个对象

cpp 复制代码

return [*this]() { return value; };  // 拷贝整个对象

3.每个lambda都是唯一的

cpp 复制代码

auto l1 = []() { return 1; };
auto l2 = []() { return 1; };

// l1 和 l2 类型不同！
// typeid(l1) != typeid(l2)

4.转换为函数指针

cpp 复制代码

// 不捕获变量→可以转换
auto l1 = [](int x) { return x + 1; };
int (*fp)(int) = l1;//正确

// 捕获变量→不能转换
int a = 10;
auto l2 = [a](int x) { return a + x; };
int (*fp2)(int) = l2;  //编译错误

记住这句话:函数指针=纯粹的代码地址，你一旦有成员变量，operator()就会依赖对象状态(a)，无法转换为函数指针，函数指针调用时，不知道a的值从哪里来。
简单来说:lambda本质是对象+代码，而函数指针只能表示纯代码

解决方式:function(可以直接存储Lambda对象)

5.混淆了[=] 和 [&]

cpp 复制代码

class MyClass {
    int value = 100;
public:
    void test() {
        auto lambda = [=]() {  //看起来按值捕获
            std::cout << value << std::endl;
        };
        //等价于 [this],捕获的是this指针
        //等价于this->value
    }
};

6.lambda递归

cpp 复制代码

auto factorial = [](int n) {  //无法递归调用自己
    return n <= 1 ? 1 : n * factorial(n - 1);  // 错误:factorial 未定义
};

//正确做法:C++23显式对象参数
auto factorial = [](this auto self, int n) {  // C++23
    return n <= 1 ? 1 : n * self(n - 1);
};

7.移动捕获

cpp 复制代码

void process(std::unique_ptr<int>&& ptr) {
    auto lambda = [p = std::move(ptr)]() {  //移动到 Lambda
        std::cout << *p << std::endl;
    };
    //错误做法
    //auto lambda = [&ptr]() {  //捕获的是引用
    //std::cout << *ptr << std::endl;
    //可能导致ptr移动后lambda失效.
    lambda();
}

二、Lambda 的本质

Lambda不是普通的函数，也不是普通的对象，它是一个重载了operator()的类对象。现在来证明一下:代码如下

cpp 复制代码

#include <iostream>

int main() {
    auto lambda = [](int x) { return x * 2; };
    int result = lambda(5);
    std::cout << result << std::endl;
    return 0;
}

gdb证明:
观察到lambda是一个结构体，且大小为1字节

引申出几个问题

为什么这里是一个空的结构体？
为什么大小为1字节？
还没有证明他是一个重载了operator()的对象

问题1:为什么这里是一个空的结构体？

我们来按值捕获参数试试:

c 复制代码

    int main() {
    int y=2;
    auto lambda = [=](int x) { return x * 2+y * 3; };
    int result = lambda(5);
    std::cout << result << std::endl;
    return 0;
}

gdb:

哦，原来捕获对象会存在这个结构体中，同时我们发现大小为4字节，就为数据的大小。

那我们捕获引用 试试呢？

同样也是引用数据类型，但是由于引用底层是存着对象的地址 ，所以它的大小为8字节，是一个指针的大小。

回到上面，为什么我们一开始的结构体什么数据都没有还是为1字节呢，C++规定了空类大小不为0，最小为1字节（保证每个对象都有唯一的地址）

总结:引用或按值捕获的数据被存在lambda对象内部

问题2：证明他是一个重载了operator()的对象

(1)gdb继续调试: 可以看到,确实是调用了一个operator()

(2)我们在用C++ Insights验证一下

访问：cppinsights.io/ 可以查看编译器实际生成的完整类定义

关注到operator()后面是一个const，说明不可以修改捕获的变量,mutable加上后const消失，可自行验证