父子进程管道通信：如何动态存储并回传字符统计数据

首先，你不需要把统计值转成字符串再发送——直接用固定大小的整数数组打包数据，通过管道传输二进制内容是最简洁高效的方式，完全不需要担心“数组长度未知”的问题，因为我们可以提前确定要发送的数据数量。

核心思路 #

你要发送的是6个整数：1个总次数 + 5个单独字符的统计次数。我们可以把这些值塞进一个int数组里，直接通过write把整个数组的二进制数据写入管道；父进程则读取固定长度的字节，再解析成同样的数组，就能直接拿到每个统计值。

修正你原有代码的问题 #

先提个关键错误：你原来的read判断括号位置错了！

// 错误写法：会把比较结果（0或1）赋值给number
number = read(pipe1[0], &character, 1) > 0
// 正确写法：先赋值，再判断是否大于0
(number = read(pipe1[0], &character, 1)) > 0

这个错误会导致你统计的number不是实际读取的字节数（虽然这里每次读1字节，结果巧合可能对，但逻辑上是错的，遇到读错误会误判）。

完整实现示例 #

子进程代码（统计+发送）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <time.h>

int main() {
    // 假设pipe1[0]是子进程的读端，pipe2[1]是子进程的写端（需在fork前创建管道）
    int stats[5] = {0}; // 存储5个字符的统计次数
    int pipe2_write_fd = pipe2[1];

    while (1) {
        // 重置统计数组，准备统计当前1秒的字符
        memset(stats, 0, sizeof(stats));
        time_t start_time = time(NULL);

        // 读取pipe1的数据，直到1秒结束
        while (difftime(time(NULL), start_time) < 1) {
            char caracter;
            ssize_t read_bytes;
            if ((read_bytes = read(pipe1[0], &caracter, 1)) > 0) {
                // 这里要根据你的字符映射逻辑调整，比如caracter是0-4的索引
                // 务必确保caracter的范围不会越界访问stats数组
                if (caracter >= 0 && caracter < 5) {
                    stats[caracter]++;
                }
            } else if (read_bytes == 0) {
                // pipe1的写端被父进程关闭，没有数据了，退出循环
                break;
            } else {
                perror("读取pipe1失败");
                exit(EXIT_FAILURE);
            }
        }

        // 打包要发送的数据：总次数 + 5个单独统计值
        int send_data[6];
        send_data[0] = stats[0] + stats[1] + stats[2] + stats[3] + stats[4];
        memcpy(&send_data[1], stats, sizeof(stats)); // 把stats复制到send_data的第1位开始

        // 发送到pipe2
        ssize_t write_bytes = write(pipe2_write_fd, send_data, sizeof(send_data));
        if (write_bytes != sizeof(send_data)) {
            perror("写入pipe2失败");
            exit(EXIT_FAILURE);
        }

        // 如果pipe1已经关闭，退出子进程
        if (read_bytes == 0) {
            break;
        }
    }

    close(pipe2_write_fd);
    close(pipe1[0]);
    return 0;
}

父进程代码（接收+打印）

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

int main() {
    // 假设pipe2[0]是父进程的读端
    int pipe2_read_fd = pipe2[0];
    int recv_data[6];
    int second_count = 0;

    while (1) {
        ssize_t read_bytes = read(pipe2_read_fd, recv_data, sizeof(recv_data));
        if (read_bytes == 0) {
            // pipe2的写端被子进程关闭，结束接收
            break;
        } else if (read_bytes < 0) {
            perror("读取pipe2失败");
            exit(EXIT_FAILURE);
        }

        second_count++;
        // 单独打印每秒的统计结果
        printf("第%d秒统计：\n", second_count);
        printf("总接收次数：%d\n", recv_data[0]);
        printf("字符0：%d，字符1：%d，字符2：%d，字符3：%d，字符4：%d\n\n",
               recv_data[1], recv_data[2], recv_data[3], recv_data[4], recv_data[5]);
    }

    close(pipe2_read_fd);
    return 0;
}

关键注意事项 #

1. 管道创建时机：必须在fork()之前创建pipe1和pipe2，这样父子进程才能共享管道的文件描述符。
2. 字符映射逻辑：你需要确保caracter的值能正确对应stats数组的索引（比如如果是字符'a'-'e'，可以转成caracter - 'a'得到0-4的索引），避免数组越界。
3. 二进制传输的优势：相比转字符串，直接传二进制整数不需要格式化/解析字符串，速度更快，也不会出现格式错误（比如整数转字符串时的位数问题）。

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