Unità 11 Allocazione dinamica

Transcript

1 Corso di Fondamenti di Informatica Ingegneria delle Comunicazioni BCOR Ingegneria Elettronica BELR Introduzione al C Unità 11 Allocazione dinamica S. Salza, C. Ciccotelli, D. Bloisi, S. Peluso, A. Pennisi

2 Gestione dinamica della memoria Nell Unità 5 è stato presentato il modello di allocazione della memoria tramite stack, che si basa sulle regole di campo d azione (definito staticamente, cioè al momento della compilazione). Attraverso i puntatori, il C permette di utilizzare un altro modello di allocazione della memoria, che consente di definire la memoria dinamicamente, cioè al momento dell esecuzione del programma. Questa possibilità risulta particolarmente utile ed importante quando non sono note o prevedibili a priori le dimensioni dei dati in ingresso ad un programma. Pagina 2

3 Allocazione dinamica della memoria Durante l esecuzione, un programma può richiedere esplicitamente uno spazio di memoria per immagazzinare dati. Allo stesso modo, può richiedere di rilasciare tale spazio quando non sarà più necessario. Il C offre la funzione malloc per riservare (allocare) uno spazio di memoria e la funzione free per rilasciare (deallocare) memoria. Insieme all operatore sizeof sono essenziali per l allocazione dinamica della memoria Pagina 3

4 La funzione malloc permette di allocare dinamicamente una porzione (chunk) di memoria. void* malloc(size_t size); Restituisce un puntatore alla porzione di memoria di dimensione size oppure NULL se si è verificato un errore size_t è definito come il tipo intero senza segno restituito dall operatore sizeof malloc è definita nella standard library, quindi per poterla usare va inserita la direttiva #include <stdlib.h> Pagina 4

5 Esempio su malloc (1) int *p; (2) p = malloc(sizeof(int)); (3) *p = 7; (4) printf("%d", *p); (1) Definisce una variabile di tipo puntatore a int (2) Crea in memoria una variabile di tipo int, è restituito in p l'indirizzo del primo byte della variabile creata (3) la variabile di tipo int creata assume il valore 7 (4) viene stampato a video 7 Pagina 5

6 L allocazione dinamica della memoria avviene nello heap Se lo spazio di memoria allocabile dinamicamente è esaurito viene restituito il puntatore NULL int *pt1; // dichiarazione del puntatore ad int pt1 = malloc(sizeof(int)); // creazione dinamica // della variabile int if (pt1 == NULL) { printf("allocazione fallita\n"); exit(exit_failure); } In caso di mancanza di memoria il programma qui sopra termina con l istruzione exit(exit_failure); che notifica il fallimento. Pagina 6

7 Funzione free La funzione free permette di deallocare la memoria allocata dinamicamente. void free( void* ptr); free dealloca lo spazio puntato da ptr, rendendolo disponibile per usi futuri free è definita nella standard library (<stdlib.h>) N.B. Per comparire in una free il puntatore ptr deve essere stato usato in una precedente chiamata a malloc() Pagina 7

8 Esempio di chiamata a free #include <stdio.h> #include <stdlib.h> int main() { int *p; double *d; p = malloc(sizeof(int)); *p = 7; printf("%d", *p); free(p); d = malloc(sizeof(double)); *d = 7; printf("%f", *d); free(d); } Pagina 8

9 Tempo di vita divariabili dinamiche Per le variabili allocate dinamicamente il tempo di vita corrisponde al periodo che va dal momento in cui la variabile viene allocata al momento in cui la variabile viene deallocata Il tempo di vita di una variabile allocata dinamicamente è definito solo a tempo di esecuzione Se una variabile allocata dinamicamente non è deallocata esplicitamente, il suo tempo di vita si prolunga fino alla terminazione del programma Può verificarsi il caso in cui una zona di memoria allocata non sia più accessibile, se non ci sono variabili che la riferiscono. Tale zona di memoria rimarrà inutilmente occupata per tutta la durata del programma: Memory Leak Pagina 9

10 Esempio: tempo di vita 1/2 int* creaint(int a) { int* temp = malloc(sizeof(int)); *temp = a; return temp; } int main() { int* pt2 = creaint(5); printf("*pt2 = %d\n", *pt2); return 0; } Pagina 10

11 Esempio: tempo di vita 2/2 Il programma precedente stampa *pt2 = 5 Questo perché la variabile allocata dalla funzione creaint viene restituita al programma principale Essendo stata creata dinamicamente, rimane accessibile anche al termine della esecuzione della funzione Le variabili create dinamicamente non rispettano le regole di campo di azione, che valgono per quelle create staticamente Pagina 11

12 Esempio: esaurimento della memoria 1/2 L'esecuzione del segmento di codice: int *temp, k; for (k = 1; 1 ; k++) { } printf("k = %d\n", k); temp = malloc(sizeof(int)); Provoca il messaggio d'errore: dynamic(1320) malloc: *** mmap(size= ) failed (error code=12) *** error: can t allocate region Pagina 12

13 Esempio: esaurimento della memoria 2/2 Si noti che la condizione del ciclo è sempre verificata (visto che 1 vale vero) L'esecuzione comporta quindi una richiesta infinita di memoria Dopo un numero sufficientemente alto di iterazioni la memoria disponibile si esaurisce Questo comporta in C l'interruzione del programma e la segnalazione di errore Pagina 13

14 Accessibilità di variabili deallocate 1/2 int *pt1; pt1 = malloc(sizeof(int)); // allocazione *pt1 = 1; printf("*pt1 = %d\n", *pt1); // accesso free(pt1); // deallocazione printf("after free\n"); printf("*pt1 = %d\n",*pt1); int *pt2 = malloc(sizeof(int)); printf("after malloc *pt2 =%d", *pt2); Non è da escludere che il programma stampi *pt1 = 1 *pt2 = 1 Pagina 14

