In questo articolo, ti mostreremo come leggere e scrivere su un file nel linguaggio di programmazione C++ usando diversi esempi. Per comprendere le operazioni sui file C++ come lettura e scrittura, dobbiamo prima comprendere il concetto di flusso in C++.
Che cos'è un flusso?
Un flusso è semplicemente un flusso di dati o caratteri. Esistono due tipi di flussi: flussi di input e flussi di output. Un flusso di input viene utilizzato per leggere i dati da un dispositivo di input esterno come una tastiera, mentre un flusso di output viene utilizzato per scrivere dati sul dispositivo di output esterno come un monitor. Un file può essere considerato sia una sorgente di input che di output.
In C++, utilizziamo un flusso per inviare o ricevere dati da o verso una fonte esterna.
Possiamo utilizzare le classi integrate per accedere a un flusso di input/output, ad esempio ios.
Ecco la gerarchia delle classi di flusso del linguaggio di programmazione C++:
Gli oggetti cin e cout sono usati rispettivamente per leggere i dati dalla tastiera e per visualizzare l'output sul monitor. Inoltre, ifstream, che sta per input file stream, viene utilizzato per leggere un flusso di dati da un file e ofstream, che sta per output file stream, viene utilizzato per scrivere un flusso di dati in un file.
Il file iostram.h contiene tutte le classi di flusso di input/output standard richieste nel linguaggio di programmazione C++.
Esempi
Ora che hai compreso le basi dei flussi, discuteremo i seguenti esempi per aiutarti a comprendere meglio le operazioni sui file in C++:
- Esempio 1: aprire e chiudere un file
- Esempio 2: Scrivi su un file
- Esempio 3: leggere da un file
- Esempio 4: leggere e scrivere su un file
- Esempio 5: leggere e scrivere su un file binario
Esempio 1: aprire e chiudere un file
In questo programma di esempio, dimostreremo come aprire/creare un file e come chiudere il file in C++. Come puoi vedere nel programma sottostante, abbiamo incluso la libreria necessaria per le operazioni sui file.
Per aprire e chiudere un file, abbiamo bisogno di un oggetto ofstream. Quindi, per leggere o scrivere su un file, dobbiamo aprire il file. Abbiamo incluso il file di intestazione fstream alla riga numero-1 in modo da poter accedere alla classe ofstream.
Abbiamo dichiarato un myFile_Handler come oggetto di ofstream all'interno della funzione principale. Possiamo quindi utilizzare la funzione open() per creare un file vuoto e la funzione close() per chiudere il file.
#includereusando spazio dei nomiore;
intprincipale()
{
ofstream myFile_Handler;
// File Apri
myFile_Handler.aprire('File_1.txt');
// Chiudi file
myFile_Handler.chiudere();
Restituzione 0;
}
Ora compileremo il programma ed esamineremo l'output. Come puoi vedere nella finestra di output sottostante, il file File_1.txt è stato creato dopo l'esecuzione del programma. La dimensione del file è zero poiché non abbiamo scritto alcun contenuto nel file.
Esempio 2: Scrivi su un file
Nel precedente programma di esempio, ti abbiamo mostrato come aprire un file e come chiuderlo. Ora ti mostreremo come scrivere qualcosa in un file.
Possiamo scrivere su un file usando l'operatore di inserimento del flusso, cioè,<<. In this program, we have used the file handler and insertion operator to write two lines in the file. The insertion operator (<<) indicates that we are inserting the string into the output file stream object.
#includereusando spazio dei nomiore;
intprincipale()
{
ofstream myFile_Handler;
// File Apri
myFile_Handler.aprire('File_1.txt');
// Scrivi nel file
myFile_Handler<< 'Questo è un file di prova di esempio. ' <<fine;
myFile_Handler<< 'Questa è la seconda riga del file. ' <<fine;
// Chiudi file
myFile_Handler.chiudere();
Restituzione 0;
}
Ora compileremo il programma sopra e lo eseguiremo. Come puoi vedere di seguito, abbiamo scritto con successo nel file File_1.txt.
Esempio 3: leggere da un file
Negli esempi precedenti, ti abbiamo mostrato come scrivere contenuto in un file. Ora leggiamo il contenuto dal file che abbiamo creato nell'Esempio-2 e visualizziamo il contenuto sul dispositivo di output standard, ovvero il monitor.
Usiamo la funzione getline() per leggere la riga completa dal file e poi cout per stampare la riga sul monitor.
#includere#includere
#includere
usando spazio dei nomiore;
intprincipale()
{
ifstream myFile_Handler;
stringa miaLinea;
// File aperto in modalità lettura
myFile_Handler.aprire('File_1.txt');
Se(myFile_Handler.è aperto())
{
// Continua a leggere il file
mentre(getline(myFile_Handler, myLine))
{
// stampa la riga sullo standard output
costo <<la mia linea<<fine;
}
// Chiudi file
myFile_Handler.chiudere();
}
altro
{
costo << 'Impossibile aprire il file!';
}
Restituzione 0;
}
Ora stamperemo il contenuto di File_1.txt usando il seguente comando: cat File_1.txt. Una volta compilato ed eseguito il programma, è chiaro che l'output corrisponde al contenuto del file. Pertanto, abbiamo letto con successo il file e stampato il contenuto del file sul monitor.
Esempio 4: leggere e scrivere su un file
Finora ti abbiamo mostrato come aprire, leggere, scrivere e chiudere un file. In C++, possiamo anche leggere e scrivere su un file allo stesso tempo. Per leggere e scrivere su un file, dobbiamo ottenere un oggetto fstream e aprire il file in modalità ios::in e ios::out.
In questo esempio, prima scriviamo del contenuto nel file. Quindi, leggiamo i dati dal file e li stampiamo sul monitor.
#includere#includere
#includere
usando spazio dei nomiore;
intprincipale()
{
fstream myFile_Handler;
stringa miaLinea;
// File Apri
myFile_Handler.aprire('File_1.txt', ios::in |ios::fuori);
// Controlla se il file è stato aperto
Se(!myFile_Handler)
{
costo << 'Il file non si è aperto!';
Uscita(1);
}
// Scrivi nel file
myFile_Handler<< '1. Questo è un altro file di prova di esempio. ' <<fine;
myFile_Handler<< '2. Questa è la seconda riga del file. ' <<fine;
myFile_Handler.ricerca(ios::elemosinare);
// Leggi il file
Se(myFile_Handler.è aperto())
{
// Continua a leggere il file
mentre(getline(myFile_Handler, myLine))
{
// stampa la riga sullo standard output
costo <<la mia linea<<fine;
}
// Chiudi file
myFile_Handler.chiudere();
}
altro
{
costo << 'Impossibile aprire il file!';
}
myFile_Handler.chiudere();
Restituzione 0;
}
Ora compileremo ed eseguiremo il programma.
Esempio 5: leggere e scrivere su un file binario
In questo esempio, dichiareremo una classe e poi scriveremo l'oggetto in un file binario. Per semplificare questo esempio, abbiamo dichiarato la classe Employee con una variabile pubblica emp_id. Quindi, leggeremo il file binario e stamperemo l'output sul monitor.
#includere#includere
usando spazio dei nomiore;
classeDipendente
{
pubblico:
intid_emp;
};
intprincipale()
{
ofstream binOutFile_Handler;
ifstream binInFile_Handler;
Impiegato empObj_W, empObj_R;
// File Apri
binOutFile_Handler.aprire('dipendente.dat', ios::fuori |ios::binario);
// Controlla se il file è stato aperto
Se(!binOutFile_Handler)
{
costo << 'Il file non si è aperto!';
Uscita(1);
}
// Inizializza empObj_W
empObj_W.id_emp = 1512;
// Scrivi nel file
binOutFile_Handler.Scrivi((char *) &empObj_W,taglia di(Dipendente));
binOutFile_Handler.chiudere();
Se(!binOutFile_Handler.Buona())
{
costo << 'Si è verificato un errore durante la scrittura del file binario!' <<fine;
Uscita(2);
}
// Ora leggiamo il file impiegato.dat
binInFile_Handler.aprire('dipendente.dat', ios::in |ios::binario);
// Controlla se il file è stato aperto
Se(!binInFile_Handler)
{
costo << 'Il file non si è aperto!';
Uscita(3);
}
// Legge il contenuto del file binario
binInFile_Handler.leggere((char *) &empObj_R,taglia di(Dipendente));
binInFile_Handler.chiudere();
Se(!binInFile_Handler.Buona())
{
costo << 'Si è verificato un errore durante la lettura del file binario!' <<fine;
Uscita(4);
}
// Stampa l'output di empObj_R
costo << 'Dettagli del dipendente : ' <<fine;
costo << 'Numero Identità dell'impiegato : ' <<empObj_R.id_emp <<fine;
Restituzione 0;
}
Conclusione
I file vengono utilizzati principalmente per archiviare i dati e svolgono un ruolo importante nella programmazione del mondo reale. In questo articolo, ti abbiamo mostrato come utilizzare varie operazioni sui file con il linguaggio di programmazione C++ attraverso diversi esempi. Inoltre, ti abbiamo mostrato come leggere e scrivere dati sia in file di testo che in file binari.