【C++11】Lambda 表达式：基本使用 和 底层原理

---

Lambda 表达式

书写格式：

[capture_list](parameters) mutable -> return_type{statement}
1

[capture_list]：

• 捕捉列表，不能省略。
• 固定在 lambda 表达式开始的位置，编译器也是根据 [] 来判断接下来的代码是否为 lambda 函数。
• 捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。

(parameters)：

• 参数列表。
• 与普通函数的参数列表一致，如果不需要参数传递，则可以连同 () 一起省略。

mutable：

• 一个修饰符，取消传值捕捉时值的默认 const 属性（lambda 函数默认是一个 const 类型的，里面的值不可修改）。
• 另：若使用了 mutable 修饰符，则 (参数列表) 是不可省略掉的，即使是参数为空。

return_type：

• 返回值类型。可以省略，编译器会自动推导。

{statement}：

• 函数体部分，{} 不能省略，但内容可以为空。
• 在该函数体内，除了可以使用其参数外，还可以使用所有捕获
  到的变量。

如下是最简单的 lambda 对象，没啥用就是了…

[] {};	
1

---

1. 不考虑捕捉列表

1.1 简单使用介绍

比如我们要实现一个两个数相加的函数，用 lambda 表达式就需要写成这样

auto add = [](int x, int y)->int {return x + y; };		
cout << add(1, 2) << endl;
//cout << [](int x, int y)->int {return x + y; }(1, 2) << endl;		// 这样写也能运行，但是我们不这样...
1
2
3

解析：
	= 后面这一坨整体，代表的是一个 lambda 对象，拿这个对象去构造 add
	后面就可以用 add 去等价调用函数了
1
2
3

可以看出，lambda 表达式实际上可以理解为 匿名函数，该函数无法直接调用，如果想要直接调用，可借助 auto 将其赋值给一个变量。

需要注意的是：

• 返回值可以忽略（编译器自动完成推导）
• 函数体语句多的话，可以按照如下格式写

auto add = [](int x, int y)		// 返回值可以省略，编译器可以自动推导
{								// 函数体语句多的话，可以放下来写
	return x + y;
};
cout << add2(1, 2) << endl;
1
2
3
4
5

---

1.2 简单使用举例

🌰实现商品各个内容的排序：

struct Goods
{
	string _name;  // 名字
	double _price; // 价格
	int _evaluate; // 评价

	Goods(const char* str, double price, int evaluate)
		:_name(str)
		, _price(price)
		, _evaluate(evaluate)
	{}
};
1
2
3
4
5
6
7
8
9
10
11
12

仿函数写法：

struct ComparePriceLess
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price < gr._price;
	}
};
struct ComparePriceGreater
{
	bool operator()(const Goods& gl, const Goods& gr)
	{
		return gl._price > gr._price;
	}
};

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };

	// <
	sort(v.begin(), v.end(), ComparePriceLess());
	// >
	sort(v.begin(), v.end(), ComparePriceGreater());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

lambda 写法：

书写格式：[capture - list](parameters) mutable -> return-type{ statement}

int main()
{
	vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };

	// 价格升序
	auto priceLess = [](const Goods& g1, const Goods& g2)->bool {return g1._price < g2._price; };
	sort(v.begin(), v.end(), priceLess);	// 相较于仿函数更好调试

	// 价格降序
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
		return g1._price > g2._price; 
		});									// 这个把断点放头上可能会一直出不来，调试的时候跳到了需要手动取消断点走下一个

	// 改成比较别的类型也很方便
	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
		return g1._evaluate < g2._evaluate;
		});

	sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
		return g1._evaluate > g2._evaluate;
		});
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

2. 捕捉列表 [ ] 和 mutable 关键字

---

📕注意事项（具体论证见下文）：

1. 父作用域指包含lambda函数的语句块。

2. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

3. 捕捉列表不允许变量重复传递，否则就会导致编译错误。

   eg：[=, a]
   = 已经以值传递方式捕捉了所有变量，捕捉 a 重复
   1
   2

