79 lines
3.0 KiB
Markdown
79 lines
3.0 KiB
Markdown
---
|
|
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`:
|
|
```cpp
|
|
double x = 10.425;
|
|
double y = x * x;
|
|
```
|
|
|
|
With `auto`:
|
|
```cpp
|
|
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`](https://guide.freecodecamp.org/cplusplus/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:
|
|
|
|
```cpp
|
|
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();
|
|
//if you want to output the "last_employee" variable you have to do it with a pointer
|
|
cout<<last_employee; //you will get an error to this
|
|
cout<<*last_employee; // this will run correctly
|
|
|
|
```
|
|
|
|
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](http://en.cppreference.com/w/cpp/language/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:
|
|
|
|
```cpp
|
|
#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.
|
|
|
|
## Further Reading :
|
|
* http://www.stroustrup.com/C++11FAQ.html#auto
|
|
|