zeno's blog
返回

现代 C++(四)：模板元编程从 SFINAE 到 Concepts

专题: 现代 C++

Table of contents

Open Table of contents

TL;DR

C++ 模板元编程（TMP）的本质是把编译器当成纯函数式解释器：类型是值、模板是函数、偏特化是模式匹配。SFINAE 是语言规则的副作用被滥用成约束机制的历史遗留，C++17 if constexpr + C++20 Concepts 把”编译期分支”和”约束表达”从巫术升级为一等公民，错误信息从 200 行模板栈变成一行说明。业务代码 95% 用不到深度 TMP，但读标准库和调试模板错误必须看得懂。

1. 什么是模板元编程

本质：把 C++ 编译器的模板实例化机制当成一个纯函数式、无副作用的解释器。把类型和编译期常量当成”值”，把类模板和函数模板当成”函数”，让编译器在产出目标代码之前先跑一段”元程序”。

关键心智模型：TMP 代码的”运行时”是编译期。“值”主要是类型和 constexpr 常量，“函数”主要是类模板特化（以 ::type / ::value 暴露结果）。这种模型更接近 Haskell 而不是 C——没有变量、没有赋值、没有循环，只有模式匹配和递归。

1.1 历史脉络（面试能体现段位的部分）

面试金句：“C++ TMP 是图灵完备的意外产物，SFINAE 是被滥用的语言副作用，C++20 Concepts 是正经的救赎”——讲得出这条时间线，段位比只会背 enable_if 语法的人高一档。

2. 模板基础快速回顾

3. SFINAE：从神技到历史遗产

核心规则：模板参数替换到函数签名（返回类型、参数类型、默认参数）时如果失败，不是编译错误，而是把这个候选从重载决议集里静悄悄拿掉。注意：替换失败必须发生在 immediate context，模板函数体内的错误是硬错误，不是 SFINAE。

3.1 典型写法

// 方式一：enable_if 放返回类型
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T>
abs(T x) { return x < 0 ? -x : x; }

// 方式二：enable_if 作为默认模板参数（更常用）
template <typename T,
          std::enable_if_t<std::is_integral_v<T>, int> = 0>
T abs(T x) { return x < 0 ? -x : x; }

3.2 std::void_t 技巧（C++17）：检测表达式合法

template <typename, typename = std::void_t<>>
struct has_size : std::false_type {};

template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type {};

原理：主模板默认匹配；偏特化要求 decltype(t.size()) 合法，合法时被选中（更特殊），否则偏特化被 SFINAE 踢掉回落到主模板。std::declval<T>() 给出一个 T&& 的”假实例”供 decltype 用（因为不是所有类型都能默认构造）。

3.3 为什么 SFINAE 从神技变遗产

  1. 错误信息地狱：替换失败层层传递，一个用户错误能爆出几百行模板栈
  2. 语法噪音：std::enable_if_t<std::is_integral_v<std::remove_cvref_t<T>>, int> = 0 占签名一半长度
  3. 组合困难：多个 enable_if 需要互斥，否则重载冲突，写起来像解逻辑题
  4. “只是恰好能工作”：SFINAE 本是语言为支持重载决议的一个副作用，被程序员滥用成约束机制。它从未被设计来干这件事
  5. C++20 concepts 是正经解决方案：直接写”T 必须满足什么”，编译器理解意图，错误友好，可命名、可组合

核心洞察：能讲出”SFINAE 是副作用被滥用”这句话，段位比只会背 enable_if 语法的人高一档。

4. Type Traits：TMP 的元素周期表

<type_traits> 分两类：

查询类（返回 bool_constant 或整数）：

修改类（返回类型）：

4.1 decay_t vs remove_cvref_t 的微妙区别

decay_t<int[5]>        // int*
remove_cvref_t<int[5]> // int[5]

需要保留数组/函数形态时用 remove_cvref_t，否则一般用 decay_t。

4.2 手写 trait 示例

// C++17 SFINAE 版（检测是否有 size() 成员）
template <typename, typename = std::void_t<>>
struct has_size : std::false_type {};
template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type {};

