Leggi un file in un array in C ++

Leggere l'intero file in un array non è così difficile come può sembrare. Un file, che sia testo o altro, è costituito da byte dall'inizio alla fine. I byte possono essere letti come caratteri. I personaggi possono essere letti uno per uno nell'array.

Questo articolo spiega come leggere un intero file in un array. L'intestazione C ++ (libreria) fstream, ha la classe IfStream. La classe ifStream ha le funzioni del membro sovraccarico GET (). Due di queste funzioni di membro sovraccarico possono essere utilizzate per leggere l'intero file in un array. Un programma per tale lettura dovrebbe iniziare con:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Le prime due righe sono direttive, non dichiarazioni. Il primo include la libreria fstream per le funzioni get (). Il secondo include la libreria iostream per la stampa al terminale (console) e per ricevere caratteri dalla tastiera. La terza riga è una dichiarazione. Insiste sul fatto che qualsiasi nome non preceduto da "std ::" è dello spazio dei nomi standard.

C'è un piccolo problema con le funzioni get (), la lunghezza dell'array deve essere stimata, per essere almeno un carattere in più rispetto al numero di caratteri nel file. L'idea è di avere '\ 0' incluso subito dopo l'ultimo personaggio di lettura nell'array formare una stringa lunga.

Se la lunghezza dell'array non può essere stimata come tale, l'intero file deve essere letto in qualche altro oggetto come un oggetto stringa (della classe String). Poiché lo scopo di questo articolo è di spiegare come leggere in un array, è necessario stimare la dimensione dell'array.

Per il resto di questo articolo, si presume che il nome del file, il cui contenuto deve essere letto, sia txtfile.txt, nella directory, dir1, nella directory home/utente.

Contenuto dell'articolo

- Leggendo il carattere per intero file per carattere

- Leggere l'intero file con una funzione di un membro

- Conclusione

Leggendo il carattere per intero file per carattere

La sintassi della funzione get () sovraccarica ifstream, per questo, è:

base_istream& get (char_type & c);

Un segmento di codice del programma per leggere il carattere successivo nel file, è:

Char C;
char arr [100];
int i = 0;
mentre (IFS.get (c))
arr [i] = c;
I ++;

La prima affermazione dichiara la variabile, C riceverà ciascuno dei caratteri. La seconda affermazione dichiara l'array che riceverà tutti i personaggi, uno per uno. La terza riga dichiara un indice per l'array a partire da zero per aver affrontato tutti gli elementi dell'array, che riceverà un personaggio. Con questo approccio, '\ 0' può essere aggiunto dopo che l'ultimo carattere del file è stato incluso nell'array.

Le parentesi del loop while hanno,

Ifs.Ottieni (c)

dove ifs è il nome dell'oggetto ifstream. Il prossimo carattere del file viene ottenuto dalla funzione Get membro e assegnato a c. Successivamente, il puntatore interno dell'oggetto ifstream indicherebbe il carattere dopo quello lettura. Quando viene raggiunta la fine del file, l'espressione, "IFS.Ottieni (c) ”diventa falso invece di vero e così finisce il loop while.

Il seguente programma, leggerà tutti i caratteri di un file e stamperà tutti i contenuti al terminale:

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

ifStream ifs = ifStream ("DIR1/TXTFILE.txt ", ios_base :: in);
if (ifs.is_open () == true)
Char C; int i = 0; char arr [100];
mentre (IFS.get (c))
arr [i] = c;
I ++;

Ifs.vicino(); arr [i] = '\ 0'; cout<
altro
cout<< "File could not be open!" <restituzione 0;

Ifstream come codificato, apre il file per la lettura.

Leggere l'intero file con una funzione di un membro

La funzione membro GET () sovraccarica IfStream per leggere l'intero file, senza il ciclo while, è:

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

Legge ancora l'intero personaggio del file per caratteri ma non è più il business del programmatore C ++. Inoltre, questa funzione aggiunge il carattere null, '\ 0' per conto del programmatore, supponendo che n sia almeno un carattere più lungo del contenuto del file.

Il primo argomento di questa funzione get () sovraccarica è l'array con gli stessi vincoli (inclusa la stima) dell'array sopra per ricevere tutti i caratteri del file. Il secondo argomento, N, di tipo StreamSize è una stima del numero di caratteri nel file. È consigliabile fare le dimensioni dell'array e n, lo stesso. Non è necessario un while-loop con questa funzione membro.

Ora, una riga in un file di testo termina con la sequenza di fuga, '\ n'. Se il terzo argomento è '\ n', allora verrà letta solo la prima riga del file. Quindi, la funzione deve essere ingannata con qualsiasi carattere che non è probabile che si trovi nel contenuto del file. Un buon candidato per il terzo argomento, è '\ 0'. Con questa funzione del membro sovraccarico, il programmatore deve avere una certa conoscenza dei possibili caratteri nel file in modo da non usare un carattere che fa parte del contenuto del file.

Il seguente programma leggerà tutti i caratteri di un file con un'istruzione e stamperà tutto il contenuto al terminale:

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

ifStream ifs = ifStream ("DIR1/TXTFILE.txt ", ios_base :: in);
if (ifs.is_open () == true)
char arr [100];
Ifs.get (arr, 100, '\ 0');
Ifs.vicino(); cout<
altro
cout<< "File could not be open!" <restituzione 0;

Conclusione

Un intero file può essere letto in un array. Questo prima di tutto ha bisogno della classe C ++ ifstream della libreria FStream. Il file deve essere aperto per la lettura. Per leggere tutti i caratteri (byte) di un file (uno per uno) nell'array usa la funzione membro IfStream,

base_istream& get (char_type & c)

come condizione in un loop while. Per leggere tutti i caratteri (byte) di un file, nell'array con una funzione membro IfStream senza loop while, la funzione del membro IfStream dovrebbe essere:

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

Non dimenticare di ingannare la funzione al terzo argomento. Con questa funzione, il programmatore deve avere una certa conoscenza dei possibili caratteri nel file.