What is the best way to create an rw channel using C ++?

Question

I have program A, which should send commands to stdin of program B and read the output of this program B. (Programming in C ++, not just Linux)

ProgramA → send letter A → ProgramB ProgramA <- output B <- ProgramB

Actually, I have the first part, send commands to B, working with popen (). I know popen is only one way.

So what is the best way to do two ways using C ++?

Answer 1

posix (, Linux , posix), pipe/execl/dup. , :

• 2 ( )
• . fd
• stdin/stdout. dup ( , )

, . :

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main ()
{
    pid_t pid;
    int pipe_in[2];   /* This is the pipe with wich we write to the child process. */
    int pipe_out[2];  /* This is the pipe with wich we read from the child process. */

    if (pipe (pipe_in) || pipe (pipe_out)) {
        fprintf (stderr, "Error in creating pipes!\n");
        exit (1);
    }

    /* Attempt to fork and check for errors */
    if ((pid = fork ()) == -1) {
        fprintf (stderr, "Error in fork!\n");
        exit (1);
    }

    if (pid) {
        /* The parent has the non-zero PID. */
        char temp[100];
        int result;
        FILE* child_in;
        FILE* child_out;

        child_in = fdopen(pipe_out[0],"r");
        child_out = fdopen(pipe_in[1],"w");
        close(pipe_out[1]);
        close(pipe_in[0]);

        fprintf(child_out, "something\n"); 

        fgets(temp,100,child_in);
        printf(" Read from child %s \n", temp); 

        /* Send a command to the child. */
        fprintf(child_out, "quit\n"); 
        fflush(child_out);

        fgets(temp,100,child_in);
        printf(" Read from child %s \n", temp);

        wait (&result);             /* Wait for child to finish */
    }
    else {
        /* The child has the zero pid returned by fork*/
        close (1);
        dup (pipe_out[1]);  /* dup uses the lowest numbered unused file descriptor as new descriptor. In our case this now is 1. */

        close (0);          /* dup uses the lowest numbered unused file descriptor as new descriptor. In our case this now is 0. */
        dup (pipe_in[0]);  

        close (pipe_out[0]);
        close (pipe_out[1]);
        close (pipe_in[0]);
        close (pipe_in[1]);
        execl ("child", "child", NULL);
        exit(1); /* Only reached if execl() failed */
    }
    return 0;
}

:

#include <stdio.h>
#include <string.h>

int main ()
{
    char temp[100];

    do {
        printf ("In child: \n");
        fflush (stdout);
        fgets (temp, 100, stdin);
        printf ("Child read %s\n", temp);
        fflush (stdout);
    } while (!strstr (temp, "quit"));

    return 0;
}

:

gcc -o parent parent.c
gcc -o child child.c
./parent

:   , quit

Answer 2

g_spawn_async_with_pipes Glib.

/.

++:

gchar** cmd_argv;
g_shell_parse_argv("your command", &cmd_argc, &cmd_argv, NULL);
g_spawn_async_with_pipes
 (NULL, //Working directory, Inherited from parent (our program)
  cmd_argv,
  NULL, //Null to inherit environment variables from parent
  G_SPAWN_SEARCH_PATH, //Flags
  NULL,
  NULL,
  NULL, //Returns the process ID of child (which runs from our program)
  &stdin_fd, //Standard input (file descriptor)
  &stdout_fd, //Standard output (file descriptor)
  &stderr_fd, //Standard error (file descriptor)
  NULL); //GError*

...

//we have to free cmd_argv
for (int i = 0; i < cmd_argc; ++i) g_free (cmd_argv [i]);

stdin_fd, stdout_fd stderr_fd ( ):

gchar* out;
GIOChannel* io = g_io_channel_unix_new(stdout_fd); //g_io_channel_win32_new_fd
while(g_io_channel_read_line(io, &out, NULL, NULL, NULL) == G_IO_STATUS_NORMAL)
{
    //...
    g_free(out);
}

++-, ( GTK ++).

Answer 3

. ( ). ( 2002 ), , , , , ACE. . .

, , .