首页 / C++ / C++ lambda 分析

C++ lambda 分析

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了C++ lambda 分析，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含7126字，纯文字阅读大概需要11分钟。

内容图文

lambda 表达式分析

构造闭包：能够捕获作用域中变量的匿名函数的对象，Lambda 表达式是纯右值表达式，其类型是独有的无名非联合非聚合类类型，被称为闭包类型（closure type），所以在声明的时候必须使用 auto 来声明。

在其它语言如lua中，闭包的格式相对更为简单，可以使用 lambda 表达式作用域的所有变量，并且返回闭包

local function add10(arg)
    local i = 10
    local ret = function()
        i = i - 1
        return i + arg
    end
    return ret
end

print( add10(1)() ) -- 10

C++ 中则显得复杂些，也提供了更多的功能来控制闭包函数的属性。

lambda 和 std::function

虽然 lambda 的使用和函数对象的调用方式有相似之处，

std::function<int(int, int)> add2 = [&](int a, int b) -> int {
    return a + b + val + f1.value;
};


但他们并不是同一种东西，lambda 的类型是不可知的（在编译期决定），使用 sizeof 两者的大小也是不相同的，std::function 是函数对象，通过消除类型再重载 operator() 达到调用的效果，只要这个函数满足可以调用的条件，就可以使用std::function保存起来，这也是上面例子的体现。
语法 C++ 17
[ 捕获 ] ( 形参 ) 说明符(可选) 异常说明 -> ret { 函数体 } 
  全量声明

[ 捕获 ] ( 形参 ) -> ret { 函数体 } 
  const lambda 声明，复制捕获 的对象在 lambda 体内为 const

[ 捕获 ] ( 形参 ) { 函数体 } 
  省略返回类型的声明，返回的类型从函数体的返回推导

[ 捕获 ] { 函数体 } 
  无实参的函数

说明符 ：
mutable, 允许 函数体 修改各个复制捕获的形参
constexpr C++ 17, 显式指定函数调用符为 constexpr，当函数体满足 constexpr函数要求时，即使未显式指定，也会是 constexpr
异常说明 ：提供 throw 或者 noexpect 字句
使用如下：
struct Foo {
    int value;
    Foo() : value(1) { std::cout << "Foo::Foo();\n"; }
    Foo(const Foo &other) {
        value = other.value;
        std::cout << "Foo::Foo(const Foo &)\n";
    }
    ~Foo() {
        value = 0;
        std::cout << "Foo::~Foo();\n";
    }
};

int main() {
    int val = 7;
    Foo f1;
    auto add1 = [&](int a, int b) mutable noexcept->int {
        return a + b + val + f1.value;
    };

    // 使用 std::function 包装
    std::function<int(int, int)> add2 = [&](int a, int b) -> int {
        f1.value = val;  // OK，引用捕获
        return a + b + val + f1.value;
    };
    auto add3 = [&](int a, int b) { return a + b + val + f1.value; };
    auto add4 = [=] {
        // f1.value = val; // 错误，复制捕获 的对象在 lambda 体内为 const
        return val + f1.value;
    };

    // 全 auto 也是可以，返回的这个 auto 不写也行
    auto add5 = [=](auto a, int b) -> auto { return a + b; };
}

// 输出：
Foo::Foo();
Foo::Foo(const Foo &)
Foo::~Foo();
Foo::~Foo();

Lambda 捕获
&（以引用隐式捕获被使用的自动变量）
=（以复制隐式捕获被使用的自动变量）
当出现任一默认捕获符时，都能隐式捕获当前对象（this）。当它被隐式捕获时，始终被以引用捕获，即使默认捕获符是 = 也是如此。~~当默认捕获符为 = 时，（this） 的隐式捕获被弃用。 (C++20 起)~~，见this分析
捕获 中单独的捕获符的语法是
标识符 
  简单以复制捕获

标识符 ...
作为包展开的简单以复制捕获

标识符 初始化器 
  带初始化器的以复制捕获

& 标识符 
  简单以引用捕获

& 标识符 ...
作为包展开的简单引用捕获

& 标识符 初始化器 
  带初始化器的以引用捕获

this
当前对象的简单以引用捕获

*this
当前对象的简单以复制捕获, C++17

