Fișiere text în C/C++

În C++, ifstream citește dintr-un fișier, iar ofstream scrie într-un fișier. Operatorii >> și << se folosesc asemănător cu cin și cout. Verifică deschiderea și condiționează prelucrarea de reușita citirii.

În Python, with open("date.txt", encoding="utf-8") as f: deschide fișierul pentru citire și îl închide la ieșirea din bloc; în C++ folosim ifstream.

În C++, clasele ifstream și ofstream din biblioteca <fstream> lucrează cu fișiere text. Un obiect ifstream citește dintr-un fișier, iar unul ofstream scrie într-un fișier. Operatorii >> și << se folosesc asemănător cu cin și cout; citirea cu >> separă valorile după spații albe (spațiu, tabulator, sfârșit de linie). Citirea unei linii întregi se face cu getline(fin, s). Deschiderea cu ofstream fout("date.out") fără mod suplimentar șterge conținutul vechi al fișierului; ios::app adaugă la sfârșit. După deschidere, testul if (!fin) arată dacă operația a eșuat, de exemplu pentru că fișierul lipsește.

Exemplul 1 — suma numerelor dintr-un fișier.

#include <iostream>
#include <fstream>
using namespace std;
int main() {
    ifstream fin("date.in");
    ofstream fout("date.out");
    int x, suma = 0;
    while (fin >> x) suma += x;
    fout << suma;
}

Dacă date.in conține 3 5, bucla citește 3 și 5, apoi se oprește la eșecul următoarei citiri, iar date.out primește 8. Condiția fin >> x este adevărată doar dacă extragerea a reușit. Fragmentul presupune deschiderea reușită a fișierelor.

Varianta din C. În C, fișierele se manevrează prin pointeri FILE*: fopen deschide, fscanf citește, fprintf scrie, iar fclose închide. Funcția fscanf întoarce numărul valorilor citite cu succes, deci testul == 1 joacă rolul condiției fin >> x:

#include <stdio.h>
int main() {
    FILE *fin = fopen("date.in", "r");
    FILE *fout = fopen("date.out", "w");
    int x, suma = 0;
    while (fscanf(fin, "%d", &x) == 1) suma += x;
    fprintf(fout, "%d", suma);
    fclose(fin);
    fclose(fout);
    return 0;
}

Pentru fișierul cu 3 5, programul scrie 8. Obiectele ifstream și ofstream din C++ se închid singure la ieșirea din domeniul lor, dar close() poate fi apelat explicit atunci când același fișier se redeschide mai departe.

Exemplul 2 — prelucrare pe linii. Fișierul date.in conține pe prima linie 4 7 și pe a doua 2, fără spații la sfârșitul liniilor. Programul citește numerele cu fin >> x, iar după fiecare număr verifică cu fin.peek() dacă urmează sfârșitul liniei; atunci afișează suma liniei și o reia de la 0:

#include <fstream>
#include <iostream>
using namespace std;
int main() {
    ifstream fin("date.in");
    int x, s = 0;
    while (fin >> x) {
        s += x;
        if (fin.peek() == '\n' || fin.eof()) {
            cout << s << " ";
            s = 0;
        }
    }
}

Se afișează 11 2: după citirea lui 4 caracterul următor este spațiu, deci suma continuă; după 7 urmează sfârșitul liniei, deci se afișează $4+7=11$; după 2 se afișează 2. Funcția peek() privește caracterul următor fără să-l citească, iar eof() acoperă ultima linie, dacă fișierul nu se termină cu sfârșit de linie.

Exemplul 3 — verificarea deschiderii și modul de adăugare.

#include <fstream>
#include <iostream>
using namespace std;
int main() {
    ifstream lipsa("lipsa.in");
    if (!lipsa) cout << "Eroare\n";
    ofstream f1("rez.out");
    f1 << 7;
    f1.close();
    ofstream f2("rez.out", ios::app);
    f2 << 5;
    f2.close();
    ifstream f3("rez.out");
    int a;
    f3 >> a;
    cout << a;
}