// C++20 concept 版：直接写
template <typename T>
concept HasSize = requires(T t) {
    { t.size() } -> std::integral;  // 还额外约束了返回类型
};

concept 版本更精确（约束返回类型）、更短、错误信息更友好。

5. Variadic Templates

5.1 C++11 递归展开

void print() {}  // 终止
template <typename T, typename... Rest>
void print(const T& first, const Rest&... rest) {
    std::cout << first;
    if constexpr (sizeof...(rest) > 0) std::cout << ", ";
    print(rest...);
}

5.2 C++17 折叠表达式

template <typename... Args>
auto sum(Args... args) { return (args + ...); }

template <typename... Args>
void print(Args... args) { ((std::cout << args << ' '), ...); }

四种折叠：

sizeof...(pack) 返回包内元素个数，不实例化，能在重载决议里直接用。

5.3 std::tuple 的实现思路

template <typename... Ts> struct Tuple {};
template <typename Head, typename... Tail>
struct Tuple<Head, Tail...> : Tuple<Tail...> {
    Head head;
    Tuple(Head h, Tail... t) : Tuple<Tail...>(t...), head(h) {}
};

递归继承 + 每层存一个元素。std::get<N> 通过类型匹配在继承链上爬。生产级实现用聚合 + std::index_sequence 避免深递归。

典型应用：make_unique<T>(args...)、emplace_back(args...)、类型安全的 printf 替代、RPC 框架自动序列化参数列表。

6. Perfect Forwarding：引用折叠是核心

万能引用（Forwarding Reference）：T&& 只有在类型推导的上下文中才是万能引用。

template <typename T> void f(T&& x);           // 万能引用
void g(MyClass&& x);                            // 纯右值引用
template <typename T> void h(std::vector<T>&& x);  // 纯右值引用（vector<T>&& 不是 T&&）

6.1 引用折叠规则

模板形参 T&&实参类型T 推导为折叠结果
左值 intint&int&int& && → int&
左值 const intconst int&const int&const int& && → const int&
右值 intint&&intint && → int&&

口诀：只要有一个是左值引用，结果就是左值引用（&+& → &，&+&& → &，&&+& → &，&&+&& → &&）。

6.2 std::forward<T> 的实现

template <typename T>
T&& forward(std::remove_reference_t<T>& x) noexcept {
    return static_cast<T&&>(x);
}

关键：用 remove_reference_t<T>& 作为形参类型，阻止类型推导。调用方必须显式指定 T（通常是函数模板的原 T）。如果 T 是 int&，static_cast<int& &&> 折叠成 int&（左值）；如果 T 是 int，转成 int&&（右值）。条件 cast。

6.3 std::move 的实现（无条件 cast）

template <typename T>
std::remove_reference_t<T>&& move(T&& x) noexcept {
    return static_cast<std::remove_reference_t<T>&&>(x);
}

一句话总结：move 是无条件转右值，forward 是保留原始值类别的条件转换，二者都是编译期的 static_cast，零运行时成本。

7. CRTP：静态多态

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

工作机制：Base 实例化时 Derived 已经是完整类型，static_cast<Derived*>(this) 告诉编译器按 Derived 调用，没有虚表查找。

典型应用：

vs 虚函数：

CRTP虚函数
开销零运行时，可内联vtable 间接
异构容器不支持（每个 Base<X> 不同类型）支持
代码体积模板膨胀单份

选型：对象自己知道自己类型且性能敏感时用 CRTP；需要运行时多态、异构容器时用虚函数。

8. 编译期常量计算：从 TMP 递归到 constexpr

8.1 老派 TMP（教学 > 实用）

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

8.2 C++11/14 constexpr

// C++11：严格单 return
constexpr int factorial(int n) { return n <= 1 ? 1 : n * factorial(n - 1); }

// C++14：放宽，可含循环
constexpr int factorial_14(int n) {
    int r = 1;
    for (int i = 2; i <= n; ++i) r *= i;
    return r;
}

8.3 C++20 对比

8.4 if constexpr 的 discarded branch 陷阱（深入点）

被丢弃的分支仍然要求语法良构（well-formed），但不做依赖类型的语义检查。

