LABORATORUL 12

Operații de intrare/ieșire. Fișiere.

Durată: 2 ore Bibliotecă: stdio.h Precedent: Laboratorul 11 PDF îndrumar EN English version

Datele din memorie dispar la terminarea programului. Fișierele sunt structuri de date organizate pe suporturi externe, care permit păstrarea informației între execuții și schimbul de date între aplicații.

1Obiectivele lucrării

inchisdeschisgood() == trueeof()fail()opensfarsit de fisiereroare de formatclose - abia acum datele ajung sigur pe disc
Fig. - Starile unui flux de fisier. Orice operatie ulterioara unei erori este ignorata pana la clear(), iar datele scrise sunt garantate pe disc abia dupa inchidere.
  • Clasificarea fișierelor după conținut, acces și tipul operațiilor permise
  • Deschiderea și închiderea corectă a unui fișier, cu verificarea reușitei
  • Alegerea modului potrivit de deschidere
  • Citirea și scrierea în fișiere text și binare
  • Poziționarea în fișier pentru acces direct

2Clasificarea fișierelor

CriteriuCategoriiDescriere
După conținutfișiere textcaractere organizate pe linii; sfârșitul liniei marcat prin <CR><LF>
fișiere cu tipînregistrări de un anumit tip, elementar sau structurat
fișiere fără tipfișiere binare, secvențe brute de octeți
După accesacces secvențialinformația se prelucrează doar în ordinea înregistrării
acces directcomponentele pot fi prelucrate în orice ordine, după poziționare
După operațiide intraredoar citire
de ieșiredoar scriere
de intrare/ieșireambele - posibilă actualizarea informației
Marcajul de sfârșitSfârșitul unui fișier este semnalat printr-un marcaj special numit EOF (end of file). Funcțiile de citire îl returnează pentru a indica faptul că nu mai există date.

3Deschidere și închidere

Orice transfer este precedat de operația de deschidere, care creează un stream și îl asociază fișierului. Se folosește o variabilă de tip FILE * și se alocă automat o zonă tampon prin care se fac transferurile.

tiparul corect
FILE *f = fopen("date.txt", "r");      // 1. deschidere

if (f == NULL) {                        // 2. VERIFICARE obligatorie
    printf("Nu pot deschide fisierul!\n");
    return 1;
}

/* ... citire sau scriere ... */        // 3. prelucrare

fclose(f);                              // 4. inchidere
De ce este obligatorie închidereaDatele scrise stau într-o zonă tampon și ajung pe disc abia când aceasta se umple sau la fclose. Dacă programul se termină fără închidere, ultimele date scrise se pot pierde. În plus, numărul de fișiere deschise simultan este limitat.
FuncțieRol
fopen(nume, mod)deschide fișierul; returnează NULL la eșec
fclose(f)golește tamponul și închide fișierul
feof(f)testează dacă s-a atins sfârșitul fișierului
ferror(f)testează dacă a apărut o eroare
fflush(f)forțează scrierea tamponului pe disc
remove(nume)șterge fișierul
rename(vechi, nou)redenumește fișierul

4Modurile de deschidere

ModSemnificațieDacă fișierul existăDacă nu există
"r"citirese deschide de la începuteroare (NULL)
"w"scrierese șterge tot conținutul!se creează
"a"adăugarese scrie la sfârșitse creează
"r+"citire și scrierese deschide de la începuteroare
"w+"citire și scrierese șterge tot conținutulse creează
"a+"citire și adăugarescrierea se face la sfârșitse creează

Se adaugă litera b pentru fișiere binare ("rb", "wb", "ab") și t pentru text, acesta fiind modul implicit.

Cel mai periculos mod este "w"Deschiderea unui fișier existent cu "w" îi șterge instantaneu tot conținutul, chiar dacă nu se scrie nimic după aceea. Pentru adăugare la un fișier existent folosiți "a".

5Operații cu fișiere text

