12 KiB
[temp.deduct.call]
13 Templates [temp]
13.10 Function template specializations [temp.fct.spec]
13.10.3 Template argument deduction [temp.deduct]
13.10.3.2 Deducing template arguments from a function call [temp.deduct.call]
Template argument deduction is done by comparing each function template parameter type (call itP) that contains template parameters that participate in template argument deduction with the type of the corresponding argument of the call (call itA) as described below.
If removing references and cv-qualifiers from P givesstd::initializer_list<Pâ²> or Pâ²[N] for some Pâ² and N and the argument is a non-empty initializer list ([dcl.init.list]), then deduction is performed instead for each element of the initializer list independently, taking Pâ² as separate function template parameter types Pâ²i and the ith initializer element as the corresponding argument.
In the Pâ²[N] case, if N is a constant template parameter,N is deduced from the length of the initializer list.
Otherwise, an initializer list argument causes the parameter to be considered a non-deduced context ([temp.deduct.type]).
[Example 1: template void f(std::initializer_list); f({1,2,3}); // T deduced as int f({1,"asdf"}); // error: T deduced as both int and const chartemplate void g(T); g({1,2,3}); // error: no argument deduced for Ttemplate<class T, int N> void h(T const(&)[N]); h({1,2,3}); // T deduced as int; N deduced as 3template void j(T const(&)[3]); j({42}); // T deduced as int; array bound not consideredstruct Aggr { int i; int j; };template void k(Aggr const(&)[N]); k({1,2,3}); // error: deduction fails, no conversion from int to Aggr k({{1},{2},{3}}); // OK, N deduced as 3template<int M, int N> void m(int const(&)[M][N]); m({{1,2},{3,4}}); // M and N both deduced as 2template<class T, int N> void n(T const(&)[N], T); n({{1},{2},{3}},Aggr()); // OK, T is Aggr, N is 3template<typename T, int N> void o(T ( const (&)[N])(T)) { }int f1(int);int f4(int);char f4(char); o({ &f1, &f4 }); // OK, T deduced as int from first element, nothing// deduced from second element, N deduced as 2 o({ &f1, static_cast<char(*)(char)>(&f4) }); // error: conflicting deductions for T â end example]
For a function parameter pack that occurs at the end of the parameter-declaration-list, deduction is performed for each remaining argument of the call, taking the type P of the declarator-id of the function parameter pack as the corresponding function template parameter type.
Each deduction deduces template arguments for subsequent positions in the template parameter packs expanded by the function parameter pack.
When a function parameter pack appears in a non-deduced context ([temp.deduct.type]), the type of that pack is never deduced.
[Example 2: template<class ... Types> void f(Types& ...);template<class T1, class ... Types> void g(T1, Types ...);template<class T1, class ... Types> void g1(Types ..., T1);
void h(int x, float& y) {const int z = x; f(x, y, z); // Types deduced as int, float, const int g(x, y, z); // T1 deduced as int; Types deduced as float, int g1(x, y, z); // error: Types is not deduced g1<int, int, int>(x, y, z); // OK, no deduction occurs} â end example]
IfP is not a reference type:
IfA is an array type, the pointer type produced by the array-to-pointer standard conversion is used in place ofA for type deduction; otherwise,
IfA is a function type, the pointer type produced by thefunction-to-pointer standard conversion is used in place ofA for type deduction; otherwise,
IfA is a cv-qualified type, the top-level cv-qualifiers ofA's type are ignored for type deduction.
IfP is a cv-qualified type, the top-level cv-qualifiers ofP's type are ignored for type deduction.
IfP is a reference type, the type referred to byP is used for type deduction.
[Example 3: template int f(const T&);int n1 = f(5); // calls f(const int&)const int i = 0;int n2 = f(i); // calls f(const int&)template int g(volatile T&);int n3 = g(i); // calls g(const volatile int&) â end example]
A forwarding reference is an rvalue reference to a cv-unqualified template parameter that does not represent a template parameter of a class template (during class template argument deduction ([over.match.class.deduct])).
If P is a forwarding reference and the argument is an lvalue, the type âlvalue reference to Aâ is used in place of A for type deduction.
[Example 4: template int f(T&& heisenreference);template int g(const T&&);int i;int n1 = f(i); // calls f<int&>(int&)int n2 = f(0); // calls f(int&&)int n3 = g(i); // error: would call g(const int&&), which// would bind an rvalue reference to an lvaluetemplate struct A {template A(T&&, U&&, int*); // #1: T&& is not a forwarding reference.// U&& is a forwarding reference. A(T&&, int*); // #2};
template A(T&&, int*) -> A; // #3: T&& is a forwarding reference.int *ip; A a{i, 0, ip}; // error: cannot deduce from #1 A a0{0, 0, ip}; // uses #1 to deduce A and #1 to initialize A a2{i, ip}; // uses #3 to deduce A<int&> and #2 to initialize â end example]
In general, the deduction process attempts to find template argument values that will make the deducedA identical toA (after the typeA is transformed as described above).
However, there are three cases that allow a difference:
-
If the originalP is a reference type, the deducedA (i.e., the type referred to by the reference) can be more cv-qualified than the transformed A.
-
The transformed A can be another pointer or pointer-to-member type that can be converted to the deducedA via a function pointer conversion and/orqualification conversion.
-
IfP is a class andP has the formsimple-template-id ortypenameopt splice-specialization-specifier, then the transformed A can be a derived class D of the deducedA. Likewise, ifP is a pointer to a class of the formsimple-template-id ortypenameopt splice-specialization-specifier, the transformed A can be a pointer to a derived class D of the class pointed to by the deducedA. However, if there is a class C that is a (direct or indirect) base class of D and derived (directly or indirectly) from a class B and that would be a valid deduced A, the deduced A cannot be B or pointer to B, respectively. [Example 5: template <typename... T> struct X;template <> struct X<> {};template <typename T, typename... Ts>struct X<T, Ts...> : X<Ts...> {};struct D : X {};struct E : X<>, X {};
template <typename... T>int f(const X<T...>&);int x = f(D()); // calls f, not f<>// B is X<>, C is Xint z = f(E()); // calls f, not f<> â end example]
These alternatives are considered only if type deduction would otherwise fail.
If they yield more than one possible deducedA, the type deduction fails.
[Note 1:
If a template parameter is not used in any of the function parameters of a function template, or is used only in a non-deduced context, its correspondingtemplate-argument cannot be deduced from a function call and thetemplate-argument must be explicitly specified.
â end note]
WhenP is a function type, function pointer type, or pointer-to-member-function type:
-
If the argument is an overload set containing one or more function templates, the parameter is treated as a non-deduced context.
-
If the argument is an overload set (not containing function templates), trial argument deduction is attempted using each of the members of the set whose associated constraints ([temp.constr.constr]) are satisfied. If all successful deductions yield the same deduced A, that deduced A is the result of deduction; otherwise, the parameter is treated as a non-deduced context.
[Example 6: // Only one function of an overload set matches the call so the function parameter is a deduced context.template int f(T (p)(T));int g(int);int g(char);int i = f(g); // calls f(int ()(int)) â end example]
[Example 7: // Ambiguous deduction causes the second function parameter to be a non-deduced context.template int f(T, T (p)(T));int g(int);char g(char);int i = f(1, g); // calls f(int, int ()(int)) â end example]
[Example 8: // The overload set contains a template, causing the second function parameter to be a non-deduced context.template int f(T, T (p)(T));char g(char);template T g(T);int i = f(1, g); // calls f(int, int ()(int)) â end example]
[Example 9: // All arguments for placeholder type deduction ([dcl.type.auto.deduct]) yield the same deduced type.template struct X {static void f(short) requires B; // #1static void f(short); // #2};void test() {auto x = &X::f; // OK, deduces void()(short), selects #1auto y = &X::f; // OK, deduces void()(short), selects #2} â end example]