Phenquestions
All About pipe () Funkció:
A szintaxisa a cső() funkció:
int cső (int pipefd [2]);Itt a pipe () függvény egyirányú adatcsatornát hoz létre a folyamatok közötti kommunikációhoz. Áthalad egy int (Egész) típusú tömb pipefd 2 tömb elemből áll a funkciócsőig (). Ezután a pipe () függvény két fájlleírót hoz létre a pipefd sor.
A. Első eleme pipefd sor, pipefd [0] a cső adatainak kiolvasására szolgál.
A. Második eleme pipefd sor, pipefd [1] adatok írására szolgál a csőhöz.
Siker esetén a pipe () függvény 0-t ad vissza. Ha hiba történik a cső inicializálása során, akkor a pipe () függvény -1-et ad vissza.
A pipe () függvény a fejlécben van meghatározva unistd.h. A pipe () függvény C-programban való használatához be kell illesztenie a fejlécet unistd.h alábbiak szerint:
#includeHa többet szeretne tudni a pipe () rendszer funkciójáról, ellenőrizze a pipe () man oldalát a következő paranccsal:
$ man 2 pipeA pipe () man oldala.
1. példa:
Az első példához hozzon létre egy új C forrásfájlt 1_pipe.c és írja be a következő kódsorokat.
#include#include
#include
int main (érvénytelen)
int pipefds [2];
if (cső (pipefds) == -1)
perror ("cső");
kilépés (EXIT_FAILURE);
printf ("Fájlleíró értékének olvasása:% d \ n", pipefds [0]);
printf ("Fájlleíró érték írása:% d \ n", pipefds [1]);
visszatér EXIT_SUCCESS;
Ide illesztettem a pipe () fejlécfájlját unistd.h először a következő sorral.
#includeAztán a fő() függvényt definiáltam pipefds két elemű egész tömb a következő sorral.
int pipefds [2];Ezután lefuttattam a pipe () függvényt a fájlleíró tömb inicializálásához pipefds alábbiak szerint.
cső (pipefds)A pipe () függvény visszatérési értékét is felhasználva ellenőriztem a hibákat. Használtam a kijárat() funkció a program lezárására abban az esetben, ha a csőfunkció meghibásodik.
if (cső (pipefds) == -1)perror ("cső");
kilépés (EXIT_FAILURE);
Ezután kinyomtattam az olvasási és írási csőfájl leírók értékét pipefds [0] és pipefds [1] illetőleg.
printf ("Fájlleíró értékének olvasása:% d \ n", pipefds [0]);printf ("Fájlleíró érték írása:% d \ n", pipefds [1]);
Ha futtatja a programot, akkor a következő kimenetet kell látnia. Amint láthatja, az olvasott pip fájl leíró értéke pipefds [0] van 3 és írja a pipa fájl leíróját pipefds [1] van 4.
2. példa:
Hozzon létre egy másik C forrásfájlt 2_pipe.c és írja be a következő kódsorokat.
#include#include
#include
#include
int main (érvénytelen)
int pipefds [2];
char puffer [5];
if (cső (pipefds) == -1)
perror ("cső");
kilépés (EXIT_FAILURE);
char * pin = "4128 \ 0";
printf ("PIN írása a csővezetékbe ... \ n");
write (pipefds [1], pin, 5);
printf ("Kész.\ n \ n ");
printf ("PIN olvasása a csövön ... \ n");
read (pipefds [0], puffer, 5);
printf ("Kész.\ n \ n ");
printf ("PIN a csőből:% s \ n", puffer);
visszatér EXIT_SUCCESS;
Ez a program alapvetően megmutatja, hogyan kell írni a csőbe, és olvasni a csőből írt adatokat.
Itt egy 4 karakteres PIN kódot tároltam a char sor. A tömb hossza 5 (beleértve a NULL karaktert \ 0).
char * pin = "4128 \ 0";Minden ASCII karakter 1 bájt méretű C-ben. Tehát ahhoz, hogy a 4 számjegyű PIN-kódot a csövön keresztül elküldhesse, 5 bájt (4 + 1 NULL karakter) adatot kell írnia a csőbe.
5 bájt adat megírása (csap) a csőbe, a ír() függvény az írási cső fájlleíróval pipefds [1] alábbiak szerint.
write (pipefds [1], pin, 5);Most, hogy van néhány adat a csőben, kiolvashatom a csőből a olvas() függvény a read pipe fájlleíróban pipefds [0]. Amint írtam 5 bájt adatot (csap) a csőbe, 5 bájt adatot is felolvasok a csőből. Az elolvasott adatok a puffer karaktertömb. Mivel 5 bájt adatot fogok olvasni a csőből, a puffer a karaktertömbnek legalább 5 bájt hosszúnak kell lennie.
Meghatároztam a puffer karaktertömb a. elején fő() funkció.
char puffer [5];Most ki tudom olvasni a PIN-kódot a csőből, és eltárolhatom a puffer tömb a következő sorral.
read (pipefds [0], puffer, 5);Most, hogy kiolvastam a PIN-kódot a csőből, ki tudom nyomtatni a printf () a szokásos módon működik.
printf ("PIN a csőből:% s \ n", puffer);Miután futtattam a programot, a helyes kimenet jelenik meg, amint láthatja.
3. példa:
Hozzon létre egy új C forrásfájlt 3_pipe.c írja be a következő kódsorokba.
#include#include
#include
#include
#include
int main (érvénytelen)
int pipefds [2];
char * pin;
char puffer [5];
if (cső (pipefds) == -1)
perror ("cső");
kilépés (EXIT_FAILURE);
pid_t pid = villa ();
if (pid == 0) // a gyermek folyamatában
pin = "4821 \ 0"; // PIN a küldéshez
bezár (pipefds [0]); // bezár olvas fd
write (pipefds [1], pin, 5); // PIN-kód beírása a pipába
printf ("PIN generálása a gyermekben és elküldés a szülőnek ... \ n");
alvás (2); // szándékos késés
kilépés (EXIT_SUCCESS);
if (pid> 0) // a fő folyamatban
várakozás (NULL); // várja meg a gyermek folyamatának befejezését
bezár (pipefds [1]); // bezár írni fd
read (pipefds [0], puffer, 5); // PIN-kód olvasása a csőből
bezár (pipefds [0]); // bezár olvas fd
printf ("A szülő megkapta a (z)"% s '\ n "PIN-kódot, puffer);
visszatér EXIT_SUCCESS;
Ebben a példában megmutattam, hogyan kell használni a csövet a folyamatok közötti kommunikációhoz. PIN kódot küldtem a gyermek folyamatból a szülő folyamatba. Ezután olvassa el a PIN-kódot a szülő folyamat csövéből, és nyomtassa ki a szülő folyamatból.
Először hoztam létre egy gyermek folyamatot a fork () függvény segítségével.
pid_t pid = villa ();Ezután a gyermek folyamatában (pid == 0), A PIN segítségével írtam a csőre a ír() funkció.
write (pipefds [1], pin, 5);Miután a PIN-kód be van írva a csővezetékbe a gyermek folyamatból, a szülő folyamat (pid> 0) olvassa el a csőből a olvas() funkció.
read (pipefds [0], puffer, 5);Ezután a szülői folyamat kinyomtatta a PIN kódot printf () a szokásos módon működik.
printf ("A szülő megkapta a (z)"% s '\ n "PIN-kódot, puffer);Mint látható, a program futtatása megadja a várt eredményt.
4. példa:
Hozzon létre egy új C forrásfájlt 4_pipe.c írja be a következő kódsorokba.
#include#include
#include
#include
#include
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
void getPIN (karaktertű [PIN_LENGTH + 1])
srand (getpid () + getppid ());
tű [0] = 49 + rand ()% 7;
mert (int i = 1; i < PIN_LENGTH; i++)
csap [i] = 48 + rand ()% 7;
pin [PIN_LENGTH] = '\ 0';
int main (érvénytelen)
míg (1)
int pipefds [2];
char pin [PIN_LENGTH + 1];
char puffer [PIN_LENGTH + 1];
pipa (pipefds);
pid_t pid = villa ();
if (pid == 0)
getPIN (pin); // PIN létrehozása
bezár (pipefds [0]); // bezár olvas fd
write (pipefds [1], pin, PIN_LENGTH + 1); // PIN-kód beírása a pipába
printf ("PIN generálása a gyermekben és elküldés a szülőnek ... \ n");
alvás (PIN_WAIT_INTERVAL); // szándékosan késlelteti a PIN-kód létrehozását.
kilépés (EXIT_SUCCESS);
if (pid> 0)
várakozás (NULL); // várja a gyermek befejezését
bezár (pipefds [1]); // bezár írni fd
read (pipefds [0], puffer, PIN_LENGTH + 1); // PIN-kód olvasása a csőből
bezár (pipefds [0]); // bezár olvas fd
printf ("A szülő megkapta a (z)"% s "PIN kódot a gyermektől.\ n \ n ", puffer);
visszatér EXIT_SUCCESS;
Ez a példa megegyezik a 3. példa. Az egyetlen különbség az, hogy ez a program folyamatosan létrehoz egy gyermekfolyamatot, generál egy PIN-kódot a gyermekfolyamatban, és egy cső segítségével elküldi a PIN-kódot a szülői folyamatnak.
Ezután a szülői folyamat kiolvassa a csőből a PIN-kódot, és kinyomtatja.
Ez a program PIN_WAIT_INTERVAL másodpercenként új PIN_LENGTH PIN kódot generál.
Mint látható, a program a várakozásoknak megfelelően működik.
A programot csak a gombbal állíthatja le
Tehát így használja a pipe () rendszerhívást C programozási nyelven. Köszönjük, hogy elolvasta ezt a cikket.
