⭐️我叫忆_恒心，一名喜欢书写博客的在读研究生👨‍🎓。
如果觉得本文能帮到您，麻烦点个赞👍呗！

近期会不断在专栏里进行更新讲解博客~~~ 有什么问题的小伙伴 欢迎留言提问欧，喜欢的小伙伴给个三连支持一下呗。👍⭐️❤️

前言

作为C++11的新特性的Lambada表达式本身书写倒不是什么难事，网上找一找也能轻易写出正确地表达式，但是在那些场景下使用以及应该如何使用反而会让很多新手困惑。

Lambda表达式

1 表达式定义

构造一个闭包：一个能够捕获作用域中变量的未命名函数对象。

在操作上，闭包是将函数与环境一起存储的记录。

2 书写规范

主要分成六个部分，其中1，2，3，5，6是需要重点掌握的。

1. capture 子句（在 C++ 规范中也称为 lambda 引入器。）
2. 参数列表自选。（也称为 lambda 声明符)
3. 可变规范自选。
4. 异常规范自选。
5. 尾随返回类型自选。
6. λ体。

3 书写表达式

书写[] 用于捕获：

3.1 捕获的基本规则

• [] - 不捕捉任何变量
• [&] - 捕获外部作用域中所有变量，并作为引用在函数体内使用 (按引用捕
  获)
• [=] - 捕获外部作用域中所有变量（依赖于编译器，只能捕获不被优化的变量），并作为副本在函数体内使用 (按值捕获)
  注:拷贝的副本在匿名函数体内部为const类型.
• [=, &foo] - 按值捕获外部作用域中所有变量，并按照引用捕获外部变量 foo
• [bar] - 按值捕获 bar 变量，同时不捕获其他变量
• [&bar] - 按引用捕获 bar 变量，同时不捕获其他变量
• [this] - 捕获当前类中的 this 指针
• 让 lambda 表达式拥有和当前类成员函数同样的访问权限
  如果已经使用了 & 或者 =, 默认添加此选项

3.2 使用的场景

用到函数指针的地方，应该考虑一下这个地方需不需要写Lambada表达式。

类中定义了只使用一次的方法，可以考虑是否需要用到Lambada表达式。

我只需要使用一次

类中进行调用。

好处：

• 简化代码： 维护代码完整性
• 捕获列表 简化代码解耦。

具体的例子：

01、代码维护上

Lambada类似于函数指针的东西，比如sort函数 自定义排序.

auto compare = [](int a, int b)
{
return a > b;
};
1
2
3
4

02、代码解耦

如果某天多了一个条件，那么普通的函数参数列表要跟着改变，但是可以使用用匿名函数进行解耦。

例子：

int lambadaParams()
{
    bool cond1 = false;
    bool cond2 = false;
    bool cond3 = true;
    bool cond4 = true;
    auto fun = [=](int t)
    {
        if (cond1)
        {
            cout << "cond1 is true" << endl;
            cout << t << endl;
        }
        if (cond1 && cond2)
        {
            cout << "cond1 && cond2" << endl;
            cout << t << endl;
        }
        if (cond3 || cond4)
        {
            cout << "cond3 || cond4" << endl;
            cout << t << endl;
        }
    };
    if (true)
    {
        fun(1);
    }
    if (true)
    {
        fun(2);
    }
    if (true)
    {
        fun(3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

3.3 细节——需要对捕获的值进行修改

由于捕获的值在函数内部是const类型，直接修改会报错。

注:拷贝的副本在匿名函数体内部为const类型.

但是可以添加可变规范

    int num1 = 2;
    int num2 = 3;
    auto fun3 = [=](int a, int b) mutable
    {
        int p = num1 + num2;
        int q = (num1--) + (num2--);
    };
    fun3(1, 2);
1
2
3
4
5
6
7
8

3.4 细节——接收返回值时需要注意

使用 auto 类型说明符声明的变量不能出现在其自身的初始值设定项中。

正确修改：

    std::function<int(int)> fun2 = [&fun2](int a)
    {
        if (a == 1)
            return 1;
        if (a == 2)
            return 2;
        else
            return fun2(a - 1) + fun2(a - 2);
    };
    auto x2 = fun2(5);
1
2
3
4
5
6
7
8
9
10

运行：

3.5 细节——不写返回值会报错的情况

虽然一般Lambada可以不写返回值类型。

当编译器无法进行推断出来类型的时候就会报错。

只需要指明类型就科一了

    auto fun1 = []() -> std::initializer_list<int>
    {
        return {1, 2, 3, 4, 5};
    };
    auto x = fun1();
1
2
3
4
5

运行：

还有一种情况需要注意的是当返回值多个类型的时候，根据某个条件进行返回不同的类型这个时候也需要指明返回值类型。

3.6 细节——其他

引用捕获有性能代价么？

需要，这种效率比较细微，体现在

=引用捕获只针对不被编译器优化的部分：

只会捕获使用的变量而不是全部变量，编译器优化问题。不过我用的gcc版本问题对a1进行了初始化，因此fun4依然可以捕获到

例如：

    int a1, b1, c1;
    auto fun4 = [=](int num1, int num2) mutable
    {
        num1++;
        num2++;
        num1 = a1 + num1;
    };
    fun4(0, 1);
1
2
3
4
5
6
7
8

完整的实验代码：

#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
using namespace std;
int main()
{
    vector<int> vec{3, 5, 1, 8, 2, 9, 0};
    auto compare = [](int a, int b)
    {
        return a > b;
    };
    sort(vec.begin(), vec.end(), compare);

    auto fun1 = []() -> std::initializer_list<int>
    {
        return {1, 2, 3, 4, 5};
    };
    auto x = fun1();

    std::function<int(int)> fun2 = [&fun2](int a)
    {
        if (a == 1)
            return 1;
        if (a == 2)
            return 2;
        else
            return fun2(a - 1) + fun2(a - 2);
    };
    auto x2 = fun2(5);

    int num1 = 2;
    int num2 = 3;
    auto fun3 = [=](int a, int b) mutable
    {
        int p = num1 + num2;
        int q = (num1--) + (num2--);
    };
    fun3(1, 2);

    int a1, b1, c1;
    auto fun4 = [=](int num1, int num2) mutable
    {
        num1++;
        num2++;
        num1 = a1 + num1;
    };
    fun4(0, 1);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

总结

Lambda表达式是C++11重要的特性，使得代码变得更加简洁，易于维护，但是同时也可能导致影响性能，因此使用的时候要注意应用场景。

1. [capture list] (params list) 关键字-> return type {function body}
2. captrue list：捕获外部变量列表（选填）
3. params list：形参列表（可省略）
4. 关键字：mutable,exception,attribute（可省略）
5. return type：返回类型（可省略）
6. function body：函数体

其中：

mutable说明lambda表达式体内的代码可以修改被捕获的变量，并且可以访问被捕获的对象的non-const方法。

exception说明lambda表达式是否抛出异常以及何种异常。

attribute用来声明属性。

特点：

​ 一次性使用

作用：

• 总体上：代码完整性
• 局部：闭包是的传参数更容易

最后，最后
如果觉得有用，麻烦三连👍⭐️❤️支持一下呀，希望这篇文章可以帮到你，你的点赞是我持续更新的动力