文章目录
- 一、引入原因
- 二、lambda 表达式的语法
- 1. lambda 表达式各部分说明
- 2.捕捉列表说明
- 三、lambda 表达式的本质
一、引入原因
如果待排序元素为自定义类型，需要用户定义排序时的比较规则。
比如：
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluation; // 评价
Goods(const char* name, double price, int evaluation)
:_name(name)
, _price(price)
, _evaluation(evaluation)
{}
};
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;
}
};
struct CompareEvaluationLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._evaluation < gr._evaluation;
}
};
struct CompareEvaluationGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._evaluation > gr._evaluation;
}
};
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());
sort(v.begin(), v.end(), CompareEvaluationLess());
sort(v.begin(), v.end(), CompareEvaluationGreater());
return 0;
}
随着 C++ 语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个 algorithm 算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是类的命名，这些都给编程者带来了极大的不便。因此，在 C++11 语法中出现了 lambda 表达式。
对上面的例子，使用 C++11 中的 lambda 表达式替换掉仿函数之后：
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 },{ "香蕉", 3, 4 },{ "橙子", 2.2, 3 },{ "菠萝", 1.5, 4 } };
/*auto ComparePriceLess = [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; };
sort(v.begin(), v.end(), ComparePriceLess);*/
// lambda表达式作为可调用对象
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price > g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluation < g2._evaluation; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._evaluation > g2._evaluation; });
return 0;
}
通过上面的代码可以看出，lambda 表达式实际是一个匿名函数。
二、lambda 表达式的语法
lambda表达式书写格式：[capture-list](parameters) mutable ->return-type { statement }
1. lambda 表达式各部分说明
① [capture-list]：捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据 [ ] 来判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下文中的变量供 lambda 函数使用。可以为空，但不能省略。
② (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同 () 一起省略。
③ mutable：传值捕捉的变量在函数体中默认是 const 类型，即不可修改。在添加了 mutable 后，便取消了其常量性，可以对此变量进行修改，但此时修改的仍然是位于 lambda 函数体中的局部变量。使用该修饰符时，参数列表不可省略（即使参数为空）。
④ ->return-type：返回值类型。用追踪返回类型的形式声明函数的返回值类型，没有返回值时此部分可省略。在返回值类型明确的情况下，也可省略，由编译器对返回值类型进行推导。
⑤ { statement }：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。可以为空，但不能省略。
注意：
在 lambda 函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。
因此 C++11 中最简单的 lambda 函数为：[ ] { } ，该 lambda 函数不能做任何事情。
测试代码1：
int main()
{
// 实现一个两个数相加的lambda表达式
auto add1 = [](int a, int b)->int {return a + b; };
// 在返回值类型明确的情况下，也可省略
//auto add1 = [](int a, int b) {return a + b; };
cout << add1(1, 2) << endl;
// 若没有参数，则可以省略参数列表
auto Func1 = [] {cout << "hello world" << endl; };
Func1();
return 0;
}
测试代码2：
int main()
{
int a = 1, b = 2;
// 传值捕捉的变量在函数体中默认是const类型，即不可修改
auto swap1 = [a, b](){
int z = a;
//a = b; // 编译报错
//b = z; // 编译报错
cout << a << " " << b << endl;
};
swap1();
cout << a << " " << b << endl;
// 在添加了mutable后，便取消了传值捕捉的变量的常量性，可以对此变量进行修改
// 但此时修改的仍然是位于lambda函数体中的局部变量
auto swap2 = [a, b]()mutable {
int z = a;
a = b;
b = z;
cout << a << " " << b << endl;
};
swap2(); // 由于是传值捕捉，所以无法改变lambda函数外的a,b变量
cout << a << " " << b << endl;
return 0;
}
测试代码3：
int main()
{
int a = 1, b = 2;
// 传引用传参
auto swap3 = [](int& x, int& y) {
int z = x;
x = y;
y = z;
};
swap3(a, b); // 可以改变a,b变量
cout << a << " " << b << endl;
// 传引用捕捉
auto swap4 = [&a, &b]() {
int z = a;
a = b;
b = z;
};
swap4(); // 可以改变a,b变量
cout << a << " " << b << endl;
return 0;
}
通过上述代码可以看出，lambda 表达式其实是一个匿名函数（即没有函数名的函数），该函数无法直接调用，如果想要直接调用，需要将其赋值给一个变量（变量的类型使用 auto 自动推导）。
2.捕捉列表说明
捕捉列表描述了上下文中哪些变量可以被 lambda 函数体使用，以及变量的捕捉方式是传值捕捉还是传引用捕捉。
- [var] ：表示以值传递方式捕捉变量 var。
- [=] ：表示以值传递方式捕获父作用域中的所有变量（包括 this）。
- [&var] ：表示以引用传递方式捕捉变量 var 。
- [&] ：表示以引用传递方式捕捉父作用域中的所有变量（包括 this）。
- [this] ：表示以值传递方式捕捉当前的 this 指针。
注意：
① 父作用域指包含 lambda 函数的语句块。
② 捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以传值方式捕捉所有变量，除了 a,b 变量以传引用捕捉。
[&, a, b]：以传引用方式捕捉所有变量，除了 a,b 变量以传值捕捉。
[a, &b]：以传值方式捕捉 a 变量，以传引用方式捕捉 b 变量。
③ 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：已经以传值方式捕捉了所有变量，传值捕捉 a 重复。
[&, &a]：已经以引用方式捕捉了所有变量，传引用捕捉 a 重复。
④ 不能捕捉带有静态存储持续时间的变量，但可以在函数体中直接访问。
⑤ 在块作用域中的 lambda 函数，仅能捕捉父作用域中的局部变量。
测试代码1：
// 不能捕捉带有静态存储持续时间的变量，但可以在函数体中直接访问
int p = 10;
static int q = 20;
//auto func1 = [p, &q]() {}; // 编译报错
auto func2 = []() {p += 2; q += 5; };
int main()
{
//auto func3 = [p]() {}; // 编译报错
auto func4 = []() {++p; ++q; };
auto func5 = []() {cout << p << " " << q << endl; };
func4();
func5();
return 0;
}
测试代码2：
// 在块作用域中的 lambda 函数，仅能捕捉父作用域中的局部变量
int main()
{
int x = 1, y = 2;
auto func6 = [x, &y]() {
y = 4;
cout << x << " " << y << endl;
};
func6();
return 0;
}
其实，捕捉跟传参差不多，若不想传参，可以在捕捉列表进行捕捉。
三、lambda 表达式的本质
通过下面的代码来查看 lambda 表达式的类型：
int main()
{
int a = 1, b = 2;
auto swap3 = [](int& x, int& y) {
int z = x;
x = y;
y = z;
};
cout << typeid(swap3).name() << endl; // 打印lambda表达式的类型
return 0;
}
在 VS2015 下，其运行结果是：
class <lambda_7721a5d10c60e907b096b0ca7c8bb873> ，即 class <lambda_UUID> 的形式。
UUID（即 Universally Unique Identifier，通用唯一识别码）是通过算法生成的唯一字符串，能够保证每次生成的 UUID 都不会重复。
其实，lambda 表达式本质上是仿函数，就像范围 for 本质上是迭代器一样。
我们将通过下面的例子进行说明：
class Rate
{
public:
Rate(double rate)
: _rate(rate)
{}
double operator()(double money, int year)
{
return money * _rate * year;
}
private:
double _rate;
};
int main()
{
double rate = 0.49;
// 函数对象
Rate r1(rate);
r1(10000, 2); // 调用函数对象
// lambda表达式
auto r2 = [=](double money, int year)->double {return money*rate*year; };
r2(10000, 2); // 调用lambda
return 0;
}
在 VS2015 下，观察和对比仿函数与 lambda 表达式的反汇编代码：
lambda 的底层实现，其实是被处理成一个类名为 <lambda_UUID> 的仿函数类。
在调用 lambda 时，会先构造一个 lambda 对象，然后调用 lambda 对象的 operator() 函数。
由于 lambda 表达式在底层实现时会被处理成类名为 <lambda_UUID> 的仿函数类，而且生成的 UUID 能保证不重复。
因此，两个 lambda 表达式，即使实现完全一样，但本质上也是两个不同类型的仿函数类，所以它们之间不能相互赋值。
// lambda表达式之间不能相互赋值
int main()
{
int x = 5, y = 7;
auto f1 = [x, &y]()->int {y = 2 * x; return x + y; };
auto f2 = [x, &y]()->int {y = 2 * x; return x + y; };
// 即使实现完全一样，但本质上也是两个不同的仿函数类
// 类型不同
cout << typeid(f1).name() << endl;
cout << typeid(f2).name() << endl;
// f1 = f2; // 编译报错
return 0;
}
lambda 表达式允许拷贝构造。
// 允许使用一个lambda表达式拷贝构造一个新的副本
int main()
{
auto f3 = []() {cout << "hello world" << endl; };
auto f4(f3);
// 由于是拷贝构造，所以副本类型跟原类型相同
cout << typeid(f3).name() << endl;
cout << typeid(f4).name() << endl;
// 由于lambda表达式删除了operator=函数
// 所以相同类型的lambda表达式也不能相互赋值
// f3 = f4; // 编译报错
return 0;
}
