可以捕获的实体的声明：它应该产生lambda之外的实体的类型吗？

Question

考虑以下简单的独立代码：

template<typename T>
void foo();

void bar() {
    int i;
    auto l = [&i]() -> decltype(auto) {
        decltype(auto) x = i;
        foo<decltype(x)>();
        foo<decltype(i)>();
        return static_cast<decltype(i)>(i);
    };
    l();
    foo<decltype(l())>();
}

GCC生成以下内容：

bar():
        sub     rsp, 8
        call    void foo<int&>()
        call    void foo<int>()
        add     rsp, 8
        jmp     void foo<int>()

Clang生成以下内容：

bar():                                # @bar()
        push    rax
        call    void foo<int>()
        call    void foo<int>()
        pop     rax
        jmp     void foo<int>()                     # TAILCALL

MSVC生成以下内容：

void bar(void) PROC                                        ; bar, COMDAT
$LN8:
        sub     rsp, 40                             ; 00000028H
        call    void foo<int &>(void)                  ; foo<int &>
        call    void foo<int &>(void)                  ; foo<int &>
        add     rsp, 40                             ; 00000028H
        jmp     void foo<int &>(void)                        ; foo<int &>
void bar(void) ENDP   

 

似乎所有三个编译器都不同意。哪一个是正确的，C ++标准的哪一部分证实了这一点？

在我看来， exltype（i）应始终是 int ，并且永远不要 int＆amp; ，无论是否被捕获。

义务编译器Explorer链接

Answer 1

exltype（auto）在 [dcl.type.auto.deduct]/4 ：

如果占位符 - 型特定器 是形式 type-constraint _opt ecltype（auto）， t 应独自成为占位符。按照 [dcl.type.decltype] ，好像 e 是 exltype 。。

的操作数

这意味着 code> nectType（auto）x = i 等效于 exltype（i）x = i 。关于 decltype（i），说明：

• 否则，如果 e 是无父母， id-xexpression 或无父母的类成员访问（ [expr.ref] ）， exltype（e）是 e 命名的实体的类型。如果没有这样的实体，则该程序是不形成的；

因此， exltype（i）是 i 命名的实体类型，即， int 。因此， x 是类型 int 的类型，因此， exltype（x）也是 int 。因此，在这种情况下，Clang是正确的。 GCC中的此错误已针对GCC 14（ patrick ）。

---

但是，似乎此修复会导致海湾合作委员会的另一个错误。如果我们将 i 的类型更改为 int＆amp; ，则以下代码演示了此问题（ godbolt ）：

template <typename T> void foo();
void bar(int &i) {
  auto l = [&i]() -> decltype(auto) {
    decltype(auto) x = i;
    foo<decltype(x)>(); // [Clang] int& [GCC 14] int  [GCC 13] int&
    foo<decltype(i)>(); // [Clang] int& [GCC 14] int& [GCC 13] int&
    return i;
  };
  l();
  foo<decltype(l())>(); // [Clang] int& [GCC 14] int  [GCC 13] int&
}

遵循与上述相同的推理，在这种情况下，Clang和GCC 13是正确的。