[temp.deduct.type] - C++14 → C++17

Files changed (1) hide show

tmp/tmped057c7w/{from.md → to.md} +150 -40

tmp/tmped057c7w/{from.md → to.md} RENAMED Viewed

@@ -14,11 +14,12 @@ In some cases, the deduction is done using a single set of types `P` and
 deduced template argument values are then combined. If type deduction
 cannot be done for any `P/A` pair, or if for any pair the deduction
 leads to more than one possible set of deduced values, or if different
 pairs yield different deduced values, or if any template argument
 remains neither deduced nor explicitly specified, template argument
-deduction fails.
 A given type `P` can be composed from a number of other types,
 templates, and non-type values:
 - A function type includes the types of each of the function parameters
@@ -39,10 +40,15 @@ In certain contexts, however, the value does not participate in type
 deduction, but instead uses the values of template arguments that were
 either deduced elsewhere or explicitly specified. If a template
 parameter is used only in non-deduced contexts and is not explicitly
 specified, template argument deduction fails.
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
 - The *expression* of a *decltype-specifier*.
@@ -60,35 +66,43 @@ The non-deduced contexts are:
   - no function matches the function parameter type, or
   - the set of functions supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list ([[dcl.init.list]]) but the parameter does not have
- `std::initializer_list` or reference to possibly cv-qualified
- `std::initializer_list` type.
   ``` cpp
   template<class T> void g(T);
   g({1,2,3});                 // error: no argument deduced for T
   ```
 - A function parameter pack that does not occur at the end of the
   *parameter-declaration-list*.
 When a type name is specified in a way that includes a non-deduced
 context, all of the types that comprise that type name are also
 non-deduced. However, a compound type can include both deduced and
-non-deduced types. If a type is specified as `A<T>::B<T2>`, both `T` and
 `T2` are non-deduced. Likewise, if a type is specified as
 `A<I+J>::X<T>`, `I`, `J`, and `T` are non-deduced. If a type is
 specified as `void` `f(typename` `A<T>::B,` `A<T>)`, the `T` in
-`A<T>::B` is non-deduced but the `T` in `A<T>` is deduced.
 Here is an example in which different parameter/argument pairs produce
 inconsistent template argument deductions:
 ``` cpp
-template<class T> void f(T x, T y) { /* ... */ }
-struct A { /* ... */ };
-struct B : A { /* ... */ };
 void g(A a, B b) {
   f(a,b);           // error: T could be A or B
   f(b,a);           // error: T could be A or B
   f(a,a);           // OK: T is A
   f(b,b);           // OK: T is B
@@ -139,10 +153,12 @@ void t() {
   f(d);             // calls f(B<int>&)
   f(d2);            // calls f(B<int>&)
 }
 ```
 A template type argument `T`, a template template argument `TT` or a
 template non-type argument `i` can be deduced if `P` and `A` have one of
 the following forms:
 ``` cpp
@@ -171,20 +187,20 @@ template-name<i>  (where template-name refers to a class template)
 TT<T>
 TT<i>
 TT<>
 ```
-where `(T)` represents a *parameter-type-list* where at least one
-parameter type contains a `T`, and `()` represents a
-*parameter-type-list* where no parameter type contains a `T`. Similarly,
 `<T>` represents template argument lists where at least one argument
 contains a `T`, `<i>` represents template argument lists where at least
 one argument contains an `i` and `<>` represents template argument lists
 where no argument contains a `T` or an `i`.
 If `P` has a form that contains `<T>` or `<i>`, then each argument Pᵢ of
-the respective template argument list `P` is compared with the
 corresponding argument Aᵢ of the corresponding template argument list of
 `A`. If the template argument list of `P` contains a pack expansion that
 is not the last template argument, the entire template argument list is
 a non-deduced context. If `Pᵢ` is a pack expansion, then the pattern of
 `Pᵢ` is compared with each remaining argument in the template argument
@@ -196,10 +212,12 @@ pack expansion:
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
 ``` cpp
 template<class T1, class... Z> class S;                               // #1
 template<class T1, class... Z> class S<T1, const Z&...> { };          // #2
 template<class T1, class T2>   class S<T1, const T2&> { };            // #3
 S<int, const int&> s;         // both #2 and #3 match; #3 is more specialized
@@ -208,24 +226,30 @@ template<class T, class... U>            struct A { };                // #1
 template<class T1, class T2, class... U> struct A<T1, T2*, U...> { }; // #2
 template<class T1, class T2>             struct A<T1, T2> { };        // #3
 template struct A<int, int*>; // selects #2
 ```
 Similarly, if `P` has a form that contains `(T)`, then each parameter
