C-keele read funktsioon: põhjalik juhend algajatele ja edasijõudnutele

1. Sissejuhatus

Mis on C-keele read funktsioon?

Erinevus teistest I/O funktsioonidest

Artiklis käsitletavad teemad

1. Põhiline kasutamine Õpid read funktsiooni prototüüpi, argumentide tähendust ja tagastusväärtusi.
2. Konkreetseid näiteid Näidised failide lugemisest, standard-sisendist ja soklikommunikatsioonist.
3. Rakendused ja tõrkeotsing Asünkroonse I/O seadistamine ja parimad praktikad veakäitluses.
4. Korduma kippuvad küsimused FAQ-vormis tüüpiliste probleemide lahendused.

2. read funktsiooni põhialused

read funktsiooni prototüüp

ssize_t read(int fd, void *buf, size_t count);

Argumentide selgitus

1. fd (failikirjeldaja)

• Määrab sihtkoha, kust lugeda.
• Näiteks open funktsiooniga saadud failikirjeldaja või standard-sisend (0), standard-väljund (1).

1. buf (puhver)

• Mälu aadress, kuhu loetud andmed ajutiselt salvestatakse.
• Puhver peab olema piisavalt suur, et mahutada loetavad andmed.

1. count (baitide arv)

• Määrab maksimaalse baitide arvu, mida loetakse.
• Soovitav on määrata väärtus, mis ei ületa puhvri suurust.

Tagastusväärtus

• Edukas lugemine: tagastab loetud baitide arvu (0 tähistab EOF-i).
• Viga: tagastab -1 ja veainfo on saadaval errno kaudu.

Põhiline kasutusnäide

Koodinäide

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    char buffer[128];
    ssize_t bytesRead;

    while ((bytesRead = read(fd, buffer, sizeof(buffer) - 1)) > 0) {
        buffer[bytesRead] = '\0'; // Lisa lõputähis, et käsitleda stringina
        printf("%s", buffer);
    }

    if (bytesRead == -1) {
        perror("Faili lugemine ebaõnnestus");
    }

    close(fd);
    return 0;
}

Koodi selgitus

1. Faili avamine open funktsiooniga

• Avatakse ainult lugemiseks, kasutades O_RDONLY.
• Kui fail ei avane, kuvatakse veateade.

1. Andmete lugemine read funktsiooniga

• Loetakse kuni 128 baiti ja salvestatakse buffer-isse.
• Tagastatakse tegelikult loetud baitide arv.

1. Veakäitlus

• Kui faili ei eksisteeri või õigused puuduvad, tagastatakse -1.

1. Puhvri lõpetamine

• Lisatakse '\0', et töödelda loetud andmeid stringina.

Mida arvestada read funktsiooni kasutamisel

Puhvri suurus ja turvalisus

• Kui proovida lugeda rohkem kui puhver mahutab, võib tekkida mälukahjustus. count väärtus peab olema puhvri suurusest väiksem või sellega võrdne.

EOF (faili lõpp) käsitlemine

• Kui read tagastab 0, tähendab see EOF-i. Sellisel juhul pole rohkem andmeid lugeda.

Osaline lugemine

• read ei pruugi alati korraga lugeda määratud baitide arvu. Eriti soklite või torude puhul võib osutuda vajalikuks korduv lugemine tsüklis, kuni kõik andmed on saadud.

3. read funktsiooni kasutusnäited

Faili põhjalik lugemine

Koodinäide: Tekstifaili lugemine

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    char buffer[128];
    ssize_t bytesRead;

    while ((bytesRead = read(fd, buffer, sizeof(buffer) - 1)) > 0) {
        buffer[bytesRead] = '\0';
        printf("%s", buffer);
    }

    if (bytesRead == -1) {
        perror("Faili lugemine ebaõnnestus");
    }

    close(fd);
    return 0;
}

Koodi selgitus

1. Faili avamine

• open funktsioon avab faili ainult lugemiseks. Kui avamine ebaõnnestub, kuvatakse viga.

