C++ lambda函数

lambda函数的格式：

[capture-list] (parameters) mutable -> return_type {statement}

[capture-list]:

捕获列表，

[var]:

捕捉var变量的值

只会捕捉定义时变量的值，此后该变量被修改，函数里的值不变

可以理解为创建了一个lambda对象，该对象里有自己的var变量

    int x = 3;
    auto f = [x]()
    { std::cout << x << std::endl; };
    f();
    x = 4;
    f();

输出：

3
3

[&var]:

捕捉var变量的引用

函数内可修改父作用域的变量，同时父作用域的变量改变会同步到函数

    int x = 3;
    auto f = [&x](){
        std::cout << x << std::endl;
        x++;
    };
    f();
    f();
    x = 8;
    f();

输出：

3
4
8

[this]:

捕捉当前的this指针的值

class A{
private:
    int _a, _b;
public:
    A(int a, int b)
        : _a{a}, _b{b}
    {}
    std::function<int()> f(){
        return [this]()
        {
            std::cout << this->_a << ' ' << this->_b << std::endl;
            return this->_a + this->_b;
        };
    }
};

int main(){
    A obj(2,3);
    auto f = obj.f();
    int res = f();
    std::cout << res << std::endl;
    return 0;
}

[=]:

捕捉所有父作用域的变量值（除了捕获列表内显式指定过的），包括this指针，即相当于[var1,var2...]，把所有var都打进去

[&]:

捕捉所有父作用域的变量的引用（除了捕获列表内显式指定过的），包括this指针，即相当于[&var1, &var2...]，把所有var都打进去

规则：

1.多个list用逗号分割，如[var1, var2, &var3]

2.捕获列表不允许出现重复，如[=, a]，因为=已经包含了a；如[a,&a]，不能既捕获值又捕获引用

3.要保证捕获列表捕获的变量的生命周期长于或者等于lambda函数，不要使其悬空

4.捕获列表不为空的lambda函数无法隐式转换为函数指针，只能用std::function来指定其类型

5.lambda函数的operator()默认为const，因此无法在函数体内修改按值捕获进来的变量，但引用可以修改

(parameter)：

参数列表，和正常函数的参数列表一样，指定lambda函数的operator()所接受的参数个数及其类型

mutable：

可缺省

当加上时，lambda函数的operator()取消其const属性，此时函数体内可修改按值捕获的变量的值

    int x = 5;
    auto f = [x]() mutable
    {
        std::cout << x << ' ';
        x++;
    };
    f();
    f();
    f();
    std::cout<< x ;

输出：

5 6 7 5

->return_type：

可缺省

指定返回类型，缺省时，编译器自动推导

{statement}：

函数体，和正常的函数一样写即可

lambda函数实现递归

传入自身写法(C++14及以上)

auto fib = [](auto self, int n)->int {
    if(n == 1 || n == 2) {
        return 1;
    }
    return self(self,n-1) + self(self,n-2);
};
std::cout<< fib(fib,10) <<std::endl;

std::function + 引用捕获(C++11及以上）

std::function<int(int)> factorial;
factorial = [&](int n) -> int {  
    if (n <= 1) return 1;
    return n * factorial(n - 1); 
};

std::cout << factorial(5);