与类型同名的类型别名

Question

Is it valid C++?

#include <iostream>


class Test {

    struct Inner {
    };

public:
    using Inner = struct Inner;  // Alias with same name as type
};

int main(int argc, const char * argv[]) {
    static_assert(std::is_pod<Test::Inner>::value, "");
    
    return 0;
}

Compile fine with clang but not with GCC / Visual C++ ("Inner is private..." error message)

Answer 1

GCC and Visual C++ are correct.

Indeed you can use using to in effect change the access of a member, eg

using Inner_ = Inner;

with

static_assert(std::is_pod<Test::Inner_>::value, "");

in the function.

But in the case where the type alias has the same name as the member, C++ requires that the scope resolution operator looks up the member. So in your case Test::Inner refers to the actual member rather than to the using and compilation should therefore fail as it's private .

---

See https://en.cppreference.com/w/cpp/language/qualified_lookup , and in particular

Qualified lookup within the scope of a namespace N first considers all declarations that are located in N and all declarations that are located in the inline namespace members of N (and, transitively, in their inline namespace members). If there are no declarations in that set then it considers declarations in all namespaces named by using-directives found in N and in all transitive inline namespace members of N

Answer 2

P1787R6: Declarations and where to find them , merged into C++23 draft, seems to favor Clang's behavior:

[basic.lookup]

In certain contexts, only certain kinds of declarations are included. After any such restriction, any declarations of classes or enumerations are discarded if any other declarations are found . [Note: A type (but not a typedef-name or template) is therefore hidden by any other entity in its scope. — end note] However, if a lookup is type-only , only declarations of types and templates whose specializations are types are considered; furthermore, if declarations of a typedef-name and of the type to which it refers are found, the declaration of the typedef-name is discarded instead of the type declaration.

So the declaration of struct Inner is discarded, because the alias-declaration is found. (One can put Inner into type-only context — Test::struct Inner — and it will refer to the struct Inner declaration, per the second part of the paragraph).