La sintaxis del tubo() la función es:
En ttubo(En tpipefd[2]);
Aquí, la función pipe () crea un canal de datos unidireccional para la comunicación entre procesos. Pasas en un En t (Entero) matriz de tipo 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.
Si tiene é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:
#incluir
Para obtener más información sobre la función del sistema pipe (), consulte la página de manual de pipe () con el siguiente comando:
$ hombre2tuboLa página de manual de pipe().
Ejemplo 1:
Para el primer ejemplo, cree un nuevo archivo fuente en C 1_pipe.c y escriba las siguientes líneas de códigos.
#incluir#incluir
#incluir
En tprincipal(vacío) {
En tpipefds[2];
si(tubo(pipefds) == -1) {
perror ('tubo');
Salida (EXIT_FAILURE);
}
printf ('Leer valor de descriptor de archivo:% d orte',pipefds[0]);
printf ('Escribir valor de descriptor de archivo:% d orte',pipefds[1]);
regresoEXIT_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 enteros de dos elementos con la siguiente línea.
En tpipefds[2];Luego, ejecuté la función pipe () para inicializar la matriz de descriptores de archivo pipefds como sigue.
tubo(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.
si(tubo(pipefds) == -1) {perror ('tubo');
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 valor de descriptor de archivo:% d orte',pipefds[0]);printf ('Escribir valor de descriptor de archivo:% d orte',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:
Crea otro archivo fuente en C 2_pipe.c y escriba las siguientes líneas de códigos.
#incluir#incluir
#incluir
#incluir
En tprincipal(vacío) {
En tpipefds[2];
carbonizarsebuffer[5];
si(tubo(pipefds) == -1) {
perror ('tubo');
Salida (EXIT_FAILURE);
}
carbonizarse *alfiler= '4128 ';
printf ('Escribiendo PIN en la tubería ... orte');
escribir(pipefds[1],alfiler, 5);
printf ('Hecho. orte orte');
printf ('Leyendo el PIN de la tubería ... orte');
leer(pipefds[0],buffer, 5);
printf ('Hecho. orte orte');
printf ('PIN de la tubería:% s orte',buffer);
regresoEXIT_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).
carbonizarse *alfiler= '4128 ';Cada carácter ASCII tiene un tamaño de 1 byte en C. Por lo tanto, 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],alfiler, 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 escribí 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.
carbonizarsebuffer[5];Ahora, puedo leer el PIN de la tubería y guardarlo en el buffer matriz con la siguiente línea.
leer(pipefds[0],buffer, 5);Ahora que he leído el PIN de la tubería, puedo imprimirlo usando el printf () funcionar como de costumbre.
printf ('PIN de la tubería:% s orte',buffer);Una vez que ejecuto el programa, se muestra la salida correcta como puede ver.
Ejemplo 3:
Crea un nuevo archivo fuente en C 3_pipe.c como escriba en las siguientes líneas de códigos.
#incluir#incluir
#incluir
#incluir
#incluir
En tprincipal(vacío) {
En tpipefds[2];
carbonizarse *alfiler;
carbonizarsebuffer[5];
si(tubo(pipefds) == -1) {
perror ('tubo');
Salida (EXIT_FAILURE);
}
pid_t pid=tenedor();
si(pid== 0) { // en proceso hijo
alfiler= '4821 '; // PIN para enviar
cerrar(pipefds[0]); // cerrar leer fd
escribir(pipefds[1],alfiler, 5); // escribir PIN en la tubería
printf ('Generando PIN en el niño y enviándolo a los padres ... orte');
dormir(2); // retraso intencional
Salida (EXIT_SUCCESS);
}
si(pid> 0) { // en proceso principal
Espere(NULO); // espera a que termine el proceso hijo
cerrar(pipefds[1]); // cerrar escribir fd
leer(pipefds[0],buffer, 5); // leer el PIN de la tubería
cerrar(pipefds[0]); // cerrar leer fd
printf ('El padre recibió el PIN'% s ' orte',buffer);
}
regresoEXIT_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=tenedor();Luego, en el proceso hijo ( pid == 0 ), Escribí el PIN en la tubería usando el escribir() función.
escribir(pipefds[1],alfiler, 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],buffer, 5);Luego, el proceso padre imprimió el PIN usando printf () funcionar como de costumbre.
printf ('El padre recibió el PIN'% s ' orte',buffer);Como puede ver, ejecutar el programa da el resultado esperado.
Ejemplo 4:
Crea un nuevo archivo fuente en C 4_pipe.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
vacíogetPIN(carbonizarsealfiler[PIN_LENGTH+ 1]) {
srand (getpid() +getppid());
alfiler[0] = 49 + hilera () % 7;
por(En tI= 1;I<PIN_LENGTH;I++) {
alfiler[I] = 48 + hilera () % 7;
}
alfiler[PIN_LENGTH] = ' ';
}
En tprincipal(vacío) {
tiempo(1) {
En tpipefds[2];
carbonizarsealfiler[PIN_LENGTH+ 1];
carbonizarsebuffer[PIN_LENGTH+ 1];
tubo(pipefds);
pid_t pid=tenedor();
si(pid== 0) {
getPIN(alfiler); // generar PIN
cerrar(pipefds[0]); // cerrar leer fd
escribir(pipefds[1],alfiler,PIN_LENGTH+ 1); // escribir PIN en la tubería
printf ('Generando PIN en el niño y enviándolo a los padres ... orte');
dormir(PIN_WAIT_INTERVAL); // retrasar intencionalmente la generación de PIN.
Salida (EXIT_SUCCESS);
}
si(pid> 0) {
Espere(NULO); // esperando que el niño termine
cerrar(pipefds[1]); // cerrar escribir fd
leer(pipefds[0],buffer,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. orte orte',buffer);
}
}
regresoEXIT_SUCCESS;
}
Este ejemplo es el mismo que Ejemplo 3 . La única diferencia es que este programa crea continuamente un proceso hijo, genera un PIN en el proceso hijo y envía el PIN al proceso padre 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 + C .
Entonces, así es como se usa la llamada al sistema pipe () en el lenguaje de programación C. Gracias por leer este artículo.