FILE DATI 16 lunedi 26 luglio giovedi ore 9

Come sappiamo, un file dati è un gruppo di informazioni tra loro correlate, memorizzate in un dispositivo di memoria secondaria e utilizzabili da un programma.

Dichiarazione (FILE). Ogni file dati è caratterizzato da un nome di file, in genere non più lungo di 8 caratteri, seguito opzionalmente da un punto e da una estensione di un massimo di 3 caratteri.

In un programma C, un file è sempre riferito da un nome di variabile che deve essere dichiarata nel programma.

Tale variabile punta a una speciale struttura di file, e quindi deve essere dichiarata come un puntatore a un file. Esempi di dichiarazioni:

FILE *file_in; FILE *prezzi;

Il nome del puntatore è il nome con il quale il programma farà riferimento al file dati, e non deve essere necessariamente uguale al nome esterno usato dal computer per memorizzare il file.

Il termine FILE è il nome tag di una speciale struttura dati usata dal C per memorizzare le informazioni relative al file, tra le quali:

se il file sia disponibile per lettura o scrittura; il prossimo carattere disponibile nel file: dove tale carattere sia memorizzato.

L’effettiva dichiarazione della struttura di un file e la sua equivalenza al nome simbolico FILE sono contenute nel file d’intestazione standard stdio.h, che deve essere incluso all’inizio di ogni programma che usi un file dati.

Apertura (fopen()). L’apertura di un file è una procedura che raggiunge due scopi, uno solo dei quali interessa direttamente il programmatore:

1. Stabilisce un canale fisico di comunicazione tra il programma e il file dati: dato che i dettagli di questo collegamento sono gestiti dal sistema operativo e sono trasparenti al programma, il programmatore di solito non li considera.

2. Uguaglia il nome del file esterno al computer al nome puntatore usato internamente dal programma.

La funzione per l’apertura di un file è chiamata fopen(); dato che la sua dichiarazione è inserita nel file d’intestazione stdio.h, esso va incluso in ogni programma che usi fopen().

Vediamo come vada chiamata fopen() per collegare il nome esterno di un file a quello interno.

Per usare fopen() occorre passarle due argomenti, racchiusi tra doppi apici:

il nome del file per il computer; il modo in cui il file va aperto.

I modi principali sono w, a, r, quelli secondari sono w+, a+, r+, che hanno i seguenti significati:

L’apertura di un file per scrittura crea un nuovo file e lo rende disponibile per l’uscita della funzione che lo ha aperto.

Ad es., l’istruzione:

out_file = fopen(“prezzi.dat”, “w”);

crea un file di nome esterno prezzi.dat in cui è possibile scrivere, e permette al programma di accedervi usando il puntatore interno di nome out_file.

prezzi.dat

#include <stdio.h> . out_file .

se esiste già un file con il nome di unoaperto per scrittura, esso viene cancellato.

L’apertura per aggiunta di un file esistente consente di aggiungervi dati alla fine.

Se il file aperto per aggiunta non esiste, ne viene creato uno con il nome indicato, in grado di ricevere l’uscita dal programma. Ad es., l’istruzione:

out_file = fopen(“prezzi.dat”, “a”);

apre il file prezzi.dat e lo rende disponibile per l’aggiunta di dati alla sua fine.

L’unica differenza tra l’apertura un file in modo scrittura e in modo aggiunta è il posto in cui i dati sono fisicamente messi nel file:

• nel modo scrittura sono scritti a partire dall’inizio del file,• nel modo aggiunta sono scritti a partire dalla fine.

Per un file nuovo, i due modi sono identici.

In ciascuna di esse il nome-di-file è il nome del puntatore interno specificato quando il file è stato aperto.

Ad es., se out_file è il nome di puntatore interno di un file aperto in modo scrittura o aggiunta, sono valide le seguenti istruzioni di uscita:

Funzioni di scrittura (fputc(), fputs(), fprintf()). Per scrivere i dati in un file aperto in modo scrittura o aggiunta si usano le funzioni di biblioteca indicate in tabella, che sono simili a quelle usate per visualizzare i dati sullo schermo (putchar(), puts(), printf()).

fputc(‘a’, out_file);fputs(“Salve tutti”, out_file);fprintf(out_file, “%s %d”, descriz, prezzo);

Osservazione. Le funzioni

fputc() fputs() fprintf()

sono usate nello stesso modo delle loro equivalenti

putchar() puts() printf()

con l’aggiunta di un nome-di-file come argomento. Esso dirige l’uscita a un file specifico, anziché al dispositivo di uscita standard che è lo schermo.

