重复实现 lambda 函数

Question

我想知道我的编译器对以下代码做了什么

void design_grid::design_valid()
{
    auto valid_idx = [this]() {
        if ((row_num < 0) || (col_num < 0))
        {
            return false;
        }
        if ((row_num >= this->num_rows) || (col_num >= this->num_rows))
        {
            return false;
        }
        return true;

    }

    /* some code that calls lambda function valid_idx() */
}

如果我反复调用上面的类成员函数（design_grid::design_valid），那么当我的程序每次遇到valid_idx的创建时究竟会发生什么？编译器是否在编译时将稍后调用的代码内联，以便在遇到 valid_idx 的创建时实际上不执行任何操作？

更新

下面是一段汇编代码。如果这有点太阅读了，我稍后会发布另一批彩色代码，以说明哪些部分是哪些部分。 （目前没有一个很好的方法来和我一起为代码段着色）。另请注意，我已经更新了我的成员函数和上面的 lambda 函数的定义，以反映它在我的代码中的真正名称（因此，在汇编语言中）。

无论如何，似乎 lambda 是与主函数分开定义的。 lambda 函数由下面的_ZZN11design_grid12design_validEvENKUliiE_clEii 函数表示。在此函数的正下方，依次启动由_ZN11design_grid12design_validEv 表示的外部函数（design_grid::design_valid）。稍后在_ZN11design_grid12design_validEv 中，调用_ZZN11design_grid12design_validEvENKUliiE_clEii。进行调用的这一行看起来像

call    _ZZN11design_grid12design_validEvENKUliiE_clEii #

如果我错了，请纠正我，但这意味着编译器将 lambda 定义为 design_valid 函数之外的普通函数，然后在应该的时候将其作为普通函数调用？也就是说，它不是每次遇到声明lambda函数的语句时都创建一个新对象吗？我可以在该特定位置看到的 lambda 函数的唯一跟踪是在第二个函数中注释为 # tmp85, valid_idx.__this 的行中，就在函数开始时重新调整基指针和堆栈指针之后，但这只是一个简单的movq 操作。

.type   _ZZN11design_grid12design_validEvENKUliiE_clEii, @function
_ZZN11design_grid12design_validEvENKUliiE_clEii:
.LFB4029:
.cfi_startproc
pushq   %rbp    #
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq    %rsp, %rbp  #,
.cfi_def_cfa_register 6
movq    %rdi, -8(%rbp)  # __closure, __closure
movl    %esi, -12(%rbp) # row_num, row_num
movl    %edx, -16(%rbp) # col_num, col_num
cmpl    $0, -12(%rbp)   #, row_num
js  .L107   #,
cmpl    $0, -16(%rbp)   #, col_num
jns .L108   #,
.L107:
movl    $0, %eax    #, D.81546
jmp .L109   #
.L108:
movq    -8(%rbp), %rax  # __closure, tmp65
movq    (%rax), %rax    # __closure_4(D)->__this, D.81547
movl    68(%rax), %eax  # _5->D.69795.num_rows, D.81548
cmpl    -12(%rbp), %eax # row_num, D.81548
jle .L110   #,
movq    -8(%rbp), %rax  # __closure, tmp66
movq    (%rax), %rax    # __closure_4(D)->__this, D.81547
movl    68(%rax), %eax  # _7->D.69795.num_rows, D.81548
cmpl    -16(%rbp), %eax # col_num, D.81548
jg  .L111   #,
.L110:
movl    $0, %eax    #, D.81546
jmp .L109   #
.L111:
movl    $1, %eax    #, D.81546
.L109:
popq    %rbp    #
.cfi_def_cfa 7, 8
ret
.cfi_endproc
.LFE4029:
.size   _ZZN11design_grid12design_validEvENKUliiE_clEii,.-_ZZN11design_grid12design_validEvENKUliiE_clEii
.align 2


.globl  _ZN11design_grid12design_validEv
.type   _ZN11design_grid12design_validEv, @function
_ZN11design_grid12design_validEv:
.LFB4028:
.cfi_startproc
pushq   %rbp    #
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq    %rsp, %rbp  #,
.cfi_def_cfa_register 6
pushq   %rbx    #
subq    $72, %rsp   #,
.cfi_offset 3, -24
movq    %rdi, -72(%rbp) # this, this
movq    -72(%rbp), %rax # this, tmp85
movq    %rax, -32(%rbp) # tmp85, valid_idx.__this
movl    $0, -52(%rbp)   #, active_count
movl    $0, -48(%rbp)   #, row_num
jmp .L113   #
.L128:
movl    $0, -44(%rbp)   #, col_num
jmp .L114   #
.L127:
movl    -44(%rbp), %eax # col_num, tmp86
movslq  %eax, %rbx  # tmp86, D.81551

Answer 1

闭包 (unnamed function objects) 对于 lambdas 就像对象对于类一样。这意味着闭包 lambda_func 是从 lambda 重复创建的：

[this]() {
        /* some code here */
    }

就像一个对象可以从一个类中重复创建一样。当然编译器可以optimize 一些步骤。

至于这部分问题：

编译器是否在编译时内联稍后调用它的代码 时间，因此它实际上并没有在创建的地方做任何事情 遇到lambda_func？

见：

• are lambda functions in c++ inline? 和
• Why can lambdas be better optimized by the compiler than plain functions?。

这是一个测试可能发生的情况的示例程序：

#include <iostream>
#include <random>
#include <algorithm>

class ClassA {
public:
    void repeatedly_called();

private:
    std::random_device rd{};
    std::mt19937 mt{rd()};
    std::uniform_int_distribution<> ud{0,10};
};


void ClassA::repeatedly_called()
{
    auto lambda_func = [this]() {
        /* some code here */
        return ud(mt);
    };

    /* some code that calls lambda_func() */
    std::cout << lambda_func()*lambda_func() << '\n';

};


int main()
{
    ClassA class_a{};
    for(size_t i{0}; i < 100; ++i) {
        class_a.repeatedly_called();
    }
    return 0;
}

经过测试here。

我们可以看到，在这种特殊情况下，函数 repeatedly_called 不会调用已内联的 lambda（生成随机数）：

在问题的更新中，似乎没有内联 lambda 指令。从理论上讲，闭包是创建的，通常这意味着一些内存分配，但是编译器可能会优化并删除一些步骤。

仅捕获this，lambda 类似于成员函数。

Answer 2

基本上发生的情况是编译器使用函数调用运算符创建了一个未命名的类，将捕获的变量作为成员变量存储在类中。然后编译器使用这个未命名的类来创建一个对象，也就是你的lambda_func 变量。