tuyau() est une fonction du système Linux. Le tuyau() La fonction système est utilisée pour ouvrir des descripteurs de fichiers, qui sont utilisés pour communiquer entre différents processus Linux. En bref, le tuyau() La fonction est utilisée pour la communication inter-processus dans Linux. Dans cet article, je vais vous montrer comment utiliser la fonction du système Pipe () dans Linux. Alors, commençons.

Fonction de pipe ():

La syntaxe du tuyau() La fonction est:

INT PIPE (int PipeFD [2]);

Ici, la fonction PIPE () crée un canal de données unidirectionnel pour la communication interprète. Vous passez dans un int (Entier) Type pipefd composé de 2 élément de tableau au tuyau de fonction (). Ensuite, la fonction tuyau () crée deux descripteurs de fichiers dans le pipefd déployer.

Le premier élément du pipefd déployer, Pipefd [0] est utilisé pour lire les données du tuyau.

Le deuxième élément du pipefd déployer, PipeFD [1] est utilisé pour écrire des données sur le tuyau.

Sur le succès, la fonction Pipe () renvoie 0. Si une erreur se produit pendant l'initialisation du tuyau, la fonction tuyau () renvoie -1.

La fonction tuyau () est définie dans l'en-tête unistd.H. Afin d'utiliser la fonction Pipe () dans votre programme C, vous devez inclure l'en-tête unistd.H comme suit:

#inclure

Pour plus d'informations sur la fonction Système Pipe (), vérifiez la page man de Pipe () avec la commande suivante:

$ man 2 tuyaux
La page de l'homme de Pipe ().

Exemple 1:

Pour le premier exemple, créez un nouveau fichier source C 1_pipe.c et saisir les lignes de codes suivantes.

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

printf ("Lire la valeur du descripteur de fichiers:% d \ n", tuy-gyming [0]);
printf ("Écrire la valeur du descripteur de fichiers:% d \ n", pipefds [1]);
return exit_success;

Ici, j'ai inclus le fichier d'en-tête de Pipe () unistd.H d'abord avec la ligne suivante.

#inclure

Ensuite, dans le principal() fonction, j'ai défini le pipe Tableau entier de deux éléments avec la ligne suivante.

int pipefds [2];

Ensuite, j'ai exécuté la fonction Pipe () pour initialiser le tableau des descripteurs de fichiers pipe comme suit.

tuyau (tuyfds)

J'ai également vérifié les erreurs en utilisant la valeur de retour de la fonction tuyau (). J'ai utilisé le sortie() fonction pour terminal le programme dans le cas où la fonction de tuyau échoue.

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

Ensuite, j'ai imprimé la valeur des descripteurs de fichiers de lecture et d'écriture PipeFDS [0] et PipeFDS [1] respectivement.

printf ("Lire la valeur du descripteur de fichiers:% d \ n", tuy-gyming [0]);
printf ("Écrire la valeur du descripteur de fichiers:% d \ n", pipefds [1]);

Si vous exécutez le programme, vous devriez voir la sortie suivante. Comme vous pouvez le voir, la valeur du descripteur de fichiers de tuyaux de lecture PipeFDS [0] est 3 et écrire un descripteur de fichiers de tuyaux PipeFDS [1] est 4.

Exemple 2:

Créer un autre fichier source C 2_.c et saisir les lignes de codes suivantes.

#inclure
#inclure
#inclure
#inclure
int main (void)
int pipefds [2];
tampon char [5];
if (pipe (tuypds) == -1)
perror ("tuyau");
exit (exit_failure);

char * pin = "4128 \ 0";
printf ("Écrire la broche au tuyau… \ n");
Écrire (PipeFDS [1], broche, 5);
printf ("fait.\ n \ n ");
printf ("Pin de lecture du tuyau… \ n");
lire (PipeFds [0], tampon, 5);
printf ("fait.\ n \ n ");
printf ("broche de tuyau:% s \ n", tampon);
return exit_success;

Ce programme vous montre essentiellement comment écrire sur le tuyau et lire les données que vous avez écrites dans le tuyau.

Ici, j'ai stocké un code de broche à 4 caractères dans un carboniser déployer. La longueur du tableau est de 5 (y compris le caractère nul \ 0).

char * pin = "4128 \ 0";

Chaque caractère ASCII a une taille de 1 octet en C. Donc, pour envoyer la broche à 4 chiffres à travers le tuyau, vous devez écrire 5 octets (4 + 1 caractère nul) de données dans le tuyau.

Pour écrire 5 octets de données (broche) Dans le tuyau, j'ai utilisé le écrire() fonction à l'aide du descripteur de fichier de tuyaux d'écriture PipeFDS [1] comme suit.

Écrire (PipeFDS [1], broche, 5);

Maintenant que j'ai des données dans le tuyau, je peux le lire à partir du tuyau en utilisant le lire() Fonction sur le descripteur de fichier de tuyau de lecture PipeFDS [0]. Comme j'ai écrit 5 octets de données (broche) Dans le tuyau, je lirai également 5 octets de données du tuyau. Les données lues seront stockées dans le amortir tableau de caractère. Comme je lirai 5 octets de données du tuyau, le amortir Le tableau des caractères doit mesurer au moins 5 octets.

