模板元编程基础

1 C++ 模板元编程（Template Metaprogramming）详解

模板元编程（TMP）是 C++ 最强大也最复杂的特性之一。它利用模板的实例化机制，让编译器在编译期完成计算、类型操作和代码生成，从而实现零运行时开销的高性能代码。

“模板元编程就是用 C++ 模板写一个程序，这个程序由编译器执行，输出的是另一段 C++ 代码。”

---

1.1 什么是模板元编程？

• 普通编程：代码在运行时执行（runtime）。
• 模板元编程：代码在编译时执行（compile-time）。编译器通过模板实例化进行“计算”。
• TMP 让 C++ 模板系统成为一门图灵完备的编程语言（可以实现任意可计算函数）。

核心优势：

• 零运行时开销（所有计算在编译期完成）
• 更强的类型安全和静态检查
• 高度泛型和可复用代码
• 实现编译期计算、代码生成、策略选择等

缺点：

• 编译时间显著增加
• 错误信息极其晦涩（尤其在 C++11 之前）
• 代码可读性差（“模板地狱”）
• 调试困难

---

1.2 模板元编程的发展历程

• C++98/03：基础模板 + 模板特化 + SFINAE（Substitution Failure Is Not An Error）
• C++11：constexpr、类型特性（type traits）、变参模板（variadic templates）
• C++14：变量模板（variable templates）、泛型 lambda
• C++17：if constexpr（极大简化 TMP）、折叠表达式（fold expressions）
• C++20：Concepts（概念）、consteval、requires 表达式 —— 彻底改变了 TMP 的写法，使其更接近“普通代码”
• C++23/26：进一步增强 constexpr 能力、反射（Reflection）提案正在推进

现代建议：优先使用 C++20/23 特性（Concepts + if constexpr + constexpr 函数），尽量减少传统 SFINAE 和递归模板。

---

1.3 基础概念与示例

1.3.1 类型计算（Type Computation）

// 传统方式：计算类型
template<typename T>
struct AddPointer {
    using type = T*;          // 类型别名
};
 
using IntPtr = AddPointer<int>::type;   // IntPtr 是 int*

1.3.2 编译期数值计算（经典阶乘示例）

C++98/03 时代最常见的入门例子：用模板递归在编译期算阶乘。

// 递归终止：Factorial<0>
template<unsigned N>
struct Factorial {
    static const unsigned value = N * Factorial<N - 1>::value;
};
 
template<>
struct Factorial<0> {
    static const unsigned value = 1;
};
 
static_assert(Factorial<5>::value == 120);  // 编译期断言

要点：

• Factorial<N>::value 必须在编译期可求值，才能用于 static_assert、数组长度、模板非类型参数等。
• 本质是「用类型（Factorial<5>）承载一次计算」，编译器在实例化模板时把结果算出来。

现代写法（C++14 起更推荐）：用 constexpr 函数代替递归类模板，可读性更好：

