目录：
- 函数模板与参数推导
- 类模板与偏特化
- 类型萃取与自定义检测
- SFINAE 原理与
std::enable_if - CRTP：静态多态
- 表达式 SFINAE 与检测惯用法
- 综合实战示例
C++ 模板不仅是泛型编程的基础，更是元编程的入口。从简单的函数模板到复杂的 SFINAE 技巧，模板系统让类型本身成为可计算的对象。本文将系统梳理函数模板、类模板、类型萃取、SFINAE、CRTP 等核心概念，并给出可直接编译运行的代码示例。
一、函数模板与参数推导
1.1 基本推导与显式特化
编译器在遇到函数模板调用时，会根据实参推导模板参数类型。最常见的形式如下：
template <typename T>
T max_value(T a, T b) {
return (a > b) ? a : b;
}
// 推导：T = int
auto result = max_value(3, 5);
如果需要为特定类型提供完全不同的实现，可使用显式特化：
template <>
const char* max_value<const char*>(const char* a, const char* b) {
return (std::strcmp(a, b) > 0) ? a : b;
}
1.2 非类型模板参数
模板参数不限于类型，也可以是整型、枚举、指针等编译期常量。C++17 引入的自动推导让语法更简洁：
template <int N>
struct Factorial {
static constexpr int value = N * Factorial<N - 1>::value;
};
template <>
struct Factorial<0> {
static constexpr int value = 1;
};
// C++17 允许使用 auto 推导非类型参数
template <auto N>
struct IntegralWrapper {
static constexpr decltype(N) value = N;
};
static_assert(IntegralWrapper<42>::value == 42);
1.3 变参模板与参数包展开
变参模板接受任意数量的参数，使用递归或折叠表达式展开：
template <typename T>
constexpr T sum(T v) { return v; }
template <typename T, typename... Rest>
constexpr T sum(T first, Rest... rest) {
return first + sum(rest...);
}
// C++17 折叠表达式更简洁
template <typename... Args>
constexpr auto fold_sum(Args... args) {
return (args + ...);
}
注意：参数包 Args... 在展开时，位置和括号优先级直接决定了语义，这在构造 tuple 或实现 printf 风格函数时尤为关键。
二、类模板与偏特化
2.1 偏特化与全特化
全特化为所有模板参数提供具体类型，偏特化只固定部分参数或添加额外约束：
template <typename T, typename U>
struct Pair {
static constexpr bool is_same = false;
};
// 全特化
template <>
struct Pair<int, int> {
static constexpr bool is_same = true;
};
// 偏特化：两个类型相同时
template <typename T>
struct Pair<T, T> {
static constexpr bool is_same = true;
};
非类型模板参数同样支持偏特化：
template <typename T, size_t N>
struct ArrayTraits {
static constexpr bool is_small = false;
};
template <typename T>
struct ArrayTraits<T, 0> {
static constexpr bool is_small = true;
};
2.2 模板模板参数
当需要传入一个模板而非具体类型时，使用模板模板参数：
template <typename T, template <typename> class Container>
struct Adapter {
Container<T> data;
};
Adapter<int, std::vector> vec_adapter;
C++17 起可配合 template <typename...> class 接受参数数量不固定的模板，例如适配 std::map。
三、类型萃取与自定义检测
3.1 标准库类型萃取
<type_traits> 头文件提供大量编译期类型查询工具：
static_assert(std::is_integral_v<int>);
static_assert(std::is_pointer_v<int*>);
static_assert(std::is_same_v<std::remove_reference_t<int&>, int>);
std::remove_reference_t<int&> 通过偏特化机制剥离引用。其典型实现如下：
template <typename T> struct remove_reference { using type = T; };
template <typename T> struct remove_reference<T&> { using type = T; };
template <typename T> struct remove_reference<T&&> { using type = T; };
3.2 自定义类型萃取
利用偏特化和 SFINAE，可以判断类型是否具有特定成员：
template <typename T, typename = void>
struct has_foo : std::false_type {};
template <typename T>
struct has_foo<T, std::void_t<decltype(std::declval<T>().foo())>> : std::true_type {};
type_identity 是一个看似简单的工具，但常用于阻止模板参数推导：
template <typename T>
struct type_identity { using type = T; };
template <typename T>
void foo(typename type_identity<T>::type arg); // T 不会被推导
此技巧在重载解析中人为制造非推导上下文，强制调用方显式指定模板参数。
四、SFINAE 原理与 std::enable_if
4.1 SFINAE 的工作方式
Substitution Failure Is Not An Error，翻译过来就是"替换失败不是错误"。当编译器尝试用实参推导模板参数时，如果替换导致不合法的 C++ 代码，不会直接报错，而是将该候选函数从重载集合中移除。
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T> check(T t) {
return t;
}
template <typename T>
std::enable_if_t<std::is_floating_point_v<T>, T> check(T t) {
return t * 2;
}
check(1); // 匹配第一个
check(1.0); // 匹配第二个
// check("hello"); // 无匹配候选，编译错误
4.2 std::enable_if 的条件重载
通过将 std::enable_if 作为默认模板参数或函数返回类型，可以控制重载集合的成员资格：
template <typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
T compute(T a, T b) {
return a + b;
}
把 std::enable_if_t<..., int> 作为默认模板参数的一个好处是：它只影响模板签名，不占用参数位置，也不改变函数返回值。
4.3 SFINAE 与 Concepts
C++20 Concepts 让约束变得更清晰、错误信息更友好：
template <typename T>
concept Arithmetic = std::is_arithmetic_v<T>;
template <Arithmetic T>
T add(T a, T b) { return a + b; }
在 C++20 环境下，优先使用 Concepts；维护旧代码库时，SFINAE 依然是兼容 C++11/14/17 的唯一选择。两者的核心差异在于：Concepts 是语言级的显式约束，而 SFINAE 是一种"副作用"式的条件过滤。
五、CRTP：静态多态
5.1 基本模式
CRTP 让派生类作为基类模板的参数，基类通过 static_cast 调用派生类成员：
template <typename Derived>
struct Base {
void interface() {
static_cast<Derived*>(this)->implementation();
}
};
struct Derived : Base<Derived> {
void implementation() {
std::cout << "Derived impl\n";
}
};
由于没有虚函数表，调用是静态内联的，.zero-cost abstraction 在这里得到完美体现。
5.2 CRTP 与混入模式
CRTP 的另一大用途是实现可复用的混入组件：
template <typename Derived>
struct Comparable {
friend bool operator!=(const Derived& lhs, const Derived& rhs) {
return !(lhs == rhs);
}
};
struct Point : Comparable<Point> {
int x, y;
friend bool operator==(const Point&, const Point&) = default;
};
5.3 与虚继承的对比
| 特性 | CRTP | 虚函数 |
|---|---|---|
| 运行时开销 | 无 | 虚表指针 + 间接调用 |
| 代码膨胀 | 每实例化一次生成一份代码 | 代码共享 |
| 运行时多态 | 不支持 | 支持 |
| 示例库 | Eigen, range-v3 | 大多数面向对象框架 |
Eigen 的矩阵表达式模板大量依赖 CRTP，使得 matrix1 + matrix2 * scalar 能在编译期展开为单一循环，避免临时对象分配。range-v3 的视图适配器同样用 CRTP 实现链式管道操作的零额外开销。
六、表达式 SFINAE 与检测惯用法
6.1 void_t 检测惯用法
C++17 引入 std::void_t，使检测表达式合法性变得异常优雅：
template <typename T, typename = void>
struct has_bar : std::false_type {};
template <typename T>
struct has_bar<T, std::void_t<decltype(std::declval<T>().bar(1))>> : std::true_type {};
当 T.bar(1) 合法时，decltype(...) 推导成功，std::void_t<...> 被替换为 void，与偏特化签名匹配；否则偏特化被 SFINAE 丢弃。
6.2 检测表达式的实际应用
结合 std::declval 可以在不构造对象的情况下检测任意表达式的有效性：
template <typename T, typename U, typename = void>
struct can_add : std::false_type {};
template <typename T, typename U>
struct can_add<T, U, std::void_t<decltype(std::declval<T>() + std::declval<U>())>> : std::true_type {};
C++20 requires 表达式底层也依赖类似机制，但语法层面更直观。
七、综合实战示例
7.1 类型安全的容器包装器
以下实现一个仅允许存储算术类型的轻量级包装器，利用 SFINAE 做静态断言：
template <typename T, typename = std::enable_if_t<std::is_arithmetic_v<T>>>
class NumericBox {
T value_;
public:
explicit NumericBox(T v) : value_(v) {}
T get() const { return value_; }
template <typename U = T>
auto add(U other) const -> std::enable_if_t<std::is_convertible_v<U, T>, T> {
return value_ + static_cast<T>(other);
}
};
NumericBox<int> box(10);
// NumericBox<std::string> sbox("x"); // 编译失败
7.2 兼容任意具备 begin/end 容器的函数
使用 void_t 检测成员函数合法性，如果失败则回退到 std::begin/std::end：
template <typename C>
auto container_sum(const C& c) -> decltype(*std::begin(c) + *std::begin(c), typename C::value_type{}) {
using value_t = typename C::value_type;
value_t total{};
for (const auto& elem : c) {
total += elem;
}
return total;
}
更稳健的写法是利用 std::iterator_traits：
template <typename C>
auto container_sum(const C& c) -> typename std::iterator_traits<decltype(std::begin(c))>::value_type {
using value_t = typename std::iterator_traits<decltype(std::begin(c))>::value_type;
value_t total{};
for (const auto& e : c) total += e;
return total;
}
7.3 SFINAE 条件重载实战
实现一个 dump 函数，对基本类型直接打印，对容器遍历打印，对类类型打印成员数量信息：
template <typename T>
std::enable_if_t<std::is_arithmetic_v<T>> dump(const T& v) {
std::cout << "value: " << v << "\n";
}
template <typename C>
std::enable_if_t<!std::is_arithmetic_v<C> && !std::is_class_v<C>>
dump(const C& c) {
std::cout << "iterable: ";
for (const auto& e : c) std::cout << e << " ";
std::cout << "\n";
}
struct MyStruct { int a; double b; };
template <typename T>
std::enable_if_t<std::is_class_v<T>> dump(const T&) {
std::cout << "class object (sizeof=" << sizeof(T) << ")\n";
}
写在最后
从简单的 template <typename T> 到复杂的表达式 SFINAE，C++ 模板系统提供了编译期计算的强大能力。但这股力量也伴随着冗长的错误信息和陡峭的学习曲线。学习模板编程时，建议逐层递进：先熟悉函数模板和类模板，再通过 type_traits 建立类型层面的直觉，最后进入 SFINAE 和 CRTP 等高级模式。对于新项目，应积极拥抱 C++20 Concepts，让意图表达得更清晰，编译器报错更友好。
掌握模板不仅是为了写出更抽象的代码，更是为了理解 STL、Boost、Eigen、range-v3 等现代 C++ 基础设施的设计哲学。泛型不是目的，零开销的抽象才是。
继续阅读
探索更多技术文章
浏览归档，发现更多关于系统设计、工具链和工程实践的内容。