Un puntatore è una variabile che contiene l indirizzo di una variabile. Una variabile di tipo puntatore è dichiarata tramite il costruttore di tipo *

Transcript

1 PUNTATORI Un untatore è una variabile che contiene l indirizzo di una variabile var. di tio "untatore a variabile di tio T" indir. di variab. variabile di tio T valore di tio T Una variabile di tio untatore è dichiarata tramite il costruttore di tio * TioDato * NomeVarPuntatore ; dichiarazione eslicita di un nuovo tio NomeTioPuntatore tyedef TioDato * NomeTioPuntatore ; Oeratore di dereferenziazione * È l oeratore unario che alicato ad un untatore restituisce il valore untato da. ATTENZIONE: distinguere tra l uso dell asterisco nell ambito della fase di definizione delle variabili untatori (l asterisco indica che è un untatore a un certo tio) l uso dell asterisco nelle istruzioni (indica che si vuole far riferimento non al untatore stesso ma a ció che esso unta) IL LINGUAGGIO C - IL TIPO PUNTATORE 1

2 Esemi: int *; /* è un untatore ad int */ int x = 0; situazione iniziale *= 10; x = *; x 0 x 0 x 10 indef Oeratore indirizzo di & È l oeratore unario che alicato ad una variabile o elemento di array X ne restituisce il suo indirizzo. &X è l indirizzo della variabile X, quindi è un untatore a X IL LINGUAGGIO C - IL TIPO PUNTATORE 2

3 Esemi: int *; /* è un untatore ad int */ int x = 0, y; situazione iniziale = &x; x 0 indef y indef y = *; x 0 x 0 y indef y 0 Si introduce un altra variabile untatore int *q; /* q è un untatore ad int */ q = ; q x 0 y 0 IL LINGUAGGIO C - IL TIPO PUNTATORE 3

4 PUNTATORI ED ARRAY In C c e una forte relazione tra untatori ed array derivante dal fatto che gli elementi di un array vengono allocati in memoria in celle consecutive. La dimensione di tali celle diende dal tio degli elementi dell array. Esemi (il simbolo? indica un valore indefinito): int *; /* è un untatore ad int */ int a[5]; /* a è un array di 5 interi */ Situazione iniziale? a:????? a[0] a[1] a[2] a[3] a[4] = &a[0]; a:????? a[0] a[1] a[2] a[3] a[4] ++; a:????? a[0] a[1] a[2] a[3] a[4] *(+2)=7; a:??? 7? a[0] a[1] a[2] a[3] a[4] IL LINGUAGGIO C - IL TIPO PUNTATORE 4

5 PUNTATORI ED ARRAY - 2 Per definizione, data una variabile a di tio array il suo valore è l indirizzo dell elemento zero dell array. Pertanto =&a[0]; equivale a =a; In C, la relazione tra untatori e array è anche sintattica: Se si dichiara un array a: a[i] uò essere scritto come &a[i] uò essere scritto come Se si dichiara un untatore : *(+i) uò essere scritto come *(a+i) a+i [i] In C, l unica differenza tra untatori e array è la seguente: int *; /* è un untatore ad int */ int a[5]; /* a è un array di 5 interi */ è una variabile di tio untatore, quindi è lecito fare ++ e =a; a è una variabile di tio array, quindi non è lecito fare a++ e a=; Le recedenti considerazioni sono valide anche er array multidimensionali. Esemi: int *; /* è un untatore ad int */ int a[5][10]; /* a è un array di 5X10 interi */ =&a[0][0]; =+2; /* ora unta all elemento a[0][2] */ =+9; /* ora unta all elemento a[1][1] */ IL LINGUAGGIO C - IL TIPO PUNTATORE 5

