Item 48：认识 template metaprogramming

从运行前已经完成的程序开始

template metaprogram 是由 compiler 执行的程序。输入通常是 types 和 compile-time constants，输出是新的 types、constants 或选定的 C++ declarations。

Item 48 的原则是 Be aware of template metaprogramming（认识模板元编程）。重点是理解其能力和成本，不是把所有逻辑改成 templates。

先预测：把工作移到 compile time 是否等于“免费”？运行时间可能减少，但编译 CPU、内存、诊断与 binary instantiations 都会增加。

Factorial：递归与终止特化

template<unsigned N>
struct Factorial {
    static constexpr unsigned value = N * Factorial<N - 1>::value;
};
 
template<>
struct Factorial<0> {
    static constexpr unsigned value = 1;
};
 
static_assert(Factorial<5>::value == 120);

一般模板相当于递归公式，Factorial<0> 完全特化相当于 base case。compiler 实例化到 0 后向上折叠结果。

这里没有 runtime recursive function，也没有 runtime loop；120 可直接进入 array bound、non-type argument 或 machine constant。

TMP 的条件、循环与变量是什么

传统 TMP 没有普通 mutable variables。状态通过 template arguments 传递，循环通过递归实例化，条件通过 specialization 或类型选择表达。

template<bool Condition, class Then, class Else>
struct Select { using type = Then; };
 
template<class Then, class Else>
struct Select<false, Then, Else> { using type = Else; };

现代 std::conditional_t 提供相同能力；理解这种模型有助于阅读 traits、enable_if 和标准库实现。

运行成本前移，不是消失

TMP 可把重复 runtime decisions 前移到编译阶段。例如 serializer 根据 type traits 选择 fixed-size path，最终函数不需要每个对象都分支。

收益可能包括更少 branch、更多 inlining、常量传播和非法状态无法表达。代价包括更慢 build、更高 compiler memory、更长 errors 和更多 instantiations。

policy choices 组合行为

template<class LockPolicy, class CheckPolicy>
class Buffer : private LockPolicy, private CheckPolicy {
public:
    void write(std::size_t index, std::byte value) {
        typename LockPolicy::Guard guard(*this);
        CheckPolicy::check(index);
        data_[index] = value;
    }
private:
    std::array<std::byte, 256> data_{};
};

不同 policies 产生不同 types，compiler 可 inline policy calls，空 policy 还可能经 EBO 不增加对象大小。代价是每种组合都可能形成新的 instantiation 和 binary code。

dimensional safety 把单位错误变成类型错误

template<int Length, int Time>
class Quantity {
public:
    explicit constexpr Quantity(double value) : value_(value) {}
private:
    double value_;
};
 
using Distance = Quantity<1, 0>;
using Duration = Quantity<0, 1>;
using Speed = Quantity<1, -1>;

multiplication/division 可在 template arguments 上加减指数，compiler 生成结果 type。距离与时间不能直接相加，错误在 build 时暴露，而不是以错误数值进入运行。

expression templates 与延迟表达式树

矩阵表达式 a = b + c + d 若每个 operator 立即构造 temporary，会产生多次遍历。expression templates 可让 operators 返回 lightweight expression node types，最终 assignment 一次遍历求值。

这是 custom code generation：expression type 编码操作树，compiler 为该树生成融合 loop。风险是 dangling references、巨大类型、诊断复杂和 compile-time 爆炸。

编译期循环的资源上限

Factorial 很小，真实元程序可能触发深层递归和大量 specializations。compiler 有 template instantiation depth 限制，也受内存和错误回溯长度影响。

用 alias templates 分段命名中间结果、减少重复实例、把稳定实现移入非模板 helper，并对 compile time 建立基准。

现代 constexpr 更适合值计算

consteval unsigned factorial(unsigned n) {
    unsigned result = 1;
    for (unsigned i = 2; i <= n; ++i) result *= i;
    return result;
}
 
static_assert(factorial(5) == 120);

对纯值计算，constexpr/consteval 通常比递归 template 更可读、diagnostics 更好。TMP 仍擅长生成/选择 types、检测 expressions 和组合 policies。

concepts 改善元程序入口

concepts 可为 requirements 命名，让非法输入在入口处失败，而不是在数十层 specialization 后报错。

但 concept 本身也属于 compile-time programming。不要把“现代语法”误认为没有复杂度；仍需控制 dependency、instantiation 和 overload set。

一套采用 TMP 的决策流程

1. 输入是否在 compile time 已知，且不会依赖 runtime data。
2. 目标是生成 types、拒绝非法组合，还是消除可测 runtime 热点。
3. 普通 constexpr、overload、variant 或 runtime branch 是否更清楚。
4. instantiation cardinality、build time、binary size 是否在预算内。
5. 错误能否通过 concepts、aliases 和 static assertions 清晰呈现。
6. 用 compile benchmark、runtime benchmark 与 contract tests 同时验收。

先预测 Factorial、单位类型和 policy Buffer 各自输出的是 value、type 还是 concrete code，再查看 compiler 生成的 symbols 与诊断。

小结

• TMP 在编译期以 types/constants 为输入，通过 specialization 和 recursive instantiation 计算
• Factorial 展示一般模板递归与完全特化终止，结果可折叠为 compile-time constant
• TMP 可做 type selection、policy choices、dimensional safety 和 custom code generation
• 运行工作前移能消除分支和非法状态，但增加 build time、instantiation 与诊断成本
• expression templates 能融合运算，也可能引入 dangling、代码膨胀和复杂错误
• 现代值计算优先考虑 constexpr/consteval，types 与结构选择仍是 TMP 强项