捕获列表可以不同的捕获方式，当默认捕获符是 & 时，后继的简单捕获符必须不以 & 开始, 当默认捕获符是 = 时，后继的简单捕获符必须以 & 开始，或者为 *this (C++17 起) 或 this (C++20 起).
在上面的示例main中增加，部分代码如下，包括了两种捕获方式，及在函数体内修改lambda捕获变量的值，及返回对象
    Foo f1;
    Foo f2;
    int val = 7;
    auto add6 = [=, &f2](int a) mutable {
        f2.value *= a;
        f1.value += f2.value + val;
        return f1;
    };

    Foo f3 = add6(3);

又到了喜闻乐见反汇编的情况了，看看编译器是怎么实现的lambda表达式的。
_ZZ4mainENUliE_clEi:
.LFB10:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $32, %rsp
    movq    %rdi, -8(%rbp)
    movq    %rsi, -16(%rbp)
    movl    %edx, -20(%rbp)   // int a
    movq    -16(%rbp), %rax   // -16(%rbp) = & this(f2)，每次都这么赋值，没优化的指令真的很冗余
    movq    (%rax), %rax
    movl    (%rax), %edx      // %edx = f2.value
    movq    -16(%rbp), %rax
    movq    (%rax), %rax
    imull   -20(%rbp), %edx   // %edx = f2.value * a
    movl    %edx, (%rax)      // f2.value = %edx
    movq    -16(%rbp), %rax
    movl    8(%rax), %edx     // 在main函数中 -32(%rbp) + 8 = -24(%rbp) 也就是copy构造函数产生的 this 指针
    movq    -16(%rbp), %rax   // 以下的就是那些加减了，
    movq    (%rax), %rax
    movl    (%rax), %ecx
    movq    -16(%rbp), %rax
    movl    12(%rax), %eax
    addl    %ecx, %eax
    addl    %eax, %edx
    movq    -16(%rbp), %rax
    movl    %edx, 8(%rax)
    movq    -16(%rbp), %rax
    leaq    8(%rax), %rdx
    movq    -8(%rbp), %rax
    movq    %rdx, %rsi        // 上一个copy构造函数内的 this 指针
    movq    %rax, %rdi        // copy构造的this指针
    call    _ZN3FooC1ERKS_    // 继续调用copy构造函数，返回
    movq    -8(%rbp), %rax
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc

// lambda 的析构函数，这个函数是隐式声明的
_ZZ4mainENUliE_D2Ev:
.LFB12:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $16, %rsp
    movq    %rdi, -8(%rbp)
    movq    -8(%rbp), %rax
    addq    $8, %rax
    movq    %rax, %rdi
    call    _ZN3FooD1Ev
    nop
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc

main:
.LFB9:
    .cfi_startproc
    pushq   %rbp
    .cfi_def_cfa_offset 16
    .cfi_offset 6, -16
    movq    %rsp, %rbp
    .cfi_def_cfa_register 6
    subq    $48, %rsp
    movl    $7, -4(%rbp)     // int val = 7;
    leaq    -8(%rbp), %rax   // -8(%rbp) = this(f1)
    movq    %rax, %rdi
    call    _ZN3FooC1Ev       // Foo f1;
    leaq    -12(%rbp), %rax   // -12(%rbp) = this(f2)
    movq    %rax, %rdi
    call    _ZN3FooC1Ev       // Foo f2;
    leaq    -12(%rbp), %rax
    movq    %rax, -32(%rbp)   // -32(%rbp) = this(f2)
    leaq    -8(%rbp), %rax    // 取 this(f1)
    leaq    -32(%rbp), %rdx
    addq    $8, %rdx          // copy 构造函数的 this = -24(%rbp)，记住这个 24
    movq    %rax, %rsi        // 第二个参数 this（f1）
    movq    %rdx, %rdi        // 第一个参数，调用copy构造函数的 this
    call    _ZN3FooC1ERKS_    // Foo(const Foo &);
    movl    -4(%rbp), %eax
    movl    %eax, -20(%rbp)   // -20(%rbp) = 7
    leaq    -36(%rbp), %rax
    leaq    -32(%rbp), %rcx
    movl    $3, %edx
    movq    %rcx, %rsi        // 第二个参数 this(f2) 的地址（两次 leaq）
    movq    %rax, %rdi        // 需要返回的 Foo 对象的 this 指针
    call    _ZZ4mainENUliE_clEi // lambda 的匿名函数
    leaq    -36(%rbp), %rax
    movq    %rax, %rdi
    call    _ZN3FooD1Ev
    leaq    -32(%rbp), %rax
    movq    %rax, %rdi
    call    _ZZ4mainENUliE_D1Ev // 析构函数
    leaq    -12(%rbp), %rax
    movq    %rax, %rdi
    call    _ZN3FooD1Ev
    leaq    -8(%rbp), %rax
    movq    %rax, %rdi
    call    _ZN3FooD1Ev
    movl    $0, %eax
    leave
    .cfi_def_cfa 7, 8
    ret
    .cfi_endproc
