无论谁说这个问题是问题“Is there a specific reason why a trailing-return-type is not a complete-class context of a class?”的重复，都不知道他/她在说什么。尾随返回类型不是类的完整类上下文这一事实不解释了为什么这个问题中的代码无法编译，尽管它解释了答案中给出的代码被拒绝的原因对于另一个问题，特别是涉及成员函数 qux 和 baz 的代码部分，正如 OP 所解释的那样。

为了阐明我认为下面的代码有效的论点，您必须考虑 the second note在 [expr.prim.this] 中说: 在尾随返回类型中，为了类成员访问的目的，被定义的类不需要是完整的。后面声明的类成员是不可见的。 因为在我的示例中 foo 是在 bar 之前声明的，所以没有什么可以阻止编译器访问 foo 在 bar 的 trailing-return-type 中。

注意the comment below @NathanOliver 是基于这样的猜想，即下面的成员函数 foo 的内联定义只是语法糖。这需要从标准中的引用中得到证明。 我还没有找到。一旦产生该引用，我肯定会接受一个答案，即代码无法编译，因为尾随返回类型不是类的完整类上下文。

struct Test {
        auto foo() {}                       
        auto bar() -> decltype(foo()) {}
    };

prog.cc:3:32: error: use of 'auto Test::foo()' before deduction of 'auto'
    3 |     auto bar() -> decltype(foo()) {}
      |                                ^
prog.cc:3:32: error: use of 'auto Test::foo()' before deduction of 'auto'

[dcl.spec.auto]/9 :

If a function with a declared return type that uses a placeholder type has no non-discarded return statements, the return type is deduced as though from a return statement with no operand at the closing brace of the function body. [ Example:

auto f() { } // OK, return type is void

auto* g() { } // error, cannot deduce auto* from void()

— end example ]

[dcl.type.auto.deduct]/(2.1) :

A type T containing a placeholder type, and a corresponding initializer e, are determined as follows:

(2.1) for a non-discarded return statement that occurs in a function declared with a return type that contains a placeholder type, T is the declared return type and e is the operand of the return statement. If the return statement has no operand, then e is void();

(2.2) for a variable declared with a type that contains a placeholder type, T is the declared type of the variable and e is the initializer. If the initialization is direct-list-initialization, the initializer shall be a braced-init-list containing only a single assignment-expression and e is the assignment-expression;

(2.3) for a non-type template parameter declared with a type that contains a placeholder type, T is the declared type of the non-type template parameter and e is the corresponding template argument.

根据 [dcl.spec.auto]/9 和 [dcl.type.auto.deduct]/(2.1) 代码应该编译。但是GCC克兰德拒绝它。我错过了什么？

最佳答案

struct Test
{
    auto foo() { /*1*/ }                       
    auto bar() -> decltype(foo()) {}
};

在标记 1 处，名称 Test::bar 与 struct Test 的所有其他成员一起在范围内。因此，在类完成之前，编译器无法分析 foo() 的主体。

然后我们有部分排序:

• 在推导其返回类型之前解析 Test::foo() 的主体
• 在解析 Test::foo() 的主体之前完成类 Test
• 在完成 Test 类(class)之前分析 Test::bar() 的尾随返回类型(根据您保证不是骗子的问题)

并且通过传递性，必须分析 Test::bar() 的返回类型，而无需为 Test::foo() 执行返回类型推导。

由于请求了标准报价，这里是来自[class.mem]:

A class is considered a completely-defined object type (or complete type) at the closing } of the class-specifier. Within the class member-specification, the class is regarded as complete within function bodies, default arguments, noexcept-specifiers, and default member initializers (including such things in nested classes). Otherwise it is regarded as incomplete within its own class member-specification.

关于c++ - 在另一个成员函数的尾随返回类型中获取推导成员函数的 decltype 是否格式正确？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/54795238/