Phenquestions
Viskas apie vamzdį () Funkcija:
Sintaksė vamzdis () funkcija yra:
int vamzdis (int pipefd [2]);Čia „pipe ()“ funkcija sukuria vienakryptį duomenų kanalą tarpprocesiniam ryšiui. Pravažiuoji tarpt (Sveikasis) tipo masyvas pipefd susideda iš 2 matricos elemento prie funkcinio vamzdžio (). Tada funkcija pipe () sukuria du failų aprašus pipefd masyvas.
Pirmasis pipefd masyvas, pipefd [0] yra naudojamas duomenims nuskaityti iš vamzdžio.
Antrasis elementas pipefd masyvas, pipefd [1] yra naudojamas duomenims rašyti į vamzdį.
Sėkmingai funkcija pipe () grąžina 0. Jei inicijuojant vamzdį įvyksta klaida, funkcija pipe () grąžina -1.
Funkcija „pipe ()“ apibrėžta antraštėje unistd.h. Norėdami naudoti „pipe“) funkciją savo C programoje, turite įtraukti antraštę unistd.h taip:
# įtrauktiNorėdami gauti daugiau informacijos apie „pipe“ () sistemos funkciją, patikrinkite „pipe“ () vadovą puslapyje naudodami šią komandą:
$ man 2 vamzdis„Pipe“ () puslapis.
1 pavyzdys:
Pirmam pavyzdžiui sukurkite naują C šaltinio failą 1_pipe.c ir įveskite šias kodų eilutes.
# įtraukti# įtraukti
# įtraukti
int main (negaliojantis)
int pipefds [2];
jei (vamzdis (pipefds) == -1)
perror ("vamzdis");
išėjimas (EXIT_FAILURE);
printf ("Skaityti failo deskriptoriaus reikšmę:% d \ n", pipefds [0]);
printf ("Rašyti failo deskriptoriaus reikšmę:% d \ n", pipefds [1]);
grąžinti EXIT_SUCCESS;
Čia įtraukiau vamzdžio () antraštės failą unistd.h pirmiausia su šia eilute.
# įtrauktiTada, pagrindinis () funkciją, aš apibrėžiau pipefds dviejų elementų sveikojo skaičiaus masyvas su šia eilute.
int pipefds [2];Tada paleidau „pipe ()“ funkciją, kad inicijuočiau failų deskriptorių masyvą pipefds taip.
vamzdis (pipefds)Aš taip pat patikrinau, ar nėra klaidų, naudodamas grįžtamąją vamzdžio () vertę. Aš naudojau išėjimas () funkcija užbaigti programą tuo atveju, jei vamzdžio funkcija sugenda.
jei (vamzdis (pipefds) == -1)perror ("vamzdis");
išėjimas (EXIT_FAILURE);
Tada atspausdinau skaitymo ir rašymo failų failų aprašų vertę pipefds [0] ir pipefds [1] atitinkamai.
printf ("Skaityti failo deskriptoriaus reikšmę:% d \ n", pipefds [0]);printf ("Rašyti failo deskriptoriaus reikšmę:% d \ n", pipefds [1]);
Jei paleisite programą, turėtumėte pamatyti šį išvestį. Kaip matote, skaityto vamzdžio failo deskriptoriaus vertė pipefds [0] yra 3 ir parašykite vamzdžių bylos aprašą pipefds [1] yra 4.
2 pavyzdys:
Sukurkite kitą C šaltinio failą 2_pipe.c ir įveskite šias kodų eilutes.
# įtraukti# įtraukti
# įtraukti
# įtraukti
int main (negaliojantis)
int pipefds [2];
char buferis [5];
jei (vamzdis (pipefds) == -1)
perror ("vamzdis");
išėjimas (EXIT_FAILURE);
char * pin = "4128 \ 0";
printf ("PIN įrašymas į vamzdį ... \ n");
rašyti (pipefds [1], pin, 5);
printf ("Atlikta.\ n \ n ");
printf ("PIN skaitymas iš vamzdžio ... \ n");
skaityti (pipefds [0], buferis, 5);
printf ("Atlikta.\ n \ n ");
printf ("PIN iš vamzdžio:% s \ n", buferis);
grąžinti EXIT_SUCCESS;
Ši programa iš esmės parodo, kaip rašyti į vamzdį ir skaityti duomenis, kuriuos parašėte iš vamzdžio.
Čia aš išsaugojau 4 simbolių PIN kodą char masyvas. Masyvo ilgis yra 5 (įskaitant simbolį NULL \ 0).
char * pin = "4128 \ 0";Kiekvienas ASCII simbolis yra 1 baito dydžio C. Taigi, norėdami išsiųsti 4 skaitmenų PIN kodą per vamzdį, į vamzdį turite įrašyti 5 baitus (4 + 1 NULL simbolis) duomenų.
Parašyti 5 baitus duomenų (kaištis) į vamzdį, aš naudojau rašyti () funkcija, naudodama rašymo failo failo aprašą pipefds [1] taip.
rašyti (pipefds [1], pin, 5);Dabar, kai vamzdyje yra keletas duomenų, galiu juos perskaityti iš vamzdžio naudodamas skaityti () funkcija skaitymo failo failo apraše pipefds [0]. Kaip parašiau 5 baitus duomenų (kaištis) į vamzdį, aš taip pat skaitysiu 5 baitus duomenų iš vamzdžio. Perskaityti duomenys bus saugomi buferis simbolių masyvas. Kai skaitysiu 5 baitus duomenų iš vamzdžio, buferis simbolių masyvas turi būti bent 5 baitų ilgio.
Aš apibrėžiau buferis simbolių masyvas pagrindinis () funkcija.
char buferis [5];Dabar aš galiu perskaityti PIN kodą iš vamzdžio ir laikyti jį buferis masyvas su šia eilute.
skaityti (pipefds [0], buferis, 5);Dabar, kai perskaičiau PIN kodą iš vamzdžio, galiu jį atsispausdinti naudodamas printf () veikia kaip įprasta.
printf ("PIN iš vamzdžio:% s \ n", buferis);Kai paleidžiu programą, rodoma teisinga išvestis, kaip matote.
3 pavyzdys:
Sukurkite naują C šaltinio failą 3_pipe.c kaip įveskite šias kodų eilutes.
# įtraukti# įtraukti
# įtraukti
# įtraukti
# įtraukti
int main (negaliojantis)
int pipefds [2];
char * kaištis;
char buferis [5];
jei (vamzdis (pipefds) == -1)
perror ("vamzdis");
išėjimas (EXIT_FAILURE);
pid_t pid = šakutė ();
if (pid == 0) // vaiko procese
kaištis = "4821 \ 0"; // PIN siųsti
uždaryti (pipefds [0]); // uždaryti skaityti fd
rašyti (pipefds [1], pin, 5); // parašykite PIN kodą
printf ("PIN kodo generavimas vaikui ir siuntimas tėvams ... \ n");
miegas (2); // tyčinis delsimas
išėjimas (EXIT_SUCCESS);
if (pid> 0) // pagrindiniame procese
palaukti (NULL); // palaukite, kol baigsis vaiko procesas
uždaryti (pipefds [1]); // uždaryti rašyti fd
skaityti (pipefds [0], buferis, 5); // perskaityti PIN iš vamzdžio
uždaryti (pipefds [0]); // uždaryti skaityti fd
printf ("Tėvas gavo PIN kodą% s '\ n", buferis);
grąžinti EXIT_SUCCESS;
Šiame pavyzdyje aš parodžiau, kaip naudoti vamzdį tarpprocesiniam bendravimui. Išsiunčiau PIN kodą iš vaiko proceso į pirminį procesą naudodamas pypkę. Tada perskaitykite pirminio proceso vamzdžio PIN ir atspausdinkite jį iš pirminio proceso.
Pirma, aš sukūriau vaiko procesą naudodamas „fork ()“ funkciją.
pid_t pid = šakutė ();Tada vaiko procese (pid == 0), Parašiau PIN kodą į vamzdį naudodamas rašyti () funkcija.
rašyti (pipefds [1], pin, 5);Kai iš vaiko proceso bus įvestas PIN kodas, pagrindinis procesas (pid> 0) perskaitykite jį iš pypkės naudodami skaityti () funkcija.
skaityti (pipefds [0], buferis, 5);Tada pirminis procesas atspausdino PIN kodą naudodamas printf () veikia kaip įprasta.
printf ("Tėvas gavo PIN kodą% s '\ n", buferis);Kaip matote, programos vykdymas duoda laukiamą rezultatą.
4 pavyzdys:
Sukurkite naują C šaltinio failą 4_pipe.c kaip įveskite šias kodų eilutes.
# įtraukti# įtraukti
# įtraukti
# įtraukti
# įtraukti
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
negaliojantis getPIN (simbolio smeigtukas [PIN_LENGTH + 1])
srand (getpid () + getppid ());
kaištis [0] = 49 + randas ()% 7;
už (int i = 1; i < PIN_LENGTH; i++)
kaištis [i] = 48 + randas ()% 7;
kaištis [PIN_LENGTH] = '\ 0';
int main (negaliojantis)
o (1)
int pipefds [2];
simbolio smeigtukas [PIN_LENGTH + 1];
char buferis [PIN_LENGTH + 1];
vamzdis (pipefds);
pid_t pid = šakutė ();
jei (pid == 0)
getPIN (kaištis); // sugeneruoti PIN kodą
uždaryti (pipefds [0]); // uždaryti skaityti fd
rašyti (pipefds [1], pin, PIN_LENGTH + 1); // parašykite PIN kodą
printf ("PIN kodo generavimas vaikui ir siuntimas tėvams ... \ n");
miegas (PIN_WAIT_INTERVAL); // tyčia atidedamas PIN generavimas.
išėjimas (EXIT_SUCCESS);
jei (pid> 0)
palaukti (NULL); // laukiu, kol vaikas baigs
uždaryti (pipefds [1]); // uždaryti rašyti fd
skaityti (pipefds [0], buferis, PIN_LENGTH + 1); // skaityti PIN iš vamzdžio
uždaryti (pipefds [0]); // uždaryti skaityti fd
printf ("Tėvas gavo PIN kodą% s" iš vaiko.\ n \ n ", buferis);
grąžinti EXIT_SUCCESS;
Šis pavyzdys yra tas pats kaip 3 pavyzdys. Vienintelis skirtumas yra tas, kad ši programa nuolat kuria vaiko procesą, generuoja PIN procesą vaiko procese ir siunčia PIN kodą tėvų procesui.
Tėvų procesas nuskaito PIN kodą ir atspausdina.
Ši programa sugeneruoja naują PIN_LENGTH PIN kodą kas PIN_WAIT_INTERVAL sekundę.
Kaip matote, programa veikia kaip tikėtasi.
Programą galite sustabdyti tik paspausdami
Taigi, taip jūs naudojate „pipe ()“ sistemos iškvietimą C programavimo kalba. Dėkojame, kad perskaitėte šį straipsnį.
