[temp.arg] - C++17 → C++20

Files changed (1) hide show

tmp/tmp7j1qqjfq/{from.md → to.md} +107 -87

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

@@ -3,12 +3,12 @@
 There are three forms of *template-argument*, corresponding to the three
 forms of *template-parameter*: type, non-type and template. The type and
 form of each *template-argument* specified in a *template-id* shall
 match the type and form specified for the corresponding parameter
 declared by the template in its *template-parameter-list*. When the
-parameter declared by the template is a template parameter pack (
-[[temp.variadic]]), it will correspond to zero or more
 *template-argument*s.
 [*Example 1*:
 ``` cpp
@@ -93,11 +93,11 @@ template <template <class TT> class T> class A {
 template <class U> class B {
 private:
   struct S { ... };
 };
-A<B> b;             // ill-formed: A has no access to B::S
 ```
 — *end example*]
 When template argument packs or default *template-argument*s are used, a
@@ -115,12 +115,12 @@ Tuple<>* t;                     // OK: Elements is empty
 Tuple* u;                       // syntax error
 ```
 — *end example*]
-An explicit destructor call ([[class.dtor]]) for an object that has a
-type that is a class template specialization may explicitly specify the
 *template-argument*s.
 [*Example 6*:
 ``` cpp
@@ -137,18 +137,18 @@ void f(A<int>* p, A<int>* q) {
 If the use of a *template-argument* gives rise to an ill-formed
 construct in the instantiation of a template specialization, the program
 is ill-formed.
-When the template in a *template-id* is an overloaded function template,
 both non-template functions in the overload set and function templates
 in the overload set for which the *template-argument*s do not match the
 *template-parameter*s are ignored. If none of the function templates
 have matching *template-parameter*s, the program is ill-formed.
 When a *simple-template-id* does not name a function, a default
-*template-argument* is implicitly instantiated ([[temp.inst]]) when the
 value of that default argument is needed.
 [*Example 7*:
 ``` cpp
@@ -159,12 +159,12 @@ S<bool>* p;         // the type of p is S<bool, int>*
 The default argument for `U` is instantiated to form the type
 `S<bool, int>*`.
 — *end example*]
-A *template-argument* followed by an ellipsis is a pack expansion (
-[[temp.variadic]]).
 ### Template type arguments <a id="temp.arg.type">[[temp.arg.type]]</a>
 A *template-argument* for a *template-parameter* which is a type shall
 be a *type-id*.
@@ -190,37 +190,45 @@ void f() {
 }
 ```
 — *end example*]
-[*Note 1*: A template type argument may be an incomplete type (
-[[basic.types]]). — *end note*]
 ### Template non-type arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
-If the type of a *template-parameter* contains a placeholder type (
-[[dcl.spec.auto]], [[temp.param]]), the deduced parameter type is
-determined from the type of the *template-argument* by placeholder type
-deduction ([[dcl.type.auto.deduct]]). If a deduced parameter type is
-not permitted for a *template-parameter* declaration ([[temp.param]]),
-the program is ill-formed.
 A *template-argument* for a non-type *template-parameter* shall be a
-converted constant expression ([[expr.const]]) of the type of the
-*template-parameter*. For a non-type *template-parameter* of reference
-or pointer type, the value of the constant expression shall not refer to
-(or for a pointer type, shall not be the address of):
-- a subobject ([[intro.object]]),
-- a temporary object ([[class.temporary]]),
-- a string literal ([[lex.string]]),
-- the result of a `typeid` expression ([[expr.typeid]]), or
-- a predefined `__func__` variable ([[dcl.fct.def.general]]).
-[*Note 1*: If the *template-argument* represents a set of overloaded
-functions (or a pointer or member pointer to such), the matching
-function is selected from the set ([[over.over]]). — *end note*]
 [*Example 1*:
 ``` cpp
 template<const int* pci> struct X { ... };
@@ -242,76 +250,67 @@ void f(int);
 template<void (*pf)(int)> struct A { ... };
 A<&f> a;                        // selects f(int)
 template<auto n> struct B { ... };
-B<5> b1;                        // OK: template parameter type is int
-B<'a'> b2;                      // OK: template parameter type is char
-B<2.5> b3;                      // error: template parameter type cannot be double
 ```
 — *end example*]
 [*Note 2*:
-A string literal ([[lex.string]]) is not an acceptable
-*template-argument*.
 [*Example 2*:
 ``` cpp
-template<class T, const char* p> class X {
   ...
 };
-X<int, "Studebaker"> x1; // error: string literal as template-argument
 const char p[] = "Vivisectionist";
-X<int,p> x2; // OK
 ```
 — *end example*]
 — *end note*]
 [*Note 3*:
-The address of an array element or non-static data member is not an
-acceptable *template-argument*.
-[*Example 3*:
-``` cpp
-template<int* p> class X { };
-int a[10];
-struct S { int m; static int s; } s;
-X<&a[2]> x3;                    // error: address of array element
-X<&s.m> x4;                     // error: address of non-static member
-X<&s.s> x5;                     // OK: address of static member
-X<&S::s> x6;                    // OK: address of static member
-```
-— *end example*]
-— *end note*]
-[*Note 4*:
 A temporary object is not an acceptable *template-argument* when the
 corresponding *template-parameter* has reference type.
-[*Example 4*:
 ``` cpp
 template<const int& CRI> struct B { ... };
-B<1> b2;                        // error: temporary would be required for template argument
 int c = 1;
-B<c> b1;                        // OK
 ```
 — *end example*]
 — *end note*]
@@ -324,11 +323,11 @@ name of a class template or an alias template, expressed as
 only primary class templates are considered when matching the template
 template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
-Any partial specializations ([[temp.class.spec]]) associated with the
 primary class template or primary variable template are considered when
 a specialization based on the template *template-parameter* is
 instantiated. If a specialization is not visible at the point of
 instantiation, and it would have been selected had it been visible, the
 program is ill-formed, no diagnostic required.
@@ -351,24 +350,25 @@ C<A> c;             // V<int> within C<A> uses the primary template, so c.y.x ha
 ```
 — *end example*]
 A *template-argument* matches a template *template-parameter* `P` when
-`P` is at least as specialized as the *template-argument* `A`. If `P`
-contains a parameter pack, then `A` also matches `P` if each of `A`’s
-template parameters matches the corresponding template parameter in the
-*template-parameter-list* of `P`. Two template parameters match if they
-are of the same kind (type, non-type, template), for non-type
-*template-parameter*s, their types are equivalent ([[temp.over.link]]),
-and for template *template-parameter*s, each of their corresponding
-*template-parameter*s matches, recursively. When `P`’s
-*template-parameter-list* contains a template parameter pack (
-[[temp.variadic]]), the template parameter pack will match zero or more
-template parameters or template parameter packs in the
-*template-parameter-list* of `A` with the same type and form as the
-template parameter pack in `P` (ignoring whether those template
-parameters are template parameter packs).
 [*Example 2*:
 ``` cpp
 template<class T> class A { ... };
@@ -411,27 +411,47 @@ eval<D<int, 17>> eD;            // error: D does not match TT in partial special
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```
 — *end example*]
 A template *template-parameter* `P` is at least as specialized as a
 template *template-argument* `A` if, given the following rewrite to two
 function templates, the function template corresponding to `P` is at
 least as specialized as the function template corresponding to `A`
-according to the partial ordering rules for function templates (
-[[temp.func.order]]). Given an invented class template `X` with the
-template parameter list of `A` (including default arguments):
-- Each of the two function templates has the same template parameters,
-  respectively, as `P` or `A`.
 - Each function template has a single function parameter whose type is a
   specialization of `X` with template arguments corresponding to the
   template parameters from the respective function template where, for
-  each template parameter `PP` in the template parameter list of the
- function template, a corresponding template argument `AA` is formed.
- If `PP` declares a parameter pack, then `AA` is the pack expansion
-  `PP...` ([[temp.variadic]]); otherwise, `AA` is the *id-expression*
   `PP`.
 If the rewrite produces an invalid type, then `P` is not at least as
 specialized as `A`.

 There are three forms of *template-argument*, corresponding to the three
 forms of *template-parameter*: type, non-type and template. The type and
 form of each *template-argument* specified in a *template-id* shall
 match the type and form specified for the corresponding parameter
 declared by the template in its *template-parameter-list*. When the
+parameter declared by the template is a template parameter pack
+[[temp.variadic]], it will correspond to zero or more
 *template-argument*s.
 [*Example 1*:
 ``` cpp
 template <class U> class B {
 private:
   struct S { ... };
 };
+A<B> b;             // error: A has no access to B::S
 ```
 — *end example*]
 When template argument packs or default *template-argument*s are used, a
 Tuple* u;                       // syntax error
 ```
 — *end example*]
