20. 模板与序列化：编译期反射尝试、结构体字段遍历的模板技巧

序列化，说白了就是把内存里的对象变成一串字节，存起来或者发出去。反过来叫反序列化。

在C++里做序列化，最烦人的是什么？是你要为每个结构体手写序列化代码。一个结构体有10个字段，你就得写10行赋值。改一个字段，序列化代码也得跟着改。我早年在一个通信中间件项目里，光维护这些序列化代码就快疯了——结构体改了，序列化函数忘了更新，线上排查了一整天才发现是字段顺序对不上。

那有没有办法让编译器帮我们干这个活？嗯，这就是我们今天要聊的——编译期反射。

20.1 什么是编译期反射

反射，就是程序在运行时能查看自己的结构。比如Java里，你可以拿到一个类的所有字段名、类型，然后动态调用。

C++呢？标准C++没有反射。至少目前没有（C++26正在推进，但还没落地）。

但我们有模板，有constexpr，有SFINAE，有C++17的if constexpr，还有C++20的concept。利用这些工具，我们可以在编译期模拟出类似反射的效果。

说白了，就是让编译器在编译阶段就知道结构体有哪些字段、什么类型，然后自动生成序列化代码。

20.2 结构体字段遍历的模板技巧

怎么遍历结构体的字段？C++标准没有提供直接的方法。但我们可以用一些“奇技淫巧”。

我个人习惯用宏 + 模板的组合拳。宏用来生成元数据，模板用来处理这些元数据。

20.2.1 宏辅助的字段注册

先看一个最简单的例子。我们定义一个宏，让结构体“注册”自己的字段：

#define DEFINE_STRUCT(Name, Fields) \
    struct Name { \
        Fields \
        template<typename Visitor> \
        void visit(Visitor&& v) { \
            /* 这里展开字段遍历 */ \
        } \
    }

// 使用
DEFINE_STRUCT(Point,
    int x;
    int y;
)

这个宏的问题很明显：visit函数里怎么展开字段？宏做不到遍历。我们需要更高级的技巧。

20.2.2 使用Boost.Preprocessor进行编译期遍历

Boost.Preprocessor可以在预处理阶段生成重复代码。配合模板，可以实现字段遍历。

我在项目中用过这个方案，效果不错，但缺点是依赖Boost，而且宏代码可读性差。后来我转向了另一种方式——结构化绑定 + 模板递归。

20.2.3 结构化绑定与编译期字段计数

C++17引入了结构化绑定。我们可以利用它来“拆开”结构体。但问题是，结构化绑定需要你知道字段数量。

有没有办法在编译期知道结构体有多少个字段？嗯，有一个trick：

template<typename T, typename... Args>
consteval auto field_count() {
    if constexpr (requires { T{std::declval<Args>()...}; }) {
        return field_count<T, Args..., void*>();
    } else {
        return sizeof...(Args) - 1;
    }
}

struct Point { int x; int y; };
static_assert(field_count<Point>() == 2);

这个技巧的原理：尝试用N个参数构造T，如果能构造，说明字段数大于等于N，继续尝试N+1；直到构造失败，返回N-1。

20.3 编译期反射的实战：自动序列化

有了字段计数，再配合std::apply和结构化绑定，我们可以写出通用的序列化函数。

来看一个完整的例子：

#include <tuple>
#include <string>
#include <sstream>

// 将结构体转为tuple的辅助函数
template<typename T>
auto as_tuple(T& t) {
    constexpr auto count = field_count<T>();
    if constexpr (count == 1) {
        auto& [a] = t;
        return std::tie(a);
    } else if constexpr (count == 2) {
        auto& [a, b] = t;
        return std::tie(a, b);
    } else if constexpr (count == 3) {
        auto& [a, b, c] = t;
        return std::tie(a, b, c);
    }
    // ... 可以继续扩展到更多字段
}

// 通用序列化函数
template<typename T>
std::string serialize(const T& obj) {
    std::ostringstream oss;
    auto tuple = as_tuple(obj);
    std::apply([&oss](const auto&... args) {
        ((oss << args << " "), ...);
    }, tuple);
    return oss.str();
}

struct Person {
    std::string name;
    int age;
    double height;
};

// 使用
Person p{"Alice", 30, 1.68};
std::string data = serialize(p); // "Alice 30 1.68"

这段代码的核心是as_tuple函数。它把结构体转成tuple，然后std::apply就可以遍历所有字段了。

20.4 Boost.PFR：开箱即用的编译期反射

Boost.PFR（Precise and Flat Reflection）是一个纯头文件库，不需要宏，不需要注册，直接就能遍历结构体字段。

用法极其简单：

#include <boost/pfr.hpp>

struct Point { int x; int y; };

Point p{10, 20};
boost::pfr::for_each_field(p, [](const auto& field, std::size_t index) {
    std::cout << "Field " << index << ": " << field << std::endl;
});
// 输出：
// Field 0: 10
// Field 1: 20

Boost.PFR的原理和我上面讲的类似，但它处理了更多边界情况，比如继承、引用成员、位域等。我在生产代码里用过Boost.PFR做JSON序列化，效果很稳定。

20.5 知识体系总览

下面这张图总结了本章的核心脉络：

20.6 避坑指南

我曾经在一个项目里用编译期字段计数做序列化，结果结构体里有个std::string字段，计数一直不对。排查了半天才发现，std::string有自定义构造函数，导致聚合初始化失败，计数逻辑直接崩了。

这里有几个坑，我帮你列出来：

• 聚合类型限制：字段计数技巧只对聚合类型有效。有自定义构造函数、私有/保护成员、虚函数的结构体都不行。
• 字段顺序依赖：结构化绑定依赖字段声明顺序。如果你调整了结构体字段的顺序，序列化结果会变，反序列化时可能出错。
• 性能问题：编译期反射本身没有运行时开销，但std::apply和lambda的展开可能会增加编译时间。大型项目里要注意。
• 可移植性：Boost.PFR依赖编译器对聚合类型的处理，不同编译器可能有细微差异。建议在目标平台上做充分测试。

20.7 小结

编译期反射是C++模板元编程的一个高级应用。它让我们在缺乏原生反射支持的情况下，依然能写出通用的序列化代码。

三种主流方案各有优劣：

方案	优点	缺点
宏 + 模板	完全控制，无外部依赖	宏代码难维护，可读性差
结构化绑定 + 递归	纯C++17，无宏	字段数有限制，需要手写分支
Boost.PFR	开箱即用，功能完善	依赖Boost，编译时间略长

我个人推荐：如果是新项目，直接上Boost.PFR。如果是老项目不想引入Boost，用结构化绑定方案也够用。宏方案嘛，除非你实在没办法，否则尽量别碰——维护起来太痛苦了。

嗯，编译期反射就聊到这儿。记住一点：模板元编程不是为了炫技，而是为了解决实际问题。序列化就是它最典型的应用场景之一。

---