C++ lambda表达式

什么是lambda表达式

lambda表达式是一个可调用的代码单元，我们可以理解为一个未命名的内联函数，当定义一个lambda时，编译器会生成一个与lambda对应的类类型。

从lambda生成的类包含它所捕获的变量的数据成员，被捕获的变量在lambda创建时进行拷贝或者引用(而不是调用时)。

lambda表达式格式

一个lambda表达式的声明格式如下：

[capture list] (params list) mutable exception-> return type { function body }

各项具体含义：

capture list：捕获外部变量列表
params list：形参列表
mutable：用来说用是否可以修改捕获的变量
exception：异常设定
return type：返回类型
function body：函数体

mutable和exception不是必须的，可以省略

[capture list] (params list)-> return type { function body }

auto lambdaFunc = []() ->const char* {return "hello world"; };

如果省略返回类型，lambda根据函数体中的代码推断返回类型，如果函数体有return语句，则返回类型从返回的表达式的类型推断而来，否则返回类型为void。

[capture list] (params list){ function body }

auto lambdaFunc = [] (){return "hello world"; };

参数列表为空且省略了返回类型，mutable，exception时，可以省略()

[capture list] -> return type { function body }

auto lambdaFunc = []{return "hello world"; };

使用捕获列表

lambda通过捕获列表指出它要使用哪些外部变量，然后就可以再函数体中访问这些变量了。

int main()
{
    const char* helloStr = "hello world";
    auto lambdaFunc = [helloStr]{return helloStr; };
    std::cout << lambdaFunc() << std::endl;
    system("pause");
    return 0;
}

值捕获与引用捕获

类似参数传递，变量的捕捉方式也可以是值或者引用，对于值捕获的变量，lambda在创建时会对其进行拷贝，而引用捕获则不同，我们在lambda内使用此变量时，实际上使用的是引用所绑定的变量，不会发生拷贝。

值捕获，输出hello world

int main()
{
    std::string helloStr = "hello world";
    auto lambdaFunc = [helloStr]{return helloStr; };
    helloStr = "hello xy";
    std::cout << lambdaFunc() << std::endl;
    system("pause");
    return 0;
}

引用捕获，输出hello xy

int main()
{
    std::string helloStr = "hello world";
    auto lambdaFunc = [&helloStr]{return helloStr; };
    helloStr = "hello xy";
    std::cout << lambdaFunc() << std::endl;
    system("pause");
    return 0;
}

隐式捕获

除了指定捕获变量外，还可以让编译器根据函数体中的代码来推断需要捕获哪些变量，隐式捕获有两种，[=]和[&]。[=]表示以值捕获的方式捕获外部变量，[&]表示以引用捕获的方式捕获外部变量。

int main()
{
    int value1 = 10;
    int value2 = 100;
    auto lambdaFunc1 = [&]{return ++value1; };
    auto lambdaFunc2 = [=] {return value2; };
    std::cout << lambdaFunc1() << std::endl;
    std::cout << lambdaFunc2() << std::endl;
    system("pause");
    return 0;
}

混合捕获

lambda还支持混合方式捕获变量：

[=, &x]，变量x以引用形式捕获，其余变量以传值形式捕获。
[&, x]，变量x以值的形式捕获，其余变量以引用形式捕获。

int main()
{
    int value1 = 10;
    int value2 = 100;
    auto lambdaFunc = [&,value2]{return ++value1+value2; };
    std::cout << lambdaFunc() << std::endl;
    system("pause");
    return 0;
}

以值的形式捕获this指针

class Person 
{
public:
    int height_=170;

    void printHeight()
    {
        auto lambdaFunc = [this] {return this->height_;};
        std::cout << lambdaFunc() << std::endl;
    }
};

 
int main()
{
    Person person;
    person.printHeight();
    system("pause");
    return 0;
}

修改值捕获的变量

如果以值传递方式捕捉外部变量，那么函数体中不能修改该变量(可以理解为加了一个const修饰符)，否则会引起编译错误，如下代码：

int main()
{
    int value1 = 10;
    auto lambdaFunc = [value1](){return ++value1; };
    std::cout << lambdaFunc() << std::endl;
    system("pause");
    return 0;
}

这个时候使用mutable关键字即可修改捕捉的变量(取消const修饰)。

int main()
{
    int value1 = 10;
    auto lambdaFunc = [value1]()mutable{return ++value1; };
    std::cout << lambdaFunc() << std::endl;
    system("pause");
    return 0;
}