tenedor() y tubos() en c

Question

¿Qué es fork y qué es pipe? Se agradecerá cualquier escenario que explique por qué es necesario su uso. ¿Cuáles son las diferencias entre fork y pipe en C? ¿Podemos usarlos en C++?

Necesito saber que esto es porque quiero implementar un programa en C++ que pueda acceder a la entrada de video en vivo, convertir su formato y escribirlo en un archivo. ¿Cuál sería el mejor enfoque para esto? He usado x264 para esto. Hasta ahora he implementado la parte de la conversión en un formato de archivo. Ahora tengo que implementarlo en una transmisión en vivo. ¿Es una buena idea usar tuberías? ¿Capturas video en otro proceso y lo pasas al otro?

Answer 1

Una tubería es un mecanismo para la comunicación entre procesos. Los datos escritos en la tubería por un proceso se pueden leer por otro proceso. La primitiva para crear una tubería es la función pipe. Esto crea los extremos de lectura y escritura de la tubería. No es muy útil para un solo proceso usar una tubería para hablar consigo mismo. En el uso típico, un proceso crea una tubería justo antes de que forks uno o más procesos secundarios. La tubería se usa para la comunicación entre los procesos padre o hijo, o entre dos procesos hermanos. Un ejemplo familiar de este tipo de comunicación se puede ver en todos los shells del sistema operativo. Cuando escribe un comando en el shell, generará el ejecutable representado por ese comando con una llamada al fork. Se abre un conducto en el nuevo proceso secundario y su salida se lee y se imprime mediante el shell. This page tiene un ejemplo completo de las funciones fork y pipe. Para su comodidad, el código se reproduce a continuación:

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

/* Read characters from the pipe and echo them to stdout. */ 

void 
read_from_pipe (int file) 
{ 
    FILE *stream; 
    int c; 
    stream = fdopen (file, "r"); 
    while ((c = fgetc (stream)) != EOF) 
    putchar (c); 
    fclose (stream); 
} 

/* Write some random text to the pipe. */ 

void 
write_to_pipe (int file) 
{ 
    FILE *stream; 
    stream = fdopen (file, "w"); 
    fprintf (stream, "hello, world!\n"); 
    fprintf (stream, "goodbye, world!\n"); 
    fclose (stream); 
} 

int 
main (void) 
{ 
    pid_t pid; 
    int mypipe[2]; 

    /* Create the pipe. */ 
    if (pipe (mypipe)) 
    { 
     fprintf (stderr, "Pipe failed.\n"); 
     return EXIT_FAILURE; 
    } 

    /* Create the child process. */ 
    pid = fork(); 
    if (pid == (pid_t) 0) 
    { 
     /* This is the child process. 
      Close other end first. */ 
     close (mypipe[1]); 
     read_from_pipe (mypipe[0]); 
     return EXIT_SUCCESS; 
    } 
    else if (pid < (pid_t) 0) 
    { 
     /* The fork failed. */ 
     fprintf (stderr, "Fork failed.\n"); 
     return EXIT_FAILURE; 
    } 
    else 
    { 
     /* This is the parent process. 
      Close other end first. */ 
     close (mypipe[0]); 
     write_to_pipe (mypipe[1]); 
     return EXIT_SUCCESS; 
    } 
} 

Al igual que otras funciones de C se puede utilizar tanto fork y pipe en C++.

Answer 2

hay stdin y stdout para entradas y salidas comunes.

Un estilo común es la siguiente:

input->process->output 

Pero con tubería, se convierte en:

input->process1->(tmp_output)->(tmp-input)->process2->output 

pipe es la función que devuelve los dos temporales tmp-input y tmp-output, es decir fd[0] y fd[1].