rura() to funkcja systemu Linux. rura() Funkcja systemu służy do otwierania deskryptorów plików, które są używane do komunikacji między różnymi procesami Linux. Krótko mówiąc, rura() Funkcja jest używana do komunikacji między procesami w Linux. W tym artykule pokażę Ci, jak używać funkcji systemu ripe () w Linux. Więc zacznijmy.

Wszystko o funkcji Pipe ():

Składnia rura() Funkcja to:

int rura (int ripefd [2]);

Tutaj funkcja PIPE () tworzy jednokierunkowy kanał danych do komunikacji między procesami. Mijasz w int (Liczba całkowita) tablica typu PIPEFD składający się z 2 elementów tablicy do rury funkcyjnej (). Następnie funkcja ripe () tworzy dwa deskryptory plików w PIPEFD szyk.

Pierwszy element PIPEFD szyk, PIPEFD [0] służy do odczytu danych z rury.

Drugi element PIPEFD szyk, PIPEFD [1] służy do pisania danych do rury.

Po sukcesie funkcja rury () zwraca 0. Jeśli błąd wystąpi podczas inicjalizacji rury, funkcja ripe () zwraca -1.

Funkcja rury () jest zdefiniowana w nagłówku unistd.H. Aby użyć funkcji Pipe () w programie C, musisz dołączyć nagłówek unistd.H następująco:

#włączać

Aby uzyskać więcej informacji na temat funkcji systemu Pipe (), sprawdź stronę Man of Pipe () za pomocą następującego polecenia:

$ man 2 rura
Strona Man of Pipe ().

Przykład 1:

Dla pierwszego przykładu utwórz nowy plik źródłowy C 1_pipe.C i wpisz następujące wiersze kodów.

#włączać
#włączać
#włączać
int main (void)
int ripefds [2];
if (ripe (PipeFDS) == -1)
Perror („rura”);
exit (exit_failure);

printf („Wartość deskryptora pliku odczytu: %d \ n”, PipeFD [0]);
printf („Wartość deskryptora pliku zapis: %d \ n”, PipeFD [1]);
return exit_success;

Tutaj dołączyłem plik nagłówka Pipe () unistd.H Najpierw z następującą linią.

#włączać

Następnie w główny() funkcja, zdefiniowałem Pipefds Dwa elementarne macierz liczby całkowitych z następującym wierszem.

int ripefds [2];

Następnie uruchomiłem funkcję PIPE (), aby zainicjować tablicę deskryptorów plików Pipefds następująco.

Rura (Pipefds)

Sprawdziłem również błędy za pomocą wartości zwracanej funkcji rury (). Użyłem Wyjście() funkcja do terminalu program w przypadku awarii funkcji rury.

if (ripe (PipeFDS) == -1)
Perror („rura”);
exit (exit_failure);

Następnie wydrukowałem wartość deskryptorów odczytu i zapisu plików rury Pipefds [0] I Pipefds [1] odpowiednio.

printf („Wartość deskryptora pliku odczytu: %d \ n”, PipeFD [0]);
printf („Wartość deskryptora pliku zapis: %d \ n”, PipeFD [1]);

Jeśli uruchomisz program, powinieneś zobaczyć następujące dane wyjściowe. Jak widać, wartość deskryptora odczytu pliku rury Pipefds [0] Jest 3 i napisz deskryptor pliku rury Pipefds [1] Jest 4.

Przykład 2:

Utwórz inny plik źródłowy C 2_pipe.C i wpisz następujące wiersze kodów.

#włączać
#włączać
#włączać
#włączać
int main (void)
int ripefds [2];
Bufor char [5];
if (ripe (PipeFDS) == -1)
Perror („rura”);
exit (exit_failure);

char *pin = "4128 \ 0";
printf („Pisanie szpilki do rur… \ n”);
Write (PipeFDS [1], pin, 5);
printf („gotowe.\ n \ n ”);
printf („Czytanie pinów z rury… \ n”);
odczyt (PipeFDS [0], bufor, 5);
printf („gotowe.\ n \ n ”);
printf („Pin z rury: %s \ n”, bufor);
return exit_success;

Ten program zasadniczo pokazuje, jak napisać do rury i odczytać dane, które napisałeś z rury.

Tutaj przechowyłem 4-znakowy kod PIN w zwęglać szyk. Długość tablicy wynosi 5 (w tym znak zerowy \ 0).

char *pin = "4128 \ 0";

Każdy znak ASCII ma 1 bajt w C. Aby wysłać 4 -cyfrowy szpilkę przez rurę, musisz napisać 5 bajtów (4 + 1 znak zerowy) danych do rury.

Napisać 5 bajtów danych (szpilka) Do rury użyłem pisać() funkcja za pomocą deskryptora pliku rur zapisu Pipefds [1] następująco.

Write (PipeFDS [1], pin, 5);

Teraz, gdy mam pewne dane w rurze, mogę je odczytać z rury za pomocą Czytać() Funkcja na deskryptorze pliku rury odczytu Pipefds [0]. Jak napisałem 5 bajtów danych (szpilka) W rurze będę również odczytać 5 bajtów danych z rury. Odczyt danych będzie przechowywany w bufor tablica postaci. Jak będę czytać 5 bajtów danych z rury, bufor tablica znaków musi mieć co najmniej 5 bajtów.

