如何通过dup2将execvp的输出捕获并存入字符串？

没问题，我来一步步帮你搞定这个需求！你已经搭好了管道的基础框架，接下来只需要通过dup2重定向子进程的标准输出到管道，再在父进程里读取管道内容，最后完成字符串拼接就行。

核心步骤拆解 #

• 子进程端：把stdout重定向到管道的写端，这样execvp的输出就会流入管道而不是终端。
• 父进程端：从管道的读端读取输出内容，存入globalString，再和myString拼接。

完整代码实现 #

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

char* globalString; // 要存入输出的全局字符串
char* myString = "one two three ";
char* append = "echo four";
int myPipe[2]; // 管道

int main() {
    // 创建管道，先检查是否成功
    if (pipe(myPipe) == -1) {
        perror("pipe failed");
        exit(EXIT_FAILURE);
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork failed");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // -------------------------- 子进程逻辑 --------------------------
        // 关闭管道读端（子进程只需要写）
        close(myPipe[0]);

        // 用dup2把stdout(文件描述符1)重定向到管道写端myPipe[1]
        if (dup2(myPipe[1], STDOUT_FILENO) == -1) {
            perror("dup2 failed");
            exit(EXIT_FAILURE);
        }

        // 重定向完成后，关闭原来的管道写端（不再需要）
        close(myPipe[1]);

        // 拆分命令字符串为execvp需要的argv数组
        // 这里append是"echo four"，拆成{"echo", "four", NULL}
        char *argv[] = {"echo", "four", NULL};
        // 调用execvp，注意第一个参数是命令名，第二个是argv数组
        execvp(argv[0], argv);

        // 如果execvp返回了，说明执行失败
        perror("execvp failed");
        exit(EXIT_FAILURE);
    } else {
        // -------------------------- 父进程逻辑 --------------------------
        // 关闭管道写端（父进程只需要读）
        close(myPipe[1]);

        // 定义缓冲区读取管道内容，这里设1024足够应对小输出
        char buffer[1024];
        ssize_t bytesRead;
        // 先初始化globalString为空字符串
        globalString = malloc(1);
        globalString[0] = '\0';

        // 循环读取管道内容，直到读完（read返回0）
        while ((bytesRead = read(myPipe[0], buffer, sizeof(buffer)-1)) > 0) {
            // 给缓冲区加结束符
            buffer[bytesRead] = '\0';
            // 去掉echo输出的换行符（如果有的话）
            buffer[strcspn(buffer, "\n")] = '\0';

            // 重新分配globalString的内存，容纳原有内容+新读取的内容
            size_t newSize = strlen(globalString) + strlen(buffer) + 1;
            globalString = realloc(globalString, newSize);
            if (!globalString) {
                perror("realloc failed");
                exit(EXIT_FAILURE);
            }
            // 把新内容追加到globalString
            strcat(globalString, buffer);
        }

        // 关闭管道读端
        close(myPipe[0]);
        // 等待子进程结束，避免僵尸进程
        wait(NULL);

        // 拼接myString和globalString
        size_t totalSize = strlen(myString) + strlen(globalString) + 1;
        char* newMyString = malloc(totalSize);
        if (!newMyString) {
            perror("malloc failed");
            exit(EXIT_FAILURE);
        }
        strcpy(newMyString, myString);
        strcat(newMyString, globalString);

        // 更新myString（注意这里如果原来的myString是静态字符串，不能直接修改，所以用新分配的内存）
        // 如果你原来的myString是动态分配的，记得先free旧的
        myString = newMyString;

        // 测试输出，应该是"one two three four"
        printf("拼接后的字符串：%s\n", myString);

        // 最后记得释放内存，避免泄漏
        free(globalString);
        free(myString);
    }

    return 0;
}

关键细节说明 #

1. 管道的两端管理：子进程必须关闭读端，父进程必须关闭写端，否则管道不会被标记为“EOF”，父进程的read会一直阻塞。
2. dup2的作用：dup2(myPipe[1], STDOUT_FILENO)会把标准输出的文件描述符（1）替换成管道的写端，这样所有原本输出到终端的内容都会流入管道。
3. 字符串处理：读取管道内容时要注意去掉echo自带的换行符，不然拼接后会有多余的换行；另外内存分配要足够，用realloc动态扩展globalString的空间。
4. 错误处理：每个系统调用（pipe、fork、dup2、execvp、read、malloc等）都要检查返回值，避免程序崩溃或出现未知问题。

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