Phenquestions
Todo sobre la función pipe ():
La sintaxis del tubo() la función es:
int pipe (int pipefd [2]);Aquí, la función pipe () crea un canal de datos unidireccional para la comunicación entre procesos. Pasas en un En t (Entero) tipo matriz pipefd que consta de 2 elementos de matriz para la función pipe (). Luego, la función pipe () crea dos descriptores de archivo en el pipefd formación.
El primer elemento del pipefd formación, pipefd [0] se utiliza para leer datos de la tubería.
El segundo elemento de la pipefd formación, pipefd [1] se utiliza para escribir datos en la tubería.
En caso de éxito, la función pipe () devuelve 0. Si se produce un error durante la inicialización de la tubería, la función pipe () devuelve -1.
La función pipe () se define en el encabezado unistd.h. Para usar la función pipe () en su programa C, debe incluir el encabezado unistd.h como sigue:
#incluirPara obtener más información sobre la función del sistema pipe (), consulte la página de manual de pipe () con el siguiente comando:
$ man 2 pipeLa página de manual de pipe ().
Ejemplo 1:
Para el primer ejemplo, cree un nuevo archivo fuente en C 1_tubo.C y escriba las siguientes líneas de códigos.
#incluir#incluir
#incluir
int main (void)
int pipefds [2];
if (pipe (pipefds) == -1)
perror ("tubería");
salir (EXIT_FAILURE);
printf ("Leer valor de descriptor de archivo:% d \ n", pipefds [0]);
printf ("Escribir valor de descriptor de archivo:% d \ n", pipefds [1]);
return EXIT_SUCCESS;
Aquí, incluí el archivo de encabezado de pipe () unistd.h primero con la siguiente línea.
#incluirEntonces, en el principal() función, definí la pipefds matriz de dos elementos enteros con la siguiente línea.
int pipefds [2];Luego, ejecuté la función pipe () para inicializar la matriz de descriptores de archivo pipefds como sigue.
pipe (pipefds)También verifiqué errores usando el valor de retorno de la función pipe (). Usé el Salida() función a la terminal del programa en caso de que falle la función de tubería.
if (pipe (pipefds) == -1)perror ("tubería");
salir (EXIT_FAILURE);
Luego, imprimí el valor de los descriptores de archivos de tubería de lectura y escritura pipefds [0] y pipefds [1] respectivamente.
printf ("Leer valor de descriptor de archivo:% d \ n", pipefds [0]);printf ("Escribir valor de descriptor de archivo:% d \ n", pipefds [1]);
Si ejecuta el programa, debería ver el siguiente resultado. Como puede ver, el valor del descriptor del archivo de canalización de lectura pipefds [0] es 3 y escribir descriptor de archivo de tubería pipefds [1] es 4.
Ejemplo 2:
Cree otro archivo fuente C 2_pipe.C y escriba las siguientes líneas de códigos.
#incluir#incluir
#incluir
#incluir
int main (void)
int pipefds [2];
tampón de carbón [5];
if (pipe (pipefds) == -1)
perror ("tubería");
salir (EXIT_FAILURE);
char * pin = "4128 \ 0";
printf ("Escribiendo PIN en la tubería ... \ n");
escribir (pipefds [1], pin, 5);
printf ("Hecho.\ n \ n ");
printf ("Leyendo el PIN de la tubería ... \ n");
read (pipefds [0], buffer, 5);
printf ("Hecho.\ n \ n ");
printf ("PIN de la tubería:% s \ n", búfer);
return EXIT_SUCCESS;
Este programa básicamente le muestra cómo escribir en la tubería y leer los datos que ha escrito desde la tubería.
Aquí, guardé un código PIN de 4 caracteres en un carbonizarse formación. La longitud de la matriz es 5 (incluido el carácter NULL \ 0).
char * pin = "4128 \ 0";Cada carácter ASCII tiene un tamaño de 1 byte en C. Entonces, para enviar el PIN de 4 dígitos a través de la tubería, debe escribir 5 bytes (4 + 1 carácter NULL) de datos en la tubería.
Para escribir 5 bytes de datos (alfiler) en la tubería, utilicé el escribir() función usando el descriptor de archivo de tubería de escritura pipefds [1] como sigue.
escribir (pipefds [1], pin, 5);Ahora que tengo algunos datos en la tubería, puedo leerlos desde la tubería usando el leer() función en el descriptor de archivo de tubería de lectura pipefds [0]. Como he escrito 5 bytes de datos (alfiler) en la tubería, también leeré 5 bytes de datos de la tubería. Los datos leídos se almacenarán en el buffer matriz de caracteres. Como leeré 5 bytes de datos de la tubería, el buffer la matriz de caracteres debe tener al menos 5 bytes de longitud.
He definido el buffer matriz de caracteres al comienzo de la principal() función.
tampón de carbón [5];Ahora, puedo leer el PIN de la tubería y guardarlo en el buffer matriz con la siguiente línea.
leer (pipefds [0], búfer, 5);Ahora que he leído el PIN de la tubería, puedo imprimirlo usando el printf () funciona como de costumbre.
printf ("PIN de la tubería:% s \ n", búfer);Una vez que ejecuto el programa, se muestra la salida correcta como puede ver.
Ejemplo 3:
Crea un nuevo archivo fuente en C 3_tubo.C como escriba en las siguientes líneas de códigos.
#incluir#incluir
#incluir
#incluir
#incluir
int main (void)
int pipefds [2];
char * pin;
tampón de carbón [5];
if (pipe (pipefds) == -1)
perror ("tubería");
salir (EXIT_FAILURE);
pid_t pid = fork ();
if (pid == 0) // en proceso hijo
pin = "4821 \ 0"; // PIN para enviar
cerrar (pipefds [0]); // cerrar leer fd
escribir (pipefds [1], pin, 5); // escribir PIN en la tubería
printf ("Generando PIN en el niño y enviándolo a los padres… \ n");
dormir (2); // retraso intencional
salir (EXIT_SUCCESS);
if (pid> 0) // en el proceso principal
esperar (NULO); // esperar a que termine el proceso hijo
cerrar (pipefds [1]); // cerrar escribir fd
leer (pipefds [0], búfer, 5); // leer el PIN de la tubería
cerrar (pipefds [0]); // cerrar leer fd
printf ("El padre recibió el PIN '% s' \ n", búfer);
return EXIT_SUCCESS;
En este ejemplo, le mostré cómo usar la tubería para la comunicación entre procesos. Envié un PIN del proceso secundario al proceso principal mediante una canalización. Luego lea el PIN de la tubería en el proceso principal e imprímalo desde el proceso principal.
Primero, he creado un proceso hijo usando la función fork ().
pid_t pid = fork ();Luego, en el proceso hijo (pid == 0), Escribí el PIN en la tubería usando el escribir() función.
escribir (pipefds [1], pin, 5);Una vez que el PIN se escribe en la tubería desde el proceso hijo, el proceso padre (pid> 0) leerlo de la tubería usando el leer() función.
leer (pipefds [0], búfer, 5);Luego, el proceso padre imprimió el PIN usando printf () funciona como de costumbre.
printf ("El padre recibió el PIN '% s' \ n", búfer);Como puede ver, ejecutar el programa da el resultado esperado.
Ejemplo 4:
Crea un nuevo archivo fuente en C 4_tubo.C como escriba en las siguientes líneas de códigos.
#incluir#incluir
#incluir
#incluir
#incluir
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
void getPIN (char pin [PIN_LENGTH + 1])
srand (getpid () + getppid ());
pin [0] = 49 + rand ()% 7;
para (int i = 1; i < PIN_LENGTH; i++)
pin [i] = 48 + rand ()% 7;
pin [PIN_LENGTH] = '\ 0';
int main (void)
while (1)
int pipefds [2];
char pin [PIN_LENGTH + 1];
búfer de caracteres [PIN_LENGTH + 1];
pipe (pipefds);
pid_t pid = fork ();
si (pid == 0)
getPIN (pin); // generar PIN
cerrar (pipefds [0]); // cerrar leer fd
escribir (pipefds [1], pin, PIN_LENGTH + 1); // escribir PIN en la tubería
printf ("Generando PIN en el niño y enviándolo a los padres… \ n");
dormir (PIN_WAIT_INTERVAL); // retrasar la generación de PIN intencionalmente.
salir (EXIT_SUCCESS);
si (pid> 0)
esperar (NULO); // esperando que el niño termine
cerrar (pipefds [1]); // cerrar escribir fd
leer (pipefds [0], búfer, PIN_LENGTH + 1); // leer el PIN de la tubería
cerrar (pipefds [0]); // cerrar leer fd
printf ("El padre recibió el PIN '% s' del niño.\ n \ n ", búfer);
return EXIT_SUCCESS;
Este ejemplo es el mismo que Ejemplo 3. La única diferencia es que este programa crea continuamente un proceso secundario, genera un PIN en el proceso secundario y envía el PIN al proceso principal mediante una tubería.
El proceso principal luego lee el PIN de la tubería y lo imprime.
Este programa genera un PIN_LENGTH PIN nuevo cada PIN_WAIT_INTERVAL segundos.
Como puede ver, el programa funciona como se esperaba.
Solo puede detener el programa presionando
Entonces, así es como se usa la llamada al sistema pipe () en el lenguaje de programación C. Gracias por leer este artículo.
