Come usare la funzione del tubo in linguaggio C

Un tubo è un mezzo per la comunicazione tra i processi. Un processo scrive i dati sul tubo e un altro processo legge i dati dal tubo. In questo articolo, vedremo come viene utilizzata la funzione pipe () per implementare il concetto usando il linguaggio C.

Su pipe

Nel tubo, i dati vengono mantenuti in un ordine FIFO, il che significa scrivere dati a un'estremità del tubo in sequenza e leggere i dati da un'altra estremità del tubo nello stesso ordine sequenziale.

Se un processo si legge dal tubo, ma nessun altro processo non ha ancora scritto nel tubo, quindi leggi restituisce la fine del file. Se un processo vuole scrivere su un tubo, ma non c'è altro processo collegato al tubo per la lettura, allora questa è una condizione di errore e il tubo genera un segnale di sigipe.

File di intestazione

#includere

Sintassi

INT Pipe (Int Filedes [2])

argomenti

Questa funzione prende un singolo argomento, un array di due numeri interi (Deniugerati). Filedes [0] viene utilizzato per la lettura dal tubo e Filedes [1] è usato per scrivere sul tubo. Il processo che vuole leggere dal tubo dovrebbe chiudere Filedes [1], e il processo che vuole scrivere sul tubo dovrebbe chiudere Filedes [0]. Se le estremità non necessarie del tubo non sono esplicitamente chiuse, allora la fine del file (EOF) non verrà mai restituito.

Valori di ritorno

Sul successo, il tubo() restituisce 0, per errore la funzione restituisce -1.

Patorialmente, possiamo rappresentare il tubo() funzione come segue:

Di seguito sono riportati alcuni esempi che descrivono come utilizzare la funzione del tubo in lingua.

Esempio 1

In questo esempio, vedremo come funziona la funzione del tubo. Anche se usare un tubo in un singolo processo non è molto utile, ma avremo un'idea.

// Esempio 1.C
#includere
#includere
#includere
#includere
int main ()

int n;
int filedes [2];
Char Buffer [1025];
char *message = "ciao, mondo!";
pipe (files);
Scrivi (Filedes [1], Message, Strlen (Message));
if ((n = read (filedes [0], buffer, 1024))> = 0)
buffer [n] = 0; // Termina la stringa
printf ("Leggi %d byte dal tubo:" %s "\ n", n, buffer);

altro
Perror ("leggi");
uscita (0);

Qui abbiamo creato per la prima volta un tubo usando tubo() funzione quindi scritta sul tubo usando Fildes [1] FINE. Quindi, i dati sono stati letti usando l'altra estremità del tubo, che è Filedes [0]. Per leggere e scrivere al file, eravamo soliti Leggere() E scrivere() funzioni.

Esempio2

In questo esempio, vedremo come comunicare i processi dei genitori e dei figli usando il tubo.

// Esempio2.C
#includere
#includere
#includere
#includere
#includere
int main ()

int filedes [2], nbyte;
pid_t Childpid;
char string [] = "ciao, mondo!\N";
Char ReadBuffer [80];
pipe (files);
if ((ChildPid = fork ()) == -1)

Perror ("fork");
uscita (1);

if (ChildPid == 0)

Close (Filedes [0]); // Il processo figlio non ha bisogno di questa estremità del tubo
/ * Invia "stringa" attraverso il lato output del tubo */
Scrivi (Filedes [1], String, (Strlen (String) +1));
uscita (0);

altro

/ * Il processo genitore chiude il lato di uscita del tubo */
Close (Filedes [1]); // Il processo genitore non ha bisogno di questa estremità del tubo
/ * Leggi in una stringa dal tubo */
nBytes = read (Filedes [0], readBuffer, sizeof (readBuffer));
printf ("Leggi String: %S", ReadBuffer);

restituzione (0);

Innanzitutto, è stato creato un tubo utilizzando la funzione del tubo, quindi è stato biforcato. Quindi, il processo del bambino chiude l'estremità di lettura e scrive sul tubo. Il processo genitore chiude la fine della scrittura e legge dal tubo e la visualizza. Qui il flusso di dati è solo un modo che va da figlio a genitore.

Conclusione:

tubo() è una potente chiamata di sistema in Linux. In questo articolo, abbiamo visto solo un flusso di dati a senso unico, un processo scrive e un altro processo recita, creando due tubi che possiamo ottenere anche il flusso di dati bidirezionali.