13 Templates [temp]

13.4 Template arguments [temp.arg]

13.4.3 Constant template arguments [temp.arg.nontype]

A template argument E for a constant template parameter with declared type T shall be such that the invented declaration 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 template parameter declaration ([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 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,

(4.1)
the initialization would be ill-formed, or
(4.2)
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
(4.3)
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):

(6.1)
a temporary object ([class.temporary]),
(6.2)
a string literal object ([lex.string]),
(6.3)
the result of a typeid expression ([expr.typeid]),
(6.4)
a predefined __func__ variable ([dcl.fct.def.general]), or
(6.5)
a subobject ([intro.object]) of one of the above.

[Example 1: 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: 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; // 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: 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 4: 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]