Chapter 98: type deduction

Section 98.1: Template parameter deduction for constructors

Prior to C++17, template deduction cannot deduce the class type for you in a constructor. It must be explicitly specified. Sometimes, however, these types can be very cumbersome or (in the case of lambdas) impossible to name, so we got a proliferation of type factories (like make_pair(), make_tuple(), back_inserter(), etc.).

Version ≥ C++17

This is no longer necessary:

std::back_insert_iterator(vi2)); // constructs a back_insert_iterator<std::vector<int>> std::lock_guard lk(mtx); // std::lock_guard<decltype(mtx)>

Constructors are considered to deduce the class template parameters, but in some cases this is insu cient and we can provide explicit deduction guides:

template <class Iter>

vector(Iter, Iter) -> vector<typename iterator_traits<Iter>::value_type>

int array[] = {1, 2, 3};

std::vector v(std::begin(array), std::end(array)); // deduces std::vector<int>

Section 98.2: Auto Type Deduction

Version ≥ C++11

Type deduction using the auto keyword works almost the same as Template Type Deduction. Below are a few examples:

The di erences are outlined below:

auto x1 = 27; // type is int, value is 27 auto x2(27); // type is int, value is 27

auto x3 = { 27 }; // type is std::initializer_list<int>, value is { 27 } auto x4{ 27 }; // type is std::initializer_list<int>, value is { 27 }

//in some compilers type may be deduced as an int with a

//value of 27. See remarks for more information.

auto x5 = { 1, 2.0 } // error! can't deduce T for std::initializer_list<t>

As you can see if you use braced initializers, auto is forced into creating a variable of type std::initializer_list<T>. If it can't deduce the of T, the code is rejected.

When auto is used as the return type of a function, it specifies that the function has a trailing return type.

auto f() -> int { return 42;

}

Version ≥ C++14

C++14 allows, in addition to the usages of auto allowed in C++11, the following:

1.When used as the return type of a function without a trailing return type, specifies that the function's return type should be deduced from the return statements in the function's body, if any.

// f returns int:

auto f() { return 42; } // g returns void:

auto g() { std::cout << "hello, world!\n"; }

2. When used in the parameter type of a lambda, defines the lambda to be a generic lambda.

auto triple = [](auto x) { return 3*x; };

const auto x = triple(42); // x is a const int with value 126

The special form decltype(auto) deduces a type using the type deduction rules of decltype rather than those of auto.

In C++03 and earlier, the auto keyword had a completely di erent meaning as a storage class specifier that was inherited from C.

Section 98.3: Template Type Deduction

Template Generic Syntax

template<typename T> void f(ParamType param);

f(expr);

Case 1: ParamType is a Reference or Pointer, but not a Universal or Forward Reference. In this case type deduction works this way. The compiler ignores the reference part if it exists in expr. The compiler then pattern-matches expr's type against ParamType to determing T.

Case 2: ParamType is a Universal Reference or Forward Reference. In this case type deduction is the same as in case 1 if the expr is an rvalue. If expr is an lvalue, both T and ParamType are deduced to be lvalue references.

Case 3: ParamType is Neither a Pointer nor a Reference. If expr is a reference the reference part is ignored. If expr is const that is ignored as well. If it is volatile that is also ignored when deducing T's type.