Lambda

奇迹小缘

于 2023-09-27 23:16:45 发布

阅读量221

点赞数 1

分类专栏： c++ 文章标签：开发语言 c++

本文链接：https://blog.csdn.net/qq_41061477/article/details/133365237

版权

c++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

c++11引入了Lambda表达式，类似于一个匿名函数，拥有捕获所在作用域中变量的能力，能够将函数做为对象一样使用，通常用来实现回调函数、代理等功能。

一、语法格式

Lambda 表达式就是一个可调用的代码单元，我们可以将其理解为一个未命名的内联函数。与任何函数类似，一个Lambda具有一个返回类型、一个参数列表和一个函数体。但与函数不同，Lambda可以定义在函数内部，其语法格式如下：

[capture list](parameter list) mutable(可选) 异常属性->return type{function body}

[capture list]是捕获列表，在应用中必填。

(parameter list)是参数列表，在应用中选填。

specifiers是限定符，在应用中选填。

exception是异常说明符，在应用中选填。

-> type是返回值类型，在应用中选填。

{ function body }是表达式的函数体，在应用中必填。

下面是一个简单的Lambda表达式：

[](int x, int y){ return x + y; }

这个Lambda表达式可以看作是一个没有函数名的函数，接受两个整型参数，并返回它们的和。应用实例如下：

auto f = [](int x, int y){ return x + y; };
int result = f(10, 20);    //result == 30

捕获列表

Lambda表达式的捕获列表可以捕获当前函数作用域的零个或多个变量，变量之间用逗号分隔；这些变量可以在Lambda表达式中被访问和修改。捕获方式有三种，分别是值捕获、引用捕获和混合捕获。

值捕获：将外部变量以const引用的方式传递到Lambda表达式中，在表达式中可以访问变量，但是不能修改变量；使用=可以将函数作用域的所有变量以值捕获方式传入到表达式中。

int a = 10; b = 20, c = 30;

//将变量a和b以值捕获方式传入到表达式中
auto f1 = [a, b]{ return a + b; };
int result1 = f1();    //result1 == 30

//将所有变量以值捕获方式传入到表达式中
auto f2 = [=]{ return a + b + c; };
int result2 = f2();    //result2 == 60

引用捕获：将外部变量以引用的方式传递到Lambda表达式中，在表达式中可以访问变量和修改变量；使用&可以将函数作用域的所有变量以引用捕获方式传入到表达式中。

int a = 10; b = 20, c = 30;

//将变量a和b以引用捕获方式传入到表达式中
auto f1 = [&a, &b]{ a++; b++; };
f1();    
//a == 11    b == 21

//将所有变量以引用捕获方式传入到表达式中
auto f2 = [&]{ a++; b++; c++; };
f2();    
//a == 12    b == 22    c == 31

混合捕获：捕获列表捕获多个变量，既有值捕获的变量也有引用捕获的变量。

int a = 10; b = 20, c = 30;

//将变量a和b以值捕获方式传入到表达式中，将变量c以引用捕获方式传递到表达式中
auto f = [=,&c]{ c++; return a + b; };
int result = f();    //result == 30
//c == 31

限定符

Lambda表达式的限定符值为mutable，其意义是可以在函数体内修改按值捕获的变量；如果不需要此操作，则可以省略此项。

int a = 10;

//未用mutable修饰
auto f1 = [a](){
    a++;    //报错
}

//使用mutable修饰
auto f2 = [a]() mutable {
    a++;    //成功
}

异常说明符

Lambda表达式的异常说明符值为noexcept，其意义是指明表达式不会抛出异常；如果不需要此操作，则可以省略此项。

//未用noexcept修饰
auto f1 = [](int x){
    if(x == 0)
        throw(0);    //成功
    return x;
}

//使用noexcept修饰
auto f2 = [](int x) noexcept {
    if(x == 0)
        throw(0);    //报错
    return x;
}

返回值类型

-> type

可以指定lambda表达式返回值类型；如果不指定返回类型，则编译器会根据代码实现为函数推导一个返回类型；如果没有返回值，则可忽略此部分。

//指定返回值类型
auto f1 = []()->int { return 1; };
int result1 = f1();    //result == 1

//不指定返回值类型
auto f2 = [](){ return 1; };
int result2 = f2();    //result == 1

函数体

Lambda表达式的函数体部分与普通函数体一致。

auto f1 = []{ std::cout << "hello world" << std::endl; };

auto f2 = [](int x, int y){ return x + y; };

二、Lambda表达式的优缺点

Lambda表达式有以下优点：

简洁：Lambda表达式可以在一个表达式中定义一个函数，不需要单独声明和定义。
方便：Lambda表达式可以捕获外部变量，使得函数对象更加灵活和易于使用。
通用：Lambda表达式可以作为任何需要函数对象的地方使用，例如STL算法、线程等。

Lambda表达式也有一些缺点：

可读性：Lambda表达式可能过于简洁，难以阅读和理解。
复杂性：Lambda表达式可以包含复杂的逻辑和控制流，使得代码难以维护和调试。
性能：Lambda表达式可能会产生额外的开销，例如变量捕获和函数调用的开销。

三、特殊处理

捕获静态变量和常量

对静态变量和常量的捕获就比较简单了，因为压根不需要捕获。只要是在lambda作用域内可见的静态变量和常量都可以在函数体内直接使用，不需要捕获。并且在函数体内部对静态变量进行修改可以反应到外部，示例代码如下

int main(){
    const int cnum = 1;
    static int snum = 2;
    auto fn_copy = []()mutable{
        std::cout << cnum << std::endl;
        std::cout << snum << std::endl;
        snum = 3;
    };
    fn_copy();
    std::cout << snum << std::endl;
    return 0;
}

在需要使用的时候定义，而无需跳出当前函数，在函数外重新定义一个函数或者struct。你或许会觉得这是一个微不足道的语法糖
lambda还有一个优势，就是定义时立即执行。
在普通lambda后面加上()，不仅定义了一个匿名lambda，还立即执行了这个lambda。
[]() {
   //....
} ();

C++中的lambda表达式的优越性体现在那些方面？ - 知乎