类型列表（Type List）：编译期的“容器”艺术

类型列表，说白了就是编译期版本的 std::vector。只不过它存的不是运行时数据，而是类型。嗯，这个概念我第一次接触时也觉得有点抽象——类型怎么能“存”起来？但等你真正用上它，就会发现这东西在模板元编程里简直无处不在。

我个人习惯把类型列表看作编译期的“数据结构”。它没有运行时开销，所有操作都在编译期完成。你想想看，这多适合做策略选择、类型分发、甚至是构建状态机。

定义类型列表：从空列表开始

最简单的类型列表，就是一个模板类，接受任意数量的类型参数：

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

这就够了。你可以这样用：

using MyList = TypeList<int, double, char, float>;
using EmptyList = TypeList<>;

空列表也是合法的。我在项目中遇到过有人忘记处理空列表的情况，结果编译错误铺天盖地。所以，永远给空列表留一条活路。

template<typename... T>
using TList = TypeList<T...>;

编译期操作：Push、Pop、Get

有了容器，自然要有操作。类型列表的三大基本操作就是：Push（追加）、Pop（弹出）、Get（按索引取）。这些操作全部在编译期完成，零运行时开销。

Push：在列表头部插入类型

Push 操作其实很简单——把新类型和旧列表拼起来：

template<typename T, typename List>
struct Push;

template<typename T, typename... Types>
struct Push<T, TypeList<Types...>> {
    using type = TypeList<T, Types...>;
};

用法：

using Original = TypeList<int, double>;
using NewList = Push<float, Original>::type;
// NewList 现在是 TypeList<float, int, double>

为什么插在头部而不是尾部？因为模板参数包只能在前面追加，尾部追加需要递归展开，性能差一些。我建议你养成“头部插入”的习惯，除非你有特殊需求。

Pop：弹出头部类型

Pop 就是把第一个类型拿掉，剩下的保留：

template<typename List>
struct Pop;

template<typename T, typename... Types>
struct Pop<TypeList<T, Types...>> {
    using type = TypeList<Types...>;
};

template<>
struct Pop<TypeList<>> {
    using type = TypeList<>; // 或者 static_assert(false, "Cannot pop from empty list");
};

Get：按索引获取类型

Get 操作稍微复杂一点，需要递归遍历：

template<size_t Index, typename List>
struct Get;

template<typename T, typename... Types>
struct Get<0, TypeList<T, Types...>> {
    using type = T;
};

template<size_t Index, typename T, typename... Types>
struct Get<Index, TypeList<T, Types...>> {
    using type = typename Get<Index - 1, TypeList<Types...>>::type;
};

用法：

using MyList = TypeList<int, double, char, float>;
using SecondType = Get<1, MyList>::type; // double

这里有个坑：索引越界。如果 Index 大于等于列表长度，编译会报错。我建议你在实际项目中加一个静态断言：

template<size_t Index, typename List>
struct Get {
    static_assert(Index < List::size, "Index out of range");
    // ...
};

不过要获取列表长度，我们还需要一个 size 元函数：

template<typename List>
struct Size;

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

知识体系图：类型列表的核心操作

下面这张图总结了类型列表的定义和三大操作，以及它们之间的关系：

组合操作：让类型列表真正可用

有了 Push、Pop、Get，你就可以组合出更复杂的操作。比如 Find（查找类型索引）、Remove（移除指定类型）、Transform（对每个类型应用元函数）。

举个例子，查找类型在列表中的位置：

template<typename T, typename List>
struct Find;

template<typename T, typename... Types>
struct Find<T, TypeList<T, Types...>> {
    static constexpr size_t value = 0;
};

template<typename T, typename U, typename... Types>
struct Find<T, TypeList<U, Types...>> {
    static constexpr size_t value = 1 + Find<T, TypeList<Types...>>::value;
};

这个实现有个问题：如果类型不存在，它会递归到空列表然后编译失败。我一般会加一个哨兵：

template<typename T>
struct Find<T, TypeList<>> {
    static constexpr size_t value = static_cast<size_t>(-1); // 表示未找到
};

实际项目中的应用

我在做游戏引擎的组件系统时，就用类型列表来管理所有组件类型。每个实体有一个类型列表，表示它拥有的组件。查询某个组件是否存在，就是一次编译期 Find 操作。性能？零开销。代码可读性？比运行时反射强一百倍。

另一个常见场景是策略模式。你可以把一组策略类型放在列表里，然后用 Get 按索引选择策略。这样策略的切换在编译期就确定了，没有虚函数开销。

嗯，这里要注意：类型列表虽然强大，但不要滥用。如果你的类型列表超过几十个元素，编译时间会明显增加。我个人的经验是，20 个以内最舒服，超过 50 个就要考虑是否该换个方案了。

好了，类型列表的基本操作就这些。记住：Push 插头部、Pop 删头部、Get 按索引取。这三个操作组合起来，能解决 90% 的编译期类型操作需求。