如何在c中序列化结构？

Question

我有一个结构对象，它包含几种原始数据类型、指针和结构指针。我想通过套接字发送它，以便它可以在另一端使用。由于我想预先支付序列化成本，我如何初始化该结构的对象以便它可以立即发送而无需编组？例如

struct A {
    int i;  
    struct B *p;
};

struct B {
    long l;
    char *s[0];
};

struct A *obj; 

// can do I initialize obj?
int len = sizeof(struct A) + sizeof(struct B) + sizeof(?);
obj = (struct A *) malloc(len);
...

write(socket, obj, len);

// on the receiver end, I want to do this
char buf[len];

read(socket, buf, len);
struct A *obj = (struct A *)buf;
int i = obj->i;
char *s = obj->p->s[0];
int i obj.i=1; obj.p.

谢谢你。

Answer 1

这个答案除了你的问题之外malloc。

不幸的是，您找不到仍然与标准兼容的好技巧。正确序列化结构的唯一方法是将每个元素分别分解为字节，将它们写入无符号字符数组，通过网络发送它们，然后在另一端将这些片段重新组合在一起。简而言之，您将需要大量移位和按位运算。

在某些情况下，您需要定义一种协议。例如，在您的情况下，您需要确保始终将对象p指向之后struct A，因此一旦恢复，您就可以正确设置指针。大家都说不能通过网络发送指针了吗？

s您可能想要做的另一件事是在 中写入为灵活数组成员分配的大小struct B。无论您选择序列化数据的哪种布局，显然双方都应该尊重。

需要注意的是，您不能依赖任何特定于机器的内容，例如字节顺序、结构填充或基本类型的大小。这意味着您应该单独序列化元素的每个字段并为其分配固定数量的字节。

Answer 2

最简单的方法可能是分配一块内存来保存所有内容。例如，考虑如下结构：

typedef struct A {
  int v;
  char* str;
} our_struct_t;

现在，最简单的方法是创建一个定义的格式并将其打包成一个字节数组。我将尝试展示一个例子：

int sLen = 0;
int tLen = 0;
char* serialized = 0;
char* metadata = 0;
char* xval = 0;
char* xstr = 0;
our_struct_t x;
x.v   = 10;
x.str = "Our String";
sLen  = strlen(x.str); // Assuming null-terminated (which ours is)
tLen  = sizeof(int) + sLen; // Our struct has an int and a string - we want the whole string not a mem addr
serialized = malloc(sizeof(char) * (tLen + sizeof(int)); // We have an additional sizeof(int) for metadata - this will hold our string length
metadata = serialized;
xval = serialized + sizeof(int);
xstr = xval + sizeof(int);
*((int*)metadata) = sLen; // Pack our metadata
*((int*)xval) = x.v; // Our "v" value (1 int)
strncpy(xstr, x.str, sLen); // A full copy of our string

所以这个例子将数据复制到一个大小的数组中，2 * sizeof(int) + sLen这允许我们使用单个整数元数据（即字符串长度）和从结构中提取的值。要反序列化，你可以想象如下：

char* serialized = // Assume we have this
char* metadata = serialized;
char* yval = metadata + sizeof(int);
char* ystr = yval + sizeof(int);
our_struct_t y;
int sLen = *((int*)metadata);
y.v = *((int*)yval);
y.str = malloc((sLen + 1) * sizeof(char)); // +1 to null-terminate
strncpy(y.str, ystr, sLen);
y.str[sLen] = '\0';

如您所见，我们的字节数组是明确定义的。下面我详细介绍了结构：

• 字节 0-3：元数据（字符串长度）
• 字节 4-7：Xv（值）
• 字节 8 - sLen : X.str (value)

如果您遵循定义的约定，这种定义良好的结构允许您在任何环境中重新创建结构。现在，通过套接字发送这个结构取决于你如何开发你的协议。您可以首先发送一个包含您刚刚构建的数据包总长度的整数数据包，或者您可以期望首先/单独发送元数据（逻辑上分开，这在技术上仍然可以同时发送）然后您知道在客户端接收多少数据。例如，如果我接收到元数据值，10那么我可以期望sizeof(int) + 10字节跟随来完成结构。一般来说，这可能是14字节。

编辑

我将根据评论中的要求列出一些说明。

我做了一个字符串的完整副本，所以它在（逻辑上）连续的内存中。也就是说，我的序列化数据包中的所有数据实际上都是完整数据——没有指针。这样，我们可以serialized通过套接字发送单个缓冲区（我们称之为 is ）。如果简单地发送指针，接收指针的用户会期望该指针是一个有效的内存地址。但是，您的内存地址不太可能完全相同。但是，即使是这样，他也不会像您一样在该地址拥有相同的数据（除非在非常有限和特殊的情况下）。

希望通过查看反序列化过程（这是在接收者方面）使这一点更加清楚。请注意我如何分配一个结构来保存发件人发送的信息。如果发送方没有向我发送完整的字符串，而只是向我发送内存地址，我实际上无法重建发送的数据（即使在同一台机器上，我们也有两个不同的虚拟内存空间，它们不一样）。所以本质上，指针只是对发起者的一个很好的映射。

最后，就“结构中的结构”而言，每个结构都需要有几个函数。也就是说，您可以重用这些功能。例如，如果我有两个结构体A和Bwhere Acontains B，我可以有两个序列化方法：

char* serializeB()
{
  // ... Do serialization
}

char* serializeA()
{
  char* B = serializeB();
  // ... Either add on to serialized version of B or do some other modifications to combine the structures
}

因此，您应该能够为每个结构体使用单个序列化方法。