C++ 11 Lambda表达式

一、声明Lambda表达式

1.语法要点

声明格式	[capture list] (params list) mutable exception -> return type { function body }
参数含义	capture list	捕获外部变量列表
	params list	形参列表
	mutable	用来说用是否可以修改捕获的变量
	exception	异常设定
	return type	返回类型
	function body	函数体

此外，还可以省略其中的某些成分来声明“不完整”的Lamb表达式，常见以下几种：

格式	含义
[capture list] (params list) -> return type { function body }	声明了const类型的表达式，这种类型的表达式不能修改捕获列表中的值。
[capture list] (params list) { function body }	省略了返回值类型，但编译器可以根据以下规则推断出Lambda表达式的返回类型： （1）：如果function body中存在return语句，则该Lambda表达式的返回类型由return语句的返回类型确定； （2）：如果function body中没有return语句，则返回值为void类型。
[capture list] { function body }	省略了参数列表，类似普通函数中的无参函数。

2.例子

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool cmp(int a, int b)
{
	return  a < b;
}

int main()
{
	vector<int> myvec{ 3, 2, 5, 7, 3, 2 };
	vector<int> lbvec(myvec);

	sort(myvec.begin(), myvec.end(), cmp); // 旧式做法
	cout << "predicate function:" << endl;
	for (int it : myvec)
		cout << it << ' ';
	cout << endl;

	sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });   // Lambda表达式
	cout << "lambda expression:" << endl;
	for (int it : lbvec)
		cout << it << ' ';

	system("pause");
}

二、捕获外部变量

Lambda表达式可以使用其课件范围内的外部变量，但是必须明确声明哪些外部变量可以被该Lambda表达式使用。Lambda表达式通过[capture list]来明确表示其内部可以访问的外部变量，这个过程称为Lambda表达式捕获外部变量。例如：

#include <iostream>
using namespace std;

int main()
{
	int a = 123;
	auto f = [a] { cout << a << endl; };//省略了参数列表，类似普通函数中的无参函数
	f(); // 输出：123
}

在Lambda表达式中，外部变量的捕获方式有以下四种：

1.值捕获

值捕获和参数传递中的值专递类似，被捕获的变量的值在Lambda表达式创建时通过值拷贝的方式传入，因此随后对该变量的修改不会影响Lambda表达式中的值。例如：

int main()
{
    int a = 123;
    auto f = [a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：123
}

值得注意的是，如果以传值方式捕获外部变量，则在Lambda表达式函数体中不能修改该外部变量的值。

2.引用捕获

使用引用捕获一个外部变量，只需要在捕获列表变量前面加上一个引用说明符&。例如：

int main()
{
    int a = 123;
    auto f = [&a] { cout << a << endl; }; 
    a = 321;
    f(); // 输出：321
}

从示例中可以看出，引用捕获的变量使用的实际上就是该引用所绑定的对象。

3.隐式捕获

所谓隐式捕获，就是让编译器根据函数体中的代码来推断需要捕获哪些变量。隐式捕获有两种方式，分别是[=]和[&]。[=]表示以值捕获的反思捕获外部变量，[&]表示以引用捕获的方式捕获外部变量。

隐式值捕获示例：

int main()
{
	int a = 123;
	auto f = [=] { cout << a << endl; };    // 值捕获
	a = 321;
	f(); // 输出：123
}

隐式引用捕获示例：

int main()
{
    int a = 123;
    auto f = [&] { cout << a << endl; };    // 引用捕获
    a = 321;
    f(); // 输出：321
}

4.混合方式

Lambda表达式还支持混合的方式捕获外部变量，这种方式主要是以上几种捕获方式的组合使用。

捕获形式	说明
[]	不捕获任何外部变量
[变量名,...]	默认以值的形式捕获指定的多个外部变量（用逗号分隔），如果引用捕获，需要显示声明（使用&说明符）
[this]	以值的形式捕获this指针
[=]	以值的形式捕获所有外部变量
[&]	以引用形式捕获或有外部变量
[=,&x]	变量x以引用形式捕获，其余变量以传值形式捕获
[&,x]	变量x以值的形式捕获，其余变量以引用形式捕获

三、修改捕获变量

使用值的形式捕获外部变量的时候，函数体中不能修改该外部变量，否则会编译出错。如果想要修改外部变量的话，可以使用mutable关键字，该关键字用以说明表达式体内的代码可以修改值捕获的变量。例如：

int main()
{
    int a = 123;
    auto f = [a]()mutable { cout << ++a; }; // 不会报错
    cout << a << endl; // 输出：123
    f(); // 输出：124
}

四、Lambda表达式的参数

Lambda表达式中的参数有几点限制:

1.参数列表中不能有默认参数

2.不支持可变参数

3.所有参数必须有参数名

例如：

#include <iostream>
#include <functional>
using namespace std;

int main()
{
	int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);
	std::cout << "m:" << m << std::endl; //输出m:16

	std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl;//输出n:9

	auto gFunc = [](int x) -> function<int(int)> { return [=](int y) { return x + y; }; };//返回值是一个函数function<int(int)>
	auto lFunc = gFunc(4);
	std::cout << lFunc(5) << std::endl;//输出9

	auto hFunc = [](const function<int(int)>& f, int z) { return f(z) + 1; };//第一个参数是一个函数引用
	std::cout << hFunc(gFunc(7), 8) << std::endl;//输出16

	int a = 111, b = 222;
	auto func = [=, &b]()mutable { a = 22; b = 333; std::cout << "a:" << a << " b:" << b << std::endl; };//a以值的方式捕获，b以引用的方式捕获
	func();//输出a:22 b:333
	std::cout << "a:" << a << " b:" << b << std::endl;//输出a:111 b:333

	a = 333;
	auto func2 = [=, &a] { a = 444; std::cout << "a:" << a << " b:" << b << std::endl; };
	func2();//输出a:333 b:444

	system("pause");
}