C++ 偏特化详解

C++偏特化

一、什么是 C++ 的偏特化（Partial Specialization）

偏特化 = 对"模板参数的一部分模式"给出特殊实现

也就是说：

• 不是所有参数都固定（那是全特化）
• 而是 只对某一类参数形态 定义行为

---

最基本的例子（类模板）

主模板（Primary Template）

template <typename T>
struct TypeInfo {
    static constexpr const char* name = "generic";
};

偏特化：指针类型

template <typename T>
struct TypeInfo<T*> {
    static constexpr const char* name = "pointer";
};

使用

TypeInfo<int>::name;    // "generic"
TypeInfo<int*>::name;  // "pointer"

这就是 偏特化

---

二、偏特化 vs 全特化

1 全特化（Fully Specialized）

所有模板参数都被确定

template <>
struct TypeInfo<int> {
    static constexpr const char* name = "int";
};

精确到某一个类型

类模板 & 函数模板都支持

---

2 偏特化（Partial Specialization）

只约束一部分参数

template <typename T>
struct TypeInfo<const T> {
    static constexpr const char* name = "const";
};

只支持类模板
函数模板不支持

---

三、 为什么函数模板不支持偏特化？

这是很多人真正"卡住"的地方

非法代码

template <typename T>
void foo(T);

template <typename T>
void foo<T*>(T*);   //  不允许

原因（核心）

函数模板有重载机制

类模板没有

如果允许函数偏特化：

• 会和重载规则冲突
• 会引入二义性
• 编译器难以排序匹配优先级

所以 C++ 标准直接禁止

---

那函数模板怎么办？ 三种替代方案

① 函数重载（最常用）

template <typename T>
void foo(T);

template <typename T>
void foo(T*);

行为 = 偏特化

实现 = 重载

---

② if constexpr（C++17+）

template <typename T>
void foo(T x) {
    if constexpr (std::is_pointer_v<T>) {
        // pointer case
    } else {
        // generic
    }
}

单一模板

编译期裁剪

---

③ Concepts（C++20，最强）

template <typename T>
concept Pointer = std::is_pointer_v<T>;

void foo(Pointer auto x) {
    // pointer version
}

void foo(auto x) {
    // fallback
}

语义最清晰

错误信息最好

---

四、偏特化的真实工程用途

1 类型萃取（STL / Eigen / GTSAM 核心）

template <typename T>
struct is_vector : std::false_type {};

template <typename T, int N>
struct is_vector<Eigen::Matrix<T, N, 1>> : std::true_type {};

Eigen 全靠这个体系

---

2 不同存储策略

template <typename T>
struct Storage;

template <typename T>
struct Storage<T*> {
    // raw pointer storage
};

template <typename T>
struct Storage<std::shared_ptr<T>> {
    // ref-counted
};

---

3 算法行为分派（存在编译期）

template <typename T, bool IsTrivial = std::is_trivial_v<T>>
struct Copier;

template <typename T>
struct Copier<T, true> {
    static void copy(T* dst, const T* src) {
        std::memcpy(dst, src, sizeof(T));
    }
};

template <typename T>
struct Copier<T, false> {
    static void copy(T* dst, const T* src) {
        *dst = *src;
    }
};

---

五、多个偏特化时的匹配规则

例子

template <typename T>
struct Foo;

template <typename T>
struct Foo<T*> {};          // A

template <typename T>
struct Foo<const T*> {};    // B

哪个更优？

Foo<const int*> f;

选择 B
"更特化（more specialized）"规则

---

二义性错误示例

template <typename T>
struct Foo<T&> {};

template <typename T>
struct Foo<const T> {};

Foo<const int&> f;  //  二义性

真实工程炸点

---

六、偏特化 ≠ 特化成员函数

错误理解：

template <typename T>
struct A {
    void f();
};

template <>
void A<int>::f();  // 这不是偏特化！

这是 成员函数全特化

类模板仍然是主模板

---

七、什么时候"应该用偏特化"

当你满足以下条件：

• 行为 完全不同
• 分支 编译期已知
• 逻辑 不可用 if constexpr 简化
• 类型结构本身携带语义（指针 / Eigen 类型 / Pose / SE(3)）

---

