Effective C++ 条款48：认识 template 元编程

Effective C++ 条款48：认识 template 元编程

模板元编程（TMP，template metaprogramming）可将工作由运行期移往编译期，因此得以实现早期错误侦测和更高的执行效率；TMP 可被用来生成"基于政策选择组合"（based on combinations of policy choices）的客户定制代码，也可用来避免生成对某些特殊类型并不适合的代码。

一、什么是模板元编程（TMP）？

模板元编程（Template Metaprogramming，TMP）是一种利用 C++ 模板在编译期执行计算和代码生成的编程范式。它本质上是**“编写程序的程序”**——通过模板实例化机制让编译器在编译阶段完成数值计算、类型操作甚至代码生成。

1.1 TMP 的起源

TMP 的发现颇具戏剧性：

1994 年，Erwin Unruh 在 C++ 标准委员会会议上展示了一段利用模板编译错误来计算素数的代码。这段代码虽然无法通过编译，但编译器输出的错误信息中却包含了素数序列！这意外揭示了 C++ 模板系统的图灵完备性。

从那以后，TMP 逐渐发展成为 C++ 泛型编程的重要技术。

1.2 TMP 的核心特征

二、TMP 入门：编译期计算阶乘

让我们从经典的"Hello World"级 TMP 程序开始——编译期计算阶乘。

2.1 运行期版本

