Pipes
Kommunikation mellan förälder och barn.
Pipes är en gratis lektion i C Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för C Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C Academy innehåller totalt 4 lektioner.
Vad är en pipe
En pipe är en enkelriktad kommunikationskanal mellan relaterade processer. En process skriver byte till den och en annan läser ut dem, ungefär som ett transportband för data.
Två filbeskrivare
Anropet pipe() fyller en array med två element: fd[0] är läsänden och fd[1] är skrivänden. Data som skrivs till fd[1] kan läsas från 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;
}Kombinera med fork
Efter fork() delar både föräldern och barnet pipe:ens filbeskrivare. Det är så en förälder och ett barn kommunicerar: den ena skriver och den andra läser.
Stäng oanvända ändar
Varje process ska stänga den ände som den inte använder. En läsare stänger skrivänden och en skrivare stänger läsänden. Annars ser läsaren aldrig slutet på filen.
#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 */
}Ett exempel med förälder och barn
Föräldern skriver ett meddelande och barnet läser det. Båda stänger den ände som de inte behöver.
#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]);
}
}Läsning returnerar EOF
När alla skrivändar är stängda returnerar read 0, vilket signalerar slutet på filen. Om en skrivände förblir öppen blockerar läsaren för alltid i väntan på mer data, vilket är ett vanligt fel.
Pipe-kapacitet och blockering
En pipe har en buffert med begränsad storlek (ofta 64 KB). Om den blir full blockerar write tills en läsare tömmer den. Om den är tom blockerar read tills data anländer. Denna flödeskontroll synkroniserar de två processerna.
Omdirigera med dup2
dup2 kan ersätta en process standardindata eller standardutdata med en pipe-ände. Det är så skal implementerar cmd1 | cmd2 genom att koppla den ena kommandots utdata till nästa kommandos indata.
#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]);
}Namngivna pipes (FIFO:er)
En vanlig pipe kopplar endast samman relaterade processer. En namngiven pipe (FIFO), som skapas med mkfifo, visas i filsystemet så att orelaterade processer kan öppna den via en sökväg och kommunicera.
#include <sys/stat.h>
int make_fifo(const char *path) {
return mkfifo(path, 0666); /* creates a FIFO file */
}SIGPIPE-risk
Om du skriver till en pipe vars läsände är stängd utlöses SIGPIPE, vilket som standard avslutar processen. Ignorera antingen signalen eller kontrollera om write returnerar felet EPIPE.
När ska pipes användas
Pipes passar utmärkt för enkel, enkelriktad dataströmning mellan en förälder och ett barn eller för att kedja ihop program. För tvåvägskommunikation eller kommunikation mellan orelaterade processer kan du överväga FIFO:er, sockets eller delat minne.
Snabbkontroll
Testa dina kunskaper om pipes.
Sammanfattning
Du har lärt dig hur pipes används för kommunikation mellan förälder och barn.
pipe()ger fd[0] (läsning) och fd[1] (skrivning)- Kombinera med
forkoch stäng oanvända ändar - read returnerar 0 vid EOF när alla skrivändar stängs
- FIFO:er kopplar samman orelaterade processer; se upp med SIGPIPE
Lär dig C med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Pipes” gratis?
Ja – hela texten till ”Pipes” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i C Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i C Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Pipes”?
Kommunikation mellan förälder och barn. Ni övar på C Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig C Academy?
Du behöver inga förkunskaper. Utbildningen i C Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Pipes”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här C Academy-lektionen?
Ja. Varje C Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.