Introduzione al C. Unità 6 Puntatori. S. Salza, C. Ciccotelli, D. Bloisi, S. Peluso, A. Pennisi

Transcript

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

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

3 Indirizzamento e puntatori In C il programmatore ha la possibilità di gestire gli indirizzi attraverso delle variabili 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 3

4 Rappresentazione grafica L indirizzamento si può rappresentare graficamente mediante una freccia. Spesso non occorre conoscere lo specifico valore di una variabile di tipo puntatore (es ). Pagina 4

5 Operatore & (indirizzo di) 1/2 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); Questo codice genera la stampa L'indirizzo di i e' 0028FF1C mentre il valore di i e' 1 Pagina 5

6 Operatore & (indirizzo di) 2/2 L operatore & si chiama operatore indirizzo-di e restituisce l indirizzo della variabile a cui viene applicato. NOTA i = &10; Non è ammesso dato che 10 è una costante int. Analogamente non si può accedere all indirizzo di una espressione. NOTA l indicatore di conversione per un indirizzo è %p (il formato è definito dall implementazione) Pagina 6

7 Operatore * di dereferenziamento 1/2 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 (con notazione un po complicata) il valore della variabile j alla variabile i. Equivale, in pratica, all istruzione i=j; L operatore (unario) di indirizzamento indiretto * non deve essere confuso con l operatore di moltiplicazione (binario). Pagina 7

8 Operatore * di dereferenziamento 2/2 int i, j = 1; i? j 1 i = *&j; &j *(&j) Valore contenuto in i 1 j 1 Pagina 8

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

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

11 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 tipo: int *p1, p2; p2 non è un puntatore! Pagina 11

12 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 12

13 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 13

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

15 Assegnazione di valori a puntatori #include <stdio.h> int main() { int *ptr; ptr = 1000; *ptr = 5; printf("%d\n", *ptr); Cosa stampa questo codice? Proteste del compilatore warning: assignment makes pointer from integer without a cast Pagina 15

16 Accesso ai valori puntati 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 16

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

18 Diagramma della memoria 1/4 x x y (1) y pointer 12098? pointer = &x; pointer Pagina 18

19 Diagramma della memoria 2/4 x x y (2) y pointer y = *pointer; pointer Pagina 19

20 Diagramma della memoria 3/4 x x y (3) y pointer x = pointer; pointer Pagina 20

21 Diagramma della memoria 4/4 x x y (4) y pointer *pointer = 3; pointer Pagina 21

22 Ricapitolando Possibili valori ottenibili tramite l utilizzo di variabili puntatore: pointer valore della variabile puntatore (i.e., l indirizzo della locazione di memoria a cui punta) &pointer indirizzo della locazione di memoria del puntatore *pointer valore contenuto nella locazione di memoria indirizzata dal puntatore Pagina 22

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

24 Puntatori 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 e costante!) In questo caso, la specifica const si applica al puntatore, ma non alla variabile puntata Cioè, quello che rimane (e deve rimanere) costante è il valore di pt cioè l indirizzo a cui punta Pagina 24

25 Puntatori 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++; // // ammesso anche vada a puntare se non si sa cosa pt (*pt)++; // NO In questo caso è l oggetto puntato, cioè k, che deve rimanere costante Pagina 25

26 Tutte le combinazioni Puntatore non costante a dati non costanti Es: char *pt Puntatore costante a dati non costanti Es: char * const pt Puntatore non costante a dati costanti Es: const char *pt Puntatore costante a dati costanti Es: const char * const pt Pagina 26

27 Perché queste dichiarazioni? Queste dichiarazioni si usano per proteggere i dati da modifiche non volute o non desiderate Questo può essere opportuno sia per la variabile puntata che per il puntatore stesso Situazione tipica è quella del passaggio di parametri a una funzione: se si usano i puntatori è sempre per riferimento In questo caso si può voler evitare che la funzione modifichi i parametri che le sono passati Il criterio tipico è quello del minimo privilegio: la funzione deve poter vedere e modificare il mino necessario Pagina 27

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

29 Diagramma della memoria Stampa il valore di x. Pagina 29