-type `Pᵢ` of the respective *parameter-type-list* of `P` is compared
-with the corresponding parameter type `Aᵢ` of the corresponding
-*parameter-type-list* of `A`. If `P` and `A` are function types that
 originated from deduction when taking the address of a function
 template ([[temp.deduct.funcaddr]]) or when deducing template arguments
 from a function declaration ([[temp.deduct.decl]]) and `Pᵢ` and `Aᵢ`
-are parameters of the top-level *parameter-type-list* of `P` and `A`,
-respectively, `Pᵢ` is adjusted if it is an rvalue reference to a
-cv-unqualified template parameter and `Aᵢ` is an lvalue reference, in
-which case the type of `Pᵢ` is changed to be the template parameter type
-(i.e., `T&&` is changed to simply `T`). As a result, when `Pᵢ` is `T&&`
-and `Aᵢ` is `X&`, the adjusted `Pᵢ` will be `T`, causing `T` to be
-deduced as `X&`.
 ``` cpp
 template <class T> void f(T&&);
 template <> void f(int&) { }    // #1
 template <> void f(int&&) { }   // #2
@@ -233,32 +257,40 @@ void g(int i) {
   f(i);                         // calls f<int&>(int&), i.e., #1
   f(0);                         // calls f<int>(int&&), i.e., #2
 }
 ```
 If the *parameter-declaration* corresponding to `Pᵢ` is a function
 parameter pack, then the type of its *declarator-id* is compared with
-each remaining parameter type in the *parameter-type-list* of `A`. Each
 comparison deduces template arguments for subsequent positions in the
 template parameter packs expanded by the function parameter pack. During
 partial ordering ([[temp.deduct.partial]]), if `Aᵢ` was originally a
 function parameter pack:
 - if `P` does not contain a function parameter type corresponding to
   `Aᵢ` then `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a function parameter pack, template argument
   deduction fails.
 ``` cpp
 template<class T, class... U> void f(T*, U...) { }  // #1
 template<class T>             void f(T) { }         // #2
 template void f(int*);                              // selects #1
 ```
 These forms can be used in the same way as `T` is for further
 composition of types.
 ``` cpp
 X<int> (*)(char[6])
 ```
 is of the form
@@ -273,22 +305,67 @@ which is a variant of
 type (*)(T)
 ```
 where type is `X<int>` and `T` is `char[6]`.
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
-A template type argument cannot be deduced from the type of a non-type
-*template-argument*.
 ``` cpp
-template<class T, T i> void f(double a[10][i]);
-int v[10][20];
-f(v);               // error: argument for template-parameter T cannot be deduced
 ```
 Except for reference and pointer types, a major array bound is not part
 of a function parameter type and cannot be deduced from an argument:
 ``` cpp
 template<int i> void f1(int a[10][i]);
@@ -303,17 +380,23 @@ void g() {
   f2<10>(v);                    // OK
   f3(v);                        // OK: i deduced to be 10
 }
 ```
 If, in the declaration of a function template with a non-type template
 parameter, the non-type template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
 ``` cpp
-template <int i> class A { /* ... */ };
 template <int i> void g(A<i+1>);
 template <int i> void f(A<i>, A<i+1>);
 void k() {
   A<1> a1;
   A<2> a2;
@@ -321,10 +404,16 @@ void k() {
   g<0>(a1);                     // OK
   f(a1, a2);                    // OK
 }
 ```
 Template parameters do not participate in template argument deduction if
 they are used only in non-deduced contexts. For example,
 ``` cpp
 template<int i, typename T>
@@ -333,23 +422,26 @@ T deduce(typename A<T>::X x,    // T is not deduced here
          typename B<i>::Y y);   // i is not deduced here
 A<int> a;
 B<77>  b;
 int    x = deduce<77>(a.xm, 62, b.ym);
-// T is deduced to be int, a.xm must be convertible to
-// A<int>::X
-// i is explicitly specified to be 77, b.ym must be convertible
-// to B<77>::Y
 ```
