C++ 模板元编程的基本技巧

作者

在 C++ 代码中，模板不仅仅是用来生成类型安全的容器或算法，它们同样可以用于在编译期执行复杂的计算，这就是模板元编程（Template Metaprogramming, TMP）的核心价值。通过 TMP，我们能够在编译阶段完成条件判断、循环展开、类型转换等操作，从而在运行时节省额外的开销。本文将从几个常见的场景出发，介绍几种常用的 TMP 技巧，并给出完整的示例代码。

1. 编译期整数序列

1.1 递归实现

一个最常见的 TMP 模块是生成整数序列（integer_sequence），它可以用来做函数参数拆包、索引访问等。最基础的实现方式是递归模板：

template<std::size_t... Ns>
struct integer_sequence {};

template<std::size_t N, std::size_t... Ns>
struct make_integer_sequence_impl
    : make_integer_sequence_impl<N - 1, N - 1, Ns...> {};

template<std::size_t... Ns>
struct make_integer_sequence_impl<0, Ns...>
    : integer_sequence<Ns...> {};

template<std::size_t N>
using make_integer_sequence = typename make_integer_sequence_impl <N>::type;

1.2 用于参数包展开

利用 make_integer_sequence，我们可以轻松实现一个多维数组的索引访问：

template<typename T, std::size_t N>
struct NDArray {
    std::array<T, N> data;

    template<std::size_t... Is>
    T& operator()(integer_sequence<Is...>) {
        // 这里可以根据需要进行多维索引计算
        return data[0]; // 简化示例
    }

    T& operator()(std::size_t idx) {
        return data[idx];
    }
};

2. 类型列表（Type List）

2.1 定义

类型列表是一个编译期的类型集合，常用来做类型遍历、过滤等操作。

template<typename... Ts>
struct TypeList {};

using MyTypes = TypeList<int, double, char, std::string>;

2.2 过滤操作

下面演示如何从类型列表中过滤出所有可赋值给 int 的类型：

template<typename List, typename Predicate>
struct Filter;

template<typename Predicate>
struct Filter<TypeList<>, Predicate> {
    using type = TypeList<>;
};

template<typename Head, typename... Tail, typename Predicate>
struct Filter<TypeList<Head, Tail...>, Predicate>
    : std::conditional_t<
        Predicate::template apply <Head>::value,
        // 继续递归并包含 Head
        std::conditional_t<
            Predicate::template apply <Head>::value,
            typename Filter<TypeList<Tail...>, Predicate>::type,
            typename Filter<TypeList<Tail...>, Predicate>::type
        >,
        typename Filter<TypeList<Tail...>, Predicate>::type
    > {};

（此处为示例，实际实现需要进一步细化）

3. 计算阶乘的元编程实现

编译期阶乘是 TMP 的经典例子：

template<std::size_t N>
struct Factorial {
    static constexpr std::size_t value = N * Factorial<N - 1>::value;
};

template<>
struct Factorial <0> {
    static constexpr std::size_t value = 1;
};

使用方式：

constexpr std::size_t fact5 = Factorial <5>::value; // 120

4. 静态多态（CRTP）

静态多态通过 CRTP（Curiously Recurring Template Pattern）实现：

template<typename Derived>
class Base {
public:
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class DerivedA : public Base <DerivedA> {
public:
    void implementation() { /* ... */ }
};

这里 DerivedA::implementation 在编译期被绑定，避免了虚函数表的开销。

5. 编译期错误检查

利用 static_assert 与 constexpr 可以在编译阶段捕捉错误：

template<typename T>
struct MyContainer {
    static_assert(std::is_same_v<T, int> || std::is_same_v<T, double>,
                  "MyContainer only supports int or double");
};

如果尝试 `MyContainer

`，编译器会报错并给出明确信息。 ## 6. 总结 模板元编程是一种强大而灵活的技术，能够在编译期完成大量工作，减轻运行时负担。上述示例只是冰山一角，真正的 TMP 应用场景包括但不限于： – 静态反射与属性映射 – 依赖注入（DI）容器 – 编译期图形/数值运算 – 代码生成与优化 掌握 TMP 需要一定的耐心和实践。建议先从简单的递归模板开始，逐步深入到更高级的元编程技巧。祝你在 C++ 的模板世界里玩得愉快！

发表评论