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;
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 as
error C3530: 'auto' cannot be combined with any other type-specifier
This is trivial, you just remove either the auto or the int and recompile.
There is a bigger problem though. If you had
auto i = 4.3;
C and the really old C++ would make
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.