In C++, if you want to invoke a console program and output its parameters or execution results in real-time, you can use the standard library function std::system from or create a process using platform-specific APIs like CreateProcess on Windows or fork and exec on Unix-like systems. However, using std::system does not provide direct access to the process's output stream for real-time reading. For that, you would need to use the platform-specific APIs.

In Windows C++ programming, if you want to invoke a console program and output its parameters or execution results in real-time, you can use the CreateProcess function from the Windows API to create a new process and set up redirection for its standard input, output, and error handles. By redirecting these handles, you can capture the output of the console program in real-time.

Here's an example of how you might do this:

#include 
#include 
​
void CreateChildProcess(const std::wstring& executablePath, const std::wstring& arguments) {
    // Initialize the STARTUPINFO structure
    STARTUPINFO si = { sizeof(si) };
    si.dwFlags = STARTF_USESTDHANDLES;
​
    // Create security attributes for the handles
    SECURITY_ATTRIBUTES saAttr = {};
    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
    saAttr.bInheritHandle = TRUE;
    saAttr.lpSecurityDescriptor = NULL;
​
    // Create a pipe for the child process's STDOUT
    HANDLE hRead, hWrite;
    if (!CreatePipe(&hRead, &hWrite, &saAttr, 0)) {
        std::cerr << "CreatePipe failed" << std::endl;
        return;
    }
​
    // Set the STDOUT handle in STARTUPINFO to the write handle of the pipe
    si.hStdOutput = hWrite;
    si.hStdError = hWrite; // You can also redirect STDERR to the same handle
​
    // Create the child process
    PROCESS_INFORMATION pi = {};
    std::wstring cmdLine = executablePath + L" " + arguments;
    if (!CreateProcess(executablePath.c_str(), const_cast(cmdLine.c_str()), NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi)) {
        std::cerr << "CreateProcess failed" << std::endl;
        CloseHandle(hRead);
        CloseHandle(hWrite);
        return;
    }
​
    // Close handles that are no longer needed
    CloseHandle(hWrite);
    CloseHandle(pi.hThread);
​
    // Read from the pipe that is connected to the child process's STDOUT
    DWORD bytesRead;
    CHAR buffer[4096];
    while (ReadFile(hRead, buffer, sizeof(buffer), &bytesRead, NULL) && bytesRead > 0) {
        std::cout.write(buffer, bytesRead);
    }
​
    // Wait for the child process to exit
    WaitForSingleObject(pi.hProcess, INFINITE);
​
    // Close the remaining handles
    CloseHandle(hRead);
    CloseHandle(pi.hProcess);
}
​
int main() {
    std::wstring executablePath = L"pathtoyourconsoleprogram.exe";
    std::wstring arguments = L"arg1 arg2 arg3";
    CreateChildProcess(executablePath, arguments);
    return 0;
}

In this example, CreateChildProcess is a function that creates a child process using CreateProcess and redirects its STDOUT and STDERR to a pipe. The parent process then reads from the pipe to get the output of the child process in real-time. After reading all the output, the parent process waits for the child process to exit and then closes all the handles.