I prototipi di fputc(), fputs(), fprintf() sono contenuti nel file stdio.h.

Chiusura (fclose()). Dopo essere stato aperto, un file va chiuso con la funzione fclose(), che ha come argomento il nome del puntatore usato quando il file è stato aperto.

Essa rompe il legame tra i nomi esterno e interno del file rilasciando il nome del puntatore al file interno, che quindi può essere usato per un altro file. Ad es., l’istruzione

fclose(out_file);

chiude il file puntato da out_file.

Dato che il numero di file che possono rimanere aperti contemporaneamente è limitato, è bene chiudere i file non più necessari (tutti i file aperti sono chiusi automaticamente dal sistema operativo alla fine della normale esecuzione del programma).

Scrittura da programma. Il programma seguente illustra l‘uso della funzione di scrittura file fprintf() per scrivere in un file un elenco di descrizioni e prezzi contenuti nel programma stesso.

#include <stdio.h>void main(void){ int i; FILE *out_file; /* dichiarazione di FILE */ float prezzo[] = {39.95, 3.22, 1.03}; char *descriz[] = {"Batterie", "Bulbi", "Fusibili"}; out_file = fopen("prezzi.dat","w"); /* apre il file */ if(out_file == NULL) { printf("\nErrore nell’apertura del file.\n"); exit(1); } for(i = 0; i < 3; ++i) fprintf(out_file,"%-9s %5.2f\n", descriz[i], prezzo[i]); fclose(out_file);}

Se per qualche ragione non è possibile aprire il file, il puntatore out_file assume il valore NULL (già visto nel caso delle liste concatenate), viene visualizzato un messaggio di errore e la funzione exit() passa il suo argomento al sistema operativo, determinando la fine della esecuzione del programma.

Se invece il file viene aperto, viene creato e salvato il file prezzi.dat consistente nelle tre linee seguenti:

Batterie 39.95 Bulbi 3.22

Fusibili 1.03

La sequenza di controllo di conversione %-9s nella chiamata alla funzione printf() forza la giustificazione a sinistra delle descrizioni in un campo di 9 caratteri.

Analogamente, i prezzi sono giustificati a destra in un campo di 5 caratteri, a partire da uno spazio dopo la fine del campo descrizioni.

42 61 74 74 65 72 69 65 20 33 39 2E 32 35 0A B a t t e r i e 3 9 . 2 5 \n

42 75 6c 62 69 20 20 20 20 20 33 2E 32 32 0A B u l b i 3 . 2 2 \n

46 75 73 69 62 69 6c 69 20 20 31 2E 30 33 0A 26 F u s i b i l i 1 . 0 3 \n ^Z

Sebbene sembri che nel file siano memorizzati 42 caratteri, corrispondenti alle descrizioni, ai caratteri vuoti e ai prezzi scritti nel file, esso in effetti ne contiene 46.

I caratteri aggiuntivi consistono in sequenze di escape di linea nuova alla fine di ogni linea, e in uno speciale marcatore di fine-file posto come ultimo carattere nel file quando esso viene chiuso.

La memorizzazione effettiva dei caratteri nel file prezzi.dat è costituita dai loro codici ASCII, come indicato in figura. Il codice per il marcatore di fine-file ^Z dipende dal sistema usato: uno molto comune è il codice esadecimale 26.

L’esecuzione del programma non produce alcuna uscita sullo schermo, e infatti la lettura del file andrà eseguita con un programma specifico.

Osservazione. Le due istruzioni

out_file = fopen("prezzi.dat","w"); if(out_file == NULL)

possono essere sostituite dall’unica istruzione

if((out_file = fopen("prezzi.dat","w")) == NULL)

Lettura. L’apertura di un file per lettura richiama un file esistente e ne rende i dati disponibili come ingresso per il programma.

Ad es., l’istruzione di apertura:

in_file = fopen(“prezzi.dat”, “r”);

apre il file prezzi.dat e rende i suoi dati disponibili per l’ingresso. All’interno della funzione che apre il file, esso è letto usando il nome di puntatore in_file.

Se un file aperto per lettura non esiste, fopen() restituisce il valore di indirizzo NULL. Esso può essere usato per controllare se sia stato aperto un file esistente.

Osservazione. Nelle precedenti istruzioni di apertura sia il nome di file esterno, sia gli argomenti relativi al modo passati a fopen() erano stringhe racchiuse tra doppi apici.

Se il nome di file esterno è dapprima memorizzato in un vettore di caratteri o come una stringa, si può usare il nome di vettore o la stringa, senza apici, come primo argomento per fopen().

