Se, det är ett fullständigt, fungerande och sammanställbart exempel. Tveka inte att kompilera det själv och testa det, det fungerar verkligen. Du bör ringa programmet från en sådan terminal:

Låt oss nu fokusera på själva läsanropet:

Den lästa signaturen är följande (extraherad från Linux-man-sidor):

Först representerar fd-argumentet filbeskrivaren. Jag har förklarat lite detta koncept i min gaffelartikel.  En filbeskrivare är ett int som representerar en öppen fil, sockel, rör, FIFO, enhet, ja det är många saker där data kan läsas eller skrivas, vanligtvis på ett strömliknande sätt. Jag kommer att gå mer i detalj om det i en framtida artikel.

öppen funktion är ett sätt att berätta för Linux: Jag vill göra saker med filen på den vägen, vänligen hitta den där den är och ge mig tillgång till den. Det kommer att ge dig tillbaka den så kallade filbeskrivaren och nu, om du vill göra något med den här filen, använd det numret. Glöm inte att ringa nära när du är klar med filen, som i exemplet.

Så du måste ange detta speciella nummer att läsa. Sedan finns det buf-argumentet. Du bör här ange en pekare till matrisen där läst lagrar dina data. Slutligen räknar du hur många byte det läser högst.

Returvärdet är av typen ssize_t. Konstig typ, eller hur?? Det betyder "signerad storlek_t", i grund och botten är det en lång int. Det returnerar antalet byte som den läser framgångsrikt, eller -1 om det finns ett problem. Du kan hitta den exakta orsaken till problemet i errno global variabel skapad av Linux, definierad i . Men för att skriva ut ett felmeddelande är det bättre att använda perror eftersom det skriver fel på dina vägnar.

I normala filer - och endast i det här fallet - läs kommer endast att returnera mindre än att räkna om du har nått filens slut. Buf-arrayen du tillhandahåller måste vara tillräckligt stor för att åtminstone kunna räkna byte, annars kan ditt program krascha eller skapa ett säkerhetsfel.

Nu är läsning inte bara användbar för vanliga filer och om du vill känna dess superkrafter - Ja jag vet att det inte finns i någon Marvels serier men det har sanna krafter - du vill använda den med andra strömmar som rör eller uttag. Låt oss ta en titt på det:

Linux-specialfiler och läst systemanrop

Faktaläsning fungerar med en mängd olika filer som rör, uttag, FIFO eller specialenheter som en disk eller seriell port är det som gör den riktigt kraftfullare. Med vissa anpassningar kan du göra riktigt intressanta saker. För det första betyder det att du bokstavligen kan skriva funktioner som arbetar på en fil och istället använda den med ett rör. Det är intressant att skicka data utan att någonsin slå på disk, vilket garanterar bästa prestanda.

Men detta utlöser också speciella regler. Låt oss ta exemplet med att läsa en rad från terminalen jämfört med en vanlig fil. När du ringer för att läsa på en vanlig fil behöver det bara några millisekunder till Linux för att få den mängd data du begär.

Men när det gäller terminal är det en annan historia: låt oss säga att du ber om ett användarnamn. Användaren skriver in terminalens användarnamn och trycker på Enter. Nu följer du mitt råd ovan och du ringer läsa med en stor buffert som 256 byte.

Om läsningen fungerade som med filer, skulle den vänta på att användaren skulle skriva 256 tecken innan han återvände! Din användare skulle vänta för evigt och sedan tyvärr döda din ansökan. Det är verkligen inte vad du vill, och du skulle ha ett stort problem.

Okej, du kan läsa en bit i taget men den här lösningen är väldigt ineffektiv, som jag sa till dig ovan. Det måste fungera bättre än så.

Men Linux-utvecklare tänkte läsa annorlunda för att undvika detta problem:

• När du läser vanliga filer försöker det så mycket som möjligt att läsa antal byte och det kommer aktivt att få byte från disk om det behövs.
• För alla andra filtyper kommer den att returneras så snart som det finns en del data tillgängliga och som mest räkna byte:
  1. För terminaler är det allmänt när användaren trycker på Enter-tangenten.
  2. För TCP-uttag är det så snart din dator får något, det spelar ingen roll hur mycket byte det får.
  3. För FIFO eller rör är det i allmänhet samma mängd som det andra programmet skrev, men Linux-kärnan kan leverera mindre åt gången om det är mer bekvämt.

Så du kan säkert ringa med din 2 KiB-buffert utan att hålla dig låst för alltid. Observera att det också kan avbrytas om applikationen får en signal. Eftersom läsning från alla dessa källor kan ta sekunder eller till och med timmar - tills den andra sidan trots allt bestämmer sig för att skriva - avbryts av signaler gör det möjligt att sluta stanna kvar för länge.

Detta har dock också en nackdel: när du vill läsa exakt 2 KiB med dessa specialfiler måste du kontrollera läsets returvärde och samtalsläsa flera gånger. läs fyller sällan hela din buffert. Om din applikation använder signaler måste du också kontrollera om läsningen misslyckades med -1 eftersom den avbröts av en signal med hjälp av errno.

Låt mig visa dig hur det kan vara intressant att använda denna speciella egenskap att läsa: