2.9 KiB
title |
---|
The Auto Feature |
The Auto Feature
auto
is a C++11 feature that lets the compiler infer the data type for you in a definition. This can save you a lot of typing, especially with complicated types.
Without auto
:
double x = 10.425;
double y = x * x;
With auto
:
double x = 10.425;
auto y = x * x;
While it may seem trivial, it becomes incredibly useful when data types begin to get complicated. For example, assume you want to store a vector
of employees, and you are only interested in their name and age. One way to store the name and age could be a pair
with a string
and an unsigned int
. This is declared as std::vector<std::pair<std::string, unsigned int>> employees
. Now suppose you want to access the last employee added:
std::vector<std::pair<std::string, unsigned int>> employees;
// without auto, you have to write:
std::pair<std::string, unsigned int>> last_employee = employees.back();
// with auto, you just have to write:
auto last_employee = employees.back();
Once the compiler determines the type on the right side of the =
it replaces auto
with that type.
However,it should be noted that it is mandatory to intialize the variable marked as auto while declaring so that the compiler can know the type of that variable.
In modern versions of C++ (since C++14), auto
can also be used in a function declaration as the return type. The compiler will then infer the return type from the return statement inside of the function. Following the example with employees:
std::vector<std::pair<std::string, unsigned int>> employees;
auto get_last_employee() {
return employees.back(); // Compiler knows the return type from this line.
}
The compiler will know from the line with the return statement that the return type from the function should be std::vector<std::pair<std::string, unsigned int>>
.
While quite technical, the cppreference page on auto describes many more usages of auto
and the details of when it can and can't be used.
auto
before C++11
In some old textbooks containing very old code, the keyword auto
is used in a very different manner.
This particular auto
was a keyword borrowed from C, and was probably the least used keyword of all time.
In C++, all variables have automatic duration, that is, they are defined until you get out of the function they're defined in.
For example:
#include <iostream>
int main()
{
int a;
a = 1; //makes sense, as it was defined in the same function
return 0;
}
a = 2; //makes no sense, since a isn't defined here
This is a given in C++, and auto
specified that the variable should have an automatic duration, hence the lack of use.