考虑简单的程序:

int i = 0;
int& j = i;

auto lambda = [=]{
    std::cout << &j << std::endl; //odr-use j
};

根据[expr.prim.lambda]，闭包成员变量j的类型应该是int:

An entity is captured by copy if it is implicitly captured and the capture-default is = or if it is explicitly captured with a capture that is not of the form & identifier or & identifier initializer. For each entity captured by copy, an unnamed non-static data member is declared in the closure type. The declaration order of these members is unspecified. The type of such a data member is the type of the corresponding captured entity if the entity is not a reference to an object, or the referenced type otherwise.

所以我正在打印的是一些与外部作用域i 或j 无关的int 的地址。这一切都很好。但是，当我输入 decltype 时:

auto lambda = [j] {
    std::cout << &j << std::endl;
    static_assert(std::is_same<decltype(j), int>::value, "!"); // error: !
};

编译失败，因为 decltype(j) 的计算结果为 int&。为什么？ j 在该范围内应该引用数据成员，不是吗？

作为相关后续行动，如果 lambda 捕获改为使用 [j=j]{...} 的init-capture，那么 clang 会将 decltype(j) 报告为 int 而不是 int&。为什么不同？

最佳答案

名称查找在 lambda 表达式中的工作方式有点特殊:id 表达式 引用实体通过复制捕获 从访问捕获的实体转换为访问闭包类型的存储数据成员——但前提是这些访问构成odr-uses。请注意，由于隐式捕获，如果没有 odr-use，则可能没有这样的数据成员。

decltype 不构成 odr-use，因此它将始终引用捕获的实体(原始)，而不是数据成员(拷贝)。

C++11 [expr.prim.lamba]p17

Every id-expression that is an odr-use of an entity captured by copy is transformed into an access to the corresponding unnamed data member of the closure type.

此外，p18 甚至在示例中显示了这种奇怪的效果:

Every occurrence of decltype((x)) where x is a possibly parenthesized id-expression that names an entity of automatic storage duration is treated as if x were transformed into an access to a corresponding data member of the closure type that would have been declared if x were an odr-use of the denoted entity. [ Example:

void f3() {
    float x, &r = x;
    [=] { // x and r are not captured (appearance in a decltype operand is not an odr-use)
        decltype(x) y1;        // y1 has type float
        decltype((x)) y2 = y1; // y2 has type float const& because this lambda
                               // is not mutable and x is an lvalue
        decltype(r) r1 = y1;   // r1 has type float& (transformation not considered)
        decltype((r)) r2 = y2; // r2 has type float const&
    };
}

— end example ]

C++14 init-captures 也被认为是复制捕获，因为 C++14 [expr.prim.lambda]p15

An entity is captured by copy if it is implicitly captured and the capture-default is = or if it is explicitly captured with a capture that is not of the form & identifier or & identifier initializer.

然而，作为T.C.已指出，它们不捕获已初始化的实体，而是捕获也用于类型推导的“虚拟变量” [expr.prim.lambda]p11

An init-capture behaves as if it declares and explicitly captures a variable of the form “auto init-capture ;” whose declarative region is the lambda-expression’s compound-statement [...]

类型推导改变了这个变量的类型，例如char const[N] -> char const*，原始实体甚至可能没有类型，例如[i = {1,2,3}]{}。

因此，lambda [j=j]{ decltype(j) x; 中的 id-expression j 指的是这个虚拟变量，它的类型是int，而不是int&。

关于c++ - 通过 copy 和 decltype 捕获 Lambda 引用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32894748/