Gestire l'input /output dei files in C++

Il C++ ha delle librerie molto potenti, in questo post cercherò di elencare i metodi più semplici per leggere, scrivere e controllare lo stato di un file.

Il C++ usa le seguenti classi per gestire l'input/output dei caratteri dei files.

ofstream: classe Stream per scrivere in un file
ifstream: classe Stream per leggere da un files
fstream: classe Stream per leggere e scrivere su un file

Queste classi sono dirette o indirette derivate  della classe istream e ostream. Sappiamo ad esempio che cin è un oggetto della classe istream e cout è un oggetto della classe ostream. Potete leggere e scrivere sui files usando proprio cin e cout, ad esempio:

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

int main () {
  ofstream myfile;
  myfile.open ("example.txt");
  myfile << "Scrivi questo sul file.\n";
  myfile.close();
  return 0;
}

L'output del nostro file sarà:

[file example.txt]
Scrivi questo sul file.

Questo codice crea un file chiamato "example.txt" e inserisce al suo interno una frase nello stesso modo con cui avete sempre usato cout, con la differenza che usate il nome del file al posto della parola chiave.

Aprire un file

La prima operazione che dovete fare quando lavorate con l'input output dei files è l'apertura del file stesso. Per aprire un file usiamo la funzione open():

open (filename, mode);
// filename: nome del file che vogliamo aprire
// mode: parametri aggiuntivi con i sottostanti flags (ne elenco solo 3)

ios::in

Apre il file per le operazioni di input.

ios::out

Apre il file per le operazioni di input.

ios::app

Tutte le operazioni di output avvengono alla fine del file, appendendo il contenuto di esse al file. Questo flag può essere usato per i files aperti in sola scrittura.

N.B.: Tutti i flags possono essere combinati con l'operatore OR (|), ad esempio:

ofstream myfile;
myfile.open ("example.bin", ios::out | ios::app | ios::binary);

Chiudere un file

Quando avete terminato le operazioni di input e/o output nel vostro file è necessario "chiudere" il file stesso. Per fare questo chiamate la funzione close(); in questo modo:

myfile.close(); // chiude il vostro file

N.B.: La funzione close() viene chiamata comunque dal sistema alla chiusura del vostro programma. E' però buona norma chiudere sempre tutto quello che avete aperto!

File di testo

Scrivere in un file:

// Scrivere in un file
#include <iostream>
#include <fstream>
using namespace std;

int main () {
  ofstream myfile ("example.txt");
  if (myfile.is_open())
  {
    myfile << "This is a line.\n";
    myfile << "This is another line.\n";
    myfile.close();
  }
  else cout << "Unable to open file";
  return 0;
} 

Leggere da un file:

// Leggere da un file
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main () {
  string line;
  ifstream myfile ("example.txt");
  if (myfile.is_open())
  {
    while ( myfile.good() )
    {
      getline (myfile,line);
      cout << line << endl;
    }
    myfile.close();
  }

  else cout << "Unable to open file"; 

  return 0;
}

Questo esempio darà il seguente output:

This is a line.
This is another line.

Flags di controllo

In aggiunta a good() ci sono altre funzioni di controllo per i vostri files e tutte ritornano un valore booleano.

bad()

Ritorna true se la lettura o la scrittura falliscono.

fail()

Ritorna true se la lettura o la scrittura falliscono, ma anche in caso di formato errato.

eof()

Ritorna true se il file aperto in lettura è giunto al termine.

good()

Ritorna false se in una delle precedenti funzioni il valore di ritorno è falso.