12 Templates [temp]

12.3 Template arguments [temp.arg]

12.3.2 Template non-type arguments [temp.arg.nontype]

1
#
If the type T of a template-parameter 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 
  T x = template-argument ;
If a deduced parameter type is not permitted for a template-parameter declaration ([temp.param]), the program is ill-formed.
2
#
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, 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):
[ Note
:
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
 ]
3
#
[ Example
: 
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
 ]
4
#
[ Note
:
A string literal ([lex.string]) is not an acceptable template-argument for a template-parameter of non-class type.
[ Example
: 
template<class T, T p> class X {
  /* ... */
};

X<const char*, "Studebaker"> x; // error: string literal as template-argument

const char p[] = "Vivisectionist";
X<const char*, p> y;            // OK

class A {
  constexpr A(const char*) {}
  auto operator<=>(A, A) = default;
};

X<A, "Pyrophoricity"> z;        // OK, string literal is a constructor argument to A
— end example
 ]
— end note
 ]
5
#
[ Note
:
The address of an array element or non-static data member is not an acceptable template-argument.
[ Example
: 
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
 ]
6
#
[ Note
:
A temporary object is not an acceptable template-argument when the corresponding template-parameter has reference type.
[ Example
: 
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
 ]