4. 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。同时有，在块作用域以外的 lambda 函数捕捉列表必须为空。

5. lambda表达式之间不能相互赋值，即使看起来类型相同

---

若不使用 lambda 捕捉，实现一个 swap 接口如下：

int x = 0, y = 1;
auto swap1 = [](int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
};

swap1(x, y);
cout << x << " "<< y << endl;
1
2
3
4
5
6
7
8
9
10

而 捕捉列表 描述了：

• 上下文中哪些数据可以被 lambda 使用
• 以及使用的方式 传值 还是 传引用

---

2.1 使用方法

传值捕捉

• [val] 是 传值捕捉 [x, y]，相当于把 x 和 y “捕捉” 到 lambda 表达式中，直接就可以访问了。这时 lambda 是 const 函数，其中的 x 和 y 不能修改；

• 加上关键字 mutable 就可以修改了，不过此时的 x 和 y 就是函数形参。

• 另外需要注意的是，有 mutable 时，参数列表的括号不能省略。建议平时也不要省略

并不能达到效果的错误使用：

// err，这是一个错误的写法
int x = 0, y = 1;
auto swap2 = [x, y]() mutable 
{
	int tmp = x;
	x = y;
	y = tmp;
};
swap2();
cout << x << " " << y << endl;
1
2
3
4
5
6
7
8
9
10

像如上，虽然对 x 和 y 进行了捕捉，也加上了 mutable 使其可以修改，但实际并达不到我们让全局变量 x 和 y 修改的效果。因为 lambda 中他们只是形参，一份临时拷贝的对象。

传引用捕捉

• [&val] 是将外面的值传引用到 lambda 内部
• 需要在 lambda 内部对某个变量修改时用传引用捕捉

真正修改了外面的参数：

// 这里的 &x 就是引用捕捉int& x（不是取地址
// 引用捕捉
int x = 0, y = 1;
auto swap2 = [&x, &y]()
{
	int tmp = x;
	x = y;
	y = tmp;
};
swap2();
cout << x << " " << y << endl;
1
2
3
4
5
6
7
8
9
10
11

---

2.2 捕捉方法一览

混合捕捉

[var]：表示 值传递方式 捕捉变量 var
[this]：表示 值传递方式 捕捉当前的 this 指针
[&var]：表示 引用传递捕捉 变量 var

auto func1 = [&x, y]()
{
	//...
};
1
2
3
4

全部引用捕捉

[&]：表示 引用传递捕捉 所有父作用域中的变量（包括 this）

auto func2 = [&]()
{
	//...
};
1
2
3
4

全部传值捕捉

[=]：表示值传递方式捕获所有父作用域中的变量（包括 this）

auto func3 = [=]()
{
	//...
};
1
2
3
4

全部引用捕捉，x 传值捕捉

auto func4 = [&, x]()
{
	//...
};
1
2
3
4

此外排列组合：

[=, &a, &b]：以 引用传递 的方式捕捉变量 a 和 b，值传递方式 捕捉其他所有变量

[&，a, this]：以 值传递方式 捕捉变量 a 和 this，引用方式 捕捉其他变量

---

2.3 使用举例

先来个讲解前提，创建线程：

• Linux 下创建线程：pthread_create（posix）
• C++98，linux 和 windows 下都可以支持的多线程程序：条件编译。

#ifdef _WIN32
	CreateThread
#else
	pthread_create
#endif 
1
2
3
4
5

• C++11，linux 和 windows 下都可以支持的多线程程序：thread库。

🌰要求 m 个线程分别打印 1~n

线程的传统写法：

