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

Files changed (1) hide show

tmp/tmp3zz89g2c/{from.md → to.md} +199 -150

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

@@ -7,10 +7,12 @@ 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.
 ``` cpp
 template<class T> class Array {
   T* v;
   int sz;
 public:
@@ -18,119 +20,159 @@ public:
   T& operator[](int);
   T& elem(int i) { return v[i]; }
 };
 Array<int> v1(20);
-typedef std::complex<double> dcomplex;  // std::complex is a standard
-                                        // library template
 Array<dcomplex> v2(30);
 Array<dcomplex> v3(40);
 void bar() {
   v1[3] = 7;
   v2[3] = v3.elem(4) = dcomplex(7,8);
 }
 ```
 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]
 ``` cpp
 template<class T> void f();
 template<int I> void f();
 void g() {
   f<int()>();       // int() is a type-id: call the first f()
 }
 ```
 The name of a *template-argument* shall be accessible at the point where
-it is used as a *template-argument*. If the name of the
-*template-argument* is accessible at the point where it is used as a
-*template-argument*, there is no further access restriction in the
-resulting instantiation where the corresponding *template-parameter*
-name is used.
 ``` cpp
 template<class T> class X {
   static T t;
 };
 class Y {
 private:
-  struct S { /* ... */ };
   X<S> x;           // OK: S is accessible
                     // X<Y::S> has a static member of type Y::S
                     // OK: even though Y::S is private
 };
 X<Y::S> y;          // error: S not accessible
 ```
 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*.
 ``` cpp
 template <template <class TT> class T> class A {
   typename T<int>::S s;
 };
 template <class U> class B {
 private:
-  struct S { /* ... */ };
 };
 A<B> b;             // ill-formed: A has no access to B::S
 ```
 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.*
 ``` cpp
 template<class T = char> class String;
 String<>* p;                    // OK: String<char>
 String* q;                      // syntax error
 template<class ... Elements> class Tuple;
 Tuple<>* t;                     // OK: Elements is empty
 Tuple* u;                       // syntax error
 ```
 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.
 ``` cpp
 template<class T> struct A {
   ~A();
 };
 void f(A<int>* p, A<int>* q) {
   p->A<int>::~A();              // OK: destructor call
   q->A<int>::~A<int>();         // OK: destructor call
 }
 ```
 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.
 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*.
 ``` cpp
 template <class T> class X { };
 template <class T> void f(T t) { }
 struct { } unnamed_obj;
@@ -146,161 +188,135 @@ void f() {
   f(unnamed_obj);   // OK
   f(b);             // OK
 }
 ```
-A template type argument may be an incomplete type ([[basic.types]]).
-If a declaration acquires a function type through a type dependent on a
-*template-parameter* and this causes a declaration that does not use the
-syntactic form of a function declarator to have function type, the
-program is ill-formed.
-``` cpp
-template<class T> struct A {
-  static T t;
-};
-typedef int function();
-A<function> a;                  // ill-formed: would declare A<function>::t
-                                // as a static member function
-```
 ### Template non-type arguments <a id="temp.arg.nontype">[[temp.arg.nontype]]</a>
-A *template-argument* for a non-type, non-template *template-parameter*
-shall be one of:
-- for a non-type *template-parameter* of integral or enumeration type, a
 converted constant expression ([[expr.const]]) of the type of the
- *template-parameter*; or
-- the name of a non-type *template-parameter*; or
-- a constant expression ([[expr.const]]) that designates the address of
-  a complete object with static storage duration and external or
-  internal linkage or a function with external or internal linkage,
-  including function templates and function *template-id*s but excluding
-  non-static class members, expressed (ignoring parentheses) as `&`
-  *id-expression*, where the *id-expression* is the name of an object or
-  function, except that the `&` may be omitted if the name refers to a
-  function or array and shall be omitted if the corresponding
- *template-parameter* is a reference; or
-- a constant expression that evaluates to a null pointer value (
- [[conv.ptr]]); or
-- a constant expression that evaluates to a null member pointer value (
- [[conv.mem]]); or
-- a pointer to member expressed as described in  [[expr.unary.op]]; or
-- a constant expression of type `std::nullptr_t`.
-A string literal ([[lex.string]]) does not satisfy the requirements of
-any of these categories and thus is not an acceptable
 *template-argument*.
 ``` 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
 ```
-Addresses of array elements and names or addresses of non-static class
-members are not acceptable *template-argument*s.
 ``` 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;                     // error: &S::s must be used
 X<&S::s> x6;                    // OK: address of static member
 ```