Apertura. Il programma seguente illustra:

• le istruzioni necessarie per aprire un file in modo lettura: chiede all’utente il nome di un file dati esterno e lo memorizza nel vettore di caratteri nome_f; passa quindi questo nome di vettore alla funzione fopen().

• l’uso del valore restituito da fopen() per controllare la corretta apertura del file: l’utente viene avvertito se il nome file esterno non esiste.

#include <stdio.h>void main(void){ FILE *in_file; char nomefile[12]; printf("\nScrivi il nome del file da leggere: "); gets(nomefile); /* oppure: scanf(“%s”, nomefile); */ in_file = fopen(nomefile, "r"); /* apre il file */ if (in_file == NULL) { printf("\nIl file non può essere aperto."); printf("\nControlla che il file esista."); exit(1); } printf("\nIl file è stato aperto per la lettura");}

Ecco un esempio della sua esecuzione:

Scrivi un nome di file: pippo

Il file non può essere aperto.Controlla che il file esista.

Osservazione. Anche adesso le istruzioni per aprire il file e assegnare l’indirizzo restituito possono essere inserite direttamente nell’istruzione if, sostituendo le due linee

in_file = fopen(nomefile, "r");if (in_file == NULL)

con l’unica espressione

if ((in_file = fopen(nomefile, “r”)) == NULL)

Il programma precedente non contiene ancora le istruzioni necessarie per leggere i dati nel file e per chiuderlo.

Funzioni di lettura (fgetc(), fgets(), fscanf()). La lettura dei dati da un file è quasi identica a quella da una tastiera standard, con l’aggiunta del nome-di-file per indicare la loro provenienza.

Le funzioni disponibili per leggere i dati da un file sono simili alle funzioni getchar(), gets(), scanf() usate per l’ingresso dei dati da tastiera, e sono indicate in tabella.

Ad es., se in_file è il nome interno di un puntatore a un file aperto in modo lettura, per leggere dati dal file si possono usare le seguenti espressioni:

Tutte le funzioni di ingresso rilevano correttamente il marcatore di fine-file; tuttavia, quando esso viene rilevato,

le funzioni fgetc() e fscanf() restituiscono la costante di nome EOF;

la funzione fgets() restituisce il carattere NULL (\0).

Entrambe le costanti EOF e NULL sono sentinelle utili per rilevare la fine di un file che viene letto, a seconda della funzione usata.

fgetc(in_file);/* legge il prossimo carattere nel file */

fscanf(in_file, “%f”, &prezzo);/* legge un numero in virgola mobile */

fgets(messaggio, 10, in_file);/*legge i 9 caratteri successivi dal file in messaggio*/

Uso di fgetc(). Come esempio di uso di fgetc(), scriviamo un programma che visualizzi i codici ASCII dei caratteri memorizzati nel file prezzi.dat. Per visualizzare i codici in formato esadecimale usiamo la sequenza di controllo di conversione %x.

#include <stdio.h>void main(void){ char var; FILE *in_file; if((in_file = fopen("prezzi.dat", "r")) == NULL) { printf("\nErrore nell'apertura del file.\n"); exit(1); } do { var = fgetc(in_file); printf("%x %c", var, ' '); } while (var != EOF); fclose(in_file);}

Esercizio. Modificare il programma precedente, in modo che chieda il nome del file da leggere e ne visualizzi i caratteri.

Ecco una possibile risposta.

#include <stdio.h>void main(void){ char var, nomefile[12]; FILE *in_file; printf(“Scrivi il nome del file da leggere”); scanf(“%s”, nomefile); /* oppure: gets(nomefile); */ if((in_file = fopen(nomefile, "r")) == NULL) { printf("\nErrore nell'apertura del file.\n"); exit(1); } do { var = fgetc(in_file); printf("%c", var); } while (var != EOF); fclose(in_file);}

Se invece si vogliono leggere tutti i caratteri presenti in un file, compresi quelli privi di “significato”, occorre leggere il file in modalità binaria.

Il programma seguente legge in modalità binaria il file salve.doc, contenente la frase “Salve a tutti” e creato con Microsoft Word, di dimensione 24 kbyte.

#include <stdio.h>void main(void){ char var; int i; FILE *in_file; if((in_file = fopen("salve.doc","rb")) == NULL) { printf("\nErrore nell'apertura del file.\n"); exit(1); } for(i = 0; i < 24000; i++) { var = fgetc(in_file); printf("%c", var); } fclose(in_file);}

