VARIABILI AUTOMATICHE E DINAMICHE. Manuale linguaggio C

Transcript

1 VARIABILI AUTOMATICHE E DINAMICHE Manuale linguaggio C

2 Variabili automatiche e dinamiche In C è possibile classificare le variabili in base al loro tempo di vita in: variabili automatiche variabili dinamiche Variabili automatiche: L allocazione e la deallocazione di variabili automatiche è effettuata automaticamente dal sistema (senza l'intervento del programmatore). Ogni variabile automatica ha un nome, attraverso il quale la si può riferire. Il programmatore non ha la possibilità di influire sul tempo di vita di variabili automatiche. tutte le variabili viste finora rientrano nella categoria delle variabili automatiche (NON le zone di memoria allocate tramite invocazione alle funzioni malloc(), calloc() e realloc()).

3 Variabili dinamiche Variabili dinamiche: Le variabili dinamiche devono essere allocate e deallocate esplicitamente dal programmatore. L area di memoria in cui vengono allocate le variabili dinamiche si chiama heap. Le variabili dinamiche non hanno un identificatore, ma possono essere riferite soltanto attraverso il loro indirizzo (cioè mediante i puntatori). Il tempo di vita delle variabili dinamiche è l'intervallo di tempo che intercorre tra l'allocazione e la deallocazione (che sono impartite esplicitamente dal programmatore). Le funzioni standard di allocazione e deallocazione per le variabili dinamiche sono malloc(), calloc(), realloc() e free()

4 Variabili dinamiche int *p1; float *p2; variabili automatiche memoria p1 heap *p1 variabili dinamiche p2 *p2 p1= (int *) malloc( ); p2= (float *) malloc( );

5 Significato malloc La malloc provoca la creazione di una variabile dinamica nell heap e restituisce l indirizzo della variabile creata. memoria heap variabili dinamiche punt Esempio: int* punt;... punt=(int * )malloc(sizeof(int)); *punt=12;

6 Significato malloc memoria heap variabili dinamiche punt Esempio: int* punt;... punt=(int * )malloc(sizeof(int)); *punt=12;

7 Significato malloc memoria heap variabili dinamiche punt 12 Esempio: int* punt;... punt=(int * )malloc(sizeof(int)); *punt=12;

8 Significato free Dopo questa chiamata a funzione, la cella di memoria occupata da *punt viene liberata e quindi *punt non esiste più. memoria heap variabili dinamiche punt Esempio: int* punt;... punt=(int * )malloc(sizeof(int)); *punt=12;...<uso di punt>... free(punt); dice al sistema operativo che la memoria allocata può essere riassegnata per un altro processo o sempre per lo stesso processo in una futura chiamata di allocazione dinamica.

9 Significato free Dopo la chiamata alla funzione free() la memoria precedentemente occupata trona libera e disponibile per gli usi futuri. memoria heap variabili dinamiche punt Attenzione a non usare il puntatore punt perché ora è privo di significato..

10 Problemi legati all uso dei puntatori 1. Aree inutilizzabili: Possibilità di perdere l'indirizzo di aree di memoria dinamiche allocate al programma che quindi non sono più accessibili. Esempio: int *P, *Q, x, y; x=5; y=14; P=(int *)malloc(sizeof(int)); Q=(int *)malloc(sizeof(int)); *P = 25; *Q = 30; *P = x; y = *Q; P = &x; ha come effetto collaterale la perdita dell'indirizzo della variabile dinamica precedentemente referenziata da P che rimane allocata ma non é più utilizzabile!

11 Problemi legati all uso dei puntatori 2. Riferimenti pendenti (dangling references): Possibilità di fare riferimento ad aree di memoria non più allocate. Esempio: int *P; P = (int *) malloc(sizeof(int));... free(p); *P = 100; /* Da non fare! */ Area deallocata memoria P heap variabili dinamiche

12 Problemi legati all uso dei puntatori 3. Aliasing: Possibilità di riferire la stessa variabile con puntatori diversi. Esempio: int *p, *q; p=(int *)malloc(sizeof(int)); *p=3; q=p; /*p e q puntano alla stessa variabile */ *q = 10; /*anche *p è cambiato! */ memoria p heap 3 10 variabili dinamiche q

13 PUNTATORI A PUNTATORI Manuale linguaggio C

14 I puntatori a puntatori Abbiamo visto che la seguente istruzione serve per dichiarare il puntatore p ad array di size elementi di tipo type: type (*p)[size]; int (*pa)[10]; //puntatore a vettore di 10 elementi di tipo int Per accedere ad uno specifico elemento possiamo scrivere: (*pa)[i]. Sappiamo che tale espressione viene trasformata in: (*pa)[i] *((*pa)+i) *pa *pa+i *((*pa)+i) indirizzo primo elemento di a indirizzo elemento i di a valore elemento i di a Quindi per accedere al valore dell elemento di indice i dell array a a partire dal puntatore pa sono necessarie due operazioni di dereferenza.

15 I puntatori a puntatori #include <stdio.h> int main(void) { int i; double a[5]; double(*pa)[5]; pa= &a; for (i=0;i<5;i++) a[i]=2.0*i+1.0; printf(" i a[i] *(*pa+i)\n"); for (i=0;i<5;i++) printf("%3d --> %.3f La dimensione di a è quella di un vettore di 5*sizeof(double) La dimensione di pa, come quella di &a, è quella di un puntatore a double %.3f\n", i, a[i], *(*pa+i)); } printf("sizeof(pa): %3lu sizeof(a): %3lu\n", sizeof(pa), sizeof(a)); printf("sizeof(&a):%3lu\n", sizeof(&a)); printf("sizeof(double *):%3lu sizeof(double): %3lu\n", sizeof(double *), sizeof(double)); return 0;

16 I puntatori a puntatori #include <stdio.h> int main(void) { int i; double a[5]; double(*pa)[5]; double * ppa; ppa=a; pa= &a; for (i=0;i<5;i++) a[i]=2.0*i+1.0; printf("****%3p \n", *pa); printf("****%3f \n", **pa); printf("*******%3f \n", *ppa); printf("**********%3p \n", pa); printf(" i a[i] *(*pa+i)\n"); for (i=0;i<5;i++) printf("%3d --> %.3f %.3f\n", i, a[i], *(*pa+i)); printf("sizeof(pa): %3lu sizeof(a): %3lu\n", sizeof(pa), sizeof(a)); printf("sizeof(&a):%3lu\n", sizeof(&a)); printf("sizeof(double *):%3lu sizeof(double): %3lu\n", sizeof(double *), sizeof(double)); return 0; }

17 I puntatori a puntatori Poiché l identificatore del vettore è il puntatore al primo elemento del vettore, l istruzione: pa = &a; //assegna al puntatore pa l indirizzo di memoria di un puntatore Il puntatore pa è quindi l indirizzo di memoria di un puntatore, cioè un puntatore a puntatore. Il puntatore pa contiene l indirizzo di memoria di una locazione di memoria che a sua volta contiene l indirizzo di memoria del primo elemento del vettore. Di conseguenza, per accedere al valore degli elementi del vettore tramite il puntatore all array sono necessarie due operazioni: la prima per conoscere l indirizzo di memoria del primo elemento dell array, la seconda per conoscere il valore dell elemento voluto a partire dall indirizzo di memoria del primo.

18 I puntatori a puntatori I puntatori a puntatori sono costrutti usati frequentemente nel contesto delle strutture dati concatenate e, in certe situazioni, quando un argomento di funzione è una variabile puntatore. La dichiarazione: int **p; // dichiara p come puntatore ad un puntatore ad int Per accedere al valore dell int, è necessario utilizzare una doppia operazione di dereferenza, quindi i doppi asterischi: j **p; // assegna un intero a j

19 I puntatori a puntatori Esempio: 4 byte int r 5; int *q &r; int **p &q; r q p 5 99C C C È possibile assegnare valori ad r come: r 10; /* Assegnamento diretto */ *q 10; /* Assegnamento con un livello di indirizzamento*/ **p 10; /* Assegnamento con due livelli di indirizzamento /

20 Esercizio int a[5]; int *pi, **pk; a[0]= 137; pi=a; pk=π printf( cosa stampo? %p \n,*pk); printf( cosa stampo? %d \n,**pk);

21 Esercizio #include <stdio.h> int main(void) { int x,y; int *p, *q; int **r; p=&x; q=&y; r=&p; //stampa contenuti Tipo int Tipo int * Tipo int ** x y x y p q p q r r *p=0; *q=1; **r=2; //stampa contenuti q=&x; *r=&y; **r=2; //stampa contenuti return 0; } 0 2 p 1 q 2 p 1 2 q r r

22 printf("p=%p \n", p); printf("contenuto pt da p=%d \n", *p); printf("q=%p \n", q); printf("contenuto pt da q=%d \n", *q); printf("r=%p \n", r); printf("contenuto pt da r=%d \n", **r); Tipo int Tipo int * Tipo int ** x y p q r x y p q r 0 2 p r 1 q 2 p r 1 2 q

23 Esercizio #include <stdio.h> int main(void) { int A[10]={1,2,3,4,5,6,7,8,9,10}; int *p = A; int (*p1)[10]=&a; int *p2[10]; //puntatore ad intero //puntatore a vettore di interi //vettore di puntatori ad intero printf ("%p\n", p); printf ("%d\n", *p); //1 printf ("%p\n", p+1); printf ("%d\n", *(p+1)); //2 printf ("%p\n", p1); //l'indirizzo dell'array A (uguale all'indirizzo contenuto in p cioè A) printf ("%d\n", *p1[0]); //1 printf ("%p\n", p1+1); //il salto è di 10 elementi printf ("%d\n", *(p1+1)); //errore printf ("%p\n", p2); printf ("%d\n", *p2); printf ("%p\n", p2+1); printf ("%d\n", *(p2+1)); return 0; } //stampa l'indirizzo del primo elemento del vettore p2 //errore //indirizzo successivo //errore

24 Esercizio #include <stdio.h> int main(void) { int A[10]={1,2,3,4,5,6,7,8,9,10}; int *p = A; int (*p1)[10]=&a; int *p2[10]; //puntatore ad intero //puntatore a vettore di interi //vettore di puntatori ad intero printf ("%p\n", p); printf ("%d\n", *p); //1 printf ("%p\n", p+1); printf ("%d\n", *(p+1)); //2 printf ("%p\n", p1); //l'indirizzo dell'array A (uguale all'indirizzo contenuto in p cioè A) printf ("%d\n", *p1[0]); //1 printf ("%p\n", p1+1); //il salto è di 10 elementi printf ("%d\n", *(p1+1)); //errore printf ("%p\n", p2); printf ("%d\n", *p2); printf ("%p\n", p2+1); printf ("%d\n", *(p2+1)); return 0; } //stampa l'indirizzo del primo elemento del vettore p2 //errore //indirizzo successivo //errore