I puntatori (richiamo)

Transcript

1 I puntatori (richiamo) Puntatori Un puntatore è una variabile che assume come valore un indirizzo in memoria L uso dei puntatori permette di: mantenere riferimenti ad altre variabili (è un punto di accesso ad altre variabili) definire strutture dati dinamiche realizzare il passaggio di parametri per riferimento 1

2 Puntatori La sintassi per dichiarare un puntatore è la seguente: <tipo base> *<identificatore>; Esempio: int *pi; pi è un puntatore esclusivamente a variabili di tipo intero Altri esempi: int *pi1, *pi2, i, j; float f, *pf; double *pd, d; Notare che le seguenti scritture sono tutte lecite ed equivalenti: int* pi; int * pi; int *pi; Assegnamento Posso allora scrivere: int v = 5; //definisco la variabile v inizializzata al valore 5 5 v int *pi; //dichiaro il puntatore pi, il cui valore non è inizializzato pi pi = &v; //assegno a pi l indirizzo di v pi 5 v 2

3 Assegnamento int b = *pi; //(dereferenziamento) assegno a b il valore della variabile puntata da pi (cioè il valore di v, 5) 5 b pi 5 v *pi = 9;//assegno 9 alla variabile puntata da pi, cioè a v 9 Lab. Programmazione I - a.a pi v L espressione *pi è di tipo intero e può quindi ricorrere all interno di altre espressioni esattamente come l espressione v Rappresentazione in memoria A voler essere più precisi, la situazione in memoria è la seguente: 0xbacd7000 0xbacd7a1c pi. pi è una variabile che come valori può assumere indirizzi di variabili intere 0xbacd7a1c 0xbacd7a v b 3

4 Differenza tra dichiarazione e dereferenziamento Attenzione a non confondere la dichiarazione di un tipo puntatore con l operatore di dereferenziamento. Entrambi usano il carattere * ma il significato è differente int *pi; //dichiarazione del puntatore a interi pi *pi = 5; //dereferenziamento, cioè attraversamento del puntatore e assegnamento del valore 5 alla cella di memoria puntata da pi Inizializzazione di puntatori I puntatori (come tutte le altre variabili) devono venire inizializzati prima di essere usati È un errore dereferenziare una variabile puntatore non inizializzata Esempio: int a; int *pi; a = *pi; //primo errore: assegniamo un valore indeterminato ad a (infatti non sappiamo dove stia puntando pi) *pi = 10;//secondo errore: assegniamo il valore 10 a una cella di memoria che potrebbe non appartenere al nostro programma; a runtime il nostro programma termina bruscamente con il peggior messaggio possibile: segmentation fault 4

5 Passaggio dei parametri per valore e per riferimento Record di attivazione (cenni) All atto dell invocazione di una funzione: 1. Si alloca sullo una zona di memoria (record di attivazione) che, tra le altre cose, contiene i parametri e le eventuali variabili locali della funzione 2. Si copiano i parametri nel record di attivazione 3. Si esegue il codice della funzione Quando la funzione termina, si ritorna ad eseguire il codice della funzione chiamante, restituendo ad essa l eventuale valore di ritorno e il record di attivazione viene distrutto Il record di attivazione verrà trattato con dovizia di particolari in corsi successivi 5