-If `P` has a form that contains `<i>`, and if the type of the
-corresponding value of `A` differs from the type of `i`, deduction
-fails. If `P` has a form that contains `[i]`, and if the type of `i` is
-not an integral type, deduction fails.[^8]
 ``` cpp
-template<int i> class A { /* ... */ };
 template<short s> void f(A<s>);
 void k1() {
   A<1> a;
   f(a);             // error: deduction fails for conversion from int to short
   f<1>(a);          // OK
@@ -361,13 +453,17 @@ void k2() {
   B<1> b;
   g(b);             // OK: cv-qualifiers are ignored on template parameter types
 }
 ```
 A *template-argument* can be deduced from a function, pointer to
 function, or pointer to member function type.
 ``` cpp
 template<class T> void f(void(*)(T,int));
 template<class T> void foo(T,int);
 void g(int,int);
 void g(char,int);
@@ -379,37 +475,49 @@ int m() {
   f(&h);            // OK: void h(char,int) is a unique match
   f(&foo);          // error: type deduction fails because foo is a template
 }
 ```
 A template *type-parameter* cannot be deduced from the type of a
 function default argument.
 ``` cpp
 template <class T> void f(T = 5, T = 7);
 void g() {
   f(1);             // OK: call f<int>(1,7)
   f();              // error: cannot deduce T
   f<int>();         // OK: call f<int>(5,7)
 }
 ```
 The *template-argument* corresponding to a template *template-parameter*
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
 ``` cpp
 template <template <class T> class X> struct A { };
 template <template <class T> class X> void f(A<X>) { }
 template<class T> struct B { };
 A<B> ab;
 f(ab);              // calls f(A<B>)
 ```
-Template argument deduction involving parameter packs (
 [[temp.variadic]]) can deduce zero or more arguments for each parameter
-pack.
 ``` cpp
 template<class> struct X { };
 template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
 template<class ... Types> struct Y { };
@@ -425,5 +533,7 @@ Y<> y1;                         // use primary template; Types is empty
 Y<int&, float&, double&> y2;    // uses partial specialization; T is int&, Types contains float, double
 Y<int, float, double> y3;       // uses primary template; Types contains int, float, double
 int fv = f(g);                  // OK; Types contains int, float
 ```

 deduced template argument values are then combined. If type deduction
 cannot be done for any `P/A` pair, or if for any pair the deduction
 leads to more than one possible set of deduced values, or if different
 pairs yield different deduced values, or if any template argument
 remains neither deduced nor explicitly specified, template argument
+deduction fails. The type of a type parameter is only deduced from an
+array bound if it is not otherwise deduced.
 A given type `P` can be composed from a number of other types,
 templates, and non-type values:
 - A function type includes the types of each of the function parameters
 deduction, but instead uses the values of template arguments that were
 either deduced elsewhere or explicitly specified. If a template
 parameter is used only in non-deduced contexts and is not explicitly
 specified, template argument deduction fails.
+[*Note 1*: Under [[temp.deduct.call]] and [[temp.deduct.partial]], if
+`P` contains no *template-parameter*s that appear in deduced contexts,
+no deduction is done, so `P` and `A` need not have the same
+form. — *end note*]
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
 - The *expression* of a *decltype-specifier*.
   - no function matches the function parameter type, or
   - the set of functions supplied as an argument contains one or more
     function templates.
 - A function parameter for which the associated argument is an
   initializer list ([[dcl.init.list]]) but the parameter does not have
+ a type for which deduction from an initializer list is specified (
+ [[temp.deduct.call]]).
+  \[*Example 1*:
   ``` cpp
   template<class T> void g(T);
   g({1,2,3});                 // error: no argument deduced for T
   ```
+  — *end example*]
 - A function parameter pack that does not occur at the end of the
   *parameter-declaration-list*.
 When a type name is specified in a way that includes a non-deduced
 context, all of the types that comprise that type name are also
 non-deduced. However, a compound type can include both deduced and
+non-deduced types.
+[*Example 2*: If a type is specified as `A<T>::B<T2>`, both `T` and
 `T2` are non-deduced. Likewise, if a type is specified as
 `A<I+J>::X<T>`, `I`, `J`, and `T` are non-deduced. If a type is
 specified as `void` `f(typename` `A<T>::B,` `A<T>)`, the `T` in
+`A<T>::B` is non-deduced but the `T` in `A<T>` is
+deduced. — *end example*]
+[*Example 3*:
 Here is an example in which different parameter/argument pairs produce
 inconsistent template argument deductions:
 ``` cpp
+template<class T> void f(T x, T y) { ... }
+struct A { ... };
+struct B : A { ... };
 void g(A a, B b) {
   f(a,b);           // error: T could be A or B
   f(b,a);           // error: T could be A or B
   f(a,a);           // OK: T is A
   f(b,b);           // OK: T is B
   f(d);             // calls f(B<int>&)
   f(d2);            // calls f(B<int>&)
 }
 ```
+— *end example*]
 A template type argument `T`, a template template argument `TT` or a
 template non-type argument `i` can be deduced if `P` and `A` have one of
 the following forms:
 ``` cpp
 TT<T>
 TT<i>
 TT<>
 ```
