模板特化与偏特化 ​

面试考点 ​

模板特化是 C++ 模板编程中的重要机制。面试官通过这道题考察你是否理解全特化和偏特化的区别、语法差异、以及函数模板不支持偏特化的原因。

核心概念 ​

全特化(Full Specialization):为所有模板参数指定具体类型,提供完全定制的实现。偏特化(Partial Specialization):只为部分模板参数指定具体类型或模式,保留其他参数的泛化能力。偏特化只适用于类模板,函数模板不支持偏特化。

基本示例 ​

cpp
#include <iostream>
#include <string>
#include <type_traits>

// ============================
// 示例1:类模板全特化
// ============================

// 主模板(通用版本)
template<typename T>
class TypeName {
public:
    static std::string get() {
        return "未知类型";
    }
};

// 全特化:为 int 提供特定实现
template<>
class TypeName<int> {
public:
    static std::string get() {
        return "int";
    }
};

// 全特化:为 double 提供特定实现
template<>
class TypeName<double> {
public:
    static std::string get() {
        return "double";
    }
};

// 全特化:为 std::string 提供特定实现
template<>
class TypeName<std::string> {
public:
    static std::string get() {
        return "std::string";
    }
};

void full_specialization_demo() {
    std::cout << TypeName<int>::get() << std::endl;          // "int"
    std::cout << TypeName<double>::get() << std::endl;       // "double"
    std::cout << TypeName<std::string>::get() << std::endl;  // "std::string"
    std::cout << TypeName<float>::get() << std::endl;        // "未知类型"
}

// ============================
// 示例2:类模板偏特化
// ============================

// 主模板
template<typename T, typename U>
class Pair {
public:
    void info() {
        std::cout << "通用 Pair<T, U>" << std::endl;
    }
};

// 偏特化:第二个参数固定为 int
template<typename T>
class Pair<T, int> {
public:
    void info() {
        std::cout << "偏特化 Pair<T, int>" << std::endl;
    }
};

// 偏特化:两个参数类型相同
template<typename T>
class Pair<T, T> {
public:
    void info() {
        std::cout << "偏特化 Pair<T, T>" << std::endl;
    }
};

// 全特化:两个参数都是 int
template<>
class Pair<int, int> {
public:
    void info() {
        std::cout << "全特化 Pair<int, int>" << std::endl;
    }
};

void partial_specialization_demo() {
    Pair<double, std::string> p1;  // 匹配主模板
    Pair<double, int> p2;          // 匹配偏特化 Pair<T, int>
    Pair<double, double> p3;       // 匹配偏特化 Pair<T, T>
    Pair<int, int> p4;             // 匹配全特化 Pair<int, int>

    p1.info();
    p2.info();
    p3.info();
    p4.info();
}

// ============================
// 示例3:指针类型的偏特化
// ============================

// 主模板
template<typename T>
class Container {
public:
    void store(T value) {
        std::cout << "存储值: " << value << std::endl;
    }
};

// 偏特化:针对指针类型
template<typename T>
class Container<T*> {
public:
    void store(T* ptr) {
        if (ptr) {
            std::cout << "存储指针指向的值: " << *ptr << std::endl;
        } else {
            std::cout << "空指针" << std::endl;
        }
    }
};

// 偏特化:针对 const 指针类型
template<typename T>
class Container<const T*> {
public:
    void store(const T* ptr) {
        if (ptr) {
            std::cout << "存储 const 指针指向的值: " << *ptr << std::endl;
        }
    }
};

void pointer_specialization_demo() {
    Container<int> c1;
    int x = 42;
    c1.store(x);

    Container<int*> c2;
    c2.store(&x);

    const int y = 100;
    Container<const int*> c3;
    c3.store(&y);
}

// ============================
// 示例4:函数模板的"特化"(用重载代替)
// ============================

// 函数模板不支持偏特化
// 应该用重载来代替

// 主模板
template<typename T>
void print(T value) {
    std::cout << "通用: " << value << std::endl;
}

// 函数模板全特化(语法上允许,但不推荐)
template<>
void print<int>(int value) {
    std::cout << "int 特化: " << value << std::endl;
}

// 推荐做法:用普通函数重载代替特化
// 重载决议优先选择非模板函数
void print(const char* str) {
    std::cout << "const char* 重载: " << str << std::endl;
}

// 想要"偏特化"指针?用重载
template<typename T>
void print(T* ptr) {
    std::cout << "指针重载: " << *ptr << std::endl;
}

void function_demo() {
    print(42);          // int 全特化
    print(3.14);        // 通用模板
    print("hello");     // const char* 重载
    int x = 99;
    print(&x);          // 指针重载
}

// ============================
// 示例5:std::hash 特化(实际应用)
// ============================

struct Point {
    int x, y;
};

// 为自定义类型特化 std::hash(用于 unordered_map/set)
template<>
struct std::hash<Point> {
    size_t operator()(const Point& p) const {
        // 组合哈希
        return std::hash<int>{}(p.x) ^ (std::hash<int>{}(p.y) << 1);
    }
};

int main() {
    std::cout << "=== 全特化 ===" << std::endl;
    full_specialization_demo();

    std::cout << "\n=== 偏特化 ===" << std::endl;
    partial_specialization_demo();

    std::cout << "\n=== 指针偏特化 ===" << std::endl;
    pointer_specialization_demo();

    std::cout << "\n=== 函数模板 ===" << std::endl;
    function_demo();

    return 0;
}

全特化 vs 偏特化 ​

特性全特化偏特化
模板参数所有参数都指定部分参数指定或模式匹配
类模板支持支持
函数模板支持(不推荐)不支持
语法template<> class X<int>template<typename T> class X<T*>
替代方案-函数模板用重载代替

常见问题 ​

为什么函数模板不支持偏特化?

C++ 标准规定只有类模板可以偏特化。函数模板不支持偏特化的原因是函数有重载机制,重载可以完成偏特化想做的事情,而且重载决议的规则更清晰。如果同时有偏特化和重载,行为会变得难以预测。

函数模板全特化和普通函数重载哪个优先?

普通函数重载优先于函数模板特化。编译器先做重载决议选择最匹配的函数或函数模板,然后才在选中的模板中查找特化版本。所以推荐用重载代替函数模板特化。

特化匹配的优先级是什么?

全特化 > 偏特化 > 主模板。编译器先尝试匹配全特化,如果没有就尝试偏特化,最后使用主模板。

适用场景 ​

  • 为特定类型提供优化实现(如 vector<bool>)
  • 类型萃取(type traits)
  • 编译期分派
  • 为自定义类型特化标准库模板(如 std::hash)

注意事项 ​

  • 偏特化只适用于类模板
  • 函数模板用重载代替偏特化
  • 特化必须在主模板之后声明
  • 特化的声明必须在使用之前可见
  • 不要过度使用特化,C++20 的 Concepts 是更好的选择

总结 ​

模板特化为特定类型提供定制实现。全特化指定所有模板参数,偏特化只指定部分参数或匹配模式(如指针、引用)。偏特化只适用于类模板,函数模板应该用重载代替。匹配优先级:全特化 > 偏特化 > 主模板。面试中要能写出全特化和偏特化的语法、解释函数模板不支持偏特化的原因、以及说明重载和特化的优先级关系。