C Programmazione

Come usare la funzione pipe in linguaggio C

Come usare la funzione pipe in linguaggio C

Una pipe è un mezzo per la comunicazione tra processi. Un processo scrive i dati nella pipe e un altro processo legge i dati dalla pipe. In questo articolo vedremo come viene utilizzata la funzione pipe() per implementare il concetto utilizzando il linguaggio C.

Informazioni sul tubo

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

Se un processo legge dalla pipe, ma nessun altro processo non ha ancora scritto nella pipe, read restituisce la fine del file. Se un processo vuole scrivere su una pipe, ma non c'è nessun altro processo collegato alla pipe per la lettura, allora questa è una condizione di errore e la pipe genera un segnale SIGPIPE.

File di intestazione

#includere

Sintassi

int pipe (int filedes[2])

argomenti

Questa funzione accetta un singolo argomento, un array di due interi (filede). filedes[0] è usato per leggere dal tubo, e file[1] è usato per scrivere sulla pipe. Il processo che vuole leggere dalla pipe dovrebbe chiudersi file[1], e il processo che vuole scrivere sulla pipe dovrebbe chiudersi filedes[0].  Se le estremità non necessarie della pipe non vengono chiuse esplicitamente, la fine del file (EOF) non verrà mai restituita.

Valori di ritorno

In caso di successo, il tubo() restituisce 0, in caso di errore la funzione restituisce -1.

Pittoricamente, possiamo rappresentare il tubo() funzionare come segue:

Di seguito sono riportati alcuni esempi che illustrano come utilizzare la funzione pipe in linguaggio C.

Esempio 1

In questo esempio, vedremo come funziona la funzione pipe. Anche se usare una pipa in un unico processo non è molto utile, ma ci faremo un'idea.

// Esempio 1.c
#includere
#includere
#includere
#includere
intero principale()

int n;
file int[2];
buffer di caratteri[1025];
char *message = "Ciao, mondo!";
pipe(file);
write(filedes[1], messaggio, strlen(messaggio));
if ((n = read ( filedes[0], buffer, 1024 ) ) >= 0)
buffer[n] = 0; //termina la stringa
printf("leggi %d byte dalla pipe: "%s"\n", n, buffer);

altro
perror("leggere");
uscita (0);

Qui abbiamo prima creato una pipa usando tubo() funzione quindi scritta nella pipe usando campi[1] fine. Quindi, i dati sono stati letti utilizzando l'altra estremità del tubo, che è filedes[0]. Per leggere e scrivere sul file, usavamo leggere() e Scrivi() funzioni.

Esempio2

In questo esempio, vedremo come i processi padre e figlio comunicano usando la pipe.

// Esempio2.c
#includere
#includere
#includere
#includere
#includere
intero principale()

int filedes[2], nbytes;
pid_t childpid;
char string[] = "Ciao, mondo!\n";
char readbuffer[80];
pipe(file);
if((childpid = fork()) == -1)

perror("forchetta");
uscita(1);

if(childpid == 0)

close(filedes[0]);//Il processo figlio non ha bisogno di questa estremità della pipe
/* Invia "stringa" attraverso il lato di output della pipe */
write(filedes[1], string, (strlen(string)+1));
uscita (0);

altro

/* Il processo padre chiude il lato di output della pipe */
close(filedes[1]);//Il processo padre non ha bisogno di questa estremità della pipe
/* Legge una stringa dalla pipe */
nbytes = read(filedes[0], readbuffer, sizeof(readbuffer));
printf("Leggi stringa: %s", readbuffer);

ritorno(0);

Innanzitutto, è stata creata una pipe utilizzando la funzione pipe, quindi è stato forkato un processo figlio. Quindi, il processo figlio chiude la fine della lettura e scrive nella pipe. Il processo genitore chiude la fine della scrittura e legge dalla pipe e la visualizza. Qui il flusso di dati è solo un modo che va da bambino a genitore.

Conclusione:

tubo() è una potente chiamata di sistema in Linux. In questo articolo, abbiamo visto solo un flusso di dati unidirezionale, un processo scrive e un altro processo legge, creando due pipe possiamo ottenere anche un flusso di dati bidirezionale.

Come utilizzare AutoKey per automatizzare i giochi Linux
AutoKey è un'utilità di automazione desktop per Linux e X11, programmata in Python 3, GTK e Qt. Utilizzando la sua funzionalità di scripting e MACRO, ...
Come mostrare il contatore FPS nei giochi Linux
I giochi Linux hanno avuto una grande spinta quando Valve ha annunciato il supporto Linux per il client Steam e i loro giochi nel 2012. Da allora, mol...
Come scaricare e giocare a Sid Meier's Civilization VI su Linux
Introduzione al gioco Civilization 6 è una versione moderna del concetto classico introdotto nella serie dei giochi Age of Empires. L'idea era abbasta...