6 OPERAZIONI SULLE VARIABILI DI TIPO PUNTATORE l assegnamento dell indirizzo di una variabile tramite l oeratore & l oerazione di dereferenziazione, tramite l oeratore *; l assegnamento del valore di un altro untatore; oerazioni aritmetiche di somma e di sottrazione, di incremento e decremento È generalmente ossibile sommare e sottrarre variabili untatore che untano allo stesso tio di dato tra di loro o con interi. È imortante osservare che in tali oerazioni si considera il valore logico del untatore e non quello reale: Se ad esemio è un untatore ad un tio che occua due byte di memoria, la situazione uò essere schematizzata come segue: 0000 memoria:??????? ? 1111 allora l istruzione =+2; rovoca l incremento di 2 del valore logico che equivale ad un incremento di 4 del valore reale: 0100 memoria:??????? ? 1111 Per questo motivo, tali oerazioni sono generalmente significative solo nel caso in cui si tratti di untatori ad elementi di un array. IL LINGUAGGIO C - IL TIPO PUNTATORE 6

7 Esemi: OPERAZIONI SULLE VARIABILI DI TIPO PUNTATORE - 2 int *,*q; /* e q sono untatori ad int */ char *y /* y e un untatore a char*/ int a[5]; /* a è un array di 5 interi */ =&a[2]; /* unta all elemento a[2] dell array */ q=&a[4]; /* unta all elemento a[4] dell array */ allora q- ha valore 2, ovvero il numero di elementi esistenti tra l elemento a cui unta q e l elemento a cui unta. =-q; //NO if (>q); // SI if (>y); // NO if (-q==2); // SI if (+q==2); // NO if (-y==2); // NO l assegnamento del valore NULL: se una variabile untatore P ha valore NULL *P è indefinito. In effetti, NULL è una costante intera di valore zero definita in <stdio.h>. Il valore zero è l unico valore intero che uò essere assegnato ad un untatore. il confronto basato sugli oeratori relazionali Generalmente il confronto uò essere fatto tra due generici untatori che untano allo stesso tio di dato; questo confronto è comunque significativo solo nel caso in cui due untatori e q untano agli elementi dello stesso array: in tal caso, ad esemio, <q significa che unta ad un elemento che recede quello untato da q. IL LINGUAGGIO C - IL TIPO PUNTATORE 7

8 STRINGHE E PUNTATORI Costante stringa È una sequenza di caratteri racchiusa tra "..." È considerata un array di caratteri, terminato con il carattere nullo '\0' Ad esemio, la costante "e una rova" equivale al seguente array e ' u n a r o v a \0 Allora, se si definisce char *; /* è un untatore ad un carattere */ è ossibile la seguente istruzione = "e una rova"; che assegna al untatore l indirizzo dell elemento zero dell array di caratteri. e ' u n a r o v a \0 Esemio: coia della stringa untata da nella stringa untata da q. char *,*q; = "e una rova"; q = "stringa da sostituire"; while (*!= \0 ){ } *q = *; ++; q++; *q= \0 ; Si noti che con l istruzione q=; si sarebbero coiati solo i untatori e non i caratteri. IL LINGUAGGIO C - IL TIPO PUNTATORE 8

9 PUNTATORI E FUNZIONI int LunghezzaStringa(char *S) { int lunghezza=0; /* la lunghezza di una stringa vuota e 0 */ while (*S!='\0'){ lunghezza++; S++; } return lunghezza; } /* fine della funzione LunghezzaStringa */ #include <stdio.h> main() { char *; int LunghezzaStringa(char *S); /* rototio */ rintf("%d\n",lunghezzastringa()); /* il risultato è indefinito */ = "e una rova"; rintf("%d\n",lunghezzastringa()); /* il risultato è 12 */ = ""; rintf("%d\n",lunghezzastringa()); /* il risultato è 0 */ } /* fine del main */ IL LINGUAGGIO C - IL TIPO PUNTATORE 9

