C++启动一个脚本(bash，python..）并使用stdin/stdout进行datatransfare [linu

您的问题是缓冲输出、未关闭的文件描述符以及使用 EOF 发出传输部分结束的信号。前两个问题可以解决，但最后一个问题需要不同的方法。稍后会详细介绍。

循序渐进：

正在使用缓冲 I/O，因此您可能希望在第一个 print 语句后添加行sys.stdout.flush()来强制 Python 刷新输出。现在"Hello!n"是逐个字符阅读的。

但接下来的read块，直到新角色到达或管道关闭。Python脚本的STDOUT仍然打开，C++程序正在等待一些东西到达，但Python脚本本身也在等待一些输入。经典的僵局。

您可能会丢弃 python 脚本中的最后一次打印并尝试关闭其 STDOUT。由于read块直到引用管道写入端的所有文件描述符都关闭，因此您必须在flush之后添加os.close(sys.stdout.fileno())和os.close(sys.stdout.fileno())。

但是仍然有有效的文件描述符引用该管道的写入部分。还记得C++源中的dup2吗？在这三行dup2之后，仍然有parentToChild[READ_FD]和childToParent[WRITE_FD]引用脚本STDIN和STDOUT。所以我们必须关闭它们。在dup2后立即添加close(parentToChild[READ_FD]);和close(childToParent[WRITE_FD]);。现在read当 Python 脚本关闭 STDOUT 和 STDERR 时返回0。

接下来，父级发送"{"AElement":"Something"}"并到达waitpid当子级退出时返回。但是孩子仍然在阅读STDIN。所以你必须在waitpid之前添加close(parentToChild[WRITE_FD]);.

现在是概念部分：在它返回0(管道关闭(之前，您无法read()，然后继续从该关闭的管道读取。您的选择：

• 读取一次，直到管道关闭。没有第二条消息。
• 知道要读多少。提前或通过解释收到的字节。
• 监控两个管道，例如使用 poll(2( 并动态决定是要读取还是写入。

顺便说一句：execlp的参数是const char *file, const char *arg, ...的，其中arg, ...是通常的char *args[]，以arg[0](！(开头并以空指针结尾。请将该行更改为int retexe = execlp(target, target, (char*) NULL);

#!/usr/bin/python2.7
import os
import sys
print "Hello!"
sys.stdout.flush()
os.close(sys.stdout.fileno())
os.close(sys.stderr.fileno())
data = sys.stdin.read()
with open("data_received_by_child.txt", "w") as fp:
    print >>fp, data

#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <sys/wait.h>
#include <unistd.h>
using namespace std;
int main()
{
    const char *target = "./hello.py";
    enum PIPE_FILE_DESCRIPTERS {
        READ_FD = 0, WRITE_FD = 1
    };
    /* Make pipes */
    int parentToChild[2]; /* Parent to child pipe */
    if (pipe(parentToChild) < 0)
    {
        perror("Can't make pipe");
        exit(1);
    }
    int childToParent[2]; /* Child to parent pipe */
    if (pipe(childToParent) < 0)
    {
        perror("Can't make pipe");
        exit(1);
    }
    /* Create a child to run command. */
    pid_t pid = fork();
    switch (pid)
    {
        case -1:
            perror("Can't fork");
            exit(1);
        case 0: /* Child */
            close(parentToChild[WRITE_FD]);
            close(childToParent[READ_FD]);
            dup2(parentToChild[READ_FD], STDIN_FILENO);
            dup2(childToParent[WRITE_FD], STDOUT_FILENO);
            close(parentToChild[READ_FD]);
            close(childToParent[WRITE_FD]);
            execlp(target, target, (char *) NULL);
            perror("Can't execute target");
            exit(1);
        default: /* Parent */
            close(parentToChild[READ_FD]);
            close(childToParent[WRITE_FD]);
            cout << "Child " << pid << " process running..." << endl;
    }
    /* Read data from child */
    string dataReadFromChild;
    char ch;
    int rc;
    while ((rc = read(childToParent[READ_FD], &ch, 1)) != 0)
    {
        if (rc == -1) {
            if ((errno == EINTR) || (errno == EAGAIN)) {
                continue;
            }
            perror("read() failed");
            exit(-1);
        }
        dataReadFromChild += ch;
    }
    close(childToParent[READ_FD]);
    cout << "End of file reached..." << endl;
    cout << "Data received was (" << dataReadFromChild.size() << "):" << endl;
    cout << dataReadFromChild << endl;
    /* Write data to child */
    cout << "starting writing" << endl;
    const char bufferW[] = "{"AElement":"Something"}";
    while (true) {
        int rc = write(parentToChild[WRITE_FD], bufferW, sizeof(bufferW));
        if (rc == -1) {
            if ((errno == EINTR) || (errno == EAGAIN)) {
                continue;
            }
            perror("write() failed");
            exit(-1);
        }
        break;
    }
    close(parentToChild[WRITE_FD]);
    /* Wait for child to exit */
    int status;
    int retWait = waitpid(pid, &status, 0);
    cout << endl << "Child exit status is:  " << WEXITSTATUS(status) << endl << endl;
}