模板元编程（Template Metaprogramming） on Dorkytiger 的小屋

泛型编程与模板特化

Mon, 01 Jan 0001 00:00:00 +0000

一、类模板全特化与偏特化

// 主模板
template <typename T>
struct TypeInfo {
    static constexpr const char* name = "unknown";
};

// 全特化：T = int
template <>
struct TypeInfo<int> {
    static constexpr const char* name = "int";
};

// 偏特化：T*（对所有指针类型）
template <typename T>
struct TypeInfo<T*> {
    static constexpr const char* name = "pointer";
};

// 偏特化：const T（对所有 const 类型）
template <typename T>
struct TypeInfo<const T> {
    static constexpr const char* name = "const";
};

// 使用
TypeInfo<double>::name;     // "unknown"（主模板）
TypeInfo<int>::name;        // "int"（全特化）
TypeInfo<float*>::name;     // "pointer"（偏特化）
TypeInfo<const int>::name;  // "const"（偏特化）

面试题：“为什么高性能库经常针对特定类型做全特化？”

因为通用实现（如逐元素循环）对 CPU 不友好，全特化可以换用 SIMD 指令（如 _mm256_loadu_si256）一次处理 8 个 int，速度提升 8 倍。

二、函数模板只能全特化，不能偏特化

template <typename T>
void func(T x) {}

template <>               // ✅ 函数全特化
void func<int>(int x) {}

template <typename T>
void func<T*>(T* x) {}    // ❌ 函数不能偏特化！编译错误

替代方案：用函数重载 + std::enable_if 或 if constexpr 实现类似效果。

编译期类型萃取（Type Traits）与 SFINAE

Mon, 01 Jan 0001 00:00:00 +0000

一、Type Traits 的本质

#include <type_traits>

// is_pointer 的底层实现（简化版）
template <typename T>
struct is_pointer_impl : false_type {};  // 默认不是指针

template <typename T>
struct is_pointer_impl<T*> : true_type {}; // T* 是指针

// 使用
static_assert(is_pointer_impl<int>::value == false);
static_assert(is_pointer_impl<int*>::value == true);

true_type 和 false_type 是什么？

struct true_type  { static constexpr bool value = true; };
struct false_type { static constexpr bool value = false; };

就这么简单——type traits 就是编译期的布尔值，通过模板特化在编译期确定。

二、SFINAE 的精髓

SFINAE（Substitution Failure Is Not An Error）—— 替换失败不是错误。

// 对于有 size() 成员的类型启用
template <typename T>
auto get_size(const T& x) -> decltype(x.size()) {
    return x.size();
}

// 对于没有 size() 但有 length() 的类型启用
template <typename T>
auto get_size(const T& x) -> decltype(x.length()) {
    return x.length();
}

// 对于没有 size() 也没有 length() 的类型启用
int get_size(...) {
    return 0;
}

// 使用
vector<int> v(10);
string s = "hello";
int n = 42;

get_size(v); // 第一个版本：v.size()
get_size(s); // 第一个版本：s.size()
get_size(n); // 第三个版本：... 匹配

编译器的视角：

`constexpr` 与 C++20 Concepts

Mon, 01 Jan 0001 00:00:00 +0000

一、`constexpr` —— 让代码在编译期运行

// 编译期阶乘
constexpr int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

int arr[factorial(5)]; // ✅ 编译期求值，arr 大小 120

int x = 5;
int y = factorial(x); // ❌ 运行时调用（x不是编译期常量）
constexpr int z = factorial(5); // ✅ 编译期调用

consteval（C++20）：强制编译期执行，不允许运行时调用。

consteval int double_it(int n) {
    return n * 2;
}

constexpr int x = double_it(21);  // ✅ 42
int y = double_it(21);            // ✅ 编译器推导为 constexpr
int z = double_it(x);             // ✅ 可以
int runtime_val = std::rand();
int w = double_it(runtime_val);   // ❌ 编译错误：consteval 不允许运行时调用

二、C++20 Concepts —— 摆脱 SFINAE 噩梦

// 定义 Concept
template <typename T>
concept Hashable = requires(T a) {
    { std::hash<T>{}(a) } -> std::convertible_to<size_t>;
};

// 使用 Concept 约束模板
template <Hashable T>
void process_hash(const T& value) {
    auto h = std::hash<T>{}(value);
}

// 或者更简约的写法
void process_hash(const Hashable auto& value) {
    auto h = std::hash<T>{}(value);
}

// 错误信息对比
process_hash(42);   // ✅ int 有 hash 特化
process_hash("hello"); // ✅ const char* 有 hash 特化

struct MyType {};
process_hash(MyType{}); // ❌ 编译错误："MyType 不满足 Hashable 约束"
                        //    而不是几万行的模板实例化失败堆栈！

Concepts 的 3 大价值：

第一阶段到第四阶段总结

Mon, 01 Jan 0001 00:00:00 +0000

第一阶段（移动语义）：
    左值/右值 → std::move 是 cast 不是 move
    → 右值引用变量本身是左值（面试陷阱）
    → 完美转发 std::forward 保持值类别

第二阶段（容器内存布局）：
    vector：连续 → 缓存友好 → 扩容因子 1.5/2 → 迭代器失效
    list：节点散落 → 缓存灾难 → 除非频繁中间插入否则别用
    deque：中控+分块 → 两端 O(1) → stack/queue 默认容器
    unordered_map：桶+链表 → O(1)均摊 → rehash 是灾难
    map：红黑树 → O(log N) → 节点散落同样缓存不友好

第三阶段（智能指针）：
    unique_ptr：零开销，就是裸指针
    shared_ptr：16字节，控制块+原子引用计数，make_shared合并分配
    weak_ptr：lock()做原子检查+增加，破循环引用

第四阶段（模板元编程）：
    模板特化：全特化/偏特化（函数不能偏特化）
    Type Traits：编译期布尔值，通过模板偏特化实现
    SFINAE：替换失败不是错误，enable_if 条件启用
    if constexpr：编译期分支，不匹配分支不编译
    constexpr/consteval：编译期计算
    Concepts C++20：约束模板参数，报错清晰

模板元编程（Template Metaprogramming） on Dorkytiger 的小屋

泛型编程与模板特化

一、类模板全特化与偏特化

二、函数模板只能全特化，不能偏特化

编译期类型萃取（Type Traits）与 SFINAE

一、Type Traits 的本质

二、SFINAE 的精髓

`constexpr` 与 C++20 Concepts

一、constexpr —— 让代码在编译期运行

二、C++20 Concepts —— 摆脱 SFINAE 噩梦

第一阶段到第四阶段总结

一、`constexpr` —— 让代码在编译期运行