template <typename T>
auto get_value(T t) {
    if constexpr (std::is_pointer_v<T>) return *t;  // 非指针类型也不报错
    else return t;
}

但是：

template <typename T>
void f(T t) {
    if constexpr (false) { syntax error here }  // 仍然是编译错误
}

C++ 标准把函数模板解析分两阶段：第一阶段做非依赖代码的语法+语义检查，第二阶段做依赖代码的检查。if constexpr 的丢弃分支跳过的是第二阶段的语义检查（对依赖类型的类型检查、成员查找等），不跳过第一阶段的语法检查和对非依赖代码的语义检查。所以 if constexpr (false) { hdsjkf } 错，但 if constexpr (false) { t.nonexistent_method(); }（t 是模板参数类型的实例）对。

9. Tag Dispatch：if constexpr 的前世

// C++14 Tag Dispatch
template <typename Iter>
void advance_impl(Iter& it, int n, std::random_access_iterator_tag) { it += n; }
template <typename Iter>
void advance_impl(Iter& it, int n, std::bidirectional_iterator_tag) {
    if (n > 0) while (n--) ++it; else while (n++) --it;
}
template <typename Iter>
void advance(Iter& it, int n) {
    advance_impl(it, n, typename std::iterator_traits<Iter>::iterator_category{});
}

// C++17 一个 if constexpr 搞定
template <typename Iter>
void advance(Iter& it, int n) {
    using Cat = typename std::iterator_traits<Iter>::iterator_category;
    if constexpr (std::is_base_of_v<std::random_access_iterator_tag, Cat>) {
        it += n;
    } else {
        if (n > 0) while (n--) ++it; else while (n++) --it;
    }
}

一个函数顶原来三个，阅读成本大幅下降。

10. Concepts：TMP 的救赎（C++20）

// SFINAE 版本（C++14）
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T> abs(T x) { return x < 0 ? -x : x; }

// Concepts 版本（C++20）
template <std::integral T>
T abs(T x) { return x < 0 ? -x : x; }

// 或缩写
auto abs(std::integral auto x) { return x < 0 ? -x : x; }

requires 表达式可以表达”这个类型必须支持某表达式”：

template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::same_as<T>;
};

代码量 1/3，意图清晰，错误信息从”无法从重载集中找到候选，注意以下 30 行替换失败”变成”abs 要求 T 满足 std::integral，你传的是 std::string”。

11. if constexpr 重构 SFINAE 示例

SFINAE 版本（三个重载）：

template <typename T>
std::enable_if_t<std::is_integral_v<T>, std::string> to_string(T t) {
    return std::to_string(t);
}

template <typename T>
std::enable_if_t<std::is_same_v<T, std::string>, std::string> to_string(T t) {
    return t;
}

template <typename T>
std::enable_if_t<std::is_pointer_v<T>, std::string> to_string(T t) {
    return t ? "ptr" : "null";
}

if constexpr 版本（一个函数）：

template <typename T>
std::string to_string(T t) {
    if constexpr (std::is_integral_v<T>)        return std::to_string(t);
    else if constexpr (std::is_same_v<T, std::string>) return t;
    else if constexpr (std::is_pointer_v<T>)    return t ? "ptr" : "null";
    else static_assert(sizeof(T) == 0, "unsupported type");
}

static_assert(sizeof(T) == 0, ...) 是一个习惯用法：用依赖表达式让 assert 只在这个分支被实例化时才触发。

12. Type Erasure：std::function 的内部

目标：存储”任何可调用、签名为 R(Args...) 的东西”在一个统一类型里。

本质技术：内部持有一个基类指针，基类有虚函数 invoke，派生类模板存储真正的 callable 并 override。

template <typename Signature> class Function;

template <typename R, typename... Args>
class Function<R(Args...)> {
    struct Concept { virtual R call(Args...) = 0; virtual ~Concept() = default; };
    template <typename F>
    struct Model : Concept {
        F f;
        Model(F f) : f(std::move(f)) {}
        R call(Args... args) override { return f(args...); }
    };
    std::unique_ptr<Concept> p;
public:
    template <typename F>
    Function(F f) : p(std::make_unique<Model<F>>(std::move(f))) {}
    R operator()(Args... args) { return p->call(args...); }
};

