Prima di allora, quando i dati I / O, lavoravamo con flussi standard: una tastiera e un monitor. Ora diamo un'occhiata a come il linguaggio C implementa la ricezione di dati dai file e la loro scrittura lì. Prima di eseguire queste operazioni, è necessario aprire il file e accedervi.

Nel linguaggio di programmazione C, un puntatore a file è di tipo FILE e la sua dichiarazione ha questo aspetto:
FILE * miofile;

D'altra parte, la funzione fopen() apre il file all'indirizzo specificato come primo argomento in modalità read ("r"), write ("w") o append ("a") e restituisce un puntatore ad esso nel programma. Pertanto, il processo di apertura di un file e di connessione al programma si presenta così:
miofile = fopen ("ciao.txt", "r");

Quando si leggono o si scrivono dati su un file, è possibile accedervi tramite un puntatore a file (in questo caso, miofile).

Se per qualche motivo (non c'è nessun file all'indirizzo specificato, l'accesso è negato) la funzione fopen() non può aprire il file, allora restituisce NULL. Nei programmi reali, l'errore di apertura di un file nel ramo if viene quasi sempre gestito, ma lo ometteremo ulteriormente.

La dichiarazione della funzione fopen() è contenuta nel file di intestazione stdio.h, quindi deve essere inclusa. Il tipo di struttura FILE è dichiarato anche in stdio.h.

Al termine del lavoro con il file, è consuetudine chiuderlo per liberare il buffer di dati e per altri motivi. Ciò è particolarmente importante se il programma continua a funzionare dopo aver lavorato con il file. L'interruzione della connessione tra un file esterno e un puntatore ad esso dal programma viene eseguita utilizzando la funzione fclose(). Gli viene passato un puntatore a un file come parametro:
fclose (miofile);

È possibile aprire più di un file nel programma. In questo caso, ogni file deve essere associato al proprio puntatore di file. Tuttavia, se il programma funziona prima con un file, quindi lo chiude, è possibile utilizzare il puntatore per aprire il secondo file.

Leggere e scrivere in un file di testo

fscanf()

La funzione fscanf() ha un significato simile alla funzione scanf(), ma a differenza di essa riceve input formattati da un file anziché input standard. La funzione fscanf() accetta parametri: un puntatore a file, una stringa di formato, indirizzi di aree di memoria per la scrittura dei dati:
fscanf (miofile, "% s% d", str, & a);

Restituisce la quantità di dati letti correttamente o EOF. Gli spazi, i caratteri di nuova riga vengono conteggiati come separatori di dati.

Supponiamo di avere un file contenente la seguente descrizione degli oggetti:

Mele 10 23,4 banane 5 25,0 pane 1 10,3

#includere main() (FILE * file; struct food (char name [20]; unsigned qty; float price;); struct food shop [10]; char i = 0; file = fopen ("fscanf.txt", "r" ); while (fscanf (file, "% s% u% f", shop [i] .name, & (shop [i] .qty), & (shop [i] .price))! = EOF) (printf ("% s% u% .2f \ n ", negozio [i] .nome, negozio [i] .qty, negozio [i] .prezzo); io++; ))

In questo caso vengono dichiarate una struttura e un array di strutture. Ogni riga del file corrisponde a un elemento dell'array; un elemento array è una struttura contenente una stringa e due campi numerici. Il ciclo legge una riga per iterazione. Quando si incontra la fine del file, fscanf() restituisce EOF e il ciclo termina.

fget ()

La funzione fgets() è simile alla funzione gets() e prende l'input riga per riga da un file. Una chiamata fgets() leggerà una riga. In questo caso, puoi leggere non l'intera riga, ma solo una parte dall'inizio. I parametri Fgets() hanno questo aspetto:
fgets (char_array, numero di caratteri da leggere, puntatore_ al file)

Ad esempio:
fgets (str, 50, miofile)

Tale chiamata di funzione leggerà dal file associato al puntatore myfile un'intera riga di testo se la sua lunghezza è inferiore a 50 caratteri, tenendo conto del carattere "\ n", che la funzione memorizzerà anche nell'array. L'ultimo (50esimo) elemento nell'array str sarà il carattere "\ 0" aggiunto da fgets (). Se la stringa è più lunga, la funzione leggerà 49 caratteri e scriverà "\0" alla fine. In questo caso, "\ n" non sarà contenuto nella riga di lettura.

#includere #define N 80 main() (FILE * file; char arr [N]; file = fopen ("fscanf.txt", "r"); while (fgets (arr, N, file)! = NULL) printf (" % s ", arr); printf (" \ n "); fclose (file); )

In questo programma, a differenza del precedente, i dati vengono letti riga per riga nell'array arr. Quando viene letta la riga successiva, quella precedente viene persa. La funzione fgets() restituisce NULL se non riesce a leggere la riga successiva.

getc() o fgetc()

La funzione getc() o fgetc() (funzionano entrambe) ti permette di ottenere il carattere successivo dal file.

while ((arr [i] = fgetc (file))! = EOF) (if (arr [i] == " \ n ") (arr [i] = " \0 " ; printf ("% s \ n ", arr); io = 0; ) altrimenti io ++; ) arr [i] = " \0 " ; printf ("% s \ n ", arr);

Il codice di esempio visualizza sullo schermo i dati di un file.

Scrivere su un file di testo

Oltre all'input, l'output sul file può essere diverso.

• Uscita formattata. Funzione Fprintf (file_pointer, format_string, variabili).
• Uscita riga per riga. Funzione fputs (stringa, file_pointer).
• Uscita carattere per carattere. Fputc() o putc (char, file_pointer).

Di seguito sono riportati esempi di codice che utilizzano tre modi per inviare i dati a un file.

Scrittura di campi di una struttura su ogni riga del file:

file = fopen ("fprintf.txt", "w"); while (scanf ("% s% u% f", shop [i] .name, & (shop [i] .qty), & (shop [i] .price))! = EOF) (fprintf (file, " % s% u% .2f \ n ", negozio [i] .nome, negozio [i] .qty, negozio [i] .prezzo); io++; )

L'output riga per riga in un file (fputs()), a differenza di puts() stesso non inserisce "\ n" alla fine della riga):

while (ottiene (arr)! = NULL) (fputs (arr, file); fputs (" \ n ", file); )

Un esempio di output carattere per carattere:

while ((i = getchar())! = EOF) putc (i, file);

Leggere e scrivere da un file binario

Puoi lavorare con un file non come una sequenza di caratteri, ma come una sequenza di byte. In linea di principio, è impossibile lavorare in modo diverso con file non di testo. Tuttavia, puoi leggere e scrivere su file di testo in questo modo. Il vantaggio di questa modalità di accesso a un file è la velocità di lettura-scrittura: un accesso può leggere/scrivere un blocco significativo di informazioni.

Quando si apre un file per l'accesso binario, il secondo parametro di fopen() è la stringa "rb" o "wb".

L'argomento del lavoro con i binari è piuttosto complesso e richiede una lezione separata per impararlo. Qui noteremo solo le peculiarità delle funzioni di lettura e scrittura su un file, che è considerato come un flusso di byte.

Le funzioni fread() e fwrite() prendono come parametri:

1. l'indirizzo dell'area di memoria da cui vengono scritti o letti i dati,
2. la dimensione di un dato tipo,
3. la quantità di dati da leggere della dimensione specificata,
4. puntatore di file.

Queste funzioni restituiscono il numero di dati letti o scritti con successo. Quelli. puoi "ordinare" la lettura di 50 elementi di dati e ottieni solo 10. Non ci saranno errori.

Un esempio di utilizzo delle funzioni fread() e fwrite():

#includere #includere main() (FILE * file; char shelf1 [50], shelf2 [100]; int n, m; file = fopen ("shelf1.txt", "rb"); n = fread (shelf1, sizeof (char), 50, file); fclose (file); file = fopen ("shelf2.txt", "rb"); m = fread (shelf2, sizeof (char), 50, file); fclose (file); shelf1 [n] = " \0 " ; scaffale2 [m] = " \ n "; ripiano2 [m + 1] = " \0 " ; file = fopen ("shop.txt", "wb"); fwrite (strcat (shelf2, shelf1), sizeof (char), n + m, file); fclose (file); )

Qui si tenta di leggere 50 caratteri dal primo file. N memorizza il numero di caratteri effettivamente letti. N può essere 50 o meno. I dati vengono inseriti in una stringa. La stessa cosa accade con il secondo file. Successivamente, la prima riga viene aggiunta alla seconda e i dati vengono scaricati nel terzo file.

Risolvere problemi

1. Scrivere un programma che chieda all'utente il nome (indirizzo) di un file di testo, quindi lo apra e conti il ​​numero di caratteri e righe in esso contenuti.
2. Scrivere un programma che scriva dati su un file ricevuto da un altro file e modificato in un modo o nell'altro prima di scrivere. Ogni riga di dati ricevuta da un file deve rientrare in una struttura.

- confronto per identificare l'uguaglianza o la disuguaglianza.

Lo scopo pratico di un'enumerazione è definire un insieme di diverse costanti simboliche di tipo intero.

Un esempio di utilizzo di variabili enumerate:

mo = 1, tu, we, th, fr, sa, su) giorni;

