C++11 – Understanding Declaration Point for auto Keyword

c++c++11

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.

Best Answer

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.

Related Solutions

C++ Auto Declarations – Why Must ‘Auto’ Declarations Be of the Same Type in C++?

Type deduction is performed for every object in the list, but the final result must be a single type [dcl.spec.auto]/7 (emphasis mine):

If the list of declarators contains more than one declarator, the type of each declared variable is determined as described above. If the type deduced for the template parameter U is not the same in each deduction, the program is ill-formed.

C++ – Understanding the ‘auto’ Keyword

auto has a lot of uses when it comes down to both generic programming and to save the programmer some typing.

For example, consider this. Would you rather type out:

std::unique_ptr<name::long_type::goes_here> g = 
    std::make_unique<name::long_type::goes_here>(1,2,3,4)

or:

auto g = std::make_unique<name::long_type::goes_here>(1,2,3,4)

Yes, they're both long but we know the return type and specifying it again is a bit cumbersome to type. This also goes for iterators:

for(auto i = vec.begin(); ...)

vs:

for(std::vector<type>::iterator i = vev.begin(); ...)

Its use in generic programming is also to figure out the return type of a function or if you're doing some generic algorithms where you don't know the type.

For example, consider a very basic example.

template<typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

This allows the compiler to figure out the type of the add operation rather than us trying to figure it out ourselves. Note that in C++14 you can omit the trailing return type. Its uses in generic programming don't stop there either. If we wanted to work with any type of container as a wrapper function for algorithms we could use auto to help us with it. For example:

template<class Cont>
void my_sort(Cont&& cont) {
    using std::begin;
    auto first = begin(std::forward<Cont>(cont));
    // work with the iterators here
}

In the future (C++14), auto can be used to make polymorphic lambdas as well such as:

[](auto a) { return a + 4; }

Which can be useful as well.

Best Answer

7.1.6.4 auto specifier

Related Solutions

C++ Auto Declarations – Why Must ‘Auto’ Declarations Be of the Same Type in C++?

C++ – Understanding the ‘auto’ Keyword

Related Question