c++ - 如何在 C++ 中序列化对象？

Question

我有一个小的对象层次结构，我需要通过套接字连接对其进行序列化和传输。我需要序列化对象，然后根据它的类型反序列化它。有没有一种简单的方法可以在 C++ 中做到这一点（就像在 Java 中一样）？

有没有 C++ 序列化在线代码示例或教程？

编辑：为了清楚起见，我正在寻找将对象转换为字节数组，然后再转换回对象的方法。我可以处理套接字传输。

score 59 · Accepted Answer

说到序列化，我想到了boost 序列化 API 。至于通过网络传输序列化数据，我会使用 Berkeley 套接字或asio 库。

编辑：
如果要将对象序列化为字节数组，可以按以下方式使用 boost 序列化程序（取自教程站点）：

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
class gps_position
{
private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & degrees;
        ar & minutes;
        ar & seconds;
    }
    int degrees;
    int minutes;
    float seconds;

public:
    gps_position(){};
    gps_position(int d, int m, float s) :
    degrees(d), minutes(m), seconds(s)
    {}
};

实际的序列化非常简单：

#include <fstream>
std::ofstream ofs("filename.dat", std::ios::binary);

    // create class instance
    const gps_position g(35, 59, 24.567f);

    // save data to archive
    {
        boost::archive::binary_oarchive oa(ofs);
        // write class instance to archive
        oa << g;
        // archive and stream closed when destructors are called
    }

反序列化以类似的方式工作。

还有一些机制可以让您处理指针的序列化（复杂的数据结构，如树等没有问题），派生类，您可以在二进制和文本序列化之间进行选择。此外，所有 STL 容器都支持开箱即用。

score 16 · Accepted Answer

在某些情况下，在处理简单类型时，您可以这样做：

object o;
socket.write(&o, sizeof(o));

这可以作为概念验证或初稿，因此您团队的其他成员可以继续处理其他部分。

但是迟早，通常会更早，这会让你受伤！

您遇到以下问题：

虚拟指针表将被损坏。
指针（指向数据/成员/函数）将被损坏。
不同机器上填充/对齐的差异。
Big/Little-Endian 字节排序问题。
浮动/双精度实现的变化。

（另外，您需要知道在接收方要拆包的内容。）

您可以通过为每个类开发自己的编组/解组方法来改进这一点。（理想情况下是虚拟的，因此它们可以在子类中扩展。）一些简单的宏可以让您以大/小端中立的顺序非常快速地写出不同的基本类型。

但是，通过boost 的序列化库处理这种繁重的工作要好得多，也更容易。

score 13 · Accepted Answer

有一个通用模式可用于序列化对象。基本原语是您可以从迭代器中读取和写入的这两个函数：

template <class OutputCharIterator>
void putByte(char byte, OutputCharIterator &&it)
{
    *it = byte;
    ++it;
}


template <class InputCharIterator>
char getByte(InputCharIterator &&it, InputCharIterator &&end)
{
    if (it == end)
    {
        throw std::runtime_error{"Unexpected end of stream."};
    }

    char byte = *it;
    ++it;
    return byte;
}

然后序列化和反序列化函数遵循以下模式：

template <class OutputCharIterator>
void serialize(const YourType &obj, OutputCharIterator &&it)
{
    // Call putbyte or other serialize overloads.
}

template <class InputCharIterator>
void deserialize(YourType &obj, InputCharIterator &&it, InputCharIterator &&end)
{
    // Call getByte or other deserialize overloads.
}

对于类，您可以使用友元函数模式来允许使用 ADL 找到重载：

class Foo
{
    int internal1, internal2;
    
    // So it can be found using ADL and it accesses private parts.
    template <class OutputCharIterator>
    friend void serialize(const Foo &obj, OutputCharIterator &&it)
    {
        // Call putByte or other serialize overloads.
    }

    // Deserialize similar.
};

然后在你的程序中，你可以序列化和对象到这样的文件中：

std::ofstream file("savestate.bin");
serialize(yourObject, std::ostreambuf_iterator<char>(file));

然后阅读：

std::ifstream file("savestate.bin");
deserialize(yourObject, std::istreamBuf_iterator<char>(file), std::istreamBuf_iterator<char>());

我的旧答案在这里：

序列化意味着将您的对象转换为二进制数据。而反序列化意味着从数据中重新创建一个对象。

序列化时，您将字节推入uint8_t向量中。反序列化时，您正在从uint8_t向量中读取字节。

在序列化内容时，您当然可以使用一些模式。

每个可序列化类都应该有一个serialize(std::vector<uint8_t> &binaryData)或类似的签名函数，它将其二进制表示写入提供的向量。然后这个函数可以把这个向量传递给它的成员的序列化函数，这样他们也可以把他们的东西写进去。

因为数据表示在不同的架构上可能不同。您需要找出如何表示数据的方案。

让我们从基础开始：

序列化整数数据

只需按小端顺序写入字节即可。如果大小很重要，或者使用 varint 表示。

以小端顺序序列化：

data.push_back(integer32 & 0xFF);
data.push_back((integer32 >> 8) & 0xFF);
data.push_back((integer32 >> 16) & 0xFF);
data.push_back((integer32 >> 24) & 0xFF);

