lambda续集——2

隐式捕获：

出了显式列出我们希望使用的来自函数的变量外，还可以让编译器根据lambda体中的代码来推断我们要使用哪些变量。为了指示编译器推断捕获列表，应在捕获列表中写一个&或=。&告诉编译器采用引用捕获方式，=告诉编译器采用值捕获方式。我们可以混合使用隐式或显式捕获，在此条件下，捕获列表的第一个元素必须是一个&或=。当混合使用隐式和显式捕获时，显式捕获的变量必须使用与隐式捕获不同的方式。即，如果隐式捕获时引用（&）方式，则显式捕获名变量必须使用值捕获方式，因此不能在显式捕获名字前使用&；如果是隐式捕获时值（=）方式，显式捕获变量名必须采用引用方式，即在名字前加&。

eg：

#include<iostream>
using namespace std;

int main()
{
    /*隐式引用捕获*/
    int ma = 10;
    int mma = 10;
    auto f= [&] {return ma+mma; };
    ma = 1;
    cout << f() << endl;

    /*隐式值捕获*/
    int a = 10;
    int aa = 10;
    auto ff = [=] {return a+aa; };
    a = 1;
    cout << ff() << endl;

    /*混合捕获,引用在前*/
    int i = 10;
    int j = 100;
    auto fff = [&,j] {return i+j; };
    //auto fff = [&i, =] {return i + j; }; err
    //auto fff = [&i, &] {return i + j; }; err
    i = 1;
    cout << fff() << endl;

    /*混合捕获，值在前*/
    int m = 10;
    int n = 100;
    auto ffff = [=, &n] {return m + n; };
    n = 1;
    cout << ffff() << endl;

    /*混合捕获的思考，多个变量，可以隐式捕获，针对特殊变量，单独指定*/
    int q = 1, w = 10, e = 20, r = 30;
    /*我想除了e变量，其余的都用值捕获*/
    auto fffff = [=, &e] {return q+w+e+r; };
    e = 100;
    cout << fffff() << endl;
    return 0;
}

 

 

可变lambda：

默认情况下，对于一个值拷贝的变量，lambda不会改变其值，如果我们希望能改变一个被捕获的变量的值，就必须在参数列表后加上mutable。因此，可变lambda能省略参数列表。

#include<iostream>
using namespace std;

int main()
{
    int ma = 10;
    auto f= [=] ()mutable {return ++ma; };
    cout << f() << endl;
    return 0;
}

一个引用捕获能否改变变量的值依赖于此引用指向的是一个const类型还是一个非const类型。

 

指定lambda返回类型：

默认情况下，如果lambda体包含return之外的任何语句，则编译器假定此lambda返回void。与其他返回void的函数类似，被推断返回void的lambda不能返回值。

#include<iostream>
using namespace std;

int main()
{
    auto f = [](int* a)->int * { if (*a > 0)return a; else return NULL; };
    cout << f(NULL) << endl;
    return 0;
}

不用位置返回类型将报错。但是如果返回类型都是一种类型，比如上诉两个return，都return一种类型，是可以推断的，但是吐过return类型不同，将要使用尾置返回类型强制指定，在不止单纯一条return语句时，建议最好使用尾置返回类型。

对于那种只在一两个地方使用的简单操作，lambda表达式是很有用的。但如果我们需要在很多地方使用相同的操作，通常应该定义一个函数，而不是多次编写相同的lambda表达式。类似的，如果一个操作需要很多语句完成，通常使用函数更好。如果一个lambda捕获列表为空，通常可以用函数来代替它。但是对于捕获局部变量的lambda，用函数替代就不那么容易了。