tubo() es una función del sistema Linux. El tubo() La función del sistema se utiliza para abrir descriptores de archivos, que se utilizan para comunicarse entre diferentes procesos de Linux. En resumen, el tubo() La función se utiliza para la comunicación entre procesos en Linux. En este artículo, le mostraré cómo usar la función del sistema Pipe () en Linux. Entonces empecemos.

Todo sobre la función de pipa ():

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 (Integer) Tipo de matriz pipa que consiste en 2 elementos de matriz a la tubería de funciones (). Entonces la función Pipe () crea dos descriptores de archivos en el pipa formación.

El primer elemento del pipa formación, pipefd [0] se usa para leer datos de la tubería.

El segundo elemento del pipa formación, pipefd [1] se usa para escribir datos en la tubería.

En el éxito, la función Pipe () devuelve 0. Si se produce un error durante la inicialización de la tubería, entonces la función de tubería () devuelve -1.

La función de tubo () 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:

#incluir

Para obtener más información sobre la función del sistema Pipe (), consulte la página del hombre de Pipe () con el siguiente comando:

$ Man 2 Pipe
La página del hombre de la pipa ().

Ejemplo 1:

Para el primer ejemplo, cree un nuevo archivo de origen C 1_pipe.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");
salida (exit_failure);

printf ("Leer el valor del descriptor del archivo: %d \ n", pipefds [0]);
printf ("Escribir el valor del descriptor del archivo: %d \ n", pipefds [1]);
return exit_success;

Aquí, incluí el archivo de encabezado de Pipe () unistd.H Primero con la siguiente línea.

#incluir

Entonces, en el principal() función, definí el pipa Matriz entera de dos elementos con la siguiente línea.

int pipefds [2];

Luego, ejecuté la función Pipe () para inicializar la matriz de descriptores de archivo pipa como sigue.

tubería (pipefds)

También verificé los errores utilizando el valor de retorno de la función Pipe (). Yo usé el salida() función para terminal del programa en caso de que falle la función de la tubería.

if (pipe (pipefds) == -1)
Perror ("tubería");
salida (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 el valor del descriptor del archivo: %d \ n", pipefds [0]);
printf ("Escribir el valor del descriptor del archivo: %d \ n", pipefds [1]);

Si ejecuta el programa, debería ver la siguiente salida. Como puede ver, el valor del descriptor de archivo de tubería de lectura pipefds [0] es 3 y escribir descriptor de archivos de tubería pipefds [1] es 4.

Ejemplo 2:

Crear otro archivo de origen C 2_pipe.C y escriba las siguientes líneas de códigos.

#incluir
#incluir
#incluir
#incluir
int main (void)
int pipefds [2];
buffer de char [5];
if (pipe (pipefds) == -1)
Perror ("tubería");
salida (exit_failure);

char *pin = "4128 \ 0";
printf ("Escribir pin a tubería ... \ n");
escribir (pipefds [1], pin, 5);
printf ("Hecho.\ n \ n ");
printf ("Lectura del pasador de la tubería ... \ n");
leer (pipefds [0], búfer, 5);
printf ("Hecho.\ n \ n ");
printf ("Pin de 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í, almacené un código PIN de 4 caracteres en un carbonizarse formación. La longitud de la matriz es 5 (incluido el carácter nulo \ 0).

char *pin = "4128 \ 0";

Cada carácter ASCII tiene 1 byte de tamaño en C. Entonces, para enviar el pasador de 4 dígitos a través de la tubería, debe escribir 5 bytes (4 + 1 carácter nulo) de datos en la tubería.

Escribir 5 bytes de datos (alfiler) En la tubería, utilicé el escribir() función utilizando 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 utilizando 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 personajes. Como leeré 5 bytes de datos de la tubería, el buffer La matriz de personajes debe tener al menos 5 bytes de largo.

He definido el buffer matriz de personajes al comienzo del principal() función.

buffer de char [5];

Ahora puedo leer el pasador de la tubería y almacenarlo en el buffer matriz con la siguiente línea.

leer (pipefds [0], búfer, 5);

Ahora que he leído el pasador de la tubería, puedo imprimirlo usando el printf () funcionar como de costumbre.

printf ("Pin de tubería: %s \ n", búfer);

Una vez que ejecuto el programa, se muestra la salida correcta como puede ver.

Ejemplo 3:

Crear un nuevo archivo de origen C 3_pipe.C como tipo en las siguientes líneas de códigos.

#incluir
#incluir
#incluir
#incluir
#incluir
int main (void)
int pipefds [2];
char *pin;
buffer de char [5];
if (pipe (pipefds) == -1)
Perror ("tubería");
salida (exit_failure);

pid_t pid = horqu ();
if (pid == 0) // en el proceso infantil
pin = "4821 \ 0"; // pin para enviar
cerrar (pipefds [0]); // Cerrar Leer FD
escribir (pipefds [1], pin, 5); // Escribir pin a tubería
printf ("generar pin en el niño y enviar al padre ... \ n");
dormir (2); // retraso intencional
salir (exit_success);

if (pid> 0) // en el proceso principal
esperar (nulo); // esperar a que termine el proceso infantil
cerrar (pipefds [1]); // Cerrar escritura FD
leer (pipefds [0], búfer, 5); // Leer el pasador de la tubería
cerrar (pipefds [0]); // Cerrar Leer FD
printf ("Pin recibido PAR '%s' \ n", búfer);

return exit_success;

En este ejemplo, le mostré cómo usar la tubería para la comunicación entre procesos. He enviado un PIN del proceso infantil al proceso principal utilizando una tubería. Luego lea el pin de la tubería en el proceso principal y lo imprimió desde el proceso principal.

Primero, he creado un proceso infantil usando la función Fork ().

pid_t pid = horqu ();

Luego, en el proceso infantil (pid == 0), Escribí el pasador a 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 del niño, el proceso principal (PID> 0) Léelo desde la tubería utilizando el leer() función.

leer (pipefds [0], búfer, 5);

Luego, el proceso principal imprimió el pin usando printf () funcionar como de costumbre.

printf ("Pin recibido PAR '%s' \ n", búfer);

Como puede ver, ejecutar el programa da el resultado esperado.

Ejemplo 4:

Crear un nuevo archivo de origen C 4_pipe.C como tipo 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)
mientras (1)
int pipefds [2];
char pin [pin_length + 1];
Char Buffer [pin_length + 1];
tubería (pipefds);
pid_t pid = horqu ();
if (pid == 0)
getPin (pin); // Generar PIN
cerrar (pipefds [0]); // Cerrar Leer FD
escribir (pipefds [1], pin, pin_length + 1); // Escribir pin a tubería
printf ("generar pin en el niño y enviar al padre ... \ n");
dormir (pin_wait_interval); // retrasando la generación de pin intencionalmente.
salir (exit_success);

if (pid> 0)
esperar (nulo); // esperando que el niño termine
cerrar (pipefds [1]); // Cerrar escritura FD
leer (pipefds [0], buffer, pin_length + 1); // Leer el pasador de la tubería
cerrar (pipefds [0]); // Cerrar Leer FD
printf ("Pin de padre recibido '%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 infantil, genera un PIN en el proceso infantil y envía el PIN al proceso principal utilizando una tubería.

El proceso principal luego lee el pin de la tubería y lo imprime.

Este programa genera un nuevo pin_length en cada pin_wait_interval segundos.

Como puede ver, el programa funciona como se esperaba.

Solo puede detener el programa presionando + C.

Entonces, así es como usa la llamada del sistema Pipe () en el lenguaje de programación C. Gracias por leer este artículo.