C++ Lambda表达式用法和原理

Lambda表达式用法

lambda表达式是C++11中引入的一项新技术，利用lambda表达式可以编写匿名函数，这样省去了我们手动声明和定义函数的时间，但是有人说，Lambda表达式增加了代码的可读性，这个真不敢恭维，我觉得Lambda破坏了函数原本的思想，而且语法很乱，反而降低了代码的可读性，本人在编程中，不使用Lambda表达式。

Lambda 表达式完整的格式如下：

[捕获列表] (形参列表) mutable 异常列表-> 返回类型
{
    函数体
}

捕获列表：捕获外部变量，捕获的变量可以在函数体中使用（可省略，即不捕获外部变量）

• []：默认不捕获任何变量；
• [=]：默认以值捕获所有变量；
• [&]：默认以引用捕获所有变量；
• [x]：仅以值捕获x，其它变量不捕获；
• [&x]：仅以引用捕获x，其它变量不捕获；
• [=, &x]：默认以值捕获所有变量，但是x是例外，通过引用捕获；
• [&, x]：默认以引用捕获所有变量，但是x是例外，通过值捕获；
• [this]：通过引用捕获当前对象（其实是复制指针）；
• [*this]：通过传值方式捕获当前对象；

形参列表：和普通函数的形参列表一样（可省略，即无参数列表）
mutable：mutable 关键字，如果有，则表示在函数体中可以修改捕获变量
异常列表：noexcept / throw(…),和普通函数的异常列表一样，可省略，即代表可能抛出任何类型的异常。
返回类型：和函数的返回类型一样。可省略，如省略，编译器将自动推导返回类型。
函数体：代码实现。可省略，但是没意义。

lambda表达式因为禁用了赋值操作符，所以不可以直接赋值，即使他们形参和返回值完全一样，但是lambda表达式没有禁用复制构造函数，所以你仍然可以用一个lambda表达式去初始化另外一个lambda表达式而产生副本，并且lambda表达式也可以赋值给相对应的函数指针，这也使得你完全可以把lambda表达式看成对应函数类型的指针。

另外，lambda表达式不能有默认参数，不支持可变参数。

示例：

#include <iostream>

int main()
{
	int a = 1;
	int b = 2;
	auto lambda = [a, b](int x, int y)mutable throw() -> bool
	{
		return a + b > x + y;
	};
	bool ret = lambda(3, 4);

	std::cout << ret << std::endl;
}

//output：0

Lambda表达式实现原理

Lambda表达式的实现步骤：

• 创建lambda匿名类，实现构造函数，使用lambda表达式的函数体重载operator()，因此，lambda表达式也叫作匿名函数对象，
• 创建lambda匿名类对象
• 通过对象调用operator()
  上述代码，经过编译器翻译后，变成了如下代码：

#include <iostream>

class lambda_xxxx {
private:
	int a;
	int b;

public:
	lambda_xxxx(int pa, int pb) {
		a = pa;
		b = pb;
	}
	bool operator()(int x, int y)throw() {
		return a + b > x + y;
	}
};
int main()
{
	int a = 1;
	int b = 2;
	
	lambda_xxxx obj = lambda_xxxx(a, b);
	bool ret = obj.operator()(3, 4);

	std::cout << ret << std::endl;
}

其中：

• lambda 表达式中的捕获列表，对应 lambda_xxxx 类的 private 成员
• lambda 表达式中的形参列表，对应 lambda_xxxx 类的成员函数 operator()的形参列表
• lambda 表达式中的mutable，对应 lambda_xxxx 类的成员函数 operator()的是否具有常属性，即函数后 带不带 const
• lambda 表达式中的返回类型，对应 lambda_xxxx 类的成员函数 operator()的返回类型
• lambda 表达式中的函数体，对应 lambda_xxxx 类的成员函数 operator()的函数体

此外，lambda表达式捕获列表的捕获方式，也影响pravite成员的类型

• 值捕获：private 成员的类型与捕获变量的类型一致
• 引用捕获：private 成员 的类型是捕获变量的引用类型

特殊情况，lambda表达式转换为函数指针

看如下代码

#include <iostream>

typedef int(*Func)(int);

int Test(Func func)
{
	return func(1);
}

int main()
{
	auto ret = Test([](int i) {
		return i;
	});

	std::cout << ret << std::endl;
}
//output:1

Test函数接受一个函数指针作为参数，并调用这个函数指针。实际调用Test时，传入的参数却是一个lambda表达式，所以这里有一个类型的转换：lambda表达式 -> 函数指针。

上面已经提到，lambda表达式就是一个匿名对象，与函数指针按理说不应该存在转换，但是上述代码却没有问题。

其问题的关键在于，上述代码中，lambda表达式没有捕获任何外部变量，即匿名类没有任何成员变量，在operator()中也就不会用到任何成员变量，也就是说，operator()虽然是成员函数，但是不依赖this指针。

因为不依赖this，所以可以将这个operator()看做是普通的函数，那普通函数与函数指针就存在转换的可能。

编译器解析的过程如下：

• 在lambda_xxxx 类中生成一个静态函数，静态函数的函数签名和operator()一致。在这个静态函数中，通过一个空指针去调用该类的operator()

• 在lambda_xxxx 重载与函数指针的类型转换操作符，在这个函数中，返回静态函数的地址。

#include <iostream>

typedef int(*Func)(int);

class lambda_xxxx {
private:
public:
	int operator()(int i) {
		return i;
	}

	static int lambda_invoker(int i) {
		lambda_xxxx* ptr = nullptr;
		return ptr->operator()(i);
	}

	operator Func()const {
		return &lambda_invoker;
	}
};
int Test(Func func)
{
	return func(1);
}

int main()
{
	auto lambda = lambda_xxxx();
	Func func = lambda.operator Func();

	auto ret = Test(func);
	std::cout << ret << std::endl;
}