[temp.arg] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpzyzoje51/{from.md → to.md} +146 -74

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

@@ -1,17 +1,15 @@
 ## Template arguments <a id="temp.arg">[[temp.arg]]</a>
 ### General <a id="temp.arg.general">[[temp.arg.general]]</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 T> class Array {
@@ -43,11 +41,11 @@ is a template parameter pack [[temp.variadic]], the nᵗʰ template
 argument is a pack expansion whose pattern is the name of the template
 parameter pack.
 In a *template-argument*, an ambiguity between a *type-id* and an
 expression is resolved to a *type-id*, regardless of the form of the
-corresponding *template-parameter*.[^3]
 [*Example 2*:
 ``` cpp
 template<class T> void f();
@@ -59,12 +57,13 @@ void g() {
 ```
 — *end example*]
 [*Note 1*: Names used in a *template-argument* are subject to access
-control where they appear. Because a *template-parameter* is not a class
-member, no access control applies. — *end note*]
 [*Example 3*:
 ``` cpp
 template<class T> class X {
@@ -82,13 +81,13 @@ private:
 X<Y::S> y;          // error: S not accessible
 ```
 — *end example*]
-For a *template-argument* that is a class type or a class template, the
 template definition has no special access rights to the members of the
-*template-argument*.
 [*Example 4*:
 ``` cpp
 template <template <class TT> class T> class A {
@@ -103,11 +102,11 @@ private:
 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
 *template-argument* list can be empty. In that case the empty `<>`
 brackets shall still be used as the *template-argument-list*.
 [*Example 5*:
@@ -138,25 +137,26 @@ void f(A<int>* p, A<int>* q) {
 }
 ```
 — *end example*]
-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 component name of 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.
 [*Note 2*: If none of the function templates have matching
 *template-parameter*s, the program is ill-formed. — *end note*]
-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
 template<typename T, typename U = int> struct S { };