30 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 quando si vuole verificare che ad una variabile puntatore non sia associato uno specifico riferimento. NULL è una costante simbolica in genere definita in <stdio.h> Pagina 30

31 Il puntatore NULL 2/3 Si faccia attenzione a non confondere variabili il cui valore è NULL con 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 31

32 Il puntatore NULL 3/3 ESEMPIO int *pt = NULL; if (pt!= NULL) *pt = 10; In questo caso il ramo if non viene eseguito. L istruzione *pt = 10; eseguita al momento in cui pt vale NULL genererebbe un errore a tempo di esecuzione. Pagina 32

33 Il tipo void* 1/2 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 e corrisponde alla dimensione di un indirizzo di memoria Quindi si può omettere la specifica del tipo della variabile puntata. void *pt; int i; pt = &i; Pagina 33

34 Il tipo void* 2/2 Se il tipo della variabile puntata non è specificato, però ci sono delle restrizioni Non sono più ammesse operazioni sui puntatori Il puntatore assegnato ad una variabile void* non può essere assegnato ad una variabile di tipo puntatore (ad un tipo definito). Pagina 34

35 Conversioni sui puntatori Anche nel caso delle variabili di tipo puntatore sono possibili conversioni esplicite (casting): void *pt; int i; pt = &i; int *pti; pti = (int*) pt;// valore di pt convertito // a puntatore a int Pagina 35

36 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 36

37 Operatore sizeof 2/2 L operatore sizeof può essere applicato ad un tipo, ad un nome di variabile o ad 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), cioè della dimensione di un dato del tipo puntato da p Pagina 37

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

39 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: chara = 'r'; int size_a; size_a = sizeof(a); size_a = sizeof a Pagina 39

40 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 // NO errore in // compilazione Quando l operando di sizeof è il nome di un tipo di dato (float, nell esempio), le parentesi sono obbligatorie. Pagina 40

41 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 41

42 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 Nella chiamata per valore si ha la garanzia che la funzione non abbia effetti sul programma chiamante (ad eccezione della restituzione del valore calcolato) Se il parametro è un puntatore, la funzione chiamata non modifica il puntatore, ma può modificare la variabile puntata Pagina 42

43 Passaggio parametri puntatore 1/3 void swap(int *a, int *b) { int temp; temp = *a; *a = *b; *b = temp; } La funzione swap non modifica il valore dei parametri *a e *b Tuttavia modifica il valore di a e di b è come se a e b fossero state passaste per riferimento Pagina 43

44 Passaggio parametri puntatore 2/3 int main (){ int x, y; x = 12; y printf("x } = 27; = %d\n", x); printf("y = %d\n", y); swap(&x, &y); printf("after swap\n"); printf("x printf("y = %d\n", x); = %d\n", y); Pagina 44

45 Passaggio parametri puntatore 3/3 Risultato dell'esecuzione x = 12 y = 27 after swap x = 27 y = 12 Pagina 45

46 Passaggio parametri puntatore 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 46

47 Passaggio per valore e per riferimento 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 N.B. swapval non produce effetti, cioè non restituisce gli argomenti a e b con i valori scambiati Pagina 47

48 Funzione con parametri puntatore Prototipo della funzione void f(int* param1, double* param2); Parametro formale di tipo puntatore ad int Parametro formale di tipo puntatore a double Pagina 48

49 Chiamata con parametri puntatore 1/3 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 dove i valori sono memorizzati a b &a 2 &b 3.2 int a; double b; a = 2; b = 3.2; f(&a, &b); Pagina 49

50 Chiamata con parametri puntatore 2/3 FUNZIONE CHIAMATA 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, double *pb) { *pa = 6; *pb = 7.4; } Pagina 50

51 Chiamata con parametri puntatore 3/3 ESECUZIONE a &a 6 int a; double b; a = 2; b = 3.2; f(&a, &b); pa &pa b &b 7.4 int *pa=&a; int *pb=&b; pb &pb void f(int *pa, int *pb) { *pa = 6; *pb = 7.4; } Pagina 51

52 Vantaggi 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 di un puntatore 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 52

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

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