前言
本篇文章我们要学习的是lambda表达式，它是C++11新增的一种特别方便的语法，相较于之前的函数指针以及仿函数都方便了不少，下面就让我们一起来学习吧。
一、lambda表达式
1.1 lambda表达式出现的场景
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法，如果待排序元素为自定义类型，需要用户定义排序时的比较规则，如下面自定义的比较排序方式：
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 } };
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
return 0;
}
随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一个algorithm算法，都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C++11语法中出现了Lambda表达式。
我们来看看使用lambda表达式的代码：
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
// priceLess为lambda对象
auto priceLess = [](const Goods& g1, const Goods& g2)->bool {return g1._price < g2._price; };
sort(v.begin(), v.end(), priceLess);
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
return g1._price < g2._price;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
return g1._price > g2._price;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
return g1._evaluate < g2._evaluate;
});
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2)->bool {
return g1._evaluate > g2._evaluate;
});
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
return 0;
}
上述代码就是使用C++11中的lambda表达式来解决，也可以看出lambda表达式实际是一个匿名函数，看起来是不是非常的方便简洁呢？下面就让我们学习一下lambda表达式的语法。
1.2 lambda表达式语法
- lambda表达式各部分说明
- [capture-list] : 捕捉列表。 该列表总是出现在lambda函数的开始位置，编译器根据
[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。 - (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
- mutable：默认情况下，lambda函数总是一个const函数，
mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。 - ->returntype：返回值类型。 用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。 (注：为了代码可读性最好还是加上！！)
- {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：
[]{}; 该lambda函数不能做任何事情。
下面我们简单来写几个lambda表达式用用它的语法：
int main()
{
auto add1 = [](int x, int y)->int {return x + y; }; // add1是一个lambda对象
cout << add1(1, 2) << endl; // lambda对象调用函数的方式跟仿函数一样
// [](int x, int y)->int {return x + y; }是一个lambda对象
cout << [](int x, int y)->int {return x + y; }(10, 20) << endl;
// 在类型明确的条件下 -> 返回值类型可以省略，由编译器自行推导
auto add2 = [](int x, int y) { return x + y; };
cout << add2(2, 4) << endl;
// 如果不需要参数传递，则可以省略()
auto func = [] {cout << "hello world" << endl; };
func();
return 0;
}
通过上述例子可以看出，lambda表达式实际上可以理解为无名函数，该函数无法直接调用，如果想要直接调用，可借助auto将其赋值给一个变量。
- 捕获列表说明
捕捉列表描述了上下文中哪些数据可以被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表达式之间不能相互赋值，即使看起来类型相同
我们来看看其中的用法：
int main()
{
int x = 10, y = 20;
//auto swap1 = [x, y]() // 传值捕捉 -- 里面改变不影响外面，但语法上lambda函数总被认为是一个const函数，因此xy这里不能被修改
//{
// int tmp = x;
// x = y;
// y = tmp;
//};
// 凡是想要"修改"传值捕捉的值，都需要加mutable修饰
// 传值捕捉 -- 捕捉外面的x、y值，里面改变不影响外面
auto swap2 = [x, y]() mutable // 从语法上用mutable修饰表示参数列表是可以修改的，就是为了通过这个代码编译
{ // 实际上lambda对象的函数体就是一个独立的作用域
int tmp = x;
x = y;
y = tmp;
};
swap2();
cout << "x = " << x << ", y = " << y << endl;
// 引用捕捉 -- 跟传引用传参一致，为xy取别名，里面改变外面也会跟着改变
auto swap3 = [&x, &y]() {
int tmp = x;
x = y;
y = tmp;
};
swap3();
cout << "x = " << x << ", y = " << y << endl;
// 混合捕捉
auto func1 = [&x, y]() mutable {
x = 10;
y = 20;
};
func1();
cout << "x = " << x << ", y = " << y << endl;
// 全部传值捕捉
auto func2 = [=]() mutable {
x = 80;
y = 90;
};
func2();
cout << "x = " << x << ", y = " << y << endl;
// 全部引用捕捉
auto func3 = [&]() {
x = 80;
y = 90;
};
func3();
cout << "x = " << x << ", y = " << y << endl;
// 全部传值捕捉，x传引用捕捉
auto func4 = [=, &x]() mutable {
x = 90;
y = 100;
};
func4();
cout << "x = " << x << ", y = " << y << endl;
// 全部引用捕捉，y传值捕捉
auto func5 = [&, y]() mutable{
x = 100;
y = 100;
};
func5();
cout << "x = " << x << ", y = " << y << endl;
return 0;
}
//打印如下：
/*x = 10, y = 20
x = 20, y = 10
x = 10, y = 10
x = 10, y = 10
x = 80, y = 90
x = 90, y = 90
x = 100, y = 90
*/
为什么lambda表达式之间不能相互赋值，我们来看一组例子：
void (*PF)();
int main()
{
auto f1 = [] {cout << "hello world" << endl; };
auto f2 = [] {cout << "hello world" << endl; };
f1 = f2; // 编译失败--->提示找不到operator=()
// 允许使用一个lambda表达式拷贝构造一个新的副本
auto f3(f2);
f3();
// 可以将lambda表达式赋值给相同类型的函数指针
PF = f2;
PF();
return 0;
}
具体原因我们接着来对比仿函数与lambda对象就知道了。
1.3 函数对象与lambda对象
函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了operator()运算符的类对象。
我们可以发现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);
// lambda
auto r2 = [=](double monty, int year)->double { return monty * rate * year;
};
r2(10000, 2);
return 0;
}
从使用方式上来看，函数对象与lambda表达式完全一样。函数对象将rate作为其成员变量，在定义对象时给出初始值即可，lambda表达式通过捕获列表可以直接将该变量捕获到。
实际在底层编译器对于lambda表达式的处理方式，完全就是按照函数对象的方式处理的。即：如果定义了一个lambda表达式，编译器会自动生成一个类，在该类中重载了operator()。注：上述右边一长串类型指明其实就是编译器自动生成的一个类，由lambda+uuid组成，uuid是通用的唯一识别码，所以说每个lambda对象的类型都是不一样的，不确定的，在编译阶段编译器自动给你生成的！！
那么我们就明白了lambda表达式之间为什么不能相互赋值的原因了，我们继续来观察一下反汇编：
从上图我们观察到f1与f2对象的类型不一致，所以它们之间不能相互赋值，那我们不能进行强制类型转换吗？因为f1与f2的类型是编译器自动生成的，我们如何得知它们的类型呢？所以就不能指定类型进行类型转换了。
二、包装器
2.1 function
function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。
我们先来看看function的原型：
std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
ret = func(x);
上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能是lamber表达式对象？所以这些都是可调用的类型！
那么该如何更好的控制调用对象的类型呢？我们来见见包装器的使用：
int f(int x, int y)
{
return x + y;
}
struct Functor
{
int operator()(int a, int b)
{
return a + b;
}
};
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
//int(*pf1)(int,int) = f; 函数指针的类型不好写
// 函数指针
function<int(int, int)> f1 = f;
cout << f1(1, 2) << endl;
// 函数对象
function<int(int, int)> f2 = Functor();
cout << f2(10, 20) << endl;
// lambda对象
function<int(int, int)> f3 = [](int a, int b) {
return a + b;
};
cout << f3(100, 200) << endl;
// 类的成员函数
std::function<int(int, int)> func4 = &Plus::plusi; // 静态成员函数不需要传this指针
cout << func4(100, 50) << endl;
std::function<double(Plus, double, double)> func5 = &Plus::plusd; // 成员函数需要传this指针
cout << func5(Plus(), 1.1, 2.2) << endl;
map<string, function<int(int, int)>> opFuncMap;
opFuncMap["函数指针"] = f;
opFuncMap["仿函数"] = Functor();
opFuncMap["lambda"] = [](int a, int b) {
return a + b;
};
cout << opFuncMap["lambda"](200, 300) << endl;
return 0;
}
/*
输出结果：
3
30
300
150
3.3
500
*/
我们可以看到有了包装器之后，能更好的控制调用对象的类型！！那么function包装器还有其他的应用场景吗？下面我们来看看：
#include <functional>
#include <string>
#include <map>
using namespace std;
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式
cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;
return 0;
}
有了function包装器之后：
#include <functional>
#include <string>
#include <map>
using namespace std;
template<class F, class T>
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数指针
std::function<double(double)> func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function<double(double)> func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
std::function<double(double)> func3 = [](double d)->double {
return d / 4;
};
cout << useF(func3, 11.11) << endl;
return 0;
}
std::function 可以封装不同类型的可调用对象，使得可以通过统一的接口进行调用，从而实现了函数的多态性。通过使用 std::function 包装函数指针、函数对象和 lambda 表达式，并将其作为参数传递给 useF 函数，实际上是将这些不同类型的可调用对象转换为了统一的 std::function 类型。这使得 useF 函数只需要一次实例化，用于处理 std::function 类型的参数，而不需要针对不同的可调用对象类型进行重复的实例化。而第一段代码中，直接使用了函数名、函数对象和 lambda 表达式作为参数传递给 useF 函数，没有使用 std::function 进行包装。因此，每种调用方式都会导致 useF 函数模板的单独实例化，用于处理不同类型的可调用对象。
总结：std::function 的作用在于提供了一种统一的接口和机制，可以将不同类型的可调用对象进行统一的封装和处理，从而实现函数的多态性和灵活性。
2.2 bind
std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。
// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。调用bind的一般形式：auto newCallable = bind(callable,arg_list);其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推。
我们简单来看看它的用法：
#include <functional>
void Print(int a, int b)
{
cout << a << " ";
cout << b << endl;
}
class Sub
{
public:
Sub(int rate)
: _rate(rate)
{}
int sub(int a, int b)
{
return (a - b) * _rate;
}
private:
int _rate = 5;
};
int main()
{
Print(10, 20);
// 调整参数顺序
//auto f1 = bind(Print, placeholders::_2, placeholders::_1);
function<void(int, int)> func1 = bind(Print, placeholders::_2, placeholders::_1);
func1(10, 20);
// 正常调用成员函数, 需要传递对象，在底层传递this指针
function<int(Sub, int, int)> func2 = &Sub::sub;
cout << func2(Sub(3), 10, 20) << endl;
// 将Sub(3)死绑定，减少了参数的个数
function<int(int, int)> func3 = bind(&Sub::sub, Sub(3), placeholders::_1, placeholders::_2);
cout << func3(10, 20) << endl;
return 0;
}
/*
输出结果：
10 20
20 10
-30
-30
*/
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