@@ -169,14 +169,14 @@ The default argument for `U` is instantiated to form the type
 — *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*.
 [*Example 1*:
 ``` cpp
 template <class T> class X { };
@@ -200,45 +200,92 @@ void f() {
 — *end example*]
 [*Note 1*: A template type argument can be an incomplete type
 [[term.incomplete.type]]. — *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 { ... };
 int ai[10];
 X<ai> xi;                       // array to pointer and qualification conversions
@@ -261,20 +308,35 @@ 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 {
   ...
 };
@@ -297,13 +359,13 @@ X<A, "Pyrophoricity"> z;        // OK, string-literal is a constructor argument
 — *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
@@ -322,21 +384,23 @@ C<Y{X{1}.n}> c;                 // error: subobject of temporary object used to
 — *end note*]
 ### Template template arguments <a id="temp.arg.template">[[temp.arg.template]]</a>
-A *template-argument* for a template *template-parameter* shall be the
-name of a class template or an alias template, expressed as
-*id-expression*. Only primary 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.spec.partial]] associated with the
 primary template are considered when a specialization based on the
-template *template-parameter* is instantiated. If a specialization is
-not reachable from the point of instantiation, and it would have been
 selected had it been reachable, the program is ill-formed, no diagnostic
 required.
 [*Example 1*:
@@ -355,26 +419,34 @@ C<A> c;             // V<int> within C<A> uses the primary template, so c.y.x ha
                     // V<int*> within C<A> uses the partial specialization, so c.z.x has type long
 ```
 — *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 { ... };
@@ -436,11 +508,11 @@ 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
@@ -450,14 +522,14 @@ according to the partial ordering rules for function templates
 - 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`.

 ## Template arguments <a id="temp.arg">[[temp.arg]]</a>
 ### General <a id="temp.arg.general">[[temp.arg.general]]</a>
+The type and form of each *template-argument* specified in a
+*template-id* or in a *splice-specialization-specifier* 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 T> class Array {
 argument is a pack expansion whose pattern is the name of the template
 parameter pack.
 In a *template-argument*, an ambiguity between a *type-id* and an
 expression is resolved to a *type-id*, regardless of the form of the
+corresponding *template-parameter*.[^2]
 [*Example 2*:
 ``` cpp
 template<class T> void f();
 ```
 — *end example*]
 [*Note 1*: Names used in a *template-argument* are subject to access
+control where they appear. Because a template parameter is not a class
+member, no access control applies where the template parameter is
+used. — *end note*]
 [*Example 3*:
 ``` cpp
 template<class T> class X {
 X<Y::S> y;          // error: S not accessible
 ```
 — *end example*]
+For a template argument that is a class type or a class template, the
 template definition has no special access rights to the members of the
+template argument.
 [*Example 4*:
 ``` cpp
 template <template <class TT> class T> class A {
 A<B> b;             // error: A has no access to B::S
 ```
 — *end example*]
+When template argument packs or default template arguments are used, a
 *template-argument* list can be empty. In that case the empty `<>`
 brackets shall still be used as the *template-argument-list*.
 [*Example 5*:
 }
 ```
 — *end example*]
+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 component name of 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.
 [*Note 2*: If none of the function templates have matching
 *template-parameter*s, the program is ill-formed. — *end note*]
+When a *simple-template-id* or *splice-specialization-specifier* does
+not designate a function, a default *template-argument* is implicitly
+instantiated [[temp.inst]] when the value of that default argument is
+needed.
 [*Example 7*:
 ``` cpp
 template<typename T, typename U = int> struct S { };
 — *end example*]
 A *template-argument* followed by an ellipsis is a pack expansion
 [[temp.variadic]].
+### Type template arguments <a id="temp.arg.type">[[temp.arg.type]]</a>
+A *template-argument* for a type template parameter shall be a
+*type-id*.
 [*Example 1*:
 ``` cpp
 template <class T> class X { };
 — *end example*]
 [*Note 1*: A template type argument can be an incomplete type
 [[term.incomplete.type]]. — *end note*]
+### Constant template arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
+A template argument E for a constant template parameter with declared
+type `T` shall be such that the invented declaration
 ``` cpp
+T x = E ;
 ```
+satisfies the semantic constraints for the definition of a `constexpr`
+variable with static storage duration [[dcl.constexpr]]. If `T` 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
+deduced from the above declaration.
+[*Note 1*: E is a *template-argument* or (for a default template
+argument) an *initializer-clause*. — *end note*]
+If the parameter type thus deduced is not permitted for a constant
+template parameter [[temp.param]], the program is ill-formed.
+The value of a constant template parameter P of (possibly deduced) type
+`T` is determined from its template argument A as follows. If `T` is not
+a class type and A is not a *braced-init-list*, A shall be a converted
+constant expression [[expr.const]] of type `T`; the value of P is A (as
+converted).
+Otherwise, a temporary variable
+``` cpp
+constexpr T v = A;
+```
+is introduced. The lifetime of `v` ends immediately after initializing
+it and any template parameter object (see below). For each such
+variable, the *id-expression* `v` is termed a *candidate initializer*.
+If `T` is a class type, a template parameter object [[temp.param]]
+exists that is constructed so as to be template-argument-equivalent to
+`v`; P denotes that template parameter object. P is copy-initialized
+from an unspecified candidate initializer that is
+template-argument-equivalent to `v`. If, for the initialization from any
+candidate initializer,
+- the initialization would be ill-formed, or
+- the full-expression of an invented *init-declarator* for the
+  initialization would not be a constant expression when interpreted as
+  a *constant-expression* [[expr.const]], or
+- the initialization would cause P to not be
+  template-argument-equivalent [[temp.type]] to `v`,
+the program is ill-formed.
+Otherwise, the value of P is that of v.
+For a constant template parameter of reference or pointer type, or for
+each non-static data member of reference or pointer type in a constant
+template parameter of class type or subobject thereof, the reference or
+pointer value shall not refer or point to (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 <int& r> class A{};
+extern int x;
+A<x> a;                 // OK
+void f(int p) {
+  constexpr int& r = p; // OK
+  A<r> a;               // error: a static constexpr int& variable cannot be initialized to refer to p here
+}
+```
+— *end example*]
+[*Example 2*:
 ``` cpp
 template<const int* pci> struct X { ... };
 int ai[10];
 X<ai> xi;                       // array to pointer and qualification conversions
 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
+template<int i> struct C { /* ... */ };
+C<{ 42 }> c1;   // OK
+struct J1 {
+  J1 *self = this;
+};
+B<J1{}> j1;     // error: initialization of template parameter object is not a constant expression
+struct J2 {
+  J2 *self = this;
+  constexpr J2() {}
+  constexpr J2(const J2&) {}
+};
+B<J2{}> j2;     // error: template parameter object not template-argument-equivalent to introduced temporary
 ```
 — *end example*]
 [*Note 2*:
 A *string-literal* [[lex.string]] is not an acceptable
+*template-argument* for a constant template parameter of non-class type.
+[*Example 3*:
 ``` cpp
 template<class T, T p> class X {
   ...
 };
 — *end note*]
 [*Note 3*:
 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> b1;                        // error: temporary would be required for template argument
 — *end note*]
 ### Template template arguments <a id="temp.arg.template">[[temp.arg.template]]</a>
+A *template-argument* for a template template parameter shall be the
+name of a template. For a *type-tt-parameter*, the name shall denote a
+class template or alias template. For a *variable-tt-parameter*, the
+name shall denote a variable template. For a *concept-tt-parameter*, the
+name shall denote a concept. Only primary 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.spec.partial]] associated with the
 primary template are considered when a specialization based on the
+template template parameter is instantiated. If a specialization is not
+reachable from the point of instantiation, and it would have been
 selected had it been reachable, the program is ill-formed, no diagnostic
 required.
 [*Example 1*:
                     // V<int*> within C<A> uses the partial specialization, so c.z.x has type long
 ```
 — *end example*]
+A template template parameter `P` and a *template-argument* `A` are
+*compatible* if
+- `A` denotes a class template or an alias template and `P` is a type
+  template template parameter,
+- `A` denotes a variable template and `P` is a variable template
+ template parameter, or
+- `A` denotes a concept and `P` is a concept template parameter.
+A template *template-argument* `A` matches a template template parameter
+`P` when `A` and `P` are compatible and `P` is at least as specialized
+as `A`, ignoring constraints on `A` if `P` is unconstrained. If `P`
+contains a template parameter pack, then `A` also matches `P` if each of
+`A`’s template parameters matches the corresponding template parameter
+declared in the *template-head* of `P`. Two template parameters match if
+they are of the same kind, for constant template parameters, their types
+are equivalent [[temp.over.link]], and for template template parameters,
+each of their corresponding template parameters matches, recursively.
+When `P`’s *template-head* contains a *template-parameter* that declares
+a template parameter pack [[temp.variadic]], the template parameter pack
+will match zero or more template parameters or template parameter packs
+declared in the *template-head* of `A` with the same type and form as
+the template parameter pack declared in `P` (ignoring whether those
+template parameters are template parameter packs).
 [*Example 2*:
 ``` cpp
 template<class T> class A { ... };
 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
 - 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 an *id-expression*
+ denoting `PP`.
 If the rewrite produces an invalid type, then `P` is not at least as
 specialized as `A`.

Diff to HTML by rtfpessoa