File di testo in C++ con approccio OOP

Il modo più semplice per introdurre l’uso dei file di testo in C++ secondo il paradigma della programmazione ad oggetti (OOP), è far riferimento alle ben note operazioni di INPUT e di OUTPUT STANDARD realizzate in C++ tramite gli operatori di LETTURA (>>) e SCRITTURA (<<).

Quando si esegue un input da tastiera, l’operatore di LETTURA (>>) opera sullo stream di input (flusso di caratteri) della periferica tastiera, attraverso l’oggetto cin associato in maniera predefinita alla tastiera dal linguaggio C++ (vedi figura sotto).

Quando si esegue un output sul monitor, l’operatore di SCRITTURA (<<) opera sullo stream di output diretto verso la periferica monitor, attraverso l’oggetto cout associato di default al monitor dal linguaggio C++ (vedi figura sotto).

In un altro articolo (link articolo) abbiamo visto come, grazie al servizio reso dal File System, anche un file di testo può essere visto a livello applicativo come una sequenza di byte di caratteri (ASCII o UNICODE, a seconda dei vari casi), cioè uno stream. Pertanto, le operazioni di SCRITTURA e di LETTURA su un file di testo possono essere ricondotte rispettivamente ad operazioni di OUTPUT e di INPUT di uno stream che agisce sulla periferica di I/O sulla quale il file è memorizzato (memoria di massa) e queste operazioni possono essere gestite allo stesso modo visto per le periferiche standard di I/O, a patto di utilizzare degli oggetti opportuni da associare alla periferica memoria di massa e, più in particolare, al file su cui si vuole realizzare l’accesso di I/O.

Il linguaggio C++ mette a disposizione la classe fstream che premette di istanziare oggetti che possono essere associati ad un file per eseguire operazioni sia di Input sia di Output. La sintassi per il suo utilizzo è la seguente:

fstream miofile; //dichiarazione di un oggetto di classe fstream

//Associazione dell'oggetto allo stream di un file e apertura del file:
miofile.open("pathname\\nomeFile.txt", ios::out); //apertura del file in modalità di RISCRITTURA
//oppure
miofile.open("pathname\\nomeFile.txt", ios::app); //apertura del file in modalità di AGGIUNTA
//oppure
miofile.open("pathname\\nomeFile.txt", ios::in); //apertura del file in modalità LETTURA

fstream miofile; //dichiarazione di un oggetto di classe fstream

//Associazione dell'oggetto allo stream di un file e apertura del file:

miofile.open("pathname\\nomeFile.txt", ios::out); //apertura del file in modalità di RISCRITTURA

//oppure

miofile.open("pathname\\nomeFile.txt", ios::app); //apertura del file in modalità di AGGIUNTA

//oppure

miofile.open("pathname\\nomeFile.txt", ios::in); //apertura del file in modalità LETTURA

Per poter eseguire operazioni di I/O su un file, esso innanzitutto deve essere aperto. Con l’apertura il file viene collegato alla memoria RAM mediante il meccanismo del buffer già discusso in un altro articolo (link articolo). Un file di testo può essere aperto e, quindi utilizzato, in tre modalità di apertura diverse: in scrittura dall’inizio (RISCRITTURA) con perdita di tutto il suo contenuto già presente; in scrittura in aggiunta a ciò che è già presente (APPEND); in LETTURA dall’inizio. La sua gestione, quindi, può avvenire solo secondo l’organizzazione sequenziale di cui abbiamo già parlato in un altro articolo (link articolo).

Ecco due semplici esempi di di scrittura e lettura di un file di testo:

//SCRITTURA dall'inizio (RISCRITTURA del file)
#include <iostream>
#include <fstream> //Libreria NECESSARIA per le operazioni di I/O sui file
#include <string>
using namespace std;
int main(){
    fstream miofile;
    miofile.open("prova.txt", ios::out);
    miofile << "Benvenuto!" << endl; //SCRITTURA nel file associato all'oggetto
    miofile.close();
    return 0;
}

//SCRITTURA dall'inizio (RISCRITTURA del file)

#include <iostream>

#include <fstream> //Libreria NECESSARIA per le operazioni di I/O sui file

#include <string>

using namespace std;

int main(){

fstream miofile;

miofile.open("prova.txt", ios::out);

miofile << "Benvenuto!" << endl; //SCRITTURA nel file associato all'oggetto

miofile.close();

return 0;

}

//LETTURA
#include <iostream>
#include <fstream> //Libreria NECESSARIA per le operazioni di I/O sui file
#include <string>
using namespace std;
int main(){
    string s;
    fstream miofile;
    miofile.open("prova.txt", ios::in);
    miofile >> s; //LETTURA nel file associato all'oggetto
    miofile.close();
    cout << s;
    return 0;
}

