目录
1、lambda表达式的概念
在C++98中，如果完美相对一个数组排序，可以使用sort
int main()
{
int array[] = { 4,1,8,5,3,7,0,9,2,6 };
// 默认按照小于比较，排出来结果是升序
std::sort(array, array + sizeof(array) / sizeof(array[0]));
// 如果需要降序，需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0;
}在现实中，对结构体对象进行排序的情况更多，需要自定义比较规则，此时就需要用到仿函数了
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
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;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
// 里面是多参数的隐式类型转换，外面是initializer_list
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
return 0;
}使用仿函数是复杂的，当比较逻辑不一样时，都需要去重新写一个类。这样，一个结构体对象若需要根据不同的成员变量排序时，需要写非常多个类。为了简便，C++11引入了lambda表达式
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,3 }, { "菠萝", 1.5, 4 } };
// 里面是多参数的隐式类型转换，外面是initializer_list
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)->bool {return gl._price < gr._price; });// 按价格排升序
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)->bool {return gl._price > gr._price; });// 按价格排降序
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)->bool {return gl._evaluate < gr._evaluate; });// 按评价升序
sort(v.begin(), v.end(), [](const Goods& gl, const Goods& gr)->bool {return gl._evaluate > gr._evaluate; });// 按评价降序
return 0;
}2、lambda表达式的语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
lambda就是一个匿名函数的对象
2.1 lambda表达式各部分说明
（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。不可省略
（2）(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
（3）mutable：可变关键字，默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
（4）->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
（5）{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。不可省略。
int main()
{
auto add = [](int x, int y)->int {return x + y; };
cout << add(1, 2) << endl;
auto func1 = []()->int
{
cout << "hello world" << endl;
return 0;
};
func1();
auto func2 = []
{
cout << "hello world" << endl;
return 0;
};
func2();
return 0;
}因为lambda表达式没有类型，所以使用auto
lambda表达式中只有捕捉列表和函数体不能省略，func2就是最省略的写法
lambda表达式单独写在最后需要;，若作为参数则不需要
2.2 捕捉列表
一个lambda表达式的函数体中，只能使用全局变量、捕捉列表、参数列表中的值
int main()
{
int a = 0, b = 1;
auto func1 = [](int& x)
{
x++;
a++;
};
func1(b);
cout << a << " " << b << endl;
return 0;
}在上面这段代码中，a++是会报错的，因为a并不是全局变量、捕捉列表、参数列表中的值，此时就需要使用捕捉列表来捕捉a
int main()
{
int a = 0, b = 1;
auto func1 = [a](int& x)
{
x++;
a++;
};
func1(b);
cout << a << " " << b << endl;
return 0;
}然后就发现，还是会错，因为捕捉列表捕捉到的变量是const修饰的，若需要改变捕捉到的值需要加可变关键字mutable，注意，加了mutable后参数列表就不能省略，即使没有参数
int main()
{
int a = 0, b = 1;
auto func1 = [a](int& x)mutable
{
x++;
a++;
};
func1(b);
cout << a << " " << b << endl;
return 0;
}结果是
，a的值并没有变，因为这是传值捕捉，只是拷贝，并且是用const修饰的
实际上，捕捉列表共有5种
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针
int main()
{
int a = 0, b = 1;
auto func1 = [&a](int& x)
{
x++;
a++;
};
func1(b);
cout << a << " " << b << endl;
return 0;
}结果是
，传引用捕捉就不需要mutable了
现在来实现一个交换两个数的lambda表达式
int main()
{
int a = 0, b = 1;
auto swap1 = [](int& x, int& y)
{
int tmp = x;
x = y;
y = tmp;
};
swap1(a, b);
cout << a << " " << b << endl;
auto swap2 = [&a, &b]
{
int tmp = a;
a = b;
b = tmp;
};
swap2();
cout << a << " " << b << endl;
return 0;
}捕捉列表还可以混合捕捉
int main()
{
int a = 0, b = 1, c = 2, c = 3;
auto func1 = [&a, b]
{
a++;
};
auto func2 = [&, b] // 所有都用引用捕捉，b用传值捕捉
{
a++;
};
return 0;
}3、lambda表达式的底层原理
我们前面说了，lambda表达式就是一个匿名函数对象。函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象
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 monty, int year)->double {return monty * rate * year;};
r2(10000, 2);
return 0;
}转到反汇编我们可以看到
实际上，lambda编译时会生成一个类，这个类中有operator()，捕捉列表中的对象是成员变量存在lambda类对象中，捕捉的本质是构造函数的初始化参数。也就是说生成的这个类的成员变量就是捕捉列表的值，捕捉列表里面的值就起到了初始化的作用。在底层，这个类对象是有名字的，只是对我们是匿名的，所以要使用auto。同一个lambda表达式不同时候运行生成的也不同，因为lambda表达式的名称的后面有uuid
注意，若捕捉列表[=]，但是函数体内没有用到，也不会被捕捉
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
