Sei sulla pagina 1di 3

I Puntatori in C

I Puntatori sono dei particolari tipi di variabili che differiscono dai tipi di variabili “classici”
per il fatto che i valori che andremo ad inserire al loro interno non hanno un significato a sé
stante.

Le Variabili “classiche” contengono un valore che verrà utilizzato all’interno del


programma. I Puntatori invece contengono degli indirizzi di specifiche aree di memoria
in cui sono contenuti i dati che verranno utilizzati all’interno del programma.

Celle di MEMORIA

Definizione della Variabile a

Definizione del Puntatore p che punta ad una cella di


memoria, ancora non sappiamo quale, che contiene un valore

Inizializzazione del Puntatore p p punta all’indirizzo di


memoria di a
Inizializzazione della Variabile a

Attribuzione di un valore alla


cella di memoria a cui punta p ,
ossia alla Variabile a

In pratica la memoria del nostro computer è essenzialmente strutturata come una serie di
celle, che sono rappresentabili come dei contenitori (come fossero delle scatole o dei
cassetti uno adiacente all’altro) all’interno di quali possiamo inserire dei valori, codificati in
bit (sequenze di 0 e 1) che possono rappresentare numeri interi o razionali, caratteri, ecc.

Ad ogni cella è assegnato un indirizzo (le celle di fatto sono numerate) tramite il quale è
possibile accedere al valore in essa contenuto per leggerlo o modificarlo.

SINTASSI
La DICHIARAZIONE, con conseguente definizione, di una variabile puntatore consiste
nell’aggiungere il simbolo di asterisco ‘*’ tra il tipo della variabile e il suo identificatore:
<tipo> * <identificatore>

Le seguenti sono valide dichiarazioni di variabili puntatore:


int* pointerToInteger;

float * pointerToFloat;

char *pointerToChar;

Quindi dichiaro il datatype contenuto nella cella di memoria a cui punta il puntatore.

Lezioni di INFORMATICA Prof Donato Greco @ 2020 Pag. 1 di 3


LE VARIABILI
Una Variabile rappresenta una ben precisa porzione di memoria, identificata da una posizione e numero di
byte utilizzati, in base alla tipologia di variabile.

Per appurare lo spazio in byte occupato da ogni singolo datatype (tipologia di variabile), basta eseguire in C
il seguente breve programma.

1. #include <stdio.h>
2. int main()
3. {
4. // print the size in bytes of Char datatype
5. printf("Char size is %lu byte\n", sizeof(char));
6. // print the size in bytes of Int datatype
7. printf("Int size is %lu byte\n", sizeof(int));
8. // print the size in bytes of Float datatype
9. printf("Float size is %lu byte\n", sizeof(float));
10. // print the size in bytes of Double datatype
11. printf("Double size is %lu byte", sizeof(double));
12. return 0;
13. }

Il risultato ottenuto eseguendo il programma precedente sarà

Char size is 1 byte


Int size is 4 byte
Float size is 4 byte
Double size is 8 byte

UTILIZZO DEI PUNTATORI


Per comprendere l’utilizzo dei puntatori, analizziamo il seguente codice.

1. #include <stdio.h>
2.
3. void main (void) {
4. int a; // DEFINISCO la variabile a
5. int *ptr_to_a; // DEFINISCO il Puntatore
6. ptr_to_a = &a; // <<<< INIZIALIZZO il Puntatore, che punta alla Variabile a
7. a = 5; // <<<< INIZIALIZZO la variabile a
8. printf ("Il valore iniziale di \'a\' e\' %d\n\n", a);
9. *ptr_to_a = 6; // <<<< ATTRIBUISCO un valore al contenuto del Puntatore
10. printf ("Il valore di \'a\' e\' stato cambiato in %d\n", a);
11. printf ("L\'indirizzo di \'a\' e\' %p\n\n", &a);
12. printf ("Il valore del puntatore \'ptr_to_a\' e\' %p\n", ptr_to_a);
13. printf ("Esso contiene il valore %d\n", *ptr_to_a);
14. }

Al rigo 6 INIZIALIZZIAMO il puntatore ptr_to_a all’indirizzo della variabile a, mentre al rigo 7


ATTRIBUIAMO alla variabile a il valore 5 (a = 5). Successivamente al rigo 9 modifichiamo il valore
della variabile a utilizzando però il puntatore (*ptr_to_a = 6).

CON ASTERISCO SENZA ASTERISCO


*ptr_to_a ptr_to_a

CONTENUTO della cella di memoria INDIRIZZO della cella di memoria

Lezioni di INFORMATICA Prof Donato Greco @ 2020 Pag. 2 di 3


ARRAY e Puntatori
Un discorso a parte merita lo studio del legame esistente fra Array (detti anche Vettori) e Puntatori.

Ad esempio la definizione: int array[4] indica che il vettore denominato array[] è costituito da
4 elementi, ognuno dei quali è identificato da un indice che parte da 0 (zero) per arrivare a 3, quindi
avremo i singoli elementi individuati come

array[0], array[1], array[2] ed array[3] (1)

Il significato della scrittura array è di rappresentare il Puntatore al PRIMO elemento del Vettore, ossia
all’indirizzo di array[0].
Di conseguenza se vogliamo accedere al CONTENUTO di array[0] tramite il Puntatore, occorre scrivere
*array oppure *(array) mentre per accedere all’elemento successivo si scrive *(array+1)
e così via, pertanto per accedere al terzo elemento array[2] posso scrivere *(array+2)

array[0] array[1] array[2] array[3]

Celle di Memoria
*(array+3)

*array *(array+1) *(array+2)

Possiamo quindi riscrivere il contenuto dell’array in (1) tramite i Puntatori nel modo seguente

*array, *(array+1), *(array+2) ed *(array+3) (2)

Vale la regola generale di conversione Array Puntatori in base alla quale scrivere

array[indice] è analogo a scrivere *(array + indice)

Lezioni di INFORMATICA Prof Donato Greco @ 2020 Pag. 3 di 3