Rohr() ist eine Linux -Systemfunktion. Der Rohr() Die Systemfunktion wird verwendet, um Dateideskriptoren zu öffnen, die zur Kommunikation zwischen verschiedenen Linux -Prozessen verwendet werden. Kurz gesagt die Rohr() Die Funktion wird für die Kommunikation zwischen den Prozess unter Linux verwendet. In diesem Artikel werde ich Ihnen zeigen, wie Sie die Funktion des PIPE () -Systems unter Linux verwenden. Also lasst uns anfangen.

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 Kommunikation zwischen den Prozess. Sie passieren in einen int (Ganzzahl) Typ Array Pipefd bestehend aus 2 Array -Elementen zum Funktionsrohr (). Dann erstellt die Funktion pipe () zwei Dateideskriptoren in der Pipefd Array.

Das erste Element der Pipefd Array, Pipefd [0] wird zum Lesen von Daten aus der Pipe verwendet.

Das zweite Element der Pipefd Array, Pipefd [1] wird zum Schreiben von Daten an das Rohr verwendet.

Bei Erfolg kehrt die Funktion pipe () 0 zurück. 0. Wenn während der Rohrinitialisierung ein Fehler auftritt, gibt die Funktion pipe () -1 -1 zurück.

Die Funktion pipe () ist im Header definiert Unistd.H. Um die Funktion pipe () in Ihrem C -Programm zu verwenden, müssen Sie den Header einschließen Unistd.H folgendermaßen:

#enthalten

Weitere Informationen zur Funktion der PIPE () -Systemfunktion finden Sie auf der Mannseite von Pipe () mit dem folgenden Befehl:

$ MAN 2 PIPE
Die Mannseite von Pipe ().

Beispiel 1:

Erstellen Sie für das erste Beispiel eine neue C -Quelldatei 1_pipe.C und geben Sie die folgenden Codes -Zeilen ein.

#enthalten
#enthalten
#enthalten
int main (void)
int pipefds [2];
if (pipe (pipEfds) == -1)
Perror ("Pfeife");
exit (exit_failure);

printf ("Dateideskriptorwert lesen: %d \ n", pipEfds [0]);
printf ("Dateideskriptorwert schreiben: %d \ n", PipEFDs [1]);
return exit_success;

Hier habe ich die Header -Datei von Pipe () aufgenommen Unistd.H zuerst mit der folgenden Zeile.

#enthalten

Dann in der hauptsächlich() Funktion, ich habe das definiert Pipefds Zwei Element Integer Array mit der folgenden Zeile.

int pipefds [2];

Dann habe ich die Funktion pipe () ausgeführt, um das Dateideskriptoren -Array zu initialisieren Pipefds folgendermaßen.

Rohr (PipEFDs)

Ich habe auch auf Fehler unter Verwendung des Rückgabewerts der Funktion pipe () überprüft. Ich habe die benutzt Ausfahrt() Funktion zum Terminal des Programms, falls die Rohrfunktion fehlschlägt.

if (pipe (pipEfds) == -1)
Perror ("Pfeife");
exit (exit_failure);

Dann druckte ich den Wert der Lese- und Schreibrohrdateideskriptoren aus Pipefds [0] Und Pipefds [1] bzw.

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 können, ist der Wert des Deskriptors der Lesepipe -Datei Pipefds [0] Ist 3 und schreiben Sie Rohrdateideskriptor Pipefds [1] Ist 4.

Beispiel 2:

Erstellen Sie eine andere C -Quelldatei 2_pipe.C und geben Sie die folgenden Codes -Zeilen ein.

#enthalten
#enthalten
#enthalten
#enthalten
int main (void)
int pipefds [2];
Zeichenpuffer [5];
if (pipe (pipEfds) == -1)
Perror ("Pfeife");
exit (exit_failure);

char *pin = "4128 \ 0";
printf ("Pin zu Pipe schreiben ... \ n");
Schreiben (PipEFDs [1], Pin, 5);
printf ("fertig.\ n \ n ");
printf ("Pin von Pipe ... \ n");
Read (PipEFDS [0], Puffer, 5);
printf ("fertig.\ n \ n ");
printf ("Pin von Pipe: %s \ n", Puffer);
return exit_success;

Dieses Programm zeigt Ihnen grundsätzlich, wie Sie in die Pipe schreiben und die Daten lesen, die Sie aus der Pipe geschrieben haben.

Hier habe ich einen 4-Charakter-Pin-Code in a aufbewahrt verkohlen Array. Die Länge des Arrays beträgt 5 (einschließlich des Nullzeichen \ 0).

char *pin = "4128 \ 0";

Jedes ASCII -Zeichen ist 1 Byte in C. Um den 4 -stelligen Pin durch die Rohr zu senden, müssen Sie 5 Bytes (4 + 1 Null -Zeichen) Daten in die Pipe schreiben.

