允许为给定类别的模板实参定制类模板或变量模板 (C++14 起)。

语法

其中 类头名 标识先前声明的类模板，而 声明符 标识先前声明的变量模板 (C++14 起)。此声明必须与它所特化的主模板定义处于相同的命名空间中，或对于成员模板，处于相同的类作用域中。

例如，

template<class T1, class T2, int I>
class A {};            // 主模板
 
template<class T, int I>
class A<T, T*, I> {};  // #1：部分特化，其中 T2 是指向 T1 的指针
 
template<class T, class T2, int I>
class A<T*, T2, I> {}; // #2：部分特化，其中 T1 是指针
 
template<class T>
class A<int, T*, 5> {}; // #3：部分特化，其中 T1 是 int，I 是 5，而 T2 是指针
 
template<class X, class T, int I>
class A<X, T*, I> {};   // #4：部分特化，其中 T2 是指针

标准库中的部分特化的例子包含 std::unique_ptr，它对数组类型有部分特化。

实参列表

下列限制应用于部分模板特化的 实参列表：

1) 实参列表不能与非特化的实参列表相同（它必须有所特化）

template<class T1, class T2, int I> class B {}; // 主模板
template<class X, class Y, int N> class B<X,Y,N> {}; // 错误

template<int N, typename T1, typename… Ts> struct B;
template<typename… Ts> struct B<0, Ts…> { }; // 错误：并不更特殊

2) 实参列表中不能出现默认实参

3) 若有任何实参是包展开，则它必须是列表中的最末实参

4) 非类型实参表达式不能使用模板形参之名，除非它完全就是模板形参的名字 (C++14 前)非类型实参表达式可以使用模板形参，只要形参至少一次出现于非推导语境之外 (C++14 起)

template <int I, int J> struct A {};
template <int I> struct A<I+5, I*2> {}; // 错误：I 不可推导
 
template <int I, int J, int K> struct B {};
template <int I> struct B<I, I*2, 2> {};  // OK：首个形参可推导

5) 非类型模板实参不能特化类型依赖于该特化的形参的模板形参：

template <class T, T t> struct C {}; // 主模板
template <class T> struct C<T, 1>; // 错误：1 的类型是 T，
                                   // 它依赖于形参 T
 
template< int X, int (*array_ptr)[X] > class B {}; // 主模板
int array[5];
template< int X > class B<X,&array> { }; // 错误：实参类型 &array 是 int(*)[X]，依赖于形参 X

名字查找

名字查找不会找到部分模板特化。仅当主模板被名字查找所找到时，才考虑其部分特化。特别是令主模板可见的 using 声明，亦令部分特化可见：

namespace N {
    template<class T1, class T2> class Z { }; // 部分特化
}
using N::Z; // 指代主模板
namespace N {
    template<class T> class Z<T, T*> { }; // 部分特化
}
Z<int,int*> z; // 名字查找找到 N::Z（主模板），
               // 然后使用带 T = int 的部分特化

部分排序

当实例化类模板或变量模板 (C++14 起)，且有部分特化可用时，编译器必须决定是继续使用主模板还是使用其部分特化之一。

1) 若只有一个特化与模板实参匹配，则使用该特化

2) 若多于一个特化匹配，则用部分排序规则确定哪个特化更加特殊。若它唯一则使用最特殊的特化（若它不唯一，则程序无法编译）

3) 若无匹配的特化，则使用主模板

// 给定上面所定义的模板 A
A<int, int, 1> a1;   // 无匹配的特化，使用主模板
A<int, int*, 1> a2;  // 用部分特化 #1，(T=int, I=1)
A<int, char*, 5> a3; // 用部分特化 #3，(T=char)
A<int, char*, 1> a4; // 用部分特化 #4，(X=int, T=char, I=1)
A<int*, int*, 2> a5; // 错误：匹配 #2 (T=int, T2=int*, I=2)
                     //      匹配 #4 (X=int*, T=int, I=2)
                     // 无一者比另一者更特殊