void Func1(int n, int num)
{
	for (int i = 0; i < n; i++)
	{
		cout <<num<<":" << i << endl;
	}
	cout << endl;
}
int main()
{
	int n1, n2;
	cin >> n1 >> n2;
	thread t1(Func1, n1, 1);
	thread t2(Func1, n2, 2);

	t1.join();
	t2.join();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

lambda 写法：第一种，较为冗余，不便于添加线程

int main()		// 这个版本蛮冗余
{
	int n1, n2;
	cin >> n1 >> n2;
	thread t1([n1](int num)
		{
			for (int i = 0; i < n1; i++)
			{
				cout <<num<<":" << i << endl;
			}
			cout << endl;
		}, 1);

	thread t2([n2](int num)
		{
			for (int i = 0; i < n2; i++)
			{
				cout << num << ":" << i << endl;
			}
			cout << endl;
		}, 2);

	t1.join();
	t2.join();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

lambda 写法：第二种，推荐

int main()
{
	size_t m;
	cin >> m;
	vector<thread> vthds(m);

	// 要求 m 个线程分别打印 1~n
	for (size_t i = 0; i < m; i++)
	{
		size_t n;
		cin >> n;

		vthds[i] = thread([i, n, m]() {		// 匿名的lambda对象，移动赋值给的vhds[i]
			for (int j = 0; j < n; j++)
			{
				cout << i << ":" << j << endl;
			}
			cout << endl;
			});
	}

	for (auto& t : vthds)	// thread 不支持拷贝构造（delete了），这里要加引用才跑得动
	{
		t.join();
	}

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

---

3. lambda 的底层分析

先说结论，实际在底层编译器对于 lambda 表达式的处理方式，完全就是按照函数对象（仿函数）的方式处理的。

lambda 就是 仿函数

即：如果定义了一个 lambda 表达式，编译器会自动生成一个类，在该类中重载了 operator()。

• 参数列表 会变成 仿函数的参数
• 函数体 就是 仿函数主体
• lambda 对象的类型 就是 仿函数的类型（见后文）
• 如下这个仿函数类是一个没有给成员变量的空类，所以大小是 1 个字节 反汇编可以查到

int x = 0, y = 1;
int m = 0, n = 1;

auto swap1 = [](int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
};

cout << sizeof(swap1) << endl;	// 输出 1 
1
2
3
4
5
6
7
8
9
10
11

有如下一个模拟计算理财收益的类：

class Rate
{
public:
	Rate(double rate) : _rate(rate)	{}			// 传入利率
	double operator()(double money, int year)	// 参数：本金和年限，返回收益
	{
		return money * _rate * year;			// 模拟计算
	}
private:
	double _rate;
};
1
2
3
4
5
6
7
8
9
10
11

• 以下代码，函数对象的汇编过程：call 仿函数的构造函数，再 call operator()

// 函数对象
int main()
{
	double rate = 0.49;
	Rate r1(rate);
	r1(10000, 2);
	cout << sizeof(r1) << endl;	// 8
	return 0;
}
1
2
3
4
5
6
7
8
9

• 以下代码，lambda 汇编过程：call lambda_uuid 类的构造函数，再call ::operator()

• uuid 是一个电脑生成的唯一随机值，作为 lambda 类的后缀，刚刚好唯一标识

lambda 类的大小

既然说 lambda 会被编译成类，那么他的大小也就跟类的大小的计算如出一辙，不过还是有需要注意的地方，🌰请看以下简单示意：

• 使用 [=]，并在 lambda 中使用的值才会被类初始化，初始化顺序和使用顺序有关，大小计算参考结构体的 内存对齐规则。
• 使用 [&]，并在 lambda 中使用的值，引用会被类定义成指针，其余规则同上。

lambda 类的类型名 / 唯一标识

• 之前提及的 lambda_uuid，才是 lambda 表达式底层的类型名称，编译器会给他们唯一标识的名称

下面代码，f1 和 f2 即使看着一样，如上阐述，实则底层的类型名称都不同，不能互相赋值：

auto f1 = [] {cout << "hello world" << endl; };
auto f2 = [] {cout << "hello world" << endl; };
//f1 = f2;	// err...
1
2
3

---

🥰如果本文对你有些帮助，欢迎👉 点赞 收藏 关注，你的支持是对作者大大莫大的鼓励！！(✿◡‿◡) 若有差错恳请留言指正~~

---