I was recently wondering why the keyword auto was chosen in C++11 to mark a variable whose type must be inferred by the compiler, like inauto x = 1;Sincevar seems more common in other programming languages (e.g. C#, Scala, JavaScript), andAs far as I understand the new semantics of auto breaks backward compatibility (it was rarely used but had a different meaning in previous revisions of C++, see e.g. here)I wanted to ask if there was a special reason for choosing auto (in favour of var or any other keyword). Was there any specific discussion about this issue before the C++11 standard was released?Also, are there any possible incompatibilities we should watch out for when recompiling legacy C++ code with a C++11 compiler?
Motivation and pitfalls (?) of the auto keyword in C++11
c++;c++11;type systems
Almost every word you might think of adding as a keyword to a language has almost certainly been used as a variable name or some other part of working code. This code would be broken if you made that word a keyword.The incredibly lucky thing about auto is that it already was a keyword, so people didn't have variables with that name, but nobody used it, because it was the default. Why type:auto int i=0;when int i=0;meant exactly the same thing?I suppose somewhere on the planet there was some small amount of code that used 'auto' the old way. But it could be fixed by removing the 'auto' and it would be working again. So it was a pretty obvious choice to repurpose the keyword. I also happen to think it's a clearer meaning. If you've worked with variants and such, when you see var you may think that the declaration is somehow less strongly typed than if you pressed all the keys yourself on the keyboard to specify the type of the variable. To me, auto makes it clearer that you're asking the compiler to automatically deduce the type, which is just as strong as if you had specified it yourself. So it really was a very lucky break that made a good name available to the committee.To clarify the (small) breaking:If you had auto int i=0;and tried to compile with a C++ 11 compiler, you will now get an error such aserror C3530: 'auto' cannot be combined with any other type-specifierThis is trivial, you just remove either the auto or the int and recompile.There is a bigger problem though. If you hadauto i = 4.3;C and the really old C++ would make i an int (as it would if you left off auto - default declaration was int). If you have gone a really long time without compiling this code, or have been using old compilers, you could have some of this code, at least in theory. C++ 11 would make it a double since that's what 4.3 is. (Or maybe a float, I'm still in Boxing Day mode, but the point is, not an int.) This might introduce subtle bugs throughout your app. And without any warnings or errors from the compiler. People in this boat should search globablly for auto to make sure they weren't using it the old way before they move to a C++ 11 compiler. Luckily, such code is extremely rare.