如何在C++程序内部读取自身进程的stdout输出？

当你没法修改some_function的定义（它只能打印到stdout而非返回结果）时，通过管道重定向stdout是最可靠的解决方案。核心思路是临时将stdout指向管道的写端，调用目标函数后从管道读端取出输出，最后恢复原stdout。

完整代码示例 #

#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <iostream>
#include <string>
#include <cstring>
#include <stdexcept>

void some_function() {
    // 模拟无法修改的目标函数，输出内容到stdout
    std::cout << "Hello from some_function!" << std::endl;
    std::cout << "Another line of output." << std::endl;
}

std::string capture_stdout() {
    // 1. 保存原始的stdout文件描述符，用于后续恢复
    int original_stdout = dup(STDOUT_FILENO);
    if (original_stdout == -1) {
        throw std::runtime_error("Failed to duplicate stdout: " + std::string(strerror(errno)));
    }

    int pipefd[2];
    // 2. 创建匿名管道，pipefd[0]是读端，pipefd[1]是写端
    if (pipe(pipefd) == -1) {
        close(original_stdout);
        throw std::runtime_error("Failed to create pipe: " + std::string(strerror(errno)));
    }

    try {
        // 3. 将stdout重定向到管道的写端
        if (dup2(pipefd[1], STDOUT_FILENO) == -1) {
            throw std::runtime_error("Failed to redirect stdout: " + std::string(strerror(errno)));
        }
        // 关闭管道写端的冗余引用（stdout已经指向它了）
        close(pipefd[1]);

        // 4. 调用目标函数，此时它的输出会写入管道
        some_function();
        // 关键：刷新C++标准输出缓冲区，确保所有内容都写入管道
        std::cout.flush();

        // 5. 从管道读端读取内容
        std::string captured_output;
        char buffer[1024];
        ssize_t bytes_read;
        while ((bytes_read = read(pipefd[0], buffer, sizeof(buffer)-1)) > 0) {
            buffer[bytes_read] = '\0';
            captured_output += buffer;
        }
        if (bytes_read == -1) {
            throw std::runtime_error("Failed to read from pipe: " + std::string(strerror(errno)));
        }

        // 6. 恢复原始的stdout
        if (dup2(original_stdout, STDOUT_FILENO) == -1) {
            throw std::runtime_error("Failed to restore stdout: " + std::string(strerror(errno)));
        }

        // 清理文件描述符
        close(original_stdout);
        close(pipefd[0]);

        return captured_output;
    } catch (...) {
        // 异常时确保关闭所有打开的文件描述符，避免资源泄漏
        close(pipefd[0]);
        close(pipefd[1]);
        close(original_stdout);
        throw;
    }
}

int main() {
    try {
        std::string output = capture_stdout();
        std::cout << "Captured output from some_function:\n" << output << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    return 0;
}

关键细节说明 #

• 保存并恢复stdout：用dup(STDOUT_FILENO)复制原始stdout的文件描述符，后续通过dup2恢复，避免影响程序后续的正常输出。
• 管道的使用：匿名管道pipe()创建的一对文件描述符，写端绑定到stdout后，所有输出会流入管道，我们从读端读取即可。
• 刷新C++缓冲区：std::cout是带缓冲的，默认可能不会立即写入管道，所以调用some_function后必须手动调用std::cout.flush()，确保所有输出都被写入管道。
• 错误处理：所有系统调用（dup、pipe、dup2、read）都可能失败，需要检查返回值并处理异常，同时确保文件描述符被正确关闭，避免资源泄漏。

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