代价：堆分配 + 虚调用。生产的 std::function 为小 callable 做 SBO（small buffer optimization）避免堆分配。

思考：类型擦除 vs 虚继承 vs 模板，本质都是把多态点推到不同阶段——虚函数是运行时、模板是编译期、类型擦除是”编译期擦除类型，运行时通过统一接口调用”。

13. 陷阱总表

陷阱说明
依赖类型需要 typenametypename T::iterator it;
依赖模板名需要 templateobj.template f<int>();
SFINAE 的 immediate context函数体内错误是硬错误，不是 SFINAE
完美转发构造函数劫持拷贝template<T> Class(T&&) 比拷贝构造更匹配，需要 SFINAE/concept 排除自身类型
万能引用不是右值引用void f(MyClass&&) 是右值引用；template<T> void f(T&&) 才是万能引用
模板代码膨胀vector<int> 和 vector<long> 是两个完全独立的代码副本
ODR 违反同一特化在不同 TU 有不同定义
变参递归深度限制编译器栈 GCC ~900，MSVC ~500
std::forward 不带模板参数必须 std::forward<T>(x)，设计上拒绝类型推导
auto&& + decltype(auto) 混淆decltype(auto) 保留引用和 cv，auto decay
constexpr 不等于”一定编译期”运行时参数调用就是普通函数，用 consteval 强制
if constexpr 非模板里没意义特性只在模板实例化时生效
CRTP Base 不能在自己定义内访问 Derived 成员类体定义阶段 Derived 还不完整
initializer_list 干扰完美转发{1,2,3} 优先匹配 initializer_list 重载

14. 对比其他语言的元编程

C++ concepts + constexpr + consteval 正在向 Zig 方向演进，但语言兼容性包袱让它永远做不到那么干净。

15. 深入话题

15.1 SFINAE 的 immediate context 到底指哪里

在 immediate context（SFINAE 生效）：

不在 immediate context（硬错误）：

这是为什么 enable_if_t 放返回类型或参数默认参数能 SFINAE，放函数体里的 static_assert 就不能。

15.2 TMP 的编译时间代价

15.3 模板膨胀的二进制影响

std::sort<vector<int>::iterator> 和 std::sort<list<int>::iterator> 是两份完整代码。Google/Facebook 的 C++ 大仓库里有专门的”去模板化”工作——把热路径从模板抽成类型擦除版本减小 i-cache 压力。“零开销抽象”在运行时是零开销，但在编译时间和二进制大小上从来不是零。

15.4 std::forward 为什么必须显式传模板参数

它的参数类型是 remove_reference_t<T>&，这是一个非推导上下文（non-deduced context），编译器无法从实参推出 T。这是故意设计——如果能推导，forward(x) 会根据 x 的类别推错（左值 x 会推出 T = X&，右值 cast 后还是左值，转发就失效）。必须调用方说”我原本这个参数的模板类型是 T”，forward 才能正确条件 cast。

16. 应届生视角：学多深

业务代码 95% 用不到深度 TMP，但以下场景必须看得懂：

面试重点（按频率）：

  1. std::forward / std::move 的区别和实现原理
  2. 引用折叠规则
  3. SFINAE 是什么、它为什么从 C++20 起被淘汰
  4. if constexpr 如何干掉 Tag Dispatch 和 SFINAE
  5. CRTP 的工作原理和 vs 虚函数
  6. Concepts 怎么让错误信息质变
  7. 模板代码膨胀和编译时间代价

学习优先级（应届生）：概念性理解 > 能读懂标准库 > 能写简单的 type trait 和 CRTP > 能在面试时讲清楚 SFINAE 演进。不要强行去学 Expression Templates、Boost.MPL/Hana 这些，ROI 低。

17. 关键信息来源

置信度说明：

分享这篇文章：
分享到 Whatsapp 分享到 Facebook 分享到 X 分享到 Telegram 分享到 Pinterest 通过邮件分享这篇文章
上一篇
现代 C++(五)：内存模型、atomic、thread 与 future
下一篇
Go 基础：正则表达式、自动机与 regexp 的线性时间保证