NivelCitireScriere
Caracterfgetc(f), getc(f)fputc(c, f), putc(c, f)
Linie / șirfgets(s, n, f)fputs(s, f)
Cu formatfscanf(f, "...", ...)fprintf(f, "...", ...)
Corespondența cu funcțiile de consolăFiecare funcție de fișier are un echivalent pentru consolă: fprintf ↔ printf, fscanf ↔ scanf, fgets ↔ gets. Diferența este primul parametru, care indică streamul. printf(...) este echivalent cu fprintf(stdout, ...).
Atenție la feofFuncția feof devine adevărată doar după o citire eșuată, nu înainte. Bucla while (!feof(f)) { fscanf(...); ... } prelucrează ultima înregistrare de două ori. Corect: while (fscanf(f, "%d", &x) == 1) { ... }

6Operații cu fișiere binare

prototipuri
size_t fread (void *p, size_t dim, size_t nr, FILE *f);
size_t fwrite(const void *p, size_t dim, size_t nr, FILE *f);

// p   - adresa zonei din memorie
// dim - dimensiunea unei inregistrari, in octeti
// nr  - cate inregistrari se transfera
// f   - streamul
// returneaza numarul de inregistrari transferate efectiv
AspectFișier textFișier binar
Conținutcaractere lizibilecopie exactă a reprezentării din memorie
Numărul 123455 caractere (5 octeți)4 octeți (un int)
Editare manualăposibilă în orice editorpractic imposibilă
Vitezămai lentă (conversii)rapidă, fără conversii
Portabilitatebunălimitată (endianness, padding)

7Acces direct - poziționarea în fișier

FuncțieRol
fseek(f, offset, origine)mută indicatorul de poziție
ftell(f)returnează poziția curentă, în octeți
rewind(f)revine la începutul fișierului
Constantă pentru originePunct de referință
SEEK_SETînceputul fișierului
SEEK_CURpoziția curentă
SEEK_ENDsfârșitul fișierului
Citirea înregistrării cu numărul n fseek(f, n * sizeof(Inregistrare), SEEK_SET); urmat de fread(...). Acesta este avantajul major al fișierelor binare cu înregistrări de dimensiune fixă: orice element se accesează direct, fără a parcurge tot fișierul.

8Cod sursă

text_scriere.c - creare și adăugare
#include <stdio.h>

int main(void)
{
    FILE *f = fopen("date.txt", "w");     // ATENTIE: sterge continutul existent
    if (f == NULL) {
        printf("Nu pot crea fisierul!\n");
        return 1;
    }

    fprintf(f, "Popescu Ion;20;9.15\n");
    fprintf(f, "Ionescu Maria;21;8.70\n");
    fprintf(f, "Georgescu Radu;20;9.60\n");

    fclose(f);
    printf("Fisier creat.\n");

    // adaugare la sfarsit, fara stergerea continutului
    f = fopen("date.txt", "a");
    if (f) {
        fprintf(f, "Dumitrescu Ana;22;9.85\n");
        fclose(f);
        printf("Inregistrare adaugata.\n");
    }
    return 0;
}
text_citire.c - parcurgere corectă
#include <stdio.h>

int main(void)
{
    FILE *f = fopen("date.txt", "r");
    if (f == NULL) {
        printf("Fisierul nu exista!\n");
        return 1;
    }

    char linie[200];
    int nrLinii = 0;

    // varianta corecta: conditia este chiar reusita citirii
    while (fgets(linie, sizeof(linie), f) != NULL) {
        nrLinii++;
        printf("%3d: %s", nrLinii, linie);
    }

    printf("\nTotal %d linii\n", nrLinii);
    fclose(f);

    // citire cu format, camp cu camp
    f = fopen("date.txt", "r");
    char nume[50];
    int varsta;
    float medie;

    printf("\nCitire structurata:\n");
    while (fscanf(f, "%49[^;];%d;%f\n", nume, &varsta, &medie) == 3) {
        printf("  %-20s %3d ani  media %.2f\n", nume, varsta, medie);
    }
    fclose(f);

    return 0;
}
binar.c - scrierea și citirea structurilor
#include <stdio.h>

typedef struct {
    char  nume[50];
    int   varsta;
    float medie;
} Student;

