Point of declaration for auto keyword

Question

I had a Q&A before: Point of declaration in C++. The rule point-of-declaration nicely is applicable on many situations. Now, I confused on usage of auto in combination of this rule.

Consider these two codes:

i. Declaring x by itself (we don't expect it to work):

{
  auto x = x;
}

ii. Declaring the inner x by the outer x (It makes error in gcc 4.8.x):

{
  int x = 101; // the outer x
  {
    auto x = x; // the inner x
  }
}

According to the rule of point-of-declaration, it should work but it doesn't. It seems there is another rule in the standard that I missed it. The question is, Where is the point-of-declaration when using auto?

 

There are two possibilities:

i. If the point of declaration is after =, at the end of statement:

auto object = expression;
                        ^
                        Is it here? If it is, why gcc complains?

So the second declaration is valid and must work, because there is no x but that outer one (which is declared before). Therefore auto x=x is valid and the inner x should be assigned to 101.

 

ii. If the point of declaration is before = :

auto object = expression;
           ^

Well, it doesn't make any sense because auto has to wait until see the following expression. For example auto x; is invalid.

---

Update: I need an answer which explains it by the rule point of declaration.

Answer 1

auto x = x; // inner x

is ill-formed.

To quote from the C++11 standard (emphasis mine):

7.1.6.4 auto specifier

...

³ Otherwise, the type of the variable is deduced from its initializer. The name of the variable being declared shall not appear in the initializer expression. ...

And so because x after = resolves to the x in auto x (as explained in the question you linked), that above piece of code is ill-formed.

Answer 2

Just like in any other kind of definition, the x on the right-hand side of the initialiser for auto x = x resolves to the local auto x. C++ has always done this (i.e. int x = x compiles but will give you undefined behaviour).

The reason auto x = x fails to compile is because while x is in scope it has no known type yet, and so using it as the initialiser fails because the type can't be deduced from the expression.

Just like any other kind of declaration, x is in scope after its declarator which is auto x.

int x = 10;
int y = 20;
{
    int x = x;  // This is NOT the outer x. This is undefined behaviour (reading an
                // uninitialised variable).
    auto y = y; // This is NOT the outer y. This is a compile error because the type of
                // y is not known.
}

Answer 3

Just adding an example with more explicit diagnostics:

auto ll = [&] { ll(); };

Results in (gcc):

error: variable ‘auto ll’ with ‘auto’ type used in its own initializer

or (clang):

error: variable 'll' declared with 'auto' type cannot appear in its own initializer
    auto ll = [&] { ll(); };
                    ^

You can see that there is an explicit rule for this. I haven't looked at the specs.

Answer 4

The compiler reads a whole statement (from the beginning of a line until the next semi-colon) and then evaluates the different parts of a statement using priorities of operations, and then when the time comes when the value of auto x is to be assigned, the type that came up after th = sign gets taken.

For example:

template <typename T>
T sum(T a, T b)
{
    return a+b;
}

int main()
{
    auto x = sum<double>(1,5); // x here is a double, because the return value is double
    auto y = sum<int>(1,7); //y is an int, because the return value is int
}

And about your auto x = x, you're redefining the same variable name. That's invalid! auto y = x shall work.