Kijk, het is een compleet, werkend en compileerbaar voorbeeld. Aarzel niet om het zelf te compileren en te testen, het werkt echt. U zou het programma vanaf een terminal als deze moeten aanroepen:

Laten we ons nu concentreren op de leesaanroep zelf:

De leeshandtekening is de volgende (geëxtraheerd uit Linux man-pagina's):

Ten eerste vertegenwoordigt het fd-argument de bestandsdescriptor. Ik heb dit concept een beetje uitgelegd in mijn vorkartikel.  Een bestandsdescriptor is een int die een open bestand, socket, pijp, FIFO, apparaat vertegenwoordigt, nou, het zijn veel dingen waar gegevens kunnen worden gelezen of geschreven, meestal op een stream-achtige manier. Daar ga ik in een volgend artikel dieper op in.

open-functie is een van de manieren om Linux te vertellen: ik wil dingen doen met het bestand op dat pad, zoek het alsjeblieft op waar het is en geef me er toegang toe. Het geeft je deze int genaamd bestandsdescriptor terug en nu, als je iets met dit bestand wilt doen, gebruik dan dat nummer. Vergeet niet close te bellen als je klaar bent met het bestand, zoals in het voorbeeld.

U moet dus dit speciale nummer opgeven om te kunnen lezen. Dan is er het buf-argument. U moet hier een verwijzing naar de array opgeven waar read uw gegevens zal opslaan. Ten slotte, tel is hoeveel bytes het maximaal zal lezen.

De retourwaarde is van het type ssize_t. Vreemd type, niet?? Het betekent "ondertekend size_t", eigenlijk is het een lange int. Het geeft het aantal bytes terug dat het met succes heeft gelezen, of -1 als er een probleem is. Je kunt de exacte oorzaak van het probleem vinden in de errno globale variabele gemaakt door Linux, gedefinieerd in defined . Maar om een ​​foutbericht af te drukken, is het beter om perror te gebruiken omdat het namens jou errno afdrukt.

In normale bestanden - en enkel en alleen in dit geval - read geeft alleen minder dan count terug als je het einde van het bestand hebt bereikt. De buf-array die u verstrekt moet groot genoeg zijn om op zijn minst in bytes te passen, anders kan je programma crashen of een beveiligingsfout veroorzaken.

Nu is lezen niet alleen handig voor normale bestanden en als je de superkrachten ervan wilt voelen - Ja, ik weet dat het in geen enkele Marvel-strip staat, maar het heeft echte krachten - je zult het willen gebruiken met andere streams zoals pijpen of stopcontacten. Laten we daar eens naar kijken:

Speciale Linux-bestanden en systeemoproep lezen

Het feit dat lezen werkt met een verscheidenheid aan bestanden, zoals buizen, sockets, FIFO's of speciale apparaten zoals een schijf of seriële poort, maakt het echt krachtiger. Met wat aanpassingen kun je echt interessante dingen doen. Ten eerste betekent dit dat je letterlijk functies kunt schrijven die aan een bestand werken en het in plaats daarvan met een pijp gebruiken. Dat is interessant om gegevens door te geven zonder ooit de schijf te raken, wat zorgt voor de beste prestaties.

Dit leidt echter ook tot speciale regels. Laten we het voorbeeld nemen van het lezen van een regel van terminal in vergelijking met een normaal bestand. Wanneer je read op een normaal bestand aanroept, heeft Linux maar een paar milliseconden nodig om de hoeveelheid gegevens te krijgen die je vraagt.

Maar als het op terminal aankomt, is dat een ander verhaal: laten we zeggen dat je om een ​​gebruikersnaam vraagt. De gebruiker typt terminal haar/zijn gebruikersnaam in en drukt op Enter. Nu volg je mijn advies hierboven en roep je read met een grote buffer zoals 256 bytes.

Als lezen werkte zoals het deed met bestanden, zou het wachten tot de gebruiker 256 tekens typt voordat hij terugkeert! Je gebruiker zou eeuwig wachten en dan helaas je applicatie doden kill. Het is zeker niet wat je wilt, en je zou een groot probleem hebben.

Oké, je zou één byte per keer kunnen lezen, maar deze oplossing is vreselijk inefficiënt, zoals ik je hierboven heb verteld. Het moet beter werken dan dat.

Maar Linux-ontwikkelaars dachten anders te lezen om dit probleem te voorkomen:

• Wanneer je normale bestanden leest, probeert het zoveel mogelijk bytes te lezen en het zal actief bytes van de schijf halen als dat nodig is.
• Voor alle andere bestandstypen zal het terugkeren zodra er zijn wat gegevens beschikbaar en hoogstens tel bytes:
  1. Voor terminals is het: over het algemeen wanneer de gebruiker op de Enter-toets drukt.
  2. Voor TCP-sockets geldt: zodra uw computer iets ontvangt, maakt het niet uit hoeveel bytes het krijgt.
  3. Voor FIFO of pipes is het over het algemeen hetzelfde bedrag als wat de andere applicatie schreef, maar de Linux-kernel kan minder tegelijk leveren als dat handiger is.

U kunt dus veilig bellen met uw 2 KiB-buffer zonder voor altijd opgesloten te zitten. Merk op dat het ook onderbroken kan worden als de applicatie een signaal ontvangt. Omdat het lezen van al deze bronnen seconden of zelfs uren kan duren - totdat de andere kant toch besluit te schrijven - onderbroken worden door signalen maakt het mogelijk om te lang geblokkeerd te blijven.

Dit heeft echter ook een nadeel: als je precies 2 KiB wilt lezen met deze speciale bestanden, moet je de return-waarde van read controleren en read meerdere keren aanroepen. lezen vult zelden je hele buffer. Als uw toepassing signalen gebruikt, moet u ook controleren of het lezen is mislukt met -1 omdat deze werd onderbroken door een signaal, met errno.

Ik zal je laten zien hoe het interessant kan zijn om deze speciale eigenschap van read: