C++如何通过函数参数返回执行命令的stdout、stderr输出内容

问题核心原因 #

你的代码无法将结果返回给调用方，本质是两个核心问题：

1. 参数传递规则错误：当前pipecom函数的qstdout、qstderr是值传递的char*指针，函数内部修改的只是指针的本地副本，调用方传入的原始指针不会收到任何修改。
2. 存在多处隐性逻辑Bug，会导致输出内容读取失败，看起来像内容被提前销毁。

具体问题&修复方案 #

1. 修复参数传递逻辑 #

有两种可选方案，根据你的使用习惯选择：

方案A（C风格，用char*返回）

将参数改为二级指针，修改函数声明为：

int pipecom(char* cmd, char** qstdout, char** qstderr)

调用时传入指针的地址：

char* out = NULL;
char* err = NULL;
int ret = pipecom("dir", &out, &err);
// 后续使用完记得手动free(out); free(err); 避免内存泄漏

函数内部赋值时要解引用二级指针：

*qstdout = (char *)malloc(1+strlen(stdoutbuf.c_str()));
strcpy(*qstdout, stdoutbuf.c_str());
*qstderr = (char *)malloc(1+strlen(stderrbuf.c_str()));
strcpy(*qstderr, stderrbuf.c_str());

方案B（C++风格，更安全）

直接传std::string引用，不需要手动管理内存，修改函数声明为：

int pipecom(const char* cmd, std::string& qstdout, std::string& qstderr)

函数内部直接对qstdout、qstderr赋值即可，调用方可以直接拿到结果。

2. 修复其他逻辑Bug #

• stderr管道未创建：你只调用了一次CreatePipe创建stdout管道，hStdReadPipeError、hStdOutPipeError是未初始化的野指针，需要单独创建stderr管道：

  // 创建stdout管道
  if(CreatePipe(&hStdOutPipeRead, &hStdOutPipeWrite, &sa, 0) == FALSE) return -1;
  // 新增创建stderr管道
  if(CreatePipe(&hStdReadPipeError, &hStdOutPipeError, &sa, 0) == FALSE) {
      CloseHandle(hStdOutPipeRead);
      CloseHandle(hStdOutPipeWrite);
      return -1;
  }
  

• 命令拼接缺少空格：当前strcpy(fullcmd, "cmd /c")后续直接拼接用户命令，会生成cmd /cdir这类错误命令，改为strcpy(fullcmd, "cmd /c ")，/c后面加空格。
• 字符串替换逻辑错误：你把\r替换为\0会导致字符串被截断，c_str()只能读到第一个\0之前的内容，改为替换为空字符串即可：

  stdoutbuf = ReplaceAll(stdoutbuf, "\r", "");
  stderrbuf = ReplaceAll(stderrbuf, "\r", "");
  

• 变量未初始化：ex_stat没有初始值，若进程等待失败会返回随机值，定义时初始化为0即可。
• 资源泄漏：需要补充关闭进程/线程句柄，释放fullcmd的malloc内存。

完整可运行参考代码（C++ string版本） #

#include <windows.h>
#include <string>
#include <cstdio>
#include <cstring>

std::string ReplaceAll(std::string str, const std::string& from, const std::string& to){
    size_t start_pos = 0;
    while((start_pos = str.find(from, start_pos)) != std::string::npos) {
        str.replace(start_pos, from.length(), to);
        start_pos += to.length();
    }
    return str;
}

int pipecom(const char* cmd, std::string& qstdout, std::string& qstderr){
    qstdout.clear();
    qstderr.clear();
    HANDLE hStdOutPipeRead = NULL, hStdOutPipeWrite = NULL;
    HANDLE hStdErrPipeRead = NULL, hStdErrPipeWrite = NULL;
    SECURITY_ATTRIBUTES sa = {};
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    sa.lpSecurityDescriptor = NULL;
    sa.bInheritHandle = TRUE;
    
    // 创建两个管道分别接收stdout、stderr
    if(CreatePipe(&hStdOutPipeRead, &hStdOutPipeWrite, &sa, 0) == FALSE) return -1;
    if(CreatePipe(&hStdErrPipeRead, &hStdErrPipeWrite, &sa, 0) == FALSE){
        CloseHandle(hStdOutPipeRead);
        CloseHandle(hStdOutPipeWrite);
        return -1;
    }
    
    STARTUPINFO si = {};
    si.cb = sizeof(STARTUPINFO);
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdError = hStdErrPipeWrite;
    si.hStdOutput = hStdOutPipeWrite;
    si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
    PROCESS_INFORMATION procinfo = {};

    // 构造完整命令
    int cmdLen = strlen(cmd);
    char* fullcmd = (char*)malloc(cmdLen + 10);
    strcpy(fullcmd, "cmd /c ");
    strcat(fullcmd, cmd);

    BOOL ok = CreateProcess(NULL, fullcmd, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &si, &procinfo);
    free(fullcmd); // 释放命令字符串内存

    if(ok == FALSE){
        CloseHandle(hStdOutPipeRead);
        CloseHandle(hStdOutPipeWrite);
        CloseHandle(hStdErrPipeRead);
        CloseHandle(hStdErrPipeWrite);
        return -1;
    }
    
    // 关闭写入端，避免ReadFile永久阻塞
    CloseHandle(hStdOutPipeWrite);
    CloseHandle(hStdErrPipeWrite);
    CloseHandle(procinfo.hThread);
    
    char buf[4097] = {};
    DWORD dwRead = 0;
    
    // 读取标准输出
    while(ReadFile(hStdOutPipeRead, buf, 4096, &dwRead, NULL) && dwRead > 0){
        buf[dwRead] = '\0';
        qstdout += buf;
    }
    // 读取标准错误
    memset(buf, 0, sizeof(buf));
    while(ReadFile(hStdErrPipeRead, buf, 4096, &dwRead, NULL) && dwRead > 0){
        buf[dwRead] = '\0';
        qstderr += buf;
    }
    
    // 替换多余的回车符
    qstdout = ReplaceAll(qstdout, "\r", "");
    qstderr = ReplaceAll(qstderr, "\r", "");

    // 获取进程退出码
    DWORD exit_code = -1;
    if(WaitForSingleObject(procinfo.hProcess, INFINITE) != WAIT_FAILED){
        GetExitCodeProcess(procinfo.hProcess, &exit_code);
    }
    
    // 释放所有句柄
    CloseHandle(hStdOutPipeRead);
    CloseHandle(hStdErrPipeRead);
    CloseHandle(procinfo.hProcess);
    
    return exit_code;
}

// 调用示例
int main() {
    std::string out, err;
    int ret = pipecom("dir C:\\", out, err);
    printf("命令退出码：%d\n", ret);
    printf("标准输出内容：\n%s\n", out.c_str());
    printf("标准错误内容：\n%s\n", err.c_str());
    return 0;
}

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