POINTERS. Una variabile pointer è una variabile che ha come valore un indirizzo di memoria.

Transcript

1 POINTERS Una variabile pointer è una variabile che ha come valore un indirizzo di memoria. Es. Sia y una variabile intera di valore e sia yptr una variabile pointer avente come valore l indirizzo di y. Si dice che yptr punta ad y. int y = ; int *yptr; yptr = &y; 0 7fff683ecbd0 y yptr 7fff683ecbd0 che si può anche disegnare così: yptr y Inoltre poichè yptr contiene l indirizzo di una variabile intera già allocata, allora la notazione *yptr indica tale variabile. yptr *yptr Es. (prosecuzione del precedente). Con l istruzione: *yptr = 20; il valore della variabile y passa da a 20. 1

2 Dichiarazioni di variabili pointer L operatore * premesso al nome di una variabile dichiara che la variabile è una variabile pointer (puntatore). Es. float *xptr; dichiara che xptr è una variabile puntatore ad un float. È possibile dichiarare puntatori ad ogni tipo di dato (int, float, double, char, array, ) Unica eccezione: void *Ptr che dichiara un pointer generico. I puntatori possono essere inizializzati a 0, NULL, nel qual caso non puntano a niente. Due nuovi operatori coinvolti con pointers 1) & (address operator) L'operatore unario & applicato ad una variabile ritorna l indirizzo del suo operando. 2) * ( indirection/dereferencing operator) L'operatore unario * applicato ad un pointer ritorna il valore puntato dal pointer. Oss. Puntatori void non possono essere deferenziati (il compilatore non sa quanti byte dereferenziare) Oss. Gli operatori & e * sono inversi. I loro effetti si cancellano: e *&yvar == yvar &*yptr == yptr Oss. Gli operatori & e * hanno precedenza molto alta, paragonabile a quella di e, come loro, associano da destra a sinistra. Osservare come si può aumentare di uno *yptr: *yptr += 1; ++*yptr; (*yptr)++; 2

3 OPERAZIONI ARITMETICHE VALIDE SUI POINTERS Assegnazione. Si può fare solo fra pointers dello stesso tipo, altrimenti si deve usare l'operazione cast. Es.: int y, *xptr, *yptr = &y; double *zptr; xptr = yptr; // xptr punta a y zptr = (double *) xptr; Eccezione: Un puntatore void (tipo void *pt ) non può essere assegnato ad un altro puntatore senza l operazione di cast, mentre ogni puntatore può essere assegnato direttamente ad un puntatore void. Assegnazione della costante 0 (indicata con la costante simbolica NULL). Pointers ed interi non sono intercambiabili, ad eccezione dello 0, che il linguaggio garantisce non poter essere un indirizzo valido. Somma o sottrazione di un intero. Indipendentemente dal tipo di oggetto cui il pointer ptr punta, ptr+n (o ptr-n) punta all n-esimo oggetto oltre (o prima di) quello puntato da ptr. Es. main() int *pt1, *pt2, mat[10]; pt1 = mat; pt2 = pt1+2; printf(" pt1 = %p\n pt2 = %p\n pt2 - pt1 = %d\n mat = %p\n", pt1, pt2, pt2 - pt1, mat); E una stampa può essere: pt1 = 0x7fff6a3bdbd0 pt2 = 0x7fff6a3bdbd8 pt2 - pt1 = 2 mat = 0x7fff6a3bdbd0 Confronto e sottrazione tra due pointers. Si possono fare solo tra pointers che puntano a membri di una stessa array. Il comportamento è indefinito tra pointers a membri di array diverse. La sottrazione restituisce il numero di elementi tra i due indirizzi. Inoltre è lecito confrontare un pointer con lo 0 o NULL. Es: if (xptr == NULL) statement; 3

4 Passare una variabile pointer int main() void raddoppia(int *ptr) int num =, *numptr; numptr = # raddoppia(numptr); numptr ptr num Si ha lo stesso effetto di quando si passa il nome di una array, che però è un indirizzo costante. void raddoppia(int *ptr) *ptr += *ptr ; /*definizione*/ int main() int num =, *numptr; numptr = # raddoppia(numptr); /*chiamata */ /* raddoppia(&num); chiamata alternativa */ e il valore della variabile num del main raddoppia. 4

5 Es.: void scambia(int x, int y) int temp; temp = x; x = y; y = temp; // definizione errata /* la chiamata */ scambia (a,b); /* non scambia i valori delle variabili a e b */ void scambia(int *ptx, int *pty) //definizione giusta int temp; temp = *ptx; *ptx = *pty; *pty = temp; /* ora la chiamata */ scambia(&a,&b); /* scambia i valori delle variabili a e b */

6 POINTERS E ARRAYS La relazione è così forte da permettere che ogni operazione che può essere fatta con indici di arrays può essere fatta, e più velocemente, con i pointers. Esempio. Se int a[10], *aptr = a; allora sono uguali i valori: a[j] a + j a[j] aptr[j] aptr + j *(aptr+j) Notazione simile: matrice [indice] matrice + offset puntatore[indice] puntatore + offset L'unica differenza sta nel fatto che un poiter è una variabile e quindi sono corrette le espressioni aptr = a e aptr++, mentre il nome di una array è un puntatore costante e quindi cose del tipo a = aptr oppure a++ non sono corrette. È anche possibile scrivere aptr [-1], aptr [-2], ecc. purchè gli elementi referenziati siano validi. Oss. Sono equivalenti le seguenti dichiarazioni di parametri formali nelle funzioni: char s[] char *s /* s è pointer a char */ int mat[][3] int (*mat)[3] /* mat è pointer ad array[3] di int */ (invece: int *mat[3] /* mat è array di 3 pointers a int */ 6