Member's potential scope for struct vs namespace

Question

Referring to this code:

namespace Y {
  char f() { return y; } // error: y was not declared in this scope
  char y;
}

struct X {
  char  f() { return x; } // OK
  char  x;
};

As per basic.scope.namespace#1:

The declarative region of a namespace-definition is its namespace-body. Entities declared in a namespace-body are said to be members of the namespace, and names introduced by these declarations into the declarative region of the namespace are said to be member names of the namespace. Its potential scope includes its namespace from the name's point of declaration onwards.

QUESTIONS

1. Is it correct to say that the error was due to the fact that Y::y is not yet declared in Y::f()?

2. I can't figure why there isn't a "reodering" for namespace members during declaration while for struct there is. What could be the reason for disallowing such behavior? Does the standard says something similar?

Answer 1

Is it correct to say that the error was due to the fact that Y::y is not yet declared in Y::f()?

Yes.

I can't figure why there isn't a "reodering" for namespace members during declaration while for struct there is. What could be the reason for disallowing such behavior? Does the standard says something similar?

The biggest hindrance for namespaces as opposed to classes, is that they are never "closed". You can always add members to a namespace by re-opening it in another translation unit and declaring more stuff in it. A class declaration however, for all its members, must appear entirely in a single translation unit. And there is no adding to it later.

[class.mem]/1

The member-specification in a class definition declares the full set of members of the class; no member can be added elsewhere.

The problem for namespaces is intractable. But classes only require a little more, quite localized, work.

It is therefore much easier, both to a language designer and a compiler writer, to demand namespace declarations appear before they are used.

You should also note that you can only use other members of the class in only a specific set of places inside the definition.

[class.mem]/6

A class is considered a completely-defined object type ([basic.types]) (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.

Answer 2

You are mistaken thinking that for structures there is "reordering".

Consider the following structure definition.

#include <iostream>

struct A
{
    char s[N];
    enum { N = 10 };
};

int main() 
{
    return 0;
}

The compiler will issue an error because the name N is not yet declared when it is used in the array declaration. So neither "reordering" exists in the class scope. As for member functions then names used within a member function are at first searched in the class scope.

Moreover a name declared in a namespace can hide the same name declared in the outer namespace. As result the "reordering" breaks scopes of variables.