10 ARRAY E FUNZIONI Quando il nome di un array è assato ad una funzione, viene assata la locazione dell elemento iniziale. main() { char a[10]; int LunghezzaStringa(char *S); \* rototio *\ rintf("%d\n",lunghezzastringa(a)); /* il risultato è indefinito */ rintf("%d\n",lunghezzastringa("e una rova")); /* il risultato è 12 */ rintf("%d\n",lunghezzastringa("")); /* il risultato è 0 */ } /* fine del main */ IL LINGUAGGIO C - IL TIPO PUNTATORE 10

11 PUNTATORI E FUNZIONI: ESEMPI /* restituisce 1 se S==T, 0 se S!=T */ int StringaUgualeA(char *S, char *T) { while (*S==*T) { if (*S== '\0') return 1; S++; T++; } return 0; } /* restituisce 1 se S<T, 0 se S==T oure se S>T */ int StringaMinoreDi(char *S, char *T) { int risult; while (*S==*T) { if (*S== '\0') return 0; S++; T++; } risult = (*S<*T); return risult; } IL LINGUAGGIO C - IL TIPO PUNTATORE 11

12 COMPOSIZIONE DI TIPI PUNTATORI Il costruttore di tio * uò essere innestato con se stesso e con gli altri costruttori di tii strutturati (array e record). tyedef int *PuntInt; tyedef PuntInt *DoioPuntInt; DoioPuntInt ; PuntInt *qq; int **rr; PuntInt, q; int x=0; La variabile di tio DoioPuntInt unta ad una variabile di tio PuntInt che quindi a sua volta unta ad una variabile di tio int. Lo stesso effetto si ottiene con le variabili qq e rr. IL LINGUAGGIO C - IL TIPO PUNTATORE 12

13 COMPOSIZIONE DI TIPI PUNTATORI CON TIPI RECORD tyedef struct { int Giorno, Mese, Anno; } Data; Data *P; Data D; P =&D; (*P).Anno=1997; Le arentesi in (*P).Anno sono necessarie in quanto l oeratore. ha una recedenza iù alta di quella dell oeratore di dereferenziazione *: senza arentesi *P.Anno signidfica *(P.Anno) che è un errore in quanto Anno non è un untatore. Siccome i untatori alle strutture sono molto frequenti, in C c è l oeratore -> in modo da oter scrivere l esressione (*P).Anno=1997 come P->Anno=1997; In generale se P è un untatore ad un record e NomeCamo è il nome di un camo di tale record, allora: P->NomeCamo è il valore del camo NomeCamo. IL LINGUAGGIO C - IL TIPO PUNTATORE 13

14 Allocazione e deallocazione di memoria in C: malloc e free In molti rogrammi non si uó saere a riori quanto sazio di memoria er le variabili si deve utilizzare - si legge da un file una serie di numeri da mettere in un array à quanto va dichiarato grande l array; - si leggono dei dati forniti dall utente in modo interattivo e imrevedibile - 1 Soluzione (ERRATA): Dichiarare tante variabili quante ne otrebbero servire nel caso eggiore. C e sreco di memoria e uó darsi non si saia quale è il caso eggiore - 2 Soluzione (GIUSTA): Si usa un metodo che ermette, dinamicamente durante l esecuzione di un rogramma, di allocare memoria al rogramma e, eventualmente, deallocarla. Esiste uno sazio di memoria aosito nei sistemi di calcolo moderni (chiamato HEAP) che viene messo a disosizione dei rogrammi rorio dal Sis. O. La Libreria Standard mette a disosizione funzioni e costanti er gestire la memoria HEAP. - la funzione di allocazione malloc - la funzione di deallocazione free, entrambe dichiarate nel header file stdlib.h - la costante NULL, con valore 0, che indica il valore nullo er una variabile untatore. IL LINGUAGGIO C - IL TIPO PUNTATORE 14

