C语言客户端/服务端FIFO传递含动态数组结构体的问题排查

嘿，这个问题我太熟了——跨进程传递带动态数组的结构体，踩过的坑能列一串！咱们先理清楚问题根源，再给你解决步骤：

为什么指针传递直接失效？ #

FIFO（命名管道）传递的是原始字节数据，不是内存地址！客户端进程里的pref_seat_list指针，指向的是客户端自己地址空间里的内存，服务端进程有完全独立的地址空间，拿到这个指针后，指向的要么是服务端里的无效内存，要么是随机数据，肯定不可能拿到客户端的数组内容。这是跨进程通信的核心常识——绝对不能传递指针，必须传递数据本身。

柔性数组为啥还是出随机值？ #

你改用柔性数组（FAM）的思路是对的，但大概率是发送/接收时没处理好总数据长度，或者内存分配、填充的姿势不对。柔性数组的本质是把结构体和数组数据连续存在一块内存里，但如果只发送结构体的头部，没把后面的数组数据发过去，服务端自然只能读到随机值。

1. 定义带柔性数组的结构体 #

首先要给结构体加一个字段记录数组元素的个数，不然服务端根本不知道要读多少数据：

// 建议强制1字节对齐，避免跨编译器的内存布局差异
#pragma pack(1)
typedef struct {
    int seat_count;  // 记录柔性数组的元素个数
    int pref_seats[]; // 柔性数组，存放座位号
} SeatRequest;
#pragma pack()

2. 客户端：分配内存+填充数据+发送 #

客户端需要分配结构体大小 + 柔性数组元素总大小的内存，然后一次性发送所有数据：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    int desired_seats[] = {3, 7, 12, 15}; // 示例数组
    int seat_num = sizeof(desired_seats)/sizeof(int);

    // 分配总内存：结构体头部 + 数组字节数
    SeatRequest *req = malloc(sizeof(SeatRequest) + seat_num * sizeof(int));
    if (!req) {
        perror("malloc failed");
        return 1;
    }

    // 填充数据
    req->seat_count = seat_num;
    for (int i = 0; i < seat_num; i++) {
        req->pref_seats[i] = desired_seats[i];
    }

    // 打开FIFO并发送全部数据
    int fifo_fd = open("seat_request_fifo", O_WRONLY);
    if (fifo_fd == -1) {
        perror("open fifo failed");
        free(req);
        return 1;
    }

    // 关键：发送的是总字节数，不是结构体头部大小！
    ssize_t sent = write(fifo_fd, req, sizeof(SeatRequest) + seat_num * sizeof(int));
    if (sent == -1) {
        perror("write failed");
    }

    close(fifo_fd);
    free(req);
    return 0;
}

3. 服务端：接收数据+解析+处理 #

服务端需要先拿到seat_count，再分配足够的内存接收完整数据：

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 创建FIFO（如果还没创建）
    mkfifo("seat_request_fifo", 0666);

    int fifo_fd = open("seat_request_fifo", O_RDONLY);
    if (fifo_fd == -1) {
        perror("open fifo failed");
        return 1;
    }

    // 步骤1：先读取seat_count，确定数组长度
    int seat_count;
    ssize_t read_len = read(fifo_fd, &seat_count, sizeof(int));
    if (read_len == -1) {
        perror("read seat count failed");
        close(fifo_fd);
        return 1;
    }

    // 步骤2：分配总内存
    SeatRequest *req = malloc(sizeof(SeatRequest) + seat_count * sizeof(int));
    if (!req) {
        perror("malloc failed");
        close(fifo_fd);
        return 1;
    }
    req->seat_count = seat_count;

    // 步骤3：读取柔性数组的内容
    read_len = read(fifo_fd, req->pref_seats, seat_count * sizeof(int));
    if (read_len == -1) {
        perror("read seat data failed");
        free(req);
        close(fifo_fd);
        return 1;
    }

    // 现在可以正常处理数据了
    printf("Received %d preferred seats:\n", req->seat_count);
    for (int i = 0; i < req->seat_count; i++) {
        printf("Seat %d: %d\n", i+1, req->pref_seats[i]);
    }

    free(req);
    close(fifo_fd);
    return 0;
}

因为多个客户端写同一个FIFO时，数据可能会被拼接在一起（FIFO是流式的），所以建议给每个请求加一个总长度前缀，避免粘包问题：

#pragma pack(1)
typedef struct {
    int total_len;   // 整个请求的总字节数（包括total_len本身）
    int seat_count;
    int pref_seats[];
} SeatRequest;
#pragma pack()

客户端计算total_len = sizeof(SeatRequest) + seat_num * sizeof(int) + sizeof(int);（因为多了一个total_len字段），发送时先写total_len，再写整个结构体；服务端先读total_len，再读对应字节数的内容，这样就能准确拆分每个客户端的请求。

内容的提问来源于stack exchange，提问作者GRoutar