C++11——lambda表达式
Posted 两片空白
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++11——lambda表达式相关的知识,希望对你有一定的参考价值。
目录
前言
在显示生活中,我们在用手机购物时。总是可以在页面上看到下面这样的选项。
我们知道底层这是通过排序来完成的,但是当我们实现时,要写多个排序算法,写多个仿函数来实现不同变量的比较。
比如下面代码:
struct CompareNameSmall;
struct CompareNameBig;
struct ComparePriceSmall;
struct ComparePriceBig;
class Goods{
friend struct CompareNameSmall;
friend struct CompareNameBig;
friend struct ComparePriceSmall;
friend struct ComparePriceBig;
private:
string _name;
double _price;
public:
Goods(string name, double price)
:_name(name)
,_price(price)
{}
};
//仿函数
struct CompareNameSmall{
bool operator()(const Goods& g1, const Goods& g2){
return g1._name < g2._name;
}
};
struct CompareNameBig{
bool operator()(const Goods& g1, const Goods& g2){
return g1._name > g2._name;
}
};
struct ComparePriceSmall{
bool operator()(const Goods& g1, const Goods& g2){
return g1._price < g2._price;
}
};
struct ComparePriceBig{
bool operator()(const Goods& g1, const Goods& g2){
return g1._price > g2._price;
}
};
int main(){
Goods gds[] = { { "苹果", 2.5 }, { "香蕉", 3.0 }, { "梨", 3.5 } };
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), CompareNameSmall());
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), CompareNameBig());
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), ComparePriceSmall());
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), ComparePriceBig());
system("pause");
return 0;
}
随着C++的发展,人们开始觉得上面的写法太复杂了。每次为了实现一个比较算法,都需要重新定义一个类,如果每次的比较逻辑不一样,还要实现多个类,特别是在相同类的命名上。并且如果不能达到见名知义,我们还得去找对应的仿函数,才能知道它的功能,这给编程者带来了极大的不便。
因此在C++11语法中出现了lambda表达式。
一.lambda表达式用法
class Goods{
public:
string _name;
double _price;
Goods(string name, double price)
:_name(name)
, _price(price)
{}
};
int main(){
Goods gds[] = { { "苹果", 2.5 }, { "香蕉", 3.0 }, { "梨", 3.5 } };
//使用lambda表达式
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._name < g2._name; });
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._name > g2._name; });
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._price < g2._price; });
sort(gds, gds + (sizeof(gds) / sizeof(gds[0])), [](const Goods& g1, const Goods& g2)->bool{return g1._price > g2._price; });
system("pause");
return 0;
}
可以实现和上面一样的效果。虽然一样要写这么多函数,但是不需要面临去定义很多类和命名问题,并且不需要在去找函数。
但是我们发现lambda表达式的格式还是很奇怪的,下面来介绍一下lambda表达式的写法。
二.lambda表达式语法
lambda表达式书写格式:[捕捉列表](参数)mutable—>返回值类型{ 函数体 }
- [捕捉列表]:该列表总是出现在lambda表达式的起始位置,编译器根据[]来判断接下来的代码是否为lambda表达式,捕捉列表能够捕捉当前作用域中的变量,供lambda函数使用。
- [val]:表示以传值方式捕捉变量val
- [=]:表示以传值方式捕捉当前作用域中的变量,包括this指针。
- [&val]:表示以引用方式传递捕捉变量val。
- [&]:表示以引用方式传递捕捉当前作用域中的所有变量,包括this指针。
- [this]:表示以传值方式捕捉当前的this指针。
- (参数):参数列表。与普通函数参数列表使用相同。如果不需要传递参数,可以连同"()"一起省略。
- mutable:默认情况下,lambda函数总是一个const函数,捕捉的传值参数具有常性,mutable可以取消常性。使用mutable修饰符时,参数列表不能省略,即使参数为空。
- —>返回值类型:返回值类型。使用追踪返回类型形式声明函数的返回值类型,没有返回值此部分可省略。返回值类型明确的情况下,也可省略,由编译器推导。
- {函数体}:在函数体内除了可以使用参数外,还能使用捕捉的变量。
注意:在lambda表达式中,参数列表和返回值类型都可省略,而捕捉列表和函数体可以为空。所以最简单的lambda表达式为:[]{},该表达式不能做任何事。
int main(){
//最简单的lambda表达式
[]{};
//捕捉当前作用域的变量,没有参数,编译器推导返回值类型。
int a = 1;
int b = 2;
[=]{return a + b; };
//使用和仿函数差不多
auto fun1 = [&](int c){b = a + c; };
fun1(10);
cout << a << " " << b << endl;
auto fun2 = [&](int c)->int{return a + c; };
fun2(20);
cout << fun2(20) << endl;
//传值捕捉
int x = 1;
int y = 2;
auto add0 = [x, y]()mutable->int{ x *= 2;//捕捉传递传值具有常性
return x + y; };
cout << add0() << endl;
auto add1 = [&x, y]()->int{ x *= 2;//捕捉传递引用不具有常性
return x + y; };
cout << add1() << endl;
auto add2 = [](int s, int m)->int{ s *= 2;//参数不具有常性
return s + m; };
system("pause");
return 0;
}
从上面要注意的一点是:捕捉列表传值传递具有常性,要加mutable,传引用传递不具有常性,参数列表不具有常性。
捕捉列表的要和捕捉参数变量名相同,传值传递是当前作用域变量的拷贝。
int main(){
//最简单的lambda表达式
[]{};
//捕捉当前作用域的变量,没有参数,编译器推导返回值类型。
int a = 1;
int b = 2;
//auto fun1 = [x, y]()->int{return x + y; };//编译错误,要和捕捉参数名相同
//传值传递是捕捉变量的拷贝,实际外面的a,b没有交换
auto swap1 = [a, b]()mutable{int z = a; a = b; b = z; };
swap1();//注意还需要调用
cout << a << " " << b << endl;
//传引用才能真正修改
auto swap2 = [&a, &b]{int z = a; a = b; b = z; };
swap2();
cout << a << " " << b << endl;
return 0;
}
注意构造完对象后,对象调用,函数才起作用。
注意点:
- 语法上捕捉列表可由多个捕捉项组成,并以逗号隔开。捕捉项不能重复传递,否则会导致编译错误。比如:当前作用域已经有了变量a,捕捉设为[=,a],=已经捕捉过a了,编译时会报错。
- 捕捉列表只能捕捉当前作用域的局部变量,作用域以外的局部变量或者非局部变量都会报错。
- lambda表达式之间不能赋值,即使看起来类型相同。
void (*PF)();
int main(){
auto f1 = []{cout << "hello world" << endl; };
auto f2 = []{cout << "hello world" << endl; };
// 此处先不解释原因,等lambda表达式底层实现原理看完后,大家就清楚了
//f1 = f2; // 编译失败--->提示找不到operator=()
// 允许使用一个lambda表达式拷贝构造一个新的副本
auto f3(f2);
f3();
// 可以将lambda表达式赋值给相同类型的函数指针
PF = f2;
PF();
return 0;
}
三.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表达式原理:实际编译器在全局作用域自动生成了一个类,在类中重载了operator(), operator()函数的内容就是lambda表达式的内容。
可以理解成lambda表达式底层还是仿函数。本来时要程序员编写,现在变成了编译器自动生成,我们看起来跟方便了。
以上是关于C++11——lambda表达式的主要内容,如果未能解决你的问题,请参考以下文章