上面的汇编代码相对cpp代码还是比较多的，由于一些隐含规则的约束下，编译器做了很多的工作，产生的代码的顺序就比较混乱
使用 = 值捕获时，会先调用copy构造函数
使用 & 引用捕获时，将捕获对象的引用（地址）作为隐式参数传给匿名函数
编译器不仅会产生匿名函数，还会有一个析构函数产生，这个函数负责调用在匿名函数内的析构函数
生命周期
lambda表达式相关的对象的生命周期，见上反汇编：
全局，更外层作用域的生命周期不受影响
使用值捕获的情况，先于lambda表达式函数体构造对象，后于函数体执行完析构
在lambda表达式函数体内的对象，在函数体执行时创建，在闭包析构函数内析构
lambda 对象的生命周期为所在作用域结束，析构的顺序为声明的逆序析构
this
使用 -std=c++14 生成的汇编代码在 =，&，this 捕获的情况下，产生的汇编代码几乎一样，都是使用的引用（this地址）传参，使用 -std=c++2a 的情况下，编译器不推荐使用值捕获的方式（虽然还是使用的引用捕获）。
TODO
补全对参数包的分析
参考
lambda 表达式，cppreference Lambda 表达式 (C++11 起)。 



  点赞 
  收藏
  分享



  

文章举报






   

漫步星辰575654643

发布了117 篇原创文章 · 获赞 3 · 访问量 9470


私信 
关注




	

                
                
                内容总结
                
                    
                        以上是互联网集市为您收集整理的C++ lambda 分析全部内容，希望文章能够帮你解决C++ lambda 分析所遇到的程序开发问题。
                        如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
                    
                
                内容备注
                
                    
                        版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
                    
                
                内容手机端
                
                    
                    
                        扫描二维码推送至手机访问。
                        本文链接：https://qyyshop.com/info/643917.html
                    
                
                
                
                来源：【匿名】


        


    
    【上一篇】C++学习 -- 开始【下一篇】c++有个库什么的吗?

            
                
                    更多 ► 
                    【C++ lambda 分析】教程文章相关的互联网学习教程文章
                
                

