在需要排序时候,如何快速实现排序。C++算法库为我们提供了sort函数,其底层通过快排实现。sort函数可以传递两个参数,一个是排序排序元素起始地址,第二个是排序元素结束地址,这样传入参数,sort会默认排升序。
当你的排序方式不仅仅需要简单排升序时候,就需要用到sort的第三个参数,排序方式。下面通过实现这个排序方式来认识伪函数和lamda表达式。
仿函数:函数对象
仿函数,又称伪函数。顾名思义,它并不是真正的函数。给一个普通的类,重载一个()
,就实现了伪函数的定义。
struct classFunc
{
int operator(/*重载运算符*/)(int a,int b /*形参列表*/)
{
return a + b;
}
};
functional头文件中的函数对象
仿函数是对象不是函数,所以我们可以定义一个函数对象,然后采用函数对象实现回调。
实际上,sort()函数底层就是实现了仿函数,比如你想要排降序,就需要这样调用。
#include<iostream>
#include<algorithm>
#include<vector>
#include<functional>//greater<int>()包含在这个头文件
using namespace std;
int main()
{
vector<int> num{ 11, 22, 50, 7, 90, 4333, 5 };
sort(num.begin(), num.end(),greater<int>());//底层采用模板实现,所以应该指明类型
for (int i : num)
cout << i<<" ";
system("pause");
}
functional头文件中是C++语言库里实现的函数对象,常用的函数对象如下:
重载的运算符 | 函数对象 |
---|---|
> | greater<T>() |
< | less<T>() |
>= | greater_equal<T>() |
<= | less_equal<T>() |
自定义函数对象
当然,我们可以自己定义函数对象:
#include<iostream>
using namespace std;
struct classFunc
{
int operator()(int a,int b)
{
return a + b;
}
};
int main()
{
classFunc f;//定义函数对象
cout << f(20, 40) << endl;
system("pause");
}
自定义函数对象实现sort函数的排序方式,将物品安装价格由高到底排序,因为mygreater并不是模板类实现的函数对象,所以不需要制定参数类型。
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
struct Goods{
string name;
double price;
};
struct mygreater{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1.price > g2.price;
}
};
int main()
{
vector<Goods> Gd{ { "苹果", 2.1 }, { "相交", 3 }, \
{ "橙子", 2.2 }, { "菠萝", 1.5 } };
sort(Gd.begin(), Gd.end(), mygreater());
for (Goods& i : Gd)
cout << i.name << ":" << i.price << endl;
system("pause");
}
lamda表达式
我们看到函数对象写起来有些繁琐,有时候我们可能实现了这个函数对象,用一次之后就不再使用了。C++11提供了这种情况下,一种更简便的实现lamda表达式。
[capture-list] (parameters) mutable -> return-type {
statement }
- [capture-list] : 捕捉列表,该列表总是出现在lambda函数的开始位置,编译器根据[]来判断接下来
的代码是否为lambda函数,捕捉列表能够捕捉上下文中的变量供lambda函数使用。 - (parameters):参数列表。与普通函数的参数列表一致,如果不需要参数传递,则可以连同()一起
省略 - mutable:默认情况下,lambda函数总是一个const函数,mutable可以取消其常量性。 使用该修饰符时,参数列表不可省略(即使参数为空)。
- ->return-type:返回值类型。用追踪返回类型形式声明函数的返回值类型,没有返回值时此部分
可省略。返回值类型明确情况下,也可省略,由编译器对返回类型进行推导。 - {statement}:函数体。在该函数体内,除了可以使用其参数外,还可以使用所有捕获到的变量。
注意: 在lambda函数定义中,参数列表和返回值类型都是可选部分,而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为:[]{}; 该lambda函数不能做任何事情。
#include<iostream>
using namespace std;
int main()
{
int a = 10, b = 20;
auto Func = [&]()mutable ->int{
int c = a;
a = b;
b = c;
return a + b;
};
cout << a << endl << b << endl << Func() << endl;
system("pause");
}
通过上述例子可以看出,lambda表达式实际上可以理解为无名函数,该函数无法直接调用,如果想要直接调用,可借助auto将其赋值给一个变量。
注意:
- 父作用域指包含lambda函数的语句块
- 语法上捕捉列表可由多个捕捉项组成,并以逗号分割。
比如:
[=, &a, &b]:以引用传递的方式捕捉变量a和b,值传递方式捕捉其他所有变量
[&,a, this]:值传递方式捕捉变量a和this,引用方式捕捉其他变量 - 捕捉列表不允许变量重复传递,否则就会导致编译错误。 比如:[=, a]:=已经以值传递方式捕捉了所有变量,捕捉a重复。
- 在块作用域以外的lambda函数捕捉列表必须为空。
- 在块作用域中的lambda函数仅能捕捉父作用域中局部变量,捕捉任何非此作用域或者非局部变量都会导致编译报错。
- lambda表达式之间不能相互赋值,即使看起来类型相同。
同样是物品安装价格排降序,使用lamda表达式实现:
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
struct Goods{
string name;
double price;
};
int main()
{
vector<Goods> Gd{ { "苹果", 2.1 }, { "相交", 3 }, \
{ "橙子", 2.2 }, { "菠萝", 1.5 } };
sort(Gd.begin(), Gd.end(), [](const Goods& g1, const Goods&g2)\
{return g1.price > g2.price; });
for (Goods& i : Gd)
cout << i.name << ":" << i.price << endl;
system("pause");
}
lamda表达式和函数对象
#include<iostream>
using namespace std;
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);
// lamda表达式
auto r2 = [=](double monty, int year)->double{return monty*rate*year; };
r2(10000, 2);
system("pause");
return 0;
}
实际在底层编译器对于lambda表达式的处理方式,完全就是按照函数对象的方式处理的,即:如果定义了一个lambda表达式,编译器会自动生成一个类,在该类中重载了operator()。