第22章模板元编程基础

课程目录第22章模板元编程基础

模板元编程基础：编译期递归，类型列表，编译期算法

模板元编程，说白了就是让编译器替你干活。

我第一次接触这个概念时，觉得这玩意儿挺玄乎的。代码还没跑，编译器先把结果算出来了？后来在项目中做高性能计算库时，才真正体会到它的威力。今天我们就来聊聊模板元编程的三个核心基础：编译期递归、类型列表、以及编译期算法。

编译期递归：让循环在编译期展开

模板元编程没有循环语句。你想想看，模板实例化发生在编译期，哪来的运行时循环？所以，我们只能用递归。

先看一个最经典的例子——编译期阶乘：

template <unsigned int N>
struct Factorial {
    static constexpr unsigned int value = N * Factorial<N - 1>::value;
};

template <>
struct Factorial<0> {
    static constexpr unsigned int value = 1;
};

// 使用
constexpr auto result = Factorial<5>::value; // 120

这里的关键是模板特化。当 N 为 0 时，编译器会匹配特化版本，递归终止。没有这个特化，编译器会无限递归下去，直到报错。

注意： 我曾经在项目中写过一个编译期斐波那契数列，忘记写终止特化，结果编译器直接爆出几千行的错误信息。嗯，那场面，至今难忘。

再来看一个更实用的例子——编译期判断一个数是否为质数：

template <unsigned int N, unsigned int D>
struct IsPrimeHelper {
    static constexpr bool value = 
        (N % D != 0) && IsPrimeHelper<N, D - 1>::value;
};

template <unsigned int N>
struct IsPrimeHelper<N, 1> {
    static constexpr bool value = true;
};

template <unsigned int N>
struct IsPrime {
    static constexpr bool value = IsPrimeHelper<N, N / 2>::value;
};

template <>
struct IsPrime<1> {
    static constexpr bool value = false;
};

// 使用
constexpr auto check = IsPrime<17>::value; // true

我个人习惯把这种递归叫做「编译期循环展开」。每次模板实例化都会生成一个新的类型，递归深度就是循环次数。但要注意，编译器对递归深度有限制，一般默认 256 或 512 层，太深了会报错。

类型列表：在类型的世界里玩数据结构

运行时我们有数组、链表、vector。编译期呢？我们有类型列表（Type List）。

类型列表就是一个模板，里面装着多个类型：

template <typename... Types>
struct TypeList {};

// 定义一个类型列表
using MyTypes = TypeList<int, double, char, float>;

就这么简单？对，但光有容器还不够，我们需要操作它的算法。

先写一个获取类型列表长度的工具：

template <typename T>
struct Length;

template <typename... Types>
struct Length<TypeList<Types...>> {
    static constexpr size_t value = sizeof...(Types);
};

// 使用
constexpr auto len = Length<MyTypes>::value; // 4

再写一个获取第 N 个类型的工具：

// 前置声明
template <size_t N, typename T>
struct TypeAt;

// 递归取第 N 个
template <size_t N, typename Head, typename... Tail>
struct TypeAt<N, TypeList<Head, Tail...>> {
    using type = typename TypeAt<N - 1, TypeList<Tail...>>::type;
};

// 终止条件：取第 0 个
template <typename Head, typename... Tail>
struct TypeAt<0, TypeList<Head, Tail...>> {
    using type = Head;
};

// 使用
using SecondType = TypeAt<1, MyTypes>::type; // double

小技巧： 我在做序列化库时，用类型列表来存储字段类型。每个字段对应一个类型，然后通过编译期算法生成对应的序列化代码。这样既保证了类型安全，又避免了运行时开销。

编译期算法：像操作数据一样操作类型

有了类型列表，我们就可以在上面实现各种算法了。说白了，就是把运行时的算法搬到编译期，只不过操作的对象从值变成了类型。

先看一个简单的——在类型列表中查找某个类型是否存在：

template <typename T, typename List>
struct Contains;

template <typename T, typename... Types>
struct Contains<T, TypeList<Types...>> {
    static constexpr bool value = 
        (std::is_same_v<T, Types> || ...);
};

