C++ 编译器内联函数局部 lambda 的效率如何？

Question

背景

作为一种组织策略，我喜欢在复杂函数中定义函数局部 lambda。它适用于封装多步逻辑、重复操作等（函数通常适用于这类事情），但不会创建在其使用范围之外可见的内容。它是 John Carmack 在他的 essay on the merits of inlining code 中提出的样式的一种综合 of/alternative，因为它将所有内容整齐地封装在它打算使用的函数中，同时还提供了（编译器可识别的）名称来记录每个功能块。一个简单的、人为的例子可能看起来像这样（假装这里实际上发生了一些足够复杂的事情，值得使用这种风格）：

void printSomeNumbers(void)
{
  const auto printNumber = [](auto number) {
    std::cout << number << std::endl; // Non-trivial logic (maybe formatting) would go here
  };

  printNumber(1);
  printNumber(2.0);
}

从语义上讲，此函数的编译形式是 'supposed' 来创建一个隐式定义的仿函数的实例，然后为每个提供的输入对该仿函数调用 operator()()，因为那是在 C++ 中使用 lambda 意味着什么。但是，在优化的构建中，as-if rule frees the compiler up to inline some stuff, meaning that the actual generated code is probably going to just inline the contents of the lambda and skip defining/instantiating the functor entirely. Discussions of this sort of inlining have come up in past discussions here and here，以及其他地方。

问题

在我找到的所有 lambda 内联问题和答案中，所提供的示例都没有使用任何形式的 lambda capture，而且它们在很大程度上也与将 lambda 作为参数传递给某事（即在 std::for_each 调用的上下文中内联 lambda）。那么，我的问题是：编译器是否仍然可以内联捕获值的 lambda？ 更具体地说（因为我假设各种变量的生命周期涉及到答案的因素相当一点），编译器是否可以合理地内联一个仅在定义它的函数内部使用的 lambda，即使它通过引用捕获了一些东西（即局部变量）？

我的直觉是内联应该是可能的，因为编译器对所有代码和相关变量（包括它们相对于 lambda 的生命周期）具有完全可见性，但我并不肯定，我的汇编-阅读技巧还不够好，无法为自己找到可靠的答案。

附加示例

以防万一我描述的具体用例不是很清楚，这里是上面 lambda 的修改版本，它使用了我正在描述的那种模式（同样，请忽略这个事实代码是人为的并且不必要地过于复杂）：

void printSomeNumbers(void)
{
  std::ostringstream ss;
  const auto appendNumber = [&ss](auto number) {
    ss << number << std::endl; // Pretend this is something non-trivial
  };

  appendNumber(1);
  appendNumber(2.0);

  std::cout << ss.str();
}

我希望优化编译器应该有足够的信息来完全内联所有 lambda 用法，并且不会在此处生成（或至少不保留）任何仿函数，即使它正在使用按引用捕获的变量'should' 被视为某些自动生成的闭包类型的成员。

Answer 1

是的。

现代编译器使用 "static single assignment" (SSA) 作为优化过程。

每次您分配一个值或修改它时，都会创建一个概念上不同的值。有时这些概念上不同的值共享同一性（出于指向指针的目的）。

身份，当你获取某物的地址时，就是阻碍这一点的东西。

简单的引用变成了它们引用的值的别名；他们没有身份。这是引用的原始设计意图的一部分，也是您不能拥有指向引用的指针的原因。

具体来说：

std::string printSomeNumbers(void)
{
  std::ostringstream ss;
  const auto appendNumber = [&ss](auto number) {
    ss << number << "\n"; // Pretend this is something non-trivial
  };

  printf("hello\n");
  appendNumber(1);
  printf("world\n");
  appendNumber(2.0);
  printf("today\n");

  return ss.str();
}

编译为：

printSomeNumbers[abi:cxx11]():           # @printSomeNumbers[abi:cxx11]()
        push    r14
        push    rbx
        sub     rsp, 376
        mov     r14, rdi
        mov     rbx, rsp
        mov     rdi, rbx
        mov     esi, 16
        call    std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >::basic_ostringstream(std::_Ios_Openmode)
        mov     edi, offset .Lstr
        call    puts
        mov     rdi, rbx
        mov     esi, 1
        call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
        mov     esi, offset .L.str.3
        mov     edx, 1
        mov     rdi, rax
        call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
        mov     edi, offset .Lstr.8
        call    puts
        mov     rdi, rsp
        movsd   xmm0, qword ptr [rip + .LCPI0_0] # xmm0 = mem[0],zero
        call    std::basic_ostream<char, std::char_traits<char> >& std::basic_ostream<char, std::char_traits<char> >::_M_insert<double>(double)
        mov     esi, offset .L.str.3
        mov     edx, 1
        mov     rdi, rax
        call    std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long)
        mov     edi, offset .Lstr.9
        call    puts
        lea     rsi, [rsp + 8]
        mov     rdi, r14
        call    std::__cxx11::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >::str() const
        mov     rax, qword ptr [rip + VTT for std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >]
        mov     qword ptr [rsp], rax
        mov     rcx, qword ptr [rip + VTT for std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >+24]
        mov     rax, qword ptr [rax - 24]
        mov     qword ptr [rsp + rax], rcx
        mov     qword ptr [rsp + 8], offset vtable for std::__cxx11::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >+16
        mov     rdi, qword ptr [rsp + 80]
        lea     rax, [rsp + 96]
        cmp     rdi, rax
        je      .LBB0_7
        call    operator delete(void*)
.LBB0_7:
        mov     qword ptr [rsp + 8], offset vtable for std::basic_streambuf<char, std::char_traits<char> >+16
        lea     rdi, [rsp + 64]
        call    std::locale::~locale() [complete object destructor]
        lea     rdi, [rsp + 112]
        call    std::ios_base::~ios_base() [base object destructor]
        mov     rax, r14
        add     rsp, 376
        pop     rbx
        pop     r14
        ret

Godbolt

请注意，在 printf 调用之间（在程序集中它们是 puts），除了直接调用 ostringstream 的 operator<< 之外没有其他调用。

C++ 编译器内联函数局部 lambda 的效率如何？

How effectively can function-local lambdas be inlined by C++ compilers?

c++

lambda

compiler-optimization

c++17