Come usare c ++ fstream

IL fstream Il termine sta per il flusso di file. Il flusso si riferisce a una sequenza di caratteri che si spostano dal disco al programma C ++ o dal programma C+ al disco. Spostare i caratteri da un file in disco al programma sta inserendo. Spostare i caratteri dal programma a un file nel disco sta eliminando. Frile-file-file abbreviato come se Stream è strutturato dalla classe modello, base_ifstream. Abbreviato dal file di uscita-file di uscita, Of Stream è strutturato dalla classe modello, Basic_ofstream.

È possibile che l'inserimento e l'uscita si svolgano in una sessione. Ciò è reso possibile dal modello di classe, base_fstream. Ora, fstream è sinonimo di base_fstream. fstream, che è ancora basic_fstream, utilizza base_ifstream e ofstream per operare.

Per fare input da solo, eseguire l'output da solo, o entrambi in una sessione, è sufficiente avviare il programma C ++ con le seguenti invocazioni dello spazio di include e nomi:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Questo tutorial ha quattro sezioni principali: apertura e chiusura di un flusso di file, flusso di file di output, aggiunta, flusso di file di input e modifica di un file. Modifica di un file significa inserire e produrre un flusso.

Contenuto dell'articolo

• Apertura e chiusura di un flusso di file
• Operazione di flusso di file di output
• Aggiungere i caratteri a un file
• Funzionamento del flusso di file di input
• Leggere l'intero file con una funzione
• Linea di lettura per riga
• Cerco nel file
• funzione Tellg ()

Apertura e chiusura di un flusso di file

Prima che possa essere aperto un flusso, è necessario creare un oggetto Stream. L'apertura di un flusso significa stabilire un canale tra il programma C ++ e il file in disco. Ciò si ottiene attraverso il quale la sequenza di caratteri si sposterà nel file; o attraverso il quale sequenza di caratteri lascerà il file e verrà al programma; o attraverso quali personaggi si sposteranno.

Un flusso viene aperto solo per la scrittura (output), la lettura (input) o sia la lettura e la scrittura. Può anche essere aperto per altri motivi.

Prima di aprire un flusso, l'oggetto flusso deve essere costruito. Il modo più semplice per esprimerlo è il seguente nella funzione C ++ Main ():

fstream strm;

Ora, con l'oggetto STRM, possono essere utilizzate le funzioni del membro FStream, Open () e Close (), che precedono ciascuno con l'operatore DOT. La seguente dichiarazione può essere utilizzata per aprire un FStream per la lettura:

void aperto ("percorso/a/e/file/file", ios_base :: in);

La funzione membro aperta () restituisce vuoto.

Con l'oggetto Stream, l'affermazione sarebbe:

strm.aprire("./myfile ", ios_base :: in);

Poiché la funzione membro aperta () restituisce vuoto, per sapere se il file nel disco è stato aperto correttamente, utilizzare la funzione membro:

bool is_open () const;

Restituisce zero per false se il file non è stato aperto e 1 per true se il file è stato aperto. Ora il nostro programma sembra così finora:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()
fstream strm;
strm.aprire("./myfile ", ios_base :: in);
if (strm.è aperto())
cout << "Open success" << endl;

altro
cout << "Open failed" << endl;
Ritorno 1;

restituzione 0;

Per aprire un file per la scrittura, usa questo flag:

strm.aprire ("percorso/a/e/file/file", ios_base :: out);

ios_base :: in significa aperto per la lettura e ios_base :: out significa aperto per la scrittura. Per aprire un file per la lettura e la scrittura, usa:

strm.aprire ("percorso/a/e/file/file", ios_base :: in | ios_base :: out);

Nota: la presenza di “ios_base :: in | ios_base :: out ", che utilizza logico o per combinare entrambe le flag come un singolo argomento alla funzione.

La chiusura di un flusso significa chiudere il canale attraverso il quale i dati possono essere inviati tra e il file. Non è più possibile inviato in entrambe le direzioni utilizzando quel canale. La chiusura del flusso non sta chiudendo l'oggetto del flusso. Lo stesso flusso può ancora essere utilizzato per aprire un nuovo canale, che dovrebbe essere chiuso dopo l'uso nella trasmissione dei dati. Fai l'abitudine di chiudere qualsiasi flusso di file, dopo che è stato aperto. Quando un flusso è chiuso, tutti i dati in memoria che avrebbero dovuto essere nel file vengono inviati al file prima di chiudere effettivamente. Il prototipo della funzione membro per chiudere Fstream è:

