Fluxuri de fișiere - Deschidere și închidere

Pentru a lucra cu fișiere, în biblioteca standard este definit fișierul de antet fstream, care definește tipurile de bază pentru citirea și scrierea fișierelor. În mod special, acestea sunt:

• ifstream: pentru citirea din fișier
• ofstream: pentru scrierea în fișier
• fstream: combină citirea și scrierea

Pentru lucrul cu date de tip wchar_t, pentru aceste fluxuri sunt definite duplicatele:

• wifstream
• wofstream
• wfstream

Deschiderea fișierului

Pentru operațiile cu fișiere, mai întâi trebuie să deschidem fișierul cu ajutorul funcției open(). Această funcție are două versiuni:

• open(cale)
• open(cale, mod)

Pentru a deschide fișierul, în funcție trebuie transmisă calea către fișier sub forma unui șir de caractere. De asemenea, se poate specifica și modul de deschidere. Lista modurilor disponibile pentru deschiderea unui fișier:

• ios::in: fișierul se deschide pentru citire. Poate fi setat doar pentru obiectele ifstream sau fstream
• ios::out: fișierul se deschide pentru scriere. Datele vechi sunt șterse. Poate fi setat doar pentru obiectele ofstream sau fstream
• ios::app: fișierul se deschide pentru adăugarea de date. Datele vechi nu sunt șterse
• ios::ate: după deschiderea fișierului, se mută indicatorul la sfârșitul fișierului
• ios::trunc: fișierul este tăiat la deschidere. Poate fi setat doar dacă este activat și modul out
• ios::binary: fișierul se deschide în mod binar

Dacă nu este specificat un mod, atunci implicit pentru obiectele ofstream este utilizat ios::out, iar pentru obiectele ifstream - ios::in. Pentru obiectele fstream se combină modurile ios::out și ios::in.

std::ofstream out;          // flux pentru scriere
out.open("hello1.txt"); // deschidem fișierul pentru scriere

std::ofstream out2;
out2.open("hello2.txt", std::ios::app); // deschidem fișierul pentru adăugare

std::ofstream out3;
out3.open("hello3.txt", std::ios::out | std::ios::trunc); // setarea mai multor moduri

std::ifstream in;       // flux pentru citire
in.open("hello4.txt"); // deschidem fișierul pentru citire

std::fstream fs;        // flux pentru citire și scriere
fs.open("hello5.txt"); // deschidem fișierul pentru citire și scriere

Totuși, nu este necesar să folosim funcția open() pentru deschiderea fișierului. Ca alternativă, se poate utiliza constructorul obiectelor de flux și se poate transmite calea către fișier și modul de deschidere:

fstream(cale)
fstream(cale, mod)

Când este apelat constructorul în care este transmisă calea către fișier, fișierul va fi deschis automat:

std::ofstream out("hello.txt");
std::ifstream in("hello.txt");
std::fstream fs("hello.txt", std::ios::app);

În acest caz, se presupune că fișierul hello.txt se află în aceeași folder ca fișierul sursă al programului.

De fapt, utilizarea constructorilor pentru deschiderea unui flux este mai recomandată, deoarece definirea variabilei care reprezintă fluxul de fișier presupune deja că acest flux va fi deschis pentru citire sau scriere. Folosirea constructorului ajută la evitarea situației în care uităm să deschidem fluxul, dar începem să-l folosim.

În timpul execuției, putem verifica dacă fișierul este deschis folosind funcția is_open(). Dacă fișierul este deschis, aceasta va returna true:

std::ifstream in;       // flux pentru citire
in.open("hello.txt"); // deschidem fișierul pentru citire
// dacă fișierul este deschis
if (in.is_open())
{
}

Închiderea fișierului

După ce am terminat lucrul cu fișierul, trebuie să-l închidem cu ajutorul funcției close(). De asemenea, merită menționat faptul că atunci când obiectul fluxului iese din domeniul de valabilitate, acesta este distrus și funcția close() este apelată automat.

#include <iostream>
#include <fstream>

int main()
{
    std::ofstream out;          // flux pentru scriere
    out.open("hello.txt"); // deschidem fișierul pentru scriere
    out.close();            // închidem fișierul

    std::ifstream in;       // flux pentru citire
    in.open("hello.txt"); // deschidem fișierul pentru citire
    in.close();             // închidem fișierul

    std::fstream fs;        // flux pentru citire și scriere
    fs.open("hello.txt"); // deschidem fișierul pentru citire și scriere
    fs.close();             // închidem fișierul
}