L apertura di un file ci restituisce un puntatore a una struttura chiamata FILE fopen:

Transcript

1 I FILE L apertura di un file ci restituisce un puntatore a una struttura chiamata FILE FILE *mfptr = NULL; mfptr = fopen( nome_del_file.txt, w ); fopen: primo argomento: nome del file secondo argomento: modalità di apertura. w = write r = read a = append r+ = lettura e scrittura w+ = lettura e scrittura (se esiste il file, svuotalo) se aggiungo una b : lettura o scrittura binaria

2 I FILE: ESEMPIO SCRITTURA #include <stdio.h> int main (){ FILE *mfptr = NULL; if ( (mfptr = fopen( nome_del_file.txt, w ) ) == NULL) { printf( Impossibile aprire il file\n ); } else { fprintf(mfptr, Ciao\n ); fclose(mfptr); } }

3 I FILE: ESEMPIO LETTURA #include <stdio.h> int main (){ FILE *mfptr = NULL; int d; if ( (mfptr = fopen( nome_del_file.txt, r ) ) == NULL) { printf( Impossibile aprire il file\n ); } else { while (!feof(mfptr) ) { fscanf(mfptr, %d\n, &d); printf( Trovato numero %d\n, d); } fclose(mfptr); } } Note: ogni volta che leggiamo dei byte di un file, stiamo spostando un puntatore del file rewind( mfptr ) ce lo riporta all inizio

4 FILE AD ACCESSO CASUALE O SEQUENZIALE File ad accesso sequenziale: record dimensione variabile ad es: per inserire un record devo traslare tutti i record successivi File ad accesso casuale: record dimensione costanti record di dimensione constante posso modificare solo un record Per scrivere/leggere dati raw (ad esempio una struct) su un file, si usano fread e fwrite: per raw data size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream); scrive su stream nmemb elementi, ciascuno di dimensione size. Il primo elemento e' individuato dal puntatore ptr. ritorna il numero di elementi scritti. Per posizionarci ad un certo punto del file usiamo: fseek( fptr, byte_offset, SEEK_SET);// riferito all inizio del file (altrimenti SEEK_CUR o SEEK_END)

5 ESERCIZIO Realizzare un sistema di inserimento di records per l anagrafica della classe. Ogni utente ha: nome cognome corso di studi (iti, elettronica, altro) età Realizzarlo in modo efficiente usando un file ad accesso casuale

6 GESTIONE DINAMICA DELLA MEMORIA Problema: vogliamo fare un programma che memorizzi in RAM un numero arbitrario (che non sappiamo in fase di compilazione) di record Serve un sistema per l allocazione dinamica della memoria (a runtime): void* malloc(size_t byte_da_allocare) void free(void *puntatore_memoria_allocata) void* realloc(void *mem_allocata, size_t byte_da_allocare) Note: La funzione malloc ritorna NULL se non è riuscito ad allocare la memoria Altrimenti ha bisogno di un cast del puntatore di uscita

7 GESTIONE DINAMICA DELLA MEMORIA Esempio: int *mptr=null; mptr = malloc(10*sizeof(int)); //allochiamo un array di 10 interi *(mptr + 1) = 4; //scriviamo 4 nel secondo elemento dell array free(mptr); // rilasciamo la memoria

8 STACK Ad ogni thread viene associata una zona di memoria dove salvare variabili locali e stato delle chiamate a funzioni Questa zona è organizzata come una pila LIFO ed è chiamata STACK Quando viene invocata una funzione, un blocco di memoria viene creato in fondo allo STACK. Quando la funzione ritorna, questo blocco viene distrutto. Lo spazio relativo alle variabili automatiche utilizzate nella funzione viene quindi rilasciato

9 HEAP Ad ogni applicazione (tipicamente) viene associata una zona di memoria per l allocazione dinamica, chiamata HEAP E possibile creare dinamicamente nuovi blocchi di memoria in questa zona. Tali blocchi vanno deallocati manualmente Si puo incorrere in frammentazione se non gestiamo in modo efficiente l heap ed allo spreco a causa di metadata

10 STACK VS HEAP Stack very fast access don't have to explicitly de-allocate variables space is managed efficiently by CPU, memory will not become fragmented local variables only limit on stack size (OS-dependent) variables cannot be resized Heap variables can be accessed globally no limit on memory size (relatively) slower access no guaranteed efficient use of space, memory may become fragmented over time as blocks of memory are allocated, then freed you must manage memory (you're in charge of allocating and freeing variables) variables can be resized using realloc() src:

11 LO STACK parameters return address - where to begin execution when function exits dynamic link - pointer to caller's stack frame static link - pointer to lexical parent (for nested functions) return value - where to put the return value local variables local work space - for temporary storage of results

12 DANGLING REFERENCE - POINTER TO A DEAD OBJECT Dead Object: char *str; str = malloc(100); free(str); *str = 'h'; // l array di 100 elementi è un oggetto morto Puntare ad un dead object si chiama «dangling reference» E un errore, spesso difficile da individuare

13 MEMORY LEAK E importantissimo ricordarsi di liberare la memoria allocata quando non ci serve più! e quindi non lasciare memoria allocata dinamicamente irraggiungibile La memoria comunque viene rilasciata quando il programma esce ma alcuni programmi vengono eseguiti per molto tempo!