模板实战模式

本章是泛型编程卷的收官之作。我们将前六章学到的模板技术——函数模板、类模板、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 使所有运算可在编译期完成,运行时零开销
  • UnitTag Concept 确保只有合法的单位标签能实例化 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 + 变量模板 = 类型安全、零开销的领域库