Gestione di File: richiami

Transcript

1 Gestione di File: ichiami un file in geneale, e' - una sequenza di dati "codificati" - teminata da EOF - la cui gestione in C e' effettuata mediante 1) APERTURA (fopen) ) ASSOCIAZIONE del file ad una vaiabile handle (di tipo FILE *) ) USO mediante funzioni applicate alla vaiablile handle i passi 1) e )... FILE * f; f = fopen(nomefile, "modo") dove - NOMEFILE e' una stinga e - modo e' -,... (lettua) + - w,... (scittua) w+ - a,... (append) a+ buffe file: cusoe posizionato lungo il file; quando viene ichiesta una opeazione di lettua o scittua (USO - fase -), questa avviene nel punto miato dal buffe file... EOF Tecniche della Pogammazione, M.Tempeini - Sui file binai 1/1

2 Gestione di File: ichiami - file testuali I file di testo hanno una oganizzazione paticolae (che li ende editabili a mano con un edito) stdin e stdout sono steam testuali (cioe' sequenze tattate come file testuali) - i dati sono caattei - i modi sono /w/a - c'e' EOF ma nel file possono esseci anche caattei paticolai EOLN (end-of-line) - gli EOLN ('\n') pemettono di dae ai caattei una oganizzazione in ighe - le funzioni di uso sono quelle (lettua/scittua) a gestione "fomattata": fpintf, fscanf ch fin i d sting 1 10 p a paola\0 double d; int i; cha ch; FILE * fin = fopen("dati.txt", " );... inizialmente il bfile e' sulla 'p' fscanf (fin, "%c", &ch); /*oa ch contiene 'p' e il buffefile e' sulla 'a' */ ewind(fin) /* oa tona sulla 'p' */ 1 fscanf(fin, "%s", sting); fscanf(fin, "%d", &i); /* legge il 10 */ 4 5 fscanf(fin, "%lf", &d); /* legge il */ 4 5 p a o l a EOLN EOF Tecniche della Pogammazione, M.Tempeini - Sui file binai /1 1 I numei in questo tipo di iquado simboleggiano la situaziojne del buffe file dopo l'esecuzione dell'istuzione

3 Gestione di File: file binai - memoizzano i dati in foma binaia (cioe' secondo il metodo di appesentazione del tipo di dato elativo) - i dati possono essee di qualsiasi tipo (e non convenzionalmente solo di caattei); spesso, ma non sempe, sono tutti del medesimo tipo (e quindi si possono avee "file di intei", "file di voli", "file di punti coloati", ma anche file con contenuto disomogeneo ) - c'e' EOF - i modi sono b/wb/ab (lettua/scittua/append) e b+/wb+/ab+ (+ = lettua e scittua) - lettua e scittua avvengono pe blocchi di byte - fead (punt, dim_dato, num_dati, vafile) legge num_dati blocchi di byte, ciascuno di dimensioni dim_dato da vafile; i dati letti vengono memoizzati in memoia centale a patie dall'indiizzo punt - fwite (punt, dim_dato, num_dati, vafile) memoizza nel file vafile num_dati blocchi di byte, ciascuno di dimensioni dim_dato, pesi in memoia centale a patie dall'indiizzo punt Tecniche della Pogammazione, M.Tempeini - Sui file binai /1

4 Gestione di File: file binai - fwite int main () { FILE * fout; int num=1; double a[5]={,4.1,.9,7.,; TipoPunto p = {14., 1.7, "osso" fout = fopen("dati.dat", "wb"); oa il buffe 1 file e' qui fwite(&num, sizeof(int), 1, fout); fout memoia peifeica.9 fwite(a+4, sizeof(double), 1, fout); fwite(a, sizeof(double), 4, fout); fwite(&p, sizeof(tipopunto), 1, fout); fclose(fout); etun 0; inseimento EOF ^ a a osso\0 memoia centale Tecniche della Pogammazione, M.Tempeini - Sui file binai 4/1 p 4 5 num o s s o NULL EOF

5 Gestione di File: file binai - fead() e fwite() in effetti le due funzioni in questione sono definite con le seguenti intestazioni (i nomi dei paameti non sono fedeli) da dove pendee i dati in memoia dimensione del singolo dato (blocco di byte) pe quanti dati singoli ipetee l'opeazione in quale file scivee, a patie dalla posizione attuale del buffe file size_t fwite (void * punt, size_t s, size_t n, FILE * steam) - effettua n memoizzazioni in steam, ciascuna di un blocco di s byte; il pimo blocco e' quello all'indiizzo punt; gli alti lo seguono; - estituisce il numeo di memoizzazioni effettuate con successo dove (cominciae a) copiae in memoia centalei dati letti dimensione del singolo dato (blocco di byte) pe quanti dati singoli ipetee l'opeazione da quale file leggee i dati size_t fead (void * punt, size_t s, size_t n, FILE * steam) - effettua n memoizzazioni in memoia centale, cominciando dall'indiizzo punt, pendendo n blocchi di dimensione s da steam; - estituisce il numeo di lettue effettuate con successo Tecniche della Pogammazione, M.Tempeini - Sui file binai 5/1

6 Gestione di File: file binai - fead /* cosi' potemmo leggee i dati messi pima nel file dati.dat */ dati.dat int main () { FILE * fin; int i, num; double a[5]; TipoPunto p; fin = fopen("dati.dat", "b"); 1 oa il buffe file e' qui memoia peifeica fead(&num, sizeof(int), 1, fin); fead(a, sizeof(double),, fin); fo (i=; i<5; i++) fead(a+i, sizeof(double), 1, fin); 4... libeazione fclose(fout); file fin etun 0; Tecniche della Pogammazione, M.Tempeini - Sui file binai 6/1 memoia centale num 1 a i a o s s o NULL EOF

7 Gestione di File: file binai - fead /* cosi' potemmo leggee i dati messi pima nel file dati.dat */ int main () { FILE * fin; int i, num; double a[5]; TipoPunto p; fin = fopen("dati.dat", "b"); osso fead(&p, sizeof(tipopunto),1, fin); p 1 oa il buffe file e' qui dati.dat 1 memoia peifeica fead(&num, sizeof(int), 1, fin); fead(a, sizeof(double),, fin); fo (i=; i<5; i++) fead(a+i, sizeof(double), 1, fin); 4... libeazione fclose(fout); file fin etun 0; memoia centale Tecniche della Pogammazione, M.Tempeini - Sui file binai 7/1 num 1 a i a o s s o NULL EOF

8 Gestione di File: file binai - esecizio - 1/4 - pogamma che - memoizza in aaydouble esattamente i dati contenuti nel file di double d1.dat - scaica tutti i dati meno uno, in un file di nome dato in input SCHEMA DI PROGRAMMA: algoitmo, stuttue dati coinvolte, main() con chiamate di funzioni di appoggio, definizioni delle funzioni (... 1 sola) Algoitmo double *aaydouble; FILE *fin; 1. apetua in lettua di d1.dat; ev. messaggio di eoe int quanti; double d;. conteggio dei dati in d1.dat e allocazione aaydouble. ewind e scansione di d1.dat, con caicamento in aaydouble dei dati letti cha nomefile[0]; FILE * fout; 4. lettua nome nuovo file e sua apetua in scittua 5. copia nel nuovo file Tecniche della Pogammazione, M.Tempeini - Sui file binai 8/1

9 Gestione di File: file binai - esecizio - /4 - int main () { FILE * fin, *fout; double *aaydouble, d; cha nomefile[0]; int quanti; fin = fopen("d1.dat", "b"); if (fin==null) { pintf("eoe in ap..."); etun 0; quanti=0; while (!feof(fin)) { fead(&d, sizeof(double), 1, fin); quanti+=1; uso di feof(): attenzione... ci si vede in laboatoio... ewind(fin);... Tecniche della Pogammazione, M.Tempeini - Sui file binai 9/1

10 Gestione di File: file binai - esecizio - /4 - aaydouble = malloc(quanti*sizeof(double)); if (!aaydouble) { fclose(fin);... stampa messaggio di eoe... etun 0; Falo senza ciclo? fo (i=0; i<quanti; i++) fead(aaydouble + i, sizeof(double), 1, fin); stampaaay(aaydouble, quanti); fclose(fin) pintf("\nnome file output? "); scanf("%s", nomefile); if (salvaaay(aaydouble, quanti, nomefile)) { pintf("... fatto e tutto bene..."); else pintf("acc... poblemi di salvataggio\n"); etun 0; stampaaay e salvaaay sono da definie appositamente: pototipi (in base alle chiamate): void stampaaay(double *, int) int salvaaay(double *, int, cha *) Tecniche della Pogammazione, M.Tempeini - Sui file binai 10/1

11 Gestione di File: file binai - esecizio - 4/4 - int salvaaay(double * a, int q, cha *nmf) { FILE * fout; int i; if ( (fout = fopen(nmf, "wb")) == NULL) { pintf... apetua andata stota etun 0; /* infatti e' andata male e estituiamo 0 */ /* se invece le cose sono andate bene... */ fo (i=0, i<q, i++) fwite(a+i, sizeof(double), 1, fout); fclose(fout); etun 1; altenativa al fo: sciviamo tutto in una volta (e contolliamo ) i = fwite(a, sizeof(double), q, fout); fclose (fout); if (i==q) etun 1; else etun 0 Tecniche della Pogammazione, M.Tempeini - Sui file binai 11/1

12 Gestione di File: file binai - ACCESSO RANDOM che non vuol die "accesso casuale, come viene viene", ma accesso deteminato esplicitamente da istuzioni del pogamma anziche' da movimenti automatici del buffe file. La funzione che pemette di modificae la posizione nel file del buffe file e' la fseek (FILE *f, long int offset, int mode) - offset e' l'entita' dello spostamento che si vuole effettuae, espessa in byte: se offset e' 10, il buffe file si sposta di 10 byte) - mode e' un valoe che puo' essee uno dei te indicati sotto; specifica da dove calcolae lo spostamento: - SEEK_SET = dall'inizio del file - SEEK_CUR = dalla posizione coente del buffe file - SEEK_END = dalla fine del file (spostamento veso su...) Tecniche della Pogammazione, M.Tempeini - Sui file binai 1/1

13 Gestione di File: file binai - ACCESSO RANDOM - esempio /* supponendo di vole leggee il sesto, l'ottavo e il penultimo double in d1.dat */ fseek(fin, sizeof(double)*5, SEEK_SET); /* posizionamento del buffe file sul sesto blocco double a patie dalla testa del file */ fead (&d, sizeof(double), 1, fin); fseek(fin, sizeof(double), SEEK_CUR); /* dalla posizione coente ci si sposta avanti di un blocco double: stavamo sul settimo, dopo ave letto il sesto e quindi andiamo sull'ottavo */ fead (&d, sizeof(double), 1, fin); /* dalla fine del file, si tona indieto di due blocchi double, in modo da posizionasi subito pima del (cioe' sul) penultimo */ fseek(fin, sizeof(double)*, SEEK_END); fead (&d, sizeof(double), 1, fin); SESTO 1.7 OTTAVO 14. PENULTIMO Tecniche della Pogammazione, M.Tempeini - Sui file binai 1/1