27、Boost.Hana 库入门：C++14/17 时代的元编程、hana::type、hana::tuple 的编译期操作

说实话，我第一次接触 Boost.Hana 的时候，心里是有点抵触的。那时候我已经习惯了用传统的 TMP（模板元编程）手法——各种 std::integral_constant、std::conditional、还有那让人又爱又恨的 std::tuple 递归展开。每次写个稍微复杂点的编译期逻辑，代码量就蹭蹭往上涨，调试起来更是头疼。

直到有一次，我在做一个配置系统，需要在编译期根据不同的平台选择不同的算法组合。传统的 TMP 写法让我维护了三个版本的代码，改一个地方要同步改三处。我实在受不了了，决定试试 Hana。结果呢？代码量直接砍了一半，而且可读性好了不止一个档次。

嗯，今天我们就来聊聊这个 C++14/17 时代的元编程利器——Boost.Hana。

为什么需要 Hana？

传统的模板元编程，说白了就是用类型来模拟计算。你想想看，我们写 std::integral_constant<int, 42> 只是为了表示一个编译期整数，写 std::conditional<true, int, double>::type 只是为了做一个 if-else。这些写法太绕了。

Hana 的思路很直接：让编译期计算像运行时计算一样自然。它把类型、整数、字符串都统一成「值」，然后用一套统一的接口来操作它们。

hana::type：类型即值

在 Hana 里，hana::type<T> 就是类型 T 的「值表示」。你可以把它当作普通变量来用。

#include <boost/hana.hpp>
namespace hana = boost::hana;

// 传统写法
using MyType = int;

// Hana 写法
auto my_type = hana::type_c<int>;  // 类型变成了值

// 甚至可以这样
auto types = hana::make_tuple(
    hana::type_c<int>,
    hana::type_c<double>,
    hana::type_c<std::string>
);

我个人习惯用 hana::type_c<T> 来快速创建一个类型值。注意，这里的 type_c 是个变量模板，返回的是 hana::type<T> 的实例。

你可能会问：「把类型当值用，有什么好处？」

好处大了去了。你可以遍历类型、过滤类型、对类型做变换——就像操作普通容器一样。

// 过滤出所有整数类型
auto is_integral = [](auto t) {
    return hana::traits::is_integral(t);
};

auto integral_types = hana::filter(types, is_integral);
// integral_types 包含：int, double（假设 double 被视为整型？不，这里只是举例）

hana::tuple：编译期容器

hana::tuple 是 Hana 的核心容器。它和 std::tuple 长得像，但功能强大多了。

// 创建一个编译期元组
auto tup = hana::make_tuple(1, 'a', 3.14);

// 访问元素
auto first = hana::at_c<0>(tup);  // 1
auto second = hana::at_c<1>(tup); // 'a'

// 变换
auto doubled = hana::transform(tup, [](auto x) {
    return x * 2;
});
// doubled: (2, 'a'*2? 等等，char 不能乘2... 这里只是演示语法)

我曾经在项目中用 hana::tuple 来管理一组策略类。每个策略类有不同的接口，但 Hana 的 transform 和 filter 让我能统一处理它们，而不需要写一堆模板特化。

编译期操作实战

我们来看一个实际例子：假设你要在编译期生成一个函数参数列表，然后根据参数类型做不同的处理。

// 定义一个编译期类型列表
auto types = hana::tuple_t<int, double, std::string>;

// 对每个类型生成一个默认值
auto defaults = hana::transform(types, [](auto t) {
    return hana::if_(
        hana::traits::is_integral(t),
        hana::type_c<int>::value,  // 0
        hana::type_c<double>::value // 0.0
    );
});

// 检查是否所有类型都是算术类型
auto all_arithmetic = hana::all_of(types, [](auto t) {
    return hana::traits::is_arithmetic(t);
});

这里要注意，hana::tuple_t 是 hana::tuple<hana::type<T>...> 的快捷写法。我刚开始用的时候经常搞混 hana::make_tuple 和 hana::tuple_t 的区别——前者创建运行时值的元组，后者创建类型值的元组。

编译期算法

Hana 提供了丰富的编译期算法，基本上你能想到的 STL 算法，Hana 都有对应的编译期版本。

算法	作用	示例
hana::transform	对每个元素应用函数	hana::transform(tup, f)
hana::filter	保留满足条件的元素	hana::filter(tup, pred)
hana::fold_left	左折叠	hana::fold_left(tup, init, f)
hana::any_of	检查是否有元素满足条件	hana::any_of(tup, pred)
hana::all_of	检查是否所有元素都满足条件	hana::all_of(tup, pred)

这些算法都是在编译期执行的，不会产生任何运行时开销。你想想看，以前用传统 TMP 写一个 fold_left 要多少代码？现在一行搞定。

Hana 的类型推导与 constexpr

Hana 大量使用了 C++14/17 的 constexpr 和 auto 特性。这意味着你可以写出非常自然的代码：

constexpr auto add = [](auto a, auto b) {
    return a + b;
};

constexpr auto result = add(hana::int_c<3>, hana::int_c<4>);
// result 是 hana::int_c<7>

这里 hana::int_c<3> 是编译期整数，add 是 constexpr lambda，整个计算在编译期完成。结果 result 的类型是 hana::integral_constant<int, 7>，可以直接用在需要编译期常量的地方。

知识体系总览

下面这张图展示了 Hana 的核心概念和它们之间的关系：

说白了，Hana 把编译期计算变成了三个基本操作：把类型变成值、把值放进容器、用算法操作容器。这个思路一旦理解了，你会发现很多以前觉得复杂的 TMP 问题，现在都能用很自然的方式解决。

总结

Boost.Hana 不是要取代传统的模板元编程，而是提供了一种更现代、更易用的方式来做编译期计算。它充分利用了 C++14/17 的特性，让元编程代码看起来就像普通代码一样自然。

我个人建议，如果你还在用 C++11 的 TMP 手法，不妨试试 Hana。刚开始可能会有点不习惯，但用上一两个项目后，你就会发现它的威力。嗯，至少我自己的项目里，Hana 已经成了标配。

---

公众号：蓝海资料掘金营，微信 deep3321