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