目录
1、什么是lambda表达式
Lambda表达式是一种在C++11中引入的功能，允许我们定义匿名函数。它的语法比较简洁，可以方便地在需要函数对象的地方使用，例如STL算法、线程、智能指针等。
在C++98中，对一个数据集合中的元素进行排序：
// 默认按照小于比较，排出来结果是升序std::sort ( array , array + sizeof ( array ) / sizeof ( array [ 0 ]));// 如果需要降序，需要改变元素的比较规则std::sort ( array , array + sizeof ( array ) / sizeof ( array [ 0 ]), greater < int > ());
但是如果是自定义类型的话，我们就需要实现仿函数
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
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());
}这样虽然可以比较，但是每次都要实现一个类，那么就有点不方便了，所以C++11中提出了lambda表达式。
2、lambda表达式
2.1 lambda表达式语法
[capture-list] (parameters) mutable -> return-type { statement }
其中各部分的含义如下：
capture-list：捕获列表，用于捕获局部变量以供lambda函数使用。可以是空的[]，表示不捕获任何变量；也可以是[&]表示按引用捕获所有变量；还可以是[=]表示按值捕获所有变量；还可以是[a, &b]表示按值捕获变量a，按引用捕获变量b。
[ ]：空的捕捉列表，表示不捕获任何外部变量。[&]：按引用捕获所有外部变量，可以在Lambda表达式中修改这些变量。[=]：按值捕获所有外部变量，以副本的方式在Lambda表达式中使用这些变量，不允许修改这些变量。[var1, var2, ...]：按值捕获指定的外部变量var1、var2等。
parameters：参数列表，与普通函数的参数列表相同。
mutable：可选关键字，用于指示lambda函数是否可以修改其捕获的变量。如果使用了mutable关键字，则lambda函数可以修改以值方式捕获的变量的副本。
mutable关键字用于在Lambda表达式中声明捕获的变量为可变的，即使这些变量是以值方式捕获的，也可以在Lambda函数体中修改它们的值。
return-type：返回类型，与普通函数的返回类型相同。可以省略，如果省略了，编译器会根据statement中的返回语句推导返回类型。
statement：函数体，与普通函数的函数体相同。
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;
}这样一来上面自定义类型的比较就方便很多：
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2,
3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), [](Goods& a, Goods& b) {return a._price < b._price; });
sort(v.begin(), v.end(), [](Goods& a, Goods& b) {return a._price > b._price; });
return 0;
}2.2 捕获列表说明
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var] ：表示值传递方式捕捉变量 var[=] ：表示值传递方式捕获所有父作用域中的变量 ( 包括 this)[&var] ：表示引用传递捕捉变量 var[&] ：表示引用传递捕捉所有父作用域中的变量 ( 包括 this)[this] ：表示值传递方式捕捉当前的 this 指针
需要注意的是：
父作用域指包含 lambda 函数的语句块语法上捕捉列表可由多个捕捉项组成，并以逗号分割 。比如： [=, &a, &b] ：以引用传递的方式捕捉变量 a 和 b ，值传递方式捕捉其他所有变量[& ， a, this] ：值传递方式捕捉变量 a 和 this ，引用方式捕捉其他变量捕捉列表不允许变量重复传递，否则就会导致编译错误 。比如： [=, a] ： = 已经以值传递方式捕捉了所有变量，捕捉 a 重复
lambda表达式之间不能相互赋值，即使看起来类型相同但是可以使用一个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;
}3、function包装器
std::function 是 C++11 中引入的一个模板类，它是一个可复制的、可存储任意可调用对象（函数、Lambda表达式、函数对象等）的对象。它提供了一种通用的方式来封装函数，使得函数可以像对象一样进行传递、存储和使用。使用 std::function 可以轻松地创建一个函数对象，并将其作为参数传递给其他函数，或者将其存储在容器中等等。
可变模板参数：
可变参数模板是 C++11 引入的一个功能，允许函数接受任意数量和类型的参数。
#include <iostream>
// 递归终止函数
void print() {
std::cout << std::endl;
}
template<typename T, typename... Args>
void print(const T& first, const Args&... args) {
std::cout << first << " ";
print(args...);
}
int main() {
print(1, 2.5, "Hello", 'a');
return 0;
} 一个接受任意数量的参数（通过模板和参数包实现），另一个是基本情况，即不接受任何参数，用于终止递归。当调用 print 函数时，参数被逐个打印出来，直到没有剩余参数。
// 类模板原型如下template < class T > function ; // undefinedtemplate < class Ret , class ... Args >class function < Ret ( Args ...) > ;模板参数说明：Ret : 被调用函数的返回类型Args… ：被调用函数的形参
#include <iostream>
#include <functional>
// 函数模板，接受一个std::function类型的参数
void print_message(std::function<void()> func) {
func(); // 调用传入的函数对象
}
int main() {
// Lambda表达式作为参数传递给print_message函数
print_message([]() {
std::cout << "Hello, std::function!" << std::endl;
});
// 函数对象作为参数传递给print_message函数
struct Printer {
void operator()() const {
std::cout << "Printing from a function object!" << std::endl;
}
};
print_message(Printer());
return 0;
}
print_message 函数接受一个 std::function<void()> 类型的参数，表示接受无参数并且返回值为 void 的可调用对象。通过将 Lambda 表达式和函数对象传递给 print_message 函数，我们可以轻松地调用它们。
得到输出
Hello, std::function!
Printing from a function object!
bind
std::bind 是 C++11 中引入的函数模板，用于创建一个可调用对象，并将其与指定的函数或函数对象绑定在一起。它可以用来创建一个函数对象，该函数对象可以延迟调用目标函数，并在需要时传递额外的参数或更改参数顺序。
#include <iostream>
#include <functional>
// 目标函数
void greet(const std::string& name, int age) {
std::cout << "Hello, " << name << "! You are " << age << " years old." << std::endl;
}
int main() {
// 使用 std::bind 绑定目标函数和部分参数
auto greetSomeone = std::bind(greet, "Alice", std::placeholders::_2); //指定参数位置
// 调用绑定后的函数对象，并传递剩余的参数
greetSomeone(0,30); //这里的0没有意义，只是为了表示第二个参数对应的位置
return 0;
}greet 函数接受两个参数：一个 std::string 类型的名称和一个 int 类型的年龄。使用 std::bind，我们将 greet 函数与参数 "Alice" 绑定在一起，并指定 std::placeholders::_2 作为占位符，表示第二个参数的位置。然后，我们创建了一个名为 greetSomeone 的函数对象，它只需要一个参数，即年龄。当我们调用 greetSomeone 时，它会以 "Alice" 作为名称，并传递给定的年龄参数。
