Fișiere text

Fișiere text în C++

Fluxurile pentru fișiere

Biblioteca <fstream> pune la dispoziție clasele folosite pentru fișiere:

Un flux este legătura dintre program și fișier. Operatorul >> transferă date dintr-un flux de intrare în variabile, iar operatorul << transferă date din variabile în fluxul de ieșire.

#include <fstream>
using namespace std;

ifstream fin("date.in");
ofstream fout("date.out");

În locul numelor fin și fout se pot folosi alte identificatoare. Important este ca fluxul de intrare să fie declarat cu ifstream, iar cel de ieșire cu ofstream.

Deschiderea și verificarea

Fișierul se poate deschide chiar la declarare:

ifstream fin("date.in");
ofstream fout("date.out");

Se poate deschide și ulterior, cu funcția open:

ifstream fin;
fin.open("date.in");

După deschidere trebuie verificat dacă operația a reușit. Expresia fluxului poate fi folosită într-o condiție:

ifstream fin("date.in");

if (!fin) {
    return 1;
}

Un fișier de intrare poate lipsi, poate avea un nume greșit sau poate să nu poată fi citit. Dacă programul continuă să citească dintr-un flux care nu s-a deschis, rezultatul nu este unul sigur.

Citirea cu operatorul >>

Operatorul >> citește următoarea valoare și ignoră spațiile, tabulatoarele și trecerile la rând nou de la început:

int x;
fin >> x;

El se folosește pentru numere și pentru cuvinte:

int n;
fin >> n;

for (int i = 0; i < n; i++) {
    int x;
    fin >> x;
}

Pentru un șir de caractere în stil C++, >> citește numai până la primul spațiu. Dacă fișierul conține linia Ana are mere, în variabila s ajunge numai Ana. Pentru o linie întreagă se folosește getline.

Citirea până la sfârșitul fișierului

Forma sigură este să pui operația de citire chiar în condiția buclei:

int x;
while (fin >> x) {
    // x este valid și poate fi prelucrat
}

Citirea evaluează fluxul ca adevărat cât timp a reușit să extragă o valoare. Când ajunge la sfârșitul fișierului sau întâlnește o valoare incompatibilă cu tipul variabilei, condiția devine falsă și bucla se oprește.

Nu se scrie:

while (!fin.eof()) {
    fin >> x;
    // x poate conține încă valoarea citită la pasul anterior
}

eof() devine adevărat abia după ce o citire a încercat să treacă de sfârșitul fișierului. De aceea această formă poate prelucra o valoare veche încă o dată.

Citirea unei linii întregi

Pentru a păstra și spațiile dintr-o linie se folosește getline:

#include <string>

string linie;
getline(fin, linie);

Citirea se oprește la trecerea la rând nou, iar aceasta nu intră în șir. Dacă înainte s-a folosit >>, trecerea la rând nou rămasă în flux trebuie eliminată:

int n;
fin >> n;
fin.ignore();

string linie;
getline(fin, linie);

Într-o problemă în care se citesc numai numere sau cuvinte separate prin spații, >> este mai simplu și nu este nevoie de getline.

Scrierea în fișier

Operatorul << scrie în fișier exact ca în cazul lui cout:

int suma = 37;
fout << suma;

Se pot scrie mai multe valori și se pot adăuga spații sau treceri la rând:

fout << suma << '\n';
fout << x << ' ' << y;

Afișarea pe ecran și scrierea într-un fișier au aceeași formă, dar fluxul este diferit:

cout << rezultat;  // ecran
fout << rezultat;  // fișier

Modurile de deschidere

ifstream deschide, în mod obișnuit, fișierul pentru citire, iar ofstream pentru scriere. Funcția open poate primi și un mod explicit:

ofstream fout("rezultat.txt", ios::out);

La deschiderea unui ofstream pentru scriere, conținutul vechi este, în mod normal, înlocuit. Pentru adăugare la sfârșit:

ofstream fout("jurnal.txt", ios::app);

Închiderea fișierului

Fișierul se închide cu close:

fin.close();
fout.close();

Închiderea eliberează resursele și se asigură că datele scrise în buffer ajung în fișier. Dacă un program folosește mai multe fișiere, fiecare trebuie închis după ultima operație asupra lui.

Model complet de citire și prelucrare

#include <fstream>
#include <iostream>
using namespace std;

int main() {
    ifstream fin("date.in");
    ofstream fout("date.out");

    if (!fin || !fout)
        return 1;

    int x;
    int suma = 0;

    while (fin >> x) {
        suma += x;
    }

    fout << suma;

    fin.close();
    fout.close();
    return 0;
}

Programul citește toate numerele din date.in, le adună fără să memoreze șirul și scrie suma în date.out. Pentru n valori, timpul este O(n), iar memoria suplimentară este O(1).