Ang isang tubo ay isang daluyan para sa komunikasyon sa pagitan ng mga proseso. Ang isang proseso ay nagsusulat ng data sa tubo, at ang isa pang proseso ay binabasa ang data mula sa tubo. Sa artikulong ito, makikita natin kung paano ginagamit ang pagpapaandar ng tubo () upang ipatupad ang konsepto gamit ang C wika.
Tungkol kay Pipe
Sa tubo, ang data ay pinapanatili sa isang pagkakasunud-sunod ng FIFO, na nangangahulugang pagsulat ng data sa isang dulo ng tubo nang sunud-sunod at pagbabasa ng data mula sa isa pang dulo ng tubo sa parehong pagkakasunud-sunod.
Kung may anumang proseso na nagbabasa mula sa tubo, ngunit wala pang ibang proseso ang hindi pa nakasulat sa tubo, pagkatapos basahin ang nagbabalik na end-of-file. Kung nais ng isang proseso na sumulat sa isang tubo, ngunit walang ibang proseso na nakakabit sa tubo para sa pagbabasa, kung gayon ito ay isang kondisyon sa error, at ang tubo ay bumubuo ng isang senyas ng SIGPIPE.
File ng Header
# isamaSyntax
inttubo(intnagsumite[2])
Mga Pangangatwiran
Ang pagpapaandar na ito ay tumatagal ng isang solong argumento, isang hanay ng dalawang mga integer ( nagsumite ). nag-file [0] ay ginagamit para sa pagbabasa mula sa tubo, at nag-file [1] ay ginagamit para sa pagsusulat sa tubo. Ang proseso na nais na basahin mula sa tubo ay dapat isara nagsumite [1], at ang proseso na nais sumulat sa tubo ay dapat na isara nag-file [0] . Kung ang mga hindi kinakailangang dulo ng tubo ay hindi malinaw na sarado, kung gayon ang end-of-file (EOF) ay hindi na ibabalik.
Mga halagang bumalik
Sa tagumpay, ang tubo () nagbabalik ng 0, para sa kabiguan ang function ay nagbabalik -1.
Sa larawan, maaari nating katawanin ang tubo () gumana tulad ng sumusunod:
Nasa ibaba ang ilang mga halimbawa na naglalarawan kung paano gamitin ang pagpapaandar ng tubo sa wikang C.
Halimbawa1
Sa halimbawang ito, makikita natin kung paano gumagana ang pagpapaandar ng tubo. Kahit na ang paggamit ng isang tubo sa isang solong proseso ay hindi masyadong kapaki-pakinabang, ngunit makakakuha kami ng isang ideya.
// Halimbawa1.c# isama
# isama
# isama
# isama
intpangunahing()
{
intn;
intnagsumite[2];
charbuffer[1025];
char *mensahe= 'Kumusta, Mundo!';
tubo(nagsumite);
sumulat(nagsumite[1],mensahe, strlen (mensahe));
kung ((n=basahin(nagsumite[0],buffer, 1024 ) ) > = 0) {
buffer[n] = 0; // wakasan ang string
printf ('basahin ang% d bytes mula sa tubo:'%s' n',n,buffer);
}
iba pa
perror ('basahin');
labasan (0);
}
Dito namin unang nilikha ang isang tubo gamit ang tubo () function pagkatapos ay nakasulat sa tubo gamit garing [1] magtapos Pagkatapos, nabasa ang data gamit ang kabilang dulo ng tubo, na kung saan nag-file [0] . Para sa pagbabasa at pagsusulat sa file, dati basahin () at sumulat () pagpapaandar
Halimbawa2
Sa halimbawang ito, makikita natin kung paano nakikipag-usap ang proseso ng magulang at anak gamit ang tubo.
// Halimbawa2.c# isama
# isama
# isama
# isama
# isama
intpangunahing()
{
intnagsumite[2],nbytes;
pid_t childpid;
charlubid[] = 'Hello, mundo! n';
charreadbuffer[80];
tubo(nagsumite);
kung((anak ng bata=tinidor()) == -1)
{
perror ('tinidor');
labasan (1);
}
kung(anak ng bata== 0)
{
malapit na(nagsumite[0]);// Ang proseso ng Bata ay hindi kailangan ng pagtatapos ng tubo
/ * Magpadala ng 'string' sa pamamagitan ng output na bahagi ng tubo * /
sumulat(nagsumite[1],lubid, ( strlen (lubid)+1));
labasan (0);
}
iba pa
{
/ * Isinasara ng proseso ng magulang ang output na bahagi ng tubo * /
malapit na(nagsumite[1]);// Proseso ng magulang ay hindi kailangan ang dulo ng tubo na ito
/ * Basahin sa isang string mula sa tubo * /
nbytes=basahin(nagsumite[0],readbuffer, sukat ng(readbuffer));
printf ('Basahin ang string:% s',readbuffer);
}
bumalik ka(0);
}
Una, ang isang tubo ay nilikha gamit ang pagpapaandar ng tubo pagkatapos ng isang proseso ng bata ay tinidor. Pagkatapos, isinasara ng proseso ng bata ang read end at nagsusulat sa tubo. Isinasara ng proseso ng magulang ang dulo ng pagsulat at nagbasa mula sa tubo at ipinapakita ito. Dito ang daloy ng data ay isang paraan lamang na mula sa bata hanggang magulang.
Konklusyon:
tubo () ay isang malakas na tawag sa system sa Linux. Sa artikulong ito, nakita lamang namin ang isang daloy ng daloy ng data, isang proseso ang nagsusulat, at isa pang proseso ang nagbabasa, na lumilikha ng dalawang tubo na makakamit din natin ang daloy ng dalawang bi-direksyong data.