ARCHIVI E FILE. Prof. Ciaschetti

Transcript

1 ISTITUTO DI ISTRUZIONE SUPERIORE ANGIOJ ARCHIVI E FILE Prof. Ciaschetti Un archivio è un insieme di registrazioni (record) memorizzate in modo persistente, cioè resta memorizzato permanentemente, anche in assenza di energia. Sono archivi, ad esempio: - una rubrica telefonica: ogni nominativo corrisponde a una registrazione, e per ogni registrazione possiamo avere il nome, il numero di telefono di casa, il numero di cellulare, ecc. - il registro di classe: ogni registrazione è un giorno che riposta le materie, le firme dei docenti, gli assenti, le giustificazioni, le note - l archivio dei clienti di un azienda: per ogni cliente, si possono avere il nominativo, la partita iva, l indirizzo, ecc. - l archivio degli utenti registrati a un sito web: ogni registrazione in questo caso memorizza il nome utente e la password. La caratteristica principale di un archivio è che le diverse registrazioni hanno tutte la stessa struttura. Ogni archivio è memorizzato su di un supporto che ne garantisce la persistenza. Il supporto su cui è memorizzato un archivio può essere di diverso tipo: nel caso del registro di classe, è di tipo cartaceo; la rubrica telefonica può essere memorizzata in forma cartacea, oppure in forma elettronica (come sul cellulare), ecc. Un archivio memorizzato in modo elettronico è realizzato tramite file. Un file è una sequenza di bit memorizzata in modo persistente su memoria di massa (Es. hard disk, floppy disk, pen drive, cd, dvd, microsd, ecc.). Un file non è sempre un archivio. Ad esempio, un file.cpp è un file in cui è scritto un programma in C/C++, un file.exe è un file eseguibile, un file.doc è un documento word, ecc, e nessuno di questi è un archivio. In generale, ogni archivio elettronico è anche un file, ma non è vero il viceversa, ci sono file che non sono archivi. Ci sono due tipi di file: file di testo e file binari. I file di testo sono leggibili dall uomo, mentre i file binari non lo sono. Il motivo di questa differenza sta nel fatto che i file di testo vengono scritti e letti utilizzando la codifica ASCII (un byte per ogni carattere, ricordate?), mentre nei file binari i dati vengono scritti così come sono all interno della RAM. Facciamo un esempio: Supponiamo di avere una variabile intera su 2 byte alla quale diamo il valore 125: short int N; N = 125;

2 In RAM, nei due byte riservati per la variabile N, avremo la rappresentazione binaria del numero 125, ossia Quando andiamo a memorizzare N su un file di testo, il numero sarà formattato in modo che l uomo possa leggerlo, cioè verrà trasformato nei seguenti tre byte che rappresentano il numero 125: rappresentazione ASCII del carattere rappresentazione ASCII del carattere rappresentazione ASCII del carattere 5 Se invece andiamo a memorizzare N su un file binario, il numero sarà scritto sul file così com è nella RAM, occupando solo 2 byte. Supponiamo ora di avere un altra variabile dello stesso tipo, a cui diamo il valore 8: short int M; M = 8; In RAM, nei due byte riservati per la variabile M, avremo la rappresentazione binaria del numero 8, ossia Se memorizziamo N su un file di testo, il numero sarà formattato in modo che l uomo possa leggerlo, cioè verrà trasformato in un solo byte: rappresentazione ASCII del carattere 8 Se invece memorizziamo M su un file binario, il numero sarà scritto sul file così com è nella RAM, occupando 2 byte. Dall esempio precedente notiamo che nei file binari, dati di uno stesso tipo occupano sempre la stessa dimensione (2 byte, nel caso del tipo short int dell esempio), mentre nei file di testo la loro dimensione dipende da quanti caratteri servono nella loro rappresentazione leggibile per l uomo (3 byte nel caso di 125, 1 byte nel caso di 8). Lo stesso vale per i record: nei file binari un record occupa sempre la stessa dimensione, che è lo spazio che serve in RAM per memorizzare il record, mentre nei file di testo la dimensione del record non è sempre la stessa, ma dipende dai dati che esso contiene. Come è possibile riconoscere un file binario da un file di testo? In generale, non esiste un modo, dipende da come il file è stato scritto. Tuttavia, se proviamo ad aprire il file con un qualsiasi editor di testo (ad esempio il blocco note), notiamo che il file di testo possiamo leggerlo, perché è stato formattato per l uomo al momento della sua scrittura, mentre nel file binario leggiamo solo tanti caratteri strani, perché l editor di testo proverà comunque a interpretare la sequenza di bit come una sequenza di caratteri in codifica ASCII, ma non è detto che significhino qualcosa. In generale, i file di testo hanno estensione.txt, ma possono anche avere diverse estensioni, come ad esempio.cpp (file di testo per programmi in linguaggio C),.pas (file di testo per programmi in linguaggio Pascal),.htm (file di testo per pagine web),.ini (file di testo con le impostazioni iniziali di un programma), tranne quelle riservate a particolari file binari, come ad esempio.exe (programma eseguibile),.com o.bat (file di comandi per il sistema operativo),.lib o.dll (file di librerie di programmi). Anche i file binari possono avere qualunque estensione, tranne.txt che è riservata ai file di testo. 2

