C++ offers two mechanisms for deducting types from an expression: auto and decltype(). auto is used to deduce a type from its initializer, while decltype() is used to deduce a type for more complex cases. This recipe will show examples of how to use both.

It might be handy (and it actually is) to avoid explicitly specifying the type of variable that will be used, especially when it is particularly long and used very locally:

1. Let's start with a typical example:

std::map<int, std::string> payslips;
// ... 
for (std::map<int, 
     std::string>::const_iterator iter = payslips.begin(); 
     iter !=payslips.end(); ++iter) 
{
 // ... 
}

2. Now, let's rewrite it with auto:

std::map<int, std::string> payslips;
// ... 
for (auto iter = payslips.begin(); iter !=payslips.end(); ++iter) 
{
    // ... 
}

3. Let's look at another example:

auto speed = 123;         // speed is an int
auto height = calculate ();    // height will be of the
                         // type returned by calculate()

decltype() is another mechanism offered by C++ that can deduce the type of expression when the expression is more complex than the auto case.

4. Let's look at this using an example:

decltype(a) y = x + 1;  // deducing the type of a
decltype(str->x) y;     // deducing the type of str->x, where str is 
                        // a struct and x 
                        // an int element of that struct

Could we use auto instead of decltype() in these two examples? We'll take a look in the next section.

The first example with auto shows that the type is deduced, at compile time, from the right-hand parameter. auto is used in simple cases.

decltype() deduces the type of expression. In the example, it defines the y variable so that it's the same type as a. As you can imagine, this would not be possible with auto. Why? This is pretty simple: decltype() tells the compiler to define a variable of a specific type; in the first example, y is a variable with the same type as a. With auto, the type is deduced automatically.

We should use auto and decltype() anytime we don't have to explicitly specify the type of a variable; for example, when we need a double type (and not a float). It's worth mentioning that both auto and decltype() deduct types of expressions that are already known to the compiler, so they are not runtime mechanisms.

There is a specific case that must be mentioned. When auto uses {} (uniform initializers) for type deduction, it can cause some headaches (or at least behaviors that we wouldn't expect). Let's look at an example:

auto fuelLevel {0, 1, 2, 3, 4, 5};

In this case, the type that's being deduced is initializer_list<T> and not an array of integers, as we could expect.

The books Effective Modern C++ by Scott Meyers and The C++ Programming Language by Bjarne Stroustrup cover these topics in great detail.