是否好奇过，这样一行代码，编译器背后做了什么？
auto lambda = [](int x) { return x * 2; };
本文将带你深入 Lambda 的底层
一、Lambda回顾
auto lambda = [](int x) { return x + 1; };
int result = lambda(5);
lambda我们很熟悉，是一个对象。
完整语法:[捕获列表] (参数列表) mutable 异常说明->返回类型{函数体}
基本的用法就不说，说几个用的时候注意的点
-
& 捕获要注意悬垂引用，不要让捕获的引用，被销毁了还在使用
-
this指针捕获，引起的悬垂指针
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捕获，直接拷贝整个对象
return [*this]() { return value; }; // 拷贝整个对象
3.每个lambda都是唯一的
auto l1 = []() { return 1; };
auto l2 = []() { return 1; };
// l1 和 l2 类型不同！
// typeid(l1) != typeid(l2)
4.转换为函数指针
// 不捕获变量→可以转换
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.混淆了[=] 和 [&]
class MyClass {
int value = 100;
public:
void test() {
auto lambda = [=]() { //看起来按值捕获
std::cout << value << std::endl;
};
//等价于 [this],捕获的是this指针
//等价于this->value
}
};
6.lambda递归
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.移动捕获
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()的类对象。 现在来证明一下:代码如下
#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:为什么这里是一个空的结构体？
我们来按值捕获参数试试:
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消失，可自行验证
