为什么编译器在使用 decltype 时不推断成员的类型？ [复制]

Question

我只是在自己的代码中注意到了这种行为，所以这是一个幼稚的问题：

这个：

struct A
{
    int get()
    {
        return a;
    }
    int a=1;
};   
int main() {}

编译当然没问题，尽管成员数据的声明位于 函数定义之后。

但后来我不明白为什么会这样：

struct A
{
    auto get() -> decltype(a)
    {
        return a;
    }
    int a=1;
};  

不编译(*)。我必须这样写：

struct A
{
    int a=1;
    auto get() -> decltype(a)
    {
        return a;
    }
};  

是否有任何与语言相关的原因导致它不正常，或者仅仅是编译器没有实现它？无论班级成员的顺序如何，我都希望有相同的行为。

(*) 通过 Ideone.com 使用 gcc 6.3 测试

Answer 1

在您的第一个示例中，A::get 被声明，然后 A::a 被声明，然后（因为 A 被完全声明），A::get 被定义。此时，在A::get 中，编译器知道A::a。

考虑这个等价形式：

struct A
{
    int get();
    int a=1;
};

inline int A::get()
{
    return a;
}

第二个示例无法编译：

struct A
{
    auto get() -> decltype(a); // What is "a"?
    int a=1;
};

inline auto A::get() -> decltype(A::a)
{
    return a;
}

声明类型时必须遵守相同的“声明顺序”，例如：

struct A
{
    using IntType = int;
    auto get() -> IntType;
    int a=1;
};

你不能这样写：

struct A
{
    using IntType = decltype(a);
    auto get() -> IntType;
    int a=1;
};

还请注意，这不仅限于返回类型：参数类型也是函数声明的一部分。所以这也不能编译：

struct A
{
    void f(decltype(a));
    int a=1;
};

Answer 2

如果可以的话，一个非正式的回答：decltype 是一个红鲱鱼。

return 类型的所有部分都需要在第一次传递时已经被编译器看到。

例如，

template <size_t N> struct T{};

struct A
{
    T<sizeof(a)> get()
    {
        return T<sizeof(a)>();
    }
    int a;
};

也会失败，原因相同：如果在get() 之前看到int a;，则编译通过。

Answer 3

让我来解释一下为什么你想写的东西不能正常工作：

struct A {
    auto get() -> decltype(a)
    {
        return a;
    } 
    int a=1;
};

如果允许这样做，则要么需要超级复杂的规则，要么还允许以下规则，但实际上没有意义：

struct cyclic {
    auto a() -> decltype(b) {
        return ...;
    }
    auto b() -> decltype(a) { 
        return ...;
    }
};

我希望另一个答案会告诉您阻止编写类似内容的语言的确切规则。我试图给出一个动机，为什么我们不能写它实际上更好。