非正式而言，“A 比 B 更特殊”的意思是“A 接受 B 所接受类型的子集”。

正式而言，为在部分特化之间建立“更特殊”关系，首先将其中每一个都转换成下列的虚设函数模板：

• 第一个函数模板拥有与第一个部分特化相同的模板形参，且只有一个函数形参，其类型是带所有来自第一个部分特化的模板实参的类模板特化
• 第二个函数模板拥有与第二个部分特化相同的模板形参，且只有一个函数形参，其类型是带所有来自第一个部分特化的模板实参的类模板特化。

然后，如同为函数模板重载所做的一样，对函数模板排行。

template<int I, int J, class T> struct X { }; // 主模板
template<int I, int J>          struct X<I, J, int> {
        static const int s = 1;
}; // 部分特化 #1
// #1 的虚设函数模板是
// template<int I, int J> void f(X<I, J, int>); #A
 
template<int I>                 struct X<I, I, int> {
        static const int s = 2;
}; // 部分特化 #2
// #2 的虚设函数模板是
// template<int I>        void f(X<I, I, int>); #B
 
int main()
{
    X<2, 2, int> x; // #1 和 #2 都要匹配
// 函数模板的部分排序：
// #A 从 #B：void(X<I,J,int>) 从 void(X<U1, U1, int>)：推导 ok
// #B 从 #A：void(X<I,I,int>) 从 void(X<U1, U2, int>)：推导失败
// #B 更特殊
// #2 为所实例化的特化
    std::cout << x.s << '\n'; // 打印 2
}

部分特化的成员

部分特化的成员的模板形参列表和模板实参列表，必须与部分特化的形参列表和实参列表相匹配。

正如主模板的成员一样，仅当它们在程序中使用时，才需要定义。

部分特化的成员与主模板的成员无关。

部分特化的成员的显式（全）特化以与主模板的显式特化相同的方式声明。

template<class T, int I>  // 主模板
struct A {
    void f(); // 成员声明
};
 
template<class T, int I>
void A<T,I>::f() { } // 主模板成员定义
 
// 部分特化
template<class T>
struct A<T,2> {
    void f();
    void g();
    void h();
};
 
// 部分特化的成员
template<class T>
void A<T,2>::g() { }
 
// 部分特化的成员的显式（全）特化
template<>
void A<char,2>::h() {}
 
int main() {
    A<char,0> a0;
    A<char,2> a2;
    a0.f(); // OK，用主模板的成员定义
    a2.g(); // OK，用部分特化的成员定义
    a2.h(); // OK，用部分特化的成员的全特化定义
    a2.f(); // 错误：部分特化 A<T,2> 中无 f() 的定义（不使用主模板）
}

若主模板是另一个类模板的成员，则其部分特化也是外围模板类的成员。若外围模板类被实例化，则每个成员部分特化的声明也被实例化（模板的所有其他成员的声明（但非其定义）也是以相同方式实例化的）

若针对外围类模板的给定（隐式）特化进行主成员模板的显式（全）特化，则对外围类模板的这个特化忽略该成员模板的部分特化。

若针对外围类模板的给定（隐式）特化进行成员模板的某个部分特化的显式特化，则对外围类模板的这个特化仍然考虑主成员模板及其其他部分特化。

template<class T> struct A { // 外围类模板
  template<class T2>
  struct B {}; // 主成员模板
  template<class T2>
  struct B<T2*> {}; // 成员模板的部分特化
};
 
template<>
template<class T2>
struct A<short>::B {}; // 主成员模板的全特化（忽略部分特化）
 
A<char>::B<int*> abcip; // 使用部分特化 T2=int
A<short>::B<int*> absip; // 使用主模板的全特化（忽略部分特化）
A<char>::B<int> abci; // 使用主模板

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。