第17章匿名函数_代码007(未授权)

本文介绍: 如果捕获列表为[&]，则表示所有的外部变量都按引用传递给lambda 使用；如果捕获列表为[=]，则表示所有的外部变量都按值传递给lambda 使用；匿名函数构建的时候对于按值传递的捕获列表，会立即将当前可以取到的值拷贝一份作为常数，然后将该常数作为参数传递。La mb da捕获列表总结[]空捕获列表，La m b da不能使用所在函数中的变量。[names]names是一个逗号分隔的名字列表，这些名字都是La m b da所在函数的局部变量。默认情况下，这些变量会被拷贝。

[捕获列表](参数列表) mutable(可选) 异常属性 -&gt; 返回类型 {
// 函数体
}

语法规则：lambda 表达式可以看成是一般函数的函数名被略去，返回值使用了一个 -> 的形式表示。唯
一与普通函数不同的是增加了“捕获列表”。

//[捕获列表](参数列表)-&gt;返回类型{函数体}
int main()
{
    auto Add = [](int a, int b)-&gt;int {
    	return a + b;
	};
    std::cout &lt;&lt; Add(1, 2) << std::endl; //输出3
    return 0;
}

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

//[捕获列表](参数列表){函数体}
int main()
{
    auto Add = [](int a, int b) {
    	return a + b;
    };
    std::cout << Add(1, 2) << std::endl; //输出3
    return 0;
}

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

有时候，需要在匿名函数内使用外部变量，所以用捕获列表来传递参数。根据传递参数的行为，捕获列
表可分为以下几种：

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

void test3()
{
    cout << "test3" << endl;
    int c = 12;
    int d = 30;
    auto Add = [c, d](int a, int b)->int {
        cout << "d = " << d << endl;
        return c;
    };
    d = 20;
    std::cout << Add(1, 2) << std::endl;
}

void test5()
{
    cout << "test5" << endl;
    int c = 12;
    int d = 30;
    auto Add = [&amp;c, &amp;d](int a, int b)->int {
        c = a; // 编译对的
        cout << "d = " << d << endl;
        return c;
    };
    d = 20;
    std::cout << Add(1, 2) << std::endl;
}

void test7()
{
    cout << "test7" << endl;
    int c = 12;
    int d = 30;
    // 把捕获列表的&amp;改成=再测试
    auto Add = [&amp;](int a, int b)->int {
        c = a; // 编译对的
        cout << "d = " << d << endl;
        return c;
    };
    d = 20;
    std::cout << Add(1, 2) << std::endl;
    std::cout << "c:" << c<< std::endl;
}

void test8()
{
    cout << "test7" << endl;
    int c = 12;
    int d = 30;
    
    // 把捕获列表的&amp;改成=再测试
    // [] 空值，不能使用外面的变量
    // [=] 传值，lambda外部的变量都能使用
    // [&amp;] 传引用值，lambda外部的变量都能使用
    auto Add = [&amp;](int a, int b)->int {
        cout << "d = " << d << endl; // 如果捕获列表为[],则编译报错
        return c;// 如果捕获列表为[],则编译报错
    };
    d = 20;
    std::cout << Add(1, 2) << std::endl;
    std::cout << "c:" << c<< std::endl;
}

void test9()
{
    cout << "test9" << endl;
    auto important = std::make_unique<int>(1);
    auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
    	return x + y + v1 + (*v2);
    };
    std::cout << add(3,4) << std::endl;
}

//泛型 Lambda C++14
void test10()
{
    cout << "test10" << endl;
    auto add = [](auto x, auto y) {
    	return x+y;
    };
    std::cout << add(1, 2) << std::endl;
    std::cout << add(1.1, 1.2) << std::endl;
}

void test12() {
    cout << "test12" << endl;
    int v = 5;
    // 值捕获方式，使用mutable修饰，可以改变捕获的变量值
    auto ff = [v]() mutable {return ++v;};
    v = 0;
    auto j = ff(); // j为6
}

void test13() {
    cout << "test13" << endl;
    int v = 5;
    // 采用引用捕获方式，可以直接修改变量值
    auto ff = [&amp;v] {return ++v;};
    v = 0;
    auto j = ff(); // v引用已修改，j为1
}

[]	空捕获列表，Lambda不能使用所在函数中的变量。
[names]	names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递
[&]	隐式捕获列表，Lambda体内使用的局部变量都按引用方式传递
[=]	隐式捕获列表，Lanbda体内使用的局部变量都按值传递
[&,identifier _list]	identifier _list是一个逗号分隔的列表，包含0个或多个来自所在函数的变量，这些变量采用值捕获的方式，其他变量则被隐式捕获，采用引用方式传递，identifier _list中的名字前面不能使用&。
[=,identi fi er_list]	identi fi er_list中的变量采用引用方式捕获，而被隐式捕获的变量都采用按值传递的方式捕获。identi fi er_list中的名字不能包含 this，且这些名字面前必须使用&。