Ang syntax ng tubo () ang pagpapaandar ay:
inttubo(intpipefd[2]);
Dito, ang pagpapaandar ng tubo () ay lumilikha ng isang unidirectional data channel para sa komunikasyon sa pagitan ng proseso. Pumasa ka sa isang int (Integer) uri ng array pipefd na binubuo ng 2 elemento ng array sa pagpapaandar ng tubo (). Pagkatapos ang pagpapaandar ng tubo () ay lumilikha ng dalawang mga tagapaglaraw ng file sa pipefd array
Ang unang elemento ng pipefd array, pipefd [0] ay ginagamit para sa pagbabasa ng data mula sa tubo.
Ang pangalawang elemento ng pipefd array, pipefd [1] ay ginagamit para sa pagsusulat ng data sa tubo.
Sa tagumpay, ang pagpapaandar ng tubo () ay nagbabalik ng 0. Kung naganap ang isang error habang pinasimulan ang tubo, pagkatapos ay ang function na tubo () ay nagbabalik -1.
Ang pagpapaandar ng tubo () ay tinukoy sa header unistd.h . Upang magamit ang pagpapaandar ng tubo () sa iyong C na programa, dapat mong isama ang header unistd.h tulad ng sumusunod:
# isama
Para sa karagdagang impormasyon sa pagpapaandar ng system ng tubo (), suriin ang pahina ng tao ng tubo () na may sumusunod na utos:
$ tao2tuboAng pahina ng tao ng tubo().
Halimbawa 1:
Para sa unang halimbawa, lumikha ng isang bagong C source file 1_pipe.c at i-type ang mga sumusunod na linya ng mga code.
# isama# isama
# isama
intpangunahing(walang bisa) {
intpipefds[2];
kung(tubo(pipefds) == -1) {
perror ('tubo');
labasan (EXIT_FAILURE);
}
printf ('Basahin ang Halaga ng Descriptor ng File:% d n',pipefds[0]);
printf ('Isulat ang Halaga ng Descriptor ng File:% d n',pipefds[1]);
bumalik kaEXIT_SUCCESS;
}
Dito, isinama ko ang header file ng tubo () unistd.h una sa sumusunod na linya.
# isamaPagkatapos, sa pangunahing () pagpapaandar, tinukoy ko ang pipefds dalawang elemento integer array na may sumusunod na linya.
intpipefds[2];Pagkatapos, pinatakbo ko ang pagpapaandar ng tubo () upang ipasimuno ang array ng mga tagapaglaraw ng file pipefds tulad ng sumusunod.
tubo(pipefds)Sinuri ko rin ang mga error gamit ang return halaga ng pagpapaandar ng tubo (). Ginamit ko ang exit () pagpapaandar sa terminal ang programa kung sakaling mabigo ang pagpapaandar ng tubo.
kung(tubo(pipefds) == -1) {perror ('tubo');
labasan (EXIT_FAILURE);
}
Pagkatapos, nai-print ko ang halaga ng mga nagbasa at nagsulat ng mga tagapaglaraw ng tubo ng file pipefds [0] at pipefds [1] ayon sa pagkakabanggit.
printf ('Basahin ang Halaga ng Descriptor ng File:% d n',pipefds[0]);printf ('Isulat ang Halaga ng Descriptor ng File:% d n',pipefds[1]);
Kung patakbuhin mo ang programa, dapat mong makita ang sumusunod na output. Tulad ng nakikita mo, ang halaga ng nabasa na tagapaglarawan ng file ng tubo pipefds [0] ay 3 at isulat ang deskriptor ng tubo ng tubo pipefds [1] ay 4 .
Halimbawa 2:
Lumikha ng isa pang C source file 2_pipe.c at i-type ang mga sumusunod na linya ng mga code.
# isama# isama
# isama
# isama
intpangunahing(walang bisa) {
intpipefds[2];
charbuffer[5];
kung(tubo(pipefds) == -1) {
perror ('tubo');
labasan (EXIT_FAILURE);
}
char *pin= '4128 0';
printf ('Nagsusulat ng PIN sa tubo ... n');
sumulat(pipefds[1],pin, 5);
printf ('Tapos na. n n');
printf ('Nagbabasa ng PIN mula sa tubo ... n');
basahin(pipefds[0],buffer, 5);
printf ('Tapos na. n n');
printf ('PIN mula sa tubo:% s n',buffer);
bumalik kaEXIT_SUCCESS;
}
Karaniwang ipinapakita sa iyo ng program na ito kung paano sumulat sa tubo at basahin ang data na isinulat mo mula sa tubo.
Dito, nag-imbak ako ng isang 4-character na PIN code sa isang char array Ang haba ng array ay 5 (kasama ang Null character 0).
char *pin= '4128 0';Ang bawat karakter na ASCII ay 1 byte sa laki sa C. Kaya, upang maipadala ang 4 na digit na PIN sa pamamagitan ng tubo, dapat kang magsulat ng 5 bytes (4 + 1 Null character) ng data sa tubo.
Upang sumulat ng 5 bytes ng data ( pin ) sa tubo, ginamit ko ang sumulat () pagpapaandar gamit ang magsulat ng tagapaglarawan ng file ng tubo pipefds [1] tulad ng sumusunod.
sumulat(pipefds[1],pin, 5);Ngayon na mayroon akong ilang data sa tubo, mababasa ko ito mula sa tubo gamit ang basahin () pagpapaandar sa nabasa na tagapaglarawan ng file ng tubo pipefds [0] . Tulad ng pagsulat ko ng 5 byte ng data ( pin ) sa tubo, magbabasa din ako ng 5 bytes ng data mula sa tubo din. Ang nabasang data ay itatabi sa buffer character array. Habang binabasa ko ang 5 bytes ng data mula sa tubo, ang buffer character array ay dapat na hindi bababa sa 5 bytes ang haba.
Natukoy ko ang buffer array ng character sa simula ng pangunahing () pagpapaandar
charbuffer[5];Ngayon, nababasa ko ang PIN mula sa tubo at iniimbak ito sa buffer array kasama ang sumusunod na linya.
basahin(pipefds[0],buffer, 5);Ngayon na nabasa ko ang PIN mula sa tubo, maaari ko itong mai-print gamit ang printf () gumana tulad ng dati.
printf ('PIN mula sa tubo:% s n',buffer);Sa sandaling patakbuhin ko ang programa, ang tamang output ay ipinapakita tulad ng nakikita mo.
Halimbawa 3:
Lumikha ng isang bagong C source file 3_pipe.c bilang uri sa mga sumusunod na linya ng mga code.
# isama# isama
# isama
# isama
# isama
intpangunahing(walang bisa) {
intpipefds[2];
char *pin;
charbuffer[5];
kung(tubo(pipefds) == -1) {
perror ('tubo');
labasan (EXIT_FAILURE);
}
pid_t pid=tinidor();
kung(pid== 0) { // sa proseso ng bata
pin= '4821 0'; // PIN upang ipadala
malapit na(pipefds[0]); // malapit basahin ang taut
sumulat(pipefds[1],pin, 5); // isulat ang PIN sa tubo
printf ('Bumubuo ng PIN sa bata at ipinapadala sa magulang ... n');
matulog(2); // sinadya pagkaantala
labasan (EXIT_SUCCESS);
}
kung(pid> 0) { // sa pangunahing proseso
teka(WALA); // hintaying matapos ang proseso ng bata
malapit na(pipefds[1]); // malapit isulat ang taut
basahin(pipefds[0],buffer, 5); // basahin ang PIN mula sa tubo
malapit na(pipefds[0]); // malapit basahin ang taut
printf (Natanggap ng 'Magulang ang PIN'% s ' n',buffer);
}
bumalik kaEXIT_SUCCESS;
}
Sa halimbawang ito, ipinakita ko sa iyo kung paano gamitin ang tubo para sa inter-proseso na komunikasyon. Nagpadala ako ng isang PIN mula sa proseso ng bata patungo sa proseso ng magulang na gumagamit ng isang tubo. Pagkatapos basahin ang PIN mula sa tubo sa proseso ng magulang at i-print ito mula sa proseso ng magulang.
Una, lumikha ako ng isang proseso ng bata gamit ang pagpapaandar ng fork ().
pid_t pid=tinidor();Pagkatapos, sa proseso ng bata ( pid == 0 ), Sinulat ko ang PIN sa tubo gamit ang sumulat () pagpapaandar
sumulat(pipefds[1],pin, 5);Kapag nakasulat ang PIN sa tubo mula sa proseso ng bata, ang proseso ng magulang ( pid> 0 ) basahin ito mula sa tubo gamit ang basahin () pagpapaandar
basahin(pipefds[0],buffer, 5);Pagkatapos, ang proseso ng magulang ay naka-print ang paggamit ng PIN printf () gumana tulad ng dati.
printf (Natanggap ng 'Magulang ang PIN'% s ' n',buffer);Tulad ng nakikita mo, ang pagpapatakbo ng programa ay nagbibigay ng inaasahang resulta.
Halimbawa 4:
Lumikha ng isang bagong C source file 4_pipe.c bilang uri sa mga sumusunod na linya ng mga code.
# isama# isama
# isama
# isama
# isama
# tukuyin ang PIN_LENGTH 4
# tukuyin ang PIN_WAIT_INTERVAL 2
walang bisagetPIN(charpin[PIN_LENGTH+ 1]) {
srand (getpid() +getppid());
pin[0] = 49 + hilera () % 7;
para sa(intako= 1;ako<PIN_LENGTH;ako++) {
pin[ako] = 48 + hilera () % 7;
}
pin[PIN_LENGTH] = ' 0';
}
intpangunahing(walang bisa) {
habang(1) {
intpipefds[2];
charpin[PIN_LENGTH+ 1];
charbuffer[PIN_LENGTH+ 1];
tubo(pipefds);
pid_t pid=tinidor();
kung(pid== 0) {
getPIN(pin); // bumuo ng PIN
malapit na(pipefds[0]); // malapit basahin ang taut
sumulat(pipefds[1],pin,PIN_LENGTH+ 1); // isulat ang PIN sa tubo
printf ('Bumubuo ng PIN sa bata at ipinapadala sa magulang ... n');
matulog(PIN_WAIT_INTERVAL); // sadyang pagpapaantala ng henerasyon ng PIN.
labasan (EXIT_SUCCESS);
}
kung(pid> 0) {
teka(WALA); // naghihintay sa pagtatapos ng bata
malapit na(pipefds[1]); // malapit isulat ang taut
basahin(pipefds[0],buffer,PIN_LENGTH+ 1); // basahin ang PIN mula sa tubo
malapit na(pipefds[0]); // malapit basahin ang taut
printf (Natanggap ng 'Magulang ang PIN'% s 'mula sa bata. n n',buffer);
}
}
bumalik kaEXIT_SUCCESS;
}
Ang halimbawang ito ay kapareho ng Halimbawa 3 . Ang pagkakaiba lamang ay ang program na ito na patuloy na lumilikha ng proseso ng bata, bumubuo ng isang PIN sa proseso ng bata at ipinapadala ang PIN sa proseso ng magulang gamit ang isang tubo.
Pagkatapos ay basahin ng proseso ng magulang ang PIN mula sa tubo at i-print ito.
Bumubuo ang program na ito ng isang bagong PIN_LENGTH PIN bawat PIN_WAIT_INTERVAL segundo.
Tulad ng nakikita mo, gumagana ang programa tulad ng inaasahan.
Maaari mo lamang itigil ang programa sa pamamagitan ng pagpindot + C .
Kaya, ito ay kung paano mo ginagamit ang tubo () na tawag sa system sa C programa ng wika. Salamat sa pagbabasa ng artikulong ito.