-Temporaries, unnamed lvalues, and named lvalues with no linkage are not
-acceptable *template-argument*s when the corresponding
-*template-parameter* has reference type.
 ``` 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
 ```
-The following conversions are performed on each expression used as a
-non-type *template-argument*. If a non-type *template-argument* cannot
-be converted to the type of the corresponding *template-parameter* then
-the program is ill-formed.
-- For a non-type *template-parameter* of integral or enumeration type,
-  conversions permitted in a converted constant expression (
-  [[expr.const]]) are applied.
-- for a non-type *template-parameter* of type pointer to object,
-  qualification conversions ([[conv.qual]]) and the array-to-pointer
-  conversion ([[conv.array]]) are applied; if the *template-argument*
-  is of type `std::nullptr_t`, the null pointer conversion (
-  [[conv.ptr]]) is applied. In particular, neither the null pointer
-  conversion for a zero-valued integer literal ([[conv.ptr]]) nor the
-  derived-to-base conversion ([[conv.ptr]]) are applied. Although `0`
-  is a valid *template-argument* for a non-type *template-parameter* of
-  integral type, it is not a valid *template-argument* for a non-type
-  *template-parameter* of pointer type. However, both `(int*)0` and
-  `nullptr` are valid *template-argument*s for a non-type
-  *template-parameter* of type “pointer to int.”
-- For a non-type *template-parameter* of type reference to object, no
-  conversions apply. The type referred to by the reference may be more
-  cv-qualified than the (otherwise identical) type of the
-  *template-argument*. The *template-parameter* is bound directly to the
-  *template-argument*, which shall be an lvalue.
-- For a non-type *template-parameter* of type pointer to function, the
-  function-to-pointer conversion ([[conv.func]]) is applied; if the
-  *template-argument* is of type `std::nullptr_t`, the null pointer
-  conversion ([[conv.ptr]]) is applied. If the *template-argument*
-  represents a set of overloaded functions (or a pointer to such), the
-  matching function is selected from the set ([[over.over]]).
-- For a non-type *template-parameter* of type reference to function, no
-  conversions apply. If the *template-argument* represents a set of
-  overloaded functions, the matching function is selected from the set (
-  [[over.over]]).
-- For a non-type *template-parameter* of type pointer to member
-  function, if the *template-argument* is of type `std::nullptr_t`, the
-  null member pointer conversion ([[conv.mem]]) is applied; otherwise,
-  no conversions apply. If the *template-argument* represents a set of
-  overloaded member functions, the matching member function is selected
-  from the set ([[over.over]]).
-- For a non-type *template-parameter* of type pointer to data member,
-  qualification conversions ([[conv.qual]]) are applied; if the
-  *template-argument* is of type `std::nullptr_t`, the null member
-  pointer conversion ([[conv.mem]]) is applied.
-``` cpp
-template<const int* pci> struct X { /* ... */ };
-int ai[10];
-X<ai> xi;                       // array to pointer and qualification conversions
-struct Y { /* ... */ };
-template<const Y& b> struct Z { /* ... */ };
-Y y;
-Z<y> z;                         // no conversion, but note extra cv-qualification
-template<int (&pa)[5]> struct W { /* ... */ };
-int b[5];
-W<b> w;                         // no conversion
-void f(char);
-void f(int);
-template<void (*pf)(int)> struct A { /* ... */ };
-A<&f> a;                        // selects f(int)
-```
 ### 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
@@ -313,11 +329,13 @@ 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 is required.
 ``` cpp
 template<class T> class A {     // primary template
   int x;
 };
@@ -326,49 +344,56 @@ template<class T> class A<T*> { // partial specialization
 };
 template<template<class U> class V> class C {
   V<int>  y;
   V<int*> z;
 };
-C<A> c; // V<int> within C<A> uses the primary template,
- // so c.y.x has type int
-                                // V<int*> within C<A> uses the partial specialization,
-                                // so c.z.x has type long
 ```
