显式(全)模板特化

来自cppreference.com
< cpp‎ | language

允许对给定的模板实参集定制模板代码。

目录

[编辑] 语法

template <> declaration

任何下列者可以完全特化:

  1. 函数模板
  2. 类模板
  3. (C++14 起)变量模板
  4. 类模板的成员函数
  5. 类模板的静态数据成员
  6. 类模板的成员类
  7. 类模板的成员枚举
  8. 类或类模板的成员类模板
  9. 类或类模板的成员函数模板

例如,

#include <iostream>
template<typename T>   // 初等模板
struct is_void : std::false_type
{
};
template<>  // 对 T = void 显式特化
struct is_void<void> : std::true_type
{
};
int main()
{
    // 对于任何异于 void 的类型 T ,类导出自 false_type
    std::cout << is_void<char>::value << '\n'; 
    // 但当 T 为 void 时类导出自 true_type
    std::cout << is_void<void>::value << '\n';
}


[编辑] 细节

显式特化可声明任何其初等模板可定义处的作用域(可异于初等模板定义处的作用域;例如同成员模板的类外特化)。显式特化必须出现在非特化模板声明后。

namespace N {
    template<class T> class X { /*...*/ }; // 初等模板
    template<> class X<int> { /*...*/ }; // 同命名空间中的特化
 
    template<class T> class Y { /*...*/ }; // 初等模板
    template<> class Y<double>; // 对 double 特化的转发声明
}
template<>
class N::Y<double> { /*...*/ }; // OK :同命名空间中的特化

在每个翻译单元中的导致隐式实例化的使用发生处,特化必须声明于这种使用之前:

class String {};
template<class T> class Array { /*...*/ };
template<class T> void sort(Array<T>& v) { /*...*/ } // 初等模板
 
void f(Array<String>& v) {
    sort(v); // 隐式实例化 sort(Array<String>&), 
}            // 使用初等模板 sort()
 
template<>  // 错误: sort(Array<String>) 的显式特化出现在隐式实例化之后
void sort<String>(Array<String>& v);

声明但不定义的模板特化能像其他不完整类型一样使用(例如可以用到它的指针和引用)

template<class T> class X; // 初等模板
template<> class X<int>; // 特化(声明,不定义)
X<int>* p; // OK :指向不完整类型的指针
X<int> x; // 错误:不完整类型的对象

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

特化函数模板时,可忽略其实参,若模板实参推导能从函数参数提供它们:

template<class T> class Array { /*...*/ };
template<class T> void sort(Array<T>& v); // 初等模板
template<> void sort(Array<int>&); // 对 T = int 的特化
// 不需要写
// template<> void sort<int>(Array<int>&);

带于特化同名且同参数列表的函数不是特化(见函数模板中的重载)

函数模板的显式特化为 inline ,仅若它声明为带 inline 指定符(或定义为被删除),若初等模板为 inline 则它不影响。

不能在函数模板、成员函数模板,及在隐式实例化类时的类模板的成员函数的显式特化中指定默认函数参数

显式特化不能是友元声明

若初等模板有不是 noexcept(false) 的异常规定,则显式特化必须有兼容的异常规定。

[编辑] 特化的成员

在类体外定义显式特化的类模板的成员时,不使用 template <> 语法,除非它是作为类模板特化的显式特化的成员类模板的成员,因为其他情况下,语法会要求这种定义以嵌套模板所要求的 template<parameters> 开始

template< typename T>
struct A {
    struct B {};  // 成员类 
    template<class U> struct C { }; // 成员类模板
};
 
template<> // 特化
struct A<int> {
    void f(int); // 特化的成员函数
};
// template<> 不用于特化的成员
void A<int>::f(int) { /* ... */ }
 
template<> // 成员类的特化
struct A<char>::B {
    void f();
};
// template<> 亦不用于特化的成员类的成员
void A<char>::B::f() { /* ... */ }
 
template<> // 成员类模板的的定义
template<class U> struct A<char>::C {
    void f();
};
 
// template<> 在作为类模板定义显式特化的成员类模板时使用
template<>
template<class U> void A<char>::C<U>::f() { /* ... */ }


模板的静态数据成员的显式特化是定义,若声明包含初始化器;否则,它是声明。这些定义对于默认初始化必须用花括号:

template<> X Q<int>::x; // 静态成员的声明
template<> X Q<int>::x (); // 错误:函数声明
template<> X Q<int>::x {}; // 静态成员的默认初始化定义

类模板的成员或成员模板可对于类模板的隐式实例化显式特化,即使成员或成员模板定义于类模板定义中。

template<typename T>
struct A {
    void f(T); // 成员,声明于初等模板
    void h(T) {} // 成员,定义于初等模板
    template<class X1> void g1(T, X1); // 成员模板
    template<class X2> void g2(T, X2); // 成员模板
};
 
// 成员的特化
template<> void A<int>::f(int);
// 成员特化 OK ,即使定义于类中
template<> void A<int>::h(int) {}
 
// 类外成员模板定义
template<class T>
template<class X1> void A<T>::g1(T, X1) { }
 
// 成员模板特化
template<>
template<class X1> void A<int>::g1(int, X1);
 
// 成员模板特化
template<>
template<> void A<int>::g2<char>(int, char); // 对于 X2 = char
// 同上,用模板实参推导 (X1 = char)
template<> 
template<> void A<int>::g1(int, char);

成员或成员模板可嵌套于多个外围类模板中。在这种成员的显式特化中,对每个显式特化的外围类模板都有一个 template<>

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

在这种嵌套声明中,某些层次可保留不特化(除了若其外围类不特化,则不能特化类成员模板)。对于每个这种层次,声明需要 template<arguments> ,因为这种特化自身是模板:

template <class T1> class A {
    template<class T2> class B {
        template<class T3> void mf1(T3); // 成员模板
        void mf2(); // 非模板成员
     };
};
 
// 特化
template<> // 对于特化的 A
template<class X> // 对于不特化的 B
class A<int>::B {
    template <class T> void mf1(T);
};
 
// 特化
template<> // 对于特化的 A
template<> // 对于特化的 B
template<class T> // 对于不特化的 mf1
void A<int>::B<double>::mf1(T t) { }
 
// 错误: B<double> 被特化而且是成员模板,故其外围的 A 也必须特化
template<class Y>
template<> void A<Y>::B<double>::mf2() { }

[编辑] 缺陷报告

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

DR 应用于 出版时的行为 正确行为
CWG 727 C++14 不允许在类作用域的全特化,即使允许部分特化 允许在任何作用域的全特化

[编辑] 参阅