传统艺能😎
小编是双非本科大一菜鸟不赘述，欢迎米娜桑来指点江山哦（QQ：1319365055）
🎉🎉非科班转码社区诚邀您入驻🎉🎉
小伙伴们，打码路上一路向北，彼岸之前皆是疾苦
一个人的单打独斗不如一群人的砥砺前行
这是我和梦想合伙人组建的社区，诚邀各位有志之士的加入！！
社区用户好文均加精（“标兵”文章字数2000+加精，“达人”文章字数1500+加精）
直达： 社区链接点我
概念🤔
自 C++11 开始，C++ 有三种方式可以创建/传递一个可调用的对象：
函数指针
仿函数
Lambda 表达式
lambda 表达式本质上就是一个匿名函数，它是一个强大的功能，他的使用可以简化代码，而且可以提高代码可读性
这里举一个实例，以一个物品为例：
struct Items
{
string _name; //名字
double _price; //价格
int _num; //数量
};
如果要对若干对象分别按照价格和数量进行升序、降序排序。
首先想到可以使用 sort 函数，但由于这里待排序的元素为自定义类型，因此需要用户自行定义排序时的比较规则，要控制 sort 比较方式有常见的两种方法，一是对商品类的的 () 运算符进行重载，二是通过仿函数来指定比较方式。
重载当前类的 () 运算符是不可行的，因为这里要求分别按照价格和数量进行升序、降序排序，每次排序都去修改一下比较方式是很低效且笨重的做法
比如我用仿函数的方式进行比较：
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;
}
};
struct CompareNumLess//数量降序
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._num < g2._num;
}
};
struct CompareNumGreater//数量升序
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._num > g2._num;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
sort(v.begin(), v.end(), ComparePriceLess()); //价格升序
sort(v.begin(), v.end(), ComparePriceGreater()); //价格降序
sort(v.begin(), v.end(), CompareNumLess()); //数量升序
sort(v.begin(), v.end(), CompareNumGreater()); //数量降序
return 0;
}
如你所见，仿函数也顺利解决了以上问题，但是如果定义和使用位置隔的很远就不好观察，这就要求取名的时候通俗易懂，这种情况下就更加推荐使用 lambda 表达式。
比如我这里有一个做加法的仿函数：
class Plus {
public:
int operator()(int a, int b) {
return a + b;
}
};
Plus plus;
std::cout << plus(11, 22) << std::endl;
我们把这个加法仿函数改写成 lambda 表达式就是：
auto Plus = [](int a, int b) { return a + b; };
因为 lambda 表达式是一个匿名函数，该函数无法直接调用，这里我们借助 auto 将其赋值给一个变量，此时这个变量就可以像普通函数一样使用
这前后一对比，显而易见两者的优劣就高下立判了
语法🤔
lambda 表达式定义：
[ capture-list ] ( params ) mutable(optional) exception(optional) attribute(optional) -> ret(optional) { body }
当然在书写格式上并不是必须写成一行，如果函数体太长可以进行换行
说明一下各个参数：
capture-list：捕捉列表。上面的例子 auto Plus = [](int a, int b) { return a + b; }; 就没有捕获任何变量
params：和普通函数一样的参数。
mutable：只有这个 Lambda 表达式是 mutable 的才允许修改按值捕获的参数。
-> ret：返回值类型，可省略，编译器可以通过 return 语句自动推导
body：具体函数
没说明的就暂时不必理解，其中 除了捕获列表， L a m b d a 表达式的其它地方其实和普通的函数基本一样 \color{red} {除了捕获列表，Lambda 表达式的其它地方其实和普通的函数基本一样} 除了捕获列表，Lambda表达式的其它地方其实和普通的函数基本一样。lambda 参数列表和返回值类型都是可有可无的，但捕捉列表和函数体是不可省略的，因此最简单的lambda函数如下：
int main()
{
[]{}; //最简单的lambda表达式
return 0;
}
捕获方式🤔
Lambda 表达式最基本的两种捕获方式是：按值捕获和按引用捕获
我们对捕获列表的说明描述了上下文中哪些数据可以被 lambda 函数使用，以及使用的方式是传值还是传引用
[var]：值传递捕捉变量var
[=]：值传递捕获所有父作用域中的变量（成员函数包括this指针）
[&var]：引用传递捕捉变量var
[&]：引用传递捕捉所有父作用域中的变量（成员函数包括this指针）
[this]：值传递捕捉当前的this指针
实际当我们以 [&]（引用传递全捕获） 或 [=] （值传递全捕获）的方式捕获变量时，编译器也不一定会把父作用域中所有的变量捕获进来，编译器可能只会对 lambda 表达式中用到的变量进行捕获，实际要看编译器的具体实现
父作用域就是包含 lambda 表达式的语句块，语法上捕捉列表可由多个逗号分割的捕捉项组成，比如KaTeX parse error: Expected '}', got '&' at position 18: …olor{red} {[=, &?a, &b]} ，我们需要清楚 3 点：
- 捕捉列表不允许重复传递，否则会导致编译错误，比如 [ = , a ] \color{red} {[=, a]} [=,a]重复传递了变量 a
- lambda表达式之间不能相互赋值，即使看起来类型相同
- 在块作用域以外的 lambda 表达式捕捉列表必须为空！即全局lambda函数的捕捉列表必须为空，且在块作用域中的 lambda 表达式仅能捕捉父作用域中的局部变量，除此以外的都会导致编译报错。
相互赋值😎
lambda表达式之间不能相互赋值，就算是两个一模一样的也不行，这不邪门儿了嘛，为啥呢？
因为 lambda 表达式底层处理方式和仿函数是一样的（本文后面的底层原理部分有细谈），在VS下 lambda 表达式会被处理为函数对象，该函数对象对应的类名叫做<lambda_uuid>
类名中的uuid叫做通用唯一识别码，简单来说就是通过算法生成的一串字符串，它具有随机性和不重复性，保证在当前程序中每次生成不同的 uuid，因为 lambda 表达式底层的类名包含 uuid，这就保证了每个 lambda 表达式底层类名都是唯一的！
我们可以通过 t y p e i d ( 变量名 ) . n a m e ( ) \color{red} { typeid(变量名).name() } typeid(变量名).name()的方式来获取lambda表达式的类型来验证上述结论：
int main()
{
int a = 10, b = 20;
auto Swap1 = [](int& x, int& y)->void
{
int tmp = x;
x = y;
y = tmp;
};
auto Swap2 = [](int& x, int& y)->void
{
int tmp = x;
x = y;
y = tmp;
};
cout << typeid(Swap1).name() << endl; //class <lambda_797a0f7342ee38a60521450c0863d41f>
cout << typeid(Swap2).name() << endl; //class <lambda_f7574cd5b805c37a13a7dc214d824b1f>
return 0;
}
如你所见，就算是一模一样的 lambda 表达式，它们的类型也是不同的
mutable🤔
在实际使用中，比如实现一个交换函数，我们用 lambda 表达式实现：
int main()
{
int a = 1, b = 2;
auto Swap = [a, b]()
{
int tem = a;
a = b;
b = tem;
};
Swap();
return 0;
}
这里一眼就是传值捕获，但是真的可以吗？答案是 No，他的编译不会通过，因为传值捕获到的变量默认是不可修改的（const）：
//值捕获的类型是 const 类型
int i = 100;
auto func = [i]() {
i = 200; // 编译错误:assignment of read-only variable ‘i’
};
如果要取消其常量属性，就需要在 lambda 表达式中加上 mutable 像这样：
auto Swap = [a, b]()mutable
{
int tem = a;
a = b;
b = tem;
};
但由于是传值捕捉，lambda 表达式中对局部变量的修改不会影响本身的变量，与函数的传值传参是一个道理，因此这种方法无法完成交换功能。
底层原理🤔
实际编译器在底层对于 lambda 表达式的处理方式，完全就是按照函数的方式处理的，函数对象就是我们平常所说的仿函数，就是在类中对 () 运算符进行了重载的类对象
我们编写了一个 Add 类，然后对 () 运算符进行了重载，因此 Add 类实例化出的 add1 对象就是函数对象，add1 可以像函数一样使用。接着写了一个 lambda 表达式，并借助 auto 将其赋值给 add2 对象，这时 add1 和 add2 都可以像普通函数一样使用
class Add
{
public:
Add(int base)
:_base(base)
{}
int operator()(int num)
{
return _base + num;
}
private:
int _base;
};
int main()
{
int base = 1;
//函数对象
Add add1(base);
add1(1000);
//lambda表达式
auto add2 = [base](int num)->int
{
return base + num;
};
add2(1000);
return 0;
}
我们再通过反汇编对代码进行观察：
创建函数对象 add1 时，会调用 Add 类的构造函数，使用 add1 时，会调用 Add 类的 () 运算符重载函数。
然后 lambda 表达式这边也是和函数的过程非常类似：在借助 auto 将 lambda 表达式赋值给 add2 对象时，会调用 <lambda_uuid> 类的构造函数，在使用add2对象时，会调用<lambda_uuid>类的()运算符重载函数
本质就是因为 l a m b d a 表达式在底层被转换成了仿函数 \color{red} {本质就是因为lambda表达式在底层被转换成了仿函数} 本质就是因为lambda表达式在底层被转换成了仿函数。
当我们定义一个lambda表达式后，编译器会自动生成一个类，在该类中对 () 运算符进行重载，实际 lambda 函数体的实现就是这个仿函数 operator() 的实现，在调用 lambda 表达式时，参数列表和捕获列表的参数，最终都传递给了仿函数的 operator()。
aqa 芭蕾 eqe 亏内，代表着开心代表着快乐，ok 了家人们。