Se, det er et fuldt blæst, fungerende og kompilerbart eksempel. Tøv ikke med at kompilere det selv og teste det, det virker virkelig. Du skal ringe til programmet fra en terminal som denne:

Lad os nu fokusere på selve læseopkaldet:

Den læste signatur er følgende (ekstraheret fra Linux-man-sider):

For det første repræsenterer fd-argumentet filbeskrivelsen. Jeg har forklaret lidt dette koncept i min gaffelartikel.  En filbeskrivelse er en int, der repræsenterer en åben fil, stikkontakt, rør, FIFO, enhed, ja det er mange ting, hvor data kan læses eller skrives, generelt på en strømlignende måde. Jeg vil gå mere i dybden med det i en fremtidig artikel.

åben funktion er en af ​​måderne at fortælle til Linux: Jeg vil gøre ting med filen på den vej, find den, hvor den er, og giv mig adgang til den. Det giver dig denne int-kaldte filbeskrivelse tilbage, og hvis du vil gøre noget med denne fil, skal du bruge dette nummer. Glem ikke at ringe tæt, når du er færdig med filen, som i eksemplet.

Så du skal angive dette specielle nummer, der skal læses. Så er der buf-argumentet. Du skal her give en markør til det array, hvor læsning gemmer dine data. Endelig tæller det, hvor mange byte det højst læser.

Returneringsværdien er af typen ssize_t. Underlig type, er det ikke?? Det betyder "signeret størrelse_t", dybest set er det en lang int. Det returnerer antallet af bytes, det med succes læser, eller -1, hvis der er et problem. Du kan finde den nøjagtige årsag til problemet i den errno globale variabel oprettet af Linux, defineret i . Men for at udskrive en fejlmeddelelse er det bedre at bruge perror, da det udskriver errno på dine vegne.

I normale filer - og kun i dette tilfælde - læse returnerer kun mindre end tæller, hvis du har nået filens afslutning. Det buf-array, du leverer skal være stor nok til i det mindste at tælle bytes, ellers kan dit program gå ned eller oprette en sikkerhedsfejl.

Nu er læsning ikke kun nyttig til normale filer, og hvis du vil føle dens superkræfter - Ja, jeg ved, det er ikke i nogen Marvels tegneserier, men det har ægte kræfter - du vil gerne bruge den med andre strømme som f.eks. rør eller stikkontakter. Lad os se på det:

Linux-specialfiler og læs systemopkald

Den faktiske læsning fungerer med en række filer som f.eks. Rør, stikkontakter, FIFO'er eller specielle enheder såsom en disk eller seriel port er det, der gør det virkelig mere kraftfuldt. Med nogle tilpasninger kan du gøre rigtig interessante ting. For det første betyder det, at du bogstaveligt talt kan skrive funktioner, der arbejder på en fil og i stedet bruge det med et rør. Det er interessant at videregive data uden nogensinde at ramme disken, hvilket sikrer den bedste ydeevne.

Dette udløser dog også særlige regler. Lad os tage eksemplet med at læse en linje fra terminal sammenlignet med en normal fil. Når du kalder læs på en normal fil, behøver det kun få millisekunder til Linux for at få den mængde data, du anmoder om.

Men når det kommer til terminal, er det en anden historie: lad os sige, at du beder om et brugernavn. Brugeren indtaster terminalens brugernavn og trykker på Enter. Nu følger du mit råd ovenfor, og du kalder læs med en stor buffer som 256 byte.

Hvis læst fungerede som det gjorde med filer, ville det vente på, at brugeren skrev 256 tegn, før han vendte tilbage! Din bruger ville vente for evigt og derefter desværre dræbe din applikation. Det er bestemt ikke, hvad du vil have, og du ville have et stort problem.

Okay, du kunne læse en byte ad gangen, men denne løsning er frygtelig ineffektiv, som jeg fortalte dig ovenfor. Det skal fungere bedre end det.

Men Linux-udviklere tænkte at læse anderledes for at undgå dette problem:

• Når du læser normale filer, forsøger det så meget som muligt at læse antal byte, og det får aktivt bytes fra disken, hvis det er nødvendigt.
• For alle andre filtyper vender den tilbage så snart der er nogle tilgængelige data og højst tæl bytes:
  1. For terminaler er det generelt når brugeren trykker på Enter-tasten.
  2. For TCP-stik er det, så snart din computer modtager noget, betyder ikke noget, hvor mange byte den får.
  3. For FIFO eller rør er det generelt det samme beløb som det, den anden applikation skrev, men Linux-kernen kan levere mindre ad gangen, hvis det er mere praktisk.

Så du kan roligt ringe med din 2 KiB-buffer uden at forblive låst inde for evigt. Bemærk, at det også kan blive afbrudt, hvis applikationen modtager et signal. Da læsning fra alle disse kilder kan tage sekunder eller endda timer - indtil den anden side trods alt beslutter at skrive - at blive afbrudt af signaler gør det muligt at stoppe med at blive blokeret for længe.

Dette har dog også en ulempe: Når du nøjagtigt vil læse 2 KiB med disse specielle filer, skal du kontrollere læsets returværdi og ringe læse flere gange. læse udfylder sjældent hele din buffer. Hvis din applikation bruger signaler, skal du også kontrollere, om læsningen mislykkedes med -1, fordi den blev afbrudt af et signal ved hjælp af errno.

Lad mig vise dig, hvordan det kan være interessant at bruge denne særlige egenskab ved at læse: