C++lambda表达式

前言

  本文介绍c++ lambda的使用方法

  本专栏知识点是通过零声教育的线上课学习，进行梳理总结写下文章，对c/c++linux课程感兴趣的读者，可以点击链接 C/C++后台高级服务器课程介绍 详细查看课程的服务。

lambda的基本语法

[捕获列表](参数列表) mutable(可选) 异常属性 -> 返回类型 {
// 函数体
}
1
2
3

  语法规则：lambda表达式可以看成是一般函数的函数名被略去，返回值使用了一个 -> 的形式表示。唯一与普通函数不同的是增加了“捕获列表”。

  一般情况下，编译器可以自动推断出lambda表达式的返回类型，所以我们可以不指定返回类型，即：

//[捕获列表](参数列表){函数体}
int main() {
	auto Add = [](int a, int b) {
		return a + b;
	};
	std::cout << Add(1, 2) << std::endl; //输出3
	return 0;
}
1
2
3
4
5
6
7
8

  但是如果函数体内有多个return语句时，编译器无法自动推断出返回类型，此时必须指定返回类型。

lambda的捕获列表

  有时候，需要在匿名函数内使用外部变量，所以用捕获列表来传递参数。根据传递参数的行为，捕获列表可分为以下几种

值捕获

  与参数传值类似，值捕获的前提是变量可以拷贝，不同之处则在于，被捕获的变量在 lambda表达式被创建时拷贝，而非调用时才拷贝

//[捕获列表](参数列表)->返回值{函数体}
int main() {
	cout << "lambda" << endl;
	int c = 6872;
	int d = 5032;
	auto Add = [c, d](int a, int b)->int {
		cout  << "c = " << c << endl<< "d = " << d << endl;
		return a+b;
	};
	d = 20;
	std::cout << "1 + 2 = " << Add(1, 2) << std::endl;
}
1
2
3
4
5
6
7
8
9
10
11
12

引用捕获

  与引用传参类似，引用捕获保存的是引用，如果修改引用变量，则在调用lambda表达式之后，外部该变量值会发生变化。

//[捕获列表](参数列表)->返回值{函数体}
int main() {
	cout << "lambda" << endl;
	int c = 6872;
	int d = 5032;
	auto Add = [&c, &d](int a, int b)->int {
		cout  << "c = " << c << endl<< "d = " << d << endl;
		c = 68725032;
		d = c;
		return a+b;
	};
	std::cout << "1 + 2 = " << Add(1, 2) << std::endl;
	cout  << "c = " << c << endl<< "d = " << d << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

隐式捕获

  手动书写捕获列表有时候是非常复杂的，这种机械性的工作可以交给编译器来处理，这时候可以在捕获列表中写一个 &(引用捕获) 或 =(值捕获) 向编译器声明采用引用捕获或者值捕获。

//[捕获列表](参数列表)->返回值{函数体}
int main() {
	cout << "lambda" << endl;
	int c = 6872;
	int d = 5032;
	auto Add = [&](int a, int b)->int {
		cout  << "c = " << c << endl<< "d = " << d << endl;
		c = 68725032;
		d = c;
		return a+b;
	};
	std::cout << "1 + 2 = " << Add(1, 2) << std::endl;
	cout  << "c = " << c << endl<< "d = " << d << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

空捕获列表

  捕获列表’[]'中为空，表示Lambda不能使用所在函数中的变量。

//[捕获列表](参数列表)->返回值{函数体}
int main() {
	cout << "lambda" << endl;
	int c = 6872;
	int d = 5032;
	// [] 空值，不能使用外面的变量
	// [=] 传值，lambda外部的变量都能使用
	// [&] 传引用值，lambda外部的变量都能使用
	auto Add = [&](int a, int b)->int {
		cout  << "c = " << c << endl<< "d = " << d << endl;
		c = 68725032;
		d = c;
		return a+b;
	};
	std::cout << "1 + 2 = " << Add(1, 2) << std::endl;
	cout  << "c = " << c << endl<< "d = " << d << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

表达式捕获

  上面提到的值捕获、引用捕获都是已经在外层作用域声明的变量，因此这些捕获方式捕获的均为左值而不能捕获右值。

  C++14之后支持捕获右值，允许捕获的成员用任意的表达式进行初始化，被声明的捕获变量类型会根据表达式进行判断，判断方式与使用 auto 本质上是相同的

//g++ -o main main.cpp -std=c++14

#include 
#include 
using namespace std;
//[捕获列表](参数列表)->返回值{函数体}
int main() {
	cout << "lambda" << endl;
	auto important = std::make_unique<int>(1);
	auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
		return x + y + v1 + (*v2);
	};
	std::cout << add(3,4) << std::endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

泛型 Lambda

  在C++14之前，lambda表示的形参只能指定具体的类型，没法泛型化。从 C++14 开始， Lambda 函数的形式参数可以使用 auto关键字来产生意义上的泛型：

#include 
#include 
using namespace std;
//[捕获列表](参数列表)->返回值{函数体}
int main() {
	cout << "lambda" << endl;
	auto add = [](auto x, auto y) {
		return x+y;
	};
	std::cout << add(1, 2) << std::endl;
	std::cout << add(1.1, 1.2) << std::endl;
}
1
2
3
4
5
6
7
8
9
10
11
12

可变lambda

• 采用值捕获的方式，lambda不能修改其值，如果想要修改，使用mutable修饰(这个修改只是在lambda函数体内生效，对原来的变量不生效)

• 采用引用捕获的方式，lambda可以直接修改其值，并且对外生效

//[捕获列表](参数列表)->返回值{函数体}
int main() {
	cout << "lambda" << endl;
	int v = 5;
	// 值捕获方式，使用mutable修饰，可以改变捕获的变量值
	auto ff = [v]() mutable {
		v=100;
		return v;
	};
	auto res = ff(); // j为6
	cout<<"v="<<v<<" return="<<res;
}
1
2
3
4
5
6
7
8
9
10
11
12

lambda
v=5 return=100
1
2

int main() {
	cout << "lambda" << endl;
	int v = 5;
	// 采用引用捕获方式，可以直接修改变量值
	auto ff = [&v](){
		v=100;
		return v;
	};
	auto res = ff();
	cout<<"v="<<v<<" return="<<res;
}
1
2
3
4
5
6
7
8
9
10
11

lambda
v=100 return=100
1
2

总结

1. 如果捕获列表为[&]，则表示所有的外部变量都按引用传递给lambda使用；
2. 如果捕获列表为[=]，则表示所有的外部变量都按值传递给lambda使用；
3. 匿名函数构建的时候对于按值传递的捕获列表，会立即将当前可以取到的值拷贝一份作为常数，然后将该常数作为参数传递。