显式（完全）模板特化

允许为给定模板参数集定制模板代码。

#include <type_traits>
 
template<typename T> // primary template
struct is_void : std::false_type {};
template<>           // explicit specialization for T = void
struct is_void<void> : std::true_type {};
 
int main()
{
    static_assert(is_void<char>::value == false,
        "for any type T other than void, the class is derived from false_type");
    static_assert(is_void<void>::value == true,
        "but when T is void, the class is derived from true_type");
}

[编辑] 详情

显式特化可以在其主模板可以定义的任何作用域内声明（这可能与主模板定义的范围不同；例如类外特化成员模板）。显式特化必须出现在非特化模板声明之后。

namespace N
{
    template<class T> // primary template
    class X { /*...*/ };
    template<>        // specialization in same namespace
    class X<int> { /*...*/ };
 
    template<class T> // primary template
    class Y { /*...*/ };
    template<>        // forward declare specialization for double
    class Y<double>;
}
 
template<> // OK: specialization in same namespace
class N::Y<double> { /*...*/ };

在每个发生隐式实例化的翻译单元中，特化必须在使用之前声明。

class String {};
 
template<class T>
class Array { /*...*/ };
 
template<class T> // primary template
void sort(Array<T>& v) { /*...*/ }
 
void f(Array<String>& v)
{
    sort(v); // implicitly instantiates sort(Array<String>&), 
}            // using the primary template for sort()
 
template<> // ERROR: explicit specialization of sort(Array<String>)
void sort<String>(Array<String>& v); // after implicit instantiation

已声明但未定义的模板特化可以像任何其他不完全类型一样使用（例如，指向它的指针和引用可以使用）。

template<class T> // primary template
class X;
template<>        // specialization (declared, not defined)
class X<int>;
 
X<int>* p; // OK: pointer to incomplete type
X<int> x;  // error: object of incomplete type

函数或变量(C++14 起)模板的显式特化是否为inline/constexpr(C++11 起)/constinit/consteval(C++20 起)，由显式特化本身决定，无论主模板是否声明了该说明符。类似地，模板声明中出现的属性对该模板的显式特化没有影响：(C++11 起)

template<class T>
void f(T) { /* ... */ }
template<>
inline void f<>(int) { /* ... */ } // OK, inline
 
template<class T>
inline T g(T) { /* ... */ }
template<>
int g<>(int) { /* ... */ }         // OK, not inline
 
template<typename>
[[noreturn]] void h([[maybe_unused]] int i);
template<> void h<int>(int i)
{
    // [[noreturn]] has no effect, but [[maybe_unused]] has
}

[编辑] 函数模板的显式特化

特化函数模板时，如果模板参数推导可以从函数参数中提供它们，则可以省略其模板参数。

template<class T>
class Array { /*...*/ };
 
template<class T> // primary template
void sort(Array<T>& v);
template<>        // specialization for T = int
void sort(Array<int>&);
 
// no need to write
// template<> void sort<int>(Array<int>&);

具有与特化相同的名称和相同参数列表的函数不是特化（参见函数模板中的模板重载）。

在函数模板、成员函数模板和类模板的成员函数的显式特化中，当类被隐式实例化时，不能指定默认函数参数。

显式特化不能是友元声明。

[编辑] 特化成员

在类体之外定义显式特化类模板的成员时，不使用语法template<>，除非它是显式特化成员类模板的成员，该成员类模板被特化为类模板，因为否则，语法将要求此类定义以嵌套模板所需的template<parameters>开头。

template<typename T>
struct A
{
    struct B {};      // member class 
 
    template<class U> // member class template
    struct C {};
};
 
template<> // specialization
struct A<int> 
{
    void f(int); // member function of a specialization
};
// template<> not used for a member of a specialization
void A<int>::f(int) { /* ... */ }
 
template<> // specialization of a member class
struct A<char>::B
{
    void f();
};
// template<> not used for a member of a specialized member class either
void A<char>::B::f() { /* ... */ }
 
template<> // specialization of a member class template
template<class U>
struct A<char>::C
{
    void f();
};
 