void vicino ();

Restituisce nullo, purtroppo. Quindi, per sapere se la chiusura ha avuto successo, usa la funzione membro:

bool is_open () const;

Se la chiusura avesse successo, questo sarebbe stato zero, il che significa che il flusso non è più aperto. Se la chiusura non avesse avuto successo, sarebbe tornato 1 e il che significa che il flusso non potrebbe essere chiuso.

Operazione di flusso di file di output

Ora dimostreremo l'apertura di un file e gli darà un nuovo contenuto di dati. Per aprire un flusso di output con fsream, basta utilizzare ios_base :: out da solo nella funzione membro aperta (). Il seguente programma apre un file e invia il contenuto di una stringa:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()
fstream strm;
strm.aperto ("Doc1.txt ", ios_base :: out);
Se (!strm.è aperto())
cout << "File could not be opened!" << endl;
Ritorno 1;

char str [] = "a: questa è la prima riga.\N"
"B: Questa è la seconda riga.\N"
"C: questa è la terza riga.\N";
strm << str;
strm.vicino();
if (strm.è aperto())
cout << "Stream could not close!" << endl;
Ritorno 1;

cout << "Success, check file" << endl;
restituzione 0;

Il nome del file è doc1.txt può includere un percorso completo o un percorso relativo. Il nuovo contenuto è identificato da STR nel programma. Alla fine del programma, il contenuto di stringa sarebbe stato inserito nel flusso e quindi il file con l'istruzione:

strm << str;

COUT è un oggetto di uscita standard e in genere viene utilizzato per la console. Utilizza l'operatore di estrazione, << . L'operatore di estrazione viene anche utilizzato con flussi di file. L'oggetto del flusso di file qui è strm. Il carattere '\ n' alla fine di ogni citazione sopra è assicurarsi che la riga successiva appaia di seguito nel file di output:

Invece di inviare il testo al file con l'operatore di inserzione, è possibile utilizzare la funzione membro Write (). Il seguente codice illustra questo:

base_ostream & write (const char_type* s, stream -size n)

Ecco il codice completo con la funzione di scrittura utilizzata:

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()
fstream strm;
strm.aperto ("Doc2.txt ", ios_base :: out);
Se (!strm.è aperto())
cout << "File could not be opened!" << endl;
Ritorno 1;

char str [] = "a: questa è la prima riga.\N"
"B: Questa è la seconda riga.\N"
"C: questa è la terza riga.\N";
strm.scrivere (str, strlen (str));
strm.vicino();
if (strm.è aperto())
cout << "Stream could not close!" << endl;
Ritorno 1;

restituzione 0;

Il primo argomento della funzione Write () è l'identificatore dell'array di caratteri. Il secondo argomento è il numero di caratteri (senza \ 0) nell'array.

Aggiungi caratteri a un file

Per aggiungere testo a un file, usa "ios_base :: app" da solo, invece di "ios_base :: out" nella funzione membro aperta (). Tuttavia, utilizzare l'operatore di inserzione, <<, as follows:

#includere
#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()
fstream strm;
strm.aperto ("Doc2.txt ", ios_base :: app);
Se (!strm.è aperto())
cout << "File could not be opened!" << endl;
Ritorno 1;

char str [] = "d: questa è la quarta riga.\N";
strm << str;
strm.vicino();
if (strm.è aperto())
cout << "Stream could not close!" << endl;
Ritorno 1;

cout << "Success, check file" << endl;
restituzione 0;

Il file di output dovrebbe ora avere quattro righe.

Funzionamento del flusso di file di input

Ora dimostreremo la lettura di un carattere file per carattere con fstream. Per leggere un file con fstream, usa ios_base :: in come il flag nella funzione membro aperta (). Il seguente programma legge tutto il contenuto del file e lo visualizza sulla console:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

fstream strm;
strm.aperto ("Doc1.txt ", ios_base :: in);
Se (!strm.è aperto())
cout << "Open file failed" << endl;
Ritorno 1;

Char C;
Mentre (!strm.eof ())
strm.ottenere (c);
cout << c;