+An explicit destructor call [[class.dtor]] for an object that has a type
+that is a class template specialization may explicitly specify the
 *template-argument*s.
 [*Example 6*:
 ``` cpp
 If the use of a *template-argument* gives rise to an ill-formed
 construct in the instantiation of a template specialization, the program
 is ill-formed.
+When name lookup for the name in a *template-id* finds an overload set,
 both non-template functions in the overload set and function templates
 in the overload set for which the *template-argument*s do not match the
 *template-parameter*s are ignored. If none of the function templates
 have matching *template-parameter*s, the program is ill-formed.
 When a *simple-template-id* does not name a function, a default
+*template-argument* is implicitly instantiated [[temp.inst]] when the
 value of that default argument is needed.
 [*Example 7*:
 ``` cpp
 The default argument for `U` is instantiated to form the type
 `S<bool, int>*`.
 — *end example*]
+A *template-argument* followed by an ellipsis is a pack expansion
+[[temp.variadic]].
 ### Template type arguments <a id="temp.arg.type">[[temp.arg.type]]</a>
 A *template-argument* for a *template-parameter* which is a type shall
 be a *type-id*.
 }
 ```
 — *end example*]
+[*Note 1*: A template type argument may be an incomplete type
+[[basic.types]]. — *end note*]
 ### Template non-type arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
+If the type `T` of a *template-parameter* [[temp.param]] contains a
+placeholder type [[dcl.spec.auto]] or a placeholder for a deduced class
+type [[dcl.type.class.deduct]], the type of the parameter is the type
+deduced for the variable `x` in the invented declaration
+``` cpp
+T x = template-argument ;
+```
+If a deduced parameter type is not permitted for a *template-parameter*
+declaration [[temp.param]], the program is ill-formed.
 A *template-argument* for a non-type *template-parameter* shall be a
+converted constant expression [[expr.const]] of the type of the
+*template-parameter*.
+[*Note 1*: If the *template-argument* is an overload set (or the
+address of such, including forming a pointer-to-member), the matching
+function is selected from the set [[over.over]]. — *end note*]
+For a non-type *template-parameter* of reference or pointer type, or for
+each non-static data member of reference or pointer type in a non-type
+*template-parameter* of class type or subobject thereof, the reference
+or pointer value shall not refer to or be the address of (respectively):
+- a temporary object [[class.temporary]],
+- a string literal object [[lex.string]],
+- the result of a `typeid` expression [[expr.typeid]],
+- a predefined `__func__` variable [[dcl.fct.def.general]], or
+- a subobject [[intro.object]] of one of the above.
 [*Example 1*:
 ``` cpp
 template<const int* pci> struct X { ... };
 template<void (*pf)(int)> struct A { ... };
 A<&f> a;                        // selects f(int)
 template<auto n> struct B { ... };
