【C++ 11】lambda 匿名函数

• 匿名函数（lambda 函数 、 lambda 表达式） ：没有名称的函数 。

【 1. 基本用法 】

• 基本语法

lambda 匿名函数结构符号	描述
[外部变量方位方式说明符]	① [ ] 方括号用于向编译器表明当前是一个 lambda 表达式，不能被省略 。 ② 在方括号内部可以注明当前 lambda 函数的函数体中可以使用哪些 外部变量 （也就是和当前 lambda 表达式位于同一作用域内的所有局部变量）。 ③ 默认情况下，对于 以值传递方式引入的外部变量，不允许在 lambda 表达式内部修改它们的值（可以理解为这部分变量都是 const 常量 ）。
(参数)	① 和普通函数的定义一样，lambda 匿名函数也 可以接收外部传递的多个参数 。 ② 和普通函数不同的是，如果 不需要传递参数，可以连同 小括号() 一起省略 。
mutable	① 此关键字可以省略； ② 如果使用 mutable 则之前的 小括号() 不能省略（尽管参数个数可以为 0）。 ③ mutable 关键字用于声明可以在 lambda 函数体内修改以值传递方式引入的外部变量的 “副本” ：对于以值传递方式引入的外部变量，mutable 修饰后的lambda 表达式修改的是拷贝的那一份，并不会修改真正的外部变量；
noexcept/throw()	① 此关键字可以省略； ② 如果使用noexcept/throw()，则之前的 小括号() 将不能省略（尽管参数个数可以为 0）。 ③ 默认情况下，lambda 函数的函数体中可以抛出任何类型的异常：标注 noexcept 关键字，表示函数体内不会抛出任何异常；使用 throw() 可以指定 lambda 函数内部可以抛出的异常类型。
-> 返回值类型	① 指明 lambda 匿名函数的返回值类型； ② 如果 lambda 函数体内 只有一个 return 语句，或者该函数返回 void，则编译器可以自行推断出返回值类型，此情况下可以直接省略-> 返回值类型 。
函数体	和普通函数一样，lambda 匿名函数包含的内部代码都放置在函数体中。该函数体内除了可以使用指定传递进来的参数之外，还可以使用指定的外部变量以及全局范围内的所有全局变量。

• [外部变量] 的定义方式

外部变量格式	功能
[ ]	空方括号表示当前 lambda 匿名函数中不导入任何外部变量。
[=]	只有一个 = 等号，表示以值传递的方式导入所有外部变量 。
[&]	只有一个& 符号，表示以引用传递的方式导入所有外部变量 。
[val1,val2,…]	表示以值传递的方式导入 val1、val2 等指定的外部变量，同时多个变量之间没有先后次序。
[&val1,&val2,…]	表示以引用传递的方式导入 val1、val2等指定的外部变量，多个变量之间没有前后次序。
[val,&val2,…]	以上 2 种方式还可以混合使用，变量之间没有前后次序。
[=,&val1,…]	表示除 val1 以引用传递的方式导入外，其它外部变量都以值传递的方式导入。
[this]	表示以值传递的方式导入当前的 this 指针。
单个外部变量不允许以相同的传递方式导入多次	例如 [=，val1] 中，val1 先后被以值传递的方式导入了 2 次，这是非法的。

[外部变量访问方式说明符] (参数) mutable noexcept/throw() -> 返回值类型
{
   函数体;
};

• 示例：一个最简单的 lambda 匿名函数。
  此 lambda 匿名函数未引入任何外部变量（[] 内为空），也没有传递任何参数，没有指定 mutable、noexcept 等关键字，没有返回值和函数体。所以，这是一个没有任何功能的 lambda 匿名函数。

[]{}

【 2. 实例 】

2.1 匿名函数与 sort 函数

• 调用 sort() 函数实现对 num 数组中元素的升序排序

#include <iostream>
#include <algorithm>
using namespace std;
//自定义的升序排序规则
bool sort_up(int x,int y){
return  x < y;
}
int main()
{
    int num[4] = { 1,4, 2, 3 };
    // 1.使用匿名函数
    sort(num, num + 4, [=](int x, int y) -> bool { return x < y; });
    // 2.使用普通函数
    // sort(num, num+4, sort_up);   
    for (int n : num) {
        cout << n << " ";
    }
    return 0;
}

2.2 为匿名函数命名

• 虽然 lambda 匿名函数没有函数名称，但我们仍可以为其手动设置一个名称。

