为什么通用 lambda 不能调用自己，但将它包装在一个类中允许它？

Question

这是完整的例子：

auto callSelf = [](auto& func) {func(func);};

class wrapper : public decltype(callSelf) {
    using base = decltype(callSelf);
public:
    wrapper() : base(callSelf) {}

    template<class T>
    void operator()(T& func) {
        base::operator()(func);
    }
};

int main()
{
    //callSelf(callSelf); // Error
    wrapper w;
    w(w); // OK, nice endless recursion
}

为什么用wrapper可以，而直接做会导致如下错误？

main.cpp:30: error: use of '<lambda(auto:1&)> [with auto:1 = <lambda(auto:1&)>]' before deduction of 'auto'
 auto callSelf = [&](auto& func) {func(func);};
                                  ~~~~^~~~~~

Answer 1

这实际上相当棘手。您违反的规则在 [dcl.spec.auto] 中：

如果需要使用具有未推导占位符类型的实体类型来确定表达式的类型，则程序格式错误。

这就是这里的问题：

auto callSelf = [](auto& func) {func(func);};
callSelf(callSelf);

我们需要知道callSelf 的类型来确定func(func) 的表达式的类型，它本身就是循环的。这很容易通过简单地指定返回类型来解决：

auto callSelf = [](auto& func) -> void {func(func);};
callSelf(callSelf); // ok. I mean, infinite recursion, but otherwise ok. ish.

但是，当您包装 lambda 时，您会得到不同的行为。这一行在这里：

w(w);

将wrapper 类型的对象有效地传递给lambda。那不是它自己的类型。 lambda 的主体在其自身上调用该对象，但我们知道该表达式的类型。你声明了它：

template<class T>
void operator()(T& func) {
~~~~~

这个函数与void一起工作（对于工作的一些定义）与我们添加-> void时lambda工作的原因相同。它不再是一个未推断的占位符。我们已经知道返回类型。要获得与 lambda 相同的行为，请将 operator() 的声明更改为 auto。

Answer 2

在您的情况下，只需定义返回类型并且编译器应该接受它：

auto callSelf = [](auto& func) -> void {func(func);};

class wrapper : public decltype(callSelf) {
    using base = decltype(callSelf);
public:
    wrapper() : base(callSelf) {}

    template<class T>
    void operator()(T& func) {
        base::operator()(func);
    }
};

int main()
{
    callSelf(callSelf); //works
    wrapper w;
    w(w); //ok, nice endless recursion
}

使用返回类型推导，编译器不能在 lambda 本身中使用 lambda，因为编译器必须查看函数体才能推导返回类型。编译器必须检查函数体的事实使它可以看到使用 lambda 本身的 lambda 的内容。由于编译器在推演过程中，不能使用lambda，所以编译出错。