// template<> is used when defining a member of an explicitly
// specialized member class template specialized as a class template
template<>
template<class U>
void A<char>::C<U>::f() { /* ... */ }

如果声明包含初始化器，则模板的静态数据成员的显式特化是一个定义；否则，它是一个声明。这些定义必须使用花括号进行默认初始化。

template<>
X Q<int>::x;    // declaration of a static member
template<>
X Q<int>::x (); // error: function declaration
template<>
X Q<int>::x {}; // definition of a default-initialized static member

类模板的成员或成员模板可以针对给定类模板的隐式实例化进行显式特化，即使该成员或成员模板是在类模板定义中定义的。

template<typename T>
struct A
{
    void f(T);         // member, declared in the primary template
 
    void h(T) {}       // member, defined in the primary template
 
    template<class X1> // member template
    void g1(T, X1);
 
    template<class X2> // member template
    void g2(T, X2);
};
 
// specialization of a member
template<>
void A<int>::f(int);
 
// member specialization OK even if defined in-class
template<>
void A<int>::h(int) {}
 
// out of class member template definition
template<class T>
template<class X1>
void A<T>::g1(T, X1) {}
 
// member template specialization
template<>
template<class X1>
void A<int>::g1(int, X1);
 
// member template specialization
template<>
template<>
void A<int>::g2<char>(int, char); // for X2 = char
 
// same, using template argument deduction (X1 = char)
template<> 
template<>
void A<int>::g1(int, char);

成员或成员模板可以嵌套在许多封闭类模板中。在为此类成员的显式特化中，对于每个显式特化的封闭类模板，都有一个template<>。

template<class T1>
struct A
{
    template<class T2>
    struct B
    {
        template<class T3>
        void mf();
    };
};
 
template<>
struct A<int>;
 
template<>
template<>
struct A<char>::B<double>;
 
template<>
template<>
template<>
void A<char>::B<char>::mf<double>();

在这种嵌套声明中，某些级别可能保持未特化（除非它不能在命名空间作用域中特化类成员模板，如果其封闭类未特化）。对于每个这些级别，声明需要template<arguments>，因为此类特化本身就是模板。

template<class T1>
class A
{
    template<class T2>
    class B
    {
        template<class T3> // member template
        void mf1(T3);
 
        void mf2();        // non-template member
    };
};
 
// specialization
template<>        // for the specialized A
template<class X> // for the unspecialized B
class A<int>::B
{
    template<class T>
    void mf1(T);
};
 
// specialization
template<>        // for the specialized A
template<>        // for the specialized B
template<class T> // for the unspecialized mf1
void A<int>::B<double>::mf1(T t) {}
 
// ERROR: B<double> is specialized and is a member template, so its enclosing A
// must be specialized also
template<class Y>
template<>
void A<Y>::B<double>::mf2() {}

[编辑] 缺陷报告

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

缺陷报告	应用于	发布时的行为	正确的行为
CWG 531	C++98	未指定在命名空间作用域中定义显式特化成员的语法未指定在命名空间作用域中定义显式	已指定
CWG 727	C++98	类作用域中不允许部分和完全特化在任何作用域中都允许	允许在任何作用域中
CWG 730	C++98	非模板类的成员模板不能完全特化类无法完全特化	允许
CWG 2478	C++20	不清楚主模板的constinit和consteval是否会传递到其显式特化中不清楚主模板的constinit和consteval是否	未传递
CWG 2604	C++11	不清楚主模板的属性是否会传递到其显式特化中模板的属性是否会传递到其显式特化中	未传递

[编辑] 另请参阅

编译器支持
自由（freestanding）与宿主（hosted）
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

参数和实参
类模板
函数模板
类成员模板
变量模板 (C++14)
模板参数推导
类模板实参推导（C++17）
显式（完全）特化
部分特化
依赖名称
包（C++11）
`sizeof...` (C++11)
折叠表达式 (C++17)
包索引 (C++26)
SFINAE
约束和概念 (C++20)
Requires 表达式 (C++20)

cppreference.cn

命名空间

变体

视图

操作