// 运行期计算
unsigned long long factorial(unsigned n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

// 使用
auto result = factorial(5);  // 120，运行期计算

2.2 TMP 版本

// 主模板：递归定义 N! = N * (N-1)!
template<unsigned N>
struct Factorial {
    static constexpr unsigned long long value = N * Factorial<N - 1>::value;
};

// 全特化：终止条件 0! = 1
template<>
struct Factorial<0> {
    static constexpr unsigned long long value = 1;
};

// 使用
constexpr auto fact5 = Factorial<5>::value;  // 120，编译期计算

2.3 工作原理图解

Factorial<5>::value
    = 5 * Factorial<4>::value
    = 5 * (4 * Factorial<3>::value)
    = 5 * (4 * (3 * Factorial<2>::value))
    = 5 * (4 * (3 * (2 * Factorial<1>::value)))
    = 5 * (4 * (3 * (2 * (1 * Factorial<0>::value))))
    = 5 * (4 * (3 * (2 * (1 * 1))))
    = 120

编译器在编译期递归实例化这些模板，最终 Factorial<5>::value 直接被替换为常量 120，运行期没有任何计算开销！

三、TMP 的核心技术

3.1 模板特化与模式匹配

模板特化是 TMP 的基础，允许为特定参数提供专门实现：

// 主模板：默认非指针类型
template<typename T>
struct IsPointer {
    static constexpr bool value = false;
};

// 偏特化：匹配指针类型
template<typename T>
struct IsPointer<T*> {
    static constexpr bool value = true;
};

// 使用
static_assert(IsPointer<int*>::value == true);
static_assert(IsPointer<int>::value == false);

3.2 类型操作与萃取

// 移除 const 修饰
template<typename T>
struct RemoveConst {
    using type = T;
};

template<typename T>
struct RemoveConst<const T> {
    using type = T;
};

// 使用
using NonConstInt = RemoveConst<const int>::type;  // int
static_assert(std::is_same_v<NonConstInt, int>);

3.3 编译期条件分支

方式一：模板特化（C++98/03）

template<bool Condition, typename TrueType, typename FalseType>
struct If;

template<typename TrueType, typename FalseType>
struct If<true, TrueType, FalseType> {
    using type = TrueType;
};

template<typename TrueType, typename FalseType>
struct If<false, TrueType, FalseType> {
    using type = FalseType;
};

// 使用：根据类型大小选择不同的实现
using SelectedType = If<sizeof(int) >= 4, int, long>::type;

方式二：if constexpr（C++17）

template<typename T>
auto process(T val) {
    if constexpr (std::is_pointer_v<T>) {
        return *val;  // 只有 T 是指针时才会编译此行
    } else {
        return val;
    }
}

四、TMP 的三大应用场景

4.1 场景一：将工作移至编译期，提升运行效率

TMP 最直观的优势就是零运行时开销。所有计算在编译期完成，运行期直接获得结果。

// 编译期计算斐波那契数列
template<unsigned N>
struct Fibonacci {
    static constexpr unsigned long long value = 
        Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};

template<>
struct Fibonacci<0> {
    static constexpr unsigned long long value = 0;
};

template<>
struct Fibonacci<1> {
    static constexpr unsigned long long value = 1;
};

// 编译期直接使用
constexpr auto fib20 = Fibonacci<20>::value;  // 6765

4.2 场景二：基于政策选择组合生成定制代码

这是 TMP 最强大的应用之一。通过组合不同的"政策"（policy），生成高度定制化的代码。

// 排序政策
template<typename T>
struct QuickSortPolicy {
    static void sort(T* data, size_t n) {
        // 快速排序实现
        std::sort(data, data + n);
    }
};

template<typename T>
struct BubbleSortPolicy {
    static void sort(T* data, size_t n) {
        // 冒泡排序实现（适合小数据量）
        for (size_t i = 0; i < n; ++i)
            for (size_t j = 0; j < n - i - 1; ++j)
                if (data[j] > data[j + 1])
                    std::swap(data[j], data[j + 1]);
    }
};

// 存储政策
template<typename T>
struct ArrayStorage {
    T data[100];
    static constexpr size_t capacity = 100;
};

template<typename T>
struct HeapStorage {
    T* data;
    size_t capacity;
    HeapStorage() : data(new T[1000]), capacity(1000) {}
    ~HeapStorage() { delete[] data; }
};

// 组合政策生成定制容器
template<typename T, 
         template<typename> class SortPolicy = QuickSortPolicy,
         template<typename> class StoragePolicy = ArrayStorage>
class CustomContainer : public StoragePolicy<T> {
public:
    void sort(size_t n) {
        SortPolicy<T>::sort(this->data, n);
    }
};

// 使用不同的政策组合
CustomContainer<int, QuickSortPolicy, ArrayStorage> smallFast;
CustomContainer<int, BubbleSortPolicy, HeapStorage> largeSimple;

4.3 场景三：避免生成对特殊类型不适合的代码

// 通用拷贝函数
template<typename T>
void safeCopy(T* dest, const T* src, size_t n) {
    if constexpr (std::is_trivially_copyable_v<T>) {
        // 对于 POD 类型，使用高效的 memcpy
        std::memcpy(dest, src, n * sizeof(T));
    } else {
        // 对于非 POD 类型，逐个调用拷贝构造函数
        for (size_t i = 0; i < n; ++i) {
            new (&dest[i]) T(src[i]);
        }
    }
}

// 测试
struct PodType {
    int x, y, z;
};

struct NonPodType {
    std::string name;
    NonPodType(const std::string& n) : name(n) {}
};

int main() {
    PodType podSrc[10], podDst[10];
    safeCopy(podDst, podSrc, 10);  // 编译为 memcpy
    
    NonPodType nonPodSrc[10] = { /* ... */ };
    NonPodType nonPodDst[10];
    safeCopy(nonPodDst, nonPodSrc, 10);  // 编译为逐个拷贝
}

五、TMP 高级技巧

5.1 表达式模板（Expression Templates）

表达式模板是 TMP 的经典应用，用于消除矩阵运算中的临时对象。

template<typename Lhs, typename Rhs>
class MatrixSum {
    const Lhs& lhs_;
    const Rhs& rhs_;
public:
    MatrixSum(const Lhs& lhs, const Rhs& rhs) : lhs_(lhs), rhs_(rhs) {}
    
    double operator()(size_t i, size_t j) const {
        return lhs_(i, j) + rhs_(i, j);
    }
};

template<typename Lhs, typename Rhs>
MatrixSum<Lhs, Rhs> operator+(const Lhs& lhs, const Rhs& rhs) {
    return MatrixSum<Lhs, Rhs>(lhs, rhs);
}

// 使用：A + B + C 不会创建临时矩阵！
// 而是构建一个表达式树，延迟求值
auto expr = A + B + C;
double val = expr(0, 0);  // 在访问时才计算 A(0,0) + B(0,0) + C(0,0)

5.2 CRTP：奇异递归模板模式

template<typename Derived>
class Shape {
public:
    void draw() const {
        static_cast<const Derived*>(this)->drawImpl();
    }
    
    double area() const {
        return static_cast<const Derived*>(this)->areaImpl();
    }
};

class Circle : public Shape<Circle> {
    double radius_;
public:
    Circle(double r) : radius_(r) {}
    void drawImpl() const { std::cout << "Drawing Circle\n"; }
    double areaImpl() const { return 3.14159 * radius_ * radius_; }
};

class Square : public Shape<Square> {
    double side_;
public:
    Square(double s) : side_(s) {}
    void drawImpl() const { std::cout << "Drawing Square\n"; }
    double areaImpl() const { return side_ * side_; }
};

// 使用：零开销多态，无需虚函数表
template<typename T>
void render(const Shape<T>& shape) {
    shape.draw();
    std::cout << "Area: " << shape.area() << "\n";
}

5.3 编译期循环展开

template<int N>
struct Unroll {
    template<typename Func>
    static void apply(Func f) {
        f(N - 1);
        Unroll<N - 1>::apply(f);
    }
};

template<>
struct Unroll<0> {
    template<typename Func>
    static void apply(Func) {}
};

// 使用：编译期展开循环
int data[5] = {1, 2, 3, 4, 5};
Unroll<5>::apply([&](int i) {
    std::cout << data[i] << " ";
});
// 编译后等价于：
// std::cout << data[4] << " ";
// std::cout << data[3] << " ";
// std::cout << data[2] << " ";
// std::cout << data[1] << " ";
// std::cout << data[0] << " ";

六、TMP 的优缺点

6.1 优点

6.2 缺点与挑战

七、现代 C++ 对 TMP 的增强

7.1 constexpr 函数（C++11/14/17）

// C++11: 受限的 constexpr
constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);  // C++11 只允许一个 return
}

