Phenquestions
Alles über pipe() Funktion:
Die Syntax der Rohr() Funktion ist:
int pipe(int pipefd[2]);Hier erstellt die Funktion pipe() einen unidirektionalen Datenkanal für die Interprozesskommunikation. Sie gehen in ein int (Integer) Typ Array pipefd bestehend aus 2 Array-Elementen zur Funktion pipe(). Dann erstellt die Funktion pipe() zwei Dateideskriptoren im pipefd Array.
Das erste Element der pipefd Array, pipefd[0] wird zum Auslesen von Daten aus der Rohrleitung verwendet.
Das zweite Element der pipefd Array, pipefd[1] wird zum Schreiben von Daten in die Pipe verwendet.
Bei Erfolg gibt die Funktion pipe() 0 . zurück. Wenn während der Pipe-Initialisierung ein Fehler auftritt, gibt die Funktion pipe() -1 . zurück.
Die Funktion pipe() ist im Header definiert defined unistd.ha. Um die Funktion pipe() in Ihrem C-Programm verwenden zu können, müssen Sie den Header einschließen unistd.ha wie folgt:
#einschließenWeitere Informationen zur Systemfunktion pipe() finden Sie in der Manpage von pipe() mit dem folgenden Befehl:
$ Mann 2 RohrDie Manpage von pipe().
Beispiel 1:
Erstellen Sie für das erste Beispiel eine neue C-Quelldatei 1_Rohr.c und geben Sie die folgenden Codezeilen ein.
#einschließen#einschließen
#einschließen
int main(void)
int-pipefds[2];
if(pipe(pipefds) == -1)
perror("Rohr");
beenden(EXIT_FAILURE);
printf("Dateideskriptorwert lesen: %d\n", pipefds[0]);
printf("Dateideskriptorwert schreiben: %d\n", pipefds[1]);
EXIT_SUCCESS zurückgeben;
Hier habe ich die Header-Datei von pipe() eingefügt unistd.ha zuerst mit der folgenden Zeile.
#einschließenDann im Main() Funktion, ich habe die definiert Pfeifen zweielementiges Integer-Array mit der folgenden Zeile.
int-pipefds[2];Dann habe ich die Funktion pipe() ausgeführt, um das Array der Dateideskriptoren zu initialisieren Pfeifen wie folgt.
Pfeife (Pfeife)Ich habe auch mit dem Rückgabewert der Funktion pipe() nach Fehlern gesucht. Ich habe das benutzt Ausfahrt() Funktion zum Beenden des Programms, falls die Pipe-Funktion fehlschlägt.
if(pipe(pipefds) == -1)perror("Rohr");
beenden(EXIT_FAILURE);
Dann habe ich den Wert der Read- und Write-Pipe-Dateideskriptoren ausgedruckt pipefds[0] und Pfeifen[1] beziehungsweise.
printf("Dateideskriptorwert lesen: %d\n", pipefds[0]);printf("Dateideskriptorwert schreiben: %d\n", pipefds[1]);
Wenn Sie das Programm ausführen, sollten Sie die folgende Ausgabe sehen. Wie Sie sehen, ist der Wert des Read Pipe-Dateideskriptors pipefds[0] ist 3 und Pipe-Dateideskriptor schreiben Pfeifen[1] ist 4.
Beispiel 2:
Erstellen Sie eine weitere C-Quelldatei 2_Rohr.c und geben Sie die folgenden Codezeilen ein.
#einschließen#einschließen
#einschließen
#einschließen
int main(void)
int-pipefds[2];
Zeichenpuffer[5];
if(pipe(pipefds) == -1)
perror("Rohr");
beenden(EXIT_FAILURE);
char *pin = "4128\0";
printf("PIN in Pipe schreiben…\n");
write(pipefds[1], pin, 5);
printf("Fertig.\n\n");
printf("Lese PIN aus Pipe… \n");
read(pipefds[0], Puffer, 5);
printf("Fertig.\n\n");
printf("PIN aus Pipe: %s\n", Puffer);
EXIT_SUCCESS zurückgeben;
Dieses Programm zeigt Ihnen im Grunde, wie Sie in die Pipe schreiben und die Daten lesen, die Sie aus der Pipe geschrieben haben.
Hier habe ich einen 4-stelligen PIN-Code in a verkohlen Array. Die Länge des Arrays beträgt 5 (einschließlich des NULL-Zeichens \0).
char *pin = "4128\0";Jedes ASCII-Zeichen ist 1 Byte groß in C. Um die 4-stellige PIN durch die Pipe zu senden, müssen Sie also 5 Byte (4 + 1 NULL-Zeichen) Daten in die Pipe schreiben.
Um 5 Byte Daten zu schreiben (Stift) in das Rohr, habe ich die schreiben() Funktion mit dem Write-Pipe-Dateideskriptor Pfeifen[1] wie folgt.
write(pipefds[1], pin, 5);Da ich nun einige Daten in der Pipe habe, kann ich sie mit dem aus der Pipe lesen lesen() Funktion auf dem Read Pipe-Dateideskriptor pipefds[0]. Da ich 5 Byte Daten geschrieben habe (Stift) in die Pipe, ich werde auch 5 Byte Daten aus der Pipe lesen. Die gelesenen Daten werden im Puffer Zeichenarray. Da ich 5 Byte Daten aus der Pipe lese, wird die Puffer Zeichenarray muss mindestens 5 Byte lang sein.
Ich habe die definiert Puffer Zeichenarray am Anfang des Main() Funktion.
Zeichenpuffer[5];Jetzt kann ich die PIN aus der Pfeife lesen und im Puffer Array mit der folgenden Zeile.
read(pipefds[0], Puffer, 5);Nachdem ich nun die PIN aus der Pipe gelesen habe, kann ich sie mit dem ausdrucken printf() Funktion wie gewohnt.
printf("PIN aus Pipe: %s\n", Puffer);Sobald ich das Programm ausführe, wird die richtige Ausgabe angezeigt, wie Sie sehen können.
Beispiel 3:
Erstellen Sie eine neue C-Quelldatei 3_Rohr.c als Typ in den folgenden Codezeilen.
#einschließen#einschließen
#einschließen
#einschließen
#einschließen
int main(void)
int-pipefds[2];
char *pin;
Zeichenpuffer[5];
if(pipe(pipefds) == -1)
perror("Rohr");
beenden(EXIT_FAILURE);
pid_t pid = fork();
if(pid == 0) // im Kindprozess
Stift = "4821\0"; // PIN zum Senden
schließen(pipefds[0]); // lese fd schließen
write(pipefds[1], pin, 5); // PIN in Pipe schreiben
printf("PIN im Kind generieren und an Eltern senden… \n");
Schlaf (2); // absichtliche Verzögerung
Beenden (EXIT_SUCCESS);
if(pid > 0) // im Hauptprozess
warten (NULL); // warten, bis der untergeordnete Prozess abgeschlossen ist
schließen(pipefds[1]); // schließe schreibe fd
read(pipefds[0], Puffer, 5); // PIN aus Pipe lesen
schließen(pipefds[0]); // lese fd schließen
printf("Eltern erhalten PIN '%s'\n", Puffer);
EXIT_SUCCESS zurückgeben;
In diesem Beispiel habe ich Ihnen gezeigt, wie Sie Pipe für die Kommunikation zwischen Prozessen verwenden. Ich habe über eine Pipe eine PIN vom untergeordneten Prozess an den übergeordneten Prozess gesendet. Dann die PIN aus der Pipe im Elternprozess lesen und aus dem Elternprozess ausdrucken.
Zuerst habe ich einen untergeordneten Prozess mit der Funktion fork() erstellt.
pid_t pid = fork();Dann im Kindprozess (pid == 0), habe ich die PIN mit dem in die Pipe geschrieben schreiben() Funktion.
write(pipefds[1], pin, 5);Sobald die PIN vom untergeordneten Prozess in die Pipe geschrieben wurde, wird der übergeordnete Prozess (pid > 0) lesen Sie es aus der Pfeife mit der lesen() Funktion.
read(pipefds[0], Puffer, 5);Dann druckte der übergeordnete Prozess die PIN mit printf() Funktion wie gewohnt.
printf("Eltern erhalten PIN '%s'\n", Puffer);Wie Sie sehen können, liefert das Ausführen des Programms das erwartete Ergebnis.
Beispiel 4:
Erstellen Sie eine neue C-Quelldatei 4_Rohr.c als Typ in den folgenden Codezeilen.
#einschließen#einschließen
#einschließen
#einschließen
#einschließen
#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)
während(1)
int-pipefds[2];
Zeichenstift [PIN_LENGTH + 1];
Zeichenpuffer[PIN_LENGTH + 1];
Pfeife (Pfeife);
pid_t pid = fork();
if(pid == 0)
getPIN(Pin); // PIN generieren
schließen(pipefds[0]); // schließe read fd
write(pipefds[1], pin, PIN_LENGTH + 1); // PIN in Pipe schreiben
printf("PIN im Kind generieren und an Eltern senden… \n");
Schlaf (PIN_WAIT_INTERVAL); // PIN-Generierung absichtlich verzögern.
Beenden (EXIT_SUCCESS);
if(pid > 0)
warten (NULL); // warten bis das Kind fertig ist
schließen(pipefds[1]); // schließe schreibe fd
read(pipefds[0], Puffer, PIN_LENGTH + 1); // PIN aus Pipe lesen
schließen(pipefds[0]); // schließe read fd
printf("Eltern haben PIN '%s' von Kind erhalten.\n\n", Puffer);
EXIT_SUCCESS zurückgeben;
Dieses Beispiel ist das gleiche wie Beispiel 3. Der einzige Unterschied besteht darin, dass dieses Programm kontinuierlich einen Child-Prozess erstellt, im Child-Prozess eine PIN generiert und die PIN über eine Pipe an den Parent-Prozess sendet.
Der übergeordnete Prozess liest dann die PIN aus der Pipe und druckt sie aus.
Dieses Programm generiert alle PIN_WAIT_INTERVAL Sekunden eine neue PIN_LENGTH PIN.
Wie Sie sehen, funktioniert das Programm wie erwartet.
Sie können das Programm nur stoppen, indem Sie drücken
So verwenden Sie den Systemaufruf pipe() in der Programmiersprache C. Danke, dass du diesen Artikel gelesen hast.
