[temp.fct.spec] - C++11 → C++14

Files changed (1) hide show

tmp/tmpj8h6n6et/{from.md → to.md} +59 -32

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

@@ -89,13 +89,13 @@ void h() {
                                 // int (*)(bool), Z is deduced to an empty sequence
 }
 ```
 An empty template argument list can be used to indicate that a given use
-refers to a specialization of a function template even when a normal
-(i.e., non-template) function is visible that would otherwise be used.
-For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
 int k = f(1);                   // uses #2
@@ -264,12 +264,15 @@ int main() {
 `f<int>(1)` and `f<const int>(1)` call distinct functions even though
 both of the functions called have the same function type.
 The resulting substituted and adjusted function type is used as the type
 of the function template for template argument deduction. If a template
-argument has not been deduced, its default template argument, if any, is
-used.
 ``` cpp
 template <class T, class U = double>
 void f(T t = 0, U u = 0);
@@ -302,24 +305,40 @@ The substitution occurs in all types and expressions that are used in
 the function type and in template parameter declarations. The
 expressions include not only constant expressions such as those that
 appear in array bounds or as nontype template arguments but also general
 expressions (i.e., non-constant expressions) inside `sizeof`,
 `decltype`, and other contexts that allow non-constant expressions. The
-equivalent substitution in exception specifications is done only when
-the function is instantiated, at which point a program is ill-formed if
-the substitution results in an invalid type or expression.
 If a substitution results in an invalid type or expression, type
 deduction fails. An invalid type or expression is one that would be
-ill-formed if written using the substituted arguments. Access checking
-is done as part of the substitution process. Only invalid types and
-expressions in the immediate context of the function type and its
-template parameter types can result in a deduction failure. The
-evaluation of the substituted types and expressions can result in side
-effects such as the instantiation of class template specializations
-and/or function template specializations, the generation of
-implicitly-defined functions, etc. Such side effects are not in the
 “immediate context” and can result in the program being ill-formed.
 ``` cpp
 struct X { };
 struct Y {
@@ -449,22 +468,26 @@ g({1,2,3});                 // error: no argument deduced for T
 For a function parameter pack that occurs at the end of the
 *parameter-declaration-list*, the type `A` of each remaining argument of
 the call is compared with the type `P` of the *declarator-id* of the
 function parameter pack. Each comparison deduces template arguments for
 subsequent positions in the template parameter packs expanded by the
-function parameter pack. For a function parameter pack that does not
-occur at the end of the *parameter-declaration-list*, the type of the
-parameter pack is a non-deduced context.
 ``` cpp
 template<class ... Types> void f(Types& ...);
 template<class T1, class ... Types> void g(T1, Types ...);
 void h(int x, float& y) {
   const int z = x;
   f(x, y, z);                  // Types is deduced to int, float, const int
   g(x, y, z);                  // T1 is deduced to int; Types is deduced to float, int
 }
 ```
 If `P` is not a reference type:
@@ -570,17 +593,22 @@ Template arguments can be deduced from the type specified when taking
 the address of an overloaded function ([[over.over]]). The function
 template’s function type and the specified type are used as the types of
 `P` and `A`, and the deduction is done as described in
 [[temp.deduct.type]].
 #### Deducing conversion function template arguments <a id="temp.deduct.conv">[[temp.deduct.conv]]</a>
 Template argument deduction is done by comparing the return type of the
-conversion function template (call it `P`; see  [[dcl.init]],
-[[over.match.conv]], and [[over.match.ref]] for the determination of
-that type) with the type that is required as the result of the
-conversion (call it `A`) as described in  [[temp.deduct.type]].
 If `P` is a reference type, the type referred to by `P` is used in place
 of `P` for type deduction and for any further references to or
 transformations of `P` in the remainder of this section.
@@ -650,11 +678,11 @@ argument template and template-1 as the parameter template.
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
   parameter types for which the function call has arguments.[^7]
-- In the context of a call to a conversion operator, the return types of
   the conversion function templates are used.
 - In other contexts ([[temp.func.order]]) the function template’s
   function type is used.
 Each type nominated above from the parameter template and the
@@ -798,10 +826,11 @@ specified, template argument deduction fails.
 The non-deduced contexts are:
 - The *nested-name-specifier* of a type that was specified using a
   *qualified-id*.
 - A non-type template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
@@ -821,11 +850,11 @@ The non-deduced contexts are:
   ``` 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-clause*.
 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
@@ -1093,17 +1122,14 @@ int    x = deduce<77>(a.xm, 62, b.ym);
 // A<int>::X
 // i is explicitly specified to be 77, b.ym must be convertible
 // to B<77>::Y
 ```
-If, in the declaration of a function template with a non-type
-*template-parameter,* the non-type *template-parameter* is used in an
-expression in the function parameter-list and, if the corresponding
-*template-argument* is deduced, the *template-argument* type shall match
-the type of the *template-parameter* exactly, except that a
-*template-argument* deduced from an array bound may be of any integral
-type.[^8]
 ``` cpp
 template<int i> class A { /* ... */ };
 template<short s> void f(A<s>);
 void k1() {
@@ -1331,10 +1357,11 @@ explicitly generated, is present in some translation unit.
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.meaning]: dcl.md#dcl.meaning
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [except.spec]: except.md#except.spec
 [expr.const]: expr.md#expr.const
 [expr.new]: expr.md#expr.new
 [expr.prim.lambda]: expr.md#expr.prim.lambda

                                 // int (*)(bool), Z is deduced to an empty sequence
 }
 ```
 An empty template argument list can be used to indicate that a given use
+refers to a specialization of a function template even when a
+non-template function ([[dcl.fct]]) is visible that would otherwise be
+used. For example:
 ``` cpp
 template <class T> int f(T);    // #1
 int f(int);                     // #2
 int k = f(1);                   // uses #2
 `f<int>(1)` and `f<const int>(1)` call distinct functions even though
 both of the functions called have the same function type.
 The resulting substituted and adjusted function type is used as the type
 of the function template for template argument deduction. If a template
