When should I use auto in C++?

The auto keyword in C++ is used for type deduction. When you use auto, the compiler infers the type of the variable from its initializer. This can be convenient and can make your code more readable in certain situations:

Example 1: When the type is long or complicated, especially when using templates:

1std::map<std::string,
2  std::vector<int>> my_map{GetMap()};
3// vs
4auto my_map{GetMap()};

Example 2: When the exact type isn't important for understanding the code:

1// If we only care that result is,
2// say, a number, auto is fine
3auto result = some_complex_function();

Example 3: With iterators, where the exact type can be verbose:

1for (std::vector<int>::const_iterator it =
2  vec.begin(); it != vec.end(); ++it) {
3  // ...
4}
5
6// vs
7
8for (auto it = vec.begin();
9  it != vec.end(); ++it) {
10  // ...
11}

However, there are also situations where using auto can make your code less readable or even cause bugs:

Example 1: When the type is not immediately clear from the context:

1// Is this an int? A long?
2// Unclear without more context.
3auto x = 5;

Example 2: When you need to be explicit about type conversions:

1// The cast is hidden
2auto result = static_cast<int>(some_float);

Example 3: When you want to commit to a specific type:

1// i is an int
2auto i = 5;
3
4// j is a long, which might not be what you want
5auto j = 5L;

As a rule of thumb, use auto when it makes your code more readable by avoiding long type names or when the exact type isn't important. But prefer explicit types when the type is not immediately clear, when type conversions are involved, or when you want to commit to a specific type.