1. Lugemine tsüklis read abil

• Failist loetakse andmeid kuni EOF-ini. Iga kord salvestatakse puhvri lõppu '\0'.

1. Veakäitlus

• Kui read tagastab -1, on tekkinud viga ja see väljastatakse perror abil.

1. Faili sulgemine

• Pärast lugemist sulgetakse fail close funktsiooniga.

Andmete lugemine standard-sisendist

Koodinäide: Kasutaja sisendi lugemine

#include <unistd.h>
#include <stdio.h>

int main() {
    char buffer[64];
    printf("Sisesta tekst: ");

    ssize_t bytesRead = read(0, buffer, sizeof(buffer) - 1); // 0 = stdin

    if (bytesRead == -1) {
        perror("Sisendi lugemine ebaõnnestus");
        return 1;
    }

    buffer[bytesRead] = '\0';
    printf("Sisestasid: %s\n", buffer);

    return 0;
}

Koodi selgitus

1. Standard-sisendi määramine

• read esimene argument on 0, mis tähistab stdin-i.

1. Puhvri lõpetamine

• Pärast lugemist lisatakse '\0', et käsitleda sisendit stringina.

1. Veakäitlus

• Kui lugemine ebaõnnestub, kuvatakse viga perror abil.

Andmete vastuvõtt sokli kaudu

Koodinäide: Andmete lugemine soklist

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server_fd == -1) {
        perror("Sokli loomine ebaõnnestus");
        return 1;
    }

    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(8080);

    if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) == -1) {
        perror("Bind ebaõnnestus");
        close(server_fd);
        return 1;
    }

    if (listen(server_fd, 3) == -1) {
        perror("Listen ebaõnnestus");
        close(server_fd);
        return 1;
    }

    int client_fd = accept(server_fd, NULL, NULL);
    if (client_fd == -1) {
        perror("Accept ebaõnnestus");
        close(server_fd);
        return 1;
    }

    char buffer[1024];
    ssize_t bytesRead = read(client_fd, buffer, sizeof(buffer) - 1);
    if (bytesRead > 0) {
        buffer[bytesRead] = '\0';
        printf("Sõnum saadud: %s\n", buffer);
    } else if (bytesRead == -1) {
        perror("Lugemine ebaõnnestus");
    }

    close(client_fd);
    close(server_fd);
    return 0;
}

Koodi selgitus

1. Sokli loomine

• socket funktsioon loob TCP sokli.

1. Aadressi sidumine

• Sokkel seotakse IP-aadressi ja pordiga.

1. Ühenduse ootamine

• listen ootab klientide ühendusi.

1. Kliendi ühenduse vastuvõtt

• accept võtab ühenduse vastu ja loob uue failikirjeldaja kliendi jaoks.

1. Andmete lugemine

• Kliendi saadetud andmed loetakse read abil ja väljastatakse.

Näidete kokkuvõte

4. read funktsiooni rakendused

Asünkroonse I/O kasutamine

Asünkroonse režiimi seadistamine

Koodinäide: Asünkroonne I/O

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    // Mitteblokeeriva režiimi seadistamine
    int flags = fcntl(fd, F_GETFL, 0);
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("Mitteblokeeriva režiimi seadmine ebaõnnestus");
        close(fd);
        return 1;
    }

    char buffer[128];
    ssize_t bytesRead;

    while ((bytesRead = read(fd, buffer, sizeof(buffer) - 1)) != 0) {
        if (bytesRead > 0) {
            buffer[bytesRead] = '\0';
            printf("Loetud andmed: %s\n", buffer);
        } else if (bytesRead == -1 && errno == EAGAIN) {
            printf("Hetkel andmeid pole, proovi hiljem uuesti\n");
        } else if (bytesRead == -1) {
            perror("Lugemisviga");
            break;
        }
    }

    close(fd);
    return 0;
}

Koodi selgitus

1. Mitteblokeeriva režiimi määramine

• fcntl abil lisatakse O_NONBLOCK lipp failikirjeldajale.

