Examples of mandatory type deduction in C++

A simple example is initialisation of a lambda variable. The type of the lambda is anonymous, therefore it cannot be named explicitly and must be deduced:

auto var = [capture]{};

Another example:

struct {
    int x, y;
} g_xy;

Here g_xy is a global variable of unnamed type. If you try to return it for example you have to let the compiler deduce the return type of the function because you cannot name it:

auto foo()
{
    return g_xy;
}

Although possible unnamed types (except lamdas) are rarely useful and used.

The style guide gives several examples where the compiler does automatic type deduction. The most obvious case is whenever you use the auto keyword, introduced with C++11. auto is a placeholder for an actual type. Whenever you use auto the compiler will deduce the type from: the type of expression used to intialise a variable; the trailing type or type of return expression of a function.

Normally you would declare a variable like this:

int i = 0;

where you specify the type int for the variable i. However, in modern C++ you could declare variables without specifying their type and the compiler will deduce their types automatically:

auto a = 42;         // a is an int
auto& b = a;         // b is an int&
auto c = b;          // c is an int
auto d{42};          // d is an int, not a std::initializer_list<int>
auto v = {1, 2, 3};  //v is a std::initializer_list<int>

Other examples include a named lambda function:

auto lower = [] (const char c) { return tolower(c); };

and in C++14 onward, a generic lambda where both the return type and lambda parameters can be auto:

auto add = [](const auto a, const auto b) { return a + b; }

One thing to note is that auto is a placeholder for type, not for const, volatile or reference specifers.

Some advantages of using auto include:

• variable is always initialised
• ensure the correct type is used without any implicit conversion
• less typing and concern for actual type

And yet another example - type of generic lambdas with auto arguments can not be specified.

auto lam = [](auto v) { }

There is no way to specify type of v in invocation of lambda.