一、Lambda表达式概述

c++在c++11标准中引入了lambda表达式，一般用于定义匿名函数，lambda表达式（也称为lambda函数）是在调用或作为函数参数传递的位置处定义匿名函数对象的便捷方法。通常，lambda用于封装传递给算法或异步方法的几行代码 。本文主要介绍Lambda的工作原理以及使用方法。

二、Lambda表达式定义

1、Lambda表达式示例

下例是MS官网上的一个示例：

#include <algorithm>
#include <cmath>

void abssort(float* x, unsigned n) {
    std::sort(x, x + n,
        // Lambda expression begins
        [](float a, float b) {
            return (std::abs(a) < std::abs(b));
        } // end of lambda expression
    );
}

这个实例中直接将排序函数的实现写在应该传递函数的位置，省去了定义排序函数的过程，对于这种不需要复用，且短小的函数，直接传递函数体可以增加代码的可读性。

2、Lambda表达式语法定义

1. capture 子句（在 C++ 规范中也称为 Lambda 引导。）

2. 参数列表（可选）。 （也称为 Lambda 声明符）

3. mutable 规范（可选）。

4. exception-specification（可选）。

5. return-type 返回值（可选）。

6. Lambda 体。

3、Lambda表达式参数详解

1）捕获列表

上面介绍完了lambda表达式的各个成分，其实很多部分和正常的函数没什么区别，其中最大的一个不同点就是捕获列表。我在刚开始用lambda表达式的时候，还一直以为这个没啥用，只是用一个 [] 来标志着这是一个lambda表达式。后来了解了才知道，原来这个捕获列表如此强大，甚至我觉得捕获列表就是lambda表达式的灵魂。下面先介绍几种常用的捕获方式。

[] 什么也不捕获，无法lambda函数体使用任何

[=] 按值的方式捕获所有变量

[&] 按引用的方式捕获所有变量

[=, &a] 除了变量a之外，按值的方式捕获所有局部变量，变量a使用引用的方式来捕获。这里可以按引用捕获多个，例如 [=, &a, &b,&c]。这里注意，如果前面加了=，后面加的具体的参数必须以引用的方式来捕获，否则会报错。

[&, a] 除了变量a之外，按引用的方式捕获所有局部变量，变量a使用值的方式来捕获。这里后面的参数也可以多个，例如 [&, a, b, c]。这里注意，如果前面加了&，后面加的具体的参数必须以值的方式来捕获。

[a, &b] 以值的方式捕获a，引用的方式捕获b，也可以捕获多个。

[this] 在成员函数中，也可以直接捕获this指针，其实在成员函数中，[=]和[&]也会捕获this指针。

    class A
    {
        public:
            int i_ = 0;

        void func(int x, int y)
        {
            auto x1 = []{ return i_; };                    // error，没有捕获外部变量
            auto x2 = [=]{ return i_ + x + y; };           // OK，捕获所有外部变量
            auto x3 = [&]{ return i_ + x + y; };           // OK，捕获所有外部变量
            auto x4 = [this]{ return i_; };                // OK，捕获this指针
            auto x5 = [this]{ return i_ + x + y; };        // error，没有捕获x、y
            auto x6 = [this, x, y]{ return i_ + x + y; };  // OK，捕获this指针、x、y
            auto x7 = [this]{ return i_++; };              // OK，捕获this指针，并修改成员的值
        }
    };

    int a = 0, b = 1;
    auto f1 = []{ return a; };               // error，没有捕获外部变量
    auto f2 = [&]{ return a++; };            // OK，捕获所有外部变量，并对a执行自加运算
    auto f3 = [=]{ return a; };              // OK，捕获所有外部变量，并返回a
    auto f4 = [=]{ return a++; };            // error，a是以复制方式捕获的，无法修改
    auto f5 = [a]{ return a + b; };          // error，没有捕获变量b
    auto f6 = [a, &b]{ return a + (b++); };  // OK，捕获a和b的引用，并对b做自加运算
    auto f7 = [=, &b]{ return a + (b++); };  // OK，捕获所有外部变量和b的引用，并对b做自加运算

2）参数列表

Lambda 既可以捕获变量，也可以接受输入参数。 参数列表（在标准语法中称为 Lambda 声明符）是可选的，它在大多数方面类似于函数的参数列表。

auto function = [] (int first, int second){
    return first + second;
};
	
function(100, 200);

3）可变规格mutable

​ mutable修饰符， 默认情况下Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）。

#include <iostream>
using namespace std;

int main()
{
   int m = 0;
   int n = 0;
   [&, n] (int a) mutable { m = ++n + a; }(4);
   cout << m << endl << n << endl;
}

4）异常说明

​ 你可以使用 throw() 异常规范来指示 lambda 表达式不会引发任何异常。与普通函数一样，如果 lambda 表达式声明 C4297 异常规范且 lambda 体引发异常，Visual C++ 编译器将生成警告 throw() 。

int main() // C4297 expected 
{ 
 	[]() throw() { throw 5; }(); 
}

5）返回类型

​ Lambda表达式的返回类型会自动推导。除非你指定了返回类型，否则不必使用关键字。返回型类似于通常的方法或函数的返回型部分。但是，返回类型必须在参数列表之后，并且必须在返回类型->之前包含类型关键字。如果lambda主体仅包含一个return语句或该表达式未返回值，则可以省略Lambda表达式的return-type部分。如果lambda主体包含一个return语句，则编译器将从return表达式的类型中推断出return类型。否则，编译器将返回类型推导为void。

auto x1 = [](int i){ return i; };

6）Lambda函数体

​ Lambda表达式的lambda主体（标准语法中的复合语句）可以包含普通方法或函数的主体可以包含的任何内容。普通函数和lambda表达式的主体都可以访问以下类型的变量：

- 捕获变量
- 形参变量
- 局部声明的变量
- 类数据成员，当在类内声明**`this`**并被捕获时
- 具有静态存储持续时间的任何变量，例如全局变量

#include <iostream>
using namespace std;

int main()
{
   int m = 0;
   int n = 0;
   [&, n] (int a) mutable { m = ++n + a; }(4);
   cout << m << endl << n << endl;
}