Chi ha paura dei puntatori?

Introduzione

La variabile

• il tipo char ha dimensione 1 byte;

• il tipo int ha dimensione 2 byte (nei sistemi operativi a 16 bit, come Windows 3.x; in quelli a 32 bit ha dimensione 4 byte);

• il tipo long ha dimensione 4 byte, il tipo double 8 byte e così via;

Il linguaggio C permette al programmatore di definire, con lo statement typedef, i propri tipi di dato a partire dai tipi di dato elementari. Ogni volta che, nel nostro codice, definiamo una variabile, il compilatore riserva nella mappa di memoria un numero di celle pari alla dimensione del tipo di dato assegnato alla variabile, e questo insieme di celle è la locazione di memoria associata alla variabile; il compilatore conserva internamente l'indirizzo della locazione di memoria per evitare di assegnare ad altre variabili le stesse celle che ha appena riservato per noi. A questo punto possiamo leggere e scrivere nella locazione di memoria associata alla nostra variabile senza avere la minima idea di quale sia la sua posizione nella mappa della memoria: sarà il compilatore a tradurre le nostre operazioni sulla variabile in operazioni di lettura e scrittura nelle celle di memoria della sua locazione; da qui discende il concetto espresso all'inizio: operazioni su una locazione di memoria fatte attravero operazioni astratte sul nome che abbiamo assegnato alla variabile.

Vediamo un esempio:

long Esempio1(void)
{
     long miaVar;
     // definizione di una variabile di tipo                     
     // long di nome miaVar: il compilatore alloca 4 byte      
     // in memoria e conserva l'indirizzo della locazione

     miaVar = 5;
     // assegniamo un valore a miaVar: il compilatore  
     // dal nome della variabile risale
     // all'indirizzo della locazione di memoria e vi  
     // scrive il valore 5

     return miaVar;
     // leggiamo il valore di miaVar: il compilatore   
     // dal nome della variabile risale
     // all'indirizzo della locazione di memoria e ne  
     // legge il contenuto
}

A questo punto qualcuno potrebbe chiedersi quand' è che la locazione di memoria torna ad essere disponibile per altre variabili, ovvero quando la variabile viene deallocata; nell'esempio fatto poc'anzi il compilatore si "dimentica" dell'indirizzo della locazione di memoria assegnata alla variabile non appena il ciclo delle istruzioni esce dall'intervallo di visibilità (scope) della variabile in oggetto, ovvero dopo la parentesi graffa di chiusura del corpo della funzione Esempio1. Questo meccanismo di allocazione e deallocazione automatica della locazione di memoria associata alla variabile, eseguito dal compilatore in maniera del tutto trasparente per il programmatore, viene chiamato allocazione statica di memoria: il compilatore è anche così intelligente da gestire in proprio variabili con lo stesso nome, definite in scope diversi, come nell'esempio che segue:

long Esempio2(void)
{
     long miaVar = 100;
     long Conta = 0;
     // le variabili miaVar e Conta sono visibili
     // all'interno di tutta la funzione

     for(Conta = 0; Conta < 5; Conta++)
     {
          long miaVar;
          long altraVar = 3;
          // le variabili miaVar e altraVar sono visibili        
          // solo all'interno del ciclo for; la
          // variabile miaVar definita in questo ciclo non       
          // è la stessa definita all'inizio della          
          // funzione:
          // all'interno di questo ciclo for la variabile        
          // miaVar interna al ciclo impedisce di vedere       
          // la miaVar esterna della funzione

          miaVar = altraVar * Conta;
     }

     if(Conta == 5)
     {
          long altraVar;
          // la variabile altraVar definita in questo       
          // ciclo non è la stessa definita nel ciclo for;
          // invece la variabile miaVar è quella visibile        
          // da tutta la funzione

          altraVar = miaVar * Conta;
          miaVar = miaVar + altraVar;
     }

     return miaVar;
     // quanto vale ora miaVar? 600.
}

Interagire direttamente con la memoria

Il puntatore

void Esempio3(void)
{
     int flag = 1;
     long valore;
     long * puntatore;
     // la variabile puntatore è visibile in tutta la funzione

     if(flag == 1)
     {
          long miaVar = 5;
          // la variabile miaVar è visibile solo dentro l'if

          puntatore = & miaVar;
          // assegniamo alla variabile puntatore       
          // l'indirizzo di miaVar

          valore = * puntatore;
          // leggiamo il valore della variabile
          // miaVar, puntata dalla variabile puntatore
     }

     valore = * puntatore;
     // questa operazione non ha senso, perchè la
     // variabile miaVar non è più allocata, e nella   
     // locazione puntata dalla variabile puntatore potrà
     // esserci chissà cosa
}

Abbiamo detto che anche il puntatore è una variabile, per cui non deve sembrare strano volerne conoscere l'indirizzo:

void Esempio4(void)
{
     long miaVar = 5;
     long * puntatore;
     long ** puntApunt;
     long * Indirizzo;
     long Valore;

     puntatore = & miaVar;
     puntApunt = & puntatore;

     Indirizzo = * puntApunt;
     // la variabile Indirizzo ora contiene l'indirizzo     
     // di miaVar

     Valore = * Indirizzo;
     // la variabile Valore ora contiene il valore di miaVar

     Valore = ** puntApunt;
     // è equivalente a scrivere Valore = * Indirizzo
}