//LETTURA

#include <iostream>

#include <fstream> //Libreria NECESSARIA per le operazioni di I/O sui file

#include <string>

using namespace std;

int main(){

string s;

fstream miofile;

miofile.open("prova.txt", ios::in);

miofile >> s; //LETTURA nel file associato all'oggetto

miofile.close();

cout << s;

return 0;

}

Della sintassi precedente esiste anche una versione compatta, che unisce in un’unica istruzione le due istruzioni di dichiarazione dell’oggetto e apertura del file:

fstream miofile("nomeFile.txt", modalitàApertura);

1	fstream miofile("nomeFile.txt", modalitàApertura);

NOTA. Negli esempi di sopra, per il primo parametro del file da associare agli oggetti è stato utilizzato solo il nome del file senza pathname. In questo caso l’applicazione si aspetta di trovare il file nella stessa directory in cui si trova l’eseguibile del programma. Due esempi di utilizzo di un pathname assoluto e un pathname relativo sono i seguenti:

fstream miofile("c:\\documenti\\prova.txt", ios:out); //PATHNAME ASSOLUTO
fstream miofile("\\archivio\\prova.txt", ios:in); //PATHNAME RELATIVO

1 2	fstream miofile("c:\\documenti\\prova.txt", ios:out); //PATHNAME ASSOLUTO fstream miofile("\\archivio\\prova.txt", ios:in); //PATHNAME RELATIVO

NOTA. Si faccia attenzione al fatto che all’interno di una stringa il carattere backslash deve essere scritto utilizzando la sequenza di escape ‘\\’, in quanto da solo viene interpretato come un carattere speciale che, appunto, introduce una sequenza di escape (si ricordino ad esempio i caratteri ‘\n’ e ‘\t’).

Si fa notare che un file di testo può essere aperto o solo in lettura o solo in scrittura ed è possibile passare alternativamente dall’una all’altra modalità chiudendolo e riaprendolo. La chiusura di un file si realizza utilizzando il metodo close() dell’oggetto associato a quel file:

miofile.close();

1	miofile.close();

Con la chiusura del file il buffer viene deallocato dalla memoria RAM e il suo contenuto viene memorizzato nel file.

ATTENZIONE. Quando un file viene aperto in SCRITTURA, se non esiste esso viene prima creato. Quando viene aperto in LETTURA, invece, se esso non esiste o per qualche ragione non è disponibile, il programma produce un errore.

Il linguaggio C++ mette a disposizione anche le classi ofstream e ifstream, delle quali la prima permette di istanziare un oggetto che è in grado di gestire solo le operazioni di scrittura, il secondo solo quelle di lettura. Con questi oggetti il parametro della modalità di apertura è opzionale. Per la gerarchia completa delle classi C++ per la gestione degli stream si rimanda al seguente articolo: link articolo. Riprendendo la sintassi nella versione compatta, nel caso di oggetti ofstream e ifstream essa diventa:

ofstream miofile("prova.txt"); //apertura in RISCRITTURA
//OPPURE
ifstream miofile("prova.txt"); //apertura in LETTURA
//OPPURE
ofstream miofile("prova.txt",ios::app); //apertura in AGGIUNTA

ofstream miofile("prova.txt"); //apertura in RISCRITTURA

//OPPURE

ifstream miofile("prova.txt"); //apertura in LETTURA

//OPPURE

ofstream miofile("prova.txt",ios::app); //apertura in AGGIUNTA

Lettura di righe intere

Come abbiamo già visto in un altro articolo (link articolo), se lo stream contiene caratteri quali spazi, tabulazioni o ritorno a capo (‘\n’), durante le operazioni di input si deve fare attenzione perché essi vengono interpretati dall’operatore di lettura C++ (>>) come dei caratteri di fine stringa. Pertanto se si vuole acquisire correttamente un input che potenzialmente può contenere caratteri di questo tipo, l’operatore di lettura non deve essere utilizzato. In questi casi si può utilizzare il metodo cin.getiline(), quando si opera con le stringhe in stile C (link articolo), o la funzione getline(), quando invece si opera con le stringhe in stile C++ (link articolo). Vediamo un semplice esempio.

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main(){
    char s[50];
    cout<<"Inserisci nome e cognome: ";
    cin.getline(s, 50); //LETTURA da tastiera di una riga intera (MAX 50 caratteri) fino al carattere '\n'
    fstream miofile;
    miofile.open("prova.txt", ios::out); //apertura in RISCRITTURA
    miofile << s;
    miofile.close();

    miofile.open("prova.txt", ios::in); //apertura in LETTURA
    miofile.getline(s, 50); //LETTURA DAL FILE di una riga intera (MAX 50 caratteri) fino al carattere '\n'
    cout << "Benvenuto, " << s << "!" << endl;
    miofile.close();
    return 0;
}