+B<5> b1;                        // OK, template parameter type is int
+B<'a'> b2;                      // OK, template parameter type is char
+B<2.5> b3;                      // OK, template parameter type is double
+B<void(0)> b4;                  // error: template parameter type cannot be void
 ```
 — *end example*]
 [*Note 2*:
+A *string-literal* [[lex.string]] is not an acceptable
+*template-argument* for a *template-parameter* of non-class type.
 [*Example 2*:
 ``` cpp
+template<class T, T p> class X {
   ...
 };
+X<const char*, "Studebaker"> x; // error: string literal object as template-argument
+X<const char*, "Knope" + 1> x2; // error: subobject of string literal object as template-argument
 const char p[] = "Vivisectionist";
+X<const char*, p> y; // OK
+struct A {
+  constexpr A(const char*) {}
+};
+X<A, "Pyrophoricity"> z;        // OK, string-literal is a constructor argument to A
 ```
 — *end example*]
 — *end note*]
 [*Note 3*:
 A temporary object is not an acceptable *template-argument* when the
 corresponding *template-parameter* has reference type.
+[*Example 3*:
 ``` cpp
 template<const int& CRI> struct B { ... };
+B<1> b1;                        // error: temporary would be required for template argument
 int c = 1;
+B<c> b2;                        // OK
+struct X { int n; };
+struct Y { const int &r; };
+template<Y y> struct C { ... };
+C<Y{X{1}.n}> c;                 // error: subobject of temporary object used to initialize
+                                // reference member of template parameter
 ```
 — *end example*]
 — *end note*]
 only primary class templates are considered when matching the template
 template argument with the corresponding parameter; partial
 specializations are not considered even if their parameter lists match
 that of the template template parameter.
+Any partial specializations [[temp.class.spec]] associated with the
 primary class template or primary variable template are considered when
 a specialization based on the template *template-parameter* is
 instantiated. If a specialization is not visible at the point of
 instantiation, and it would have been selected had it been visible, the
 program is ill-formed, no diagnostic required.
 ```
 — *end example*]
 A *template-argument* matches a template *template-parameter* `P` when