Come nelle migliori cacce al tesoro, possiamo divertirci a seminare puntatori; con un pò di pazienza, potremo ritrovare la bella ragazza di cui sopra partendo da Piazza Venezia, dove troveremo una busta con un indirizzo di via Cavour, dove troveremo una busta con un indirizzo di via Merulana, dove troveremo una busta con un indirizzo di via Appia, dove troveremo una busta con un indirizzo di via Casilina, dove finalmente troveremo la nostra amata (che, guardacaso, aveva traslocato proprio nell'appartamento di fronte al nostro).

void Esempio5(BELLARAGAZZA ***** piazzaVenezia)
{
     // BELLARAGAZZA è un tipo di dato da noi definito
     // con il typedef

     BELLARAGAZZA **** viaCavour;
     BELLARAGAZZA *** viaMerulana;
     BELLARAGAZZA ** viaAppia;
     BELLARAGAZZA * viaCasilina;
     BELLARAGAZZA AnnaFalchi;

     viaCavour = * piazzaVenezia;
     // l'indirizzo di via Cavour

     viaMerulana = * viaCavour;
     // l'indirizzo di via Merulana

     viaAppia = * viaMerulana;
     // l'indirizzo di via Appia

     viaCasilina = * viaAppia;
     // l'indirizzo di via Casilina

     AnnaFalchi = * viaCasilina;
     // è stata dura, ma ne valeva la pena!
}

Operazioni con i puntatori

 &   è l'operatore di indirizzo;
*  è l'operatore di indirezione;
-> è l'operatore di indirezione del membro di una struttura.

void Esempio6(void)
{
     struct PUNTO{int x; int y;} miaVar = {3, 9};
     // dichiaro una struttura di tipo PUNTO, e la
     // inizializzo
     struct PUNTO * mioPunt;
     // dichiaro il puntatore ad una struttura di tipo      
     // PUNTO
     int xCoord, yCoord;

     mioPunt = &miaVar;
     // assegno al puntatore l'indirizzo della struttura

     miaVar = * mioPunt;
     // ricavo il contenuto della struttura a partire dal   
     // suo indirizzo

     xCoord = mioPunt->x;
     yCoord = mioPunt->y;
     // ricavo il contenuto dei singoli membri della   
     // struttura a partire dal suo indirizzo: è
     // equivalente a scrivere

     xCoord = (* mioPunt).x;
     yCoord = (* mioPunt).y;
}

Puntatori e array

void Esempio7(void)
{
     int mioArray[] = {3, 9, 12, 34, 21};
     // dichiaro un array di 5 elementi interi e lo
     // inizializzo
     int * mioPunt;
     // dichiaro un puntatore ad interi
     int valore;

     mioPunt = mioArray;
     // assegno al puntatore l'indirizzo dell'array
     // è equivalente a scrivere

     mioPunt = &mioArray[0];

     valore = * mioPunt;
     // ricavo solo il contenuto del primo elemento
     // dell'array: è equivalente a scrivere

     valore = mioPunt[0];

     valore = mioPunt[2];
     // ricavo il contenuto del terzo elemento dell'array
}

Purtroppo, l'impossibilità di conoscere la dimensione di un array (o di una struttura) tramite la semplice operazione di indirezione del suo puntatore costituisce un limite del linguaggio ed anche una continua fonte di errori di programmazione: l'applicazione dell'operatore sizeof ad un puntatore a qualsiasi tipo di struttura o array restituisce sempre il medesimo valore, la dimensione in byte della variabile puntatore, a prescindere dall'effettiva dimensione della variabile puntata.

void Esempio8(void)
{
     long tipo3[5];
     struct PUNTO {int x; int y;} tipo4;
     long * punt3;
     int size;

     punt3 = tipo3;

     size = sizeof(char);            // 1
     size = sizeof(int);             // 2
     size = sizeof(tipo3);           // 20
     size = sizeof(struct PUNTO);    // 4
     size = sizeof(char *);          // 2
     size = sizeof(int *);           // 2
     size = sizeof(punt3);           // 2
     size = sizeof(struct PUNTO *);  // 2
}

Conclusioni

Per chiudere questo breve discorso sui puntatori vorrei riassumere alcuni concetti:

• non è indispensabile utilizzare i puntatori per scrivere codice in linguaggio C;
• conoscere i puntatori è indispensabile per leggere ed interpretare il codice scritto dagli altri programmatori (quelli "bravi");
• l'utilizzo spinto dei puntatori porta ad un codice meno "leggibile", per cui è opportuno non spingersi troppo in là con il numero di asterischi;
• l'utilizzo dei puntatori genera un codice di dimensioni più ridotte e che "gira" più veloce;
• i puntatori, scavalcando i meccanismi di gestione dell'allocazione di memoria del compilatore, possono portare ad errori in run-time con effetti disastrosi;
• nell'uso dei puntatori, gli sbagli che più comunemente si compiono sono relativi all'uso dell'operatore sizeof ed alla precedenza degli operatori durante le indirezioni (attenzione a dove mettete le parentesi!).

La prossima volta vi parlerò sia del passaggio di parametri alle funzioni per indirizzo, sia dell'allocazione dinamica di memoria, che non può prescindere dall'utilizzo di questi maledetti (da alcuni, benedetti da altri) bacarozzi a forma di asterisco.