当前位置：首页 > news >正文

C++ Cereal序列化库的使用

news 来源：原创 2025/6/19 12:57:15

C++ Cereal 库使用指南

Cereal 是一个轻量级的 C++ 序列化库，用于将对象序列化为二进制、XML 或 JSON 格式，以及从这些格式反序列化。它支持标准库类型和用户自定义类型的序列化，且无需修改原有类定义。

基本用法

1. 安装与包含

#include <cereal/archives/binary.hpp>
#include <cereal/types/vector.hpp>  // 包含对vector的支持
#include <cereal/types/string.hpp> // 包含对string的支持

2. 基本序列化/反序列化

#include <fstream>
#include <iostream>
#include <vector>

struct MyData {
    int x;
    double y;
    std::string z;
    std::vector<int> nums;

    // 序列化函数模板
    template<class Archive>
    void serialize(Archive & archive) {
        archive(x, y, z, nums); // 序列化所有成员
    }
};

int main() {
    MyData data1{42, 3.14, "hello", {1, 2, 3}};
    
    // 序列化到文件
    {
        std::ofstream os("data.bin", std::ios::binary);
        cereal::BinaryOutputArchive archive(os);
        archive(data1); // 写入数据
    }

    // 从文件反序列化
    MyData data2;
    {
        std::ifstream is("data.bin", std::ios::binary);
        cereal::BinaryInputArchive archive(is);
        archive(data2); // 读取数据
    }

    std::cout << data2.x << ", " << data2.y << ", " << data2.z << std::endl;
    return 0;
}

高级特性

1. 分离加载和保存

struct MyClass {
    int a;
    std::string b;

    template<class Archive>
    void save(Archive & archive) const {
        archive(a, b);
    }

    template<class Archive>
    void load(Archive & archive) {
        archive(a, b);
    }
};

2. 版本控制

struct VersionedData {
    int x;
    std::string y;

    template<class Archive>
    void serialize(Archive & ar, const std::uint32_t version) {
        ar(x, y);
        if(version >= 2) {
            // 版本2新增的字段
        }
    }
};

// 注册版本
CEREAL_CLASS_VERSION(VersionedData, 2)

3. 指针和智能指针

struct Node {
    int value;
    std::shared_ptr<Node> next;

    template<class Archive>
    void serialize(Archive & ar) {
        ar(value, next);
    }
};

4. 继承

struct Base {
    int x;
    template<class Archive>
    void serialize(Archive & ar) {
        ar(x);
    }
};

struct Derived : Base {
    double y;
    template<class Archive>
    void serialize(Archive & ar) {
        ar(cereal::base_class<Base>(this), y);
    }
};

不同格式支持

1. 二进制格式

#include <cereal/archives/binary.hpp>

// 输出
std::ofstream os("data.bin", std::ios::binary);
cereal::BinaryOutputArchive archive(os);
archive(data);

// 输入
std::ifstream is("data.bin", std::ios::binary);
cereal::BinaryInputArchive archive(is);
archive(data);

2. JSON格式

#include <cereal/archives/json.hpp>

// 输出
std::ofstream os("data.json");
cereal::JSONOutputArchive archive(os);
archive(cereal::make_nvp("MyData", data)); // 使用命名

// 输入
std::ifstream is("data.json");
cereal::JSONInputArchive archive(is);
archive(data);

3. XML格式

#include <cereal/archives/xml.hpp>

// 输出
std::ofstream os("data.xml");
cereal::XMLOutputArchive archive(os);
archive(cereal::make_nvp("MyData", data));

// 输入
std::ifstream is("data.xml");
cereal::XMLInputArchive archive(is);
archive(data);

实际应用示例

1. 序列化自定义类

class Person {
public:
    Person() = default;
    Person(std::string n, int a) : name(n), age(a) {}
    
private:
    std::string name;
    int age;
    std::vector<std::string> friends;
    
    friend class cereal::access;
    
    template<class Archive>
    void serialize(Archive & ar) {
        ar(name, age, friends);
    }
};

2. 序列化STL容器

std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}};
std::vector<double> myVec = {1.1, 2.2, 3.3};

{
    std::ofstream os("container.bin", std::ios::binary);
    cereal::BinaryOutputArchive archive(os);
    archive(myMap, myVec);
}

3. 多态类型序列化

struct Base {
    virtual void foo() = 0;
    virtual ~Base() = default;
    
    template<class Archive>
    void serialize(Archive & ar) {}
};

struct Derived : Base {
    int x;
    void foo() override {}
    
    template<class Archive>
    void serialize(Archive & ar) {
        ar(cereal::base_class<Base>(this), x);
    }
};

// 注册多态类型
CEREAL_REGISTER_TYPE(Derived)