However for those of you that don't know the basics of the new standard yet, auto is a new variable that works like this:
// Hooded.cpp : Defines the entry point for the console application.
int _tmain(int argc, _TCHAR* argv)
auto Compiler_Determines_This_Is_An_Int = 5;
auto Compiler_Determines_This_Is_An_String = "I Am A Auto-String";
auto Compiler_Determines_This_Is_A_Float = 3.14;
auto Compiler_Determines_This_Is_A_Char = 'C';
auto Compiler_Determines_This_Is_A_Boolean = true;
std::cout << Compiler_Determines_This_Is_An_Int << std::endl;
std::cout << Compiler_Determines_This_Is_An_String << std::endl;
std::cout << Compiler_Determines_This_Is_A_Float << std::endl;
std::cout << Compiler_Determines_This_Is_A_Char << std::endl;
std::cout << Compiler_Determines_This_Is_A_Boolean << std::endl;
I Am A Auto-String
Press any key to continue . . .
I can't believe it! It's the equivalent of a "var" in other, newer programming languages! It's perfect!
So, what just happened? The compiler used the values I initialized the variables with too set their type. Essentially, an auto variable that's type can be determined by the compiler.
There are some rules, however:
- Auto variables have to be initialized to a value when they're created.
- Auto variables can't have their types changed after initialization.
There are many uses for this in advanced and generic programming, however I'm going to talk about it's use for the beginning C++ programmer.
First off, I believe that using this for generic programming is fine, as clarified by Aardvajk.
The problem arises when beginning programmers want to be lazy and use these for everything. That is bad programming practice, and a lazy work ethic. You should know the types of your variables in your program, and using the auto variable because you don't want to memorize the names of the basic types defeats the purpose.
Now, where can I see myself using this variable? When I don't know the type of a variable I'm receiving. This generally doesn't happen very often unless you're dealing with generic programming, in which using this value is perfectly fine.
I also believe auto variables could be very confusing. If someone defines all their variables as auto variables, than I'll have no idea what the type of each variable is. This is especially noticeable in classes with an auto variable in them. If the variable is initialized in the constructor of the class, then I'd have to hunt through your code to find the type. This can be overcome by leaving a comment telling me what type the auto variable is, however that seem to defeat the purpose.
I hope you enjoyed my (now corrected) blog post. Cheers !