从小端顺序反序列化：

integer32 = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);

序列化浮点数据

据我所知，IEEE 754 在这里拥有垄断地位。我不知道任何主流架构会使用其他东西作为浮动。唯一可以不同的是字节顺序。一些体系结构使用小端，另一些使用大端字节顺序。这意味着您需要小心在接收端大声播放字节的顺序。另一个区别可能是处理非正规和无穷大和 NAN 值。但只要你避免这些值，你应该没问题。

序列化：

uint8_t mem[8];
memcpy(mem, doubleValue, 8);
data.push_back(mem[0]);
data.push_back(mem[1]);
...

反序列化是向后做的。注意架构的字节顺序！

序列化字符串

首先，您需要就编码达成一致。UTF-8 很常见。然后将其存储为长度前缀的方式：首先使用我上面提到的方法存储字符串的长度，然后逐字节写入字符串。

序列化数组。

它们与字符串相同。您首先序列化一个表示数组大小的整数，然后序列化其中的每个对象。

序列化整个对象

正如我之前所说，他们应该有一种serialize将内容添加到向量的方法。要反序列化一个对象，它应该有一个接受字节流的构造函数。它可以是一个istream但在最简单的情况下它可以只是一个引用uint8_t指针。构造函数从流中读取它想要的字节并设置对象中的字段。如果系统设计良好并按对象字段顺序序列化字段，您只需将流传递给初始化列表中的字段构造函数，并以正确的顺序对它们进行反序列化。

序列化对象图

首先，您需要确定这些对象是否真的是您想要序列化的东西。如果目标上存在这些对象的实例，则不需要序列化它们。

现在您发现需要序列化指针指向的对象。仅在使用它们的程序中才有效的指针问题。您不能序列化指针，您应该停止在对象中使用它们。而是创建对象池。这个对象池基本上是一个包含“盒子”的动态数组。这些框有一个引用计数。非零引用计数表示一个活动对象，零表示一个空槽。然后创建类似于 shared_ptr 的智能指针，它不存储指向对象的指针，而是存储数组中的索引。您还需要就表示空指针的索引达成一致，例如。-1。

基本上我们在这里所做的是将指针替换为数组索引。现在在序列化时，您可以像往常一样序列化这个数组索引。您无需担心对象将在目标系统的内存中的什么位置。只要确保它们也具有相同的对象池。

所以我们需要序列化对象池。但哪些？好吧，当您序列化一个对象图时，您不仅仅是在序列化一个对象，而是在序列化整个系统。这意味着系统的序列化不应从系统的某些部分开始。这些对象不应该担心系统的其余部分，它们只需要序列化数组索引就可以了。您应该有一个系统序列化程序来编排系统的序列化并遍历相关的对象池并序列化所有对象池。

在接收端，所有数组和其中的对象都被反序列化，重新创建所需的对象图。

序列化函数指针

不要在对象中存储指针。有一个静态数组，其中包含指向这些函数的指针并将索引存储在对象中。

由于这两个程序都将该表编译到它们的架子中，因此仅使用索引应该可以工作。

序列化多态类型

既然我说过你应该避免使用可序列化类型的指针，而应该使用数组索引，那么多态性就无法工作，因为它需要指针。

您需要使用类型标签和联合来解决这个问题。

版本控制

在所有上述之上。您可能希望不同版本的软件互操作。

在这种情况下，每个对象都应该在其序列化的开头写一个版本号来指示版本。

在另一侧加载对象时，较新的对象可能能够处理较旧的表示，但较旧的对象无法处理较新的表示，因此它们应该对此抛出异常。

每次发生变化时，您都应该增加版本号。

所以总结一下，序列化可能很复杂。但幸运的是，您不需要序列化程序中的所有内容，通常只序列化协议消息，这些消息通常是普通的旧结构。所以你不需要我上面经常提到的复杂技巧。

score 1 · Accepted Answer

通过学习，我编写了一个简单的 C++11 序列化程序。我尝试了其他各种重量级的产品，但想要一些我能真正理解的东西，当它出错或无法用最新的 g++ 编译时（这发生在我使用 Cereal 时；一个非常好的库但很复杂，我无法理解编译器在升级时抛出的错误。）无论如何，它只是标题并处理 POD 类型、容器、地图等......没有版本控制，它只会从保存它的同一个拱门加载文件。

https://github.com/goblinhack/simple-c-plus-plus-serializer

示例用法：

#include "c_plus_plus_serializer.h"

static void serialize (std::ofstream out)
{
    char a = 42;
    unsigned short b = 65535;
    int c = 123456;
    float d = std::numeric_limits<float>::max();
    double e = std::numeric_limits<double>::max();
    std::string f("hello");

    out << bits(a) << bits(b) << bits(c) << bits(d);
    out << bits(e) << bits(f);
}

static void deserialize (std::ifstream in)
{
    char a;
    unsigned short b;
    int c;
    float d;
    double e;
    std::string f;

    in >> bits(a) >> bits(b) >> bits(c) >> bits(d);
    in >> bits(e) >> bits(f);
}