J'ai défini le amortir tableau de caractères au début du principal() fonction.

tampon char [5];

Maintenant, je peux lire la broche du tuyau et la stocker dans le amortir tableau avec la ligne suivante.

lire (PipeFds [0], tampon, 5);

Maintenant que j'ai lu la broche du tuyau, je peux l'imprimer en utilisant le printf () fonctionne comme d'habitude.

printf ("broche de tuyau:% s \ n", tampon);

Une fois que j'ai exécuté le programme, la sortie correcte s'affiche comme vous pouvez le voir.

Exemple 3:

Créer un nouveau fichier source C 3_.c comme type dans les lignes de codes suivantes.

#inclure
#inclure
#inclure
#inclure
#inclure
int main (void)
int pipefds [2];
char * broche;
tampon char [5];
if (pipe (tuypds) == -1)
perror ("tuyau");
exit (exit_failure);

pid_t pid = fork ();
if (pid == 0) // dans le processus de l'enfant
pin = "4821 \ 0"; // épingle à envoyer
Close (PipeFDS [0]); // Fermer la lecture FD
Écrire (PipeFDS [1], broche, 5); // Écrivez la broche au tuyau
printf ("générer une broche dans l'enfant et envoyer à Parent… \ n");
sommeil (2); // retard intentionnel
exit (exit_success);

if (pid> 0) // dans le processus principal
attendre (null); // attendez que le processus enfant se termine
Close (PipeFDS [1]); // Fermer l'écriture FD
lire (PipeFds [0], tampon, 5); // Lire la broche du tuyau
Close (PipeFDS [0]); // Fermer la lecture FD
printf ("Parent reçu Pin '% s' \ n", tampon);

return exit_success;

Dans cet exemple, je vous ai montré comment utiliser le tuyau pour la communication interprète. J'ai envoyé une épingle du processus de l'enfant au processus parent à l'aide d'un tuyau. Ensuite, lisez la broche du tuyau dans le processus parent et imprimez-la à partir du processus parent.

Tout d'abord, j'ai créé un processus d'enfant à l'aide de la fonction Fork ().

pid_t pid = fork ();

Ensuite, dans le processus de l'enfant (pid == 0), J'ai écrit la broche au tuyau en utilisant le écrire() fonction.

Écrire (PipeFDS [1], broche, 5);

Une fois la broche écrite au tuyau du processus de l'enfant, le processus parent (pid> 0) Lisez-le à partir du tuyau en utilisant le lire() fonction.

lire (PipeFds [0], tampon, 5);

Ensuite, le processus parent a imprimé la broche en utilisant printf () fonctionne comme d'habitude.

printf ("Parent reçu Pin '% s' \ n", tampon);

Comme vous pouvez le voir, l'exécution du programme donne le résultat attendu.

Exemple 4:

Créer un nouveau fichier source C 4_.c comme type dans les lignes de codes suivantes.

#inclure
#inclure
#inclure
#inclure
#inclure
#define pin_length 4
#define pin_wait_interval 2
void getpin (char à charnière [pin_length + 1])
srand (getPid () + getppid ());
broche [0] = 49 + rand ()% 7;
pour (int i = 1; i < PIN_LENGTH; i++)
broche [i] = 48 + rand ()% 7;

pin [pin_length] = '\ 0';

int main (void)
tandis que (1)
int pipefds [2];
char à broche [pin_length + 1];
tampon char [pin_length + 1];
tuyau (pipefds);
pid_t pid = fork ();
if (pid == 0)
getPin (broche); // générer une broche
Close (PipeFDS [0]); // Fermer la lecture FD
écriture (tuy-gym bas [1], broche, pin_length + 1); // Écrivez la broche au tuyau
printf ("générer une broche dans l'enfant et envoyer à Parent… \ n");
Sleep (pin_wait_interval); // retarder la génération de broches intentionnellement.
exit (exit_success);

if (pid> 0)
attendre (null); // attendant que l'enfant finisse
Close (PipeFDS [1]); // Fermer l'écriture FD
lire (tuy-gym bas [0], tampon, pin_length + 1); // Lire la broche du tuyau
Close (PipeFDS [0]); // Fermer la lecture FD
printf ("Parent reçu Pin '% S' de l'enfant.\ n \ n ", tampon);


return exit_success;

Cet exemple est le même que Exemple 3. La seule différence est que ce programme crée continuellement un processus enfant, génère une broche dans le processus de l'enfant et envoie la broche au processus parent à l'aide d'un tuyau.

Le processus parent lit ensuite la broche du tuyau et l'imprime.

Ce programme génère une nouvelle broche Pin_length chaque PIN_WAIT_Interval Seconds.

Comme vous pouvez le voir, le programme fonctionne comme prévu.

Vous ne pouvez arrêter le programme qu'en appuyant sur + C.

C'est donc ainsi que vous utilisez l'appel du système Pipe () dans le langage de programmation C. Merci d'avoir lu cet article.