15 MALLOC La funzione di allocazione malloc, che ha la seguente intestazione: void *malloc(int NumByte) alloca NumByte byte di memoria e restituisce un untatore a tale memoria. restituisce il untatore NULL se non è ossibile allocare la memoria richiesta (ad esemio, erchè non c è memoria sufficiente). Il untatore restituito da malloc è un untatore al tio generico void e er oterlo utilizzare si deve effettuare il casting al tio aroriato. Esemio, er allocare dinamicamente una variabile intera (2 byte) si otrebbe fare int *P; P = (int*)malloc(2); erò la dimensione del tio int diende dal comilatore e inoltre non semre è facile calcolare la dimensione della variabile da allocare (si ensi ad una variabile di tio record). Generalmente si usa come argomento della malloc l'oeratore sizeof: P = (int*)malloc(sizeof(int)); IL LINGUAGGIO C - IL TIPO PUNTATORE 15

16 FREE Doo che la variabile dinamica è stata utilizzata e non è iù necessaria, sarebbe meglio rimuoverla eslicitamente in modo da recuerare la memoria che essa occuava. Funzione di deallocazione free, la cui intestazione è la seguente: void free(void *P) Pertanto l'istruzione free(p) libera l area di memoria indirizzata da P e successive chiamate di malloc otranno, eventualmente, riutilizzare tale area er l allocazione di altre variabili dinamiche. La erdita del valore del untatore P rima che sia effettuata la free(p) rende imossibile il riuso degli sazi. free(p) lascia P con valore indefinito, ertanto doo la sua esecuzione il untatore che ne è argomento non uò essere riutilizzato a meno che non gli si assegni un valore valido. Se P è un untatore ad un area di memoria non ottenuta con malloc è un errore usare free(p) er liberare tale area. Alcuni linguaggi, come Lis e Java, hanno dei meccanismi automatici di recuero della memoria detti sazzini (garbage collector), viceversa in C è meglio gestire con cura allocazioni e deallocazioni di memoria. IL LINGUAGGIO C - IL TIPO PUNTATORE 16

17 Esemio: variabile dinamica di tio integer #include <stdio.h> #include <stdlib.h> main(){ tyedef int TI; /* dichiara tio er la variabile dinamica */ tyedef TI *PTI; /* dichiara il tio untatore */ PTI P; /* dichiara la variabile untatore (statica) */ P=(int *)malloc(sizeof(int)); /* creazione della variabile dinamica*/ *P = 3; /* si accede in assegnamento alla variabile dinamica*/ rintf("%d",*p); /* accesso alla variabile dinamica*/ free(p); /* rimozione della variabile dinamica */ } Prima dell'istruzione P=(int *)malloc(sizeof(int)); la variabile P ha, come tutte le variabili non inizializzate, un valore indefinito; di conseguenza il valore untato, *P, è indefinito e la modifica di tale valore deve essere evitata in quanto uò causare errori durante l'esecuzione del rogramma. Si noti che la variabile dinamica esiste indiendentemente dal blocco all'interno del quale è stata creata; la sua visibilità è legata soltanto alla disonibilità del untatore. IL LINGUAGGIO C - IL TIPO PUNTATORE 17

18 Array dinamici Sfruttando la forte relazione tra untatori ed array, una variabile dinamica di tio array, cioè un array di dimensioni non refissate all'atto della sua dichiarazione ma stabilito durante l'esecuzione del rogramma, uò essere utilizzato in modo molto omogeneo risetto ad un array statico. Esemio: vettore dinamico #include <stdio.h> #include <stdlib.h> main(){ int *VettoreDinamico; /* vettore dinamico */ int I,N; rintf("inserire dimensioni vettore dinamico"); scanf("%d",&n); VettoreDinamico =(int *)malloc(n*sizeof(int)); /* Acquisizione : Notazione come "untatore" */ for (I=0;I<N;I++) scanf("%d",(vettoredinamico+i)); /* Stama : Notazione come "untatore" */ for (I=0;I<N;I++) rintf("%d\n",*(vettoredinamico+i)); /* Acquisizione: Notazione come "array" */ for (I=0;I<N;I++) scanf("%d",&vettoredinamico[i]); /* Stama : Notazione come "array" */ for (I=0;I<N;I++) rintf("%d\n",vettoredinamico[i]); free(vettoredinamico); } /* end main */ IL LINGUAGGIO C - IL TIPO PUNTATORE 18