#include <iostream>

#include <fstream>

#include <string>

using namespace std;

int main(){

char s[50];

cout<<"Inserisci nome e cognome: ";

cin.getline(s, 50); //LETTURA da tastiera di una riga intera (MAX 50 caratteri) fino al carattere '\n'

fstream miofile;

miofile.open("prova.txt", ios::out); //apertura in RISCRITTURA

miofile << s;

miofile.close();

miofile.open("prova.txt", ios::in); //apertura in LETTURA

miofile.getline(s, 50); //LETTURA DAL FILE di una riga intera (MAX 50 caratteri) fino al carattere '\n'

cout << "Benvenuto, " << s << "!" << endl;

miofile.close();

return 0;

}

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main(){
    string s;
    cout<<"Inserisci nome e cognome: ";
    getline(cin, s); //LETTURA da tastiera di una riga intera fino al carattere '\n'
    fstream miofile;
    miofile.open("prova.txt", ios::out); //apertura in RISCRITTURA
    miofile << s;
    miofile.close();

    miofile.open("prova.txt", ios::in); //apertura in LETTURA
    getline(miofile, s); //LETTURA DAL FILE di una riga intera fino al carattere '\n'
    cout << "Benvenuto, " << s << "!" << endl;
    miofile.close();
    return 0;
}

#include <iostream>

#include <fstream>

#include <string>

using namespace std;

int main(){

string s;

cout<<"Inserisci nome e cognome: ";

getline(cin, s); //LETTURA da tastiera di una riga intera fino al carattere '\n'

fstream miofile;

miofile.open("prova.txt", ios::out); //apertura in RISCRITTURA

miofile << s;

miofile.close();

miofile.open("prova.txt", ios::in); //apertura in LETTURA

getline(miofile, s); //LETTURA DAL FILE di una riga intera fino al carattere '\n'

cout << "Benvenuto, " << s << "!" << endl;

miofile.close();

return 0;

}

Lettura fino alla fine del file

La fine di un file viene marcata con un opportuno carattere di fine file (EOF) e questo fatto può essere sfruttato quando si ha l’esigenza di leggere completamente un file di testo, dall’inizio fino alla fine. Per far ciò si ha a disposizione il metodo eof() degli oggetti di classe fstream e ifstream, che restituisce TRUE quando viene letto il carattere di fine file, FALSE altrimenti. Vediamo un semplice codice di esempio di lettura sequenziale di un file di testo dall’inizio fino alla fine del file:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main(){
    string s;
    fstream miofile("prova.txt", ios::app); //apertura in AGGIUNTA
    cout<<"Inserisci nome e cognome (0 per terminare): ";
    getline(cin, s); //LETTURA da tastiera di una riga intera, fino al carattere '\n
    while(s!="0"){
        miofile << s << '\n'; //SCRITTURA nel file
        cout<<"Inserisci nome e cognome (0 per terminare): ";
        getline(cin, s); //LETTURA da tastiera di una riga intera, fino al carattere '\n
    }
    miofile.close();

    miofile.open("prova.txt", ios::in); //apertura in LETTURA
    cout << "Un benvenuto a: " << endl;
    getline(miofile, s); //LETTURA DAL FILE di una riga intera, fino al carattere '\n'
    while(!miofile.eof()) {
        cout << s << endl;
        getline(miofile, s); //LETTURA dal file di una riga intera, fino al carattere '\n'
    }
    miofile.close();
    return 0;
}

#include <iostream>

#include <fstream>

#include <string>

using namespace std;

int main(){

string s;

fstream miofile("prova.txt", ios::app); //apertura in AGGIUNTA

cout<<"Inserisci nome e cognome (0 per terminare): ";

getline(cin, s); //LETTURA da tastiera di una riga intera, fino al carattere '\n

while(s!="0"){

miofile << s << '\n'; //SCRITTURA nel file

cout<<"Inserisci nome e cognome (0 per terminare): ";

getline(cin, s); //LETTURA da tastiera di una riga intera, fino al carattere '\n

}

miofile.close();

miofile.open("prova.txt", ios::in); //apertura in LETTURA

cout << "Un benvenuto a: " << endl;

getline(miofile, s); //LETTURA DAL FILE di una riga intera, fino al carattere '\n'

while(!miofile.eof()) {

cout << s << endl;

getline(miofile, s); //LETTURA dal file di una riga intera, fino al carattere '\n'

}

miofile.close();

return 0;

}

P.S. Affinché il ciclo while dell’esempio precedente funzioni correttamente in modo da leggere fino all’ultima riga compresa, il file di testo deve contenere come ultima riga una riga vuota (‘\n’).

Articoli che ti potrebbero interessare