6 Passaggio per valore Passaggio per valore (by value) si trasferisce una copia del parametro effettivo tale copia è strettamente privata e locale alla funzione chiamata la funzione può quindi alterare il valore ricevuto senza alcun impatto sul chiamante Conseguenza: è impossibile usare un parametro per trasferire informazioni verso il chiamante per trasferire un informazione al chiamante si deve sfruttare il valore di ritorno della funzione Il C fornisce esclusivamente il passaggio per valore Esempio int incr(int i) { i = i+1; return i; int (void) { int m = 5; int val = incr(m); return 0; Quanto vale val? Quanto invece m? 6

7 Prima dell invocazione della funzione incr, sullo si trova il record di attivazione (RdA) del m = 5 val =? incr i = 5 All invocazione della funzione incr, viene aggiunto sullo il RdA di incr. Poiché il passaggio dei parametri è per valore, nel parametro n di incr viene copiato il valore del parametro m m = 5 val =? 7

8 Viene eseguito il corpo della funzione incr incr i = 6 m = 5 val =? Al termine della funzione incr, il controllo torna al e il RdA di incr viene rimosso dallo Il valore di ritorno viene assegnato alla variabile val del m = 5 val = 6 Il valore di m non è cambiato 8

9 Passaggio per riferimento in C Il passaggio per valore non è sufficiente: ci possono essere casi in cui risulta utile che una funzione alteri il valore di un parametro Dato che il C offre supporto esclusivamente al passaggio per valore (il C++, invece, anche al passaggio per riferimento), utilizziamo i puntatori per simulare il passaggio per riferimento in questo modo: non trasferiamo per valore come parametro la variabile, ma l indirizzo della variabile La funzione chiamata, avendone l indirizzo, può accedere direttamente alla variabile in possesso del chiamante e può modificarla Esempio void incr(int *pi) { *pi = *pi + 1; int (void) { int m = 5; incr(&m); return 0; Con &m passiamo a incr l indirizzo di m. In questo modo incr, usando il puntatore *pi, può modificare direttamente il valore della variabile nella funzione 9

10 Come già visto, prima dell invocazione della funzione incr, sullo si trova il RdA del m = 5 incr pi All invocazione della funzione incr, viene aggiunto sullo il RdA di incr. Nel parametro pi di incr viene copiato l indirizzo della variabile m, quindi pi punta alla variabile m nel m = 5 10

11 Viene eseguito il corpo della funzione incr, che modifica *pi, cioè direttamente la variabile m del incr pi m = 6 Al termine della funzione incr, il controllo torna al e il RdA di incr viene rimosso dallo m = 6 11

12 Relazione tra array e puntatori Aritmetica dei puntatori Array e Puntatori In generale, quando in C definiamo una struttura dati, non sappiamo cosa contengono celle di memoria adiacenti. L unico caso in cui sappiamo quali sono le locazioni di memoria successive e cosa contengono è quando utilizziamo gli array Infatti, in C gli elementi di un array sono allocati in memoria in modo contiguo In C array e puntatori sono intimamente correlati: la variabile usata come array è in realtà un puntatore che punta alla base dell array, cioè all elemento con indice 0 a int a[5]; 12

13 Array e Puntatori Quindi, quando definiamo un array, implicitamente definiamo un puntatore al primo elemento dell array Esempio: dichiarando int a[5]; è come se stessimo dichiarando non solo un array ma anche un puntatore a interi int *a; il cui valore corrisponde all indirizzo base dell array Infatti, provate con: a == &a[0]; printf("%p %p", a, &a[0]): stampa due volte lo stesso indirizzo Array e Puntatori Attenzione: in generale int a[5] e int* a non sono equivalenti per due motivi Primo motivo: quando si dichiara il puntatore la memoria non viene allocata automaticamente: int a[5]; //riserva una quantità di memoria sufficiente a memorizzare 5 interi (su molte macchine 20 byte) a int *a; //riserva una quantità di memoria sufficiente a memorizzare un indirizzo a 13

14 Array e Puntatori Secondo motivo: non è possibile modificare l indirizzo di base di un array, quindi, definendo int a[5], a è un puntatore costante e non è possibile modificare il suo valore In altre parole, essendo a un puntatore costante, non può comparire a sinistra in un assegnamento int a[5]; int *pa; a = pa; ß ILLEGALE Però si può fare il viceversa: pa = a; //è del tutto analogo a pa=&a[0] Infatti pa è una variabile. Dunque espressioni come pa++ e pa = a sono legali Array e Puntatori Il C sfrutta i puntatori e l allocazione contigua di un array per offrire l aritmetica dei puntatori, che permette di eseguire alcune operazioni aritmetiche sui puntatori, per esempio sommare un intero a un puntatore Sfruttando l aritmetica dei puntatori è possibile accedere agli elementi di un array in un modo alternativo a quello di indicare l indice tra parentesi quadre, cioè attraverso un puntatore all indirizzo base dell array stesso 14

15 Array e Puntatori int a[5]; int *pi = a; *(pi + 3) = 28; // pi+3 punta all elemento di indice 3 dell array; uguale a a[3]=28 Il 3 viene detto offset (o scostamento) del puntatore Servono le parentesi perché * ha priorità maggiore di + a[5] pi pi+3 Array e Puntatori Se a è memorizzato a partire dall indirizzo 2000, a (e pi) valgono 2000 Però pi + 3 non vale 2003 perché il C tiene conto dello spazio occupato da ogni singolo elemento puntato. In questo caso, supponendo che un int occupi 4 byte, quindi, pi + 3 varrà 2012 e *(pi + 3) equivale ad a[3] 15

16 Array e Puntatori Che cosa denota *pi + 3? Avrebbe senso scrivere *pi + 3 = 28? Osservazione: &a[3] equivale a &(a[3]), a pi+3 e a a+3 *&a[3] equivale a *(pi+3) e a *(a+3) Inoltre, *&a[3] equivale a a[3] Array e Puntatori Dato un array int b[4] scrivere almeno tre diversi modi per stampare con un ciclo for gli elementi dell array usando array, indici, puntatori, aritmetica dei puntatori 16

17 Array e Puntatori 1. Con array e indice: int i; for (i=0; i<4; i++) printf("b[%d] = %d\n", i, b[i]); 2. Con puntatore e aritmetica dei puntatori: int i, *pi = b; for (i=0; i<4; i++) printf("*(pi+%d) = %d\n", i, *(pi + i)); 3. Con puntatore e indici: int i, *pi = b; for (i=0; i<4; i++) printf("pi[%d] = %d\n", i, pi[i]); Array e Puntatori 4. Con array e aritmetica dei puntatori: int i; for (i=0; i<4; i++) printf("*(b+%d) = %d\n", i, *(b + i)); 5. Con puntatore, aritmetica dei puntatori e incrementando direttamente il puntatore int i, *pi; for (pi=b, i=0; i<4; i++, pi++) printf("*pi = %d\n", *pi); A cosa punta pi al termine del ciclo? 17

18 Esempio Stabiliamo la lunghezza di una stringa usando i puntatori int string_length(char s[]) { int n; for (n = 0; *s!= '\0'; s++, n++); return n; Il punto e virgola al termine dell istruzione for significa che il corpo del for non contiene istruzioni (ma n (e s) vengono comunque incrementati!) Utilizzare i puntatori rende il codice generalmente meno leggibile, ma il compilatore potrebbe riuscire a trarne vantaggio e a produrre un modulo oggetto più efficiente Passaggio di array come parametri Cosa succede quando si passa un array come parametro? Bisogna ricordare che il nome dell array corrisponde all indirizzo del primo elemento dell array Quindi abbiamo un passaggio per riferimento dell array 18

19 Passaggio di array come parametri Sia int a[] che int* a si riferiscono a puntatori a interi La definizione di funzione void myfunction(int a[]) { è equivalente a void myfunction(int *a) { In entrambi i casi myfunction riceve un puntatore al primo elemento dell array Si noti che la funzione non ha modo di sapere quanto è lungo l array: o la lunghezza è nota in qualche modo (ad es. per una #define o perché è una stringa correttamente terminata da '\0') o la lunghezza deve essere un parametro Esempio #include <stdio.h> #include <ctype.h> //per il prototipo di toupper void inmaiuscolo(char s[]) { int i; for (i=0; s[i]!= '\0'; i++) s[i] = toupper(s[i]); //rende un carattere maiuscolo int (void) { char str[] = "PiPpO"; inmaiuscolo(str); printf("%s\n", str); return 0; 19

20 Ingresso nella funzione inmaiuscolo: inmaiuscolo s str "PiPpO" void inmaiuscolo(char s[]) { int i; for(i=0; s[i]!='\0'; i++) s[i] = toupper(s[i]); Uscita dalla funzione inmaiuscolo: inmaiuscolo s void inmaiuscolo(char s[]) { int i; for(i=0; s[i]!='\0'; i++) s[i] = toupper(s[i]); str "PIPPO" 20

21 Passaggio di array come parametri La funzione inmaiuscolo modifica la stringa str passata come parametro perché il nome di un array corrisponde a un puntatore al primo elemento dell array Quindi alla funzione inmaiuscolo viene passato per valore un puntatore al primo elemento dell array La funzione non può modificare il puntatore ma può modificare gli elementi dell array Passaggio di array come parametri Cosa succede in questo caso errato? #include <stdio.h> #include <ctype.h> #define MAXSTRING 10 void inmaiuscolono1(char s[]) { char s1[maxstring]; int i; for(i=0; s[i]!= '\0'; i++) s1[i] = toupper(s[i]); s1[i] = '\0'; s = s1; int (void) { char str[] = "PiPpO"; inmaiuscolono1(str); printf("%s\n", str); return 0; 21

22 inmaiuscolono1 s s1 "@$GSf%^" i str "PiPpO" Ingresso nella funzione inmaiuscolono1: void inmaiuscolono1(char s[]) { char s1[maxstring]; int i; for(i=0;s[i]!='\0';i++) s1[i] = toupper(s[i]); s1[i] = '\0'; s = s1; inmaiuscolono1 s s1 "PIPPO" i=5 str void inmaiuscolono1(char s[]) { char s1[maxstring]; int i; for(i=0;s[i]!='\0';i++) s1[i] = toupper(s[i]); s1[i] = '\0'; s = s1; "PiPpO" 22

23 inmaiuscolono1 s s1 "PIPPO" i=5 str "PiPpO" void inmaiuscolono1(char s[]) { char s1[maxstring]; int i; for(i=0;s[i]!='\0';i++) s1[i] = toupper(s[i]); s1[i] = '\0'; s = s1; Dato che il parametro s era un puntatore passato per valore, l ultimo assegnamento (s=s1) è inutile dato che il RdA di inmaiuscolono1 viene rimosso dallo str "PiPpO" 23

24 Passaggio di array come parametri Cosa succede in questo altro caso (errato)? #include <stdio.h> #include <ctype.h> #define MAXSTRING 10 char* inmaiuscolono2(char s[]) { char s1[maxstring]; int i; for(i=0;s[i]!='\0';i++) s1[i] = toupper(s[i]); s1[i] = '\0'; return s1; int (void) { char str[] = "PiPpO"; char *str2 = inmaiuscolono2(str); printf("%s\n", str2); return 0; Passaggio di array come parametri Il compilatore genera un avvertimento: warning: address of memory associated with local variable 's1' returned Infatti s1 è un array locale alla funzione (viene allocato nel RdA della funzione): la funzione restituisce un puntatore s1 ma, quando si esce dalla funzione, l array (insieme al resto del RdA) viene deallocato e il non può accedervi 24

25 inmaiuscolono2 s s1 "@$GSf%^" i str "PiPpO" str2 Ingresso nella funzione inmaiuscolono2: char* inmaiuscolono2(char s[]) { char s1[maxstring]; int i; for(i=0;s[i]!='\0';i++) s1[i] = toupper(s[i]); s1[i] = '\0'; return s1; inmaiuscolono2 s s1 "PIPPO" i=5 str "PiPpO" str2 char* inmaiuscolono2(char s[]) { char s1[maxstring]; int i; for(i=0;s[i]!='\0';i++) s1[i] = toupper(s[i]); s1[i] = '\0'; return s1; 25

26 str "PiPpO" str2 All uscita dalla funzione, il suo RdA viene rimosso dallo compresa la stringa convertita. str2 punta a una zona di memoria che è non più allocata e la printf successiva ha un comportamento imprevedibile int (void) { char str[]="pippo"; char *str2=inmaiuscolono2(str); printf("%s\n", str2); return 0; 26