#include <iostream>
using namespace std;
int main()
{
    //display 即为 lambda 匿名函数的函数名
    auto display = [](int a, int b) -> void {cout << a << " and " << b; };
    //调用 lambda 函数
    display(10, 20);
    return 0;
}

2.3 匿名函数的传值调用和引用调用

2.3.1 传值调用和引用调用的区别

• 在创建 lambda1 和 lambda2 匿名函数的作用域中，有 num_1、num_2 和 num_3 这 3 个局部变量，另外还有 all_num 全局变量：
  • 其中，lambda1 匿名函数是以 [=] 值传递的方式导入的局部变量，这意味着默认情况下，此函数内部无法修改这 3 个局部变量的值，但全局变量 all_num 除外。
  • 相对地，lambda2 匿名函数以 [&] 引用传递的方式导入这 3 个局部变量，因此在该函数的内部不就可以访问这 3 个局部变量，还可以任意修改它们。同样，也可以访问甚至修改全局变量。

#include <iostream>
using namespace std;
//全局变量
int all_num = 0;
int main()
{
    //局部变量
    int num_1 = 1;
    int num_2 = 2;
    int num_3 = 3;
    cout << "lambda1:\n";
    auto lambda1 = [=] {
        //全局变量可以访问甚至修改
        all_num = 10;
        //错误：num_1 = 314; 函数体内只能使用外部变量的副本，而无法对它们进行修改
        cout << num_1 << " "
            << num_2 << " "
            << num_3 << endl;
        };
    lambda1();
    cout << all_num << endl;

    cout << "lambda2:\n";
    auto lambda2 = [&] {
        all_num = 100;
        num_1 = 10;
        num_2 = 20;
        num_3 = 30;
        cout << num_1 << " "
            << num_2 << " "
            << num_3 << endl;
        };
    lambda2();
    cout << all_num << endl;
    return 0;
}

2.3.2 mutable 修饰传值调用的匿名函数

• 如果我们想在 lambda1 匿名函数的基础上修改外部变量的 “副本” 的值，可以借助 mutable 关键字，真正外部变量的值并不会发生改变。
  lambda1 匿名函数、整个源文件及运行结果分别如下：

auto lambda1 = [=] () mutable{
    //全局变量可以访问甚至修改
    all_num = 10;
    //正确： mutable 声明可以在 lambda 函数体内修改以值传递方式引入的外部变量
    num_1 = 314;
    cout << num_1 << " "
         << num_2 << " "
         << num_3 << endl;
    };

#include <iostream>
using namespace std;
//全局变量
int all_num = 0;
int main()
{
    //局部变量
    int num_1 = 1;
    int num_2 = 2;
    int num_3 = 3;
    cout << "lambda1:\n";
    auto lambda1 = [=]() mutable {
        //全局变量可以访问甚至修改
        all_num = 10;
        //正确： mutable 声明可以在 lambda 函数体内修改以值传递方式引入的外部变量的“副本”
        num_1 = 314;
        cout << num_1 << " "
            << num_2 << " "
            << num_3 << endl;
        };
    lambda1();
    cout << all_num << endl;
    cout << num_1 << endl;


    cout << "lambda2:\n";
    auto lambda2 = [&] {
        all_num = 100;
        num_1 = 10;
        num_2 = 20;
        num_3 = 30;
        cout << num_1 << " "
            << num_2 << " "
            << num_3 << endl;
        };
    lambda2();
    cout << all_num << endl;
    return 0;
}

2.4 匿名函数抛出异常

• 【C++上层应用】3. 异常处理
• 实例1：抛出整型异常
  except 函数体中可以抛出整形异常，因此当函数体中真正发生整形异常时，可以借助 try-catch 块成功捕获并处理。

#include <iostream>
using namespace std;
int main()
{
    // 匿名函数 except
    auto except = []()throw(int) {
        throw 10;
    };
    
    try {
        except();
    }
    catch (int) {
        cout << "捕获到了整形异常！！！";
    }
    return 0;
}

• 实例2：匿名函数指定异常类型与函数体内抛出异常不一致，此程序运行会直接崩溃：
  • except1 匿名函数指定了函数体中不发生任何异常，但函数体中却发生了整形异常。
  • except2 匿名函数指定函数体可能会发生字符异常，但函数体中却发生了整形异常。

#include <iostream>
using namespace std;
int main()
{
    auto except1 = []()noexcept{
        throw 100;
    };
    auto except2 = []()throw(char){
        throw 10;
    };
    try{
        except1();
        except2();
    }catch(int){
        cout << "捕获到了整形异常"<< endl;
    }
    return 0;
}