3 Tornando a parlare di archivi, una caratteristica importante che distingue gli archivi è la modalità di accesso, che può essere: - accesso sequenziale - accesso casuale o diretto Per accesso sequenziale si intende che si accede all inizio dell archivio, e poi bisogna scorrerlo in avanti per arrivare all informazione desiderata, un po come il nastro di una videocassetta. Per accesso casuale, invece, si intende la possibilità di accedere direttamente all informazione desiderata, come succede ad esempio nei lettori cd, dove possiamo scegliere il numero della traccia e sentire direttamente quella, senza dover scorrere prima tutte le tracce precedenti. I file di testo sono sempre ad accesso sequenziale, mentre i file binari permettono l accesso casuale. La motivazione sta nel fatto che mentre nei file binari sappiamo che il numero di byte di una registrazione è sempre lo stesso, nei file di testo questo non è possibile. Facciamo un esempio: Supponiamo che ogni registrazione rappresenti un punto del piano cartesiano, con due campi che indicano la coordinata x e la coordinata y del punto. La struttura che definisce il record potrebbe essere la seguente: struct punto { float x; float y; }; typedef struct punto point; Supponiamo ora di voler creare un archivio con i seguenti punti: point punto1, punto2, punto3; punto1.x = 3.534; punto1.y = 2.34; punto2.x = 7.235; punto2.y = 4.1; punto3.x = ; punto3.y = 3.877; utilizzando un file binario, andremo a rappresentare i dati esattamente nella loro forma binaria, e cioè, essendo il tipo di dato float su 4 byte, avremo 8 byte per il primo punto (4 per la coordinata x, 4 per la coordinata y), 8 byte per il secondo punto e 8 byte per il terzo punto. Complessivamente, il nostro file avrà una dimensione pari a 24 byte. Potremmo, ad esempio, effettuare un accesso diretto al terzo record dicendo semplicemente salta in avanti di 2 volte la dimensione di un record. Se invece utilizziamo un file di testo per memorizzare il nostro archivio, il primo punto richiederà complessivamente 9 byte, 5 byte per la coordinata x (i caratteri 3,., 5, 3 e 4 ) e 4 byte per la coordinata y (i caratteri 2,., 3, 4 ). Analogamente, il secondo record richiederà 8 byte e il terzo record 12 byte. Non conoscendo a priori la dimensione di ogni record, non sappiamo dire di quanto occorre saltare in avanti per posizionarsi sul terzo record. 3

4 E meglio usare archivi ad accesso sequenziale o archivi ad accesso diretto? La risposta dipende dal tipo di operazioni che devono essere eseguite sull archivio. Se l archivio ci serve solo per fare un backup dei dati, che poi difficilmente andremo a rileggere, può andare benissimo un archivio ad accesso sequenziale (ed infatti, per questo tipo di archivi sono spesso usati file di testo). Se invece occorre effettuare spesso operazioni di lettura di dati dall archivio, e in modo disordinato (cioè non sequenziale), conviene utilizzare un archivio ad accesso diretto per evitare di aspettare ogni volta che vengano letti tutti i record che precedono quello che ci interessa. Per evitare accessi multipli in scrittura su un file, che potrebbero causare effetti indesiderati (si pensi a due programmi che cerchino di scrivere contemporaneamente la stringa ciao e la stringa pippo su uno stesso file: si potrebbe avere come effetto, ad esempio, la scrittura della stringa cpipiaopo completamente priva di significato), si ricorre a un meccanismo semaforico di apertura e chiusura del file. Questo meccanismo prevede di aprire il file prima di compiere su di esso le operazioni di lettura/scrittura, e poi chiuderlo alla fine. Quando un file è aperto in scrittura da un processo, nessun altro processo può accedere al file per scriverci sopra, fino a quando esso non sarà stato chiuso. In lettura, invece, non ci sono problemi. Istruzioni del linguaggio C per lavorare con i file Per lavorare con un file in C occorre innanzitutto dichiarare una variabile di tipo puntatore a file, come ad esempio FILE *fp; Nella variabile fp verrà memorizzato l indirizzo del file (in questo caso non si tratta di un indirizzo nella memoria RAM, ma su memoria di massa, quindi costituito da numero di cilindro, traccia e settore del dispositivo magnetico o ottico di memorizzazione) al momento della sua apertura. APERTURA E CHIUSURA DEL FILE Per aprire un file, si utilizza l istruzione fopen: fopen("nomefile.estensione","modalita"); Apre un file. Restituisce l indirizzo del file, oppure NULL se il file non è stato trovato. Modalità: r = lettura, w = scrittura, a = append, r+ = lettura/scrittura. La modalità w riscrive il file da capo, e ne crea uno nuovo nel caso in cui non esiste. La modalità a continua a scrivere un file mantenendo il suo contenuto precedente, e crea un nuovo file nel caso in cui non esiste. La modalità r+ riscrive il file da capo, e ne crea uno nuovo nel caso in cui non esiste. FILE *fp; /* dichiarazione della variabile puntatore a file fp */ fp = fopen("pippo.txt","r"); /* apre il file in modalità lettura e salva in fp l indirizzo del file */ 4