Uso di fscanf(). La lettura dei dati tramite fscanf() richiede che si conosca il formato in cui essi sono memorizzati nel file (esattamente come succedeva con scanf()). Ciò per una corretta “strisciatura” dei dati dal file in variabili adatte per la memorizzazione.

Tutti i file sono letti in modo sequenziale, cosicché, una volta letta una voce, la successiva nel file diventa disponibile per la lettura.

Il programma seguente illustra la lettura del file prezzi.dat tramite fscanf(): si osservi l’uso del marcatore EOF, che viene restituito da fscanf() quando s’incontra la fine del file.

#include <stdio.h>void main(void){ char descriz[10]; float prezzi; FILE *in_file; if((in_file = fopen("prezzi.dat","r")) == NULL) { printf("\nErrore nell’apertura del file.\n"); exit(1); } while (fscanf(in_file,"%s %f",descriz, &prezzi) != EOF) printf("%-9s %5.2f\n",descriz, prezzi); fclose(in_file);}

Lettura con fscanf()

Il programma continua a leggere il file fino a che s’incontra il marcatore EOF.

Ogni volta che si legge il file, sono immessi nel programma una stringa e un numero in virgola mobile.

Ecco la visualizzazione prodotta:

Uso di fgets(). In luogo della funzione fscanf() si può usare la funzione fgets(), che richiede tre argomenti:

l’indirizzo dove sarà memorizzato il primo carattere letto; il numero massimo di caratteri da leggere; il nome del file d’ingresso.

Batterie 39.95Bulbi 3.22Fusibili 1.03

Ad es., la chiamata di funzione:

fgets(linea, 81, in_file);

determina la lettura di un massimo di 80 caratteri (1 in meno del numero indicato) dal file in_file e la loro memorizzazione a partire dall’indirizzo contenuto nel puntatore di nome linea.

fgets() continua a leggere i caratteri fino a che

• ne sono stati letti 80, oppure • s’incontra un carattere di linea nuova (\n).

Nel secondo caso, il carattere viene incluso con gli altri caratteri immessi prima che la stringa sia terminata con il marcatore di fine-stringa \0.

Anche fgets() rileva il marcatore di fine-file, ma quando lo incontra restituisce il carattere NULL.

Il programma seguente illustra l’uso di fgets() in un programma effettivo.

#include <stdio.h>void main(void){ char linea[81];

FILE *in_file; if((in_file = fopen("prezzi.dat", "r")) == NULL) { printf("\nImpossibile aprire il file.\n"); exit(1); } while (fgets(linea, 81, in_file) != NULL) printf("%s", linea);

fclose(in_file);}

Lettura con fgets()

Questo programma di lettura è in realtà un programma di copia di un testo linea per linea, che legge una linea di testo dal file e la visualizza sullo schermo. Perciò la sua uscita è identica a quella del programma di lettura con fscanf().

Però, a differenza di esso, non usa le variabili individuali descrizione e prezzo per memorizzare i valori.

Se ciò fosse necessario, si dovrebbe elaborare ulteriormente la stringa restituita da fgets() tramite la funzione di scansione di stringa, scanf().

Per estrarre la descrizione e il prezzo dalla stringa memorizzata nel vettore di caratteri linea si potrebbe, ad es., aggiungere l’istruzione

scanf(linea, “%s %f”, descriz, &prezzo);

Ciò, naturalmente, dopo la dichiarazione delle variabili descriz e prezzo:

char descriz[10]; float prezzo;

File standard di dispositivo (stdin, stdout). I puntatori a file di dati che abbiamo usato erano tutti puntatori a file logici.

Un puntatore a un file logico fa riferimento a un file o a un dato collegato che è stato salvato sotto un nome comune; cioè “punta a” un file di dati.

In aggiunta ai puntatori a file logici, i C supporta anche puntatori a file fisici.

Un puntatore a un file fisico “punta a” un dispositivo hardware quale la tastiera, lo schermo o una stampante.

L’effettivo dispositivo fisico assegnato a un programma per l’ingresso dei dati è detto formalmente file d’ingresso standard, ed è di solito la tastiera.

Quando in un programma C s’incontra una chiamata alla funzione scanf(), il computer va automaticamente a questo file d’ingresso standard per l’ingresso atteso.

Analogamente, quando s’incontra una chiamata alla funzione printf(), l’uscita è automaticamente visualizzata o “scritta su” un dispositivo che è stato assegnato come file standard di uscita, in genere lo schermo (ma talvolta una stampante).

Quando si esegue un programma, la tastiera usata per l’ingresso dei dati è automaticamente aperta e assegnata al puntatore di file interno di nome stdin.