strm.vicino();
restituzione 0;

L'EOF () è una funzione membro e restituisce 1 quando viene raggiunta la fine del file e zero altrimenti. Il programma legge i caratteri del file, uno per uno, fino a raggiungere la fine del file. Utilizza la funzione membro get (), inserendo il carattere di lettura nella variabile C, che è già stata dichiarata. Cout invia ogni carattere alla console. L'output dovrebbe essere:

A: Questa è la prima riga.
B: Questa è la seconda riga.
C: Questa è la terza riga.

Leggere l'intero file con una funzione

L'intero file può essere letto utilizzando la funzione membro:

base_istream & get (char_type* s, streamSize N, char_type delim);

Copia i caratteri dal file e li mette in un array di caratteri. Lo fa fino a quando non incontra il delimitatore, EOF o fino a quando non ha copiato il carattere N - 1. Si adatterà al carattere null ('\ 0') come ultimo carattere consecutivo nell'array. Ciò significa che il numero di caratteri scelti per l'array dovrebbe essere stimato in almeno il numero di caratteri di file (incluso qualsiasi \ n), più uno per il carattere null. Non copia il carattere delimitatore. Il codice seguente copia l'intero file di DOC1.txt, usando questa funzione membro:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

fstream strm;
strm.aperto ("Doc1.txt ", ios_base :: in);
Se (!strm.è aperto())
cout << "Open file failed" << endl;
Ritorno 1;

char arr [150];
strm.get (arr, 150, eof);
strm.vicino();
cout << arr << endl;
restituzione 0;

Linea di lettura per riga

La funzione membro da utilizzare per la lettura da un file con fstream riga per riga è:

base_istream& getLine (char_type* s, stream -size n, char_type delim);

Copia i caratteri dal file e li mette in un array di caratteri. Lo fa finché non incontra il delimitatore (e.G. '\ n') o fino a quando non ha copiato il carattere n - 1. Si adatterà al carattere NUL ('\ 0') come ultimo carattere consecutivo nell'array. Ciò significa che il numero di caratteri scelti per l'array dovrebbe essere stimato in almeno il numero di caratteri visibili, più uno per il carattere null. Non copia il carattere delimitatore. Il codice seguente copia l'intero file di DOC1.txt riga per riga, usando questa funzione membro:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

fstream strm;
strm.aperto ("Doc1.txt ", ios_base :: in);
Se (!strm.è aperto())
cout << "Open file failed" << endl;
Ritorno 1;

char arr [100];
Mentre (!strm.eof ())
strm.getline (arr, 100, '\ n');
cout << arr << endl;

strm.vicino();
restituzione 0;

Poiché '\ n' non viene copiato durante la copia di una linea, deve essere utilizzato endl per il display di uscita. Si noti che il numero di caratteri nell'array e la variabile di streaming è stato realizzato lo stesso. Se è noto in anticipo che il delimitatore è '\ n', è possibile utilizzare la seguente funzione del membro:

base_istream& getline (char_type* s, stream -size n);

Cerco nel file

I caratteri tra cui '\ n' hanno le loro posizioni naturali nel file, a partire da 0, quindi 1, 2, 3 e così via. La funzione membro Seekg (POS) punterebbe il puntatore al carattere di una posizione nell'oggetto del flusso. Quindi, ottenere (c) può essere usato per ottenere quel carattere. Il personaggio nel 27^th posizione dell'attuale DOC1.Il file txt è 'b'. Il seguente codice legge e lo visualizza:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

fstream strm;
strm.aperto ("Doc1.txt ", ios_base :: in);
Se (!strm.è aperto())
cout << "Open file failed" << endl;
Ritorno 1;

Char C;
strm.Seekg (27);
strm.ottenere (c);
cout << c << endl;
strm.vicino();
restituzione 0;

Se la posizione indicata è maggiore di quella dell'ultimo carattere nel file (meno 1), NULL viene restituito.

funzione Tellg ()

Mentre un file viene letto, un puntatore interno indica il carattere successivo da leggere. La funzione membro Tellg () può ottenere il numero di posizione del carattere a cui punta il puntatore. Quando il file viene appena aperto, Tellg () restituirà 0 per il primo carattere. Dopo aver letto la prima riga, Tellg () restituirebbe un numero come 27 nell'esempio seguente:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