15 Accessibilità di variabili deallocate 2/2 In questo caso, può verificarsi che la memoria rimanga accessibile anche dopo il rilascio ed addirittura che il suo contenuto sia ancora immutato (anche se non è garantito). In aggiunta, la riallocazione immediata potrebbe riallocare la variabile nella stessa posizione della memoria e quindi con lo stesso valore (anche questo non è garantito). In ogni caso, entrambe le situazioni sopra delineate sono da evitare accuratamente, in quanto fonti di errori e di comportamenti instabili del programma. Pagina 15

16 Esempio: puntatori appesi 1/2 int *pt1; pt1 = malloc(sizeof(int)); *pt1 = 1; printf("*pt1 = %d\n", *pt1); int *pt2; pt2 = pt1; printf("prima di free(pt1)\n"); printf("*pt2 = %d\n", *pt2); free(pt1); printf("dopo di free(pt1)\n"); printf("*pt2 = %d\n", *pt2); Pagina 16

17 Esempio: puntatori appesi 2/2 Questo segmento di codice genera la stampa *pt1 = 1 prima di free(pt1) *pt2 = 1 dopo di free(pt1) *pt2 = In questo caso, il rilascio della memoria puntata da pt1 lascia pt2 puntare a una locazione di memoria rilasciata e quindi suscettibile di modifiche arbitrarie da parte del sistema operativo. Questa situazione di puntatore appeso (dangling) è da evitare assolutamente in quanto fonte di errori difficili da individuare Pagina 17

18 Relazione tra array e puntatori 1/2 In C il nome di un array rappresenta l indirizzo dell elemento di indice 0 int array[10]; printf("%p %p", array, &array[0]); Si noti che array e &array[0] hanno lo stesso valore Infatti la seguente istruzione stampa due volte lo stesso indirizzo printf("%p %p", array, &array[0]); Pagina 18

19 Relazione tra array e puntatori 2/2 Quindi, come pratica comune, possiamo assegnare l indirizzo (del primo elemento) di un array ad una variabile puntatore: int arr[7]; int *pi; pi = arr; In questo caso, l ultima istruzione è del tutto equivalente a: pi = &arr[0]; Pagina 19

20 Allocazione dinamica di un array ALLOCAZIONE STATICA: facciamo puntare un puntatore pi a un vettore allocato attraverso una dichiarazione (quindi statico, creato nello stack) ALLOCAZIONE DINAMICA: facciamo puntare un puntatore pi a una zona di memoria allocata dinamicamente (quindi nello heap) int *pi, dim; scanf("%d", &dim); pi = malloc(dim * sizeof(int)); if(pi!= NULL) pi[dim-1] = 3; Assegno 3 alla cella di pi in posizione dim-1 Pagina 20

21 Indirizzamento di un array ALLOCAZIONE STATICA tipo arr[n]; ALLOCAZIONE DINAMICA tipo *arr = (tipo*)malloc(n*sizeof(tipo)); Assegnazione di val alla cella i dell array arr arr[i] = val; *(arr+i) = val; Pagina 21

22 Array come risultato di una funzione La funzione copiainversa prende come parametro un array a di dimensione n e restituisce il puntatore a un array con gli elementi in ordine inverso, dall ultimo al primo int* copiainversa(int a[], int n) { int* temp = (int*)malloc(n *sizeof(int)); if(temp!= NULL) { int i; for (i = 0; i < n; i++) { temp[n-1-i] = a[i]; } } return temp; } Pagina 22

23 Esempio d uso int main () { const int n = 5; int x[n], i; x[0] = 5; x[1] = 3; x[2] = 9; x[3] = 5;x[4] = 12; for (i = 0; i < n; i++) printf("%d ", x[i]); // stampa printf("\n"); int *y = copiainversa(x, n); if(y == NULL) { printf("errore\n"); return(exit_failure); } for (i = 0; i < n; i++) printf("%d ", y[i]); // stampa printf("\n"); free(y); return(exit_success); } Pagina 23

24 Note Il risultato di una funzione può essere un riferimento ad un array, ma occorre usare esplicitamente il puntatore, cioè non si può scrivere int[] come tipo del risultato della funzione. Array allocati staticamente non devono essere deallocati esplicitamente. L array x nell esempio precedente sarà deallocato automaticamente al termine del bloccodi codice in cui è definito (cioè nel main). Invece, quando si alloca dinamicamente un array, al termine del suo uso bisogna deallocare la memoria occupata esplicitamente, tramite la funzione free. Nell esempio precedente: free(y); Pagina 24

25 Matrici dinamiche Allocazione di una matrice dinamica di dimensioni R x C, di elementi di tipo t La matrice M è allocata come un array di R elementi (le righe), che sono a loro volte array di C elementi t** M; //Puntatore a puntatore a t M = (t**) malloc(r*sizeof(t*)); M[0] = malloc(c*sizeof(t));... M[R-1] = malloc(c*sizeof(t)); Pagina 25

26 Struttura della matrice M M[0][0] M[0][C-1] M[0] M[C-1] M[R-1][0] M[R-1][C-1] Pagina 26

27 Matrici statiche vs. Matrici dinamiche void f(int** A){ printf( %d\n, A[1] [0]); } int main(){ int M[3][2]; M[1][0] = 5; f(m); return 0; } COSA STAMPA? Attenzione! Le rappresentazioni di matrici statiche e dinamiche costituiscono tipi incompatibili Pagina 27