C++11 lambda表达式基本用法
#include <iostream>
using namespace std;void func1()
{cout<<"lambda表达式，值捕获，类似值传递"<<endl;size_t v1=30;//size_t为unsigned int无符号整数size_t v2=30;size_t v3=30;auto f=[v1,v2,v3]{return v1+v2+v3;};//lambda表达式中[]里面放的是要传递的参数，可以放多个。v1=2;cout<<f()<<endl;cout<<endl;//因为这是类似值传递，所以v1在改变前就已经给了f，所以不会变。注意隐式捕获得到的变量不能被改变，只能使用其值...
C++中Lambda表达式浅析【代码】
1. Lambda表达式Lambda表达式是C++11最重要也是最常用的特性之一，是现代编程语言的一个特点，简洁，提高了代码的效率并且可以使程序更加灵活Lambda表达式就是一个匿名函数，所谓匿名函数，那自然是没有名字的函数，当一个函数只是临时使用而且比较简单的时候，就可以采用Lambda表达式Lambda表达式的语法格式如下：当你不需要capture捕获的时候，就直接写一个框框[]
当你不需要参数的时候，就直接写一个括号()
当年不需要返回值的时...
【C++11】lambda 表达式
概述C++ 11中引入了新的lamdba表达式，使用也很简单，我最喜欢的是不用给函数取名称，每次给函数取名称都感觉自己读书太少~1、lambda表达式lambda表达式可以理解为一个匿名的内联函数。和函数一样，lambda表达式具有一个返回类型、一个参数列表和一个函数体。与函数不一样的是lambda必须使用尾置返回类型。一个lambda表达式表示一个可调用的代码单元。语法：[capture list] (parameter list) -> return type {function body}captur...
C++11 lambda表达式学习【代码】
最近在接手一个模块，看到了很多奇葩的语法，查了一下是lambda表达式，这块还真不了解。周末学习一下记录记录。lambda表达式是C++11最重要也最常用的一个特性之一。lambda来源于函数式编程的概念，也是现代编程语言的一个特点。目前支持lamdba的语言不少，如python，C++11, Java等。 lambda表达式的语法归纳如下：[ caputrue ] ( params ) opt -> ret { body; };1).capture是捕获列表；2).params是参数表；(选填)3).opt是函数选项；...
c++ 11学习笔记--Lambda 表达式（对比测试Lambda ，bind，Function Object）【代码】
所有c++ coder都应该为这个语法感到高兴，说的直白一点，Lambda 表达式就是函数对象的语法糖。 还是直接看对比栗子吧，抄袭的是msdn的官网该示例使用 for_each 函数调用中嵌入的 lambda 向控制台打印 vector 对象中的每个元素是偶数还是奇数。使用lambda#include <algorithm>
#include <iostream>
#include <vector>
usingnamespace std;int main() 
{// Create a vector object that contains 10 elements.vector<int> v;for (int...
c++ lambda表达式在标准库函数sort中的应用【代码】
Lambda表达式包含一个函数对象参数标识一个 Lambda 表达式的开始，这部分必须存在，不能省略。函数对象参数是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些到定义 Lambda 为止时 Lambda 所在作用范围内可见的局部变量(包括 Lambda 所在类的 this)。函数对象参数有以下形式：空。没有任何函数对象参数。=。函数体内可以使用 Lambda 所在范围内所有可见的局部变量（包括 Lambda 所在类的 this），并且是值...
C++ lambda函数及其用法（转）【代码】
由于接触C++不久，很多东西比较陌生，今天看阿里云OSS的C++ SDK文件下载部分例子，发现有如下lambda表达式用法，故了解一下相关知识/*获取文件到本地文件*/
GetObjectRequest request(BucketName, ObjectName);
request.setResponseStreamFactory([=]() {return std::make_shared<std::fstream>(FileNametoSave, std::ios_base::out | std::ios_base::in | std::ios_base::trunc| std::ios_base::binary); });auto outcome = clien...
C++11 lambda的理解【代码】
C++11 的 lambda 表达式规范如下：[ capture ] ( params ) mutable exception attribute -> ret { body } (1) [ capture ] ( params ) -> ret { body }	(2)	 [ capture ] ( params ) { body }	(3)	 [ capture ] { body }	(4)	  // 简单的例子// 这个例子有2个参数x和y 返回x+y[](int x,int y){ return x+y; }; 其实看起来和函数差不多只不过使用了[]代替了函数名,[]里面的捕获参数：[]  	 // 不捕获外部变量[&] 	 // 引用形式捕获所...
C++11 lambda 表达式作用在传统C回调函数上【代码】
//--std=c++11
#include <functional>
#include <cstdio>typedef bool (*IS_X_NUM)(int);void show_x_num(int * array, int len, IS_X_NUM is_x_num)
{
    for(int i = 0; i < len; i++) {
        if(is_x_num(array[i])) {
            printf("%d ", array[i]);
        }
    }
    printf("\n");
}void show_x_num2(int * array, int len, std::function<bool(int)> is_x_num)
{
    for(int i = 0; i < len; i++) {
       ...
[C++] lambda 表达式【代码】
lambda表达式的最简单形式是:[](){};
这样就构成了lambda表达式的最基本组成部分，它实际上是在构造一个能够捕获作用域中的变量的无名函数对象的闭包，这里[]就是起这个捕获的作用，()里面就像普通函数一样写形参，花括号就是构造的闭包。
如果直接写像上面一样的简单形式，是不会执行的，只有最后加上括号调用了才会。同时自然的，最后的括号与前面的括号里的参数要对应。int main()
{[](){ std::cout<<"hahaha"<<endl; };//no ou...
【C++11】新特性——Lambda函数【代码】
本篇文章由：http://www.sollyu.com/c11-new-lambda-function/文章列表本文章为系列文章【C++11】新特性——auto的使用 http://www.sollyu.com/c11-new-features-auto/【C++11】新特性——Lambda函数 http://www.sollyu.com/c11-new-lambda-function/说明在标准 C++，特别是当使用 C++ 标准程序库算法函数诸如 sort 和 find，用户经常希望能够在算法函数调用的附近定义一个临时的述部函数(又称谓词函数，predicate function)。由于...
C++、PHP、Javascript、...、对lambda表达式的支持【图】
lambdalambda表达式，也叫Closure(闭包)，也叫匿名函数。由于其强大之处，几乎被所有主流开发语言支持，本文试图列出大部分语言中lambda表达式的样例代码，后续持续更新。PHP对lambda的支持$i = 12;
$j = 33;
$callable = function()use($i, &$j)
{echo$i . "\n";echo$j . "\n";
};$callable();$i++;
$j++;$callable();
必须显式引用外部变量，区分值和引用传递。C++对lambda的支持#include usingnamespacestd;int main(int argc, ...
c++ lambda function【代码】
1.概述
考虑最简单的lambda function , [](){},它没有参数也没有返回值。
[]里面用来捕获函数外部的变量，而()里面就是匿名函数的参数，{}里面就是函数的执行代码。
One easy example:
#include <iostream>  
using namespace std;  
int main()  
{  auto func = [] () { cout << "Hello world"; };  //定义了一个lambda funcitonfunc(); // now call the function  
}2. lambda 表达式
形如: [capture](parameters)->return-type...
c++ Lambda表达式中捕获[a=b]的情况【代码】
https://blog.csdn.net/gongjianbo1992/article/details/105128849 捕获列表中=表示值捕获，但是如果是[a=b]则应理解为，先执行a=b 的赋值，然后捕获a
#include <iostream>
using namespace std;
int main()
{   int a=10;int b=5;auto cwd=[a=b](){int b=7;cout<<"a="<<a<<"     b="<<b<<endl;        return a+b;};cout<<cwd()<<endl;
}[Running] cd "/home/cwd/code/" && g++ test.cpp -o test && "/home/cwd/code/"test
a=5   ...
C++11之lambda回调设置与应用【代码】【图】
在程序中有时候我们需要实现回调效果，比如先设置监听，然后在后面具体执行完某个操作后再将该操作的结果通知给前面监听中。这种机制实际很常用，比如window底下的消息机制，Qt中的信号槽的机制都有类似的效果。但是在C++中并没有类似机制，那么我们应如何实现呢？
       实际上在C++中我们可以使用模板、函数指针、抽象类、和lambda就可实现回调的效果，本文重点讲解如何使用lambda和function在同步线程中实现回调的效果。关于la...


    


    
        C++ - 技术教程分类
        
            
                    
                        C++ 教程
                                        
                        C++ 简介
                                        
                        C++ 基本语法
                                        
                        C++ 注释
                                        
                        C++ 数据类型
                                        
                        C++ 变量类型
                                        
                        C++ 变量作用域
                                        
                        C++ 常量
                                        
                        C++ 修饰符类型
                                        
                        C++ 存储类
                                        
                        C++ 运算符
                                        
                        C++ 循环
                                        
                        C++ 判断
                                        
                        C++ 函数
                                        
                        C++ 数字
                                        
                        C++ 数组
                                        
                        C++ 字符串
                                        
                        C++ 指针
                                        
                        C++ 引用
                                        
                        C++ 日期 & 时间
                                        
                        C++ 基本的输入输出
                                        
                        C++ 数据结构
                                        
                        C++ 类 & 对象
                                        
                        C++ 继承
                                        
                        C++ 重载运算符和重载函数
                                        
                        C++ 多态
                                        
                        C++ 数据抽象
                                        
                        C++ 数据封装
                                        
                        C++ 接口（抽象类）
                                        
                        C++ 文件和流
                                        
                        C++ 异常处理
                                        
                        C++ 动态内存
                                        
                        C++ 命名空间
                                        
                        C++ 模板
                                        
                        C++ 预处理器
                                        
                        C++ 信号处理
                                        
                        C++ 多线程
                                        
                        C++ Web 编程
                                        
                        C++ 标准库
                                        
                        C++ 有用的资源
                                        
                        C++ 实例
                                    
                    c++ 全部
                
            
        
    



    
        C++ - 最新教程
    
C++ 编译器的安装（MinGW）C++图像识别转灰度c++的强制类型转换C++智能指针C/C++算法竞赛入门经典Page15 习题1-1 ...C++中vector小学习，顺便查了下<stdio....LeetCode面试题 08.12. 八皇后---回溯算...C++中的异常安全性【转】c++ primer 5th 练习3.43C++类型转换运算符 static_cast，dynam...



    C++ - 最热教程
    C++通过共享内存实现进程间通信（windo...C++基于EasyX制作贪吃蛇游戏（一）文档C++中的分治算法及常见题目汇总【C++】stringstream的str() 和 string...c++中内置函数qsort（快速排序）和bsea...VS2019 C++创建一个简单项目demo[C++]VS2015用动态链接(MD/MDd)方式编译...C/C++编程学习 - 第15周 ⑥ 药房管理万维考试系统检测不到VC++ 6.0环境解决...C/C++ QT自定义对话框与MID窗体