跨平台（优先Windows）C++创建子进程并实时获取输出方案问询

我来帮你搞定Windows下C++实时捕获子进程输出的问题，顺便也给你跨平台兼容的方案参考～

核心思路：WinAPI匿名管道+异步读取 #

通过WinAPI创建匿名管道重定向子进程的标准输出，结合异步读取+Observer模式，实时将子进程输出以字符串形式推送给主进程。

步骤拆解 #

1. 创建匿名管道，保证子进程能继承管道句柄
2. 配置子进程启动信息，将其stdout/stderr重定向到管道写端
3. 启动子进程后关闭主进程侧的管道写端（避免管道无法正常关闭）
4. 异步循环读取管道读端数据，通过Observer接口实时通知主进程

完整代码实现 #

首先定义Observer接口，用于输出回调：

#include <functional>
#include <string>

class OutputObserver {
public:
    virtual void onNewOutput(const std::string& output) = 0;
    virtual ~OutputObserver() = default;
};

然后是Pipe类的具体实现：

#include <windows.h>
#include <iostream>
#include <stdexcept>
#include <future>
#include <vector>

namespace pipe {
class Pipe {
private:
    HANDLE hReadPipe = nullptr;
    HANDLE hWritePipe = nullptr;
    HANDLE hChildProcess = nullptr;
    OutputObserver* observer = nullptr;

    // 异步读取管道的工作函数
    void readPipeAsync() {
        char buffer[4096];
        DWORD bytesRead = 0;
        BOOL success = TRUE;

        while (success && hReadPipe != nullptr) {
            success = ReadFile(hReadPipe, buffer, sizeof(buffer) - 1, &bytesRead, nullptr);
            if (bytesRead > 0) {
                buffer[bytesRead] = '\0';
                // 若子进程输出为UTF-16，需用WideCharToMultiByte转换为UTF-8
                std::string output(buffer);
                if (observer) {
                    observer->onNewOutput(output);
                }
            }
            // 子进程退出后管道会断开，属于正常结束
            if (!success && GetLastError() != ERROR_BROKEN_PIPE) {
                throw std::runtime_error("Failed to read pipe");
            }
        }
    }

public:
    Pipe(OutputObserver* obs) : observer(obs) {}
    ~Pipe() {
        if (hReadPipe) CloseHandle(hReadPipe);
        if (hWritePipe) CloseHandle(hWritePipe);
        if (hChildProcess) CloseHandle(hChildProcess);
    }

    void syncMode(const std::string& cmd) {
        SECURITY_ATTRIBUTES sa;
        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.bInheritHandle = TRUE;
        sa.lpSecurityDescriptor = nullptr;

        // 创建匿名管道
        if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0)) {
            throw std::runtime_error("Failed to create pipe");
        }

        // 配置子进程启动信息，重定向输出
        STARTUPINFO si;
        ZeroMemory(&si, sizeof(STARTUPINFO));
        si.cb = sizeof(STARTUPINFO);
        si.hStdOutput = hWritePipe;
        si.hStdError = hWritePipe; // 同时重定向错误输出
        si.dwFlags |= STARTF_USESTDHANDLES;

        PROCESS_INFORMATION pi;
        ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

        // 转换命令为宽字符（适配CreateProcessW）
        std::wstring wideCmd(cmd.begin(), cmd.end());
        if (!CreateProcessW(nullptr, const_cast<wchar_t*>(wideCmd.c_str()), nullptr, nullptr, TRUE, 0, nullptr, nullptr, &si, &pi)) {
            throw std::runtime_error("Failed to create process");
        }

        // 主进程不再需要写端，关闭避免阻塞
        CloseHandle(hWritePipe);
        hWritePipe = nullptr;

        // 同步读取直到子进程结束
        readPipeAsync();

