La syntaxe du tuyau() la fonction est :
entiertuyau(entierpipefd[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 tuyau, 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:
#comprendre
Pour plus d'informations sur la fonction système pipe(), consultez la page de manuel de pipe() avec la commande suivante :
$ homme2tuyauLa 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.
#comprendre#comprendre
#comprendre
entierprincipale(annuler) {
entierpipefds[2];
si(tuyau(pipefds) == -1) {
erreur ('tuyau');
sortir (EXIT_FAILURE);
}
imprimer ('Lire la valeur du descripteur de fichier : %d ',pipefds[0]);
imprimer ('Écrire la valeur du descripteur de fichier : %d ',pipefds[1]);
revenirEXIT_SUCCESS;
}
Ici, j'ai inclus le fichier d'en-tête de pipe() unistd.h d'abord avec la ligne suivante.
#comprendreEnsuite, dans le principale() fonction, j'ai défini la pipefds tableau d'entiers à deux éléments avec la ligne suivante.
entierpipefds[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() pour terminer le programme en cas d'échec de la fonction pipe.
si(tuyau(pipefds) == -1) {erreur ('tuyau');
sortir (EXIT_FAILURE);
}
Ensuite, j'ai imprimé la valeur des descripteurs de fichier pipe en lecture et en écriture pipefds[0] et pipefd[1] respectivement.
imprimer ('Lire la valeur du descripteur de fichier : %d ',pipefds[0]);imprimer ('Écrire la valeur du descripteur de fichier : %d ',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.
#comprendre#comprendre
#comprendre
#comprendre
entierprincipale(annuler) {
entierpipefds[2];
carboniseramortir[5];
si(tuyau(pipefds) == -1) {
erreur ('tuyau');
sortir (EXIT_FAILURE);
}
carboniser *épingler= '4128 0';
imprimer ('Écriture du code PIN dans le tuyau... ');
écrivez(pipefds[1],épingler, 5);
imprimer ('Terminé. ');
imprimer ('Lecture du code PIN du tuyau... ');
lire(pipefds[0],amortir, 5);
imprimer ('Terminé. ');
imprimer ('PIN du canal : %s ',amortir);
revenirEXIT_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 ).
carboniser *épingler= '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.
écrivez(pipefds[1],épingler, 5);Maintenant que j'ai des données dans le tuyau, je peux les lire à partir du tuyau en utilisant le lire() fonction sur le descripteur de fichier pipe lu pipefds[0] . Comme j'ai écrit 5 octets de données ( épingler ) dans le tube, je vais également lire 5 octets de données du tube. 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() fonction.
carboniseramortir[5];Maintenant, je peux lire le code PIN du tuyau et le stocker dans le amortir tableau avec la ligne suivante.
lire(pipefds[0],amortir, 5);Maintenant que j'ai lu le code PIN du tuyau, je peux l'imprimer en utilisant le printf() fonctionner comme d'habitude.
imprimer ('PIN du canal : %s ',amortir);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 en tant que type dans les lignes de codes suivantes.
#comprendre#comprendre
#comprendre
#comprendre
#comprendre
entierprincipale(annuler) {
entierpipefds[2];
carboniser *épingler;
carboniseramortir[5];
si(tuyau(pipefds) == -1) {
erreur ('tuyau');
sortir (EXIT_FAILURE);
}
pid_t pid=fourchette();
si(pid== 0) { // dans le processus fils
épingler= '4821 0'; // PIN à envoyer
proche(pipefds[0]); // ferme read fd
écrivez(pipefds[1],épingler, 5); // écrire le code PIN dans le tube
imprimer ('Génération du code PIN chez l'enfant et envoi au parent... ');
dormir(2); // retard intentionnel
sortir (EXIT_SUCCESS);
}
si(pid> 0) { // dans le processus principal
attendre(NUL); // attend la fin du processus fils
proche(pipefds[1]); // ferme l'écriture de fd
lire(pipefds[0],amortir, 5); // lit le code PIN du tube
proche(pipefds[0]); // ferme read fd
imprimer ('Le parent a reçu le code PIN '%s' ',amortir);
}
revenirEXIT_SUCCESS;
}
Dans cet exemple, je vous ai montré comment utiliser le tuyau 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 canal 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=fourchette();Ensuite, dans le processus fils ( pid == 0 ), j'ai écrit le code PIN sur le tuyau en utilisant le écrivez() fonction.
écrivez(pipefds[1],épingler, 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 lire() fonction.
lire(pipefds[0],amortir, 5);Ensuite, le processus parent a imprimé le code PIN en utilisant printf() fonctionner comme d'habitude.
imprimer ('Le parent a reçu le code PIN '%s' ',amortir);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 en tant que type dans les lignes de codes suivantes.
#comprendre#comprendre
#comprendre
#comprendre
#comprendre
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
annulerobtenir le NIP(carboniserépingler[PIN_LENGTH+ 1]) {
srand (getpid() +getppid());
épingler[0] = 49 + ligne () % 7;
pour(entierje= 1;je<PIN_LENGTH;je++) {
épingler[je] = 48 + ligne () % 7;
}
épingler[PIN_LENGTH] = ' 0';
}
entierprincipale(annuler) {
tandis que(1) {
entierpipefds[2];
carboniserépingler[PIN_LENGTH+ 1];
carboniseramortir[PIN_LENGTH+ 1];
tuyau(pipefds);
pid_t pid=fourchette();
si(pid== 0) {
obtenir le NIP(épingler); // générer le code PIN
proche(pipefds[0]); // ferme read fd
écrivez(pipefds[1],épingler,PIN_LENGTH+ 1); // écrire le code PIN dans le tube
imprimer ('Génération du code PIN chez l'enfant et envoi au parent... ');
dormir(PIN_WAIT_INTERVAL); // retarder intentionnellement la génération du code PIN.
sortir (EXIT_SUCCESS);
}
si(pid> 0) {
attendre(NUL); // attend que l'enfant finisse
proche(pipefds[1]); // ferme l'écriture de fd
lire(pipefds[0],amortir,PIN_LENGTH+ 1); // lit le code PIN du tube
proche(pipefds[0]); // ferme read fd
imprimer ('Le parent a reçu le code PIN '%s' de l'enfant. ',amortir);
}
}
revenirEXIT_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 canal.
Le processus parent lit ensuite le code PIN du canal et l'imprime.
Ce programme génère un nouveau code PIN 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 + C .
Voici donc comment utiliser l'appel système pipe() en langage de programmation C. Merci d'avoir lu cet article.