1. Veakäitlus

• Kui andmeid pole veel saadaval, seatakse errno väärtuseks EAGAIN või EWOULDBLOCK.

1. Korduv lugemine

• Asünkroonses režiimis tuleb vajadusel read funktsiooni kutsuda korduvalt.

Suurte andmete efektiivne lugemine

Tehnika 1: Puhvri suuruse optimeerimine

• Suurem puhver vähendab süsteemikõnede arvu ja parandab jõudlust.
• Üldiselt soovitatakse kasutada süsteemi lehe suurust (getpagesize() abil).

Koodinäide: Suur puhver

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    int fd = open("largefile.bin", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    size_t bufferSize = 4096; // 4KB
    char *buffer = malloc(bufferSize);
    if (!buffer) {
        perror("Puhvri eraldamine ebaõnnestus");
        close(fd);
        return 1;
    }

    ssize_t bytesRead;
    while ((bytesRead = read(fd, buffer, bufferSize)) > 0) {
        printf("Loetud %zd baiti\n", bytesRead);
        // Lisa vajadusel töötlemisloogika
    }

    if (bytesRead == -1) {
        perror("Lugemisviga");
    }

    free(buffer);
    close(fd);
    return 0;
}

Binaarsete andmete lugemine

Koodinäide: Binaarfaili lugemine

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdint.h>

typedef struct {
    uint32_t id;
    float value;
} DataRecord;

int main() {
    int fd = open("data.bin", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    DataRecord record;
    ssize_t bytesRead;

    while ((bytesRead = read(fd, &record, sizeof(record))) > 0) {
        printf("ID: %u, Väärtus: %.2f\n", record.id, record.value);
    }

    if (bytesRead == -1) {
        perror("Lugemisviga");
    }

    close(fd);
    return 0;
}

Koodi selgitus

1. Struktuuri lugemine

• Kasutatakse read funktsiooni, et lugeda korraga terve struktuur.

1. Andmete töötlemine

• Struktuuri liikmeid saab otse kasutada andmete väljastamiseks või töötlemiseks.

1. Endianness

• Kui fail on loodud teises platvormis, võib osutuda vajalikuks baitide järjekorra teisendamine.

Rakendusnäidete kokkuvõte

5. read funktsiooni kasutamisel tähelepanekud

Puhvri ületäitumise vältimine

Kuidas ennetada

1. Õige puhvri suurus

• Puhver peaks olema piisavalt suur eeldatava andmemahu jaoks.
• count argumendina tuleks alati anda väärtus, mis on väiksem või võrdne puhvri suurusega.

1. Puhvri lõpetamine

• Kui töötled andmeid stringina, lisa alati lõppu '\0'.

Koodinäide: Turvaline puhvri kasutus

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    char buffer[128];
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    ssize_t bytesRead = read(fd, buffer, sizeof(buffer) - 1);
    if (bytesRead == -1) {
        perror("Faili lugemine ebaõnnestus");
        close(fd);
        return 1;
    }

    buffer[bytesRead] = '\0'; // Lisa lõputähis
    printf("Loetud andmed: %s\n", buffer);

    close(fd);
    return 0;
}

EOF (faili lõpp) käsitlemine

Õige lähenemine EOF-i käsitlemisel

1. Tagastusväärtuse kontrollimine

• Kui väärtus on 0, pole enam andmeid lugeda.

1. Tsükli tingimus

• EOF-i töötlemiseks kasuta tsüklis tingimust bytesRead > 0.

Koodinäide: EOF käsitlemine

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>

int main() {
    char buffer[128];
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    ssize_t bytesRead;
    while ((bytesRead = read(fd, buffer, sizeof(buffer) - 1)) > 0) {
        buffer[bytesRead] = '\0';
        printf("Loetud: %s\n", buffer);
    }

    if (bytesRead == -1) {
        perror("Lugemisviga");
    }

    close(fd);
    return 0;
}

Osaline lugemine ja tõrkeotsing

