Hvordan bruke rørfunksjon på C -språk

Et rør er et medium for kommunikasjon mellom prosesser. Én prosess skriver data til røret, og en annen prosess leser dataene fra røret. I denne artikkelen vil vi se hvordan Pipe () -funksjonen brukes til å implementere konseptet ved hjelp av C -språk.

Om rør

I røret opprettholdes dataene i en FIFO -rekkefølge, noe som betyr å skrive data til den ene enden av røret sekvensielt og lese data fra en annen ende av røret i samme sekvensielle rekkefølge.

Hvis noen prosess leser fra røret, men ingen annen prosess ikke har skrevet til røret ennå, kan du lese return-av-av-fil. Hvis en prosess ønsker å skrive til et rør, men det ikke er noen annen prosess festet til røret for lesing, er dette en feiltilstand, og røret genererer et SigPipe -signal.

Headerfil

#inkludere

Syntaks

int pipe (int filedes [2])

Argumenter

Denne funksjonen tar et enkelt argument, en rekke to heltall (Filedes). Filedes [0] brukes til lesing fra røret, og Filedes [1] brukes til å skrive til røret. Prosessen som vil lese fra røret skal lukke Filedes [1], og prosessen som ønsker å skrive til røret, skal lukke Filedes [0]. Hvis de unødvendige endene av røret ikke er eksplisitt lukket, vil end-of-filen (EOF) aldri bli returnert.

Returverdier

Om suksess, den rør() Returnerer 0, for feil kommer funksjonen tilbake -1.

Bildelig kan vi representere rør() funksjon som følger:

Nedenfor er noen få eksempler som skildrer hvordan du bruker rørfunksjonen på C -språket.

Eksempel1

I dette eksemplet vil vi se hvordan rørfunksjonen fungerer. Selv om det ikke er veldig nyttig å bruke et rør i en enkelt prosess, men vi vil få en idé.

// Eksempel1.c
#inkludere
#inkludere
#inkludere
#inkludere
int main ()

int n;
int Filedes [2];
Char Buffer [1025];
char *melding = "Hei, verden!";
rør (arkiverte);
skriv (arkiverte [1], melding, strlen (melding));
if ((n = lest (arkiverte [0], buffer, 1024))> = 0)
buffer [n] = 0; // avslutte strengen
printf ("Les %d byte fra røret:" %s "\ n", n, buffer);

ellers
Perror ("Les");
Avslutt (0);

Her har vi først laget et rør ved hjelp av rør() funksjon deretter skrevet til røret ved hjelp av Fildes [1] slutt. Deretter er dataene lest ved bruk av den andre enden av røret, som er Filedes [0]. For å lese og skrive til filen, pleide vi å lese() og skrive() funksjoner.

Eksempel2

I dette eksemplet vil vi se hvordan foreldre- og barneprosesser kommuniserer ved hjelp av røret.

// Eksempel2.c
#inkludere
#inkludere
#inkludere
#inkludere
#inkludere
int main ()

Int Filedes [2], Nbytes;
PID_T Childpid;
Char String [] = "Hei, verden!\ n ";
Char Readbuffer [80];
rør (arkiverte);
if ((childpid = gaffel ()) == -1)

Perror ("gaffel");
Avslutt (1);

if (childpid == 0)

Lukk (arkiverte [0]); // Barneprosess trenger ikke denne enden av røret
/ * Send "streng" gjennom utgangssiden av røret */
Skriv (Filedes [1], String, (Strlen (String) +1));
Avslutt (0);

ellers

/ * Foreldreprosess lukker ut utgangssiden av røret */
Lukk (arkiverte [1]); // Foreldreprosess trenger ikke denne enden av røret
/ * Les i en streng fra røret */
nbytes = lest (arkiverte [0], readbuffer, størrelse av (readbuffer));
printf ("Les streng: %s", readbuffer);

return (0);

For det første er det opprettet ett rør ved hjelp av rørfunksjonen, så er en barneprosess blitt gaffel. Deretter lukker barneprosessen den lesende enden og skriver til røret. Foreldreprosessen lukker skriveenden og leser fra røret og viser den. Her er dataflyt bare en måte som er fra barn til foreldre.

Konklusjon:

rør() er et kraftig systemanrop i Linux. I denne artikkelen har vi sett bare enveis dataflyt, en prosess skriver, og en annen prosess lyder, og skaper to rør vi kan oppnå toveis dataflyt også.