在 C++11 及之后的版本中，C++ 提供了 lambda 表达式，它是一种方便了参数传递和定义匿名函数的方法。该方法通常用于封装算法、执行异步方法 ，也就是说比较适用于少量的代码。以下原文：

In C++11 and later, a lambda expression—often called a lambda—is a convenient way of defining an anonymous function object (a closure) right at the location where it is invoked or passed as an argument to a function. Typically lambdas are used to encapsulate a few lines of code that are passed to algorithms or asynchronous methods. This article defines what lambdas are, compares them to other programming techniques, describes their advantages, and provides a basic example.

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
}

mutable 可变声明优势在于可以在内部直接改变外部变量，相当于使用了 [&num] 引用方法。

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

Algorithms