1. Lambda 表达式的组成

先对 lambda 表达式有一个直观的认识，参考下面程序，该程序完成的是将输入的数组 nums 按照绝对值大小进行升序排列。

int main() {
    std::vector<int> nums = {1, 5, 3, 4, 2, -1, 10};
    std::sort(nums.begin(), nums.end(), [](int a, int b) mutable throw() -> bool {
        // lambda 表达式函数体，在这里做到了将输入数组升序排列
        return (std::abs(a) < std::abs(b));
    });
    for (int i : nums) std::cout << i << " ";
    // >: 1 -1 2 3 4 5 10
}

抛开边边角角，单独拿出最重要的一部分来学习，[](int a, int b) mutable throw() -> bool{ // statement } 就是 lambda 表达式最原始的内容。在该表达式中，每一部分的含义如下叙述：

1. [] 捕获子句：用来捕获周围范围中出现的变量，也被称为引导子句，可以在其中声明获取的变量是按值访问还是引用来访问，默认值为 & ，上文中的例子和 [&] 是一样的效果，具体例子见下文。
2. () 参数列表：用来获取参数，对于一个一般的 lambda 函数，使用起来和一般的指针函数没有区别，也是需要有参数列表的，具体例子见下文。
3. mutable 可变类型（可选）：一般来说，在 lambda 体中调用运算符的变量，都是以 const value 来使用的，加上这个 mutable 之后，人家变成了变量来使用，具体栗子见下文。
4. throw() 异常类型（可选）：和普通函数一样样，lambda 函数也可能引发异常，如果不会引发异常的话，直接声明 noexcept 就可以啦~
5. -> bool 返回类型（可选）：继续和普通函数一样
6. {// statement } lambda 体：和一般的函数体一样。

不难发现，lambda 函数和一般的函数没有太大区别，基本上只有在头部位置有特殊语法。

2. 捕获语句的使用 & 可变规范 mutable

拿出栗子：

int main() {
    int num = 1; // 在上文中声明好变量 num
    auto f = [n = num]() { // 在下文中通过 捕获[] 来获取 num，并在 lambda 函数体中进行使用
        std::cout << n << std::endl;
        // std::cout << ++num << std::endl; // 错误的使用，因为 num 是不可变的常量
    };
    f(); // >: 1
    auto m = [num]() mutable {
        std::cout << ++num << std::endl; // 将内部变量声明成 mutable 可变类型，此时可以修改内部变量
    };
    m(); // >: 2
    std::cout << num << std::endl; // >: 2
}

在 C++14 及以后的版本中，可以通过 capture 语句从周围（Surrounding Scope）捕获变量，在 [] 子句中指定要捕获哪些变量，以及按照何种方式使用它们。和普通语法一样，带有 ＆ 前缀的变量可以通过引用进行访问，而没有前缀 ＆ 的变量可以通过值进行访问。而空的捕获子句[]表示 lambda 表达式的主体在闭包范围内不访问外部任何变量。 当然~，也可以使用默认的捕获模式来指示如何捕获 lambda 中引用的任何外部变量：[＆] 表示周围所有变量都是通过引用捕获的，而 [=] 意味着它们按值所捕获。

一般情况下，lambda的函数调用运算符是常量值，但是使用 mutable 关键字可以修改默认值，mutable 使 lambda 表达式的函数体可以修改按值捕获的变量。

3. 参数列表

再拿出一个栗子：

int main() {
    auto y = [](int a, int b) {
        return a + b;
    };
    std::cout << y(3, 2); // >: 5
}

从这里开始，也就是参数列表开始，后面的内容都是可选项，也就是如果为空，那么就直接省略不写即可。例如：

int main() {
    auto empty = [] {
        std::cout << "Wow!空的~" << std::endl;
        // 啥也没有只有个函数体};
    };
    empty(); // >: Wow!空的~
}

4. 特殊用法

4.1 花里胡哨的 lambda 嵌套

int main() {
    // 两层 lambda 嵌套，看起来挺花里胡哨
    auto embed_embed_lambda = [](int a) {
        std::cout << a << " - - ";
        return [](int c) { return c / 2; };
    };
    std::cout << embed_embed_lambda(2)(2) << std::endl; // >: 2 - - 1
}

4.2 高阶 lambda 函数

高阶函数是指，采用另一个 lambda 表达式作为其参数或返回 lambda 表达式的 lambda 表达式（不知不觉想起了俄罗斯套娃🤔）

int main() {
    // 返回 function 对象的 lambda 表达式
    auto get_function = [](int x) -> std::function<int(int)> {
        return [=](int y) { return x + y; };
    };
    // 使用 function 为对象作为其参数的 lambda 表达式
    auto param_function = [](const std::function<int(int)> &f, int n) {
        return f(n) * 2;
    };
    auto ans = param_function(get_function(2), 3); // x = 2, n = 3
    std::cout << ans << std::endl;
}

5. 总结

写到此处，关于 C++ 的 lambda 语法规范和用法已经学习了一小部分，它作为一种方便灵活的方法随用随学也是阔以的。

因为参数类型和函数模板参数一样可以被推导而无需和具体参数类型耦合，有利于重构代码；和使用auto声明变量的作用类似，它也允许避免书写过于复杂的参数类型。特别地，不需要显式指出参数类型使得使用高阶函数变得更加容易。

以下程序源码：

/**
 * Created by Xiaozhong on 2020/8/30.
 * Copyright (c) 2020/8/30 Xiaozhong. All rights reserved.
 */
#include <functional>
#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> nums = {1, 5, 3, 4, 2, -1, 10};
    std::sort(nums.begin(), nums.end(), [&](int a, int b) mutable throw() -> bool {
        // lambda 表达式函数体，在这里做到了将输入数组升序排列
        return (std::abs(a) < std::abs(b));
    });
    for (int i : nums) std::cout << i << " ";
    // >: 1 -1 2 3 4 5 10

    int num = 1; // 在上文中声明好变量 num
    auto f = [n = num]() { // 在下文中通过 捕获[] 来获取 num，并在 lambda 函数体中进行使用
        std::cout << n << std::endl;
        // std::cout << ++num << std::endl; // 错误的使用，因为 num 是不可变的常量
    };
    f(); // >: 1
    auto m = [num]() mutable {
        std::cout << ++num << std::endl; // 将内部变量声明成 mutable 可变类型，此时可以修改内部变量
    };
    m(); // >: 2
    std::cout << num << std::endl; // >: 2

    auto y = [](int a, int b) {
        return a + b;
    };
    std::cout << y(3, 2); // >: 5

    auto empty = [] {
        std::cout << "Wow!空的~" << std::endl;
        // 啥也没有只有个函数体};
    };
    empty(); // >: Wow!空的~

    // 声明一个函数，然后直接使用 (5, 3)
    int n = [](int a, int b) { return a + b; }(5, 3);
    std::cout << n << std::endl; // >: 8

    // 两层 lambda 嵌套，看起来挺花里胡哨
    auto embed_embed_lambda = [](int a) {
        std::cout << a << " - - ";
        return [](int c) { return c / 2; };
    };
    std::cout << embed_embed_lambda(2)(2) << std::endl; // >: 2 - - 1

    // 返回 function 对象的 lambda 表达式
    auto get_function = [](int x) -> std::function<int(int)> {
        return [=](int y) { return x + y; };
    };

    // 使用 function 为对象作为其参数的 lambda 表达式
    auto param_function = [](const std::function<int(int)> &f, int n) {
        return f(n) * 2;
    };

    auto ans = param_function(get_function(2), 3);
    std::cout << ans << std::endl;
}