Puntatori. Unità 6. Corso di Laboratorio di Informatica Ingegneria Clinica BCLR. Domenico Daniele Bloisi

Transcript

1 Corso di Ingegneria Clinica BCLR Domenico Daniele Bloisi

2 Docente Ing. Domenico Daniele Bloisi, PhD Ricercatore Dipartimento di Ingegneria Informatica, Automatica e Gestionale Antonio Ruberti Via Ariosto 25 (adiacente Piazza Dante, Manzoni Tram 3 fermata via Labicana) bloisi@dis.uniroma1.it home page: Pagina 2

3 Ricevimento In aula, subito dopo le lezioni Su appuntamento (tramite invio di una ) presso: Dipartimento di Ingegneria Informatica, Automatica e Gestionale Antonio Ruberti, via Ariosto 25 - II piano, stanza A209 Si invitano gli studenti a controllare regolarmente la bacheca degli avvisi Pagina 3

4 Orari Lunedì Aula 4, via del Castro Laurenziano 7A Martedì Aula 15, Laboratorio Didattico via Tiburtina 205 Mercoledì Aula 4, via via del Castro Laurenziano 7A 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 Memoria, indirizzamento e puntatori L accesso memoria di un calcolatore avviene attraverso un meccanismo di indirizzamento. In C il programmatore ha la possibilità di gestire gli indirizzi attraverso delle variabili che vengono definite di tipo puntatore. I valori delle variabili di tipo puntatore sono indirizzi di memoria, ossia dei valori numerici che fanno riferimento a specifiche locazioni di memoria. Pagina 6

7 Notazione grafica L indirizzamento si rappresenta graficamente tramite una freccia. Spesso non occorre conoscere lo specifico valore di una variabile di tipo puntatore (es ). Pagina 7

8 Operatore indirizzo-di Per ottenere dei valori di tipo puntatore, cioè degli indirizzi, si utilizza l operatore & int i = 1; printf("l\' indirizzo di i e\' " "%p\n", &i); printf("mentre il valore di i e\' " "%d\n", i); stampa L' indirizzo di i e' 0028FF1C mentre il valore di i e' 1 Pagina 8

9 Operatore indirizzo-di Il simbolo & denota l operatore indirizzo-di. & restituisce l indirizzo della variabile a cui viene applicato. Nota: i = &10; non è ammesso poiché 10 è un letterale int. Analogamente, non si può accedere all indirizzo di una espressione. Nota: l indicatore di conversione per un indirizzo è %p e il formato di stampa è definito dall implementazione Pagina 9

10 Operatore di dereferenziamento (indirizzamento indiretto) Quando si considera una variabile di tipo puntatore, l operatore * permette di recuperare il valore della locazione di memoria puntata. int i, j = 1; i = *&j; L istruzione i = *&j; assegna il valore della variabile j alla variabile i. Equivale all istruzione i = j; L operatore (unario) di indirizzamento indiretto * non deve essere confuso con l operatore di moltiplicazione (binario). Pagina 10

11 Operatore di dereferenziamento (indirizzamento indiretto) int i, j = 1; i? j 1 i = *&j; &j *(&j) Valore contenuto in i 1 j 1 Pagina 11

12 Operatore & VS operatore * Se x è una variabile, &x denota l indirizzo in memoria di tale variabile. &x α nome x α indirizzo Se α è l indirizzo in memoria di una variabile, *α denota tale variabile: *α x Pagina 12

13 Variabili di tipo puntatore Per la gestione degli indirizzi occorre dichiarare delle variabili di tipo puntatore, specificando il tipo della locazione di memoria puntata. int *p1;... // allocazione di memoria (vedi dopo) *p1 = 10; dichiara una variabile di tipo puntatore ad intero e assegna alla variabile puntata il valore 10. Pagina 13

14 Attenzione 1. La dichiarazione di una variabile puntatore non alloca memoria per la variabile puntata; prima di accedere alla variabile puntata bisogna allocare esplicitamente memoria (vedremo dopo come ) 2. Nelle dichiarazioni multiple come la seguente int *p1, p2; p2 non è un puntatore! Pagina 14

15 Esempio Uso di variabili puntatore int i, j, k; int *pt_i, *pt_j; pt_i = &i; pt_j = &j; i = 1; j = 2; k = *pt_i + *pt_j; *pt_i = 10; printf("i = %d\n", i); printf("k = %d\n", k); Pagina 15

16 Diagramma della memoria Le variabili di tipo int i, j, k, vengono manipolate attraverso i puntatori alle locazioni di memoria ad esse associate al momento della dichiarazione. Pagina 16

17 Esecuzione Il programma stampa a video: i = 10 k = 3 Pagina 17