-A *template-argument* matches a template *template-parameter* (call it
-`P`) when each of the template parameters in the
-*template-parameter-list* of the *template-argument*’s corresponding
-class template or alias template (call it `A`) 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).
 ``` cpp
-template<class T> class A { /* ... */ };
-template<class T, class U = T> class B { /* ... */ };
-template <class ... Types> class C { /* ... */ };
-template<template<class> class P> class X { /* ... */ };
-template<template<class ...> class Q> class Y { /* ... */ };
 X<A> xa;            // OK
-X<B> xb;            // ill-formed: default arguments for the parameters of a template argument are ignored
-X<C> xc;            // ill-formed: a template parameter pack does not match a template parameter
 Y<A> ya;            // OK
 Y<B> yb;            // OK
 Y<C> yc;            // OK
 ```
 ``` cpp
 template <class T> struct eval;
 template <template <class, class...> class TT, class T1, class... Rest>
 struct eval<TT<T1, Rest...>> { };
@@ -384,5 +409,29 @@ eval<B<int, float>> eB;         // OK: matches partial specialization of eval
 eval<C<17>> eC;                 // error: C does not match TT in partial specialization
 eval<D<int, 17>> eD;            // error: D does not match TT in partial specialization
 eval<E<int, float>> eE;         // error: E does not match TT in partial specialization
 ```

 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 {
   T* v;
   int sz;
 public:
   T& operator[](int);
   T& elem(int i) { return v[i]; }
 };
 Array<int> v1(20);
+typedef std::complex<double> dcomplex;  // std::complex is a standard library template
 Array<dcomplex> v2(30);
 Array<dcomplex> v3(40);
 void bar() {
   v1[3] = 7;
   v2[3] = v3.elem(4) = dcomplex(7,8);
 }
 ```
+— *end example*]
 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();
 template<int I> void f();
 void g() {
   f<int()>();       // int() is a type-id: call the first f()
 }
 ```
+— *end example*]
 The name of a *template-argument* shall be accessible at the point where
+it is used as a *template-argument*.
+[*Note 1*: If the name of the *template-argument* is accessible at the
+point where it is used as a *template-argument*, there is no further
+access restriction in the resulting instantiation where the
+corresponding *template-parameter* name is used. — *end note*]
+[*Example 3*:
 ``` cpp
 template<class T> class X {
   static T t;
 };
 class Y {
 private:
+  struct S { ... };
   X<S> x;           // OK: S is accessible
                     // X<Y::S> has a static member of type Y::S
                     // OK: even though Y::S is 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 {
   typename T<int>::S s;
 };
 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
 *template-argument* list can be empty. In that case the empty `<>`
+brackets shall still be used as the *template-argument-list*.
+[*Example 5*:
 ``` cpp
 template<class T = char> class String;
 String<>* p;                    // OK: String<char>
 String* q;                      // syntax error
 template<class ... Elements> class Tuple;
 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
 template<class T> struct A {
   ~A();
 };
 void f(A<int>* p, A<int>* q) {
   p->A<int>::~A();              // OK: destructor call
   q->A<int>::~A<int>();         // OK: destructor call
 }
 ```
+— *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 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
+template<typename T, typename U = int> struct S { };
+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*.
+[*Example 1*:
 ``` cpp
 template <class T> class X { };
 template <class T> void f(T t) { }
 struct { } unnamed_obj;
   f(unnamed_obj);   // OK
   f(b);             // OK
 }
 ```
+— *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 { ... };
+int ai[10];
+X<ai> xi;                       // array to pointer and qualification conversions
+struct Y { ... };
+template<const Y& b> struct Z { ... };
+Y y;
+Z<y> z;                         // no conversion, but note extra cv-qualification
+template<int (&pa)[5]> struct W { ... };
+int b[5];
+W<b> w;                         // no conversion
+void f(char);
+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*]
 ### 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
 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.
+[*Example 1*:
 ``` cpp
 template<class T> class A {     // primary template
   int x;
 };
 };
 template<template<class U> class V> class C {
   V<int>  y;
   V<int*> z;
 };
+C<A> c; // V<int> within C<A> uses the primary template, so c.y.x has type int
+ // 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`. 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 { ... };
+template<class T, class U = T> class B { ... };
+template<class ... Types> class C { ... };
+template<auto n> class D { ... };
+template<template<class> class P> class X { ... };
+template<template<class ...> class Q> class Y { ... };
+template<template<int> class R> class Z { ... };
 X<A> xa;            // OK
+X<B> xb;            // OK
+X<C> xc;            // OK
 Y<A> ya;            // OK
 Y<B> yb;            // OK
 Y<C> yc;            // OK
+Z<D> zd;            // OK
 ```
+— *end example*]
+[*Example 3*:
 ``` cpp
 template <class T> struct eval;
 template <template <class, class...> class TT, class T1, class... Rest>
 struct eval<TT<T1, Rest...>> { };
 eval<C<17>> eC;                 // error: C does not match TT in partial specialization
 eval<D<int, 17>> eD;            // error: D does not match TT in partial specialization
 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`.

Diff to HTML by rtfpessoa