Analogamente, il dispositivo di uscita usato per visualizzare è assegnato al puntatore di file di nome stdout. Questi puntatori di file sono sempre disponibili per l’uso del programmatore.

Le somiglianze tra printf() e fprintf(), e tra scanf() e fscanf() non sono accidentali:

•printf() è un caso speciale di fprintf() che ha come default il file di uscita standard, mentre

•scanf() è un caso speciale di fscanf() che ha come default il file d’ingresso standard.

Così, si ottiene la stessa visualizzazione con le due espressioni:

fprintf(stdout, “Salve a tutti”);e

printf(“Salve a tuti”);

come pure sono tra loro equivalenti le espressioni:

fscanf(stdin, “%d”, &num);e

scanf(“%d”, &num);

Puntatore di file (stderr). Oltre ai puntatori di file stdin e stdout, esiste un terzo puntatore, di nome stderr, assegnato al dispositivo di uscita usato per i messaggi di sistema.

Sebbene stderr e stdout si riferiscano frequentemente allo stesso dispositivo, l’uso di stderr fornisce un mezzo per reindirizzare qualsiasi messaggio di errore dal file usato per la normale uscita del programma.

Proprio come printf() e scanf() sono casi speciali rispettivamente di fprintf() e fscanf(), anche le funzioni getchar() e gets(), putchar() e puts() sono casi speciali delle funzioni più generali elencate in tabella.

Le coppie di funzioni di carattere sulla stessa riga (evidenziate in verde) possono essere usate in modo intercambiabile le une con le altre.

Ciò non è vero per le funzioni che manipolano le stringhe (evidenziate in rosa), per le seguenti ragioni.

Confronto tra fgets()/gets(). . .

In fase d’ingresso, come osservato, la funzione fgets() legge i dati da un file fino a una sequenza di escape di linea nuova (\n), o fino a che sia stato letto uno specificato numero di caratteri.

Come sappiamo, la funzione gets()non memorizza nella stringa finale la sequenza di escape di linea nuova (\n) (dato che la traduce in un carattere NULL (\0)).

Invece, come abbiamo visto nel programma di lettura con fgets(),

se fgets() incontra una sequenza di escape di linea nuova(\n) la memorizza insieme agli altri caratteri immessi.

Entrambe le funzioni terminano i caratteri immessi con un carattere NULL di fine-stringa.

. . . e puts()/fputs()

In fase di uscita, sia puts() sia fputs() scrivono tutti i caratteri nella stringa, tranne il carattere terminale di fine-stringa NULL.

Come sappiamo, la funzione puts() aggiunge automaticamente una sequenza di escape di linea nuova (\n) alla fine dei caratteri trasmessi.

Invece

fputs() non aggiunge la sequenza \nalla fine dei caratteri trasmessi.

Scrittura di un file da tastiera (feof()). Mentre il precedente programma di scrittura scriveva in un file i dati contenuti nel programma stesso, di solito i dati vengono forniti in modo interattivo da tastiera.

Il programma seguente crea il file ad accesso sequenziale cliente.dat relativo alla situazione contabile dei clienti di una banca, nel quale memorizza i dati relativi a numero di conto, nome e saldo di ciascun cliente, immessi da tastiera.

Per terminare l’immissione dei dati si deve immettere il carattere di fine-file (^Z in ambiente Windows).

I dati di ogni cliente costituiscono il suo “record”, mentre il numero di conto costituisce la “chiave” del record, ossia il campo rispetto al quale il file viene ordinato.

#include <stdio.h>int main(){ int conto; char nome[30]; float saldo; FILE *out_file; if((out_file = fopen("cliente.dat","w")) == NULL) printf("Impossibile aprire il file\n"); else { printf("Scrivi conto, nome, saldo (^Z per teminare).\n"); scanf("%d %s %f", &conto, nome, &saldo); while(!feof(stdin)) { fprintf(out_file, "%d %s %f\n", conto, nome, saldo); scanf("%d %s %f", &conto, nome, &saldo); } fclose(out_file); } return(0);}

Il programma contiene l’espressione

while(!feof(stdin))

che determina l’elaborazione di un nuovo record se in precedenza non è stato immesso da tastiera il carattere di fine-file.

Per determinare la presenza del carattere di fine-file nel file al quale punta stdin (ossia la tastiera), si è usata la funzione feof(). Essa ha come argomento il puntatore al file nel quale si vuole esaminare la presenza dell’indicatore di fine-file (come detto, il file è stdin, ossia la tastiera).

