C++ 序列化库选型实战：从 JSON 到 FlatBuffers

#include <nlohmann/json.hpp>
#include <string>
#include <iostream>

using json = nlohmann::json;

struct User {
    std::string name;
    int age;
    std::vector<std::string> tags;
};

// 声明式映射：无需手写解析逻辑
void to_json(json& j, const User& u) {
    j = json{{"name", u.name}, {"age", u.age}, {"tags", u.tags}};
}
void from_json(const json& j, User& u) {
    j.at("name").get_to(u.name);
    j.at("age").get_to(u.age);
    j.at("tags").get_to(u.tags);
}

int main() {
    User u{"alice", 30, {"cpp", "simd"}};
    std::string s = json(u).dump(2);          // 带缩进输出
    std::cout << s << std::endl;

    auto parsed = json::parse(s).get<User>(); // 反序列化
    std::cout << parsed.name << " " << parsed.age << std::endl;
}

#include <rapidjson/document.h>
#include <rapidjson/writer.h>
#include <rapidjson/stringbuffer.h>
#include <string>

using namespace rapidjson;

std::string serialize() {
    Document d;
    d.SetObject();
    auto& alloc = d.GetAllocator();

    d.AddMember("name", Value("alice", alloc), alloc);
    d.AddMember("age", 30, alloc);

    StringBuffer buf;
    Writer<StringBuffer> w(buf);
    d.Accept(w);
    return std::string(buf.GetString(), buf.GetSize());
}

// SAX 模式：零对象分配，适合超大文档流式处理
struct AgeHandler : BaseReaderHandler<UTF8<>, AgeHandler> {
    int age = 0;
    bool Int(int i) { age = i; return true; }
    bool Key(const char* str, SizeType len, bool) {
        return std::string(str, len) == "age";
    }
};

// user.proto
syntax = "proto3";

message User {
  string name = 1;
  int32 age = 2;
  repeated string tags = 3;
  map<string, string> attrs = 4;
}

#include "user.pb.h"

std::string serialize(const User& u) {
    std::string out;
    u.SerializeToString(&out);       // 序列化
    return out;
}

User deserialize(const std::string& bytes) {
    User u;
    u.ParseFromString(bytes);        // 反序列化（需要遍历构造对象）
    return u;
}

#include "user_generated.h"

// 构造（写入需要 builder，有写放大）
flatbuffers::FlatBufferBuilder builder;
auto name = builder.CreateString("alice");
auto tags = builder.CreateVector(std::vector<flatbuffers::Offset<flatbuffers::String>>{});
auto user = CreateUser(builder, name, 30, tags);
builder.Finish(user);

// 访问：直接从字节缓冲区读，零拷贝零分配
const uint8_t* buf = builder.GetBufferPointer();
auto u = GetUser(buf);
int age = u->age();                      // 直接读，纳秒级
auto n = u->name()->string_view();

message User {
  string name = 1;
  int32 age = 2;
  reserved 3, 5;            // 显式保留，防止被复用
  reserved "old_email";     // 保留字段名
  string email = 6;         // 新字段用新编号
}

// 宽容读取：字段缺失时回退到默认值
json j = json::parse(payload);
User u;
u.name = j.value("name", std::string{"anonymous"});
u.age  = j.value("age", 0);
// 未知字段被自然忽略，不会抛异常

// 完整可运行示例：nlohmann/json 与手写 TLV 编码的性能对比
// 编译：g++ -std=c++20 -O2 -o serial_demo serial_demo.cpp
// 依赖：nlohmann/json 单头文件（可从 GitHub 获取 json.hpp）

#include <nlohmann/json.hpp>
#include <iostream>
#include <string>
#include <vector>
#include <chrono>
#include <cstring>

using json = nlohmann::json;
using Clock = std::chrono::high_resolution_clock;

struct User {
    std::string name;
    int age;
    std::vector<std::string> tags;
};

// ====== JSON 方案 ======
std::string to_json_str(const User& u) {
    json j{{"name", u.name}, {"age", u.age}, {"tags", u.tags}};
    return j.dump();
}
User from_json_str(const std::string& s) {
    auto j = json::parse(s);
    return User{j.at("name").get<std::string>(),
                j.at("age").get<int>(),
                j.at("tags").get<std::vector<std::string>>()};
}

// ====== 手写 TLV 方案（Varint 长度 + 原始字节） ======
void put_varint(std::string& out, std::uint64_t v) {
    while (v >= 0x80) { out.push_back(char(v | 0x80)); v >>= 7; }
    out.push_back(char(v));
}
std::uint64_t get_varint(const char*& p, const char* end) {
    std::uint64_t v = 0; int shift = 0;
    while (p < end) {
        std::uint8_t b = static_cast<std::uint8_t>(*p++);
        v |= std::uint64_t(b & 0x7F) << shift;
        if (!(b & 0x80)) break;
        shift += 7;
    }
    return v;
}
std::string to_tlv(const User& u) {
    std::string out;
    put_varint(out, u.name.size());
    out += u.name;
    put_varint(out, static_cast<std::uint64_t>(u.age));
    put_varint(out, u.tags.size());
    for (const auto& t : u.tags) {
        put_varint(out, t.size());
        out += t;
    }
    return out;
}
User from_tlv(const std::string& s) {
    User u;
    const char* p = s.data();
    const char* end = p + s.size();
    auto len = get_varint(p, end);
    u.name.assign(p, len); p += len;
    u.age = static_cast<int>(get_varint(p, end));
    auto n = get_varint(p, end);
    u.tags.resize(n);
    for (auto& t : u.tags) {
        auto l = get_varint(p, end);
        t.assign(p, l); p += l;
    }
    return u;
}

template <typename F>
double bench(F f, int iters) {
    auto t0 = Clock::now();
    for (int i = 0; i < iters; ++i) f();
    auto t1 = Clock::now();
    return std::chrono::duration<double, std::micro>(t1 - t0).count() / iters;
}

int main() {
    User u{"alice", 30, {"cpp", "simd", "lockfree"}};
    const int ITERS = 20000;

    std::string js = to_json_str(u);
    std::string tl = to_tlv(u);
    std::cout << "JSON 体积: " << js.size() << " B\n"
              << "TLV  体积: " << tl.size() << " B" << std::endl;

    auto js_user = from_json_str(js);
    auto tl_user = from_tlv(tl);
    std::cout << "往返一致: "
              << (js_user.name == u.name && tl_user.name == u.name ? "OK" : "FAIL")
              << std::endl;

    std::cout << "\n=== 序列化 (us) ===" << std::endl;
    std::cout << "JSON: " << bench([&]{ to_json_str(u); }, ITERS) << std::endl;
    std::cout << "TLV : " << bench([&]{ to_tlv(u); }, ITERS) << std::endl;

    std::cout << "\n=== 反序列化 (us) ===" << std::endl;
    std::cout << "JSON: " << bench([&]{ from_json_str(js); }, ITERS) << std::endl;
    std::cout << "TLV : " << bench([&]{ from_tlv(tl); }, ITERS) << std::endl;
    return 0;
}