int main(void)
{
    Student grupa[3] = {
        {"Popescu Ion",    20, 9.15f},
        {"Ionescu Maria",  21, 8.70f},
        {"Georgescu Radu", 20, 9.60f}
    };

    // scriere binara: tot tabloul, dintr-un singur apel
    FILE *f = fopen("studenti.dat", "wb");
    if (!f) return 1;
    fwrite(grupa, sizeof(Student), 3, f);
    fclose(f);

    // citirea inregistrarii cu numarul 1 (a doua), FARA a citi prima
    f = fopen("studenti.dat", "rb");
    if (!f) return 1;

    Student unul;
    fseek(f, 1 * sizeof(Student), SEEK_SET);   // pozitionare directa
    fread(&unul, sizeof(Student), 1, f);

    printf("Inregistrarea 1: %s, %d ani, media %.2f\n",
           unul.nume, unul.varsta, unul.medie);

    // dimensiunea fisierului
    fseek(f, 0, SEEK_END);
    long dim = ftell(f);
    printf("Dimensiune fisier: %ld octeti = %ld inregistrari\n",
           dim, dim / (long)sizeof(Student));

    fclose(f);
    return 0;
}
copiere.c - copierea unui fișier, octet cu octet
#include <stdio.h>

int main(void)
{
    FILE *sursa = fopen("date.txt", "rb");
    if (!sursa) { printf("Sursa lipseste\n"); return 1; }

    FILE *dest = fopen("copie.txt", "wb");
    if (!dest) { fclose(sursa); return 1; }

    char tampon[1024];
    size_t citite;
    long total = 0;

    // se copiaza in blocuri, mult mai rapid decat octet cu octet
    while ((citite = fread(tampon, 1, sizeof(tampon), sursa)) > 0) {
        fwrite(tampon, 1, citite, dest);
        total += citite;
    }

    printf("Copiati %ld octeti\n", total);

    fclose(sursa);
    fclose(dest);
    return 0;
}

9Atelier de cod

Casetele de mai jos au un sistem de fișiere propriu, care există doar în pagină. Fișierele scrise de un program pot fi citite imediat după aceea de același program.

Scriere și citire dintr-un fișier text
#include <stdio.h>

int main(void)
{
    FILE *f;
    int   nota;
    char  nume[20];

    /* --- scriere --- */
    f = fopen("note.txt", "w");
    if (f == NULL) { printf("Nu pot deschide fisierul\n"); return 1; }

    fprintf(f, "Popescu 9\n");
    fprintf(f, "Ionescu 7\n");
    fprintf(f, "Vasilescu 10\n");
    fclose(f);

    /* --- citire --- */
    f = fopen("note.txt", "r");
    if (f == NULL) { printf("Fisierul nu exista\n"); return 1; }

    printf("Continutul fisierului:\n");
    while (fscanf(f, "%s %d", nume, &nota) == 2)
        printf("  %-12s %2d\n", nume, nota);
    fclose(f);
    return 0;
}
De încercatSchimbați modul din "w" în "a" (adăugare) și rulați de două ori: veți vedea că liniile se adaugă la sfârșit în loc să înlocuiască fișierul.
Exercițiu - citire linie cu linie
#include <stdio.h>

int main(void)
{
    FILE *f = fopen("poezie.txt", "r");
    char linie[100];
    int  nr = 0;

    if (f == NULL) { printf("Fisierul nu exista\n"); return 1; }

    /* Cititi fisierul linie cu linie cu fgets si afisati fiecare
       linie precedata de numarul ei, in formatul din dreapta.
       La final afisati cate linii are fisierul.                  */

    fclose(f);
    return 0;
}
De încercatFișierul poezie.txt există deja în sistemul de fișiere al acestei casete.

10Exerciții cu verificare automată

Aici scrieți voi codul. Butonul ✓ Verifică rulează programul pe mai multe seturi de date și vă arată imediat unde diferă rezultatul. La final trimiteți traseul ales, iar profesorul îl notează automat.

