模板实战模式
本章是泛型编程卷的收官之作。我们将前六章学到的模板技术——函数模板、类模板、Concepts、可变参数模板、编译期编程——综合运用到工程中常见的设计模式和实战场景中。掌握这些模式后,你将具备阅读和编写生产级模板代码的能力。
1. CRTP(奇异递归模板模式)
CRTP 的核心思想:派生类将自身作为模板参数传递给基类。这样基类可以在编译期"知道"派生类的完整类型,实现静态多态——无虚函数开销。
// CRTP 基本结构
template<typename Derived>
class Base {
public:
void interface() {
// 基类调用派生类的实现——编译期绑定,零开销
static_cast<Derived*>(this)->implementation();
}
};
class Concrete : public Base<Concrete> {
public:
void implementation() {
std::println("Concrete 的实现");
}
};
实例:Comparable Mixin——自动生成比较运算符
只需派生类实现一个 compare_to 方法,基类自动生成全部六个比较运算符:
#include <print>
#include <compare>
// CRTP Mixin:自动生成所有比较运算符
template<typename Derived>
struct Comparable {
// 派生类只需实现 compare_to(const Derived&) -> std::strong_ordering
friend bool operator==(const Derived& a, const Derived& b) {
return a.compare_to(b) == std::strong_ordering::equal;
}
friend bool operator!=(const Derived& a, const Derived& b) {
return !(a == b);
}
friend bool operator<(const Derived& a, const Derived& b) {
return a.compare_to(b) == std::strong_ordering::less;
}
friend bool operator>(const Derived& a, const Derived& b) {
return b < a;
}
friend bool operator<=(const Derived& a, const Derived& b) {
return !(b < a);
}
friend bool operator>=(const Derived& a, const Derived& b) {
return !(a < b);
}
};
// 使用:只需实现 compare_to
struct Temperature : Comparable<Temperature> {
double celsius;
explicit Temperature(double c) : celsius{c} {}
std::strong_ordering compare_to(const Temperature& other) const {
if (celsius < other.celsius) return std::strong_ordering::less;
if (celsius > other.celsius) return std::strong_ordering::greater;
return std::strong_ordering::equal;
}
};
int main() {
Temperature boiling{100.0};
Temperature freezing{0.0};
std::println("{}", boiling > freezing); // true
std::println("{}", freezing < boiling); // true
std::println("{}", boiling == boiling); // true
}
CRTP 的典型用途:(1)Mixin 功能注入(如上面的比较运算符);(2)静态接口检查;(3)引用计数基类;(4)enable_shared_from_this 就是标准库中的 CRTP 实例。
C++23 Deducing this:CRTP 的现代替代
C++23 引入了 this 参数推导(deducing this),可以在某些场景下替代 CRTP,语法更直观:
// C++23: 不再需要模板参数传递派生类
struct ComparableBase {
// this 参数自动推导为实际派生类型
template<typename Self>
bool less_than(this const Self& self, const Self& other) {
return self.value() < other.value();
}
};
struct Score : ComparableBase {
int points;
int value() const { return points; }
};
// Score 对象可以直接调用 less_than,无需 CRTP 继承模板
注意:Deducing this 尚未在所有编译器中完全实现(截至 2025 年底)。在生产代码中,如果你的工具链支持 C++23 且编译器已实现该特性,优先使用 deducing this;否则 CRTP 仍是可靠的选择。
2. Policy-Based Design(基于策略的设计)
策略模式的核心思想:通过模板参数注入算法的可变部分。每个策略是一个独立的类型(通常是只含静态函数的空结构体),组合不同策略产生不同行为——全部在编译期决定,零运行时开销。
#include <algorithm>
#include <vector>
#include <print>
#include <string>
// ===== 排序策略 =====
struct AscendingSort {
template<typename Iter>
static void sort(Iter begin, Iter end) {
std::ranges::sort(begin, end);
}
};
struct DescendingSort {
template<typename Iter>
static void sort(Iter begin, Iter end) {
std::ranges::sort(begin, end, std::greater{});
}
};
// ===== 日志策略 =====
struct ConsoleLog {
static void log(std::string_view msg) {
std::println("[LOG] {}", msg);
}
};
struct NullLog {
static void log(std::string_view) {
// 什么都不做——编译器会完全优化掉
}
};
// ===== 主类:通过模板参数组合策略 =====
template<typename SortPolicy, typename LogPolicy>
class DataProcessor {
std::vector<int> data_;
public:
void add(int value) {
data_.push_back(value);
LogPolicy::log("添加元素");
}
void process() {
LogPolicy::log("开始排序...");
SortPolicy::sort(data_.begin(), data_.end());
LogPolicy::log("排序完成");
}
void print() const {
for (int v : data_) std::print("{} ", v);
std::println("");
}
};
int main() {
// 组合1:降序 + 控制台日志
DataProcessor<DescendingSort, ConsoleLog> verbose;
verbose.add(3);
verbose.add(1);
verbose.add(4);
verbose.process(); // 会打印日志
verbose.print(); // 4 3 1
// 组合2:升序 + 无日志(零开销)
DataProcessor<AscendingSort, NullLog> fast;
fast.add(3);
fast.add(1);
fast.add(4);
fast.process(); // 无任何日志开销
fast.print(); // 1 3 4
}
与运行时策略模式的对比
// 运行时策略:使用虚函数,有 vtable 开销
struct ISortStrategy {
virtual void sort(std::vector<int>& data) = 0;
virtual ~ISortStrategy() = default;
};
// 编译期策略(Policy-Based Design):
// - 零虚函数开销
// - 编译器可内联策略函数
// - 不同策略组合生成不同类型(不能混用)
// - 缺点:不能在运行时切换策略
选择指南:如果策略在编译期就能确定(大多数情况),用 Policy-Based Design 获得零开销;如果确实需要运行时动态切换策略(如用户配置文件决定行为),才使用虚函数。
3. Tag Dispatch(传统)vs Concepts(现代)
Tag Dispatch 是 C++98 时代的编译期分发技术,通过空结构体标签选择函数重载。C++20 Concepts 可以更优雅地完成同样的工作。下面用同一个算法展示两种实现方式。
需求:对迭代器 advance n 步
// ============ 传统方式:Tag Dispatch ============
#include <iterator>
namespace old_style {
// 不同迭代器类别的实现
template<typename Iter>
void advance_impl(Iter& it, int n, std::input_iterator_tag) {
// 只能向前逐个移动
for (int i = 0; i < n; ++i) ++it;
}
template<typename Iter>
void advance_impl(Iter& it, int n, std::random_access_iterator_tag) {
// 可以直接跳转
it += n;
}
// 对外接口:通过 iterator_category 标签选择实现
template<typename Iter>
void advance(Iter& it, int n) {
advance_impl(it, n,
typename std::iterator_traits<Iter>::iterator_category{});
}
} // namespace old_style
// ============ 现代方式:Concepts 约束 ============
#include <iterator>
#include <concepts>
namespace modern {
// 直接用 Concept 约束——清晰、无标签、无间接层
template<std::input_iterator Iter>
void advance(Iter& it, int n) {
for (int i = 0; i < n; ++i) ++it;
}
// 更受约束的重载自动优先匹配
template<std::random_access_iterator Iter>
void advance(Iter& it, int n) {
it += n;
}
} // namespace modern
新代码优先使用 Concepts。Tag Dispatch 仍会在遗留代码和某些标准库实现中出现,了解即可。Concepts 的优势:(1) 无需额外标签类型;(2) 重载决议基于约束子集关系,更自然;(3) 错误信息更清晰。
4. Type Traits 与 SFINAE(了解)
Type Traits 是编译期类型查询工具,SFINAE 是 C++11/14/17 时代约束模板的"黑魔法"。你不需要精通 SFINAE 来编写新代码,但需要能读懂它——大量现存库代码使用了这些技术。
常用 Type Traits
#include <type_traits>
#include <print>
template<typename T>
void inspect() {
std::println("is_integral: {}", std::is_integral_v<T>);
std::println("is_floating_point: {}", std::is_floating_point_v<T>);
std::println("is_same<T, int>: {}", std::is_same_v<T, int>);
std::println("is_const: {}", std::is_const_v<T>);
std::println("is_reference: {}", std::is_reference_v<T>);
}
int main() {
inspect<int>();
// is_integral: true, is_floating_point: false, is_same: true, ...
inspect<const double&>();
// is_integral: false, is_floating_point: false, is_const: false (引用本身不是 const)
}
SFINAE:enable_if 的丑陋真相
// ===== SFINAE 方式(C++11/14/17 遗留写法)=====
#include <type_traits>
// 只有当 T 是整数类型时,这个重载才存在
template<typename T>
std::enable_if_t<std::is_integral_v<T>, T>
safe_divide(T a, T b) {
if (b == 0) return 0; // 整数除零保护
return a / b;
}
// 只有当 T 是浮点类型时,这个重载才存在
template<typename T>
std::enable_if_t<std::is_floating_point_v<T>, T>
safe_divide(T a, T b) {
return a / b; // 浮点除零得到 inf,不需要特殊处理
}
// ===== 同样的功能,Concepts 写法(C++20)=====
#include <concepts>
template<std::integral T>
T safe_divide(T a, T b) {
if (b == 0) return 0;
return a / b;
}
template<std::floating_point T>
T safe_divide(T a, T b) {
return a / b;
}
SFINAE 的问题:(1)语法晦涩,可读性极差;(2)编译错误信息是"候选函数不可行"的长串废话,无法指出真正原因;(3)容易写错导致难以调试的 bug。新代码一律使用 Concepts,只在阅读遗留代码时需要理解 SFINAE。
5. 模板与编译
模板代码的编译模型与普通代码不同,理解这些差异对大型项目的构建时间和组织结构至关重要。
为什么模板必须放在头文件中?
// === math.hpp ===
template<typename T>
T square(T x) {
return x * x;
}
// 模板的完整定义必须对使用它的每个翻译单元可见
// 因为编译器需要在实例化点生成具体代码
// === 错误做法 ===
// math.hpp: 只声明
// template<typename T> T square(T x);
//
// math.cpp: 定义
// template<typename T> T square(T x) { return x * x; }
//
// main.cpp: #include "math.hpp"
// square(42); // 链接错误!编译 main.cpp 时看不到模板体
显式实例化(Explicit Instantiation)
// === math.hpp ===
template<typename T>
T square(T x); // 只有声明
// === math.cpp ===
template<typename T>
T square(T x) { return x * x; }
// 显式实例化:告诉编译器"在此处生成这些版本"
template int square<int>(int);
template double square<double>(double);
// 只有 int 和 double 版本可用,其他类型会链接错误
// 用途:
// 1. 减少编译时间(模板体不暴露给所有 TU)
// 2. 控制哪些实例化被允许
// 3. 减小二进制体积
extern template——抑制隐式实例化
// === common.hpp ===
template<typename T>
class HeavyTemplate {
// ... 大量代码 ...
void method1();
void method2();
void method3();
};
// 告诉编译器:"不要在这个 TU 中实例化这些版本,它们在别处"
extern template class HeavyTemplate<int>;
extern template class HeavyTemplate<std::string>;
// === heavy_template.cpp ===
#include "common.hpp"
// 在这个文件中集中实例化
template class HeavyTemplate<int>;
template class HeavyTemplate<std::string>;
// 效果:其他 .cpp 文件 include common.hpp 时不会重复实例化
// 大型项目中可显著减少编译时间
编译时间实践建议:(1)小模板直接放头文件,保持简单;(2)大型模板类(如容器实现)如果只用少数类型,考虑 extern template;(3)使用前向声明减少头文件依赖;(4)C++20 Modules 从根本上解决了头文件包含问题(见卷六)。
6. 变量模板(Variable Templates)
C++14 引入变量模板,允许模板化一个常量值。最常见的用途是为 type traits 提供简洁的 _v 后缀版本。
#include <numbers>
#include <print>
// 变量模板:不同精度的 pi
template<typename T>
constexpr T pi = T(3.14159265358979323846L);
// 使用
double circle_area(double r) {
return pi<double> * r * r; // 双精度 pi
}
float fast_area(float r) {
return pi<float> * r * r; // 单精度 pi
}
// 注:C++20 标准库已提供 std::numbers::pi_v<T>
// 上面只是演示变量模板语法
用变量模板简化 Type Traits
// 标准库中的模式:
// std::is_integral<T>::value → std::is_integral_v<T>
// 自定义 type trait + 变量模板
template<typename T>
struct is_number : std::bool_constant<
std::is_integral_v<T> || std::is_floating_point_v<T>
> {};
// 变量模板版本——使用更方便
template<typename T>
constexpr bool is_number_v = is_number<T>::value;
// 配合 Concept 使用
template<typename T>
concept Number = is_number_v<T>;
// 现在可以这样约束
template<Number T>
T add(T a, T b) { return a + b; }
int main() {
std::println("{}", is_number_v<int>); // true
std::println("{}", is_number_v<double>); // true
std::println("{}", is_number_v<std::string>); // false
add(1, 2); // OK
add(1.5, 2.5); // OK
// add("a", "b"); // 编译错误:std::string 不满足 Number
}
7. 综合实例:类型安全单位库
最后,我们综合运用 CRTP、Concepts、constexpr 和变量模板,构建一个编译期类型安全的物理单位库。核心目标:让"米 + 秒"这样的无意义运算在编译期就被拒绝。
#include <print>
#include <concepts>
// ===== 单位标签 =====
struct Meters {};
struct Seconds {};
struct MetersPerSecond {};
// ===== Concept:约束合法单位类型 =====
template<typename T>
concept UnitTag = std::same_as<T, Meters>
|| std::same_as<T, Seconds>
|| std::same_as<T, MetersPerSecond>;
// ===== 核心类模板 =====
template<UnitTag Unit>
class Quantity {
double value_;
public:
constexpr explicit Quantity(double v) : value_{v} {}
constexpr double value() const { return value_; }
// 同单位加法
constexpr Quantity operator+(Quantity other) const {
return Quantity{value_ + other.value_};
}
// 同单位减法
constexpr Quantity operator-(Quantity other) const {
return Quantity{value_ - other.value_};
}
// 标量乘法
constexpr Quantity operator*(double scalar) const {
return Quantity{value_ * scalar};
}
// 比较
constexpr auto operator<=>(const Quantity&) const = default;
};
// ===== 类型别名,方便使用 =====
using Distance = Quantity<Meters>;
using Duration = Quantity<Seconds>;
using Speed = Quantity<MetersPerSecond>;
// ===== 单位运算:距离 / 时间 = 速度 =====
constexpr Speed operator/(Distance d, Duration t) {
return Speed{d.value() / t.value()};
}
// ===== 用户自定义字面量 =====
constexpr Distance operator""_m(long double v) {
return Distance{static_cast<double>(v)};
}
constexpr Duration operator""_s(long double v) {
return Duration{static_cast<double>(v)};
}
int main() {
constexpr auto marathon = Distance{42195.0};
constexpr auto time = Duration{7200.0}; // 2小时
constexpr auto speed = marathon / time;
std::println("马拉松配速: {} m/s", speed.value()); // ≈ 5.86 m/s
// 同单位运算 OK
constexpr auto total = Distance{100.0} + Distance{200.0};
std::println("总距离: {} m", total.value()); // 300 m
// 字面量语法
constexpr auto d = 9.8_m;
constexpr auto t = 1.0_s;
std::println("速度: {} m/s", (d / t).value());
// ===== 以下代码将产生编译错误 =====
// auto nonsense = Distance{100.0} + Duration{5.0};
// 错误信息示例:
// no match for 'operator+' (operand types are
// 'Quantity<Meters>' and 'Quantity<Seconds>')
//
// 不同单位的值是完全不同的类型,无法相加!
}
这个设计的关键点:
Quantity<Meters>和Quantity<Seconds>是不同类型,编译器天然阻止混合运算constexpr使所有运算可在编译期完成,运行时零开销UnitTagConcept 确保只有合法的单位标签能实例化 Quantity- 用户自定义字面量提供了直观的语法 (
9.8_m) - 错误在编译期即被捕获,不会产生运行时 bug
扩展思路
// 更完整的单位库会使用维度分析(dimensional analysis)
// 用编译期整数表示每个基本量的指数:
template<int LengthDim, int TimeDim, int MassDim>
struct Dimension {};
// 米 = Dimension<1, 0, 0>
// 秒 = Dimension<0, 1, 0>
// 速度 = Dimension<1, -1, 0> (m/s = m * s^-1)
// 加速度 = Dimension<1, -2, 0> (m/s^2)
// 力 = Dimension<1, -2, 1> (kg * m / s^2)
// 这就是 Boost.Units 和 mp-units 库的核心思想
// 生产环境推荐使用 mp-units(C++23 标准库候选)
生产建议:实际项目中不要自己实现单位库。推荐使用 mp-units(已进入 C++26 标准化流程),它提供了完整的维度分析、单位转换和零开销抽象。上面的代码仅用于教学——展示多种模板技术如何协同工作。
本章小结
- CRTP:派生类作为基类模板参数,实现编译期多态和 Mixin 功能注入;C++23 deducing this 可替代部分用法
- Policy-Based Design:通过模板参数组合行为策略,零运行时开销,比虚函数策略模式更高效
- Tag Dispatch → Concepts:新代码用 Concepts 直接约束,老代码可能用 tag dispatch
- SFINAE / enable_if:历史遗留的约束技术,只需能读懂,新代码不要使用
- 模板编译模型:定义必须在头文件中可见;extern template 减少重复实例化
- 变量模板:模板化常量值,广泛用于 type traits 的
_v版本 - 综合运用:CRTP + Concepts + constexpr + 变量模板 = 类型安全、零开销的领域库