在 C++ 中二进制读写复杂的结构

Question

我需要能够在我的项目中保存/读取我的数据结构，但是所有数据本身都是非常复杂和独特的结构形式，我通常通过其他结构和向量来实现这些结构。我已经将它们全部包装到一个结构中，这样我就有了类似的东西

struct master{
    std::vector<apprentice_type1> a;
    std::vector<apprentice_type2> b; //etc.

    std::string label;
};

与其他定义类似

struct apprentice_type1{
    vec location;
    int point_label;
    std::vector<int> relational_data;
};

struct vec{
    double x,y,z;
};

所以它变得相当复杂！我非常希望有一些好的、快速和天真的像

master obj;
//write to obj....
std::ofstream ofs("data.dat", std::ios::binary);
ofs.write((char *)&obj, sizeof(obj));

会起作用，但目前似乎不起作用。在我迷失在调试兔子洞之前，这实际上是我接近它的方式还是我需要重新考虑？如果有，怎么做？

谢谢。

Answer 1

如果您想要替代 Boost 序列化并访问 C++11 编译器，您还可以查看cereal。它的工作方式与 Boost 序列化几乎相同，但只是一个标头库，因此没有可链接的内容。

Answer 2

[...] 还是我需要重新考虑？如果有，怎么做？

您可能需要提供完整的实现（即探索“兔子洞”）。

这是一个已知问题（流序列化），没有单一的最佳解决方案，因为大多数实现需要解决不同的需求。

您可以执行以下操作之一：

• 实现 std::i/ostream 序列化；这意味着您将检查您的课程并实现operator>>(std::istream*, your_type&)，它是相反的operator<<(std::ostream*, your_type&)。

• 基于流库（如 boost.archive）实现序列化。

• 使用 JSON 或 XML 库。

• 使用谷歌协议缓冲区（或其他）

• 根据您的需要推出您自己的实施。

Answer 3

如果您选择 boost::serialization，这里有一个小示例：

#include <fstream>
#include <vector>

#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/vector.hpp>


template <typename T>
inline const boost::serialization::nvp<T> archive_value(const char* name, T& value) {
    return boost::serialization::make_nvp(name, value);
}

const unsigned Version = 0;

class Point{
    public:
    double x,y,z;

    private:
    template <typename P, typename Archive>
    static void serialize(P& p, Archive& ar, const unsigned int version) {
        std::cout << "Point\n";
        ar & archive_value("X", p.x);
        ar & archive_value("Y", p.y);
        ar & archive_value("Z", p.z);
    }

    public:
    template <typename Archive>
    void serialize(Archive& ar, const unsigned int version) const {
        serialize(*this, ar, version);
    }

    template <typename Archive>
    void serialize(Archive& ar, const unsigned int version) {
        serialize(*this, ar, version);
    }
};

BOOST_CLASS_VERSION(Point, Version)

struct Scene{
    std::vector<Point> points;

    private:
    template <typename S, typename Archive>
    static void serialize(S& s, Archive& ar, const unsigned int version) {
        std::cout << "Scene\n";
        ar & archive_value("Points", s.points);
    }

    public:
    template <typename Archive>
    void serialize(Archive& ar, const unsigned int version) const {
        serialize(*this, ar, version);
    }

    template <typename Archive>
    void serialize(Archive& ar, const unsigned int version) {
        serialize(*this, ar, version);
    }
};

BOOST_CLASS_VERSION(Scene, Version)


template <typename Archive>
void register_types(Archive& ar) {
    ar.template register_type<Point>();
    ar.template register_type<Scene>();
}

int main() {
    Scene scene;
    scene.points = { { 0, 0, 0 }, { 1, 1, 1 }, { 2, 2, 2 } };

    // Output
    {
        std::ofstream out("test.dat", std::ios_base::binary);
        boost::archive::binary_oarchive output(out);


        // First the version!
        output & archive_value("Version", Version);
        // Next the types!
        register_types(output);
        // Finally the data
        output & archive_value("Scene", scene);
    }

    scene.points = {};

    // Input
    {
        int version;
        std::ifstream in("test.dat", std::ios_base::binary);
        boost::archive::binary_iarchive input(in);
        // First the version!
        input & archive_value("Version", Version);
        // Next the types!
        register_types(input);
        // Finally the data
        input & archive_value("Scene", scene);
    }

    for(const auto& p : scene.points)
        std::cout << p.x << '\n';
}

注意：文件格式可能会演变，序列化功能（输入和/或输出）可能会根据文件版本进行调整。