C++ 编译期反射与序列化：模板元编程驱动的结构与高性能二进制协议

#include <tuple>
#include <type_traits>

// 把聚合体的成员转成 tuple 引用，从而获得"字段数"
template<typename T, size_t... I>
constexpr auto as_tuple_impl(T& t, std::index_sequence<I...>) {
    auto&& [a...] = t;                    // 结构化绑定展开全部成员
    return std::tie(a...);
}

template<typename T>
constexpr auto as_tuple(T& t) {
    return as_tuple_impl(t, std::make_index_sequence<
        std::tuple_size_v<decltype(as_tuple_impl(t, std::make_index_sequence<0>{}))>>{});
}

#include <boost/pfr.hpp>
#include <iostream>

struct Point { int x, y, z; };

int main() {
    Point p{1, 2, 3};
    // 遍历所有字段，无需任何宏
    boost::pfr::for_each_field(p, [](auto& f) {
        std::cout << f << ' ';            // 1 2 3
    });
    std::cout << "fields: " << boost::pfr::tuple_size<Point>::value << '\n';
}

#include <boost/pfr.hpp>
#include <cstring>
#include <vector>

template<typename Buffer>
void serialize_impl(const auto& v, Buffer& buf);      // 前向声明

template<typename T>
void serialize_field(const T& v, std::vector<uint8_t>& buf) {
    if constexpr (std::is_arithmetic_v<T>) {
        // 按小端写入原始字节
        const auto* bytes = reinterpret_cast<const uint8_t*>(&v);
        buf.insert(buf.end(), bytes, bytes + sizeof(T));
    } else if constexpr (requires { v.size(); v.data(); }) {
        // 容器：先写长度，再逐个序列化
        uint64_t n = v.size();
        serialize_field(n, buf);
        for (auto& e : v) serialize_field(e, buf);
    } else {
        // 聚合体：逐字段递归
        boost::pfr::for_each_field(v, [&](auto& f) { serialize_field(f, buf); });
    }
}

template<typename T>
void serialize_to(const T& v, std::vector<uint8_t>& buf) {
    serialize_field(v, buf);
}

template<typename T>
void serialize_field(const std::string& s, std::vector<uint8_t>& buf) {
    serialize_field(static_cast<uint64_t>(s.size()), buf);
    buf.insert(buf.end(), s.begin(), s.end());
}

template<typename K, typename V>
void serialize_field(const std::map<K, V>& m, std::vector<uint8_t>& buf) {
    serialize_field(static_cast<uint64_t>(m.size()), buf);
    for (auto& [k, v] : m) { serialize_field(k, buf); serialize_field(v, buf); }
}

// 定义字段清单（X-Macro 的核心）
#define ENTITY_FIELDS(X) \
    X(int, id)           \
    X(std::string, name) \
    X(double, score)

struct Player {
#define X(type, name) type name;
    ENTITY_FIELDS(X)
#undef X

    // 序列化：宏展开出逐字段代码
    template<typename Buffer>
    void serialize(Buffer& buf) const {
#define X(type, name) serialize_field(name, buf);
        ENTITY_FIELDS(X)
#undef X
    }
};

#define STRINGIFY(x) #x

// 生成 {"id":1,"name":"alice"} 风格的字段名
#define X(type, name) "\"" #name "\": " << name << ",";

#include <string>

// 手工字段声明 + 编译期字段表
struct Person {
    std::string name;
    int age;

    static constexpr auto fields() {
        return std::make_tuple(std::pair{"name", &Person::name},
                               std::pair{"age", &Person::age});
    }
};

#include <cstring>

// 对 POD 结构体，可直接按内存布局直写（需处理对齐与字节序）
struct Header { uint32_t magic; uint16_t version; uint16_t flags; };

void write_header(std::vector<uint8_t>& out, const Header& h) {
    // 手动打包：避免结构体 padding 造成跨平台差异
    auto push = [&](auto v) {
        using U = std::remove_cvref_t<decltype(v)>;
        for (int i = 0; i < int(sizeof(U)); ++i)
            out.push_back(uint8_t(v >> (8 * i)));   // 小端
    };
    push(h.magic); push(h.version); push(h.flags);
}

#include <cereal/archives/binary.hpp>
#include <cereal/archives/json.hpp>
#include <cereal/types/vector.hpp>
#include <cereal/types/string.hpp>
#include <fstream>

struct Config {
    std::string name;
    int width = 1920;
    int height = 1080;
    std::vector<std::string> enabled_features;

    // cereal 的侵入式接口：手写但极简
    template<class Archive>
    void serialize(Archive& ar) {
        ar(name, width, height, enabled_features);
    }
};

int main() {
    Config cfg{"main", 2560, 1440, {"vsync", "hdr"}};

    // 二进制归档
    {
        std::ofstream ofs("cfg.bin", std::ios::binary);
        cereal::BinaryOutputArchive oar(ofs);
        oar(cfg);
    }
    // JSON 归档（调试友好，无需改任何序列化代码）
    {
        std::ofstream ofs("cfg.json");
        cereal::JSONOutputArchive joar(ofs);
        joar(cfg);
    }

    // 读回
    Config loaded;
    std::ifstream ifs("cfg.bin", std::ios::binary);
    cereal::BinaryInputArchive iar(ifs);
    iar(loaded);
    return 0;
}

// 伪代码：P2996 风格
template<typename T>
void log_all_fields(const T& obj) {
    std::meta::for_each(meta::members_of(^T), [&](auto meta_member) {
        // meta_member 携带类型与名称，直接可读 obj.*meta_member
    });
}