constexpr unsigned factorial(unsigned n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
 
static_assert(factorial(5) == 120);
 
// C++17：编译期变量
constexpr unsigned fact10 = factorial(10);

constexpr 函数仍可在编译期求值；若传入的运行时值在编译期未知，则退化为运行时计算。TMP 的「计算」越来越多由 constexpr 承担，类模板递归更多留给类型层面的操作。

1.3.3 编译期分支：std::integral_constant 与布尔值

很多 TMP 需要「编译期的 true/false」，标准库用 std::bool_constant / std::integral_constant 表达：

#include <type_traits>
 
template<typename T>
struct IsPointer : std::false_type {};
 
template<typename T>
struct IsPointer<T*> : std::true_type {};
 
static_assert(IsPointer<int*>::value == true);
static_assert(IsPointer<int>::value == false);

• std::true_type / std::false_type 的 .value 是 constexpr bool。
• 偏特化 IsPointer<T*> 只匹配指针类型，是 TMP 里「按形状选实现」的基本手法。

C++17 起可直接用 std::is_pointer_v<T> 等 type traits，不必手写，但理解偏特化对读库代码和写 Concept 仍有帮助。

---

1.4 SFINAE：替换失败不是错误

SFINAE（Substitution Failure Is Not An Error）：在重载决议时，若把模板参数代入某候选函数会导致无效类型/表达式，该候选被静默丢弃，而不是整段编译失败。

典型用途：根据类型是否有某个成员、是否可调用，在编译期选择不同重载。

#include <type_traits>
#include <iostream>
 
// 有 .size() 的类型走这里
template<typename T>
auto print_size(const T& x) -> decltype((void)x.size(), void())
{
    std::cout << "size = " << x.size() << '\n';
}
 
// 没有 .size() 的走这里（省略号优先级最低，作兜底）
void print_size(...) {
    std::cout << "no size()\n";
}
 
int main() {
    print_size(std::string{"hi"});  // size = 2
    print_size(42);                 // no size()
}

decltype((void)x.size(), void()) 一行里：若 x.size() 不合法，替换失败，第一个重载不参与匹配，编译器选 print_size(...)。

C++11 std::enable_if（仍常见于旧代码与库实现）：

template<typename T>
typename std::enable_if<std::is_integral_v<T>, void>::type
foo(T) { /* 仅整数 */ }
 
template<typename T>
typename std::enable_if<std::is_floating_point_v<T>, void>::type
foo(T) { /* 仅浮点 */ }

缺点：错误信息长、重载集难维护。现代代码优先 if constexpr 或 Concepts（见 C++17、C++20）。

---

1.5 类型萃取（Type Traits）与 decltype

Type traits 在 <type_traits> 中提供编译期「类型属性」与「类型变换」：

类别	示例	作用
属性查询	std::is_integral_v<T>	是否为整数
类型变换	std::remove_reference_t<T>	去掉引用
类型变换	std::add_pointer_t<T>	得到 T*
条件类型	std::conditional_t<Cond, A, B>	编译期 if-else 选类型

与 模版函数实例化的时机 配合理解：traits 常在模板定义阶段决定返回类型、重载或分支，实例化时已经定型。

decltype 根据表达式推导类型，常与尾置返回类型、SFINAE 一起用：

template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

C++14 起可写 auto add(T a, U b) { return a + b; }，编译器自动推导返回类型。

---

1.6 变参模板与折叠表达式

变参模板（C++11）可接受任意个数类型/值参数，常用于 tuple、格式化、std::variant visit 等。

template<typename... Args>
void log(Args&&... args) {
    (std::cout << ... << args) << '\n';  // C++17 二元左折叠
}
 
log(1, " ", 3.14, "\n");  // 输出 1 3.14\n

折叠表达式（C++17）对参数包 args... 做一元/二元运算展开，替代大量递归模板。常见形式：

• (args + ...) — 右折叠，求和
• (... + args) — 左折叠
• (f(args), ...) — 逗号折叠，对每个参数调用 f

---

1.7 if constexpr：编译期分支（C++17）

在模板内按类型分支时，if constexpr 让不满足条件的分支不参与编译，避免 SFINAE 式重载爆炸。详见 C++17 中 if constexpr 一节。

template<typename T>
auto process(T value) {
    if constexpr (std::is_integral_v<T>) {
        return value * 2;
    } else if constexpr (std::is_floating_point_v<T>) {
        return value * 1.5;
    } else {
        return value;
    }
}

注意：条件必须是编译期常量；if constexpr 主要在模板里发挥「丢弃分支」的作用。

---

1.8 Concepts（C++20）：约束模板参数

Concepts 用 requires 把「模板参数必须满足什么」写清楚，错误信息比 SFINAE 友好得多。详见 C++20。

#include <concepts>
 
template<std::integral T>
T add(T a, T b) { return a + b; }
 
// add(1, 2);     OK
// add(1.0, 2.0); 编译错误：约束不满足

自定义 concept 示例：

template<typename T>
concept HasSize = requires(T t) {
    { t.size() } -> std::convertible_to<std::size_t>;
};
 
template<HasSize T>
void print_len(const T& x) {
    std::cout << x.size() << '\n';
}

TMP 的「类型约束」从技巧性 SFINAE 走向语言级、可读的契约。

---

1.9 常见模式速查

1.9.1 Tag Dispatch（标签分发）

用空类型（tag type）在重载集里选实现，编译期零开销：

struct random_access_tag {};
struct input_tag {};
 
template<typename It>
void advance_impl(It& it, int n, random_access_tag) {
    it += n;
}
 
template<typename It>
void advance_impl(It& it, int n, input_tag) {
    while (n-- > 0) ++it;
}
 
template<typename It>
void advance(It& it, int n) {
    using tag = typename std::iterator_traits<It>::iterator_category;
    advance_impl(it, n, tag{});
}

与 STL iterator_category 设计一脉相承。

1.9.2 CRTP（奇异递归模板模式）

派生类把自己作为基类模板参数，用于静态多态、混入功能：

template<typename Derived>
struct Base {
    void interface() {
        static_cast<Derived*>(this)->impl();
    }
};
 
struct Impl : Base<Impl> {
    void impl() { /* ... */ }
};

无虚表开销，常见于 enable_shared_from_this、部分表达式模板库。

1.9.3 表达式模板（简要）

用于延迟求值、减少临时对象（如矩阵库 Eigen 的思路）：运算符重载返回代理类型，在赋值时才真正计算。属于 TMP 的工业级应用，实现复杂，日常业务代码较少手写。

---

1.10 何时用 TMP，何时不用

适合：

• 性能敏感、必须在编译期确定的常量（数组大小、位掩码、协议字段偏移）
• 泛型库（容器、算法、序列化）需要随类型变化而零开销适配
• 用 Concept / static_assert 把错误前移到编译期

尽量避免：

• 能用普通 constexpr + 普通函数解决的，不必上递归模板
• 团队不熟悉 TMP 的核心业务逻辑（可维护性 > 微优化）
• 过度 SFINAE 导致报错难以定位

实践顺序：constexpr 函数 → if constexpr + type traits → Concepts → 仅在库边界或确有需要时再写 SFINAE/CRTP。

---

1.11 小结

主题	要点
本质	利用模板实例化在编译期做计算与代码生成
演进	SFINAE → constexpr / traits → if constexpr → Concepts
数值计算	优先 constexpr，少用递归 Factorial<N> 类
类型操作	type traits、偏特化、decltype
参数包	变参模板 + C++17 折叠表达式
约束	C++20 Concepts 替代大部分 enable_if

模板元编程不是「炫技」，而是让正确性尽量在编译期体现、运行时尽量少付钱。结合 模版函数实例化的时机 理解实例化时机，结合 C++11、C++17、C++20 按标准逐步采用现代写法，可以少走很多模板地狱。

---

1.12 延伸阅读

• C++17 — if constexpr、折叠表达式、std::optional 等
• C++20 — Concepts、consteval、ranges
• 模版函数实例化的时机 — 模板何时真正生成代码
• cppreference — Template metaprogramming