La funzione feof() restituisce un valore diverso da 0 (vero) quando rileva nel file la presenza dell’indicatore di fine-file, altrimenti restituisce 0.

Lettura del file immesso da tastiera. Se eseguiamo il programma precedente, possiamo verificare che i record siano stati memorizzati correttamente nel file eseguendo il programma seguente, che legge il file cliente.dat e ne visualizza il contenuto.

#include <stdio.h>int main(){ int conto; char nome[30]; float saldo; FILE *out_file; if((out_file = fopen("cliente.dat", "r")) == NULL) printf("Il file non può essere letto\n"); else { printf("%-10s %-16s %-12s\n", "Conto", "Nome", "Saldo"); fscanf(out_file, "%d %s %f", &conto, nome, &saldo); while(!feof(out_file)) { printf("%-10d %-13s %7.2f\n", conto, nome, saldo); fscanf(out_file, "%d %s %f", &conto, nome, &saldo); } fclose(out_file); } return(0);}

File offset. La struttura FILE, associata a ogni file, ha tra i suoi membri il puntatore di posizione del file, detto anche file offset. Esso non è un puntatore vero e proprio, ma un numero intero che specifica la posizione del byte in corrispondenza del quale sarà eseguita la prossima lettura o scrittura.

Il file offset viene utilizzato dalle funzioni di biblioteca standard rewind(), fseek() e ftell().

Funzione rewind(). Di solito, per recuperare in modo sequenziale i dati di un file, un programma incomincia dal suo inizio e legge tutti i dati in modo consecutivo, finché non siano stati trovati quelli desiderati.

Durante l’esecuzione di un programma potrebbe essere necessario rielaborare più volte in modo sequenziale i dati di un file ripartendo dal suo inizio. A tale scopo si usa una istruzione del tipo

rewind(in_file);

che riposiziona all’inizio (ossia al byte 0) del file puntato da in_file il puntatore di posizione del file. In tal modo il prossimo carattere a cui si avrà accesso sarà il primo nel file.

Quando si apre un file in modo lettura, viene eseguita automaticamente una rewind().

Il programma seguente usa rewind() per trovare nel file cliente.dat e visualizzare sullo schermo i record nei quali il saldo sia zero o positivo, a seconda della scelta (1 o 2) dell’utente.

#include <stdio.h>int main(){ int scelta, conto; float saldo; char nome[30]; FILE *in_file; if((in_file=fopen("cliente.dat", "r")) == NULL) printf("Il file non può essere letto\n"); else { printf("Scegli una richiesta\n1 - Elenca i conti con saldo 0\n2 - Elenca i conti con saldo positivo\n3 - Fine del programma\n? "); scanf(“%d", &scelta); while(scelta != 3) { fscanf(in_file, "%d %s %f", &conto, nome, &saldo); switch(scelta) { case 1: printf("Conti con saldo zero:\n"); while(!feof(in_file)) {

if(saldo == 0) printf("%-10d %-13s %7.2f\n", conto, nome, saldo); fscanf(in_file, "%d %s %f", &conto, nome, &saldo); } break; case 2: printf("Conti con saldo positivo:\n"); while(!feof(in_file)) { if(saldo > 0) printf("%-10d %-13s %7.2f\n", conto, nome, saldo); fscanf(in_file, "%d %s %f", &conto, nome, &saldo); } break; } rewind(in_file); printf("\n? "); scanf("%d", &scelta); } printf("Fine del programma.\n"); fclose(in_file); } return(0);}

Funzione fseek(). La funzione fseek()

consente di muoversi in qualsiasi posizione nel file.

Per comprenderne il funzionamento, ricordiamo come avviene il riferimento ai dati in un file.

Ogni carattere in un file dati è localizzato tramite la sua posizione nel file: il primo nella posizione 0, il secondo nella posizione 1 e così via.

La posizione di un carattere è detta anche il suo offset dall’inizio del file. Così, il primo carattere ha offset 0, il secondo offset 1 e così via.

La funzione fseek() richiede 3 argomenti:

il nome puntatore del file; l’offset, in forma di intero lungo; la posizione a partire dalla quale va calcolato l’offset.

La forma generale di fseek() è la seguente:

fseek(nome-di-file, offset, origine)

Un offset positivo fa muovere in avanti nel file; uno negativo fa muovere indietro.

Ecco alcuni esempi di fseek() (nei quali in_file è il nome del puntatore di file usato quando il file dati è stato aperto):

I valori dell’argomento origine possono essere 0, 1 o 2, che sono definiti in stdio.h come le costanti di nomi rispettivamente SEEK_SET, SEEK_CUR e SEEK_END.

