通过C中的套接字传递带有整数数组的结构

我想将结构传递到C中的套接字上。我在这里了解到：

但我的问题是，我有一个整数结构数组的内部，我不知道如何序列化和反序列化它，有什么建议吗

struct packet{
    int id;
    char buffer[512];
    int array[4];
}

序列化函数，它正在工作，但缺少整数数组

size_t encode_pack(packet pack, char *buf){

    size_t pack_len;
    unsigned char *pt = buf;
    *pt++ = (pack.id  >> 24) & 255 ;
    *pt++ = (pack.id  >> 16)& 255;
    *pt++ = (pack.id >> 8) & 255;
    *pt++ = (pack.id & 255);

    strcpy(pt,pack.buffer);
    pt += strlen(pack.buffer)+1;
    pack_len = sizeof(pack.id) + strlen(pack.buffer); 

    return pack_len;

}

---

因为数组的大小在编译时是已知的，所以可以将其视为给定示例中的结构

想想

char缓冲区[512]，出于您的目的，与
char buffer0，buffer1，buffer2，…，buffer511相同

另外，使用
sizeof（struct packet）
仍然有效，因为数组大小在编译时已知，编译器在计算总结构大小时可以将其考虑在内。
因为数组大小在编译时已知，所以可以将其视为给定示例中的结构

想想
char缓冲区[512]，出于您的目的，与
char buffer0，buffer1，buffer2，…，buffer511相同

另外，使用
sizeof（struct packet）
仍然有效，因为数组大小在编译时已知，编译器在计算总结构大小时可以将其考虑在内。
因为数组大小在编译时已知，所以可以将其视为给定示例中的结构

想想
char缓冲区[512]，出于您的目的，与
char buffer0，buffer1，buffer2，…，buffer511相同

另外，使用
sizeof（struct packet）
仍然有效，因为数组大小在编译时已知，编译器在计算总结构大小时可以将其考虑在内。
因为数组大小在编译时已知，所以可以将其视为给定示例中的结构

想想
char缓冲区[512]，出于您的目的，与
char buffer0，buffer1，buffer2，…，buffer511相同

此外，使用
sizeof（struct packet）
仍然有效-同样，由于数组大小在编译时已知，编译器在计算总结构大小时可以考虑它们。
您可以这样发送：

struct packet p;
int socket;
// Todo: Get socket, initialize/populate p
int temp=hton(p.id);
send(socket,&temp,sizeof(temp),0);
send(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    temp=hton(p.array[i]);
    send(socket,&temp,sizeof(temp),0);
}
// Todo: Check send calls to make sure they succeed

struct packet p;
int socket;
// Todo: Get socket
int temp;
recv(socket,&temp,sizeof(temp),0);
p.id=ntoh(temp);
recv(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    recv(socket,&temp,sizeof(temp),0);
    p.array[i]=ntoh(temp);
}
// Todo: Check return value of recv calls to make sure data actually received

struct包p；
int插座；
//Todo:获取套接字，初始化/填充
内部温度=hton（p.id）；
发送（socket和temp，sizeof（temp），0）；
发送（套接字，p.buffer，sizeof（p.buffer），0）；
对于（size_t i=0；i您可以这样发送：

struct packet p;
int socket;
// Todo: Get socket, initialize/populate p
int temp=hton(p.id);
send(socket,&temp,sizeof(temp),0);
send(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    temp=hton(p.array[i]);
    send(socket,&temp,sizeof(temp),0);
}
// Todo: Check send calls to make sure they succeed

struct packet p;
int socket;
// Todo: Get socket
int temp;
recv(socket,&temp,sizeof(temp),0);
p.id=ntoh(temp);
recv(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    recv(socket,&temp,sizeof(temp),0);
    p.array[i]=ntoh(temp);
}
// Todo: Check return value of recv calls to make sure data actually received

struct包p；
int插座；
//Todo:获取套接字，初始化/填充
内部温度=hton（p.id）；
发送（socket和temp，sizeof（temp），0）；
发送（套接字，p.buffer，sizeof（p.buffer），0）；
对于（size_t i=0；i您可以这样发送：