        // 等待子进程退出并清理句柄
        WaitForSingleObject(pi.hProcess, INFINITE);
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
        hChildProcess = nullptr;
    }

    void asyncMode(const std::string& cmd) {
        SECURITY_ATTRIBUTES sa;
        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.bInheritHandle = TRUE;
        sa.lpSecurityDescriptor = nullptr;

        if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0)) {
            throw std::runtime_error("Failed to create pipe");
        }

        STARTUPINFO si;
        ZeroMemory(&si, sizeof(STARTUPINFO));
        si.cb = sizeof(STARTUPINFO);
        si.hStdOutput = hWritePipe;
        si.hStdError = hWritePipe;
        si.dwFlags |= STARTF_USESTDHANDLES;

        PROCESS_INFORMATION pi;
        ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

        std::wstring wideCmd(cmd.begin(), cmd.end());
        if (!CreateProcessW(nullptr, const_cast<wchar_t*>(wideCmd.c_str()), nullptr, nullptr, TRUE, 0, nullptr, nullptr, &si, &pi)) {
            throw std::runtime_error("Failed to create process");
        }

        CloseHandle(hWritePipe);
        hWritePipe = nullptr;
        hChildProcess = pi.hProcess;
        CloseHandle(pi.hThread);

        // 用std::async启动异步读取任务
        std::async(std::launch::async, &Pipe::readPipeAsync, this);
    }

    // 检查子进程是否仍在运行
    bool isChildRunning() {
        if (!hChildProcess) return false;
        DWORD exitCode;
        GetExitCodeProcess(hChildProcess, &exitCode);
        return exitCode == STILL_ACTIVE;
    }
};
} // namespace pipe

主进程使用示例：

class MyObserver : public OutputObserver {
public:
    void onNewOutput(const std::string& output) override {
        std::cout << "[实时输出] " << output;
    }
};

int main() {
    try {
        MyObserver observer;
        pipe::Pipe pipe(&observer);

        // 异步启动子进程（比如持续输出的ping命令）
        pipe.asyncMode("ping -t localhost");

        // 主进程可执行其他逻辑，这里等待用户输入退出
        std::cout << "按下回车键退出..." << std::endl;
        std::cin.get();

        // 等待子进程结束（可选）
        while (pipe.isChildRunning()) {
            Sleep(100);
        }
    } catch (const std::exception& e) {
        std::cerr << "错误：" << e.what() << std::endl;
        return 1;
    }
    return 0;
}

关键注意点 #

• 句柄继承：创建管道时必须设置bInheritHandle = TRUE，否则子进程无法获取管道句柄
• 关闭多余句柄：主进程启动子进程后必须关闭管道写端，否则ReadFile会一直阻塞
• 编码转换：如果子进程输出是UTF-16格式，需要用WideCharToMultiByte转换为UTF-8字符串
• std::async的坑：若不保存std::async返回的std::future，主线程会阻塞等待异步任务完成，失去异步效果

如果需要同时支持Windows和Linux/macOS，可通过条件编译区分平台实现：

#include <functional>
#include <string>
#include <stdexcept>
#include <future>
#include <vector>

#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#endif

class OutputObserver {
public:
    virtual void onNewOutput(const std::string& output) = 0;
    virtual ~OutputObserver() = default;
};

namespace pipe {
class Pipe {
private:
#ifdef _WIN32
    HANDLE hReadPipe = nullptr;
    HANDLE hWritePipe = nullptr;
    HANDLE hChildProcess = nullptr;
#else
    int pipeFds[2];
    pid_t childPid = -1;
#endif
    OutputObserver* observer = nullptr;

