C++ lambda表达式

lambda表达式最先出现于python脚本语言，在运行时候才会一行一行的解释指令，速度虽然满，但是对于程序员来说减少了大量的代码工作，语法相对更加简单

lambda表达式是一个匿名的函数

完整表达式：[capture-list](parameters)mutable->return-type{statement}
[]中的变量就是可以将上下文中的变量引入到匿名函数中去使用，默认属性为const
()中的变量为函数的参数列表，定义方式和普通函数一样，可省略，但是如果添加mutable属性后即使()为空也需要显示写出
mutable的作用是将[]的变量属性修改为非const。可省略
->return-type为函数的返回值，但是编译器可以自动推导，可省略
{}为函数体，可以使用[]和()内的变量

void test()
{
     
	int a = 10;
	int b = 20;
	[a, b] {
     return a + b; };
	[a, b](int c) {
     return a + b + c; };
	[a, b](int c) ->int{
     return a + b + c; };
	[a, b]()mutable{
     a = 100; b = 200; };
	[] {
     };
}

如果要使用lambda表达式，可以定义一个auto变量来接收这个匿名函数

void test()
{
     
	int a = 10;
	int b = 20;
	auto fun = [a, b](int c) ->int{
     return a + b + c; };
	int ret = fun(10);
	cout << ret << endl;
}

[]如果要捕捉多个变量，如果一个一个写会非常麻烦，此时C++也引入了需要的语法来便捷操作
[=]：以值的形式捕捉上下文的所有变量（包括this指针）
[&]：以引用的形式捕捉上下文的所有变量（包括this指针）
[&x]：以引用博主的方式捕捉x
[=, &x]：x变量以引用方式来捕捉，其他变量都以值形式捕捉
[&, x]：x变量以值方式来捕捉，其他变量都以引用形式捕捉
[this]：以值形式来捕捉当前的this指针

错误捕捉方式：[=, x]、[&, &x]重复捕捉

class A
{
     
public:
	void fun(int a)
	{
     
		[this]() {
     return this->_a; };
	}
private:
	int _a;
};

void test()
{
     
	int a = 10;
	int b = 20;
	auto fun = [=](int c) ->int{
     return a + b + c; };
	auto fun1 = [&](int c) ->int {
     return a + b + c; };
	auto fun2 = [&a](int c) ->int {
     return a + c; };
	auto fun3 = [=, &a](int c) ->int {
     return a + b + c;};
	auto fun4 = [&, a](int c) ->int {
     return a + b + c; };
}

不能捕捉不在同一作用域中的变量或者是非局部变量的变量

int g = 10;

void test()
{
     
	int t = 20;
	auto f = [g] {
     };//error
}

int main()
{
     
	auto f1 = [t] {
     };//error
	test();
	return 0;
}

不能进行赋值，但是可以进行拷贝

void test()
{
     
	int t = 20;
	auto f = [t](int a) {
     return a + t; };
	auto f1 = [t](int a) {
     return a + t; };
	f = f1;//error
	auto f2(f);//ok
}

我们再来看看lambda表达式中C++底层是如何实现的
测试代码如下：

struct Sum
{
     
	int operator()(int a, int b)
	{
     
		return a + b;
	}
};

void test()
{
     
	auto f = [](int a, int b) {
     return a + b; };
	int sum = f(10, 20);
	Sum s;
	s(10, 20);
}

我们来看看执行f时的汇编代码和创建Sum对象进行的括号运算符重载的汇编代码。我们可以发现其实lambda底层就是通过伪函数来实现的