@[TOC]

lambda

1. 使用sort对自定义类型的排序时，需要我们显示的传一个比较器--也就是仿函数对象(或者叫函数对象），如果自定义类型有多个成员变量时，我们可能需要建立多个相似名字的仿函数类，通过需求来添加相应的仿函数对象。构建多个相似的类是很麻烦而且冗余的，因此c++11基于这种需求新建了一个语法：lambda表达式。简洁明了。
2. lambda不可以用c++的函数思路去理解，它是一个新语法

lambda表达式书写格式

[capture-list] (parameters) mutable -> return-type { statement
}

lambda表达式各部分说明

1. [capture-list]

• 捕捉列表；2种捕获方式：值捕获，引用捕获.该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。

• 捕获的是实参且值捕获后数据默认是const的

  ![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sJQTGneG-1664696518981)(./C++11-lambda.assets/image-20221001211359261.png)\]](https://ucc.alicdn.com/images/user-upload-01/4f6be4370a8c47f080cb5c896cfc1549.png)

1. (parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
2. mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
3. ->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
4. {statemen t}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量

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表达式实际上可以理解为无名函数，该函数无法直接调
用，如果想要直接调用，可借助auto将其赋值给一个变量

捕捉列表再说明

1. 捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
   [var]：表示值传递方式捕捉变量var
   [=]：表示值传递方式捕获所有父作用域中的变量(包括this)
   [&var]：表示引用传递捕捉变量var
   [&]：表示引用传递捕捉所有父作用域中的变量(包括this)
   [this]：表示值传递方式捕捉当前的this指针

2. 注意：

   • 父作用域指包含lambda函数的语句块

   • 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。

     比如：[=, &a,+  &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量

     [&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

   • 捕捉列表不允许变量重复传递，否则就会导致编译错误。
     比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
   • 在块作用域以外的lambda函数捕捉列表必须为空。
   • 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都
     会导致编译报错。
   • lambda表达式之间不能相互赋值，即使看起来类型相同 ，因为每个lambda对象的uuid是不同的，即使用仿函数默认的operator=；

lambda，函数对象

函数对象，又称为仿函数，即可以想函数一样使用的对象，就是在类中重载了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()

包装器

function包装器

function包装器 也叫作适配器。C++中的function本质是 一个类模板，也是一个包装器 。

std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参

学完lambda后，可以调用的对象有：函数指针，仿函数，lambda。可能会导致模板的效率低下

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);
}

按正常思路，传递不同类型，静态count会自动++，但是对于可调用的对象，函数模板是实例化独立的多份，count始终为1，这就不符合模板的泛型编程

包装器的意义

通过包装器，让编译器认为 函数指针，仿函数，lambda是一类，这样就可以实现模板只实例化一份的需求。

function包装注意点

对于非静态成员函数，要提供this指针也就是对象地址即要在参数包中添加类，调用时加入临时对象。

包装器的缺陷

上面的包装器的形参是固定不变，对于需要传递this的包装器很麻烦，这就需要通过绑定--bind解决问题

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为第二个参数，以此类推。

如果改变参数接收顺序，会依据实参的顺序来赋值给行参即

第二个实参会赋值给第一个形参，以次类推。一般不用。

std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_2,placeholders::_1);

总结

如果你想在不改变形参个数情况下，多传几个实参，或者改变参数接受的顺序，可以通过blind,且编译器会自动适配合适的函数。