// C++14: 更灵活的 constexpr
constexpr int factorial_cpp14(int n) {
    int result = 1;
    for (int i = 2; i <= n; ++i)
        result *= i;
    return result;
}

// C++17: constexpr if
constexpr int abs(int x) {
    if constexpr (sizeof(int) == 4) {
        return x < 0 ? -x : x;
    }
    return x;
}

7.2 变量模板（C++14）

// 简化 traits 使用
template<typename T>
constexpr bool is_pointer_v = std::is_pointer<T>::value;

// 不再需要写 std::is_pointer<int*>::value
static_assert(is_pointer_v<int*>);

7.3 Concepts（C++20）

#include <concepts>

// 定义概念
template<typename T>
concept Arithmetic = std::is_arithmetic_v<T>;

// 使用概念约束模板
template<Arithmetic T>
T add(T a, T b) {
    return a + b;
}

// 错误信息更友好
// add(std::string("a"), std::string("b"));  // 编译错误：string 不满足 Arithmetic

八、实际应用案例

8.1 编译期配置系统

// 编译期配置参数
template<typename Config>
class NetworkManager {
    static constexpr bool useCompression = Config::enableCompression;
    static constexpr int timeoutMs = Config::timeoutMilliseconds;
    static constexpr auto protocol = Config::protocolType;
    
public:
    void send(const std::string& data) {
        if constexpr (useCompression) {
            auto compressed = compress(data);
            sendImpl(compressed);
        } else {
            sendImpl(data);
        }
    }
};

struct HighPerformanceConfig {
    static constexpr bool enableCompression = false;
    static constexpr int timeoutMilliseconds = 1000;
    static constexpr auto protocolType = Protocol::TCP;
};

NetworkManager<HighPerformanceConfig> fastNetwork;

8.2 类型安全的单位系统

template<typename Unit, typename Ratio = std::ratio<1>>
class Quantity {
    double value_;
public:
    explicit constexpr Quantity(double v) : value_(v) {}
    
    constexpr double value() const { return value_; }
    
    // 编译期单位转换
    template<typename OtherRatio>
    constexpr Quantity<Unit, OtherRatio> convert() const {
        static_assert(std::is_same_v<Unit, Unit>, "Unit mismatch!");
        return Quantity<Unit, OtherRatio>(
            value_ * Ratio::num / Ratio::den * OtherRatio::den / OtherRatio::num
        );
    }
};

struct Meter {};
struct Second {};

using Kilometer = Quantity<Meter, std::kilo>;
using MeterUnit = Quantity<Meter>;

constexpr Kilometer distance(5.0);  // 5 km
constexpr MeterUnit meters = distance.convert<std::ratio<1>>();  // 5000 m

九、总结

💡 学习建议：

1. 从简单的编译期计算（阶乘、斐波那契）入手
2. 理解模板特化和偏特化的模式匹配
3. 学习 CRTP 和表达式模板等经典模式
4. 善用现代 C++ 特性简化 TMP 代码

模板元编程是 C++ "零成本抽象"哲学的巅峰体现。虽然学习曲线陡峭，但掌握 TMP 后，你将能够编写出既高度泛化又极致高效的代码，真正释放 C++ 的深层潜力！

参考资料：《Effective C++》第三版，Scott Meyers 著