18 Assegnazione di un valore specifico a puntatore #include <stdio.h> int main() { int *ptr; ptr = 1000; *ptr = 5; printf("%d\n", *ptr); } Cosa stampa questo programma? Output del compilatore warning: assignment makes pointer from integer without a cast Pagina 18

19 Assegnazione di un valore specifico a puntatore L assegnazione di un indirizzo specifico a una variabile puntatore è da evitare, poiché può causare il crash del programma. Pagina 19

20 Accessi in memoria int i, j = 2, *pt; pt = &j; i = *pt; per ottenere il valore da assegnare a i devono essere fatti 2 accessi in memoria: Il primo accesso viene fatto all indirizzo di pt, per recuperare il dato ivi memorizzato, i.e. l indirizzo di j Il secondo accesso avviene all indirizzo di j, per recuperare il valore memorizzato nella variabile j Pagina 20

21 Esempio puntatori Consideriamo gli effetti del seguente codice: int *pointer; int x = 1, y = 2; pointer = &x; y = *pointer; x = pointer; *pointer = 3; // dichiara pointer come un // puntatore a int // (1) assegna a pointer l'indirizzo // di x (i.e., pointer punta x) // (2) assegna a y il contenuto di // pointer // (3) assegna ad x l'indirizzo // contenuto in pointer // (4) assegna alla variabile // puntata da pointer il valore 3 Pagina 21

22 Diagramma della memoria x 1 x y 2 (1) y pointer = &x; pointer? pointer Pagina 22

23 Diagramma della memoria x 1 x y 2 (2) y y = *pointer; pointer pointer Pagina 23

24 Diagramma della memoria x 1 x y 1 (3) y x = pointer; pointer pointer Pagina 24

25 Diagramma della memoria x x y 1 (4) y *pointer = 3; pointer pointer Pagina 25

26 Ricapitolando Possibili valori ottenibili tramite l utilizzo di variabili puntatore: pointer valore della variabile puntatore (cioè, l indirizzo della locazione di memoria a cui punta) &pointer indirizzo fisico della locazione di memoria del puntatore *pointer valore contenuto nella locazione di memoria a cui punta il puntatore Pagina 26

27 Operazioni sui puntatori A valori di tipo puntatore si applicano le operazioni del tipo int. Particolarmente utile è l operazione di incremento, ad es. int *pti;... pt++; che consente di puntare alla successiva locazione di tipo int. L uso di queste operazioni verrà approfondito nella Unità 7 Array e Matrici Pagina 27

28 costanti La specifica const può essere applicata anche a variabili di tipo puntatore. double pi = 3.5; double const *pt = π (*pt)++; // OK (pi vale 4.5) pt++; // NO (pt è costante) In questo caso, la specifica const si applica al puntatore, ma non alla variabile puntata. Pagina 28

29 a costanti Si può anche specificare che un puntatore debba puntare a costanti. const int k = 3; const int *pt; // dichiarazione di puntatore // a costante pt = &k; // OK pt++; int *pti; pti = &k; // NO // ammesso anche se non si sa cosa // vada a puntare pt Pagina 29

30 a puntatori Come per ogni altro tipo, si può definire un puntatore a una variabile di tipo puntatore. double x; double *pt; double **ptpt; x = 4; pt = &x; ptpt = &pt; printf("%f\n", **ptpt); Cosa stampa questo frammento di codice? Pagina 30

31 Diagramma della memoria stampa il valore di x Pagina 31

32 Il puntatore NULL (1/3) Le variabili di tipo puntatore possono assumere anche un valore speciale: NULL Questo valore serve a specificare che la variabile non punta alcuna locazione di memoria. In C tale valore in genere corrisponde allo 0, ma si raccomanda di usare NULL, in particolare per verificare che ad una variabile puntatore non sia associato uno specifico riferimento. NULL è una costante simbolica in genere definita in <stdio.h> Pagina 32

33 Il puntatore NULL (2/3) Non bisogna confondere le variabili il cui valore è NULL con le variabili non inizializzate: una variabile non inizializzata non ha alcun valore, neanche NULL. Il confronto con NULL può essere usato in una condizione di un istruzione if-else, for, etc. Pagina 33

34 Il puntatore NULL (3/3) Esempio int *pt = NULL; if(pt!= NULL) *pt = 10; Nell esempio il ramo if non viene eseguito. L istruzione *pt = 10; se fosse eseguita al momento in cui pt valesse NULL genererebbe un errore a tempo di esecuzione. Pagina 34

35 Il tipo void* (1/2) Mentre nel caso delle dichiarazioni dei tipi primitivi è indispensabile definire il tipo della variabile, per consentire al compilatore di allocare la memoria necessaria, nel caso dei puntatori, la memoria per il puntatore è fissa (corrisponde alla dimensione di un indirizzo di memoria) e, quindi, si può omettere la specifica del tipo della variabile puntata. void *pt; int i; pt = &i; Pagina 35

