class Student {
public:
    std::string name;
    int age;
    float score;

    // 序列化：将对象写入输出流
    void serialize(std::ostream& out) const {
        size_t name_len = name.size();
        out.write(reinterpret_cast<const char*>(&name_len), sizeof(name_len));
        out.write(name.c_str(), name_len);
        out.write(reinterpret_cast<const char*>(&age), sizeof(age));
        out.write(reinterpret_cast<const char*>(&score), sizeof(score));
    }

    // 反序列化：从输入流恢复对象
    void deserialize(std::istream& in) {
        size_t name_len;
        in.read(reinterpret_cast<char*>(&name_len), sizeof(name_len));
        name.resize(name_len);
        in.read(&name[0], name_len);
        in.read(reinterpret_cast<char*>(&age), sizeof(age));
        in.read(reinterpret_cast<char*>(&score), sizeof(score));
    }
};

Student s{"Alice", 20, 95.5f};

// 写入文件（序列化）
std::ofstream ofs("student.dat", std::ios::binary);
s.serialize(ofs);
ofs.close();

// 读取文件（反序列化）
Student s2;
std::ifstream ifs("student.dat", std::ios::binary);
s2.deserialize(ifs);
ifs.close();

#include <boost/serialization/string.hpp>
#include <boost/serialization/access.hpp>

class Student {
public:
    std::string name;
    int age;
    float score;

private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version) {
        ar & name;
        ar & age;
        ar & score;
    }
};

// 序列化到二进制文件
{
    std::ofstream ofs("student.bin", std::ios::binary);
    boost::archive::binary_oarchive oa(ofs);
    Student s{"Bob", 21, 88.0f};
    oa << s;
}

// 反序列化
{
    std::ifstream ifs("student.bin", std::ios::binary);
    boost::archive::binary_iarchive ia(ifs);
    Student s;
    ia >> s;
}

#include <nlohmann/json.hpp>

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Student, name, age, score)

// 序列化为JSON字符串
Student s{"Charlie", 19, 92.0f};
nlohmann::json j = s;
std::string json_str = j.dump();

// 反序列化
nlohmann::json j2 = nlohmann::json::parse(json_str);
Student s2 = j2.get<Student>();