puts ("Inserisci il giorno della settimana (da 1 a 7):"); scanf ("% d", & t_day);

w_day = su; inizio = mese;

fine = w_day -t_day;

printf ("\ n lunedì è% d-esimo giorno della settimana, \ ora% d-esimo giorno. \ n \

Ci sono % d giorni (giorni) fino alla fine della settimana. ”, Inizio, t_day, fine);

Il risultato del programma: Inserire il giorno della settimana (da 1 a 7): 2

Il lunedì è il 1° giorno della settimana, ora il 2° giorno. Fino alla fine della settimana 5 giorni (giorno).

18. File in linguaggio C

Un file è un insieme di dati che si trova su un supporto esterno e considerato nel processo di elaborazione nel suo insieme. I file contengono dati destinati all'archiviazione a lungo termine.

Esistono due tipi di file: di testo e binari. I file di testo sono una sequenza di caratteri ASCII e possono essere visualizzati e modificati con qualsiasi editor di testo.

I file binari (binari) sono una sequenza di dati, la cui struttura è definita a livello di codice.

Il linguaggio C ha un ampio set di funzioni per lavorare con i file, la maggior parte delle quali si trovano nelle librerie stdio.h e io.h.

18.1. Apertura di un file

Ad ogni file viene assegnato un nome logico interno, che viene utilizzato in seguito quando vi si fa riferimento. Il nome logico (ID file) è

