模板元编程就像是给 C++ 编译器装了一台时间机器，它把运行时的计算提前到编译时完成，让程序跑得更快，让代码更灵活，也让你的发际线……呃，更靠后？
no，秃顶可是个要命的东西啊(｡ŏ_ŏ)！
emm...这叫什么呢？这叫聪明绝顶呐(^u^)。
好了，这篇文章呢我主要想聊聊模板元编程到底解决了什么实际问题、怎么上手、以及如何写出能跑也看得懂的元代码。
基础概念
咳，我们就先从基础开始整起。
当我们把这些概念搞透，模板元编程的大门就算踹开了。
1. 模板的编译期本质
先看这段再普通不过的代码：
template<int N>
int square() { return N * N; }
int main()
{
return square<5>();
}
你觉得 square<5> 在运行时做了什么？
其实啥也没做——编译器在编译期就把 N 替换成 5，算出 5*5=25，然后把函数体直接优化成 return 25;最终生成的机器码里根本没有乘法指令。
本质：模板不是函数/类，它是编译器用的模具。
我们给模具填材料（模板参数），编译器在编译期就生成具体的代码。
这意味着：
- 模板参数必须是编译期常量（比如字面量、constexpr 变量）。
- 模板实例化不产生运行时开销（除非故意写运行时循环）。
这就是为什么模板报错动辄一大堆——编译器是在编译期帮我们把代码‘手写’出来，然后发现写错了。
它很委屈：你让我照着图纸造车，图纸里轮子是方的，我能怎么办？我能怎么办嘛(☍﹏⁰。)！
2. 元函数：类型世界的‘函数’
普通函数：输入值，输出值。
元函数：输入类型/编译期常量，输出类型/编译期常量。
C++ 里最朴素的元函数长这样：
// 输入一个类型 T，输出去掉 const 后的类型
template<typename T>
struct remove_const
{
using type = T; // 默认情况：没 const，原样输出
};
// 偏特化：匹配带 const 的类型
template<typename T>
struct remove_const<const T>
{
using type = T; // 去掉 const，输出 T
};
// 用法
remove_const<const int>::type x = 21; // x 是 int
static_assert(std::is_same_v<decltype(x), int>);
怎么读：我们可以把 remove_const<const int> 看作函数调用，把 ::type 看作返回值。
举个栗子也许好懂一些：元函数就像我们在自动售货机处，投进去硬币（类型）后，它哐当掉出来我们想买的东西（另一个类型）。
3. 编译期控制流
普通代码里写 if (condition) {...} else {...}，condition 可以是运行时变量。
编译期控制流：condition 必须是编译期常量，且分支内代码只在编译期实例化时选择，不存在的分支连生成都不生成。
方案一：模板特化 + SFINAE（老派但经典）
比如实现一个编译期的类型比较器：
template<bool B, typename T, typename F>
struct conditional { using type = T; }; // true 时取 T
template<typename T, typename F>
struct conditional<false, T, F> { using type = F; }; // false 时取 F
// 用法：如果 sizeof(int) > sizeof(char)，选 int，否则选 char
using larger_type = conditional<(sizeof(int) > sizeof(char)), int, char>::type;
static_assert(std::is_same_v<larger_type, int>);
这就是 conditional 的原理，相当于编译期的 (cond ? T : F)。
方案二：if constexpr
写递归模板函数时再也不怕爆栈：
// 编译期计算阶乘
template<int N>
constexpr int factorial()
{
if constexpr (N <= 1)
{
return 1; // 这个分支只在 N<=1 时编译
}
else
{
return N * factorial<N - 1>(); // 否则走这里
}
}
int main()
{
constexpr int f5 = factorial<5>(); // 编译期算出 120
}
普通 if 两个分支都会实例化，而 if constexpr 会丢弃不匹配的分支。
没有 if constexpr 的老标准，只能靠模板特化或 SFINAE 模拟，代码又臭又长。
4. 总结
总结一下吧：
- 编译期本质：模板是编译期执行的代码生成器，参数必须常量。
- 元函数：用类模板/别名模板模拟函数，输入输出类型或常量。
- 编译期控制流：用特化/if constexpr 实现分支，避免生成无效代码。
类型操作
这一块整明白了，我们就能在类型的世界里像操作链表一样组合、变换、查询，算是属于模板元编程的‘容器与算法’篇。
1. 类型特征
所谓类型特征，就是回答关于类型的问题：是不是整型？是不是指针？是不是有 const？两个类型是不是一样？......
最朴素的实现：模板特化 + 继承。
判断两个类型是否相同
template<typename T, typename U>
struct is_same : std::false_type {}; // 默认：不相同
template<typename T>
struct is_same<T, T> : std::true_type {}; // 特化：相同
// 用法
static_assert(is_same<int, int>::value); // true
static_assert(!is_same<int, const int>::value); // false
这里 std::true_type 和 std::false_type 是啥？其实就是：
using true_type = std::integral_constant<bool, true>;
using false_type = std::integral_constant<bool, false>;
而 integral_constant<T, v> 是一个包装了编译期常量的类模板，提供 ::value 静态成员和类型别名 ::type。
它主要的作用是在编译期存储和表示一个常量值。
其值是存储在 ::value 静态成员中的。
2. 编译期常量
编译期常量除了 constexpr 变量，还可以编码进类型系统。
三种常见姿势：
(1) 枚举（虽然老了点但能用）
template<int N>
struct Factorial
{
enum { value = N * Factorial<N - 1>::value };
};
template<> struct Factorial<0> { enum { value = 1 }; };
int arr[Factorial<5>::value]; // 编译期确定数组大小
(2) 静态常量成员
template<int N>
struct Factorial
{
static const int value = N * Factorial<N-1>::value;
};
(3) std::integral_constant（个人推荐）
template<int N>
struct Factorial : std::integral_constant<int, N* Factorial<N - 1>::value> {};
template<> struct Factorial<0> : std::integral_constant<int, 1> {};
// 调用
constexpr int f5 = Factorial<5>::value;
好处是能统一接口，并且可以用 decltype(Factorial<5>()) 拿到这个值类型本身，在元编程里很方便传参。
integral_constant 能方便我们的把‘值’提升到‘类型’层次。
如果我们想写一个元函数，既返回类型又返回一个 bool 标记？用 integral_constant 继承就搞定。
3. 类型列表
类型列表是一个只存类型、不存值的列表。
最经典的实现就是递归对 + 空标记，或者直接用 std::tuple 当列表。
先看看经典实现
template<typename... Ts>
struct typelist
{
static constexpr size_t size = sizeof...(Ts); // 计算类型列表的长度
};
// 取第一个类型（car）
template<typename List>
struct front; // 只声明
template<typename Head, typename... Tail>
struct front<typelist<Head, Tail...>>
{
using type = Head; // 将 Head 类型公开为 type 成员
};
// 去掉第一个（cdr）
template<typename List>
struct pop_front; // 依旧只声明
template<typename Head, typename... Tail>
struct pop_front<typelist<Head, Tail...>>
{
using type = typelist<Tail...>; // 返回一个新类型列表，其中只包含 Tail... 部分
};
上述栗子实现了一个类型列表及其两个基本操作：获取头部和移除头部。
如果我们不想自己造轮子，直接用 std::tuple 也可以：
// 取第一个类型
template<typename Tuple>
struct tuple_front;
template<typename Head, typename... Tail>
struct tuple_front<std::tuple<Head, Tail...>>
{
using type = Head;
};
// 去除略
4. 实战：类型特征 + 编译期常量 + 类型列表
举个例子：从一个类型列表里找出第一个满足“是指针”的类型。
template<typename List>
struct find_first_pointer;
// 递归边界：空列表 -> 没找到
template<>
struct find_first_pointer<typelist<>>
{
using type = void;
};
// 递归步骤
template<typename Head, typename... Tail>
struct find_first_pointer<typelist<Head, Tail...>>
{
using type = std::conditional_t<
std::is_pointer_v<Head>, // 如果 Head 是指针
Head, // 就返回 Head
typename find_first_pointer<typelist<Tail...>>::type // 否则递归
>;
};
// 使用
using PtrList = typelist<int, double*, char>;
using Found = find_first_pointer<PtrList>::type; // double*
上述代码中的 std::conditional_t 是一个条件类型选择器，它是 std::conditional模板的一个便捷版本,允许我们根据某个条件来选择两种不同的类型。
其的定义如下：
template< bool B, class T, class F >
struct conditional;
template< bool B, class T, class F >
using conditional_t = std::conditional<B,T,F>::type;
如果 B 为 true，其定义为 T，否则为 F。
看到这个例子有木有头晕目眩？先别怕，现代 C++ 有 if constexpr、concepts 和折叠表达式，写起来已经不像天书了。
我们只要记住——类型列表上的每一个‘算法’都是递归 + 特化，没别的。
SFINAE 与 enable_if
这一块算是一个头疼的地方，但搞懂它之后，就能让编译器“猜我们想重载哪个函数”。
1. SFINAE 回顾
全称：Substitution Failure Is Not An Error。
翻译成人话：“模板参数替换失败不算编译错误，只是这个候选函数被淘汰了。”
先来看个经典例子：
template<typename T>
void foo(typename T::type x) { std::cout << "has type" << std::endl; } // 候选1
template<typename T>
void foo(T x) { std::cout << "fallback" << std::endl; } // 候选2
struct A { using type = int; };
int main() {
foo<A>(0); // 候选1成功：输出 "has type"
foo<int>(0); // 候选1失败：使用候选2，输出 "fallback"
}
当编译器尝试实例化第一个 foo 时，对 int 来说 int::type 是不合法的。
但 SFINAE 规则说：这种失败只是把该重载从候选集里移除，而不是终止编译。然后第二个 foo 匹配成功，程序正常编译。
2. std::enable_if
enable_if 的原理很简单：
template<bool B, typename T = void> struct enable_if;
当 B == true 时，enable_if<B, T>::type 是 T；当 B == false 时，没有 type 成员。
也就是说：当条件为真时，它有一个 type 成员；条件为假时，没有。
我们来看看它是怎么使用的：
2.1 返回值后置（直观）
template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
half(T x)
{
return x / 2;
}
int main()
{
half(10); // 编译通过，返回 5
half(3.14); // 编译错误，double 不是整型，enable_if 无 type，替换失败
}
2.2 默认模板参数（清爽）
template<typename T, typename Enable = typename std::enable_if<std::is_integral<T>::value>::type>
T half(T x) { return x / 2; }
2.3 函数参数（不常用）
template<typename T>
void foo(T x, typename std::enable_if<std::is_pointer<T>::value>::type* = 0)
{
// 仅当 T 是指针时匹配
}
enable_if 像洋葱一样，一层一层的剥开想哭。
能用 if constexpr 或 concepts 就尽量别用它。
但如果要区分两个重载（比如一个是 T*，一个是 const T*），enable_if 还是好使的。
3. 检测成员是否存在
想写一个通用函数：如果类型有 reserve 方法，就调用它；否则啥也不做。
这就是 void_t 技巧。
核心思路：利用 SFINAE 探测表达式是否合法
// 主模板：默认 false
template<typename, typename = void>
struct has_reserve : std::false_type {};
// 特化版本：如果 T.reserve(size_t) 能编译，则匹配
template<typename T>
struct has_reserve<T, std::void_t<decltype(std::declval<T>().reserve(std::declval<size_t>()))>>
: std::true_type {};
// 用法
static_assert(has_reserve<std::vector<int>>::value); // true
static_assert(!has_reserve<int>::value); // false
解释说明：
- std::declval<T>() 假装得到一个 T 的实例（无需构造函数）。
- decltype(expr) 取得表达式的类型。
- std::void_t<...> 把一堆类型映射成 void，但只要其中任何一个无效，特化失败，回退到主模板。
好吧，这玩意搞得像俄罗斯套娃一样，一套一套的。
所以在 C++20 之后可以使用 concept。
4. C++20 的 concepts 版本
template<typename T>
concept has_reserve = requires(T t, size_t n)
{
t.reserve(n);
};
// 使用
template<has_reserve T>
void optimized_insert(T& container)
{
container.reserve(100); // 有 reserve 才进入此模板
}
简洁到令人发指。
因此在现代 C++ 中，如果条件允许的话，我们能用 C++20，请忘掉 enable_if 的复杂语法，直接上 concepts。
递归与特化
这次来看看递归与特化，这是模板元编程的“递归函数 + 模式匹配”。
1. 递归实例化
普通递归：函数在运行时调用自己。
模板递归：编译器在编译期实例化模板时生成新的模板实例，直到特化终止。
一个经典例子：编译期阶乘
template<int N>
struct Factorial
{
static constexpr int value = N * Factorial<N-1>::value;
};
// 特化：递归终止条件
template<>
struct Factorial<0>
{
static constexpr int value = 1;
};
int main()
{
constexpr int x = Factorial<5>::value; // 编译期计算 120
}
编译器做的事：
- 看到 Factorial<5>，需要 Factorial<4>。
- 看到 Factorial<4>，需要 Factorial<3>。
- 直到 Factorial<0>，终止。
- 然后反向代入计算：5*24=120。
它的好处是值在编译期就固定了，运行时零开销。
坏处是如果深度太大（比如 10000 层）编译器可能会爆栈，所以递归深度要控制一下。
2. 偏特化进行模式匹配
模板偏特化允许我们对部分参数指定模式，类似函数式语言的模式匹配。
栗子：编译期判断一个类型是不是 std::vector
template<typename T>
struct is_vector : std::false_type {};
// 偏特化：匹配任何 std::vector<U, Alloc>
template<typename U, typename Alloc>
struct is_vector<std::vector<U, Alloc>> : std::true_type {};
static_assert(is_vector<std::vector<int>>::value); // true
static_assert(!is_vector<int>::value); // false
这里 std::vector<U, Alloc> 是一个模式，U 和 Alloc 是占位符。
编译器会把传入的类型和模式比对，能对上就选用偏特化版本。
偏特化就是编译期的 switch + 解构。
我们在运行时写 if (auto p = dynamic_cast<Derived*>(base))，在编译期写 template<Derived T> 偏特化。
只不过编译期不能运行，只能匹配类型结构。
3. 编译期算法：用递归+特化实现 map
这没什么好说的，直接上栗子。
算法：map——对每个类型应用元函数
目标：typelist<int, double, char> 转成 typelist<int*, double*, char*>。
template<typename List, template<typename> class MetaFunc>
struct map;
// 递归边界
template<template<typename> class MetaFunc>
struct map<typelist<>, MetaFunc>
{
using type = typelist<>;
};
// 递归步骤
template<typename Head, typename... Tail, template<typename> class MetaFunc>
struct map<typelist<Head, Tail...>, MetaFunc>
{
using type = typelist<
typename MetaFunc<Head>::type, // 变换 Head
typename map<typelist<Tail...>, MetaFunc>::type // 递归处理 Tail
>;
};
// 元函数：加指针
template<typename T>
struct add_pointer
{
using type = T*;
};
using Original = typelist<int, double, char>;
using Result = map<Original, add_pointer>::type; // typelist<int*, double*, char*>
有些东西在之前实现过，就不过多讲解了。
编译期算法写起来像在写纯函数式语言，但 C++ 模板语法非常啰嗦。
好消息是 C++14/17 之后引入的变量模板、constexpr 函数和 if constexpr 能大幅简化。
那么我们就来瞅瞅吧。
4. 现代简化方案
C++17 以后，很多编译期算法不再需要模板特化递归，可以用 constexpr 函数 + 普通循环。
例子：编译期整数序列的 map
template<auto... vals>
struct value_list {};
// 定义一个 constexpr 函数对象类型
struct square
{
static constexpr auto apply(auto x) { return x * x; }
};
// constexpr 函数
template<auto... Vs, typename Func>
constexpr auto map_values(value_list<Vs...>, Func)
{
return value_list<Func::template apply(Vs)...>{};
}
using Input = value_list<1, 2, 3>;
using Squared = decltype(map_values(Input{}, square{}));
static_assert(std::is_same_v<Squared, value_list<1, 4, 9>>);
模板特化递归只在真正需要‘类型模式匹配’时用，比如检测一个类型是不是特化、提取模板参数等。
性能与注意事项
性能与注意事项，emm...这是模板元编程的现实拷问。
我们看完编译期计算阶乘可能觉得它超酷，但真上了项目就被编译时间和二进制体积教做人。
1. 编译期开销
模板元编程的本质是让编译器在编译期执行算法。
代价就是：
- 实例化爆炸：每个模板参数组合都会生成一份独立的代码。
比如我们写 std::vector<int>、std::vector<double>、std::vector<std::string>，编译器要分别实例化三份 vector 的所有成员函数。
- 递归深度：经典的模板递归（比如阶乘、类型列表遍历）每层都产生新的模板实例。深度几百层可能还好，上千层就可能会让编译器内存暴涨。
- 编译时间：一个复杂的模板元程序可能让编译时间从秒级变成分钟级。
可能我去泡杯茶，回来后发现编译器还在编译。
所以我的建议是：
不要把编译期计算当成免费的午餐，凡是都是有代价的。能用 constexpr 函数就别用模板递归。
2. 代码可读性：写的时候很爽，读的时候想骂人
模板元编程的语法像两个团队设计的：类型、值、模板、特化混在一起，加上 typename、template 消歧义关键字，看的头晕脑胀直接劝退。
依旧是那个例子：检测类型是否有 reserve 成员
template<typename T, typename = void>
struct has_reserve : std::false_type {};
template<typename T>
struct has_reserve<T, std::void_t<decltype(std::declval<T>().reserve(std::declval<size_t>()))>>
: std::true_type {};
一个新手看了会问：“declval 是什么？void_t 为什么这样写？为什么有两个 struct 定义？”
对比 concepts：
template<typename T>
concept has_reserve = requires(T t, size_t n) { t.reserve(n); };
高下立判。
微不足道小建议：
- 如果能使用 C++20 的话，坚决用 concepts + if constexpr，别再用 SFINAE 写新代码。
- 如果必须用 C++14/17 的话，把复杂的元函数封装成“看起来像普通函数”的别名模板，并写详细的注释，注释很重要！
3. 二进制大小
模板实例化的代码膨胀是 ODR（单一定义规则）的必然结果。
每个实例化会生成独立的机器码，即使逻辑相同。
栗子：
template<typename T>
void copy_n(T* dest, const T* src, size_t n)
{
for (size_t i = 0; i < n; ++i) dest[i] = src[i];
}
如果我们对 int、double、float、long 各实例化一次，链接器可能合并相同指令的函数，但并非总能合并。
如果是更复杂的模板，比如 std::sort 对每种迭代器类型生成特化版本，二进制里可能躺着几十份几乎一样的排序代码。
减少膨胀的方法：
- 提取不依赖模板参数的公共代码到非模板函数（比如上面 copy_n 可以调用 memcpy 对于平凡可复制类型）。
- 对于 std::vector 这类容器，用 void* 实现存储，模板层只做类型转换（像 std::vector<bool> 的特化思路）。
- 使用 extern template 显式实例化，避免在多个翻译单元重复实例化（例如在 .cpp 中实例化 vector，头文件里声明 extern template class vector）。
4. 什么时候模板元编程是值得的？
虽然有一堆缺点，但有些场景不用不行：
- 零开销抽象：std::tuple、std::variant、std::visit 在性能敏感代码中比虚函数或 union 更安全且快。
- 编译期多态：避免运行时 dynamic_cast 和虚函数表开销（比如策略模式用模板参数）。
- 编译期计算：生成查表数据、正则表达式状态机等，把运行时开销转移到编译期。
- 库基础设施：实现 std::is_integral、std::enable_if 这类类型特征，虽然我们大概率不用自己写，但理解原理有助于调试。
小建议：
- 先用运行时版本写原型，如果性能不够且无法优化，再考虑模板元编程。
- 限制模板元的使用范围：只在一个小的头文件内，并确保编译时间和二进制膨胀可接受。
- 不要为了炫技而用：如果别人看不懂这段模板，而我们跑路了，这段代码就是灾难。（这也算是防御式编程吧）
5. 小小总结一下
现代 C++ 提供了 constexpr、if constexpr、concepts 等工具，能让我们在大多数场景避免裸写模板特化递归。
记住：写能维护的代码，比写最聪明的代码更重要。
当我们不得不深入模板元编程时，确保写的代码自己和别人能看懂，并配上详尽的注释。
结尾
通篇读下来，我们可能已经感觉到：模板元编程是一把双刃剑，用好了能够大杀四方，用不好被四方砍成大沙杯。
也没啥好说的了，该说的都说了(‾◡◝ )。
那么最后，记住一句话：“不要用模板元编程来炫耀你的智商，要用它来解决真正的问题。”
