C++ 通过管道将一个子系统的标准输出发送到另一个子系统的标准输出

以下是影响代码的主要问题:

• 如何将多达1000个字符读入一个字符

  char words; read(STDIN_FILENO, words, 1000);
  

• 如果您读取字符，则需要将其格式化为字符串(%s，而不是%d).

• 将管道的写入端复制到标准输入意味着读取操作将失败

  dup2(pipe_name[1],STDIN_FILENO);
  

  该1必须为0.

• 在管道上写入的内容将不是以null结尾的字符串，而是一个字节array.你必须确保它是一个字符串.

最好确保管道未使用的端部及时关闭. 这并不是一个大问题，因为您只执行一次读取操作，而不是读取直到读取. 最好从一开始就养成良好的习惯.

此外，错误应该在stderr上报告，当出现错误时，程序应该以非零状态退出.

以下是解决这些问题的一些修订代码:

/* SO 7818-3904 */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

static void wait_loop(void)
{
    int corpse;
    int status;

    while ((corpse = wait(&status)) != -1)
    {
        fprintf(stderr, "%d: PID %d exited with status 0x%.4X\n",
                (int)getpid(), corpse, status);
    }
}

int
main(void)
{
    int pipe_name[2];
    printf("hello world (pid:%d)\n", (int)getpid());
    if (pipe(pipe_name) < 0)
    {
        fprintf(stderr, "mission failed! We'll gettem next time...\n");
        exit(1);
    }

    int rc1 = fork();
    if (rc1 < 0)
    {
        fprintf(stderr, "fork 1 failed\n");
        exit(1);
    }
    else if (rc1 == 0)
    {
        printf("hello, I am child 1 (pid:%d)\n", (int)getpid());
        dup2(pipe_name[1], STDOUT_FILENO);
        close(pipe_name[0]);
        close(pipe_name[1]);
        printf("hello, I am child 1 (pid:%d)\n", (int)getpid());
    }
    else
    {
        wait_loop();    /* Not really necessary here */
        int rc2 = fork();
        if (rc2 < 0)
        {
            fprintf(stderr, "fork 2 failed\n");
            exit(1);
        }
        else if (rc2 == 0)
        {
            close(pipe_name[1]);
            printf("hello, I am child 2 (pid:%d)\n", (int)getpid());
            dup2(pipe_name[0], STDIN_FILENO);
            close(pipe_name[0]);
            char words[1000];
            int nbytes = read(STDIN_FILENO, words, sizeof(words));
            if (nbytes > 0)
            {
                words[nbytes] = '\0';
                printf("My sibling says:\n%d: [%s]\n", nbytes, words);
            }
            else
            {
                fprintf(stderr, "%d: Got value %d from read(): %d %s\n",
                        (int)getpid(), nbytes, errno, strerror(errno));
                exit(1);
            }
        }
        else
        {
            close(pipe_name[0]);
            close(pipe_name[1]);
            wait_loop();
            // parent goes down this path (original process)
            printf("%d: hello, I am parent of %d and %d\n",
                   (int)getpid(), rc1, rc2);
        }
    }
    return 0;
}

样品输出:

hello world (pid:23510)
hello, I am child 1 (pid:23511)
23510: PID 23511 exited with status 0x0000
hello, I am child 2 (pid:23512)
My sibling says:
32: [hello, I am child 1 (pid:23511)
]
23510: PID 23512 exited with status 0x0000
23510: hello, I am parent of 23511 and 23512

请注意，我把等待的代码放入一个函数中，并打印出返回的值—我认为wait(NULL)是一个不连贯的指示. 您的流程可能有它不知道的子项目(不太可能，但可能). 获取输出有助于调试.

第一个等待循环并不是真正必要的，尽管在这种情况下它没有什么坏处. 然而，如果子系统传输了足够多的数据(这些天，超过64 KiB，但POSIX只保证一个管道可以容纳4 KiB)，那么早期等待循环将阻止读取器启动，写入器将永远不会完成，因为它正在等待某个进程清空管道，这不会发生. 这是一个僵局，需要避免.