un puntatore a un file, ad es. nell'area di memoria, che contiene tutte le informazioni necessarie sul file. Il formato per dichiarare un puntatore a file è il seguente:

Prima di iniziare a lavorare con il file, ad es. per poter leggere o scrivere informazioni su un file, è necessario aprirlo per l'accesso. Per questo, di solito viene utilizzata la funzione

FILE * fopen (char * nome file, char * modalità);

prende la rappresentazione esterna - il nome fisico del file sul supporto (disco floppy, disco rigido) e gli assegna un nome logico.

Nome fisico, ad es. il nome del file e il suo percorso sono specificati dal primo parametro

- una riga, ad esempio, "a: Mas_dat.dat" - un file denominato Mas_dat.dat situato su un dischetto, "d: \\ work \\ Sved.txt" - un file denominato Sved.txt situato sul disco rigido drive nella directory di lavoro ...

Attenzione! Una barra rovesciata (\), come carattere speciale, viene scritta due volte in una stringa.

Dopo l'apertura riuscita, la funzione fopen restituisce un puntatore a file (di seguito denominato puntatore a file). Restituisce NULL in caso di errore. Questa situazione si verifica in genere quando il percorso del file che si sta aprendo è specificato in modo errato. Ad esempio, se specifichi un percorso in cui è vietato scrivere nell'aula espositiva del nostro ateneo (di solito d:\lavoro\è consentito).

Il secondo parametro è una stringa che imposta la modalità di accesso ai file:

w - il file viene aperto per la scrittura; se non esiste un file con il nome specificato, verrà creato; se tale file esiste, le informazioni precedenti vengono distrutte prima dell'apertura;

r - il file viene aperto in sola lettura; se non esiste tale file, si verifica un errore;

a - il file viene aperto per aggiungere nuove informazioni alla fine;

r + - il file viene aperto per la modifica dei dati - sono possibili sia la scrittura che la lettura delle informazioni;

w + - lo stesso di r +;

a + - lo stesso di a, solo la scrittura può essere eseguita ovunque nel file; è disponibile anche la lettura di file;

t - il file viene aperto in modalità testo; b - il file viene aperto in modalità binaria.

La modalità testo differisce dalla modalità binaria in quanto quando il file viene aperto come una coppia di caratteri di testo "line feed", "carriage return" è sostituito da un carattere: "line feed" per tutte le funzioni di scrittura dei dati sul file, e per tutte le funzioni di output il carattere "avanzamento riga" è ora sostituito da due caratteri: "avanzamento riga", "ritorno a capo".