Põhjused

1. Signaalide katkestus

• Kui süsteemikõne katkestatakse signaaliga, võib lugemine peatuda.

1. Mitteblokeeriv režiim

• Mitteblokeerivas režiimis tagastab read kohe, isegi kui andmeid veel pole.

1. Puhvri suuruse piirang

• Kui andmed ei mahu korraga puhvri sisse, tuleb neid lugeda mitu korda.

Lahendused

1. Korduv lugemine

• Tee tsükkel, mis loeb andmeid seni, kuni kogu info on käes.

1. Veakoodide kontrollimine

• Kasuta errno väärtusi nagu EINTR ja EAGAIN, et rakendada õige käitumine.

Koodinäide: Osalise lugemise käsitlemine

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

int main() {
    char buffer[128];
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    ssize_t bytesRead;
    size_t totalBytesRead = 0;

    while ((bytesRead = read(fd, buffer + totalBytesRead, sizeof(buffer) - totalBytesRead - 1)) > 0) {
        totalBytesRead += bytesRead;
    }

    if (bytesRead == -1 && errno != EINTR) {
        perror("Lugemisviga");
    } else {
        buffer[totalBytesRead] = '\0';
        printf("Kokku loetud: %s\n", buffer);
    }

    close(fd);
    return 0;
}

Tähelepanekute kokkuvõte

• Puhvri suurus: määra alati piisavalt suur puhver ja hoia turvalisus.
• EOF tuvastamine: kasuta õigesti tagastusväärtust, et vältida lõputuid tsükleid.
• Osaline lugemine: kasuta korduvat lugemist ja kontrolli veakoode.

6. Korduma kippuvad küsimused (FAQ)

Q1. Mis vahe on read ja fread funktsioonidel?

Vastus:

• read funktsioon:
• Süsteemikõne, mis suhtleb otse operatsioonisüsteemiga.
• Kasutab failikirjeldajat ja võimaldab madala taseme I/O-d.
• Paindlik, kuid nõuab veakäitlust ja puhvri haldamist.
• fread funktsioon:
• Kõrgema taseme funktsioon standardses C-teegis.
• Kasutab failipointerit ja töötab voogude tasandil.
• Puhvri haldus toimub automaatselt, lihtsam kasutada.

Millal kumbagi kasutada:

• read: sobib süsteemiprogrammeerimiseks ja soklite puhul, kui on vaja madalat taset kontrollida.
• fread: sobib tavaliste failide lugemiseks, kus mugavus on tähtsam kui paindlikkus.

Q2. Kui read tagastab 0, kas see tähendab viga?

Vastus:

Kuidas käituda:

• Kui read tagastab 0, tuleb lugemisprotsess lõpetada.
• Tsüklis kasutades kasuta tingimust bytesRead > 0.

Q3. Kuidas kasutada read funktsiooni mitteblokeerivas režiimis?

Vastus:

Koodinäide:

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

int main() {
    int fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Faili avamine ebaõnnestus");
        return 1;
    }

    // Mitteblokeeriva režiimi seadmine
    int flags = fcntl(fd, F_GETFL, 0);
    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
        perror("Režiimi muutmine ebaõnnestus");
        close(fd);
        return 1;
    }

    char buffer[128];
    ssize_t bytesRead = read(fd, buffer, sizeof(buffer));

    if (bytesRead == -1 && errno == EAGAIN) {
        printf("Andmed pole hetkel saadaval\n");
    } else if (bytesRead > 0) {
        buffer[bytesRead] = '\0';
        printf("Loetud andmed: %s\n", buffer);
    }

    close(fd);
    return 0;
}

Märkus:

• Kui andmeid pole, tagastab read -1 ja errno väärtuseks saab EAGAIN või EWOULDBLOCK.
• Mitteblokeeriv režiim eeldab sageli sündmustepõhist programmeerimist.

Q4. Mida teha, kui read tagastab -1?

Vastus:

Levinumad veakoodid:

