目录
一、引例
在C++98中,使用sort排序时,如果待排序类型是自定义类型,我们要根据自己的需求实现相应的仿函数完善这个功能。比如对货物Goods要按照价格排序。
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& g1, const Goods& g2)
{
return g1._price < g2._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._price > g2._price;
}
};
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());
return 0;
}
如果有更复杂的类的场景,可能要按照需求实现更多仿函数,这对于编程者将会是不小的任务量。而为了更加方便的实现我们的需求。C++11新增了lambda表达式。
int main()
{
vector<Goods> v = {
{"苹果",2.1,5},
{"香蕉",3,4},
{"橙子",2.2,3},
{"菠萝",1.5,4}
};
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._evaluate < g2._evaluate; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)
{return g1._evaluate > g2._evaluate; });
}
二、格式
lambda表达式可以理解为有函数相同的功能,但是语法不同于传统函数,该表达式的结果是一个对象,类型为lambda函数,比较复杂,每个表达式的类型不一样,一般写auto。
lambda表达式格式:[capture-list] (parameters) mutable -> return-type { statement }
[capture-list] : 捕捉列表
,该列表总是出现在
lambda
函数的开始位置,
编译器根据
[]
来
判断接下来的代码是否为
lambda
函数
,
捕捉列表能够捕捉上下文中的变量供
lambda
函数使用
。
(parameters):参数列表。与
普通函数的参数列表一致
,如果不需要参数传递,则可以连同()
一起省略。
mutable:默认情况下,
lambda
函数总是一个
const
函数,
mutable
可以取消其常量性。使用该修饰符时,参数列表不可省略(
即使参数为空
),
一般省略该部分
。
->returntype:返回值类型
。用
追踪返回类型形式声明函数的返回值类型
,没有返回 值时此部分可省略。返回值类型明确情况下,也可省略,由编译器对返回类型进行推
导
。
{statement}:函数体
。在该函数体内,除了可以使用其参数外,还可以使用所有捕获到的变量。
注意:
在lambda
函数定义中,
参数列表和返回值类型都是可选部分,而捕捉列表和函数体可以为
空
。因此
C++11
中
最简单的
lambda
函数为:
[]{}
;
该
lambda
函数不能做任何事情。
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[]{};
// 省略参数列表和返回值类型,返回值类型由编译器推导为int
int a = 3, b = 4;
[=]{return a + 3; };
// 省略了返回值类型,无返回值类型
auto fun1 = [&](int c){b = a + c; };
fun1(10)
cout<<a<<" "<<b<<endl;
// 各部分都很完善的lambda函数
auto fun2 = [=, &b](int c)->int{return b += a+ c; };
cout<<fun2(10)<<endl;
// 复制捕捉x
int x = 10;
auto add_x = [x](int a) mutable { x *= 2; return a + x; };
cout << add_x(10) << endl;
return 0;
}
捕捉列表
捕捉列表描述了上下文中那些数据可以被lambda使用,以及使用的方式传值还是传引用。
[var]
:表示值传递方式捕捉变量
var
[=]
:表示值传递方式捕获所有父作用域中的变量
(
包括
this)
[&var]
:表示引用传递捕捉变量
var
[&]
:表示引用传递捕捉所有父作用域中的变量
(
包括
this)
[this]
:表示值传递方式捕捉当前的
this
指针
注意:a. 父作用域指包含 lambda 函数的语句块b. 语法上捕捉列表可由多个捕捉项组成,并以逗号分割 。比如: [=, &a, &b] :以引用传递的方式捕捉变量 a 和 b ,值传递方式捕捉其他所有变量 [&, a, this] :值传递方式捕捉变量 a 和 this ,引用方式捕捉其他变量c. 捕捉列表不允许变量重复传递,否则就会导致编译错误 。比如: [=, a] : = 已经以值传递方式捕捉了所有变量,捕捉 a 重复d. 在块作用域以外的 lambda 函数捕捉列表必须为空 。e. 在块作用域中的 lambda 函数仅能捕捉父作用域中局部变量,捕捉任何非此作用域或者非局部变量都会导致编译报错。f. 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;
}
函数对象
函数对象,又称为仿函数,即可以像函数一样使用的对象,就是在类中重载了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);
// lamber
auto r2 = [=](double monty, int year)->double{return monty*rate*year;
};
r2(10000, 2);
return 0;
}
从使用方式上来看,函数对象与lambda表达式完全一样。 函数对象将rate作为其成员变量,在定义对象时给出初始值即可,lambda表达式通过捕获列表可以直接将该变量捕获到。
实际在底层编译器对于lambda表达式的处理方式,完全就是按照函数对象的方式处理的,即:如果定义了一个lambda表达式,编译器会自动生成一个类,在该类中重载了operator()。