Zdefiniowałem bufor tablica postaci na początku główny() funkcjonować.

Bufor char [5];

Teraz mogę odczytać szpilkę z rury i przechowywać w bufor tablica z następującą linią.

odczyt (PipeFDS [0], bufor, 5);

Teraz, gdy przeczytałem szpilkę z rury, mogę go wydrukować za pomocą printf () funkcjonować jak zwykle.

printf („Pin z rury: %s \ n”, bufor);

Po uruchomieniu programu wyświetlane jest prawidłowe wyjście, jak widać.

Przykład 3:

Utwórz nowy plik źródłowy C 3_pipe.C jako typ w następujących wierszach kodów.

#włączać
#włączać
#włączać
#włączać
#włączać
int main (void)
int ripefds [2];
char *pin;
Bufor char [5];
if (ripe (PipeFDS) == -1)
Perror („rura”);
exit (exit_failure);

PID_T PID = Fork ();
if (PID == 0) // w procesie dziecka
pin = "4821 \ 0"; // PIN, aby wysłać
Zamknij (PipeFD [0]); // Zamknij przeczytaj FD
Write (PipeFDS [1], pin, 5); // Napisz szpilkę do rury
printf („Generowanie szpilki w dziecku i wysyłanie do rodzica… \ n”);
sen (2); // zamierzone opóźnienie
exit (exit_success);

if (PID> 0) // w głównym procesie
Czekaj (NULL); // Poczekaj, aż proces dziecięcy skończy
Zamknij (PipeFD [1]); // Zamknij zapisz FD
odczyt (PipeFDS [0], bufor, 5); // Odczytaj szpilkę z rury
Zamknij (PipeFD [0]); // Zamknij przeczytaj FD
printf („rodzic otrzymał pin '%s' \ n”, bufor);

return exit_success;

W tym przykładzie pokazałem, jak używać rur do komunikacji między procesami. Wysłałem szpilkę z procesu dziecka do procesu nadrzędnego za pomocą rury. Następnie odczytaj pin z rury w procesie nadrzędnym i wydrukuj go z procesu nadrzędnego.

Najpierw stworzyłem proces dziecięcy za pomocą funkcji Fork ().

PID_T PID = Fork ();

Następnie w procesie dziecka (PID == 0), Napisałem szpilkę do rury za pomocą pisać() funkcjonować.

Write (PipeFDS [1], pin, 5);

Po zapisaniu pinu do rury z procesu potomnego procesu (PID> 0) Przeczytaj go z rury za pomocą Czytać() funkcjonować.

odczyt (PipeFDS [0], bufor, 5);

Następnie proces nadrzędny wydrukował szpilkę za pomocą printf () funkcjonować jak zwykle.

printf („rodzic otrzymał pin '%s' \ n”, bufor);

Jak widać, uruchomienie programu daje oczekiwany wynik.

Przykład 4:

Utwórz nowy plik źródłowy C 4_pipe.C jako typ w następujących wierszach kodów.

#włączać
#włączać
#włączać
#włączać
#włączać
#definicja pin_length 4
#definicja pin_wait_interval 2
void getpin (char pin [pin_length + 1])
srand (getPid () + getPPID ());
pin [0] = 49 + rand () % 7;
dla (int i = 1; i < PIN_LENGTH; i++)
pin [i] = 48 + rand () % 7;

pin [pin_length] = '\ 0';

int main (void)
while (1)
int ripefds [2];
Pin char [pin_length + 1];
Char Buffer [pin_length + 1];
rura (Pipefds);
PID_T PID = Fork ();
if (pid == 0)
getpin (pin); // Wygeneruj PIN
Zamknij (PipeFD [0]); // Zamknij przeczytaj FD
Write (PipeFDS [1], pin, pin_length + 1); // Napisz szpilkę do rury
printf („Generowanie szpilki w dziecku i wysyłanie do rodzica… \ n”);
sleep (pin_wait_interval); // celowo opóźniać generowanie pinów.
exit (exit_success);

if (PID> 0)
Czekaj (NULL); // Oczekiwanie na zakończenie dziecka
Zamknij (PipeFD [1]); // Zamknij zapisz FD
odczyt (PipeFDS [0], bufor, pin_length + 1); // Odczytaj szpilkę z rury
Zamknij (PipeFD [0]); // Zamknij przeczytaj FD
printf („rodzic otrzymał pin '%s” od dziecka.\ n \ n ”, bufor);


return exit_success;

Ten przykład jest taki sam jak Przykład 3. Jedyną różnicą jest to, że program ten stale tworzy proces potomny, generuje kod PIN w procesie dziecka i wysyła PIN do procesu nadrzędnego za pomocą rury.

Proces nadrzędny następnie odczytuje szpilkę z rury i drukuje.

Ten program generuje nowy pin pin_length w każdej sekund pin_wait_interval.

Jak widać, program działa zgodnie z oczekiwaniami.

Możesz zatrzymać program tylko naciskając + C.

W ten sposób używasz wywołania systemu Pipe () w języku programowania C. Dziękujemy za przeczytanie tego artykułu.