Phenquestions
Tutto sulla funzione pipe():
La sintassi di tubo() la funzione è:
int pipe(int pipefd[2]);Qui, la funzione pipe() crea un canale dati unidirezionale per la comunicazione tra processi. Passi in un int (Intero) tipo array pipefd composto da 2 elementi dell'array alla funzione pipe(). Quindi la funzione pipe() crea due descrittori di file nel pipefd Vettore.
Il primo elemento della pipefd Vettore, pipefd[0] viene utilizzato per leggere i dati dal tubo.
Il secondo elemento della pipefd Vettore, pipefd[1] è usato per scrivere dati nella pipe.
In caso di successo, la funzione pipe() restituisce 0. Se si verifica un errore durante l'inizializzazione della pipe, la funzione pipe() restituisce -1.
La funzione pipe() è definita nell'intestazione unistd.h. Per utilizzare la funzione pipe() nel tuo programma C, devi includere l'intestazione unistd.h come segue:
#includerePer maggiori informazioni sulla funzione di sistema pipe(), controlla la pagina man di pipe() con il seguente comando:
$ uomo 2 tubiLa pagina man di pipe().
Esempio 1:
Per il primo esempio, crea un nuovo file sorgente C 1_tubo.c e digita le seguenti righe di codici.
#includere#includere
#includere
int main(void)
int pipefd[2];
if(pipe(pipefds) == -1)
perror("pipa");
exit(EXIT_FAILURE);
printf("Leggi valore descrittore file: %d\n", pipefds[0]);
printf("Scrivi valore descrittore file: %d\n", pipefds[1]);
restituire EXIT_SUCCESS;
Qui, ho incluso il file di intestazione di pipe() unistd.h prima con la riga seguente.
#includerePoi, nel principale() funzione, ho definito la pipefds array di due elementi interi con la seguente riga.
int pipefd[2];Quindi, ho eseguito la funzione pipe() per inizializzare l'array dei descrittori di file pipefds come segue.
tubo (pipefd)Ho anche verificato la presenza di errori utilizzando il valore di ritorno della funzione pipe(). ho usato il Uscita() funzione per terminare il programma nel caso in cui la funzione pipe non riesca.
if(pipe(pipefds) == -1)perror("pipa");
exit(EXIT_FAILURE);
Quindi, ho stampato il valore dei descrittori di file pipe di lettura e scrittura pipefds[0] e pipefd[1] rispettivamente.
printf("Leggi valore descrittore file: %d\n", pipefds[0]);printf("Scrivi valore descrittore file: %d\n", pipefds[1]);
Se esegui il programma, dovresti vedere il seguente output. Come puoi vedere, il valore del descrittore di file read pipe pipefds[0] è 3 e scrivi il descrittore di file pipe pipefd[1] è 4.
Esempio 2:
Crea un altro file sorgente C 2_tubo.c e digita le seguenti righe di codici.
#includere#includere
#includere
#includere
int main(void)
int pipefd[2];
buffer di caratteri[5];
if(pipe(pipefds) == -1)
perror("pipa");
exit(EXIT_FAILURE);
char *pin = "4128\0";
printf("Scrittura PIN per reindirizzare... \n");
write(pipefds[1], pin, 5);
printf("Fatto.\n\n");
printf("Lettura PIN dalla pipe... \n");
read(pipefds[0], buffer, 5);
printf("Fatto.\n\n");
printf("PIN dalla pipe: %s\n", buffer);
restituire EXIT_SUCCESS;
Questo programma ti mostra fondamentalmente come scrivere sulla pipe e leggere i dati che hai scritto dalla pipe.
Qui, ho memorizzato un codice PIN di 4 caratteri in a char Vettore. La lunghezza dell'array è 5 (incluso il carattere NULL \0).
char *pin = "4128\0";Ogni carattere ASCII ha una dimensione di 1 byte in C. Quindi, per inviare il PIN a 4 cifre attraverso la pipe, è necessario scrivere 5 byte (4 + 1 carattere NULL) di dati nella pipe.
Per scrivere 5 byte di dati (pin) nel tubo, ho usato il Scrivi() funzione utilizzando il descrittore di file write pipe pipefd[1] come segue.
write(pipefds[1], pin, 5);Ora che ho dei dati nella pipe, posso leggerli dalla pipe usando il leggere() funzione sul descrittore di file read pipe pipefds[0]. Come ho scritto 5 byte di dati (pin) nella pipe, leggerò anche 5 byte di dati dalla pipe. I dati letti verranno archiviati nel buffer matrice di caratteri. Poiché leggerò 5 byte di dati dalla pipe, il buffer l'array di caratteri deve essere lungo almeno 5 byte.
ho definito il buffer array di caratteri all'inizio del principale() funzione.
buffer di caratteri[5];Ora posso leggere il PIN dalla pipe e memorizzarlo nel buffer array con la seguente riga.
read(pipefds[0], buffer, 5);Ora che ho letto il PIN dalla pipe, posso stamparlo usando il printf() funzionare come al solito.
printf("PIN dalla pipe: %s\n", buffer);Una volta eseguito il programma, viene visualizzato l'output corretto come puoi vedere.
Esempio 3:
Crea un nuovo file sorgente C 3_tubo.c come digitare nelle seguenti righe di codici.
#includere#includere
#includere
#includere
#includere
int main(void)
int pipefd[2];
carattere *pin;
buffer di caratteri[5];
if(pipe(pipefds) == -1)
perror("pipa");
exit(EXIT_FAILURE);
pid_t pid = fork();
if(pid == 0) // nel processo figlio
pin = "4821\0"; // PIN da inviare
close(pipefds[0]); // chiudi leggi fd
write(pipefds[1], pin, 5); // scrivi il PIN su pipe
printf("Generazione PIN nel figlio e invio al genitore... \n");
dormire(2); // ritardo intenzionale
exit(EXIT_SUCCESS);
if(pid > 0) // nel processo principale
attendere(NULL); // attendo che il processo figlio finisca
close(pipefd[1]); // chiudi scrivi fd
read(pipefds[0], buffer, 5); // legge il PIN dalla pipe
close(pipefds[0]); // chiudi leggi fd
printf("Il genitore ha ricevuto il PIN '%s'\n", buffer);
restituire EXIT_SUCCESS;
In questo esempio, ti ho mostrato come utilizzare la pipe per la comunicazione tra processi. Ho inviato un PIN dal processo figlio al processo padre utilizzando una pipe. Quindi leggi il PIN dalla pipe nel processo padre e stampalo dal processo padre.
Innanzitutto, ho creato un processo figlio utilizzando la funzione fork().
pid_t pid = fork();Quindi, nel processo figlio (pid == 0), ho scritto il PIN sulla pipe usando il Scrivi() funzione.
write(pipefds[1], pin, 5);Una volta che il PIN è stato scritto nella pipe dal processo figlio, il processo padre (pid > 0) leggerlo dalla pipa usando il leggere() funzione.
read(pipefds[0], buffer, 5);Quindi, il processo padre ha stampato il PIN utilizzando printf() funzionare come al solito.
printf("Il genitore ha ricevuto il PIN '%s'\n", buffer);Come puoi vedere, l'esecuzione del programma dà il risultato atteso.
Esempio 4:
Crea un nuovo file sorgente C 4_tubo.c come digitare nelle seguenti righe di codici.
#includere#includere
#includere
#includere
#includere
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
void getPIN(char pin[PIN_LENGTH + 1])
srand(getpid() + getppid());
pin[0] = 49 + rand() % 7;
for(int i = 1; i < PIN_LENGTH; i++)
pin[i] = 48 + rand() % 7;
pin[PIN_LENGTH] = '\0';
int main(void)
mentre(1)
int pipefd[2];
char pin[LUNGHEZZA_PIN + 1];
char buffer[LUNGHEZZA_PIN + 1];
tubo(pipefd);
pid_t pid = fork();
if(pid == 0)
getPIN(pin); // genera il PIN
close(pipefds[0]); // chiudi leggi fd
write(pipefds[1], pin, PIN_LENGTH + 1); // scrivi il PIN su pipe
printf("Generazione PIN nel figlio e invio al genitore... \n");
sleep(PIN_WAIT_INTERVAL); // ritardare intenzionalmente la generazione del PIN.
exit(EXIT_SUCCESS);
if(pid > 0)
attendere(NULL); // aspetto che il bambino finisca
close(pipefd[1]); // chiudi scrivi fd
read(pipefds[0], buffer, PIN_LENGTH + 1); // legge il PIN dalla pipe
close(pipefds[0]); // chiudi leggi fd
printf("Il genitore ha ricevuto il PIN '%s' dal figlio.\n\n", buffer);
restituire EXIT_SUCCESS;
Questo esempio è lo stesso di Esempio 3. L'unica differenza è che questo programma crea continuamente un processo figlio, genera un PIN nel processo figlio e invia il PIN al processo padre utilizzando una pipe.
Il processo padre legge quindi il PIN dalla pipe e lo stampa.
Questo programma genera un nuovo PIN_LENGTH PIN ogni PIN_WAIT_INTERVAL secondi.
Come puoi vedere, il programma funziona come previsto.
È possibile interrompere il programma solo premendo
Quindi, questo è il modo in cui usi la chiamata di sistema pipe() nel linguaggio di programmazione C. Grazie per aver letto questo articolo.
