如何在C语言中用fork、pipe、execvp实现stdout重定向及Shell管道？

我完全懂你现在的困境——自己写Shell的管道逻辑，既要让ls -l的输出流给grep toto，还得让最终结果由父进程打印出来，而不是让执行grep的子进程直接输出到终端。用两次fork的思路是对的，但大概率是管道文件描述符管理、进程同步或者输出捕获的环节出了问题。下面我一步步给你拆解正确的实现方式，还有你可能踩过的坑。

核心思路拆解 #

要实现你的需求，我们需要两个管道：

1. 第一个管道（pipe1）：连接ls -l的标准输出和grep toto的标准输入，让两个命令的数据流打通。
2. 第二个管道（pipe2）：连接grep toto的标准输出和父进程的标准输入，这样父进程就能捕获grep的结果，再自己打印。

然后通过两次fork创建两个子进程分别执行两个命令，父进程负责等待子进程结束、读取pipe2的内容并输出。

关键步骤&避坑点 #

1. 先创建两个管道 #

用pipe()函数创建管道时，会得到一对文件描述符：fd[0]是读端，fd[1]是写端。一定要检查pipe()的返回值，避免创建失败。

2. 第一个子进程（执行ls -l） #

• 把它的标准输出（STDOUT_FILENO）重定向到pipe1的写端（pipe1[1]），用dup2()实现。
• 必须关闭所有不需要的文件描述符：pipe1的读端（pipe1[0]）、pipe2的两端（这个子进程用不上）。如果不关闭，会导致后续进程的read操作一直阻塞（因为管道的写/读端还有其他进程打开着，不会触发EOF）。
• 用execvp()执行ls -l，注意参数数组要以NULL结尾。

3. 第二个子进程（执行grep toto） #

• 把它的标准输入（STDIN_FILENO）重定向到pipe1的读端（pipe1[0]），这样就能读取ls -l的输出。
• 把它的标准输出（STDOUT_FILENO）重定向到pipe2的写端（pipe2[1]），让父进程能从pipe2的读端获取结果。
• 同样要关闭所有不需要的文件描述符：pipe1的写端（pipe1[1]）、pipe2的读端（pipe2[0]）。

4. 父进程的收尾操作 #

• 关闭所有管道的无关端：pipe1的两端（父进程不需要读写pipe1）、pipe2的写端（父进程只需要读pipe2）。
• 用waitpid()等待两个子进程结束，避免僵尸进程。
• 从pipe2的读端循环读取数据，直到read()返回0（表示EOF），然后把读取到的内容打印到终端——这就实现了父进程显示结果的需求。

完整示例代码 #

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

#define BUFFER_SIZE 1024

int main() {
    int pipe1[2], pipe2[2];
    pid_t pid1, pid2;
    char buffer[BUFFER_SIZE];
    ssize_t bytes_read;

    // 创建第一个管道：ls -> grep
    if (pipe(pipe1) == -1) {
        perror("pipe1 failed");
        exit(EXIT_FAILURE);
    }

    // 创建第二个管道：grep -> 父进程
    if (pipe(pipe2) == -1) {
        perror("pipe2 failed");
        close(pipe1[0]);
        close(pipe1[1]);
        exit(EXIT_FAILURE);
    }

    // 第一个子进程：执行 ls -l
    pid1 = fork();
    if (pid1 == -1) {
        perror("fork1 failed");
        close(pipe1[0]);
        close(pipe1[1]);
        close(pipe2[0]);
        close(pipe2[1]);
        exit(EXIT_FAILURE);
    }

    if (pid1 == 0) {
        // 重定向stdout到pipe1写端
        if (dup2(pipe1[1], STDOUT_FILENO) == -1) {
            perror("dup2 stdout to pipe1 failed");
            exit(EXIT_FAILURE);
        }

        // 关闭无关文件描述符
        close(pipe1[0]);
        close(pipe1[1]);
        close(pipe2[0]);
        close(pipe2[1]);

        // 执行命令
        char *args[] = {"ls", "-l", NULL};
        execvp(args[0], args);
        perror("execvp ls failed"); // 走到这里说明execvp出错了
        exit(EXIT_FAILURE);
    }

    // 第二个子进程：执行 grep toto
    pid2 = fork();
    if (pid2 == -1) {
        perror("fork2 failed");
        close(pipe1[0]);
        close(pipe1[1]);
        close(pipe2[0]);
        close(pipe2[1]);
        waitpid(pid1, NULL, 0); // 清理第一个子进程，避免僵尸
        exit(EXIT_FAILURE);
    }

    if (pid2 == 0) {
        // 重定向stdin到pipe1读端
        if (dup2(pipe1[0], STDIN_FILENO) == -1) {
            perror("dup2 stdin from pipe1 failed");
            exit(EXIT_FAILURE);
        }

        // 重定向stdout到pipe2写端
        if (dup2(pipe2[1], STDOUT_FILENO) == -1) {
            perror("dup2 stdout to pipe2 failed");
            exit(EXIT_FAILURE);
        }

        // 关闭无关文件描述符
        close(pipe1[0]);
        close(pipe1[1]);
        close(pipe2[0]);
        close(pipe2[1]);

        // 执行命令
        char *args[] = {"grep", "toto", NULL};
        execvp(args[0], args);
        perror("execvp grep failed");
        exit(EXIT_FAILURE);
    }

    // 父进程操作
    // 关闭所有管道的无关端
    close(pipe1[0]);
    close(pipe1[1]);
    close(pipe2[1]);

    // 等待两个子进程完成
    waitpid(pid1, NULL, 0);
    waitpid(pid2, NULL, 0);

    // 读取grep的输出并打印（父进程显示结果）
    while ((bytes_read = read(pipe2[0], buffer, BUFFER_SIZE - 1)) > 0) {
        buffer[bytes_read] = '\0'; // 确保字符串终止
        printf("%s", buffer);
    }

    if (bytes_read == -1) {
        perror("read from pipe2 failed");
    }

    close(pipe2[0]);

    return EXIT_SUCCESS;
}

你可能踩过的坑 #

1. 没有关闭多余的管道描述符：这是管道阻塞的最常见原因。比如父进程没关闭pipe1的写端，那么grep进程的read()会一直等待，因为系统认为还有进程可能往pipe1里写数据，不会触发EOF。
2. 只用了一个管道：如果只创建一个管道，父进程读取的是ls -l的原始输出，而不是经过grep过滤后的结果，不符合需求。
3. 等待子进程的顺序错误：如果先等第二个子进程再等第一个，可能会出现僵尸进程的问题，最好用waitpid()分别等待，或者循环调用wait()直到所有子进程结束。
4. 尝试用变量存储第一个命令的输出：这其实没必要，管道是流式的，直接让两个子进程通过管道通信更高效，也符合Shell管道的设计逻辑。

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