+where `(T)` represents a parameter-type-list ([[dcl.fct]]) where at
+least one parameter type contains a `T`, and `()` represents a
+parameter-type-list where no parameter type contains a `T`. Similarly,
 `<T>` represents template argument lists where at least one argument
 contains a `T`, `<i>` represents template argument lists where at least
 one argument contains an `i` and `<>` represents template argument lists
 where no argument contains a `T` or an `i`.
 If `P` has a form that contains `<T>` or `<i>`, then each argument Pᵢ of
+the respective template argument list of `P` is compared with the
 corresponding argument Aᵢ of the corresponding template argument list of
 `A`. If the template argument list of `P` contains a pack expansion that
 is not the last template argument, the entire template argument list is
 a non-deduced context. If `Pᵢ` is a pack expansion, then the pattern of
 `Pᵢ` is compared with each remaining argument in the template argument
 - if `P` does not contain a template argument corresponding to `Aᵢ` then
   `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a pack expansion, template argument
   deduction fails.
+[*Example 4*:
 ``` cpp
 template<class T1, class... Z> class S;                               // #1
 template<class T1, class... Z> class S<T1, const Z&...> { };          // #2
 template<class T1, class T2>   class S<T1, const T2&> { };            // #3
 S<int, const int&> s;         // both #2 and #3 match; #3 is more specialized
 template<class T1, class T2, class... U> struct A<T1, T2*, U...> { }; // #2
 template<class T1, class T2>             struct A<T1, T2> { };        // #3
 template struct A<int, int*>; // selects #2
 ```
+— *end example*]
 Similarly, if `P` has a form that contains `(T)`, then each parameter
+type `Pᵢ` of the respective parameter-type-list ([[dcl.fct]]) of `P` is
+compared with the corresponding parameter type `Aᵢ` of the corresponding
+parameter-type-list of `A`. If `P` and `A` are function types that
 originated from deduction when taking the address of a function
 template ([[temp.deduct.funcaddr]]) or when deducing template arguments
 from a function declaration ([[temp.deduct.decl]]) and `Pᵢ` and `Aᵢ`
+are parameters of the top-level parameter-type-list of `P` and `A`,
+respectively, `Pᵢ` is adjusted if it is a forwarding reference (
+[[temp.deduct.call]]) and `Aᵢ` is an lvalue reference, in which case the
+type of `Pᵢ` is changed to be the template parameter type (i.e., `T&&`
+is changed to simply `T`).
+[*Note 2*: As a result, when `Pᵢ` is `T&&` and `Aᵢ` is `X&`, the
+adjusted `Pᵢ` will be `T`, causing `T` to be deduced as
+`X&`. — *end note*]
+[*Example 5*:
 ``` cpp
 template <class T> void f(T&&);
 template <> void f(int&) { }    // #1
 template <> void f(int&&) { }   // #2
   f(i);                         // calls f<int&>(int&), i.e., #1
   f(0);                         // calls f<int>(int&&), i.e., #2
 }
 ```
+— *end example*]
 If the *parameter-declaration* corresponding to `Pᵢ` is a function
 parameter pack, then the type of its *declarator-id* is compared with
+each remaining parameter type in the parameter-type-list of `A`. Each
 comparison deduces template arguments for subsequent positions in the
 template parameter packs expanded by the function parameter pack. During
 partial ordering ([[temp.deduct.partial]]), if `Aᵢ` was originally a
 function parameter pack:
 - if `P` does not contain a function parameter type corresponding to
   `Aᵢ` then `Aᵢ` is ignored;
 - otherwise, if `Pᵢ` is not a function parameter pack, template argument
   deduction fails.
+[*Example 6*:
 ``` cpp
 template<class T, class... U> void f(T*, U...) { }  // #1
 template<class T>             void f(T) { }         // #2
 template void f(int*);                              // selects #1
 ```
+— *end example*]
 These forms can be used in the same way as `T` is for further
 composition of types.
+[*Example 7*:
 ``` cpp
 X<int> (*)(char[6])
 ```
 is of the form
 type (*)(T)
 ```
 where type is `X<int>` and `T` is `char[6]`.
+— *end example*]
 Template arguments cannot be deduced from function arguments involving
 constructs other than the ones specified above.
