HOWTO · C++
Come leggere un file riga per riga in C++
In questo articolo esploreremo quattro approcci comuni per leggere un file riga per riga in C++: l'uso di ifstream con getline(), la funzione getline() della libreria C, la funzione fgets() e istream_iterator.
In questa pagina
Leggere un file riga per riga in C++ è un’operazione fondamentale in molte attività di programmazione, come l’elaborazione dei dati, l’analisi del testo e l’analisi dei file. Che si lavori con piccoli file di testo o con grandi insiemi di dati, sapere come svolgere questa operazione è importante.
In questo articolo esploreremo quattro approcci comuni per leggere un file riga per riga in C++: l’uso di ifstream con getline(), la funzione getline() della libreria C, la funzione fgets() e istream_iterator.
Perché leggere un file riga per riga
Leggere un file riga per riga è spesso preferibile rispetto a leggerlo tutto in una volta, soprattutto quando si ha a che fare con file di grandi dimensioni. Elaborando una riga alla volta, è possibile gestire in modo efficiente l’utilizzo della memoria e gestire file praticamente di qualsiasi dimensione.
Questo approccio è particolarmente utile per le attività in cui è necessario elaborare ogni riga in modo indipendente, come l’analisi dei file CSV, l’elaborazione dei log o l’analisi del testo.
Di seguito è riportato un file di esempio input.txt che contiene un testo di esempio:
This is a sample input file.
It contains multiple lines of text.
Each line demonstrates a different scenario.
For example, this line contains numbers: 12345.
And this line has special characters: !@#$%^&*().
Utilizziamo questo file come input per testare gli esempi di lettura dei file nelle sezioni successive.
Come leggere un file riga per riga in C++ usando ifstream con la funzione getline()
Quando si tratta di leggere un file riga per riga in C++, uno dei metodi più semplici e più comunemente utilizzati consiste nell’utilizzare la classe ifstream insieme alla funzione getline(). Questo approccio offre semplicità ed efficienza nella gestione dell’input da file, il che lo rende una scelta preferita da molti sviluppatori.
La funzione getline() fa parte della libreria standard C++ e viene utilizzata principalmente per leggere righe da flussi di input, come file o input standard (cin).
La sua sintassi è la seguente:
istream& getline(istream& is, string& str, char delim);
Dove:
is: flusso di input da cui leggere i caratteri.str: variabile stringa in cui vengono memorizzati i caratteri estratti.delim: carattere delimitatore che segna la fine di ogni riga (il valore predefinito è'\n').
La funzione getline() legge i caratteri dal flusso di input fino a quando non incontra il delimitatore specificato o raggiunge la fine del flusso. Quindi memorizza questi caratteri nella variabile stringa fornita, escludendo il delimitatore stesso.
È importante notare che getline() restituisce il flusso di input (is), consentendo di concatenare più operazioni di input.
Ora vediamo un esempio che mostra come leggere un file riga per riga usando ifstream con getline() in C++:
#include <fstream>
#include <iostream>
#include <string>
int main() {
std::ifstream file("input.txt");
if (!file.is_open()) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
std::string line;
while (std::getline(file, line)) {
std::cout << line << std::endl;
}
file.close();
return 0;
}
In questo esempio, iniziamo includendo i file di intestazione necessari: <iostream>, <fstream> e <string>. Questi forniscono rispettivamente funzionalità per input/output, flussi di file e manipolazione delle stringhe.
Definiamo quindi la funzione main. All’interno della funzione main, viene creata un’istanza di std::ifstream denominata file, che rappresenta il flusso del file di input.
Tentiamo quindi di aprire il file denominato "input.txt" utilizzando il costruttore del file. Se il file non viene aperto, viene stampato un messaggio di errore nel flusso di errore standard (cerr) e il programma termina con uno stato diverso da zero.
Successivamente, dichiariamo una variabile stringa line per memorizzare ogni riga letta dal file. All’interno del ciclo while, chiamiamo ripetutamente std::getline() con il flusso del file (file) e la variabile stringa (line) come argomenti.
Questa funzione legge una riga dal flusso del file fino a raggiungere la fine della riga o la fine del file. Ogni riga letta viene quindi stampata nel flusso di output standard (cout).
Infine, dopo aver letto tutte le righe dal file, chiudiamo il flusso del file utilizzando il metodo close() per liberare le risorse di sistema.
Uscita:
Questo mostra come leggere in modo efficace un file riga per riga in C++ usando ifstream con getline(), fornendo un metodo chiaro e conciso per gestire le operazioni di input da file.
Come leggere un file riga per riga in C++ usando la funzione getline() della libreria C
Oltre alla libreria standard C++, gli sviluppatori C++ possono utilizzare anche la funzione getline() fornita dalla libreria C per leggere un file riga per riga. Sebbene questa funzione funzioni in modo leggermente diverso, offre un’alternativa valida per gestire le operazioni di input da file.
La funzione getline() della libreria C viene utilizzata principalmente per leggere righe dai flussi di input, analogamente alla sua controparte nella libreria standard C++. La sua sintassi è la seguente:
ssize_t getline(char** lineptr, size_t* n, FILE* stream);
Qui,
lineptr: puntatore al buffer in cui verrà memorizzata la riga.n: puntatore alla variabile che contiene la dimensione del buffer (che verrà ridimensionata se necessario).stream: flusso del file da cui leggere la riga.
A differenza della funzione getline() della libreria standard C++, la versione della libreria C restituisce un valore ssize_t che indica il numero di caratteri letti, oppure -1 se si verifica un errore o viene raggiunta la fine del file.
Vediamo un esempio che mostra come leggere un file riga per riga usando getline() della libreria C in C++:
#include <cstdio>
#include <cstdlib>
#include <iostream>
int main() {
FILE* file = fopen("input.txt", "r");
if (!file) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
char* line = nullptr;
size_t len = 0;
ssize_t read;
while ((read = getline(&line, &len, file)) != -1) {
std::cout << line;
}
free(line);
fclose(file);
return 0;
}
Iniziamo con l’inclusione dei file di intestazione necessari: <iostream> per le operazioni di input/output, <cstdio> per l’input/output in stile C e <cstdlib> per le funzioni di allocazione della memoria.
Nella funzione main, dichiariamo un puntatore FILE* denominato file e tentiamo di aprire il file "input.txt" in modalità di lettura utilizzando la funzione fopen(). Se il file non viene aperto, viene stampato un messaggio di errore e il programma termina con uno stato diverso da zero.
Dichiariamo quindi un puntatore a carattere line e una variabile size_t len per memorizzare rispettivamente ogni riga letta dal file e la sua lunghezza. All’interno del ciclo while, chiamiamo ripetutamente getline() con il flusso del file (file), l’indirizzo del puntatore line e l’indirizzo della variabile len.
Questa funzione legge una riga dal flusso del file, alloca dinamicamente la memoria secondo necessità e memorizza la riga nel buffer puntato da line. Ogni riga letta viene quindi stampata nel flusso di output standard (cout).
Dopo aver letto tutte le righe dal file, liberiamo la memoria allocata dinamicamente per il buffer line utilizzando la funzione free() e chiudiamo il flusso del file utilizzando la funzione fclose() per liberare le risorse di sistema.
Uscita:
Questo mostra un metodo alternativo per leggere un file riga per riga in C++, sfruttando la funzione getline() della libreria C.
Come leggere un file riga per riga in C++ usando la funzione fgets()
Un altro metodo per leggere un file riga per riga in C++ consiste nell’utilizzare la funzione fgets(), che fa parte della libreria standard C. Sebbene fgets() possa sembrare meno intuitiva rispetto agli approcci basati sui flussi C++, offre semplicità e compatibilità con basi di codice legacy o scenari in cui si preferisce l’input/output in stile C.
La sintassi di fgets() è la seguente:
char *fgets(char *str, int size, FILE *stream);
Qui,
str: puntatore all’array di caratteri (buffer) in cui verrà memorizzata la riga.size: numero massimo di caratteri da leggere (incluso il terminatore null).stream: flusso del file da cui leggere la riga.
La funzione restituisce str in caso di successo, oppure NULL se si verifica un errore o viene raggiunta la fine del file.
Procediamo con un esempio che illustra come leggere un file riga per riga usando fgets() in C++:
#include <cstdio>
#include <iostream>
int main() {
FILE* file = fopen("input.txt", "r");
if (!file) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
char line[256];
while (fgets(line, sizeof(line), file) != NULL) {
std::cout << line;
}
fclose(file);
return 0;
}
In questo esempio, iniziamo includendo i file di intestazione necessari: <iostream> per le operazioni di input/output e <cstdio> per l’input/output in stile C.
All’interno della funzione main, dichiariamo un puntatore FILE* denominato file e tentiamo di aprire il file "input.txt" in modalità di lettura utilizzando la funzione fopen(). Se il file non viene aperto, viene stampato un messaggio di errore e il programma termina con uno stato diverso da zero.
Definiamo quindi un array di caratteri line con una dimensione di 256 caratteri per memorizzare ogni riga letta dal file. All’interno del ciclo while, chiamiamo ripetutamente fgets() con il flusso del file (file), l’indirizzo dell’array line e la dimensione dell’array.
Questa funzione legge una riga dal flusso del file e la memorizza nel buffer line. Ogni riga letta viene quindi stampata nel flusso di output standard (cout).
Dopo aver letto tutte le righe dal file, chiudiamo il flusso del file utilizzando la funzione fclose() per liberare le risorse di sistema.
Uscita:
Questo mostra un approccio alternativo per leggere un file riga per riga in C++. Pur differendo leggermente nella sintassi e nell’uso, fgets() offre un’opzione valida per gestire le operazioni di input da file, garantendo compatibilità e familiarità con i paradigmi di programmazione in stile C.
Come leggere un file riga per riga in C++ usando istream_iterator
istream_iterator fornisce un modo elegante e moderno per leggere i dati dai flussi di input, inclusi i file, trattando il flusso come una sequenza di elementi. Sebbene venga tipicamente utilizzato per leggere dati formattati come numeri interi o stringhe, può essere impiegato anche per leggere le righe di un file trattando ogni riga come un elemento stringa.
Questo approccio offre concisione e leggibilità del codice, il che lo rende una scelta comoda per molti sviluppatori.
La sintassi di istream_iterator è la seguente:
istream_iterator<T> it(istream& is);
Qui,
T: tipo di dati da leggere.is: flusso di input da cui leggere i dati.
Il costruttore di istream_iterator inizializza un iteratore (it) per scorrere gli elementi estratti dal flusso di input (is). Viene tipicamente utilizzato in combinazione con gli operatori di dereferenziazione e di incremento di istream_iterator (*it e ++it, rispettivamente) per accedere agli elementi del flusso e avanzare tra di essi.
Consideriamo il seguente esempio di codice che mostra come leggere un file riga per riga usando istream_iterator in C++:
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
int main() {
std::ifstream file("input.txt");
if (!file.is_open()) {
std::cerr << "Error: Unable to open the file." << std::endl;
return 1;
}
std::istream_iterator<std::string> it(file);
std::istream_iterator<std::string> end;
if (it == end) {
std::cerr << "Error: Empty file." << std::endl;
return 1;
}
std::cout << *it++;
while (it != end) {
std::cout << " " << *it++;
}
std::cout << std::endl;
file.close();
return 0;
}
Iniziamo con l’inclusione dei file di intestazione necessari: <iostream> per le operazioni di input/output, <fstream> per i flussi di file, <iterator> per le operazioni sugli iteratori e <string> per la manipolazione delle stringhe.
Nella funzione main, dichiariamo un oggetto ifstream denominato file e tentiamo di aprire il file "input.txt". Se il file non viene aperto, viene stampato un messaggio di errore e il programma termina con uno stato diverso da zero.
Creiamo quindi un istream_iterator denominato it, inizializzato con il flusso del file file, per leggere le stringhe dal file. Inoltre, creiamo un iteratore di fine flusso denominato end per indicare la fine del file.
All’interno del ciclo while, scorriamo il contenuto del file utilizzando l’iteratore it fino a raggiungere l’iteratore di fine flusso end. A ogni iterazione, dereferenziamo l’iteratore (*it) per ottenere la riga corrente, la stampiamo nella console e quindi facciamo avanzare l’iteratore (++it).
Dopo aver elaborato tutte le righe dal file, chiudiamo il flusso del file utilizzando il metodo close() per liberare le risorse di sistema.
Uscita:
Questo mostra un metodo alternativo per leggere un file riga per riga in C++, sfruttando istream_iterator per trattare il contenuto del file come una sequenza di stringhe. Questo approccio fornisce una soluzione moderna e concisa per gestire le operazioni di input da file, migliorando la leggibilità e la manutenibilità del codice.
Conclusione
Abbiamo esplorato diversi metodi per leggere un file riga per riga in C++, ognuno dei quali offre i propri vantaggi e la propria idoneità a seconda dei requisiti specifici e delle preferenze del programmatore. Che si utilizzi la funzione getline() della libreria standard C++, getline() della libreria C, fgets() o istream_iterator, gli sviluppatori hanno una gamma di opzioni tra cui scegliere.
La funzione getline() in entrambe le librerie C++ e C fornisce un approccio semplice, mentre fgets() offre compatibilità con la programmazione in stile C. D’altra parte, istream_iterator presenta una soluzione moderna e concisa per scorrere il contenuto del file come una sequenza di stringhe.
Indipendentemente dal metodo scelto, l’obiettivo chiave rimane lo stesso: leggere in modo efficiente e accurato il contenuto di un file riga per riga. Comprendendo la sintassi e il funzionamento di ciascun metodo, possiamo selezionare l’approccio più adatto ai nostri progetti, garantendo una gestione efficiente dei file e una leggibilità ottimale del codice.