Se afișează Eroare, apoi 75. Fișierul lipsa.in nu există, deci testul !lipsa este adevărat. Primul ofstream creează rez.out cu textul 7; al doilea, deschis cu ios::app, adaugă 5 după el. Fișierul conține textul 75, pe care f3 >> a îl citește ca numărul 75, nu ca suma 12. Dacă al doilea ofstream ar fi fost deschis fără ios::app, fișierul ar conține doar 5.

Exemplul 4 — numărul de valori în prima linie. Fișierul date.in conține pe prima linie numărul $n=5$ și pe a doua cele cinci valori 3 9 1 7 4. Programul citește întâi pe $n$ și primul element, pe care îl ia drept minim provizoriu, apoi compară cu restul:

#include <fstream>
using namespace std;
int main() {
    ifstream fin("date.in");
    ofstream fout("date.out");
    int n, x, mn;
    fin >> n >> mn;
    for (int i = 1; i < n; i++) {
        fin >> x;
        if (x < mn) mn = x;
    }
    fout << mn;
}

Urmărirea: după prima citire $n=5$ și mn $=3$. Pentru x egal cu 9, 1, 7, 4 în această ordine, doar 1 este mai mic decât mn, deci mn devine 1 și rămâne așa. În date.out se scrie 1. Ordinea citirilor trebuie să fie aceeași cu ordinea valorilor din fișier, altfel n ar primi o valoare care nu îi aparține.

Date neașteptate în fișier. Dacă date.in conține 3 a 5, citirea cu fin >> x reușește pentru 3, dar eșuează la a, deoarece litera nu poate fi interpretată ca întreg. Fluxul trece în starea de eroare, bucla din Exemplul 1 se oprește și suma este 3, nu 8; valoarea 5 nu mai este citită. Dacă fișierul este gol, prima citire eșuează, corpul buclei nu se execută niciodată și suma rămâne 0.

Evaluează condiția while(fin >> x) ca test al reușitei extragerii. Modelul while(!fin.eof()) poate prelucra greșit o valoare după o citire eșuată, deoarece indicatorul de sfârșit de fișier se activează abia după o încercare nereușită de citire; dacă fișierul se termină cu un sfârșit de linie, ultima valoare este urmată de o iterație în plus. Pentru fișierul cu 4 7 și 2, terminat cu sfârșit de linie, bucla while(!fin.eof()) { fin >> x; ++n; } face 4 iterații, nu 3. La scriere cu ofstream deschis obișnuit, conținutul anterior al fișierului este șters. Numărul valorilor se numără doar la citiri reușite.

Exemplu în formatul examenului. Fișierul date.in conține pe prima linie 4 7 și pe a doua 2. Ce se scrie în date.out după executarea programului?

ifstream fin("date.in");
ofstream fout("date.out");
int x, s = 0, n = 0;
while (fin >> x) { s += x; ++n; }
fout << s << ' ' << n;

• a) 13 3
• b) 13 2
• c) 11 3
• d) 13 4

Răspunsul corect este a). Bucla citește pe rând 4, 7 și 2, deci $s=4+7+2=13$ și $n=3$; a patra citire eșuează și oprește bucla fără să modifice s și n. Varianta b) numără liniile, nu valorile. Varianta c) ignoră valoarea 2 din suma. Varianta d) ar rezulta dintr-o buclă while(!fin.eof()), care face o iterație în plus.

Al doilea exemplu în formatul examenului. Fișierul date.in conține pe prima linie 6 2 8 și pe a doua 5 4. Câte valori pare numără programul?

ifstream fin("date.in");
int x, k = 0;
while (fin >> x)
    if (x % 2 == 0) k++;
cout << k;

• a) 3
• b) 4
• c) 5
• d) 2

Răspunsul corect este b). Se citesc pe rând valorile 6, 2, 8, 5, 4, indiferent de linia pe care se află. Numerele pare sunt 6, 2, 8 și 4, deci $k=4$. Varianta c) este numărul tuturor valorilor citite, iar varianta a) ignoră a doua linie a fișierului.

Greșeli frecvente

• Greșit: while(!fin.eof()) garantează că în corp avem o nouă valoare validă.
  Corect: testează direct extragerea.
• Greșit: ifstream scrie în fișier.
  Corect: este pentru citire.
• Greșit: fin >> x citește și spațiile ca valori separate.
  Corect: spațiile albe delimitează valorile.

Înainte și după