Tubes
Communication parent-enfant
Tubes est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.
Qu'est-ce qu'un tube
Un tube est un canal de communication unidirectionnel entre des processus liés. Un processus y écrit des octets et un autre les lit, comme sur un tapis roulant de données.
Deux descripteurs de fichiers
L'appel pipe() remplit un tableau de deux éléments : fd[0] est l'extrémité de lecture et fd[1] l'extrémité d'écriture. Les données écrites dans fd[1] peuvent être lues depuis fd[0].
#include <unistd.h>
#include <stdio.h>
int make_pipe(int fd[2]) {
if (pipe(fd) < 0) { perror("pipe"); return -1; }
/* fd[0] read end, fd[1] write end */
return 0;
}Combiner avec fork
Après fork(), le processus parent et le processus enfant partagent les descripteurs du tube. C'est ainsi qu'ils communiquent : l'un écrit et l'autre lit.
Fermer les extrémités inutilisées
Chaque processus doit fermer l'extrémité qu'il n'utilise pas. Un lecteur ferme l'extrémité d'écriture ; un écrivain ferme l'extrémité de lecture. Sinon, le lecteur ne voit jamais la fin du fichier.
#include <unistd.h>
void parent_as_writer(int fd[2]) {
close(fd[0]); /* parent will not read */
write(fd[1], "hello", 5); /* parent writes */
close(fd[1]); /* signal EOF to reader */
}Un exemple parent-enfant
Le parent écrit un message ; l'enfant le lit. Chacun ferme l'extrémité dont il n'a pas besoin.
#include <unistd.h>
#include <stdio.h>
void demo(int fd[2]) {
if (fork() == 0) { /* child: reader */
close(fd[1]);
char buf[64];
ssize_t n = read(fd[0], buf, sizeof buf - 1);
buf[n] = 0;
printf("child got: %s\n", buf);
close(fd[0]);
} else { /* parent: writer */
close(fd[0]);
write(fd[1], "hi child", 8);
close(fd[1]);
}
}La lecture renvoie EOF
Lorsque toutes les extrémités d'écriture sont fermées, read renvoie 0, ce qui signale la fin du fichier. Si une extrémité d'écriture reste ouverte, le lecteur se bloque indéfiniment en attendant d'autres données, ce qui constitue un bogue fréquent.
Capacité et blocage des tubes
Un tube possède un tampon de capacité limitée (souvent 64 KB). Lorsqu'il est plein, write se bloque jusqu'à ce qu'un lecteur le vide. Lorsqu'il est vide, read se bloque jusqu'à l'arrivée de données. Ce contrôle du flux synchronise les deux processus.
Rediriger avec dup2
dup2 peut remplacer l'entrée standard ou la sortie standard d'un processus par une extrémité de tube. C'est ainsi que les interpréteurs de commandes implémentent cmd1 | cmd2, en reliant la sortie d'une commande à l'entrée de la suivante.
#include <unistd.h>
void stdout_to_pipe(int fd[2]) {
close(fd[0]);
dup2(fd[1], STDOUT_FILENO); /* writes to stdout go into pipe */
close(fd[1]);
}Tubes nommés (FIFOs)
Un tube ordinaire ne relie que des processus liés. Un tube nommé (FIFO), créé avec mkfifo, apparaît dans le système de fichiers ; des processus sans lien peuvent donc l'ouvrir par son chemin et communiquer.
#include <sys/stat.h>
int make_fifo(const char *path) {
return mkfifo(path, 0666); /* creates a FIFO file */
}Risque lié à SIGPIPE
Écrire dans un tube dont l'extrémité de lecture est fermée déclenche SIGPIPE, qui tue le processus par défaut. Vous pouvez soit ignorer le signal, soit vérifier l'erreur EPIPE renvoyée par write.
Quand utiliser les tubes
Les tubes sont idéaux pour diffuser simplement des données dans un seul sens entre un parent et un enfant, ou pour enchaîner des programmes. Pour une communication bidirectionnelle ou entre des processus sans lien, envisagez les FIFOs, les sockets ou la mémoire partagée.
Vérification rapide
Testez votre compréhension des tubes.
Récapitulatif
Vous avez appris à utiliser les tubes pour la communication entre un parent et un enfant.
pipe()fournit fd[0] (lecture) et fd[1] (écriture)- Combinez-le avec
fork; fermez les extrémités inutilisées - read renvoie 0 à la fin du fichier lorsque toutes les extrémités d'écriture sont fermées
- Les FIFOs relient des processus sans lien ; méfiez-vous de SIGPIPE
Apprends C avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 39
- Leçons
- 144
Questions Fréquemment Posées
La leçon « Tubes » est-elle gratuite ?
Oui — le texte complet de « Tubes » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Tubes » ?
Communication parent-enfant Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C Academy ?
Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Tubes » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C Academy ?
Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.