+argument has not been deduced and its corresponding template parameter
+has a default argument, the template argument is determined by
+substituting the template arguments determined for preceding template
+parameters into the default argument. If the substitution results in an
+invalid type, as described above, type deduction fails.
 ``` cpp
 template <class T, class U = double>
 void f(T t = 0, U u = 0);
 the function type and in template parameter declarations. The
 expressions include not only constant expressions such as those that
 appear in array bounds or as nontype template arguments but also general
 expressions (i.e., non-constant expressions) inside `sizeof`,
 `decltype`, and other contexts that allow non-constant expressions. The
+substitution proceeds in lexical order and stops when a condition that
+causes deduction to fail is encountered. The equivalent substitution in
+exception specifications is done only when the *exception-specification*
+is instantiated, at which point a program is ill-formed if the
+substitution results in an invalid type or expression.
+``` cpp
+template <class T> struct A { using X = typename T::X; };
+template <class T> typename T::X f(typename A<T>::X);
+template <class T> void f(...) { }
+template <class T> auto g(typename A<T>::X) -> typename T::X;
+template <class T> void g(...) { }
+void h() {
+  f<int>(0); // OK, substituting return type causes deduction to fail
+  g<int>(0); // error, substituting parameter type instantiates A<int>
+}
+```
 If a substitution results in an invalid type or expression, type
 deduction fails. An invalid type or expression is one that would be
+ill-formed, with a diagnostic required, if written using the substituted
+arguments. If no diagnostic is required, the program is still
+ill-formed. Access checking is done as part of the substitution process.
+Only invalid types and expressions in the immediate context of the
+function type and its template parameter types can result in a deduction
+failure. The evaluation of the substituted types and expressions can
+result in side effects such as the instantiation of class template
+specializations and/or function template specializations, the generation
+of implicitly-defined functions, etc. Such side effects are not in the
 “immediate context” and can result in the program being ill-formed.
 ``` cpp
 struct X { };
 struct Y {
 For a function parameter pack that occurs at the end of the
 *parameter-declaration-list*, the type `A` of each remaining argument of
 the call is compared with the type `P` of the *declarator-id* of the
 function parameter pack. Each comparison 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 parameter
+pack is never deduced.
 ``` cpp
 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 is deduced to int, float, const int
   g(x, y, z);                  // T1 is deduced to int; Types is deduced to float, int
+  g1(x, y, z);                 // error: Types is not deduced
+  g1<int, int, int>(x, y, z);  // OK, no deduction occurs
 }
 ```
 If `P` is not a reference type:
 the address of an overloaded function ([[over.over]]). The function
 template’s function type and the specified type are used as the types of
 `P` and `A`, and the deduction is done as described in
 [[temp.deduct.type]].
+A placeholder type ([[dcl.spec.auto]]) in the return type of a function
+template is a non-deduced context. If template argument deduction
+succeeds for such a function, the return type is determined from
+instantiation of the function body.
 #### Deducing conversion function template arguments <a id="temp.deduct.conv">[[temp.deduct.conv]]</a>
 Template argument deduction is done by comparing the return type of the
+conversion function template (call it `P`) with the type that is
+required as the result of the conversion (call it `A`; see
+[[dcl.init]], [[over.match.conv]], and [[over.match.ref]] for the
+determination of that type) as described in  [[temp.deduct.type]].
 If `P` is a reference type, the type referred to by `P` is used in place
 of `P` for type deduction and for any further references to or
 transformations of `P` in the remainder of this section.
 The types used to determine the ordering depend on the context in which
 the partial ordering is done:
 - In the context of a function call, the types used are those function
   parameter types for which the function call has arguments.[^7]
+- In the context of a call to a conversion function, the return types of
   the conversion function templates are used.
 - In other contexts ([[temp.func.order]]) the function template’s
   function type is used.
 Each type nominated above from the parameter template and the
 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*.
 - A non-type template argument or an array bound in which a
   subexpression references a template parameter.
 - A template parameter used in the parameter type of a function
   parameter that has a default argument that is being used in the call
   for which argument deduction is being done.
   ``` 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
 // 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() {
 [dcl.fct]: dcl.md#dcl.fct
 [dcl.fct.default]: dcl.md#dcl.fct.default
 [dcl.init]: dcl.md#dcl.init
 [dcl.init.list]: dcl.md#dcl.init.list
 [dcl.meaning]: dcl.md#dcl.meaning
+[dcl.spec.auto]: dcl.md#dcl.spec.auto
 [dcl.type.elab]: dcl.md#dcl.type.elab
 [except.spec]: except.md#except.spec
 [expr.const]: expr.md#expr.const
 [expr.new]: expr.md#expr.new
 [expr.prim.lambda]: expr.md#expr.prim.lambda

Diff to HTML by rtfpessoa