5 fp = fopen("videoteca.dat","w"); /* apre il file in modalità scrittura e salva in fp l indirizzo del file */ Al momento dell apertura di un file la testina di lettura/scrittura si posiziona all inizio del file, e scorre in avanti, ad ogni operazione di lettura/scrittura, di tanti byte quanti sono quelli letti o scritti. Per chiudere un file, dopo che ci si è lavorato, si usa l istruzione fclose: fclose(indirizzo del file); Chiude un file precedentemente aperto. Se il file non era stato aperto, dà errore. fclose(fp); /* fp puntatore a file già aperto in precedenza */ LETTURA E SCRITTURA SU FILE DI TESTO Ci sono due istruzioni per leggere e due istruzioni per scrivere su file di testo. Due di queste si riferiscono alla lettura e scrittura di un carattere per volta (getc e putc), mentre le altre due si riferiscono alla lettura e scrittura formattata di un qualsiasi dato (fscanf e fprintf). Tutte e quattro queste istruzioni non si riferiscono direttamente al nome del file, ma al suo indirizzo, che è stato salvato al momento dell apertura nella variabile di tipo puntatore a file (che supponiamo si chiami fp in quanto segue). ISTRUZIONI PER LEGGERE E SCRIVERE UN SINGOLO CARATTERE Per leggere un carattere da file di testo si usa l istruzione getc: getc(indirizzo del file) Legge i prossimi 8 bit da file di testo. Restituisce il carattere letto, oppure EOF se alla fine del file. char ch; /* variabile di tipo carattere */ ch = getc(fp); /* assegna a ch il carattere letto da file */ printf( %c, getc(fp)) /* visualizza il carattere letto dal file */ 5

6 Per scrivere un carattere su file di testo si usa l istruzione putc: putc(carattere, indirizzo del file) Scrive il carattere su file di testo. E di tipo void. putc( W, fp); /* scrive il carattere W sul file */ char ch = A ; /* variabile di tipo carattere */ putc(ch, fp); /* scrive il carattere ch su file */ ISTRUZIONI PER LEGGERE E SCRIVERE UN QUALSIASI DATO Per leggere un qualsiasi dato da file di testo si usa l istruzione fscanf: fscanf(indirizzo del file, specificatore di formato, indirizzo RAM) Legge da file un dato formattato secondo lo specificatore di formato, e lo memorizza in RAM all indirizzo specificato. Restituisce il numero di byte letti, oppure EOF se alla fine del file. Può essere usata come void. int N; fscanf(fp,"%d",&n); /* legge un intero da file e lo memorizza nella variabile N*/ if(fscanf(fp,"%d",&n) == EOF) printf("errore"); /* prova a leggere un intero da file, ma raggiunge la fine del file prima di riuscirci */ 6

7 Per scrivere un qualsiasi dato su file di testo si usa l istruzione fprintf: fprintf(indirizzo del file, stringa di output, espressioni) float t = 1.5; fprintf(fp,"%f",t); /* scrive su file il valore 1.5 */ Scrive la stringa di output formattata su file di testo. Restituisce il numero di byte scritti. Può essere usata come void. fprintf(fp,"ciao mondo"); /* scrive ciao mondo su file */ fprintf(fp,"\n ); /* va a capo nel file */ fprintf(fp,"%d %d", 3, 8); /* scrive su file 3 e 8 */ fprintf(fp,"%c, A ); /* scrive su file il carattere A */ 7