Fiecare exercițiu are programul deja început, iar comentariile vă spun ce mai trebuie adăugat. Scrieți codul, apăsați ✓ Verifică și citiți ce spune fiecare test picat. Dacă v-ați blocat, deschideți câte un indiciu. Puteți afișa și mesaje pentru utilizator (de tipul Introduceti n:), testul se uită la ce afișați la final.

P1

Suma numerelor dintr-un fișier

Fișierul date.txt conține numere întregi despărțite prin spații și rânduri noi. Afișați câte numere sunt și suma lor.

fișier date.txt1 2 3 4 5
ieșire5 15
#include <stdio.h>

int main(void)
{
    FILE *f;
    int x, n = 0;
    long long s = 0;

    f = fopen("date.txt", "r");
    if (f == NULL) {
        printf("nu pot deschide fisierul\n");
        return 1;
    }

    /* fscanf întoarce câte valori a citit. Citiți în buclă cât timp
       fscanf(f, "%d", &x) == 1, numărând valorile și adunându-le. */

    fclose(f);
    printf("%d %lld\n", n, s);
    return 0;
}
P2

Numărarea rândurilor

Fișierul text.txt conține un text (fiecare rând are cel mult 200 de caractere). Afișați numărul de rânduri și cel mai lung rând (fără '\n'); la egalitate, primul.

fișier text.txtAna are mere Ion programarea calculatoarelor
ieșire3 programarea calculatoarelor
#include <stdio.h>
#include <string.h>

int main(void)
{
    FILE *f = fopen("text.txt", "r");
    char rand[256], lung[256] = "";
    int n = 0;
    if (f == NULL) return 1;

    /* fgets(rand, sizeof rand, f) citește un rând și întoarce NULL la final.
       Pentru fiecare rând: n++, ștergeți '\n' de la capăt cu
       rand[strcspn(rand, "\n")] = '\0'; și, dacă e mai lung decât lung,
       copiați-l cu strcpy(lung, rand). */

    fclose(f);
    printf("%d\n%s\n", n, lung);
    return 0;
}
P3

Scriere și recitire

Citiți n de la tastatură. Scrieți în fișierul patrate.txt pătratele numerelor de la 1 la n, câte unul pe rând. Închideți fișierul, redeschideți-l pentru citire și afișați suma valorilor citite din el.

intrare3
ieșire14
#include <stdio.h>

int main(void)
{
    int n, i, x;
    long long s = 0;
    FILE *f;
    scanf("%d", &n);

    /* 1. f = fopen("patrate.txt", "w"); și fprintf(f, "%d\n", i * i); în buclă;
       2. fclose(f);
       3. f = fopen("patrate.txt", "r"); citiți cu fscanf și adunați la s;
       4. fclose(f); */

    printf("%lld\n", s);
    return 0;
}
P4

Fișierul care lipsește

Deschideți note.txt, care conține note întregi. Dacă fișierul nu există, afișați eroare la deschidere. Altfel afișați cea mai mare notă (fișierul are cel puțin o notă).

fișier note.txt7 9 4
ieșire9
#include <stdio.h>

int main(void)
{
    FILE *f;
    int x, max;

    /* fopen întoarce NULL când fișierul nu poate fi deschis.
       Verificați întotdeauna rezultatul înainte să citiți din fișier!
       Pentru maxim: citiți prima valoare în max, apoi comparați restul. */

    return 0;
}
P5

Adăugare la sfârșitul fișierului

Fișierul jurnal.txt are deja câteva rânduri. Citiți de la tastatură un rând nou (un singur cuvânt), adăugați-l la sfârșitul fișierului fără să pierdeți ce era înainte, apoi recitiți fișierul și afișați numărul de rânduri și ultimul rând.

intrareintrare3
fișier jurnal.txtintrare1 intrare2
ieșire3 intrare3
#include <stdio.h>
#include <string.h>

