Passaggio parametri puntatore Corso di Fondamenti di Informatica Ingegneria delle Comunicazioni BCOR Ingegneria Elettronica BELR

Transcript

1 Corso di Fondamenti di Informatica Ingegneria delle Comunicazioni BCOR Ingegneria Elettronica BELR Domenico Daniele Bloisi

2 Docenti Parte I prof. Silvio Salza salza@dis.uniroma1.it Parte II ing. Domenico Daniele Bloisi bloisi@dis.uniroma1.it Nota: %7E corrisponde alla tilde ~ Pagina 2

3 Informazioni Generali ing. Domenico Daniele Bloisi, PhD Dipartimento di Informatica e Sistemistica Via Ariosto 25 (adiacente Piazza Dante, A fermate Manzoni, Vittorio Emanuele, Tram 3 fermata via Labicana) mailto:bloisi@dis.uniroma1.it Pagina 3

4 Ricevimento Martedì DIS, via Ariosto 25 Aula docenti adiacente aula A4 Si consiglia di inviare una per conferma e di controllare la bacheca degli avvisi Pagina 4

5 Sommario Memoria, indirizzamento e puntatori Tipo void * e conversioni sui puntatori Gestione dinamica della memoria Tempo di vita delle variabili allocate dinamicamente Problemi di deallocazione della memoria Passaggio dei parametri tramite puntatori Pagina 5

6 Tempo di vita delle variabili allocate dinamicamente (1/2) 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 al momento dell'esecuzione del programma. Pagina 6

7 Tempo di vita delle variabili allocate dinamicamente (2/2) Se una variabile allocata dinamicamente non viene deallocata esplicitamente, il suo tempo di vita termina alla terminazione del programma. Può verificarsi il caso in cui una zona di memoria allocata non sia più accessibile, in quanto non ci sono variabili che la riferiscono. Tale zona di memoria rimarrà inutilmente occupata per tutta la durata del programma. Pagina 7

8 Esempio: tempo di vita variabili dinamiche int * creaint (int a) { int * temp = malloc(sizeof(int)); *temp = a; return temp; } int main () { int * pt2 = creaint(5); printf("*pt2 = %d\n", *pt2); } Pagina 8

9 Esecuzione: Tempo di vita variabili dinamiche Il programma precedente stampa *pt2 = 5 poiché la variabile allocata dalla funzione creaint viene restituita al programma principale e rimane accessibile anche al termine della esecuzione della funzione. Le variabili create dinamicamente non rispettano le regole di campo di azione. Pagina 9

10 Esempio: esaurimento della memoria // sciupamemoria; int *temp, k; for (k = 1; 1 ; k++) { printf("k = %d\n", k); temp = malloc(sizeof(int)); } L'esecuzione comporta una richiesta infinita di memoria (la condizione del ciclo è sempre verificata). Pagina 10

11 Esecuzione: esaurimento della memoria L esecuzione produrrà una richiesta infinita di memoria che in C comporta (dopo un numero di cicli piuttosto alto) l interruzione dell esecuzione con un messaggio simile al seguente: dynamic(1320) malloc: *** mmap(size= ) failed (error code=12) *** error: can t allocate region Nota: Ad ogni ripetizione del ciclo, la memoria allocata al ciclo precedente risulta inaccessibile. Pagina 11

12 Problemi di deallocazione della memoria int *pt1; pt1 = malloc(sizeof(int)); // allocazione della variabile *pt1 = 1; printf("*pt1 = %d\n", *pt1); // uso della variabile free(pt1); // la locazione di memoria rimane accessibile dopo free!!! printf("after free\n"); printf("*pt1 = %d\n", *pt1); // la stessa locazione di memoria potrebbe essere ri-allocata!!! int *pt2 = malloc(sizeof(int)); printf("after malloc\n"); printf("*pt2 = %d\n", *pt2); Pagina 12

13 Esecuzione Pagina 13