19 COMPOSIZIONE DI TIPI STRUTTURATI Per array e record non si è osto alcun vincolo sui tii utilizzati nelle comonenti. - È ossibile utilizzare come comonenti dei tii a loro volta strutturati: matrici di record, record di matrici, record di record, etc etc, - E ossibile usare, a qualsiasi livello, anche il costruttore di tio untatore. - Esistono in generale dei limiti al numero di innestamenti ossibili, che diendono dallo secifico comilatore. Esemio: Corso raresentato come un array di ersone #define NumCar 16 #define MaxStud 30 tyedef char Parola[NumCar]; tyedef struct { Parola Nome; Data Nascita; } Persona; Persona Corso[MaxStud]; /* Iniziale dell'ultima ersona del corso /* Corso[MaxStud-1].Nome[0]; /* Anno di nascita della rima ersona del corso /* Corso[0].Nascita.Anno; IL LINGUAGGIO C - IL TIPO PUNTATORE 19

20 Esemio: Gioco del tresette tyedef enum {Sade,Coe,Denari,Bastoni} TioSegno; tyedef enum {Uno,Due,Tre,Quattro, Cinque,Sei,Sette, Fante,Cavallo,Re } TioValore; tyedef struct { TioSegno Segno; TioValore Valore; } TioCarta; /* ad ogni mano giocano 4 giocatori con 10 carte /* TioCarta ManoDiTresette[4][10]; /* se il giocatore 2 ha come terza carta un bastoni /* if (ManoDiTresette[2][3].Segno==Bastoni) IL LINGUAGGIO C - IL TIPO PUNTATORE 20

21 Esemio: Comosizione di tii untatori con tii record tyedef struct{ int Giorno, Mese, Anno; } Data; Data *P; Data D; P =&D; (*P).Anno=2000; Le arentesi in (*P).Anno sono necessarie in quanto l oeratore. di selezione di un camo del record ha una recedenza iù alta di quella dell oeratore di dereferenziazione *: senza arentesi *P.Anno significa *(P.Anno) che è un errore in quanto Anno non è un untatore. Per semlificare esressioni di questo tio, è meglio usare l oeratore unario à in questo modo: (*P).Anno è equivalente a P->Anno IL LINGUAGGIO C - IL TIPO PUNTATORE 21

22 Esemio: Array dinamico di record Dato il tio tyedef struct { int matricola; int eta; } Studente; scrivere la funzione Studente *CreaStudente(int n); che alloca ed acquisisce da inut un array di n studenti e restituisce un untatore al rimo studente. Usare tale funzione in un rogramma. #include <stdio.h> #include <stdlib.h> tyedef struct { int matricola; int eta; } Studente; Studente *CreaStudente(int n){ Studente *V; int I; V=(Studente *)malloc(n * sizeof(studente)); for(i=0;i<n;i++){ scanf("%d",&v[i].matricola); scanf("%d",&v[i].eta); } return V; } IL LINGUAGGIO C - IL TIPO PUNTATORE 22

23 main(){ Studente *P; /* variabile untatore (statica) */ int I; P=CreaStudente(2); /*crea la variabile dinamica*/ /* uso della variabile dinamica */ for(i=0;i<2;i++) rintf("matricola %d, Eta %d \n", P[I].matricola,P[I].eta); free(p); /* rimuove la variabile dinamica */ } /* end main */ Si noti la recedenza degli oeratori nell'esressione &V[I].matricola: rima si alica l'oeratore di accesso al vettore (V[I]) ottenendo un elemento che è un record, al quale si alica l'oeratore di selezione del camo del record (V[I].matricola) ottenendo una variabile di tio int, che viene acquisita nella scanf anteonendo l'oeratore indirizzo. IL LINGUAGGIO C - IL TIPO PUNTATORE 23