int main(void)
{
    char nou[100], rand[200], ultim[200] = "";
    int n = 0;
    FILE *f;
    scanf("%99s", nou);

    /* 1. Deschideți cu modul "a" (append) și scrieți: fprintf(f, "%s\n", nou);
          Cu "w" s-ar pierde rândurile vechi!
       2. Închideți, redeschideți cu "r" și citiți rândurile cu fgets,
          numărându-le și păstrând ultimul în ultim (fără '\n'). */

    printf("%d %s\n", n, ultim);
    return 0;
}

Problemele pornesc de la un main gol. Formatul ieșirii trebuie respectat exact (spațiile și rândurile noi nu contează, dacă enunțul nu spune altfel), deci nu afișați mesaje pentru utilizator. Testele vizibile acoperă doar cazurile simple; la notare se rulează și teste ascunse, alese să prindă cazurile limită.

A1

Statistici de text

Afișați, pentru fișierul text.txt, numărul de rânduri, de cuvinte și de caractere, ca programul wc: rândurile sunt caracterele '\n', cuvintele sunt secvențe de caractere diferite de spațiu, TAB și '\n', iar caracterele se numără toate.

fișier text.txtAna are mere si pere
ieșire2 5 21
#include <stdio.h>

int main(void)
{
    /* scrieți aici rezolvarea */

    return 0;
}
A2

Catalog din fișier CSV

Fișierul studenti.txt are pe fiecare rând Nume;nota1;nota2;nota3 (numele poate conține spații, notele sunt întregi). Afișați, pentru fiecare student cu media cel puțin 5, Nume: medie (media cu două zecimale), în ordinea din fișier, apoi, pe ultimul rând, numărul de restanțieri.

fișier studenti.txtPopescu Ana;9;8;10 Ionescu Dan;4;5;4
ieșirePopescu Ana: 9.00 1
#include <stdio.h>

int main(void)
{
    /* scrieți aici rezolvarea */

    return 0;
}
A3

Fișier binar: a k-a înregistrare

Citiți n înregistrări cod pret (întreg, real) de la tastatură și scrieți-le cu fwrite în fișierul binar produse.bin. Apoi citiți un indice k (de la 0), redeschideți fișierul, poziționați-vă direct pe înregistrarea k cu fseek, citiți-o cu fread și afișați cod pret (prețul cu două zecimale). Dacă k nu există, afișați inexistent.

intrare3 10 2.5 20 3.75 30 9 1
ieșire20 3.75
#include <stdio.h>

int main(void)
{
    /* scrieți aici rezolvarea */

    return 0;
}
A4

Interclasarea a două fișiere

Fișierele a.txt și b.txt conțin numere întregi sortate crescător. Scrieți în c.txt toate numerele, interclasate (tot crescător, câte unul pe rând), apoi recitiți c.txt și afișați conținutul lui pe un rând.

fișier a.txt1 4 9
fișier b.txt2 3 10 11
ieșire1 2 3 4 9 10 11
#include <stdio.h>

int main(void)
{
    /* scrieți aici rezolvarea */

    return 0;
}

11Sarcini de lucru

  • Creați un fișier text cu date despre studenți și citiți-l apoi linie cu linie.
  • Deschideți un fișier existent cu modul "w" și observați ce se întâmplă cu conținutul.
  • Adăugați înregistrări noi folosind modul "a", fără a pierde datele vechi.
  • Numărați liniile, cuvintele și caracterele dintr-un fișier text.
  • Scrieți un tablou de structuri într-un fișier binar și citiți doar a treia înregistrare.
  • Comparați dimensiunea aceleiași informații salvate în format text și în format binar.
  • Implementați copierea unui fișier folosind un tampon de 1024 de octeți.
  • Testați diferența dintre while (!feof(f)) și while (fscanf(...) == n).

12Aplicație de aprofundare

ExtindereImplementați o agendă telefonică persistentă, cu fișier binar de înregistrări de dimensiune fixă: adăugare, căutare după nume, modificarea unei înregistrări existente (prin fseek și rescriere pe loc, fără a recrea fișierul) și ștergere logică printr-un câmp indicator. Adăugați o funcție de „compactare" care elimină fizic înregistrările marcate ca șterse.

13Întrebări de verificare

14Resurse