14 Discussione: problemi di deallocazione della memoria In questo caso, si può verificare che la memoria rimanga accessibile anche dopo il rilascio, ed addirittura che sia ancora immutata (anche se non è garantito). In aggiunta, la riallocazione immediata potrebbe riallocare la variabile nella stessa posizione della memoria e quindi con lo stesso valore (ma 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 14

15 Puntatori appesi Si consideri il seguente frammento di codice 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 15

16 Esecuzione: Puntatori appesi *pt1 = 1 prima di free(pt1) *pt2 = 1 dopo di free(pt1) *pt2 = In questo caso, il rilascio della memoria puntata dalla variabile pt1 lascia la variabile pt2 puntare ad 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 16

17 Passaggio di parametri (1/2) L uso di variabili di tipo puntatore consente di simulare la modalità di passaggio dei parametri per riferimento. Nel passaggio di parametri per valore, in genere utilizzato per i dati di tipo primitivo, il parametro formale può essere considerato come una variabile locale che viene inizializzata al momento della chiamata della funzione con il valore corrispondente al parametro attuale. Pagina 17

18 Passaggio di parametri (2/2) Il passaggio di parametro per valore effettuato con il tipo puntatore consente di aggirare una proprietà cruciale del passaggio di parametri per valore, cioè la garanzia che la funzione non abbia effetti sul programma chiamante (ad eccezione della restituzione del valore calcolato). Pagina 18

19 Esempio: passaggio parametri puntatore void swap(int *a, int *b) { int temp; temp = *a; *a = *b; *b = temp; } Pagina 19

20 Esempio: passaggio parametri puntatore int main (){ int x, y; x = 12; y = 27; printf("x = %d\n", x); printf("y = %d\n", y); swap(&x, &y); printf("after swap\n"); printf("x = %d\n", x); printf("y = %d\n", y); } Pagina 20

21 Esecuzione x = 12 y = 27 after swap x = 27 y = 12 Pagina 21

22 Nonostante il passaggio di parametri sia per valore, il risultato dell esecuzione della funzione swap consiste proprio nel modificare il valore di due variabili del programma principale. Passando alla funzione i puntatori a due variabili è possibile modificare il valore delle variabili puntate, anche se il valore delle variabili puntatore rimane inalterato. L uso dei puntatori nel passaggio di parametri per valore consente di effettuare in pratica il passaggio di parametri per riferimento. Pagina 22

23 Passaggio per valore VS passaggio tramite puntatori void swap(int *a, int *b) { int temp; temp = *a; *a = *b; definizione *b = temp; } swap(&x, &y); invocazione void swapval(int a, int b) { int temp; temp = a; a = b; definizione b = temp; } swapval(x, y); invocazione Cosa succede se si invoca swapval(&x, &y);? Pagina 23

24 Esecuzione Pagina 24

25 Chiamata tramite parametri puntatore (per indirizzo): funzione chiamante Quando la funzione viene chiamata, devono essere passati come parametri gli indirizzi delle variabili il passaggio degli indirizzi potrà essere ottenuto applicando l operatore di indirizzo & alla variabile che deve essere modificata sono passate le celle fisiche dove i valori sono memorizzati &a a b &b 2 3 int a; int b; a = 2; b = 3; f(&a, &b); Pagina 25

26 Chiamata per indirizzo Nell intestazione della funzione chiamata deve essere usato l operatore di deriferimento per le variabili passate per indirizzo pa pb &pa &a &pb &b void f(int *pa, int *pb) { *pa = 6; *pb = 7; } Pagina 26

27 Chiamata per indirizzo: esecuzione a &a 6 int a; int b; a = 2; b = 3; f(&a, &b); pa &pa b &b 7 int *pa = &a; pb &pb void f(int *pa, int *pb) { *pa = 6; *pb = 7; } Pagina 27

28 Vantaggi del passaggio per riferimento Il passaggio di parametri di tipo puntatore è particolarmente utile quando i dati che devono essere scambiati tra funzione chiamata e programma chiamante sono voluminosi. Il passaggio per riferimento risulta molto più efficiente sia in termini di occupazione di memoria che di tempo di calcolo (infatti, occorre la copia del solo puntatore ai dati, non di tutto l insieme dei dati). Pagina 28

29 Valori restituiti di tipo puntatore double *puntatore (double a) { double *r = malloc(sizeof(double)); *r = a; return r; } int main () { double *pd = puntatore(5.4); printf("pd = %p\n", pd); printf("*pd = %f\n", *pd); return 0; } la funzione puntatore crea un puntatore ad una variabile di tipo double e la inizializza con il valore passato come argomento Pagina 29

30 Esercizi Esercizio 6.5 Scrivere un programma che legga tre valori in tre distinte variabili small, medium, large, e ne scambi i valori in modo da avere il più grande nella variabile large, il più piccolo nella variabile small ed il restante nella variabile medium. Definire una funzione per lo scambio dei tre valori che utilizzi il passaggio di parametri puntatore. Pagina 30

31 Esercizi Esercizio 6.6 Scrivere una funzione che dati due valori interi a e b restituisca quoziente e resto della divisione a/b. Scrivere un programma di prova per tale funzione, leggendo l input da tastiera. Pagina 31

32 Appendice: memoria 0 Memoria La memoria del calcolatore può essere idealmente descritta come un insieme di celle ORDINATO UNIVOCAMENTE n Pagina 32

33 Appendice: assegnazione 0 int x = 1; n 1 x L istruzione di assegnazione permette di scrivere un valore all interno di una cella simboleggiata da un nome di variabile Pagina 33

34 Appendice: valore di una variabile 0 int x = 1; printf("x = %d\n", x); Produce x x = 1 n Tramite il nome di una variabile è possibile leggere il contenuto della cella simboleggiata da quella variabile Pagina 34

35 Appendice: indirizzo di una variabile 0 int x = 1; printf("&x = %d\n", &x); Produce x &x = n Tramite l operatore & applicato al nome di una variabile è possibile leggere l indirizzo della cella simboleggiata da quella variabile Pagina 35

36 Appendice: puntatore x_ptr int x = 1; int *x_ptr; x_ptr = &x; x printf("*x_ptr = %d\n", *x_ptr); printf("&x_ptr = %d\n", &x_ptr); printf("x_ptr = %d\n", x_ptr); Produce n *x_ptr = 1 &x_ptr = x_ptr = Pagina 36

37 Appendice: valore tramite un puntatore x_ptr x Tramite l operatore * applicato al nome di un puntatore è possibile leggere il contenuto della cella il cui indirizzo è contenuto nella cella simboleggiata da quel puntatore n Pagina 37

38 Soluzioni Esercizio 6.2 Scrivere un programma che legga 10 numeri interi e restituisca il minimo, usando variabili di tipo puntatore ad int anziché variabili di tipo int. Pagina 38

39 Soluzioni #include <stdio.h> #include <stdlib.h> int main() { int i, v, min; int *min_ptr, *v_ptr; min_ptr = &min; v_ptr = &v; printf("inserisci 10 interi:\n"); scanf("%d", v_ptr); //printf("ho letto %d\n", *v_ptr); *min_ptr = *v_ptr; for(i = 1; i < 10; i++) { scanf("%d", v_ptr); } //printf("ho letto %d\n", *v_ptr); if(*v_ptr < *min_ptr) *min_ptr = *v_ptr; } printf("minimo = %d\n", *min_ptr); return 0; Pagina 39

40 Soluzioni Esercizio 6.3 Scrivere il programma dell esercizio precedente tramite allocazione dinamica della memoria. Deallocare la memoria utilizzata prima della terminazione del programma. Pagina 40

41 Soluzioni #include <stdio.h> #include <stdlib.h> int main() { int i, *min, *v; min = malloc(sizeof(int)); v = malloc(sizeof(int)); printf("inserisci 10 interi:\n"); scanf("%d", v); //printf("ho letto %d\n", *v); *min = *v; for(i = 1; i < 10; i++) { scanf("%d", v); //printf("ho letto %d\n", *v); if(*v < *min) *min = *v; } printf("minimo = %d\n", *min); free(v); free(min); return 0; } Pagina 41

42 Soluzioni Esercizio 6.4 Scrivere una funzione che dato in ingresso un puntatore ne stampi la dimensione in byte, il valore, l indirizzo di memoria ed il valore della variabile puntata. Scrivere un programma che ne verifichi il comportamento. Pagina 42

43 Soluzioni void infoptr_int(int **ptr) { printf("dimensione del puntatore: %d\n", sizeof(*ptr)); printf("valore del puntatore: %p\n", *ptr); printf("indirizzo del puntatore: %p\n", &(*ptr)); printf("dimensione della variabile puntata: " "%d\n", sizeof(**ptr)); printf("valore della variabile puntata: %d\n\n", **ptr); } Si provi a scrivere una funzione int main() { } int i = 5, *ptr_i; ptr_i = &i; infoptr_int(&ptr_i); void infoptr_double(double **ptr) Pagina 43