Why do I need to explicitly write the 'auto' keyword?

Question

I am moving towards C++11 from C++98 and have become familiar with the auto keyword. I was wondering why we need to explicitly declare auto if the compiler is able to automatically deduce the type. I know C++ is a strongly typed language and this is a rule but was it not possible to achieve the same outcome without explicitly declaring a variable auto?

Answer 1

Dropping the explicit auto would break the language:

e.g.

int main() {     int n;     {         auto n = 0; // this shadows the outer n.     } } 

where you can see that dropping the auto would not shadow the outer n.

Answer 2

Your question allows two interpretations:

• Why do we need 'auto' at all? Can't we simply drop it?
• Why are we obliged to use auto? Can't we just have it implicit, if it is not given?

Bathsheba answered nicely the first interpretation, for the second, consider the following (assuming no other declarations exist so far; hypothetically valid C++):

int f(); double g();  n = f(); // declares a new variable, type is int; d = g(); // another new variable, type is double  if(n == d) {     n = 7; // reassigns n     auto d = 2.0; // new d, shadowing the outer one } 

It would be possible, other languages get away quite well with (well, apart from the shadowing issue perhaps)... It is not so in C++, though, and the question (in the sense of the second interpretation) now is: Why?

This time, the answer is not as evident as in the first interpretation. One thing is obvious, though: The explicit requirement for the keyword makes the language safer (I do not know if this is what drove the language committee to its decision, still it remains a point):

grummel = f();  // ...  if(true) {     brummel = f();   //^ uh, oh, a typo... } 

Can we agree on this not needing any further explanations?

The even bigger danger in not requiring auto, [however], is that it means that adding a global variable in a place far away from a function (e.g. in a header file) can turn what was intended to be the declaration of a locally-scoped variable in that function into an assignment to the global variable... with potentially disastrous (and certainly very confusing) consequences.

_{(cited psmears' comment due to its importance - thanks for hinting to)}