A szintaxisa pipa() funkciója:
intpipa(intpipefd[2]);
Itt a pipe () függvény egyirányú adatcsatornát hoz létre a folyamatok közötti kommunikációhoz. Belép egy int (Egész szám) típusú tömb pipefd 2 tömb elemből áll a függvénycsőhöz (). Ezután a pipe () függvény két fájlleírót hoz létre a pipefd sor.
Az első eleme a pipefd sor, pipefd [0] a csőből származó adatok olvasására szolgál.
A második elem a pipefd sor, pipefd [1] adatok írására szolgál a csőbe.
A siker esetén a pipe () függvény 0 értéket ad vissza. Ha hiba történik a cső inicializálása során, akkor a pipe () függvény -1 értéket ad vissza.
A pipe () függvény a fejlécben van definiálva unistd.h . Ahhoz, hogy a pipe () függvényt a C programjában használni tudja, tartalmaznia kell a fejlécet unistd.h alábbiak szerint:
#befoglalni
Ha többet szeretne megtudni a pipe () rendszer funkciójáról, ellenőrizze a pipe () kézikönyvoldalát a következő paranccsal:
$ ember2pipaA cső man oldala().
1. példa:
Az első példában hozzon létre egy új C forrásfájlt 1_cső.c és írja be a következő kódsorokat.
#befoglalni#befoglalni
#befoglalni
intfő-(üres) {
intpipefds[2];
ha(pipa(pipefds) == -1) {
tévedés ('pipa');
kijárat (EXIT_FAILURE);
}
printf ('Fájlleíró olvasása Érték: %d n',pipefds[0]);
printf ('Írási fájl leíró értéke: %d n',pipefds[1]);
VisszatérésEXIT_SUCCESS;
}
Itt szerepeltettem a pipe () fejlécfájlját unistd.h először a következő sorral.
#befoglalniAztán, a fő() függvény, definiáltam a pipefds két elemből álló egész tömb a következő sorral.
intpipefds[2];Ezután futtattam a pipe () függvényt a fájlleíró tömb inicializálásához pipefds alábbiak szerint.
pipa(pipefds)A pipe () függvény visszatérési értékével is ellenőriztem a hibákat. Használtam a kijárat() funkció a program lezárására, ha a csőfunkció meghibásodik.
ha(pipa(pipefds) == -1) {tévedés ('pipa');
kijárat (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ó olvasása Érték: %d n',pipefds[0]);printf ('Írási fájl leíró értéke: %d n',pipefds[1]);
Ha futtatja a programot, akkor a következő kimenetet kell látnia. Amint láthatja, az olvasócső fájlleíró értéke pipefds [0] van 3 és írjon pipe fájl leírót pipefds [1] van 4 .
2. példa:
Hozzon létre egy másik C forrásfájlt 2_cső.c és írja be a következő kódsorokat.
#befoglalni#befoglalni
#befoglalni
#befoglalni
intfő-(üres) {
intpipefds[2];
charpuffer[5];
ha(pipa(pipefds) == -1) {
tévedés ('pipa');
kijárat (EXIT_FAILURE);
}
char *csap= „4128 0';
printf ('PIN -kód írása a csőre ... n');
ír(pipefds[1],csap, 5);
printf ('Kész. n n');
printf ('PIN -kód olvasása a csőből ... n');
olvas(pipefds[0],puffer, 5);
printf ('Kész. n n');
printf ('PIN a csőből: %s n',puffer);
VisszatérésEXIT_SUCCESS;
}
Ez a program alapvetően megmutatja, hogyan kell írni a csőbe, és elolvasni a csőből írt adatokat.
Itt egy 4 karakterből álló PIN-kódot tároltam a char sor. A tömb hossza 5 (beleértve a NULL karaktert 0).
char *csap= „4128 0';Minden ASCII karakter 1 bájt méretű C -ben. Tehát a 4 számjegyű PIN -kód csövön keresztüli elküldéséhez 5 bájt (4 + 1 NULL karakter) adatot kell beírnia a csőbe.
5 bájt adat írásához ( csap ) a csőbe, a ír() függvényt az írási cső fájl leíró használatával pipefds [1] alábbiak szerint.
ír(pipefds[1],csap, 5);Most, hogy van néhány adatom a csőben, ki tudom olvasni a csőből a olvas() funkciót az olvasócső fájl leírójában pipefds [0] . Ahogy 5 bájtnyi adatot írtam ( csap ) a csőbe, a csőből 5 bájt adatot is leolvasok. Az olvasott adatok a puffer karakter tömb. Ahogy 5 bájt adatot fogok olvasni a csőből, a puffer a karakter tömbnek legalább 5 bájt hosszúnak kell lennie.
Meghatároztam a puffer karakter tömb az elején fő() funkció.
charpuffer[5];Most ki tudom olvasni a PIN -kódot a csőből, és tárolhatom a puffer tömb a következő sorral.
olvas(pipefds[0],puffer, 5);Most, hogy kiolvastam a PIN -kódot a csőből, ki tudom nyomtatni a printf () működjön a szokásos módon.
printf ('PIN a csőből: %s n',puffer);Miután futtattam a programot, a megfelelő kimenet jelenik meg, amint látható.
3. példa:
Hozzon létre egy új C forrásfájlt 3_pipe.c írja be a következő kódsorokat.
#befoglalni#befoglalni
#befoglalni
#befoglalni
#befoglalni
intfő-(üres) {
intpipefds[2];
char *csap;
charpuffer[5];
ha(pipa(pipefds) == -1) {
tévedés ('pipa');
kijárat (EXIT_FAILURE);
}
pid_t pid=Villa();
ha(pid== 0) { // gyermek folyamatban
csap= „4821 0'; // PIN elküldeni
Bezárás(pipefds[0]); // bezár olvas fd
ír(pipefds[1],csap, 5); // PIN -kód írása a csőbe
printf ('PIN -kód generálása gyermekben és elküldése szülőnek ... n');
alvás(2); // szándékos késleltetés
kijárat (EXIT_SUCCESS);
}
ha(pid> 0) { // a fő folyamatban
várjon(NULLA); // várja meg, amíg a gyermek folyamat befejeződik
Bezárás(pipefds[1]); // bezár írás fd
olvas(pipefds[0],puffer, 5); // PIN -kód olvasása a csőből
Bezárás(pipefds[0]); // bezár olvas fd
printf ('A szülő megkapta a (z)%s' PIN kódot n',puffer);
}
VisszatérésEXIT_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 gyermekfolyamatból a szülői folyamatba pipával. Ezután olvassa el a PIN kódot a csőből a szülői folyamatban, és nyomtassa ki a szülői folyamatból.
Először létrehoztam egy gyermekfolyamatot a fork () függvény használatával.
pid_t pid=Villa();Ezután a gyermekfolyamatban ( pid == 0 ), Írtam a PIN -kódot a csőre a ír() funkció.
ír(pipefds[1],csap, 5);Miután a PIN kódot a csőbe írták a gyermekfolyamatból, a szülői folyamat ( pid> 0 ) olvassa el a csőből a olvas() funkció.
olvas(pipefds[0],puffer, 5);Ezután a szülői folyamat kinyomtatta a PIN kódot printf () működjön a szokásos módon.
printf ('A szülő megkapta a (z)%s' PIN kódot n',puffer);Mint látható, a program futtatása meghozza a várt eredményt.
4. példa:
Hozzon létre egy új C forrásfájlt 4_cső.c írja be a következő kódsorokat.
#befoglalni#befoglalni
#befoglalni
#befoglalni
#befoglalni
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
üresgetPIN(charcsap[PIN_LENGTH+ 1]) {
srand (hülye() +kapaszkodó());
csap[0] = 49 + sor () % 7;
számára(intén= 1;én<PIN_LENGTH;én++) {
csap[én] = 48 + sor () % 7;
}
csap[PIN_LENGTH] = ' 0';
}
intfő-(üres) {
míg(1) {
intpipefds[2];
charcsap[PIN_LENGTH+ 1];
charpuffer[PIN_LENGTH+ 1];
pipa(pipefds);
pid_t pid=Villa();
ha(pid== 0) {
getPIN(csap); // PIN -kód generálása
Bezárás(pipefds[0]); // bezár olvas fd
ír(pipefds[1],csap,PIN_LENGTH+ 1); // PIN -kód írása a csőbe
printf ('PIN -kód generálása gyermekben és elküldése szülőnek ... n');
alvás(PIN_WAIT_INTERVAL); // szándékosan késlelteti a PIN -kód generálását.
kijárat (EXIT_SUCCESS);
}
ha(pid> 0) {
várjon(NULLA); // várjuk a gyermek befejezését
Bezárás(pipefds[1]); // bezár írás fd
olvas(pipefds[0],puffer,PIN_LENGTH+ 1); // PIN -kód olvasása a csőből
Bezárás(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ésEXIT_SUCCESS;
}
Ez a példa ugyanaz, mint 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.
A szülői folyamat ezután kiolvassa a PIN -kódot a csőből, és kinyomtatja.
Ez a program PIN_WAIT_INTERVAL másodpercenként generál egy új PIN_LENGTH PIN kódot.
Mint látható, a program a várt módon működik.
A programot csak a gomb megnyomásával állíthatja le + C .
Tehát így használja a pipe () rendszerhívást C programozási nyelven. Köszönjük, hogy elolvasta ezt a cikket.