Why is the code "foo::foo::foo::foob" compiling?

Question

A co-worker accidentally wrote code like this:

struct foo {
  foo() : baz(foobar) {}
  enum bar {foobar, fbar, foob};
  bar baz;
};

void f() {
  for( auto x : { foo::foobar,
                  foo::fbar,
                  foo::
                  foo::
                  foo::foob } );
    // ...
}

GCC 5.1.0 compiles this.

What's the rule that makes this compile?

can you be a bit more specific regarding what part you don't expect to compile cleanly? — neuhaus, Oct 18 '17 at 08:08
There is a missing include file and the for loop is missing a statement but apart from that it compiles — Johan, Oct 18 '17 at 08:10
This can be simplified to `struct foo { static const int v{42}; }; auto x{foo::foo::foo::foo::foo::v};` — user7860670, Oct 18 '17 at 08:17
@sbi Which part makes you confusing? The injected class name? The range-based for loop? — songyuanyao, Oct 18 '17 at 08:27
@Johan Also, this compiler uses C++98 by default. Adding e.g. ``-std=c++11`` to the compiler options fixes this. — Arne Vogel, Oct 18 '17 at 16:29
Are you asking why `foo::foo::foo::foob` does not fail with postfixing the constructor by `::` or what is the exact expectation? — Johannes Schaub - litb, Oct 28 '17 at 20:27

songyuanyao · Accepted Answer · 2017-10-28T11:57:18.353

The injected-class-name is used here,

the name of the class within its own definition acts as a public member type alias of itself for the purpose of lookup (except when used to name a constructor): this is known as injected-class-name

then

foo::
foo::
foo::foob

i.e. foo::foo::foo::foob is same as foo::foob.

And then for (auto x : {foo::foobar, foo::fbar, foo::foob }) is a range-based for loop (since C++11), which iterates on the braced-init-list formed by the 3 enumerators.

Gor Asatryan · Answer 2 · 2017-10-30T12:41:03.910

I changed this code to this:

#include <initializer_list>
#include <iostream>
struct foo {
  foo() : baz(foobar) {}
  enum bar {foobar, fbar, foob};
  bar baz;
};

int main() {
  for( auto x : { foo::foobar,
                  foo::fbar,
                  foo::
                  foo::
                  foo::foob } )
                  {
                      std::cout << "x=" << x << std::endl;
                  }
  return 0;
}

for loop runs 3 times. output is: "x=1 x=2 x=3".

foo::foo::foo::foob is the same foo::foob. So

for( auto x : { foo::foobar,
                  foo::fbar,
                  foo::
                  foo::
                  foo::foob } )

is the same

for( auto x : { foo::foobar, foo::fbar, foo::foob } )
{
}

It means that x is in range { foo::foobar, foo::fbar, foo::foob }

Why is the code "foo::foo::foo::foob" compiling?

2 Answers2

Linked