多进程管道实现大小写转换程序未完成转换且无输出到文件的问题排查

嘿，我帮你梳理下代码里的几个关键问题，这些问题合起来导致了程序没完成大小写转换，也没输出到文件：

核心问题1：管道根本没初始化 #

你定义了fd1[2]和fd2[2]两个管道数组，但完全没调用pipe()函数创建管道！管道是需要通过pipe()系统调用初始化的，否则这些文件描述符都是无效的，读写操作根本不会往管道里传输数据——子进程读不到内容，自然没法做转换，后续的输出也无从谈起。

问题2：管道关闭时机混乱 #

• 父进程在第一次循环里就close(fd1[1])，直接关闭了管道的写端，后续循环再想往管道写数据就彻底失败了。
• 子进程里的管道关闭逻辑也有问题，比如ChildProcess1先close(fd1[1])，但此时父进程还没开始写数据，而且管道本身没初始化，这一步完全没有意义。

问题3：进程执行顺序与等待逻辑错误 #

你先fork出两个子进程，再进入父进程的读文件循环。但此时ChildProcess1已经在尝试读空管道（会阻塞），ChildProcess2也在等fd2[0]的数据。而父进程的wait(NULL)只会等待任意一个子进程结束，第一次wait可能直接等ChildProcess1结束，后续循环的逻辑完全混乱，根本没法持续处理数据。

问题4：文件操作的潜在坑 #

• 你没检查fopen()的返回值，如果input.txt不存在或者output.txt无法写入，程序会默默出错，你根本不知道。
• ChildProcess2里的fprintf没有刷新缓冲区，子进程退出时可能还没把内容写入文件，导致输出文件为空。

修正后的完整代码 #

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
#include <ctype.h>

int main() {
    pid_t ChildProcess1, ChildProcess2;
    int fd1[2], fd2[2];
    FILE *inputFile, *outputFile;

    // 初始化两个管道，必须检查返回值
    if (pipe(fd1) == -1 || pipe(fd2) == -1) {
        perror("pipe failed");
        exit(EXIT_FAILURE);
    }

    // 打开文件，检查是否成功
    inputFile = fopen("input.txt", "r");
    if (!inputFile) {
        perror("open input.txt failed");
        exit(EXIT_FAILURE);
    }
    outputFile = fopen("output.txt", "w");
    if (!outputFile) {
        perror("open output.txt failed");
        fclose(inputFile);
        exit(EXIT_FAILURE);
    }

    // 创建第一个子进程：负责大小写转换
    ChildProcess1 = fork();
    if (ChildProcess1 == -1) {
        perror("fork child1 failed");
        exit(EXIT_FAILURE);
    }

    if (ChildProcess1 == 0) {
        // 子进程1：关闭不需要的管道端
        close(fd1[1]); // 关闭fd1的写端，只读
        close(fd2[0]); // 关闭fd2的读端，只写

        char string[500];
        ssize_t bytes_read;
        // 循环读取管道数据，直到父进程关闭写端
        while ((bytes_read = read(fd1[0], string, sizeof(string)-1)) > 0) {
            string[bytes_read] = '\0'; // 确保字符串结束符
            // 大小写转换逻辑
            for (int i = 0; string[i] != '\0'; i++) {
                char c = string[i];
                if (islower(c)) {
                    string[i] = toupper(c);
                } else if (isupper(c)) {
                    string[i] = tolower(c);
                }
                // 非字母字符直接保留，去掉多余提示避免干扰输出
            }
            // 把转换后的内容写入第二个管道
            write(fd2[1], string, strlen(string));
            memset(string, 0, sizeof(string));
        }

        // 关闭子进程1的管道端
        close(fd1[0]);
        close(fd2[1]);
        exit(EXIT_SUCCESS);
    }

    // 创建第二个子进程：负责写入输出文件
    ChildProcess2 = fork();
    if (ChildProcess2 == -1) {
        perror("fork child2 failed");
        waitpid(ChildProcess1, NULL, 0); // 避免僵尸进程
        exit(EXIT_FAILURE);
    }

    if (ChildProcess2 == 0) {
        // 子进程2：关闭不需要的管道端
        close(fd1[0]);
        close(fd1[1]);
        close(fd2[1]); // 关闭fd2的写端，只读

        char string[500];
        ssize_t bytes_read;
        // 循环读取管道数据，直到子进程1关闭写端
        while ((bytes_read = read(fd2[0], string, sizeof(string)-1)) > 0) {
            string[bytes_read] = '\0';
            fprintf(outputFile, "%s", string);
            fflush(outputFile); // 强制刷新缓冲区，确保写入文件
            printf("%s", string); // 同时打印到控制台
            memset(string, 0, sizeof(string));
        }

        // 关闭子进程2的管道端
        close(fd2[0]);
        exit(EXIT_SUCCESS);
    }

    // 父进程：关闭不需要的管道端
    close(fd1[0]);
    close(fd2[0]);
    close(fd2[1]);

    // 父进程读取input.txt，写入第一个管道
    char string[500];
    while (fgets(string, sizeof(string), inputFile) != NULL) {
        write(fd1[1], string, strlen(string));
        memset(string, 0, sizeof(string));
    }

    // 关闭fd1的写端，通知子进程1没有数据了
    close(fd1[1]);

    // 等待两个子进程都结束
    waitpid(ChildProcess1, NULL, 0);
    waitpid(ChildProcess2, NULL, 0);

    // 关闭文件
    fclose(inputFile);
    fclose(outputFile);

    return 0;
}

关键修改点说明 #

1. 新增管道初始化：调用pipe()创建管道，并检查返回值，确保管道可用。
2. 修正管道关闭逻辑：每个进程只保留需要的管道读写端，避免资源泄漏和错误。
3. 循环处理数据：子进程采用循环读取管道的方式，支持处理多行输入，而非只读取一次。
4. 完善错误检查：所有系统调用和文件操作都增加了错误检查，方便排查问题。
5. 强制文件刷新：子进程2里增加fflush(outputFile)，确保写入的内容立即刷新到文件。
6. 规范进程等待：父进程明确等待两个子进程结束，避免僵尸进程。

备注：内容来源于stack exchange，提问作者Thomas Kent