36 Il tipo void* (2/2) In caso di omessa specifica del tipo di dato per la variabile puntata: non sono più ammesse le operazioni sui puntatori il puntatore assegnato ad una variabile void* non può essere assegnato a una variabile di tipo puntatore (a un tipo definito). Pagina 36

37 Conversioni su puntatori Anche nel caso delle variabili di tipo puntatore sono possibili conversioni esplicite: void * pt; int i; pt = &i; int * pti; pti = (int*)pt; // il valore viene convertito // a puntatore a int Tuttavia, l utilizzo delle conversioni sui puntatori è sconsigliato, in quanto, spesso, provoca degli errori di programmazione. Pagina 37

38 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 e importante quando non sono note o prevedibili a priori le dimensioni dei dati in ingresso a un programma. Pagina 38

39 L operatore sizeof (1/2) Il numero di byte occupati da una variabile è dato dall applicazione di sizeof. Esempio sizeof(a) è il numero di byte occupati dalla variabile a Pagina 39

40 L operatore sizeof (2/2) L operatore sizeof può essere applicato a un tipo, a un nome di variabile o a una costante Restituisce la dimensione in byte dell oggetto passato come parametro Tale calcolo viene effettuato in compilazione in base al tipo di dato che viene passato a sizeof Se si incrementa un puntatore p, il suo valore numerico (indirizzo in memoria in byte) verrà incrementato di sizeof(*p) Pagina 40

41 Stampa indirizzo, occupazione di memoria e valore int main() { int a = 12; char b = 'a'; float c = ; printf ("Indirizzo di a e\' %x, occupa %d bytes," " il suo valore e\' %d\n", &a, sizeof(a), a); printf ("Indirizzo di b e\' %x, occupa %d bytes," " il suo valore e\' %c\n", &b, sizeof(b), b); printf ("Indirizzo di c e\' %x, occupa %d bytes," " il suo valore e\' %f\n", &c, sizeof(c), c); return EXIT_SUCCESS; } %x intero esadecimale senza segno Pagina 41

42 Esecuzione Pagina 42

43 Esercizio Esercizio 6.1 Si modifichi il codice precedente in modo da stampare la parola byte se l occupazione è pari a 1, mentre bytes se l occupazione è > 1 Esempio Indirizzo di b e' 28ff1b, occupa 1 byte, il suo valore e' a Pagina 43

44 Differenza tra valore e indirizzo di una variabile L indirizzo è dato in forma numerica (ma non di tipo numerico) ed è assegnato dal compilatore Il valore è assegnato dal programma Tutte le variabili dello stesso tipo occupano lo stesso numero di byte (hanno la medesima rappresentazione interna) Pagina 44

45 Applicazione di sizeof (1/2) Essendo un operatore, sizeof può essere utilizzato ponendo l operando tra parentesi oppure anche senza l utilizzo delle parentesi Le seguenti istruzioni sono equivalenti tra loro: char a = 'r'; int size_a; size_a = sizeof a; size_a = sizeof(a); Pagina 45

46 Applicazione di sizeof (2/2) Un eccezione a questa possibilità si ha nel caso seguente: int size_float; size_float = sizeof(float); size_float = sizeof float; // espressione // valida // errore in // compilazione quando l operando di sizeof è il nome di un tipo di dato (float, nell esempio), le parentesi sono obbligatorie. Pagina 46

47 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 esso non sia più necessario ai fini dell esecuzione. Il C offre la funzione malloc per riservare (allocare) uno spazio di memoria e la funzione free per rilasciare (deallocare) memoria. La funzione malloc e l operatore sizeof sono usati in combinazione per ottenere una allocazione dinamica della memoria. Pagina 47

48 Funzione malloc La funzione malloc permette di allocare dinamicamente una porzione (detta 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. E definita nella standard library - va inserita la direttiva #include <stdlib.h> size_t è definito come il tipo intero senza segno restituito dall operatore sizeof Pagina 48

49 Esempio malloc int *p; crea in memoria una variabile di tipo puntatore a int p = malloc(sizeof(int)); crea in memoria una variabile di tipo int restituisce l indirizzo della variabile creata (primo byte) assegna l indirizzo restituito a p *p = 7; la variabile di tipo int creata assume il valore 7 printf("%d", *p); viene stampato a video 7 Pagina 49

50 Modello di allocazione dinamica 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 termina con l istruzione exit(exit_failure); che notifica il fallimento. Pagina 50

51 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. Nota: ptr deve essere stato usato in una chiamata precedente a malloc() E definita nella standard library (<stdlib.h>) Pagina 51

52 Esempio 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 52

53 Esercizi 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. Esercizio 6.3 Scrivere il programma dell esercizio precedente tramite allocazione dinamica della memoria. Deallocare la memoria utilizzata prima della terminazione del programma. Pagina 53

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