Phenquestions
Tout sur la fonction 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 inter-processus. Vous passez dans un entier Tableau de type (entier) pipefd composé de 2 éléments de tableau à la fonction pipe(). Ensuite, la fonction pipe() crée deux descripteurs de fichier dans le pipefd déployer.
Le premier élément de la pipefd déployer, pipefd[0] est utilisé pour lire les données du tuyau.
Le deuxième élément de la pipefd déployer, pipefd[1] est utilisé pour écrire des données dans le tube.
En cas de succès, la fonction pipe() renvoie 0. Si une erreur se produit lors de l'initialisation du tube, la fonction pipe() renvoie -1.
La fonction pipe() est définie dans l'en-tête unistd.h. Pour utiliser la fonction pipe() dans votre programme C, vous devez inclure l'en-tête unistd.h comme suit:
#inclurePour plus d'informations sur la fonction système pipe(), consultez la page de manuel de pipe() avec la commande suivante :
$ homme 2 tuyauxLa page de manuel de pipe().
Exemple 1:
Pour le premier exemple, créez un nouveau fichier source C 1_tuyau.c et tapez les lignes de codes suivantes.
#inclure#inclure
#inclure
int main(void)
int pipefds[2];
if(pipe(pipefds) == -1)
perror("tuyau");
exit(EXIT_FAILURE);
printf("Lire la valeur du descripteur de fichier : %d\n", pipefds[0]);
printf("Ecrire la valeur du descripteur de fichier : %d\n", pipefds[1]);
renvoie EXIT_SUCCESS ;
Ici, j'ai inclus le fichier d'en-tête de pipe() unistd.h d'abord avec la ligne suivante.
#inclureEnsuite, dans le principale() fonction, j'ai défini la pipefds tableau d'entiers à 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 pipefds comme suit.
tuyau (pipefds)J'ai également vérifié les erreurs en utilisant la valeur de retour de la fonction pipe(). j'ai utilisé le sortir() fonction pour terminer le programme en cas d'échec de la fonction pipe.
if(pipe(pipefds) == -1)perror("tuyau");
exit(EXIT_FAILURE);
Ensuite, j'ai imprimé la valeur des descripteurs de fichier pipe en lecture et en écriture pipefds[0] et pipefd[1] respectivement.
printf("Lire la valeur du descripteur de fichier : %d\n", pipefds[0]);printf("Ecrire la valeur du descripteur de fichier : %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 fichier read pipe pipefds[0] est 3 et écrire le descripteur de fichier pipe pipefd[1] est 4.
Exemple 2 :
Créer un autre fichier source C 2_tuyau.c et tapez les lignes de codes suivantes.
#inclure#inclure
#inclure
#inclure
int main(void)
int pipefds[2];
tampon de caractères[5];
if(pipe(pipefds) == -1)
perror("tuyau");
exit(EXIT_FAILURE);
char *pin = "4128\0" ;
printf("Ecriture du code PIN dans le tube… \n");
écrire(pipefds[1], broche, 5);
printf("Terminé.\n\n");
printf("Lecture du code PIN du tube… \n");
read(pipefds[0], tampon, 5);
printf("Terminé.\n\n");
printf("PIN du tube : %s\n", buffer);
renvoie EXIT_SUCCESS ;
Ce programme vous montre essentiellement comment écrire dans le tube et lire les données que vous avez écrites à partir du tube.
Ici, j'ai stocké un code PIN à 4 caractères dans un carboniser déployer. La longueur du tableau est de 5 (y compris le caractère NULL \0).
char *pin = "4128\0" ;Chaque caractère ASCII a une taille de 1 octet en C. Ainsi, pour envoyer le code PIN à 4 chiffres via le canal, vous devez écrire 5 octets (4 + 1 caractère NULL) de données dans le canal.
Pour écrire 5 octets de données (épingler) dans le tuyau, j'ai utilisé le écrivez() fonction utilisant le descripteur de fichier pipe d'écriture pipefd[1] comme suit.
écrire(pipefds[1], broche, 5);Maintenant que j'ai des données dans le tuyau, je peux les lire à partir du tuyau en utilisant le lis() fonction sur le descripteur de fichier pipe lu pipefds[0]. Comme j'ai écrit 5 octets de données (épingler) dans le tuyau, je vais également lire 5 octets de données du tuyau. Les données lues seront stockées dans le amortir tableau de caractères. Comme je vais lire 5 octets de données du tuyau, le amortir le tableau de caractères doit faire au moins 5 octets.
j'ai défini le amortir tableau de caractères au début du principale() une fonction.
tampon de caractères[5];Maintenant, je peux lire le code PIN du tuyau et le stocker dans le amortir tableau avec la ligne suivante.
read(pipefds[0], tampon, 5);Maintenant que j'ai lu le code PIN du tuyau, je peux l'imprimer en utilisant le printf() fonctionner comme d'habitude.
printf("PIN du tube : %s\n", buffer);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_tuyau.c comme type dans les lignes de codes suivantes.
#inclure#inclure
#inclure
#inclure
#inclure
int main(void)
int pipefds[2];
char *épingle;
tampon de caractères[5];
if(pipe(pipefds) == -1)
perror("tuyau");
exit(EXIT_FAILURE);
pid_t pid = fourche();
if(pid == 0) // dans le processus fils
broche = "4821\0" ; // PIN à envoyer
close(pipefds[0]); // ferme read fd
écrire(pipefds[1], broche, 5); // écrire le code PIN dans le tube
printf("Génération du code PIN dans l'enfant et envoi au parent… \n");
sommeil(2); // retard intentionnel
exit(EXIT_SUCCESS);
if(pid > 0) // dans le processus principal
attendre(NULL); // attend la fin du processus fils
close(pipefds[1]); // ferme l'écriture de fd
read(pipefds[0], tampon, 5); // lit le code PIN du tube
close(pipefds[0]); // ferme read fd
printf("Le parent a reçu le code PIN '%s'\n", buffer);
renvoie EXIT_SUCCESS ;
Dans cet exemple, je vous ai montré comment utiliser pipe pour la communication inter-processus. J'ai envoyé un code PIN du processus enfant au processus parent à l'aide d'un canal. Ensuite, lisez le code PIN du tuyau dans le processus parent et imprimez-le à partir du processus parent.
Tout d'abord, j'ai créé un processus enfant à l'aide de la fonction fork ().
pid_t pid = fourche();Ensuite, dans le processus fils (pid == 0), j'ai écrit le code PIN sur le tuyau en utilisant le écrivez() une fonction.
écrire(pipefds[1], broche, 5);Une fois le code PIN écrit dans le canal à partir du processus enfant, le processus parent (pid > 0) lisez-le à partir du tuyau en utilisant le lis() une fonction.
read(pipefds[0], tampon, 5);Ensuite, le processus parent a imprimé le code PIN en utilisant printf() fonctionner comme d'habitude.
printf("Le parent a reçu le code PIN '%s'\n", buffer);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_tuyau.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 pin[PIN_LENGTH + 1])
srand(getpid() + getppid());
broche[0] = 49 + rand() % 7 ;
for(int i = 1; je < PIN_LENGTH; i++)
broche[i] = 48 + rand() % 7 ;
pin[PIN_LENGTH] = '\0';
int main(void)
tandis que (1)
int pipefds[2];
car pin[PIN_LENGTH + 1] ;
tampon de caractères [PIN_LENGTH + 1] ;
pipe(pipefds);
pid_t pid = fourche();
if(pid == 0)
getPIN(broche); // générer le code PIN
close(pipefds[0]); // ferme read fd
écrire (pipefds[1], broche, PIN_LENGTH + 1); // écrire le code PIN dans le tube
printf("Génération du code PIN dans l'enfant et envoi au parent… \n");
sommeil(PIN_WAIT_INTERVAL); // retarder intentionnellement la génération du code PIN.
exit(EXIT_SUCCESS);
si(pid > 0)
attendre(NULL); // attend que l'enfant finisse
close(pipefds[1]); // ferme l'écriture de fd
read(pipefds[0], tampon, PIN_LENGTH + 1); // lit le code PIN du tube
close(pipefds[0]); // ferme read fd
printf("Le parent a reçu le code PIN '%s' de l'enfant.\n\n", tampon);
renvoie EXIT_SUCCESS ;
Cet exemple est le même que Exemple 3. La seule différence est que ce programme crée en permanence un processus enfant, génère un code PIN dans le processus enfant et envoie le code PIN au processus parent à l'aide d'un tube.
Le processus parent lit ensuite le code PIN du tube et l'imprime.
Ce programme génère un nouveau PIN_LENGTH toutes les PIN_WAIT_INTERVAL secondes.
Comme vous pouvez le voir, le programme fonctionne comme prévu.
Vous ne pouvez arrêter le programme qu'en appuyant sur
Donc, voici comment vous utilisez l'appel système pipe() en langage de programmation C. Merci d'avoir lu cet article.