Per impostazione predefinita, il file si apre in modalità testo. Esempio: FILE * f; - viene dichiarato un puntatore a un file f;

f = fopen ("d: \\ lavoro \\ Dat_sp.cpp", "w"); - viene aperto in scrittura un file con nome logico f con nome fisico Dat_sp.cpp, che si trova sul disco d, nella directory di lavoro; o più brevemente

FILE * f = fopen ("d: \\ lavoro \\ Dat_sp.cpp", "w");

18.2. Chiusura del file

Dopo aver lavorato con il file, l'accesso ad esso deve essere chiuso. Questo viene fatto da int fclose (puntatore al file). Ad esempio, dall'esempio precedente, il file viene chiuso in questo modo: fclose (f);

Per chiudere più file è stata introdotta una funzione che viene dichiarata come segue: void fcloseall (void);

Se è necessario modificare la modalità di accesso per un file, è necessario prima chiudere questo file e quindi riaprirlo, ma con diritti di accesso diversi. Per fare ciò, usa la funzione standard:

FILE * freopen (char * nome_file, char * modalità, FILE * puntatore_file);

Questa funzione chiude prima il file dichiarato file_pointer(come fa la funzione fopen) e quindi apre il file con i permessi file_name e mode.

Il linguaggio C ha la capacità di lavorare con file temporanei che sono necessari solo durante il lavoro del programma. In questo caso viene utilizzata la funzione

FILE * tmpfile (void);

che crea un file temporaneo sul disco con diritti di accesso "w + b", dopo che il programma termina o dopo aver chiuso il file temporaneo, viene automaticamente eliminato.

18.3. Scrivere - leggere le informazioni

Tutte le azioni di lettura-scrittura dei dati su un file possono essere suddivise in tre gruppi: operazioni di input-output carattere per carattere; operazioni di I/O di linea; bloccare le operazioni di I/O.

Consideriamo le principali funzioni utilizzate in ciascuno di questi tre gruppi di operazioni.

Carattere I/O

Nelle funzioni di I/O carattere per carattere, un carattere viene ricevuto da un file o un carattere viene trasmesso a un file:

Linea I/O

Nelle funzioni di I/O di linea, c'è un trasferimento da un file o verso

Blocco I/O

Le funzioni Block I/O funzionano con interi blocchi

L'I/O formattato è prodotto dalle funzioni.

Abbiamo già imparato a scrivere informazioni su un file di testo. - Se non hai imparato, vedi l'ultimo articolo. Racconta e descrive in dettaglio

Ma cosa succede se il file esiste già e abbiamo bisogno di leggere le informazioni da esso per l'elaborazione? Fortunatamente, anche questo è abbastanza semplice. Lascia che ti ricordi che ci sono diverse opzioni per l'implementazione di questo compito, ne ho descritta solo una. Descritto è quello che per qualche motivo personalmente mi sembra il più facile per la percezione.

#includere

intero principale ()
{
carattere s1 //La variabile leggerà la stringa
ifstream in ("C: \\\ FromC \\ miofile.txt"); //Apertura del file per leggere le informazioni
in >> s1; //leggi la riga
in .close() // Chiudi il file

cout<Visualizzazione del valore s1 sullo schermo
restituisce 0;
}

Ecco il programma più semplice per leggere la prima riga da un file di testo situato lungo il percorso
C: \\\ FromC \\ miofile.txt -
Poiché questa è una continuazione dell'ultimo articolo, ho deciso di utilizzare il file che abbiamo creato lì. Probabilmente non dovrebbero esserci difficoltà con questo.
Ma torniamo al codice. Innanzitutto, apriamo il file per leggere le informazioni da esso, per questo usiamo il comando ifstream, tra parentesi indichiamo o il nome del file, o il percorso del file, come ho fatto io. (“C: \\\ FromC \\ miofile.txt”);
Quando abbiamo aperto il file per leggere qualcosa da esso, abbiamo dichiarato una variabile come carattere -
carattere s1
Ora non ci resta che assegnare alla variabile il valore della stringa dal file. Lo facciamo come una squadra in
Fai attenzione alle parentesi angolari in >>
In realtà, come si evince dai commenti al codice del programma, affinché la variabile assegni il valore letto, dobbiamo scriverlo dopo in >>
in >> s1;