tubo() è una funzione di sistema Linux. IL tubo() La funzione di sistema viene utilizzata per aprire i descrittori di file, che vengono utilizzati per comunicare tra diversi processi Linux. In breve, il tubo() La funzione viene utilizzata per la comunicazione tra process in Linux. In questo articolo, ti mostrerò come utilizzare la funzione di sistema pipe () in Linux. Quindi iniziamo.

Funzione tutto sulla pipe ():

La sintassi del tubo() La funzione è:

int pipe (int pipefd [2]);

Qui, la funzione Pipe () crea un canale di dati unidirezionale per la comunicazione tra processo. Passi in un int (Intero) Array di tipo Pipefd composto da 2 elementi array al tubo di funzione (). Quindi la funzione pipe () crea due descrittori di file in Pipefd vettore.

Il primo elemento del Pipefd vettore, Pipefd [0] viene utilizzato per leggere i dati dal tubo.

Il secondo elemento del Pipefd vettore, Pipefd [1] viene utilizzato per scrivere dati sul tubo.

Al successo, la funzione pipe () restituisce 0. Se si verifica un errore durante l'inizializzazione del tubo, la funzione tubo () restituisce -1.

La funzione Pipe () è definita nell'intestazione unistd.H. Per utilizzare la funzione pipe () nel programma C, è necessario includere l'intestazione unistd.H come segue:

#includere

Per ulteriori informazioni sulla funzione di sistema pipe (), controllare la pagina man di pipe () con il seguente comando:

$ man 2 pipe
The Man Page of Pipe ().

Esempio 1:

Per il primo esempio, crea un nuovo file di origine C 1_pipe.C e digitare le seguenti righe di codici.

#includere
#includere
#includere
int main (void)
int pipefds [2];
if (pipe (pipefds) == -1)
perror ("pipe");
exit (exit_failure);

printf ("Leggi il valore del descrittore dei file: %d \ n", pipefds [0]);
printf ("Scrivi il valore del descrittore dei file: %d \ n", pipefds [1]);
restituire exit_success;

Qui, ho incluso il file di intestazione di pipe () unistd.H Prima con la riga seguente.

#includere

Quindi, nel principale() funzione, ho definito il Pipefds Array intero a due elementi con la riga seguente.

int pipefds [2];

Quindi, ho eseguito la funzione pipe () per inizializzare l'array di descrittori di file Pipefds come segue.

Pipe (Pipefds)

Ho anche verificato gli errori utilizzando il valore di ritorno della funzione pipe (). Ho usato il Uscita() funzione al terminale il programma nel caso in cui la funzione del tubo fallisca.

if (pipe (pipefds) == -1)
perror ("pipe");
exit (exit_failure);

Quindi, ho stampato il valore dei descrittori di file di lettura e scrittura Pipefds [0] E Pipefds [1] rispettivamente.

printf ("Leggi il valore del descrittore dei file: %d \ n", pipefds [0]);
printf ("Scrivi il valore del descrittore dei file: %d \ n", pipefds [1]);

Se esegui il programma, dovresti vedere il seguente output. Come puoi vedere, il valore del descrittore dei file di lettura Pipefds [0] È 3 e scrivi il descrittore di file pipe Pipefds [1] È 4.

Esempio 2:

Crea un altro file di origine C 2_pipe.C e digitare le seguenti righe di codici.

#includere
#includere
#includere
#includere
int main (void)
int pipefds [2];
Char Buffer [5];
if (pipe (pipefds) == -1)
perror ("pipe");
exit (exit_failure);

char *pin = "4128 \ 0";
printf ("writing pin to pipe… \ n");
scrivere (pipefds [1], pin, 5);
printf ("Done.\ n \ n ");
printf ("Lettura del perno dal tubo… \ n");
leggi (Pipefds [0], buffer, 5);
printf ("Done.\ n \ n ");
printf ("pin dal tubo: %s \ n", buffer);
restituire exit_success;

Questo programma in pratica mostra come scrivere sul tubo e leggere i dati che hai scritto dal tubo.

Qui, ho memorizzato un codice PIN a 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 il tubo, è necessario scrivere 5 byte (carattere null 4 + 1) di dati nel tubo.

Per scrivere 5 byte di dati (spillo) nel tubo, ho usato il scrivere() funzione utilizzando il descrittore dei file tubi di scrittura Pipefds [1] come segue.

scrivere (pipefds [1], pin, 5);

