La sintassi di tubo() la funzione è:
inttubo(intpipefd[2]);
Qui, la funzione pipe() crea un canale dati unidirezionale per la comunicazione tra processi. Passi in un int (Intero) tipo array pipefd costituito 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 dalla pipe.
Il secondo elemento della pipefd Vettore, pipefd[1] viene utilizzato 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:
#includere
Per maggiori informazioni sulla funzione di sistema pipe(), controlla la pagina man di pipe() con il seguente comando:
$ uomo2tuboLa pagina man di pipe().
Esempio 1:
Per il primo esempio, crea un nuovo file sorgente C 1_pipe.c e digitare le seguenti righe di codici.
#includere#includere
#includere
intprincipale(vuoto) {
intpipefds[2];
Se(tubo(pipefds) == -1) {
errore ('tubo');
Uscita (EXIT_FAILURE);
}
printf ('Leggi valore descrittore file: %d ',pipefds[0]);
printf ('Scrivi il valore del descrittore di file: %d ',pipefds[1]);
RestituzioneEXIT_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 riga seguente.
intpipefds[2];Quindi, ho eseguito la funzione pipe() per inizializzare l'array dei descrittori di file pipefds come segue.
tubo(pipefds)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.
Se(tubo(pipefds) == -1) {errore ('tubo');
Uscita (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 ',pipefds[0]);printf ('Scrivi il valore del descrittore di file: %d ',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_pipe.c e digitare le seguenti righe di codici.
#includere#includere
#includere
#includere
intprincipale(vuoto) {
intpipefds[2];
charrespingente[5];
Se(tubo(pipefds) == -1) {
errore ('tubo');
Uscita (EXIT_FAILURE);
}
char *spillo= '4128 0';
printf ('Scrivo PIN su pipe... ');
Scrivi(pipefds[1],spillo, 5);
printf ('Fatto. ');
printf ('Lettura PIN dalla pipe... ');
leggere(pipefds[0],respingente, 5);
printf ('Fatto. ');
printf ('PIN dalla pipe: %s ',respingente);
RestituzioneEXIT_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 ).
char *spillo= '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 ( spillo ) nel tubo, ho usato il Scrivi() funzione utilizzando il descrittore di file write pipe pipefd[1] come segue.
Scrivi(pipefds[1],spillo, 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 ( spillo ) nella pipe, leggerò anche 5 byte di dati dalla pipe. I dati letti verranno archiviati nel respingente matrice di caratteri. Poiché leggerò 5 byte di dati dalla pipe, il respingente l'array di caratteri deve essere lungo almeno 5 byte.
ho definito il respingente array di caratteri all'inizio del principale() funzione.
charrespingente[5];Ora posso leggere il PIN dalla pipe e memorizzarlo nel respingente array con la seguente riga.
leggere(pipefds[0],respingente, 5);Ora che ho letto il PIN dalla pipe, posso stamparlo usando il printf() funzionare come al solito.
printf ('PIN dalla pipe: %s ',respingente);Una volta eseguito il programma, viene visualizzato l'output corretto come puoi vedere.
Esempio 3:
Crea un nuovo file sorgente C 3_pipe.c come digitare nelle seguenti righe di codici.
#includere#includere
#includere
#includere
#includere
intprincipale(vuoto) {
intpipefds[2];
char *spillo;
charrespingente[5];
Se(tubo(pipefds) == -1) {
errore ('tubo');
Uscita (EXIT_FAILURE);
}
pid_t pid=forchetta();
Se(pid== 0) { // nel processo figlio
spillo= '4821 0'; // PIN da inviare
chiudere(pipefds[0]); // chiudi leggi fd
Scrivi(pipefds[1],spillo, 5); // scrivi il PIN su pipe
printf ('Generazione del PIN nel bambino e invio al genitore... ');
dormire(2); // ritardo intenzionale
Uscita (EXIT_SUCCESS);
}
Se(pid> 0) { // nel processo principale
aspettare(NULLO); // attendo che il processo figlio finisca
chiudere(pipefds[1]); // chiudi scrivi fd
leggere(pipefds[0],respingente, 5); // legge il PIN dalla pipe
chiudere(pipefds[0]); // chiudi leggi fd
printf ('Il genitore ha ricevuto il PIN '%s' ',respingente);
}
RestituzioneEXIT_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 leggere il PIN dalla pipe nel processo padre e stamparlo dal processo padre.
Innanzitutto, ho creato un processo figlio utilizzando la funzione fork().
pid_t pid=forchetta();Quindi, nel processo figlio ( pid == 0 ), ho scritto il PIN sulla pipe usando il Scrivi() funzione.
Scrivi(pipefds[1],spillo, 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.
leggere(pipefds[0],respingente, 5);Quindi, il processo padre ha stampato il PIN utilizzando printf() funzionare come al solito.
printf ('Il genitore ha ricevuto il PIN '%s' ',respingente);Come puoi vedere, l'esecuzione del programma dà il risultato atteso.
Esempio 4:
Crea un nuovo file sorgente C 4_pipe.c come digitare nelle seguenti righe di codici.
#includere#includere
#includere
#includere
#includere
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
vuotogetPIN(charspillo[PIN_LENGTH+ 1]) {
srand (getpid() +getppid());
spillo[0] = 49 + riga () % 7;
per(intio= 1;io<PIN_LENGTH;io++) {
spillo[io] = 48 + riga () % 7;
}
spillo[PIN_LENGTH] = ' 0';
}
intprincipale(vuoto) {
mentre(1) {
intpipefds[2];
charspillo[PIN_LENGTH+ 1];
charrespingente[PIN_LENGTH+ 1];
tubo(pipefds);
pid_t pid=forchetta();
Se(pid== 0) {
getPIN(spillo); // genera il PIN
chiudere(pipefds[0]); // chiudi leggi fd
Scrivi(pipefds[1],spillo,PIN_LENGTH+ 1); // scrivi il PIN su pipe
printf ('Generazione del PIN nel bambino e invio al genitore... ');
dormire(PIN_WAIT_INTERVAL); // ritardando intenzionalmente la generazione del PIN.
Uscita (EXIT_SUCCESS);
}
Se(pid> 0) {
aspettare(NULLO); // aspetto che il bambino finisca
chiudere(pipefds[1]); // chiudi scrivi fd
leggere(pipefds[0],respingente,PIN_LENGTH+ 1); // legge il PIN dalla pipe
chiudere(pipefds[0]); // chiudi leggi fd
printf ('Il genitore ha ricevuto il PIN '%s' dal figlio. ',respingente);
}
}
RestituzioneEXIT_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 + C .
Quindi, questo è il modo in cui usi la chiamata di sistema pipe() nel linguaggio di programmazione C. Grazie per aver letto questo articolo.