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

Files changed (1) hide show

tmp/tmp16dn37ig/{from.md → to.md} +51 -52

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

@@ -1,29 +1,37 @@
 ### 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 { ... };
@@ -45,76 +53,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*]

 ### 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*]

Diff to HTML by rtfpessoa