Sintaxa țeavă () funcția este:
intconductă(intpipefd[2]);
Aici, funcția pipe () creează un canal de date unidirecțional pentru comunicarea inter-proces. Treci într-un int (Întreg) matrice de tip pipefd format din 2 elemente de matrice la conducta funcțională (). Apoi funcția pipe () creează doi descriptori de fișiere în pipefd matrice.
Primul element al pipefd matrice, pipefd [0] este utilizat pentru citirea datelor din conductă.
Al doilea element al pipefd matrice, pipefd [1] este folosit pentru scrierea datelor în conductă.
La succes, funcția pipe () returnează 0. Dacă apare o eroare în timpul inițializării pipe, atunci funcția pipe () returnează -1.
Funcția pipe () este definită în antet unistd.h . Pentru a utiliza funcția pipe () în programul dvs. C, trebuie să includeți antetul unistd.h după cum urmează:
#include
Pentru mai multe informații despre funcția sistemului pipe (), verificați pagina manuală a pipe () cu următoarea comandă:
$ omule2conductăPagina manuală a pipei().
Exemplul 1:
Pentru primul exemplu, creați un nou fișier sursă C. 1_pipe.c și introduceți următoarele linii de coduri.
#include#include
#include
intprincipal(nul) {
intpipefds[2];
dacă(conductă(pipefds) == -1) {
perror („țeavă”);
Ieșire (EXIT_FAILURE);
}
printf („Citiți valoarea descriptorului fișierului:% d n',pipefds[0]);
printf ('Scrie valoarea descriptorului fișierului:% d n',pipefds[1]);
întoarcereEXIT_SUCCESS;
}
Aici, am inclus fișierul antet al pipe () unistd.h mai întâi cu următoarea linie.
#includeApoi, în principal() funcție, am definit pipefds matrice între două elemente cu următoarea linie.
intpipefds[2];Apoi, am rulat funcția pipe () pentru a inițializa matricea descriptorilor de fișiere pipefds după cum urmează.
conductă(pipefds)De asemenea, am verificat erori folosind valoarea returnată a funcției pipe (). Am folosit Ieșire() funcția de a termina programul în cazul în care funcția conductei eșuează.
dacă(conductă(pipefds) == -1) {perror („țeavă”);
Ieșire (EXIT_FAILURE);
}
Apoi, am tipărit valoarea descriptorilor fișierelor de citire și scriere pipefds [0] și pipefds [1] respectiv.
printf („Citiți valoarea descriptorului fișierului:% d n',pipefds[0]);printf ('Scrie valoarea descriptorului fișierului:% d n',pipefds[1]);
Dacă rulați programul, ar trebui să vedeți următoarea ieșire. După cum puteți vedea, valoarea descriptorului fișierului țeavă citit pipefds [0] este 3 și scrieți descriptorul fișierului pipe pipefds [1] este 4 .
Exemplul 2:
Creați un alt fișier sursă C. 2_pipe.c și introduceți următoarele linii de coduri.
#include#include
#include
#include
intprincipal(nul) {
intpipefds[2];
chartampon[5];
dacă(conductă(pipefds) == -1) {
perror („țeavă”);
Ieșire (EXIT_FAILURE);
}
char *pin= '4128 0';
printf („Scrierea codului PIN pentru a țevi ... n');
scrie(pipefds[1],pin, 5);
printf ('Terminat. n n');
printf („Citirea codului PIN din conductă ... n');
citit(pipefds[0],tampon, 5);
printf ('Terminat. n n');
printf ('PIN din conductă:% s n',tampon);
întoarcereEXIT_SUCCESS;
}
Acest program vă arată practic cum să scrieți în pipă și să citiți datele pe care le-ați scris din pipă.
Aici am stocat un cod PIN de 4 caractere într-un char matrice. Lungimea tabloului este 5 (inclusiv caracterul NULL 0).
char *pin= '4128 0';Fiecare caracter ASCII are o dimensiune de 1 octet în C. Deci, pentru a trimite codul PIN de 4 cifre prin conductă, trebuie să scrieți 5 octeți (4 + 1 caracter NULL) de date în conductă.
Pentru a scrie 5 octeți de date ( pin ) în conductă, am folosit scrie() funcția utilizând descriptorul de fișier de scriere a țevii pipefds [1] după cum urmează.
scrie(pipefds[1],pin, 5);Acum, că am câteva date în țeavă, o pot citi din țeavă folosind citit() funcție pe descriptorul fișierului de citire a țevii pipefds [0] . După cum am scris 5 octeți de date ( pin ) în conductă, voi citi și 5 octeți de date din conductă. Datele citite vor fi stocate în tampon matrice de caractere. Deoarece voi citi 5 octeți de date din conductă, tampon matricea de caractere trebuie să aibă cel puțin 5 octeți lungime.
Am definit tampon matrice de caractere la începutul principal() funcţie.
chartampon[5];Acum, pot citi codul PIN din conductă și îl pot stoca în tampon matrice cu următoarea linie.
citit(pipefds[0],tampon, 5);Acum că am citit PIN-ul din țeavă, îl pot imprima folosind printf () funcționează ca de obicei.
printf ('PIN din conductă:% s n',tampon);Odată ce am rulat programul, rezultatul corect este afișat după cum puteți vedea.
Exemplul 3:
Creați un nou fișier sursă C. 3_pipe.c ca tip în următoarele rânduri de coduri.
#include#include
#include
#include
#include
intprincipal(nul) {
intpipefds[2];
char *pin;
chartampon[5];
dacă(conductă(pipefds) == -1) {
perror („țeavă”);
Ieșire (EXIT_FAILURE);
}
pid_t pid=furculiţă();
dacă(pid== 0) { // în procesul copil
pin= '4821 0'; // PIN pentru a trimite
închide(pipefds[0]); // închide citit fd
scrie(pipefds[1],pin, 5); // scrie PIN la țeavă
printf („Generarea codului PIN în copil și trimiterea către părinte ... n');
dormi(2); // întârziere intenționată
Ieșire (EXIT_SUCCESS);
}
dacă(pid> 0) { // în proces principal
aștepta(NUL); // așteptați finalizarea procesului copil
închide(pipefds[1]); // închide scrie fd
citit(pipefds[0],tampon, 5); // citiți codul PIN din țeavă
închide(pipefds[0]); // închide citit fd
printf („Părintele a primit codul PIN„% s ” n',tampon);
}
întoarcereEXIT_SUCCESS;
}
În acest exemplu, v-am arătat cum să utilizați conducta pentru comunicarea inter-proces. Am trimis un cod PIN din procesul copil către procesul părinte folosind un canal. Apoi citiți codul PIN din conducta din procesul părinte și imprimați-l din procesul părinte.
În primul rând, am creat un proces copil folosind funcția fork ().
pid_t pid=furculiţă();Apoi, în procesul copilului ( pid == 0 ), Am scris PIN-ul pe țeavă folosind scrie() funcţie.
scrie(pipefds[1],pin, 5);Odată ce PIN-ul este scris în conductă din procesul copil, procesul părinte ( pid> 0 ) citiți-l din țeavă folosind citit() funcţie.
citit(pipefds[0],tampon, 5);Apoi, procesul părinte a tipărit codul PIN folosind printf () funcționează ca de obicei.
printf („Părintele a primit codul PIN„% s ” n',tampon);După cum puteți vedea, rularea programului oferă rezultatul scontat.
Exemplul 4:
Creați un nou fișier sursă C. 4_pipe.c ca tip în următoarele rânduri de coduri.
#include#include
#include
#include
#include
#define PIN_LENGTH 4
#define PIN_WAIT_INTERVAL 2
nulgetPIN(charpin[PIN_LENGTH+ 1]) {
srand (obraznic() +înfiorat());
pin[0] = 49 + rand () % 7;
pentru(inteu= 1;eu<PIN_LENGTH;eu++) {
pin[eu] = 48 + rand () % 7;
}
pin[PIN_LENGTH] = ' 0';
}
intprincipal(nul) {
in timp ce(1) {
intpipefds[2];
charpin[PIN_LENGTH+ 1];
chartampon[PIN_LENGTH+ 1];
conductă(pipefds);
pid_t pid=furculiţă();
dacă(pid== 0) {
getPIN(pin); // generează codul PIN
închide(pipefds[0]); // închide citit fd
scrie(pipefds[1],pin,PIN_LENGTH+ 1); // scrie PIN la țeavă
printf („Generarea codului PIN în copil și trimiterea către părinte ... n');
dormi(PIN_WAIT_INTERVAL); // întârzierea generării PIN în mod intenționat.
Ieșire (EXIT_SUCCESS);
}
dacă(pid> 0) {
aștepta(NUL); // așteptând să termine copilul
închide(pipefds[1]); // închide scrie fd
citit(pipefds[0],tampon,PIN_LENGTH+ 1); // citiți codul PIN din țeavă
închide(pipefds[0]); // închide citit fd
printf („Părintele a primit codul PIN„% s ”de la copil. n n',tampon);
}
}
întoarcereEXIT_SUCCESS;
}
Acest exemplu este același cu Exemplul 3 . Singura diferență este că acest program creează continuu un proces copil, generează un cod PIN în procesul copil și trimite codul PIN către procesul părinte folosind o conductă.
Procesul părinte citește apoi codul PIN din țeavă și îl imprimă.
Acest program generează un nou PIN_LENGTH PIN la fiecare PIN_WAIT_INTERVAL secunde.
După cum puteți vedea, programul funcționează conform așteptărilor.
Puteți opri programul doar apăsând + C .
Deci, așa utilizați apelul de sistem pipe () în limbajul de programare C. Vă mulțumim că ați citit acest articol.