Funzione ftell(). La funzione ftell()

restituisce il valore di offset del prossimocarattere che sarà letto o scritto.

Ad es., se sono stati già letti 10 caratteri dal file in_file, la chiamata di funzione

ftell(in_file);

restituisce l’intero lungo 10. Ciò significa che il prossimo carattere che sarà letto è alla posizione 10 byte di offset dall’inizio del file, ossia è l’11° carattere del file.

Anche il prototipo di ftell() è contenuto in stdio.h.

Il programma seguente mostra l’uso congiunto di fseek() e ftell() per leggere un file in ordine inverso dall’ultimo carattere al primo, e visualizza ogni carattere letto.

#include <stdio.h>void main(void){ int ch, n; long int offset, ult, ftell(); FILE *in_file; if((in_file = fopen(“prezzi.dat","r")) == NULL) { printf("\nErrore nell’aprire il file prezzi.dat.\n"); exit(1); } fseek(in_file, 0L, SEEK_END); ult = ftell(in_file); /* salva l’offset dell’ultimo caratt. */ for(offset = 0; offset <= ult; ++offset) { fseek(in_file, -offset, SEEK_END); /* va al caratt. preced. */ ch = getc(in_file); /* riceve il carattere */ switch(ch) { case '\n': printf("LF : "); break; case EOF : printf("EOF: "); break; default : printf("%c : ",ch); break; } } fclose(in_file);}

Questo programma va inizialmente all’ultimo carattere nel file, che è quello di fine-file, e salva il suo offset nella variabile ult (dato che ftell() restituisce un intero lungo, ult è stata dichiarata come intero lungo).

A partire dalla fine del file, si usa fseek() per posizionare il prossimo crattere da leggere, con riferimento alla fine del file.

Via via che ogni carattere è letto, esso è visualizzato e l’offset modificato in modo da accedere al prosimo carattere.

File ad accesso casuale

Con organizzazione di un file s’intende il modo con cui i dati vi sono memorizzati.

Tutti i file usati finora avevano una organizzazione sequenziale, nel senso che i caratteri erano memorizzati sequenzialmente, uno dopo l’altro. Inoltre, abbiamo anche letto il file in modo sequenziale.

Il modo in cui si accede ai dati di un file è detto accesso al file.

Tuttavia, il fatto che i dati in un file siano memorizzati in modo sequenziale non ci costringe anche ad accedere al file in modo sequenziale.

Nell’accesso casuale ogni carattere nel file può essere letto immediatamente, senza che sia necessario leggere prima tutti i caratteri precedenti.

I record di un file creati con l’uscita formattata della funzione fprintf() non hanno tutti necessariamente la stessa lunghezza.

Invece tutti i record di un file ad accesso casuale hanno la stessa lunghezza, cosicché la posizione ciascuno di essi, relativamente all’inizio del file, può essere calcolata con una funzione della chiave del record.

Ciò consente di accedere a ogni record in modo diretto (e quindi più velocemente) senza passare attraverso i precedenti.

Per questa ragione i file ad accesso casuale sono particolarmente appropriati per i sistemi per l’elaborazione di transazioni che richiedano un accesso rapido a dati specifici.

La figura seguente illustra un modo di implementare un file ad accesso casuale: un file di questo tipo è come un treno merci con molti vagoni, alcuni vuoti e altri con un carico, ognuno dei quali ha la stessa lunghezza.

In un file ad accesso casuale i nuovi dati possono essere inseriti senza distruggere quelli già immagazzinati; questi ultimi possono anche essere aggiornati o eliminati, senza che si debba riscrivere l’intero file.

Creazione di un file ad accesso casuale (fwrite())

La funzione fwrite() scrive in un file un numero specificato di byte, a partire da quello indicato dal puntatore di posizione del file.

La funzione fread() trasferisce un numero specificato di byte dalla posizione indicata dal file offset a un’area di memoria che comincia a un indirizzo specificato.

A questo punto, per scrivere un intero, invece di usare

fprintf(in_file, “%d”, numero);

che può stampare da un minimo di 1 a un massimo di 11 caratteri (10 cifre più il segno), ognuno dei quali richiede un byte di memoria, per un intero di 4 byte possiamo usare:

fwrite(&numero, sizeof(int), 1, in_file);

che scrive in ogni caso 4 byte* dalla variabile numero al file puntato da in_file. In seguito useremo fread() per leggere 4 di quei byte nella variabile intera numero.

*o 2, su sistemi con interi di 2 byte