// 使用
constexpr auto hasInt = Contains<int, MyTypes>::value; // true

这里用到了 C++17 的折叠表达式，让代码简洁了不少。如果是 C++11，你得写递归。

再来看一个更复杂的——过滤出满足条件的类型：

// 前置声明
template <template<typename> class Pred, typename List>
struct Filter;

// 递归处理
template <template<typename> class Pred, typename Head, typename... Tail>
struct Filter<Pred, TypeList<Head, Tail...>> {
    using type = typename std::conditional_t<
        Pred<Head>::value,
        TypeList<Head>,
        TypeList<>
    >;
    // 这里简化了，实际需要拼接两个 TypeList
};

// 实际项目中我会用更复杂的拼接方式
// 这里展示核心思路

为什么需要这些算法？

我在做一个反射库时，需要根据类型列表生成对应的成员函数。比如，给一个结构体的所有字段生成 getter/setter。用类型列表 + 编译期算法，我可以在编译期遍历所有字段类型，生成对应的代码。运行时完全零开销。

算法	运行时版本	编译期版本
查找	std::find	Contains
过滤	std::copy_if	Filter
转换	std::transform	Transform
累加	std::accumulate	Accumulate

核心思想： 模板元编程的本质是「类型即数据，模板即函数」。编译期递归替代循环，模板特化替代条件分支，类型列表替代容器。掌握了这三样，你就能在编译期做很多事情。

实战：编译期类型排序

最后，我们综合运用一下。写一个编译期类型排序算法，按类型的大小排序：

// 比较两个类型的大小
template <typename A, typename B>
struct TypeSizeLess {
    static constexpr bool value = sizeof(A) < sizeof(B);
};

// 插入排序（编译期版本）
template <typename T, typename List>
struct Insert;

template <typename T>
struct Insert<T, TypeList<>> {
    using type = TypeList<T>;
};

template <typename T, typename Head, typename... Tail>
struct Insert<T, TypeList<Head, Tail...>> {
    using type = typename std::conditional_t<
        TypeSizeLess<T, Head>::value,
        TypeList<T, Head, Tail...>,
        typename Insert<T, TypeList<Tail...>>::type
    >;
};

// 排序入口
template <typename List>
struct Sort;

template <>
struct Sort<TypeList<>> {
    using type = TypeList<>;
};

template <typename Head, typename... Tail>
struct Sort<TypeList<Head, Tail...>> {
    using type = typename Insert<Head, typename Sort<TypeList<Tail...>>::type>::type;
};

// 使用
using Sorted = Sort<TypeList<double, char, int, long long>>::type;
// 结果：char, int, double, long long

这段代码在编译期完成排序。你想想看，运行时完全不需要排序，因为结果在编译期就已经确定了。

避坑指南： 我曾经在项目中用编译期排序处理一个包含 50 个类型的列表，结果编译时间从 2 秒飙升到 30 秒。模板元编程的编译期开销是真实存在的。如果你的类型列表超过 20 个，建议考虑运行时方案，或者用更高效的算法（比如归并排序的编译期版本）。

模板元编程不是银弹。它适合那些「运行时性能敏感、类型信息在编译期已知」的场景。比如：

序列化/反序列化框架
状态机生成
编译期计算常量
类型安全的工厂模式

记住一点：能用 constexpr 解决的问题，就别用模板元编程。模板元编程的代码可读性差，调试困难，编译时间长。只有在 constexpr 搞不定的时候（比如操作类型本身），才考虑模板元编程。

好了，编译期递归、类型列表、编译期算法，这三样东西你掌握了，模板元编程的大门就算打开了。剩下的就是多写、多练、多踩坑。嗯，踩坑也是一种学习方式。

模板元编程这条路，走通了就是降维打击。走不通？嗯，那就多看看编译器的错误信息，慢慢就习惯了。

📚 课程目录

模板元编程基础：编译期递归，类型列表，编译期算法

编译期递归：让循环在编译期展开

类型列表：在类型的世界里玩数据结构

编译期算法：像操作数据一样操作类型

实战：编译期类型排序