+`P` is at least as specialized as the *template-argument* `A`. In this
+comparison, if `P` is unconstrained, the constraints on `A` are not
+considered. If `P` contains a template parameter pack, then `A` also
+matches `P` if each of `A`’s template parameters matches the
+corresponding template parameter in the *template-head* of `P`. Two
+template parameters match if they are of the same kind (type, non-type,
+template), for non-type *template-parameter*s, their types are
+equivalent [[temp.over.link]], and for template *template-parameter*s,
+each of their corresponding *template-parameter*s matches, recursively.
+When `P`’s *template-head* contains a template parameter pack
+[[temp.variadic]], the template parameter pack will match zero or more
+template parameters or template parameter packs in the *template-head*
+of `A` with the same type and form as the template parameter pack in `P`
+(ignoring whether those template parameters are template parameter
+packs).
 [*Example 2*:
 ``` cpp
 template<class T> class A { ... };
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```
 — *end example*]
+[*Example 4*:
+``` cpp
+template<typename T> concept C = requires (T t) { t.f(); };
+template<typename T> concept D = C<T> && requires (T t) { t.g(); };
+template<template<C> class P> struct S { };
+template<C> struct X { };
+template<D> struct Y { };
+template<typename T> struct Z { };
+S<X> s1;            // OK, X and P have equivalent constraints
+S<Y> s2;            // error: P is not at least as specialized as Y
+S<Z> s3;            // OK, P is at least as specialized as Z
+```
+— *end example*]
 A template *template-parameter* `P` is at least as specialized as a
 template *template-argument* `A` if, given the following rewrite to two
 function templates, the function template corresponding to `P` is at
 least as specialized as the function template corresponding to `A`
+according to the partial ordering rules for function templates
+[[temp.func.order]]. Given an invented class template `X` with the
+*template-head* of `A` (including default arguments and
+*requires-clause*, if any):
+- Each of the two function templates has the same template parameters
+ and *requires-clause* (if any), respectively, as `P` or `A`.
 - Each function template has a single function parameter whose type is a
   specialization of `X` with template arguments corresponding to the
   template parameters from the respective function template where, for
+  each template parameter `PP` in the *template-head* of the function
+  template, a corresponding template argument `AA` is formed. If `PP`
+  declares a template parameter pack, then `AA` is the pack expansion
+  `PP...` [[temp.variadic]]; otherwise, `AA` is the *id-expression*
   `PP`.
 If the rewrite produces an invalid type, then `P` is not at least as
 specialized as `A`.

Diff to HTML by rtfpessoa