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

Files changed (1) hide show

tmp/tmpvrrxzkr1/{from.md → to.md} +36 -31

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

@@ -172,22 +172,24 @@ 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
- an 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*, 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]].
 A string literal ([[lex.string]]) does not satisfy the requirements of
 any of these categories and thus is not an acceptable
 *template-argument*.
@@ -241,18 +243,17 @@ the program is ill-formed.
 - 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 integral constant expression (
- [[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.
@@ -308,15 +309,15 @@ 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 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;
 };
@@ -331,10 +332,26 @@ 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
 ```
 ``` cpp
 template<class T> class A { /* ... */ };
 template<class T, class U = T> class B { /* ... */ };
 template <class ... Types> class C { /* ... */ };
@@ -348,22 +365,10 @@ X<C> xc;            // ill-formed: a template parameter pack does not match a te
 Y<A> ya;            // OK
 Y<B> yb;            // OK
 Y<C> yc;            // OK
 ```
-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`. 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> struct eval;
 template <template <class, class...> class TT, class T1, class... Rest>
 struct eval<TT<T1, Rest...>> { };

 - 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*.
 - 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.
 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 is required.
 ``` cpp
 template<class T> class A {     // primary template
   int x;
 };
                                 // 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 { /* ... */ };
 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...>> { };

Diff to HTML by rtfpessoa