• EINTR: lugemine katkestati signaaliga – proovige uuesti.
• EAGAIN või EWOULDBLOCK: mitteblokeerivas režiimis pole andmeid saadaval.
• Muud vead: nt vigane failikirjeldaja (EBADF).

Näide:

if (bytesRead == -1) {
    if (errno == EINTR) {
        // Korda lugemist
    } else {
        perror("Lugemine ebaõnnestus");
    }
}

Q5. Kuidas töödelda väga suuri faile read funktsiooniga?

Vastus:

1. Jaga lugemine plokkideks

• Määra puhver ja loe andmeid korduvate read väljakutsetega.

1. Mälu kasutuse optimeerimine

• Kasuta malloc funktsiooni, kui vajad dünaamilist puhvrit.

Koodinäide:

char buffer[4096];
while ((bytesRead = read(fd, buffer, sizeof(buffer))) > 0) {
    // Töötle andmeid
}

Q6. Miks read mõnikord tagastab ainult osa andmetest?

Vastus:

1. Osaline lugemine

• Eriti soklite ja torude puhul ei pruugi kogu andmehulk olla korraga saadaval.

1. Signaalide katkestus

• Lugemine võib katkeda signaali tõttu.

1. Mitteblokeeriv režiim

• Kui andmeid pole piisavalt, tagastatakse kohe.

Kuidas lahendada:

• Korda read väljakutset seni, kuni kogu vajalik andmehulk on loetud.
• Käsitle veakoode õigesti (nt EINTR, EAGAIN).

FAQ kokkuvõte

7. Kokkuvõte

read funktsiooni põhiülevaade

• Üldine kirjeldus: read on madala taseme I/O funktsioon, mis loeb andmeid failikirjeldaja abil.
• Süntaks:

ssize_t read(int fd, void *buf, size_t count);

• Põhiomadused:
• Paindlik ja sobib failide, seadmete ning soklite andmeside jaoks.
• On süsteemikõne, mis eeldab veakäitlust ja puhvri haldamist.

Peamised kasutusnäited

• Failist lugemine: Faili avamine ja sisu lugemine tsükli abil kuni EOF-ini.
• Standard-sisend: Kasutaja sisendi lugemine ja töötlemine.
• Soklite puhul: Serveri ja kliendi vahelise andmeside näited.

Rakenduslik kasutus

• Asünkroonne I/O: Failikirjeldaja seadistamine mitteblokeerivaks fcntl abil.
• Suurte andmete töötlemine: Optimeeritud puhvrisuuruse ja mälu kasutuse olulisus.
• Binaarsete andmete lugemine: Struktuuride lugemine ja endianness’i arvestamine.

Tähtsad tähelepanekud ja tõrkeotsing

• Puhvri ületäitumise vältimine: Seadista puhvri suurus õigesti.
• EOF töötlemine: read tagastab 0 faili lõpus.
• Osaline lugemine: Soklite ja mitteblokeeriva režiimi korral kasuta korduvat lugemist.

KKK-st lahendatud peamised küsimused

1. read vs fread

• read = madala taseme I/O, fread = kõrgema taseme I/O.

1. Mitteblokeeriv režiim

• Kasuta fcntl ja kontrolli errno väärtusi.

1. Veakäitluse parimad praktikad

• Käsitle errno koodid õigesti (EINTR, EAGAIN jne).

Mida sellest artiklist õppisid

1. Põhikasutus: Kuidas lugeda andmeid failidest ja sisendseadmetest turvaliselt.
2. Rakendused: Asünkroonne I/O, suurte ja binaarsete andmete töötlemine.
3. Veakäitlus: Kuidas käsitleda osalist lugemist ja EOF-i.

Järgmised sammud õppimiseks

1. write funktsioon: Madala taseme andmete kirjutamine failidesse ja seadmetesse.
2. open ja close funktsioonid: Failihalduse põhitõed.
3. Asünkroonne programmeerimine: Sündmustepõhine arhitektuur ja efektiivsem I/O töötlemine.

Lõppsõna