    void readPipeAsync() {
#ifdef _WIN32
        char buffer[4096];
        DWORD bytesRead = 0;
        BOOL success = TRUE;

        while (success && hReadPipe != nullptr) {
            success = ReadFile(hReadPipe, buffer, sizeof(buffer) - 1, &bytesRead, nullptr);
            if (bytesRead > 0) {
                buffer[bytesRead] = '\0';
                std::string output(buffer);
                if (observer) observer->onNewOutput(output);
            }
            if (!success && GetLastError() != ERROR_BROKEN_PIPE) {
                throw std::runtime_error("Failed to read pipe");
            }
        }
#else
        char buffer[4096];
        ssize_t bytesRead = 0;
        while ((bytesRead = read(pipeFds[0], buffer, sizeof(buffer)-1)) > 0) {
            buffer[bytesRead] = '\0';
            std::string output(buffer);
            if (observer) observer->onNewOutput(output);
        }
        close(pipeFds[0]);
#endif
    }

public:
    Pipe(OutputObserver* obs) : observer(obs) {}
    ~Pipe() {
#ifdef _WIN32
        if (hReadPipe) CloseHandle(hReadPipe);
        if (hWritePipe) CloseHandle(hWritePipe);
        if (hChildProcess) CloseHandle(hChildProcess);
#else
        if (pipeFds[0] != -1) close(pipeFds[0]);
        if (pipeFds[1] != -1) close(pipeFds[1]);
#endif
    }

    void asyncMode(const std::string& cmd) {
#ifdef _WIN32
        SECURITY_ATTRIBUTES sa;
        sa.nLength = sizeof(SECURITY_ATTRIBUTES);
        sa.bInheritHandle = TRUE;
        sa.lpSecurityDescriptor = nullptr;

        if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0)) {
            throw std::runtime_error("Failed to create pipe");
        }

        STARTUPINFO si;
        ZeroMemory(&si, sizeof(STARTUPINFO));
        si.cb = sizeof(STARTUPINFO);
        si.hStdOutput = hWritePipe;
        si.hStdError = hWritePipe;
        si.dwFlags |= STARTF_USESTDHANDLES;

        PROCESS_INFORMATION pi;
        ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));

        std::wstring wideCmd(cmd.begin(), cmd.end());
        if (!CreateProcessW(nullptr, const_cast<wchar_t*>(wideCmd.c_str()), nullptr, nullptr, TRUE, 0, nullptr, nullptr, &si, &pi)) {
            throw std::runtime_error("Failed to create process");
        }

        CloseHandle(hWritePipe);
        hWritePipe = nullptr;
        hChildProcess = pi.hProcess;
        CloseHandle(pi.hThread);
#else
        if (pipe(pipeFds) == -1) {
            throw std::runtime_error("Failed to create pipe");
        }

        childPid = fork();
        if (childPid == -1) {
            throw std::runtime_error("Failed to fork process");
        } else if (childPid == 0) {
            // 子进程重定向输出到管道
            close(pipeFds[0]);
            dup2(pipeFds[1], STDOUT_FILENO);
            dup2(pipeFds[1], STDERR_FILENO);
            close(pipeFds[1]);

            // 通过sh -c解析命令行
            execl("/bin/sh", "sh", "-c", cmd.c_str(), nullptr);
            exit(EXIT_FAILURE);
        } else {
            // 父进程关闭写端
            close(pipeFds[1]);
        }
#endif
        std::async(std::launch::async, &Pipe::readPipeAsync, this);
    }

    bool isChildRunning() {
#ifdef _WIN32
        if (!hChildProcess) return false;
        DWORD exitCode;
        GetExitCodeProcess(hChildProcess, &exitCode);
        return exitCode == STILL_ACTIVE;
#else
        if (childPid == -1) return false;
        int status;
        pid_t result = waitpid(childPid, &status, WNOHANG);
        return result == 0;
#endif
    }
};
} // namespace pipe

你提到用Observer模式结合std::async没正常工作，大概率是这几个原因：

1. 管道句柄未正确处理：主进程未关闭管道写端，导致ReadFile一直阻塞，无法实时获取输出
2. std::async的future被销毁：未保存异步任务返回的future，主线程阻塞等待任务完成，失去异步效果
3. 读取逻辑问题：仅读取一次管道数据，没有循环读取，导致只能获取部分输出

按照上面的代码实现，应该能解决这些问题，实时捕获子进程的输出并通过Observer推送给主进程。

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