模板实参

template<auto n>
struct B { /* ... */ };
 
B<5> b1;   // OK：常量模板形参的类型是 int
B<'a'> b2; // OK：常量模板形参的类型是 char
B<2.5> b3; // 错误（C++20 前）：常量模板形参的类型不能是 double
 
// C++20 的推导类类型占位符，在调用处推导类模板实参
template<std::array arr>
void f();
 
f<std::array<double, 8>{}>();
 
template<auto...>
struct C {};
 
C<'C', 0, 2L, nullptr> x; // OK

template<int i>
struct C { /* ... */ };
 
C<{42}> c1; // OK
 
template<auto n>
struct B { /* ... */ };
 
struct J1
{
    J1* self = this;
};
 
B<J1{}> j1; // 错误：模板形参对象的初始化不是常量表达式
 
struct J2
{
    J2 *self = this;
    constexpr J2() {}
    constexpr J2(const J2&) {}
};
 
B<J2{}> j2; // 错误：模板形参对象与引入的临时量并不模板实参等价

template<const int* pci>
struct X {};
 
int ai[10];
X<ai> xi; // OK：数组到指针转换和 cv 限定转换
 
struct Y {};
 
template<const Y& b>
struct Z {};
 
Y y;
Z<y> z;   // OK：没有转换
 
template<int (&pa)[5]>
struct W {};
 
int b[5];
W<b> w;   // OK：没有转换
 
void f(char);
void f(int);
 
template<void (*pf)(int)>
struct A {};
 
A<&f> a;  // OK：重载决议选择 f(int)

template<class T, const char* p>
class X {};
 
X<int, "Studebaker"> x1; // 错误：将字符串字面量用作模板实参
 
template<int* p>
class X {};
 
int a[10];
 
struct S
{
    int m;
    static int s;
} s;
 
X<&a[2]> x3; // 错误（C++20 前）：数组元素的地址
X<&s.m> x4;  // 错误（C++20 前）：非静态成员的地址
X<&s.s> x5;  // OK：静态成员的地址
X<&S::s> x6; // OK：静态成员的地址
 
template<const int& CRI>
struct B {};
 
B<1> b2;     // 错误：模板实参要求临时量
int c = 1;
B<c> b1;     // OK

template<typename T>
class X {}; // 类模板
 
struct A;            // 不完整类型
typedef struct {} B; // 无名类型的类型别名
 
int main()
{
    X<A> x1;  // OK：'A' 指名类型
    X<A*> x2; // OK：'A*' 指名类型
    X<B> x3;  // OK：'B' 指名类型
}

template<typename T> // 主模板
class A { int x; };
 
template<typename T> // 部分特化
class A<T*> { long x; };
 
// 带有模板模板形参 V 的类模板
template<template<typename> class V>
class C
{
    V<int> y;  // 使用主模板
    V<int*> z; // 使用部分特化
};
 
C<A> c; // c.y.x 的类型是 int，c.z.x 的类型是 long

template<typename T>
struct eval;                     // 主模板 
 
template<template<typename, typename...> class TT, typename T1, typename... Rest>
struct eval<TT<T1, Rest...>> {}; // eval 的部分特化
 
template<typename T1> struct A;
template<typename T1, typename T2> struct B;
template<int N> struct C;
template<typename T1, int N> struct D;
template<typename T1, typename T2, int N = 17> struct E;
 
eval<A<int>> eA;        // OK：匹配 eval 的部分特化
eval<B<int, float>> eB; // OK：匹配 eval 的部分特化
eval<C<17>> eC;         // 错误：C 在部分特化中不匹配 TT，因为 TT 的首个形参是类型模板形参
                        // 而 17 不指名类型
eval<D<int, 17>> eD;    // 错误：D 在部分特化中不匹配 TT，
                        // 因为 TT 的第二个形参是类型形参包，而 17 不指名类型
eval<E<int, float>> eE; // 错误：E 在部分特化中不匹配 TT
                        // 因为 E 的第三个（默认）形参是常量形参

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 { /* ... */ };
X<A> xa; // OK
X<B> xb; // 在 P0552R0 后 OK；之前是错误的：非严格匹配
X<C> xc; // 在 P0552R0 后 OK；之前是错误的：非严格匹配
 
template<template<class...> class Q> class Y { /* ... */ };
Y<A> ya; // OK
Y<B> yb; // OK
Y<C> yc; // OK
 
template<auto n> class D { /* ... */ };   // 注意：C++17
template<template<int> class R> class Z { /* ... */ };
Z<D> zd; // 在 P0552R0 后 OK：模板形参比模板实参更特殊
 
template<int> struct SI { /* ... */ };
template<template<auto> class> void FA(); // 注意：C++17
FA<SI>(); // 错误

template<class T>
void f(); // #1
 
template<int I>
void f(); // #2
 
void g()
{
    f<int()>(); // “int()” 既是类型又是表达式，
                // 因为它被解释成类型，所以调用 #1
}