De syntaxis van de pijp() functie is:
intpijp(intpipefd[2]);
Hier creëert de functie pipe() een unidirectioneel gegevenskanaal voor communicatie tussen processen. Je passeert in een int (Integer) type array pipefd bestaande uit 2 array-elementen naar de functie pipe(). Vervolgens maakt de functie pipe() twee bestandsdescriptors in de pipefd reeks.
Het eerste element van de pipefd reeks, pipefd[0] wordt gebruikt voor het lezen van gegevens uit de pijp.
Het tweede element van de pipefd reeks, pipefd[1] wordt gebruikt voor het schrijven van gegevens naar de pijp.
Bij succes retourneert de functie pipe() 0. Als er een fout optreedt tijdens de initialisatie van de pijp, retourneert de functie pipe() -1.
De functie pipe() is gedefinieerd in de header unistd.h . Om de functie pipe() in uw C-programma te gebruiken, moet u de header unistd.h als volgt:
#erbij betrekken
Voor meer informatie over de pipe() systeemfunctie, check de man-pagina van pipe() met het volgende commando:
$ man2pijpDe man-pagina van pipe().
Voorbeeld 1:
Maak voor het eerste voorbeeld een nieuw C-bronbestand 1_pipe.c en typ de volgende regels codes in.
#erbij betrekken#erbij betrekken
#erbij betrekken
inthoofd(leegte) {
intpipefds[2];
indien(pijp(pipefds) == -1) {
perror ('pijp');
Uitgang (EXIT_FAILURE);
}
printf ('Lees bestandsdescriptorwaarde: %dN',pipefds[0]);
printf ('Schrijf bestandsdescriptorwaarde: %dN',pipefds[1]);
opbrengstEXIT_SUCCESS;
}
Hier heb ik het headerbestand van pipe() opgenomen unistd.h eerst met de volgende regel.
#erbij betrekkenDan, in de hoofd() functie, ik definieerde de pipefds integer array van twee elementen met de volgende regel.
intpipefds[2];Vervolgens heb ik de functie pipe() uitgevoerd om de array met bestandsdescriptors te initialiseren pipefds als volgt.
pijp(pipefds)Ik heb ook gecontroleerd op fouten met behulp van de retourwaarde van de functie pipe(). ik gebruikte de Uitgang() functie om het programma te terminalen in het geval dat de pipe-functie faalt.
indien(pijp(pipefds) == -1) {perror ('pijp');
Uitgang (EXIT_FAILURE);
}
Vervolgens heb ik de waarde van de lees- en schrijfpijpbestanddescriptors afgedrukt pipefds[0] en pipefds[1] respectievelijk.
printf ('Lees bestandsdescriptorwaarde: %dN',pipefds[0]);printf ('Schrijf bestandsdescriptorwaarde: %dN',pipefds[1]);
Als u het programma uitvoert, zou u de volgende uitvoer moeten zien. Zoals u kunt zien, is de waarde van de read pipe-bestandsdescriptor pipefds[0] is 3 en schrijf de descriptor van het pijpbestand pipefds[1] is 4 .
Voorbeeld 2:
Een ander C-bronbestand maken 2_pipe.c en typ de volgende regels codes in.
#erbij betrekken#erbij betrekken
#erbij betrekken
#erbij betrekken
inthoofd(leegte) {
intpipefds[2];
charbuffer[5];
indien(pijp(pipefds) == -1) {
perror ('pijp');
Uitgang (EXIT_FAILURE);
}
char *pin= '4128 0';
printf ('PIN schrijven naar pijp...N');
schrijven(pipefds[1],pin, 5);
printf ('Gedaan.NN');
printf ('PIN lezen van pijp...N');
lezen(pipefds[0],buffer, 5);
printf ('Gedaan.NN');
printf ('PIN van pijp: %sN',buffer);
opbrengstEXIT_SUCCESS;
}
Dit programma laat je in feite zien hoe je naar de pijp schrijft en de gegevens leest die je vanuit de pijp hebt geschreven.
Hier heb ik een pincode van 4 tekens opgeslagen in een char reeks. De lengte van de array is 5 (inclusief het NULL-teken ).
char *pin= '4128 0';Elk ASCII-teken is 1 byte groot in C. Dus om de 4-cijferige pincode door de pijp te sturen, moet je 5 bytes (4 + 1 NULL-teken) aan gegevens in de pijp schrijven.
Om 5 bytes aan gegevens te schrijven ( pin ) in de pijp, gebruikte ik de schrijven() functie met behulp van de descriptor van het schrijfpijpbestand pipefds[1] als volgt.
schrijven(pipefds[1],pin, 5);Nu ik wat gegevens in de pijp heb, kan ik deze uit de pijp lezen met behulp van de lezen() functie op de descriptor van het leespijpbestand pipefds[0] . Aangezien ik 5 bytes aan gegevens heb geschreven ( pin ) in de pijp, zal ik ook 5 bytes aan gegevens uit de pijp lezen. De gelezen gegevens worden opgeslagen in de buffer tekenreeks. Aangezien ik 5 bytes aan gegevens uit de pijp zal lezen, is de buffer tekenreeks moet minimaal 5 bytes lang zijn.
ik heb de . gedefinieerd buffer tekenreeks aan het begin van de hoofd() functie.
charbuffer[5];Nu kan ik de pincode van de pijp lezen en opslaan in de buffer array met de volgende regel.
lezen(pipefds[0],buffer, 5);Nu ik de pincode van de pijp heb gelezen, kan ik deze afdrukken met de printf() normaal functioneren.
printf ('PIN van pijp: %sN',buffer);Zodra ik het programma heb uitgevoerd, wordt de juiste uitvoer weergegeven, zoals u kunt zien.
Voorbeeld 3:
Een nieuw C-bronbestand maken 3_pipe.c als type in de volgende regels codes.
#erbij betrekken#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
inthoofd(leegte) {
intpipefds[2];
char *pin;
charbuffer[5];
indien(pijp(pipefds) == -1) {
perror ('pijp');
Uitgang (EXIT_FAILURE);
}
pid_t pid=vork();
indien(pid== 0) { // in kinderproces
pin= '4821 0'; // PIN om te verzenden
dichtbij(pipefds[0]); // sluit lees fd
schrijven(pipefds[1],pin, 5); // schrijf PIN naar pipe
printf ('Pincode genereren in kind en verzenden naar ouder...N');
slaap(2); // opzettelijke vertraging
Uitgang (EXIT_SUCCESS);
}
indien(pid> 0) { // in hoofdproces
wacht(NUL); // wacht tot het onderliggende proces is voltooid
dichtbij(pipefds[1]); // sluit schrijven fd
lezen(pipefds[0],buffer, 5); // lees de pincode van de pijp
dichtbij(pipefds[0]); // sluit lees fd
printf ('Ouder heeft pincode ontvangen '%s'N',buffer);
}
opbrengstEXIT_SUCCESS;
}
In dit voorbeeld heb ik je laten zien hoe je pipe kunt gebruiken voor communicatie tussen processen. Ik heb een pincode van het onderliggende proces naar het bovenliggende proces gestuurd met behulp van een pipe. Lees vervolgens de pincode uit de pijp in het bovenliggende proces en print deze uit het bovenliggende proces.
Eerst heb ik een kindproces gemaakt met de functie fork().
pid_t pid=vork();Vervolgens, in het kindproces ( pid == 0 ), heb ik de pincode op de pijp geschreven met de schrijven() functie.
schrijven(pipefds[1],pin, 5);Zodra de pincode vanuit het onderliggende proces naar de pijp is geschreven, wordt het bovenliggende proces ( pid > 0 ) lees het uit de pijp met behulp van de lezen() functie.
lezen(pipefds[0],buffer, 5);Vervolgens heeft het bovenliggende proces de pincode afgedrukt met: printf() normaal functioneren.
printf ('Ouder heeft pincode ontvangen '%s'N',buffer);Zoals u kunt zien, geeft het uitvoeren van het programma het verwachte resultaat.
Voorbeeld 4:
Een nieuw C-bronbestand maken 4_pipe.c als type in de volgende regels codes.
#erbij betrekken#erbij betrekken
#erbij betrekken
#erbij betrekken
#erbij betrekken
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
leegtegetPIN(charpin[PIN_LENGTH+ 1]) {
srand (getpid() +getppid());
pin[0] = 49 + rij () % 7;
voor(intl= 1;l<PIN_LENGTH;l++) {
pin[l] = 48 + rij () % 7;
}
pin[PIN_LENGTH] = ' 0';
}
inthoofd(leegte) {
terwijl(1) {
intpipefds[2];
charpin[PIN_LENGTH+ 1];
charbuffer[PIN_LENGTH+ 1];
pijp(pipefds);
pid_t pid=vork();
indien(pid== 0) {
getPIN(pin); // pincode genereren
dichtbij(pipefds[0]); // sluit lees fd
schrijven(pipefds[1],pin,PIN_LENGTH+ 1); // schrijf PIN naar pipe
printf ('Pincode genereren in kind en verzenden naar ouder...N');
slaap(PIN_WAIT_INTERVAL); // het opzettelijk vertragen van het genereren van pincodes.
Uitgang (EXIT_SUCCESS);
}
indien(pid> 0) {
wacht(NUL); // wachten tot het kind klaar is
dichtbij(pipefds[1]); // sluit schrijven fd
lezen(pipefds[0],buffer,PIN_LENGTH+ 1); // lees de pincode van de pijp
dichtbij(pipefds[0]); // sluit lees fd
printf ('Ouder heeft pincode '%s' ontvangen van kind.NN',buffer);
}
}
opbrengstEXIT_SUCCESS;
}
Dit voorbeeld is hetzelfde als Voorbeeld 3 . Het enige verschil is dat dit programma continu een onderliggend proces creëert, een pincode genereert in het onderliggende proces en de pincode via een pipe naar het bovenliggende proces stuurt.
Het bovenliggende proces leest vervolgens de pincode uit de pijp en drukt deze af.
Dit programma genereert elke PIN_WAIT_INTERVAL seconden een nieuwe PIN_LENGTH PIN.
Zoals je kunt zien, werkt het programma zoals verwacht.
U kunt het programma alleen stoppen door op te drukken + C .
Dus, dit is hoe je de pipe() systeemaanroep in C programmeertaal gebruikt. Bedankt voor het lezen van dit artikel.