5 Byte Daten schreiben (Datenbytes (Stift) In das Rohr benutzte ich das schreiben() Funktion mit dem Deskriptor "Write Pipe Datei" Pipefds [1] folgendermaßen.

Schreiben (PipEFDs [1], Pin, 5);

Jetzt, da ich einige Daten in der Pipe habe, kann ich sie aus der Pipe mit dem lesen lesen() Funktion auf dem Deskriptor des Lesepipe -Datei Pipefds [0]. Wie ich 5 Bytes Daten geschrieben habe (Stift) In die Pipe werde ich auch 5 Bytes Daten aus der Pipe lesen. Die gelesenen Daten werden in der gespeichert Puffer Charakter -Array. Da ich 5 Bytes Daten aus der Pipe lesen werde, die Puffer Das Charakter -Array muss mindestens 5 Bytes lang sein.

Ich habe das definiert Puffer Charakterarray am Anfang des hauptsächlich() Funktion.

Zeichenpuffer [5];

Jetzt kann ich den Stift aus der Pfeife lesen und in der speichern Puffer Array mit der folgenden Zeile.

Read (PipEFDS [0], Puffer, 5);

Jetzt, wo ich den Pin aus dem Rohr gelesen habe, kann ich ihn mit dem drucken printf () Funktionen wie gewohnt.

printf ("Pin von Pipe: %s \ n", Puffer);

Sobald ich das Programm ausgeführt habe, wird die richtige Ausgabe angezeigt, wie Sie sehen können.

Beispiel 3:

Erstellen Sie eine neue C -Quelldatei 3_pipe.C als Typ in den folgenden Zeilen von Codes.

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
int main (void)
int pipefds [2];
Char *Pin;
Zeichenpuffer [5];
if (pipe (pipEfds) == -1)
Perror ("Pfeife");
exit (exit_failure);

pid_t pid = fork ();
if (pid == 0) // im untergeordneten Prozess
pin = "4821 \ 0"; // Pin zum Senden
schließen (PIPEFDS [0]); // Schließen Sie
Schreiben (PipEFDs [1], Pin, 5); // Pin in Pipe schreiben
printf ("Pin im Kind generieren und an Eltern senden ... \ n");
Schlaf (2); // Absichtliche Verzögerung
exit (exit_success);

if (pid> 0) // im Hauptprozess
warte (null); // Warten Sie, bis der Kinderprozess fertig ist
schließen (PipEFDs [1]); // Schließen Sie schreiben FD
Read (PipEFDS [0], Puffer, 5); // Pin aus Rohr lesen
schließen (PIPEFDS [0]); // Schließen Sie
printf ("übergeordnete Pin '%s' \ n", Puffer);

return exit_success;

In diesem Beispiel habe ich Ihnen gezeigt. Ich habe einen Pin aus dem untergeordneten Prozess an den übergeordneten Prozess mit einem Rohr gesendet. Lesen Sie dann den Pin aus der Pipe im übergeordneten Vorgang und drucken Sie sie aus dem übergeordneten Prozess aus.

Zunächst habe ich einen Kinderprozess mit fork () -Funktion erstellt.

pid_t pid = fork ();

Dann im Kinderprozess (PID == 0), Ich schrieb den Stift mit der Pfeife an die Pfeife schreiben() Funktion.

Schreiben (PipEFDs [1], Pin, 5);

Sobald der PIN aus dem untergeordneten Prozess an das Rohr geschrieben ist, dem übergeordneten Prozess (PID> 0) Lesen Sie es mit dem Rohr aus dem Rohr lesen() Funktion.

Read (PipEFDS [0], Puffer, 5);

Dann druckte der übergeordnete Prozess den Pin mithilfe printf () Funktionen wie gewohnt.

printf ("übergeordnete Pin '%s' \ n", Puffer);

Wie Sie sehen können, gibt das Ausführen des Programms das erwartete Ergebnis zu.

Beispiel 4:

Erstellen Sie eine neue C -Quelldatei 4_pipe.C als Typ in den folgenden Zeilen von Codes.

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
#define pin_length 4
#define pin_wait_interval 2
void getPin (Zeichen Pin [pin_length + 1])
srand (getPid () + getPlpid ());
Pin [0] = 49 + Rand () % 7;
für (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];
char pin [pin_length + 1];
char buffer [pin_length + 1];
Rohr (PipEFDs);
pid_t pid = fork ();
if (pid == 0)
Getpin (Pin); // Pin erzeugen
schließen (PIPEFDS [0]); // Schließen Sie
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); // die Pin -Generation absichtlich verzögern.
exit (exit_success);

if (pid> 0)
warte (null); // Warten darauf, dass das Kind fertig ist
schließen (PipEFDs [1]); // Schließen Sie schreiben FD
Read (PipEFDS [0], Puffer, Pin_Length + 1); // Pin aus Rohr lesen
schließen (PIPEFDS [0]); // Schließen Sie
printf ("übergeordnete Pin '%s' von Child.\ n \ n ", Puffer);


return exit_success;

Dieses Beispiel ist das gleiche wie Beispiel 3. Der einzige Unterschied besteht darin, dass dieses Programm kontinuierlich einen untergeordneten Prozess erstellt, eine PIN im untergeordneten Prozess erzeugt und die PIN mithilfe einer Rohr.

Der übergeordnete Vorgang liest dann den Pin aus der Rohr und druckt ihn aus.

Dieses Programm generiert eine neue Pin_Length -Pin jeder pin_wait_interval Sekunden.

Wie Sie sehen können, funktioniert das Programm wie erwartet.

Sie können das Programm nur durch Drücken stoppen + C.

So verwenden Sie den PIPE () -Systemanruf in C -Programmiersprache. Danke, dass du diesen Artikel gelesen hast.