C++之lambda【匿名函数】

1、语法

语法结构：

cpp 复制代码

[捕获列表](参数列表) mutable(可选) 异常属性 -> 返回类型 {
	// 函数处理
}

注意：

一般情况下，编译器可以自动推断出lambda表达式的返回类型，所以我们可以不指定返回类型。

但是如果函数体内有多个return语句时，编译器无法自动推断出返回类型，此时必须指定返回类型。

代码：

cpp 复制代码

#include <iostream>

int main(int argc,char **argv)
{
    auto Add = [](float x, float y) -> int {
        return x + y;
    };

    std::cout << Add(1.0, 2.0) << std::endl;
	return 0;
}

结果：

cpp 复制代码

2、捕获列表

需要在匿名函数内使用外部变量，可以用捕获列表来传递参数。

2.1、值捕获传递参数

与参数传值类似，值捕获的前提是变量可以拷贝，不同之处则在于，被捕获的变量在 lambda表达式被创建时拷贝，而不是在调用时才拷贝。

代码：

cpp 复制代码

#include <iostream>

int main(int argc,char **argv)
{
    int m = 99;
    int n = 123127;

    auto Add = [m, n](float x, float y) -> int {
        std::cout << m + n + x + y << std::endl;
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。值捕获的时候不发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
	return 0;
}

结果：

cpp 复制代码

123229
3

2.2、引用捕获传递参数

与引用传参类似，引用捕获保存的是引用，值会发生变化。

代码：

cpp 复制代码

#include <iostream>

int main(int argc,char **argv)
{
    int m = 99;
    int n = 123127;

    auto Add = [m, &n](float x, float y) -> int {
        std::cout << m + n + x + y << std::endl;
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。引用捕获的时候发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
	return 0;
}

结果：

cpp 复制代码

225
3

2.3、隐式捕获传递参数

手动书写捕获列表有时候是非常复杂的，这种机械性的工作可以交给编译器来处理，这时候可以在捕获列表中写一个 & 或**=** 向编译器声明采用引用捕获或者值捕获。编译器会将外部变量全部捕获。

代码：

cpp 复制代码

#include <iostream>

void test_1()
{
    int m = 99;
    int n = 123127;

    auto Add = [=](float x, float y) -> int {
        std::cout << m + n + x + y << std::endl;
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。值捕获的时候不发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
}

void test_2()
{
    int m = 99;
    int n = 123127;

    auto Add = [&](float x, float y) -> int {
        std::cout << m + n + x + y << std::endl;
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。引用捕获的时候发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
}

int main(int argc,char **argv)
{
    test_1();
    test_2();
	return 0;
}

结果：

cpp 复制代码

2.4、空捕获列表

捕获列表 [] 为空，表示Lambda不能使用所在函数中的变量。

代码：

cpp 复制代码

#include <iostream>

int main(int argc,char **argv)
{
    int m = 99;
    int n = 123127;

    auto Add = [](float x, float y) -> int {
        // std::cout << m + n + x + y << std::endl;   // 编译失败，不能使用m和n变量
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。值捕获的时候不发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
	return 0;
}

结果：

cpp 复制代码

2.5、表达式捕获

上面提到的值捕获、引用捕获都是已经在外层作用域声明的变量，因此这些捕获方式捕获的均为左值，而不能捕获右值。

C++14之后支持捕获右值，允许捕获的成员用任意的表达式进行初始化，被声明的捕获变量类型会根据表达式进行判断，判断方式与使用 auto 本质上是相同的：

代码：

cpp 复制代码

#include <iostream>
#include <memory>

int main(int argc,char **argv)
{
    int m = 99;
    int n = 123127;
    auto important = std::make_unique<int>(1);

    auto Add = [mm = 200, nn = std::move(important)](float x, float y) -> int {
        std::cout << mm + *nn + x + y << std::endl;
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。值捕获的时候不发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
	return 0;
}

结果：

cpp 复制代码

204
3

2.6、可变lambda

（1）采用值捕获的方式，lambda不能修改其值，如果想要修改，使用mutable修饰。

（2）采用引用捕获的方式，lambda可以直接修改其值。

代码：

cpp 复制代码

#include <iostream>

void test_1()
{
    // 值传递，加关键字mutable
    int m = 10;
    auto Add = [m](auto x, auto y) mutable -> auto {
        m++;
        return x + y + m;
    };
    std::cout << Add(1, 4) << std::endl;
}

void test_2()
{
    // 引用传递可直接修改
    int m = 10;
    auto Add = [&m](auto x, auto y) -> auto {
        m++;
        return x + y + m;
    };
    std::cout << Add(1, 4) << std::endl;
}

int main(int argc,char **argv)
{
	test_1();
	test_2();
	return 0;
}

结果：

cpp 复制代码

16
16

2.7、混合捕获

（1）要求捕获列表中第一个元素必须是隐式捕获（&或=）。

（2）混合使用时，若隐式捕获采用引用捕获（&）则显式捕获的变量必须采用值捕获的方式。

（3）若隐式捕获采用值捕获（=），则显式捕获的变量必须采用引用捕获的方式。

代码：

cpp 复制代码

#include <iostream>

void test_1()
{
    int m = 99;
    int n = 123127;

    auto Add = [=, &n, m1 = 4.5](float x, float y) -> int {
        std::cout << m + n + x + y + m1 << std::endl;
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。值捕获的时候不发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
}

void test_2()
{
    int m = 99;
    int n = 123127;

    auto Add = [&, n, m1 = 1](float x, float y) -> int {
        std::cout << m + n + x + y + m1 << std::endl;
        return x + y;
    };

    // 修改n的值, 查看Add(1.0, 2.0)打印的值是否发生变化。引用捕获的时候发生变化。
    n = 123;

    std::cout << Add(1.0, 2.0) << std::endl;
}

int main(int argc,char **argv)
{
    test_1();
    test_2();
	return 0;
}

结果：

cpp 复制代码

3、泛型 Lambda

在C++14之前，lambda表示的形参只能指定具体的类型，没法泛型化。从 C++14 开始， Lambda 函数的形式参数可以使用 auto关键字来产生意义上的泛型。

代码：

cpp 复制代码

#include <iostream>

int main(int argc,char **argv)
{
    auto Add = [](auto x, auto y) -> auto {
        return x + y;
    };

    std::cout << Add(1.4, 2.0) << std::endl;
    std::cout << Add(1, 2) << std::endl;
	return 0;
}

结果：

cpp 复制代码

3.4
3