fstream strm;
strm.aperto ("Doc1.txt ", ios_base :: in);
Se (!strm.è aperto())
cout << "Open file failed" << endl;
Ritorno 1;

char arr [100];
int pos;
strm.getline (arr, 100, '\ n');
pos = strm.Tellg ();
strm.vicino();
cout << "Position in file is now: " << pos <restituzione 0;

L'output è:

~ $ ./T9
La posizione in file è ora: 27

La funzione equivalente per l'output è Tellp ().

Seekdir

SeekDir significa cercare la direzione. Le sue costanti definite nella libreria iOS_Base sono: implorare per l'inizio del file, cur per la posizione corrente del file e terminare per la fine del file. La funzione di secelg () di cui sopra è sovraccarica per il flusso di input come:

base_istream & seekg (off_type, ios_base :: seekdir)

Quindi, se il puntatore interno punta al carattere in posizione 27 contando l'inizio da 0, quindi

strm.Seekg (0, ios_base :: cur);

Manterrà il puntatore nella posizione corrente.

strm.Seekg (5, ios_base :: cur);

Prenderò il puntatore 5 posti in vantaggio per puntare su "I" nel secondo "questo" del DOC1.file txt.

strm.Seekg (-5, ios_base :: cur);

Prenderò il puntatore 5 posti dietro per indicare "I" nella prima "linea" del DOC1.file txt. Si noti che viene conteggiata la posizione del carattere di Newline '\ n', che non viene visualizzato all'uscita.

Ora, non importa dove potrebbe essere il puntatore,

strm.Seekg (0, ios_base :: beg);

Prende e mantiene il puntatore all'inizio del file; per indicare il primo carattere del file, con un offset di 0. In questo caso, indicherà "A".

strm.Seekg (5, ios_base :: beg);

Porterà il puntatore all'inizio con un offset di 5 posti davanti; punta su "io" nel primo "questo" del doc1.file txt. Si noti che il singolo spazio è conteggiato come un personaggio.

Un intero negativo nella posizione di offset per "ios_base :: beg" non è utile.

Bene, non importa dove potrebbe essere il puntatore,

strm.Seekg (0, ios_base :: end);

Prenderà e manterrà il puntatore subito dopo la fine del file; Non indicare nulla.

Un intero positivo nella posizione di offset per "ios_base :: end" non è utile.

strm.Seekg (-5, ios_base :: end);

Porterà il puntatore fino alla fine con un offset di 5 posti dietro; punta a "io" nell'ultima "linea" del DOC1.file txt. Si noti che '\ n' e il punto sono conteggiati come un personaggio ciascuno.

Il seguente codice illustra l'uso della funzione, nella posizione corrente, con un offset negativo e positivo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

fstream strm;
strm.aperto ("Doc1.txt ", ios_base :: in);
Se (!strm.è aperto())
cout << "Open file failed" << endl;
Ritorno 1;

Char C;
strm.Seekg (27);
strm.Seekg (0, ios_base :: cur);
strm.ottenere (c);
cout << c << endl;
strm.Seekg (-5, ios_base :: cur);
strm.ottenere (c);
cout << c << endl;
strm.Seekg (+10, ios_base :: cur);
strm.ottenere (c);
strm.vicino();
restituzione 0;

L'output è:

B
N

La funzione membro get () sposta il puntatore un posto in anticipo dopo la sua esecuzione.

La funzione equivalente per l'output è:

base_ostream& Seekp (off_type, ios_base :: Seekdir)

Nota la "P" in Seekp per Put, al contrario di "G" in Seekg for Get.

Conclusione

La classe FStream tratta l'input da un file a un programma C ++ e l'output dal programma al file. Per utilizzare C ++ Fstream, un oggetto della classe deve essere istanziato. L'oggetto flusso deve quindi essere aperto per l'input o l'output o entrambi. Per aggiungere testo al file, il flusso deve essere aperto per l'avvio. Prendere l'abitudine di chiudere sempre il flusso dopo che è stato aperto e utilizzato. Se il file è un file di immagine, allora ios_base :: binario dovrà essere ORED usando | , con il secondo argomento della funzione membro aperta (). Questo articolo si spera che ti abbia aiutato a utilizzare C ++ FStream.