Reference

I reference (riferimenti) sono sotto certi aspetti un costrutto a meta` tra puntatori e le usuali variabili: come i puntatori essi sono contenitori di indirizzi, ma non e` necessario dereferenziarli per accedere all'oggetto puntato (si usano come se fossero normali variabili). In pratica possiamo vedere i reference come un meccanismo per creare alias di variabili, anche se in effetti questa e` una definizione non del tutto esatta.
Cosi` come un puntatore viene indicato nelle dichiarazioni dal simbolo *, un reference viene indicato dal simbolo &:

int Var = 5;
float f = 0.5;

int* IntPtr = &Var;
int& IntRef = Var;   // nei reference non serve
float& FloatRef = f; // utilizzare & a destra di =

 

Le ultime due righe dichiarano rispettivamente un riferimento a int e uno a float che vengono subito inizializzati usando le due variabili dichiarate prima. Un riferimento va inizializzato immediatamente, e dopo l'inizializzazione non puo` essere piu` cambiato; si noti che non e` necessario utilizzare l'operatore & (indirizzo di) per eseguire l'inizializzazione. Dopo l'inizializzazione il riferimento potra` essere utilizzato in luogo della variabile cui e` legato, utilizzare l'uno o l'altro sara` indifferente:

cout << "Var = " << Var << endl;
cout << "IntRef = " << IntRef << endl;
cout << "Assegnamento a IntRef..." << endl;
IntRef = 8;
cout << "Var = " << Var << endl;
cout << "IntRef = " << IntRef << endl;
cout << "Assegnamento a Var..." << endl;
Var = 15;
cout << "Var = " << Var << endl;
cout << "IntRef = " << IntRef << endl;

 

Ecco l'output del precedente codice:

Var = 5
IntRef = 5
Assegnamento a IntRef...
Var = 8
IntRef = 8;
Assegnamento a Var...
Var = 15
IntRef = 15

 

Dall'esempio si capisce perche`, dopo l'inizializzazione, un riferimento non possa essere piu` associato ad un nuovo oggetto: ogni assegnamento al riferimento si traduce in un assegnamento all'oggetto riferito.
Un riferimento puo` essere inizializzato anche tramite un puntatore:

int* IntPtr = new int(5);
// il valore tra parentesi specifica il valore cui
// inizializzare l'oggetto allocato. Per adesso il
// metodo funziona solo con i tipi primitivi.

int& IntRef = *IntPtr;

 

Si noti che il puntatore va dereferenziato, altrimenti si legherebbe il riferimento al puntatore (in questo caso l'uso del riferimento comporta implicitamente una conversione da int* a int).
Ovviamente il metodo puo` essere utilizzato anche con l'operatore new:

double& DoubleRef = *new double;

// Ora si puo` accedere all'oggetto allocato
// tramite il riferimento.

DoubleRef = 7.3;
// Di nuovo, e` compito del programmatore
// distruggere l'oggetto crato con new

delete &DoubleRef;

// Si noti che va usato l'operatore &, per
// indicare l'intenzione di deallocare
// l'oggetto riferito, non il riferimento!

 

L'uso dei riferimenti per accedere a oggetti dinamici e` sicuramente molto comodo perche` e` possibile uniformare tali oggetti alle comuni variabili, tuttavia e` una pratica che bisognerebbe evitare perche` puo` generare confusione e di conseguenza errori assai insidiosi.

successivo
–«  INDICE  »–