Phenquestions
Alles over pipe() Functie:
De syntaxis van de pijp() functie is:
int pijp(int pipefd[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:
#includeVoor meer informatie over de pipe() systeemfunctie, check de man-pagina van pipe() met het volgende commando:
$ man 2 pijpDe man-pagina van pipe().
Voorbeeld 1:
Maak voor het eerste voorbeeld een nieuw C-bronbestand 1_pijp.c en typ de volgende regels codes in:.
#include#include
#include
int main(void)
int pipefds[2];
if(pipe(pipefds) == -1)
perror("pijp");
afsluiten (EXIT_FAILURE);
printf("Lees de bestandsdescriptorwaarde: %d\n", pipefds[0]);
printf("Schrijf bestandsdescriptorwaarde: %d\n", pipefds[1]);
retourneer EXIT_SUCCESS;
Hier heb ik het headerbestand van pipe() opgenomen unistd.h eerst met de volgende regel:.
#includeDan, in de hoofd() functie, ik definieerde de pipefds integer array van twee elementen met de volgende regel:.
int pipefds[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 de pijpfunctie faalt.
if(pipe(pipefds) == -1)perror("pijp");
afsluiten (EXIT_FAILURE);
Vervolgens heb ik de waarde van de lees- en schrijfpijpbestanddescriptors afgedrukt pipefds[0] en pipefds[1] respectievelijk.
printf("Lees de bestandsdescriptorwaarde: %d\n", pipefds[0]);printf("Schrijf bestandsdescriptorwaarde: %d\n", 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_pijp.c en typ de volgende regels codes in:.
#include#include
#include
#include
int main(void)
int pipefds[2];
char-buffer[5];
if(pipe(pipefds) == -1)
perror("pijp");
afsluiten (EXIT_FAILURE);
char *pin = "4128\0";
printf("PIN schrijven naar pipe... \n");
schrijven (pipefds [1], pin, 5);
printf("Gereed.\n\n");
printf("PIN lezen van pijp... \n");
lezen(pipefds[0], buffer, 5);
printf("Gereed.\n\n");
printf("PIN van pijp: %s\n", buffer);
retourneer EXIT_SUCCESS;
Dit programma laat je in principe 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 \0).
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, ik zal 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.
char-buffer[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() functioneren zoals gewoonlijk.
printf("PIN van pijp: %s\n", buffer);Zodra ik het programma heb uitgevoerd, wordt de juiste uitvoer weergegeven, zoals u kunt zien.
Voorbeeld 3:
Een nieuw C-bronbestand maken 3_pijp.c als type in de volgende regels codes:.
#include#include
#include
#include
#include
int main(void)
int pipefds[2];
teken *pin;
char-buffer[5];
if(pipe(pipefds) == -1)
perror("pijp");
afsluiten (EXIT_FAILURE);
pid_t pid = vork();
if (pid == 0) // in onderliggend proces
pin = "4821\0"; // PIN om te verzenden
sluiten(pipefds[0]); // sluit lees fd
schrijven (pipefds [1], pin, 5); // schrijf PIN naar pipe
printf("PIN aanmaken in kind en verzenden naar ouder... \n");
slapen(2); // opzettelijke vertraging
afsluiten (EXIT_SUCCESS);
if(pid > 0) // in hoofdproces
wacht (NULL); // wacht tot het onderliggende proces is voltooid
sluiten(pipefds[1]); // sluit schrijven fd
lezen(pipefds[0], buffer, 5); // lees de pincode van de pijp
sluiten(pipefds[0]); // sluit lees fd
printf("Ouder heeft pincode ontvangen '%s'\n", buffer);
retourneer EXIT_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.
Ten eerste 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() functioneren zoals gewoonlijk.
printf("Ouder heeft pincode ontvangen '%s'\n", buffer);Zoals je kunt zien, geeft het uitvoeren van het programma het verwachte resultaat.
Voorbeeld 4:
Een nieuw C-bronbestand maken 4_pijp.c als type in de volgende regels codes:.
#include#include
#include
#include
#include
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
void getPIN(char pin [PIN_LENGTH + 1])
srand(getpid() + getppid());
pin[0] = 49 + rand() % 7;
for(int i = 1; i < PIN_LENGTH; i++)
pin[i] = 48 + rand() % 7;
pin[PIN_LENGTH] = '\0';
int main(void)
terwijl(1)
int pipefds[2];
char pin [PIN_LENGTH + 1];
char buffer [PIN_LENGTH + 1];
pijp (pipefds);
pid_t pid = vork();
if(pid == 0)
getPIN(pin); // pincode genereren
sluiten(pipefds[0]); // sluit lees fd
schrijven (pipefds [1], pin, PIN_LENGTH + 1); // schrijf PIN naar pipe
printf("PIN aanmaken in kind en verzenden naar ouder... \n");
slaap (PIN_WAIT_INTERVAL); // opzettelijk het genereren van pincodes vertragen.
afsluiten (EXIT_SUCCESS);
if(pid > 0)
wacht (NULL); // wachten tot het kind klaar is
sluiten(pipefds[1]); // sluit schrijven fd
lezen (pipefds [0], buffer, PIN_LENGTH + 1); // lees de pincode van de pijp
sluiten(pipefds[0]); // sluit lees fd
printf("Ouder heeft pincode '%s' ontvangen van kind.\n\n", buffer);
retourneer EXIT_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 naar het bovenliggende proces stuurt met behulp van een pipe.
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
Dus, dit is hoe je de pipe() systeemaanroep in C programmeertaal gebruikt. Bedankt voor het lezen van dit artikel.