Se, da una parte, fread() e fwrite() leggono e scrivono dei dati come gli interi in un formato con dimensione fissa, anziché variabile, dall’altro i dati che esse gestiscono sono elaborati nel formato “dati grezzi”, ossia in byte di dati, anziché nel formato umanamente intelligibile di printf() e scanf().

Le funzioni fwrite() e fread() sono in grado di leggere e scrivere su disco interi vettori di dati; in effetti il loro terzo argomento è appunto il numero di elementi del vettore che dovranno essere letti dal disco, o che vi dovranno essere scritti.

La precedente chiamata della funzione fwrite() scrive su disco un singolo intero, dato che il terzo argomento è 1 (come per scrivere un solo elemento di un vettore).

Di solito i programmi per l’elaborazione dei file non scrivono un solo campo all’interno di un file, ma una intera struttura per volta, come mostrato nell’esempio che segue.

Esempio. Vogliamo creare un sistema in grado di memorizzare fino a 100 record di lunghezza fissa; ognuno dovrà consistere in:

• un numero (intero) di conto, che sarà usato come chiave del record

• un cognome• un nome• un saldo.

Dovremo scrivere tre distinti programmi, in grado rispettivamente di:

1.creare il file dove saranno memorizzati i vari record

2.aggungere un record nuovo, aggiornarne o cancellarne uno esistente

3.elencare tutti i record in un file di testo formattato per la visualizzazione.

Il programma seguente mostra come:

• aprire un file ad accesso casuale• definire un formato di record usando una struttura,• scrivere i dati sul disco e• chiudere il file.

Esso inizializza i 100 record del file credito.dat con una struttura vuota usando la funzione fwrite(). Ogni struttura vuota contiene 0 per il numero di conto, una “” (stringa vuota) per il cognome e una per il nome, e 0 per il saldo.

Il file viene inizializzato in questo modo per creare sul disco lo spazio nel quale sarà memorizzato, e per consentire di determinare se un record contenga dei dati.

#include <stdio.h>struct Dati_cli{ int num_conto; char cognome[15]; char nome[10]; int saldo;};int main(){ int i; struct Dati_cli vuoto = {0, "", "", 0.0}; FILE *out_file; if((out_file = fopen("credito.dat", "wb")) == NULL) { printf("Impossibile creare il file.\n"); close(1); } else { for(i=1; i<=100; i++) fwrite(&vuoto, sizeof(struct Dati_cli), 1, out_file); fclose(out_file); } return(0);}

Scrittura di un file ad accesso casuale

Il seguente programma consente di scrivere e di modificare dei record nel file ad accesso casuale credito.dat appena creato.

#include <stdio.h>struct Dati_cli{ int num_conto; char cognome[15]; char nome[10]; int saldo;};int main(){ struct Dati_cli cliente = {0, "", "", 0.0}; FILE *out_file; if((out_file = fopen("credito.dat", "rb+")) == NULL) { printf("Impossibile aprire il file.\n"); close(1); } else { printf("Scrivi un n° di conto (da 1 a 100, 0 per finire)\n? "); scanf("%d", &cliente.num_conto); while(cliente.num_conto != 0) { printf("Scrivi Cognome, Nome, saldo\n? "); fscanf(stdin, "%s%s%d", cliente.cognome, cliente.nome, &cliente.saldo); fseek(out_file,(cliente.num_conto-1)*sizeof(struct Dati_cli),SEEK_SET); fwrite(&cliente, sizeof(struct Dati_cli), 1, out_file); printf("Scrivi un n° di conto (0 per finire)\n? "); scanf("%d", &cliente.num_conto); } fclose(out_file); } return(0);}

Lettura di un file ad accesso casuale

Il seguente programma consente di leggere i record memorizzati nel file ad accesso casuale credito.dat appena creato.

#include <stdio.h>struct Dati_cli{ int num_conto; char cognome[15]; char nome[10]; int saldo;};int main(){ struct Dati_cli cliente = {0, "", "", 0.0}; FILE *out_file; if((out_file = fopen("credito.dat", "rb")) == NULL) { printf("Impossibile aprire il file.\n"); close(1); } else { printf("%-6s %-16s %-11s %10s \n", "Conto","Cognome","Nome","Saldo"); while(!feof(out_file)) { fread(&cliente, sizeof(struct Dati_cli), 1, out_file); if(cliente.num_conto != 0) { printf("%-6d %-16s %-11s %10d \n",cliente.num_conto,cliente.cognome, cliente.nome, cliente.saldo); } } fclose(out_file); } return(0);}