八、总结

偏特化 = 用"类型形态"驱动编译期行为分派，是 C++ 类型系统的模式匹配机制。

---

二、偏特化推导规则

一、 偏特化的「匹配优先级」推导规则

Partial ordering of class template partial specializations

1 核心一句话

"谁能匹配的集合更小，谁就更特化（more specialized）"

编译器做的不是"人类直觉判断"，而是形式化推导。

---

2 编译器真实在做什么？

给定：

template <typename T>
struct Foo;

template <typename T>
struct Foo<T*>;          // A

template <typename T>
struct Foo<const T*>;    // B

当写：

Foo<const int*> x;

编译器做两件事：

Step 1：检查「是否能匹配」

• A：T* ← const int*
• B：const T* ← const int*

Step 2：互相"代入"比较

判断 A 是否至少和 B 一样特化

判断 B 是否至少和 A 一样特化

---

形式化推导

判断 B 是否比 A 更特化

用 A 的模式去"匹配" B 的参数形式

B 的形式是：

const T*

能否写成 A 的形式：

U*

不行（丢失 const）

---

判断 A 是否比 B 更特化

用 B 的模式去匹配 A

A 的形式：

T*

是否能写成：

const U*

可以（T = const U）

---

结论

B 比 A 更特化

选择 Foo<const T*>

---

4 再来一个常见炸点

template <typename T>
struct Foo<T&> {};      // A

template <typename T>
struct Foo<const T> {}; // B

Foo<const int&> x;

推导结果

• A：T& ← const int&
• B：const T ← const int& //错误（引用不是 const-qualified object）

只有 A 可行

没有二义性（很多人以为会炸）

---

5 真正的二义性例子

template <typename T>
struct Foo<T*> {};          // A

template <typename T>
struct Foo<const T> {};     // B

Foo<const int*> x;

• A：T* ← const int*
• B：const T ← const int*

互相代入：

• A 不能匹配 B
• B 不能匹配 A

无"更特化者" → 编译错误

---

6 工程经验法则

不要让不同偏特化从"不同维度"约束同一个类型

好：

Foo<T*>
Foo<const T*>

危险：

Foo<T*>
Foo<const T>

---

二、 偏特化 + ODR / 链接错误

模板错误 ≠ 编译错误

很多是 链接期炸

---

1 偏特化本身不是 inline 的

template <typename T>
struct Foo;

template <typename T>
struct Foo<T*> {
    static int value;
};

template <typename T>
int Foo<T*>::value = 42;  // 

问题

每个 TU 都会生成一个定义

→ 违反 ODR

---

2 正确写法（C++17+）

inline 静态成员

template <typename T>
struct Foo<T*> {
    inline static int value = 42;
};

---

或 constexpr

template <typename T>
struct Foo<T*> {
    static constexpr int value = 42;
};

---

3 偏特化 + 非内联成员函数

// header.h
template <typename T>
struct Foo<T*> {
    void f();
};

// source.cpp
template <typename T>
void Foo<T*>::f() {
    ...
}

链接失败

原因

• 偏特化仍是模板
• 编译器看不到定义 → 无法实例化

---

正确方式

方案 A：全部放 header

template <typename T>
struct Foo<T*> {
    void f() {
        ...
    }
};

方案 B：显式实例化（极少用）

template struct Foo<int*>;

---

4 偏特化 + inline namespace

inline namespace v1 {

template <typename T>
struct Foo;

template <typename T>
struct Foo<T*> {};

}

后来改成：

inline namespace v2 { ... }

所有偏特化都变成新类型

ABI / 插件系统直接崩

---

5 STL / Eigen 为什么从不"乱用偏特化"

原因只有一个：

偏特化 = 类型系统分叉点

一旦发布，几乎无法修改

---

6 偏特化的工程级使用原则

必须满足：

• 类型语义稳定
• 偏特化数量有限
• 不依赖外部宏
• 不跨动态库边界

---

否则请用：

• if constexpr
• tag dispatch
• concepts

---

三、终极总结

偏特化不是"写法技巧"，而是"类型层面的架构决策"。

它决定了：

• 编译期行为分派
• ODR 风险
• ABI 稳定性
• 编译时间
• 错误可读性

---