我正在做一个测试程序，它可以打开一个控制台应用程序，读取它的标准输入，写入它的标准输出，但是我遇到了管道的问题。我使用命名管道，因为我可能必须运行这个线程，甚至一次打开多个可执行文件进行通信。这些需要保持运行，并不断地接受输入和给予。就像在控制台计算器中，询问您是否需要另一次计算或在每次计算后退出。
使用错误检查我发现管道创建成功，我将它们应用到startupInfo结构并成功打开可执行文件。这里需要注意的是，如果我在调用createProcess之后立即在visual studio中设置断点，子进程确实会显示在我的任务管理器中，检查STILL_ACTIVE为真，管道的峰值显示一个空管道。如果没有设置断点，那么我看不到它，检查STILL_ACTIVE为假。
为了简化这个问题，我回到了基础，一个简单的hello world在c中的可执行文件。计算器将是下一个测试。它将hello world打印到控制台，并通过cin：get（）等待按下enter键。我用测试器运行了这个测试，并试图从子进程中读取“Hello World”。我什么也没得到。
最终项目将是开源的，我不希望用户下载任何其他库来编译项目，Boost：：Process实际上需要2次安装，因为Process还不是标准的。
我知道我已经很接近了，下面是我的简单测试器，它是一个文件，其中的流程类被提取出来内联在main中。我已经在我的编译器中启用了c20。

// Tester.cpp 
#include <string>
#include <string_view>
#include <vector>
#include <iostream>
#include <fstream>
#include <filesystem>
#include <io.h>
#include <fcntl.h>
#include <windows.h>

int main()
{
    std::string data = "";
    int id = 1;
    std::string executable = "HelloWorld.exe";

    if (_access((executable).c_str(), 0) != -1)
    {
        std::cerr << "Error: Executable file not found: " << executable << std::endl;
        exit(0);
    }

    SECURITY_ATTRIBUTES saAttr{};
    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    saAttr.bInheritHandle = TRUE;
    saAttr.lpSecurityDescriptor = NULL;

    //Pipe names
    std::wstring pipeErr = L"\\\\.\\pipe\\err_" + std::to_wstring(id);
    std::wstring pipeOut = L"\\\\.\\pipe\\out_" + std::to_wstring(id);
    std::wstring pipeIn = L"\\\\.\\pipe\\in_" + std::to_wstring(id);    

    // The Child error pipe for reading
    CreateNamedPipeW(pipeErr.c_str(), PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 1, 1024, 1024, 0, NULL);
    HANDLE err_pipe = CreateFileW(pipeErr.c_str(), GENERIC_READ | GENERIC_WRITE, 0, &saAttr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);

    // The Child out pipe for reading
    CreateNamedPipeW(pipeOut.c_str(), PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 1, 1024, 1024, 0, NULL);
    HANDLE out_pipe = CreateFileW(pipeOut.c_str(), GENERIC_READ | GENERIC_WRITE, 0, &saAttr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
    
    // The Child in pipe for writing
    CreateNamedPipeW(pipeIn.c_str(), PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE | PIPE_WAIT, 1, 1024, 1024, 0, NULL);
    HANDLE in_pipe = CreateFileW(pipeIn.c_str(), GENERIC_READ | GENERIC_WRITE, 0, &saAttr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
    
    if (in_pipe == INVALID_HANDLE_VALUE || out_pipe == INVALID_HANDLE_VALUE || err_pipe == INVALID_HANDLE_VALUE)
    {
        std::cout << "Error Creating Handles, Code: " << GetLastError() << std::endl;
        return 0;
    }

    // Make sure the handles' inheritance is set correctly
    if (!SetHandleInformation(in_pipe, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT) ||
        !SetHandleInformation(out_pipe, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT) ||
        !SetHandleInformation(err_pipe, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
    {
        std::cerr << "Error: Failed to set handle information for the child process" << std::endl;
        return 0;
    }
    
    // Set up the startup info struct
    STARTUPINFOA startupInfo;
    memset(&startupInfo, 0, sizeof(startupInfo));
    startupInfo.cb = sizeof(STARTUPINFOA);
    startupInfo.hStdInput = in_pipe;
    startupInfo.hStdOutput = out_pipe;
    startupInfo.hStdError = err_pipe;
    startupInfo.dwFlags |= STARTF_USESTDHANDLES;
    
    // Set up the process info struct
    PROCESS_INFORMATION processInfo;
    memset(&processInfo, 0, sizeof(processInfo));
    
    // Create the child process
    if (CreateProcessA(NULL, executable.data(), NULL, NULL, TRUE, 0, NULL, NULL, &startupInfo, &processInfo) == 0)
    {
        std::cerr << "Error: Failed to create the child process" << std::endl;
        return 0;
    }

    // Set the pipes to non-blocking mode
    DWORD mode = PIPE_NOWAIT;
    SetNamedPipeHandleState(out_pipe, &mode, NULL, NULL);
    SetNamedPipeHandleState(err_pipe, &mode, NULL, NULL);
    SetNamedPipeHandleState(in_pipe, &mode, NULL, NULL);

    Sleep(500); //wait for child to start, may not be neccesary
    
    // Get the exit code of the child process
    DWORD exitCode;
    GetExitCodeProcess(processInfo.hProcess, &exitCode);

    if (exitCode == STILL_ACTIVE) {
        // Set up the read buffer
        char buffer[1024];
        memset(buffer, 0, sizeof(buffer));
        DWORD bytesRead = 0;
        DWORD bytesAvail = 0;

        // Check if there is data available to read from the pipe
        if (!PeekNamedPipe(out_pipe, buffer, sizeof(buffer), &bytesRead, &bytesAvail, NULL)) {
            std::cerr << "PeekNamedPipe failed (" << GetLastError() << ").\n";
            return 0;
        }

        if (bytesAvail == 0)
        {
            std::cerr << "Pipe is empty" << std::endl;
        }

        if (!ReadFile(out_pipe, buffer, sizeof(buffer) - 1, &bytesRead, NULL))
        {
            std::cerr << "Failed to read from pipe. Error code: " << GetLastError() << std::endl;
            return 0;
        }
        data = buffer;

    }
    if (data == "") {
        std::cout << "Something went wrong. Code: " << GetLastError() << std::endl;
    }
    else {
        std::cout << data << std::endl;
    }

    std::cout << "Press any key." << std::endl;
    std::cin.get();
    return 0;
}

下面是helloworld.exe作为参考：

// HelloWorld.cpp
#include <iostream>

int main()
{
    std::cout << "Hello World!" << std::endl;
    std::cin.get();
}