+When the value of the argument corresponding to a non-type template
+parameter `P` that is declared with a dependent type is deduced from an
+expression, the template parameters in the type of `P` are deduced from
+the type of the value.
+[*Example 8*:
 ``` cpp
+template<long n> struct A { };
+template<typename T> struct C;
+template<typename T, T n> struct C<A<n>> {
+  using Q = T;
+};
+using R = long;
+using R = C<A<2>>::Q;           // OK; T was deduced to long from the
+                                // template argument value in the type A<2>
 ```
+— *end example*]
+The type of `N` in the type `T[N]` is `std::size_t`.
+[*Example 9*:
+``` cpp
+template<typename T> struct S;
+template<typename T, T n> struct S<int[n]> {
+  using Q = T;
+};
+using V = decltype(sizeof 0);
+using V = S<int[42]>::Q;        // OK; T was deduced to std::size_t from the type int[42]
+```
+— *end example*]
+[*Example 10*:
+``` cpp
+template<class T, T i> void f(int (&a)[i]);
+int v[10];
+void g() {
+  f(v);                         // OK: T is std::size_t
+}
+```
+— *end example*]
+[*Note 3*:
 Except for reference and pointer types, a major array bound is not part
 of a function parameter type and cannot be deduced from an argument:
 ``` cpp
 template<int i> void f1(int a[10][i]);
   f2<10>(v);                    // OK
   f3(v);                        // OK: i deduced to be 10
 }
 ```
+— *end note*]
+[*Note 4*:
 If, in the declaration of a function template with a non-type template
 parameter, the non-type template parameter is used in a subexpression in
 the function parameter list, the expression is a non-deduced context as
 specified above.
+[*Example 11*:
 ``` cpp
+template <int i> class A { ... };
 template <int i> void g(A<i+1>);
 template <int i> void f(A<i>, A<i+1>);
 void k() {
   A<1> a1;
   A<2> a2;
   g<0>(a1);                     // OK
   f(a1, a2);                    // OK
 }
 ```
+— *end example*]
+— *end note*]
+[*Note 5*:
 Template parameters do not participate in template argument deduction if
 they are used only in non-deduced contexts. For example,
 ``` cpp
 template<int i, typename T>
          typename B<i>::Y y);   // i is not deduced here
 A<int> a;
 B<77>  b;
 int    x = deduce<77>(a.xm, 62, b.ym);
+// T is deduced to be int, a.xm must be convertible to A<int>::X
+// i is explicitly specified to be 77, b.ym must be convertible to B<77>::Y
 ```
+— *end note*]
+If `P` has a form that contains `<i>`, and if the type of `i` differs
+from the type of the corresponding template parameter of the template
+named by the enclosing *simple-template-id*, deduction fails. If `P` has
+a form that contains `[i]`, and if the type of `i` is not an integral
+type, deduction fails.[^8]
+[*Example 12*:
 ``` cpp
+template<int i> class A { ... };
 template<short s> void f(A<s>);
 void k1() {
   A<1> a;
   f(a);             // error: deduction fails for conversion from int to short
   f<1>(a);          // OK
   B<1> b;
   g(b);             // OK: cv-qualifiers are ignored on template parameter types
 }
 ```
+— *end example*]
 A *template-argument* can be deduced from a function, pointer to
 function, or pointer to member function type.
+[*Example 13*:
 ``` cpp
 template<class T> void f(void(*)(T,int));
 template<class T> void foo(T,int);
 void g(int,int);
 void g(char,int);
   f(&h);            // OK: void h(char,int) is a unique match
   f(&foo);          // error: type deduction fails because foo is a template
 }
 ```
+— *end example*]
 A template *type-parameter* cannot be deduced from the type of a
 function default argument.
+[*Example 14*:
 ``` cpp
 template <class T> void f(T = 5, T = 7);
 void g() {
   f(1);             // OK: call f<int>(1,7)
   f();              // error: cannot deduce T
   f<int>();         // OK: call f<int>(5,7)
 }
 ```
+— *end example*]
 The *template-argument* corresponding to a template *template-parameter*
 is deduced from the type of the *template-argument* of a class template
 specialization used in the argument list of a function call.
+[*Example 15*:
 ``` cpp
 template <template <class T> class X> struct A { };
 template <template <class T> class X> void f(A<X>) { }
 template<class T> struct B { };
 A<B> ab;
 f(ab);              // calls f(A<B>)
 ```
+— *end example*]
+[*Note 6*: Template argument deduction involving parameter packs (
 [[temp.variadic]]) can deduce zero or more arguments for each parameter
+pack. — *end note*]
+[*Example 16*:
 ``` cpp
 template<class> struct X { };
 template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
 template<class ... Types> struct Y { };
 Y<int&, float&, double&> y2;    // uses partial specialization; T is int&, Types contains float, double
 Y<int, float, double> y3;       // uses primary template; Types contains int, float, double
 int fv = f(g);                  // OK; Types contains int, float
 ```
+— *end example*]

Diff to HTML by rtfpessoa