Ora che ho alcuni dati nel tubo, posso leggerli dal tubo usando il Leggere() funzione sul descrittore dei file di lettura tubo Pipefds [0]. Come ho scritto 5 byte di dati (spillo) nel tubo, leggerò anche 5 byte di dati dal tubo. I dati letti verranno archiviati in respingente array di caratteri. Come leggerò 5 byte di dati dal tubo, il respingente L'array di caratteri deve essere lungo almeno 5 byte.

Ho definito il respingente Array di caratteri all'inizio del principale() funzione.

Char Buffer [5];

Ora posso leggere il perno dal tubo e archiviarlo nel respingente Array con la riga seguente.

leggi (Pipefds [0], buffer, 5);

Ora che ho letto il pin dal tubo, posso stamparlo usando il printf () Funzionare come al solito.

printf ("pin dal tubo: %s \ n", buffer);

Una volta eseguito il programma, viene visualizzato l'output corretto come puoi vedere.

Esempio 3:

Crea un nuovo file di origine C 3_pipe.C come digitare le seguenti righe di codici.

#includere
#includere
#includere
#includere
#includere
int main (void)
int pipefds [2];
char *pin;
Char Buffer [5];
if (pipe (pipefds) == -1)
perror ("pipe");
exit (exit_failure);

pid_t pid = fork ();
if (pid == 0) // nel processo figlio
pin = "4821 \ 0"; // Pin da inviare
chiudere (pipefds [0]); // Chiudi leggere FD
scrivere (pipefds [1], pin, 5); // Scrivi il pin al tubo
printf ("Generazione del pin in figlio e invio al genitore ... \ n");
sonno (2); // ritardo intenzionale
usit (exit_success);

if (pid> 0) // nel processo principale
wait (null); // Aspetta che il processo del bambino finisca
chiudere (pipefds [1]); // Chiudi scrivere fd
leggi (Pipefds [0], buffer, 5); // Leggi il pin dal tubo
chiudere (pipefds [0]); // Chiudi leggere FD
printf ("genitore ha ricevuto pin '%s' \ n", buffer);

restituire exit_success;

In questo esempio, ti ho mostrato come usare il tubo per la comunicazione tra processi. Ho inviato un pin dal processo figlio al processo genitore usando un tubo. Quindi leggi il pin dal tubo nel processo genitore e lo stampato dal processo genitore.

Innanzitutto, ho creato un processo figlio usando la funzione fork ().

pid_t pid = fork ();

Quindi, nel processo del bambino (pid == 0), Ho scritto il perno al tubo usando il scrivere() funzione.

scrivere (pipefds [1], pin, 5);

Una volta che il pin è stato scritto sul tubo dal processo figlio, il processo genitore (PID> 0) Leggilo dal tubo usando il Leggere() funzione.

leggi (Pipefds [0], buffer, 5);

Quindi, il processo genitore ha stampato il pin utilizzando printf () Funzionare come al solito.

printf ("genitore ha ricevuto pin '%s' \ n", buffer);

Come puoi vedere, l'esecuzione del programma fornisce il risultato previsto.

Esempio 4:

Crea un nuovo file di origine C 4_pipe.C come digitare le 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;
per (int i = 1; i < PIN_LENGTH; i++)
pin [i] = 48 + rand () % 7;

pin [pin_length] = '\ 0';

int main (void)
while (1)
int pipefds [2];
char pin [pin_length + 1];
char buffer [pin_length + 1];
pipe (pipefds);
pid_t pid = fork ();
if (pid == 0)
getpin (pin); // Genera PIN
chiudere (pipefds [0]); // Chiudi leggere FD
scrivere (pipefds [1], pin, pin_length + 1); // Scrivi il pin al tubo
printf ("Generazione del pin in figlio e invio al genitore ... \ n");
sleep (pin_wait_interval); // ritardando intenzionalmente la generazione dei pin.
usit (exit_success);

if (pid> 0)
wait (null); // Aspettando che il bambino finisca
chiudere (pipefds [1]); // Chiudi scrivere fd
leggi (Pipefds [0], buffer, pin_length + 1); // Leggi il pin dal tubo
chiudere (pipefds [0]); // Chiudi leggere FD
printf ("genitore ha ricevuto pin '%s' da 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 genitore utilizzando un tubo.

Il processo genitore legge quindi il pin dal tubo e lo stampa.

Questo programma genera un nuovo pin pin_length ogni pin_wait_interval secondi.

Come puoi vedere, il programma funziona come previsto.

Puoi fermare il programma solo premendo + C.

Quindi, questo è il modo in cui si utilizza la chiamata di sistema pipe () in linguaggio di programmazione C. Grazie per aver letto questo articolo.