8 LETTURA E SCRITTURA SU FILE BINARIO Per la lettura e scrittura su file binario si usano due istruzioni: fread e fwrite. Entrambe trasferiscono un insieme di bit da file a RAM (fread) o da RAM a file (fwrite) così come sono memorizzati, senza formattazione. Per leggere un qualsiasi dato da file binario si usa l istruzione fread: fread(indirizzo RAM, numero byte, numero blocchi, indirizzo del file) Legge da file uno o più blocchi di bit non formattati, e li memorizza in RAM a partire dall indirizzo specificato. Parametri: numero byte: numero di byte del blocco numero blocchi: numero di blocchi da leggere. Restituisce il numero di blocchi letti. int N; fread(&n, sizeof(int), 1, fp); /* legge un intero da file e lo memorizza nella variabile N*/ struct libro { /* definizione del record */ char titolo[20]; char autore[20]; int anno; char editore[20]; }; typedef struct libro book; /* definizione esplicita */ book b; /* dichiarazione variabile */ fread(&b, sizeof(book), 1, fp); /* legge un record da file e lo memorizza nella variabile b */ Esempio (con la stessa definizione di record di sopra): book biblioteca[100]; /* dichiarazione array di record */ fread(&biblioteca[20], sizeof(book), 5, fp); /* legge cinque record da file e li memorizza nel vettore biblioteca a partire dalla posizione 20 */ 8

9 Per scrivere un qualsiasi dato su file binario si usa l istruzione fwrite: fwrite(indirizzo RAM, numero byte, numero blocchi, indirizzo del file) Scrive su file uno o più blocchi di bit non formattati, prelevandoli dalla RAM a partire dall indirizzo specificato. Parametri: numero byte: numero di byte del blocco numero blocchi: numero di blocchi da scrivere. Restituisce il numero di blocchi scritti. int N; fwrite(&n,sizeof(int),1,fp); /* scrive su file l intero memorizzato nella variabile N*/ struct libro { /* definizione del record */ char titolo[20]; char autore[20]; int anno; char editore[20]; }; typedef struct libro book; /* definizione esplicita */ book b; /* dichiarazione variabile */ fwrite(&b, sizeof(book), 1, fp); /* scrive il record b su file */ Esempio (con la stessa definizione di record di sopra): book biblioteca[100]; /* dichiarazione array di record */ fwrite(&biblioteca[0], sizeof(book), 5, fp); /* scrive su file i primi cinque record dell array biblioteca */ 9

10 ACCESSO DIRETTO Per realizzare un archivio con accesso diretto dobbiamo usare i file binari. Il motivo, come già spiegato, sta nel fatto che la dimensione dei diversi record dell archivio è sempre la stessa nei file binari, mentre può variare nei file di testo. L accesso diretto si realizza utilizzando l istruzione fseek, che serve a spostare la testina di lettura/scrittura all interno del file. Basta spostare la testina all inizio del record al quale si vuole accedere (ad esempio, se si vuole leggere il 5 record, si salta in avanti di 4 record), e leggere il record con una fread. Per spostare la testina sul record al quale si vuole accedere si usa l istruzione fseek: fseek(indirizzo del file, num_byte, start); Sposta la testina di lettura/scrittura, sul file specificato, di num_byte a partire da start. Il terzo parametro, start, può valere: - SEEK_SET inizio del file - SEEK_CUR posizione corrente - SEEK_END fine del file Restituisce 1 in caso d errore, 0 se tutto OK, ma è solitamente usata come void. fseek(fp,10,seek_set); /* sposta la testina in avanti di 10 byte dall inizio del file */ Esempio (con la definizione del record book degli esempi precedenti): fseek(fp, 3*sizeof(book), SEEK_SET); /* sposta la testina all inizio del quarto record */ fseek(fp, -sizeof(book), SEEK_CUR); /* sposta la testina indietro di un record */ fseek(fp, -2*sizeof(book), SEEK_END); /* sposta la testina sul penultimo record dell archivio */ RICERCA DI UN RECORD IN UN ARCHIVIO Se si vuole cercare un particolare record in un archivio, occorre scorrere uno per uno tutti i record dell archivio. Per ognuno di questi, bisogna ripetere le seguenti operazioni: - leggere il record (portarlo in RAM) - controllare se è il record cercato. C è bisogno allora di un ciclo! In generale, non si può utilizzare il ciclo for perché non si conosce a priori il numero di record dell archivio. Ci viene però in aiuto l istruzione feof, che possiamo utilizzare per determinare il raggiungimento della fine del file. Per determinare se si è raggiunto la fine del file, si usa l istruzione feof: feof(indirizzo del file); Determina il raggiungimento della fine del file. Restituisce 1 se il file è terminato, 0 altrimenti. while (!feof(fp)) /* fino a che non è finito il file fp */ { fread( ) /* leggi un record dal file */ if ( ) /* controlla se è il record cercato */ } 10