struct packet p;
int socket;
// Todo: Get socket, initialize/populate p
int temp=hton(p.id);
send(socket,&temp,sizeof(temp),0);
send(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    temp=hton(p.array[i]);
    send(socket,&temp,sizeof(temp),0);
}
// Todo: Check send calls to make sure they succeed

struct packet p;
int socket;
// Todo: Get socket
int temp;
recv(socket,&temp,sizeof(temp),0);
p.id=ntoh(temp);
recv(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    recv(socket,&temp,sizeof(temp),0);
    p.array[i]=ntoh(temp);
}
// Todo: Check return value of recv calls to make sure data actually received

struct包p；
int插座；
//Todo:获取套接字，初始化/填充
内部温度=hton（p.id）；
发送（socket和temp，sizeof（temp），0）；
发送（套接字，p.buffer，sizeof（p.buffer），0）；
对于（size_t i=0；i您可以这样发送：

struct packet p;
int socket;
// Todo: Get socket, initialize/populate p
int temp=hton(p.id);
send(socket,&temp,sizeof(temp),0);
send(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    temp=hton(p.array[i]);
    send(socket,&temp,sizeof(temp),0);
}
// Todo: Check send calls to make sure they succeed

struct packet p;
int socket;
// Todo: Get socket
int temp;
recv(socket,&temp,sizeof(temp),0);
p.id=ntoh(temp);
recv(socket,p.buffer,sizeof(p.buffer),0);
for (size_t i=0;i<4;++i) {
    recv(socket,&temp,sizeof(temp),0);
    p.array[i]=ntoh(temp);
}
// Todo: Check return value of recv calls to make sure data actually received

struct包p；
int插座；
//Todo:获取套接字，初始化/填充
内部温度=hton（p.id）；
发送（socket和temp，sizeof（temp），0）；
发送（套接字，p.buffer，sizeof（p.buffer），0）；
对于（size_t i=0；ii，如果您不关心字节顺序（例如，如果套接字指的是本地计算机）
struct packet pack；res=write（fd，&pack，sizeof pack）；
，或者等效项，如果您不关心字节顺序，trickI应该用示例代码更新我的问题吗（例如，如果套接字指向本地计算机）
struct packet pack；res=write（fd，&pack，sizeof pack）；
，或等效程序，如果您不关心字节顺序（例如，如果套接字指向本地计算机）
struct packet pack；res=write，trickI应该用示例代码更新我的问题吗（fd，&pack，sizeof-pack）；
或同等版本，如果您不关心字节顺序（例如，如果套接字指的是本地计算机）
struct-packet-pack；res=write（fd，&pack，sizeof-pack）
，或同等的，trickI用示例代码更新了我的问题乍一看，这似乎不必要的复杂。但是，这解决了结构布局和端点的差异问题。+1另外，可能值得指出的是，
hton
和
ntoh
可能指的是函数族ns-实际函数本身有一个
s
或
l
前缀。我编辑了答案，包括一个关于
hton
和
ntoh
的注释，以及一个指向文档的链接。我不想单独发送和接收结构的每个成员，因此我不接受这种解决方案事实上，这是必须的。由于结构的成员之间可能存在垃圾，并且结构可能在不同的机器上以不同的方式在内存中布局。您可以进入编译器扩展领域并尝试使用该结构，但这应该被认为是有害的/避免的，因为它sn不可移植，也不是标准的C。乍一看，这似乎不必要的复杂。但是，这解决了结构布局和端点的差异问题。+1另外，可能值得指出的是，
hton
和
ntoh
可能指的是函数族-实际函数本身有一个
s
或者
l
前缀。我已经编辑了答案，包括关于
hton
和
ntoh
的注释，以及文档链接。我不想单独发送和接收结构的每个成员，因此我不能接受此解决方案。不幸的是，这是必须的。由于结构的成员之间可能存在垃圾，并且结构可能在不同的计算机上的内存中被不同的布局