lamaba表达式的引入
- 在C++11之前,如果我们想对自定义类型Goods排序,可以根据姓名,价格,学号按照从大到小或者从小到大的方式排序,可是,这样我们要写额外写6个相关的仿函数.
- 并且我们在对自定义仿函数命名的过程中,很容易会因为命名不规范造成代码解读麻烦,无法通过仅仅通过仿函数名字了解实际功能,只能重新去查找对应的函数名的仿函数去了解实际功能.
struct Goods
{
string _name; //名字
double _price; //价格
int _num; //数量
};
struct ComparePriceLess
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._price < g2._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._price > g2._price;
}
};
struct CompareNumLess
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._num < g2._num;
}
};
struct CompareNumGreater
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._num > g2._num;
}
};
int main()
{
vector<Goods> v = {
{
"苹果", 2, 20 }, {
"香蕉", 3, 30}, {
"橙子", 4,40 }, {
"菠萝", 5,50 } };
sort(v.begin(), v.end(), ComparePriceLess()); //按Goods价格升序排序
sort(v.begin(), v.end(), ComparePriceGreater()); //按Goods价格降序排序
sort(v.begin(), v.end(), CompareNumLess()); //按Goods升序排序
sort(v.begin(), v.end(), CompareNumGreater()); //按Goods降序排序
return 0;
}
在C++11后,我们便可以通过lamada表达式来解决,lamada表达式实际上就是一个匿名函数,这样我们即可通过lamada表达式直接了解sort排序的比较方式,进而提高了代码的可读性.
int main()
{
vector<Goods> v = {
{
"苹果", 2.1, 300 }, {
"香蕉", 3.3, 100 }, {
"橙子", 2.2, 1000 }, {
"菠萝", 1.5, 1 } };
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._num < g2._num; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._num < g2._num; });
return 0;
}
lambda表达式语法
lamada表达式的书写格式:
[capture-list] (parameters) mutable -> return-type
{
statement
}
lamabda达式各部分说明
- [capture-list]: 捕捉列表,该列表总是出现在lambda表达式的开始位置,编译器会根据[]来判断接下来的代码是否为lambda表达式, 捕捉列表能够根据上下文中的变量让lambda表达式使用.
- (parameters): 参数列表,与普通的参数列表一致,如果不需要传递参数,则可以来连同()一起省略.
- mutable: 默认情况下,lambda表达式总是一个const函数(函数形参不可以被修改),而mutable可以取消常量性,在使用该修饰符时,参数列表是不可以省略的(即使参数列表为空.
- ->returntype: 返回值类型.,一般由于编译器对返回类型进行推导,在返回值明确的情况下,可以省略.
- {statement}: 函数体.在该函数体内,除了可以使用函数体内的形参外,还可以使用所有被捕获到的变量.
lambda表达式的简单运用
int mian()
{
//由于lambda表达式实际上就是一个匿名对象,没有函数名不好调用,但是我们可以通过auto自动获取.
auto add1 = [](int a, int b) {
return a + b; }; //省略返回值.
cout << add1(1, 2) << endl;
}
捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式为传值还是传引用.
- [var]：表示值传递方式捕捉变量var.
- [=]：表示值传递方式捕获所有父作用域中的变量(包括this).
- [&var]：表示引用传递捕捉变量var.
- [&]：表示引用传递捕捉所有父作用域中的变量(包括this).
- [this]：表示值传递方式捕捉当前的this指针.
lambda表达式中未使用捕获列表和使用捕获列表对比.
如果我们不适用捕获列表,我们就要额外写函数形参,在调用时也必须将实参传过去,这样过于麻烦.
int main()
{
//之前做法
int x = 0,y = 1;
auto swap1 = [](int& x1, int& x2) {
int tmp = x1; x1 = x2; x2 = tmp;};
swap1(x, y);
return 0;
}
所以,我们可以使用捕获列表,又因为传值捕获过来的x,y通常是不可以被修改的(可以使用mutable修饰符),并且此时捕获过来的x,y仅仅为实参的拷贝,此时,我们一般采用引用捕捉,这样让代码更加简洁.
int main()
{
auto swap2 = [&x, &y] {
int tmp = x; x = y; x = tmp;}; //引用捕捉.
swap2(); //不需要传递实参.
cout << x << ":" << y << endl;
}
捕捉列表其他特性的简单运用
int main()
{
int a, b, c, d, e;
auto f1 = [=] {
cout << a << b << d << e; }; //a,b,c,d,e全部传值捕获.
f1();
auto f2 = [=, &a] {
a++; cout << a << b << c << d << e; }; //b,c,d,e传值捕获,a传引用捕获.
f2();
}
但是注意,捕获列表不允许变量重复传递,否则就会导致编译错误.
int main()
{
int a, b, c, d, e;
auto f = [=,a] {
cout << a << b << d << e; }; //重复捕获.
}
lamaba表达式底层原理探索
编译器对于lambda的处理,实际上和仿函数的处理一样.
为了对lambda表达式的底层原理进行验证,我们分别写了一个仿函数和一个lambda表达式,他们的功能相同.
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);
// lamber表达式
auto r2 = [=](double monty, int year)->double {
return monty * rate * year;
};
r2(10000, 2);
return 0;
}
当我们对仿函数和lambda表达式分别调用时,转到反汇编查看.
总结:
- 从使用方式来看,仿函数与lambda表达式完全一样,函数对象将rate作为其成员变量，在定义对象时传递实参即可,lambda表达式通过捕获列表可以直接将该变量捕获到实参传过去。
- 从底层实现的方式来看,完全就是按照仿函数的方式处理,当我们定义一个lambda表达式时,编译器就会主动生成一个仿函数,并且,为了方便处理,编译器都要通过UUID的方式基本生成一个唯一的仿函数名.然后在调用的时候通过lambda表达式调用这个仿函数,该仿函数又调用操符重载operator().所以实际上,捕获列表捕获到的变量传递给了operator()后在函数体内实现.