Operatori di riferimento indiretto e address-of

L'operatore di riferimento indiretto unario (*) accede indirettamente a un valore tramite un puntatore. L'operando deve essere un tipo di puntatore. Il risultato dell'operazione è il valore indicato dall'operando, ovvero il valore al cui indirizzo punta l'operando. Il tipo del risultato corrisponde al tipo indirizzato dall'operando.

Il risultato dell'operatore di riferimento indiretto è type se l'operando è di tipo pointer to type. Se l'operando punta a una funzione, il risultato è un indicatore di funzione. Se invece punta a un oggetto, il risultato è un lvalue che definisce l'oggetto.

Se il valore del puntatore non è valido, il risultato dell'operatore di riferimento indiretto non è definito. Ecco alcune delle condizioni più comuni che invalidano un valore del puntatore:

• Il puntatore è un puntatore null.

• Il puntatore specifica l'indirizzo di un oggetto dopo la fine della durata al momento del riferimento. Ad esempio, un oggetto che non rientra nell'ambito o che è stato deallocato.

• Il puntatore specifica un indirizzo allineato in modo non appropriato per il tipo dell'oggetto a cui punta.

• Il puntatore specifica un indirizzo non utilizzato dal programma di esecuzione.

L'operatore address-of unario (&) specifica l'indirizzo del relativo operando. L'operando deve essere uno di questi elementi:

• Valore lvalue che definisce un oggetto che non è dichiarato register e non è un campo di bit.

• Risultato di un operatore di dereferenziazione unario (*) o dereferenziazione matrice ([]).

• Un designatore di funzione.

Il risultato è di tipo puntatore a operand_type per un operando di tipo operand_type.

Se l'operando è il risultato di un operatore unario * , nessun operatore viene valutato e il risultato è come se entrambi venissero omessi. Il risultato non è un lvalue e i vincoli sugli operatori vengono ancora applicati. Se l'operando è il risultato di un [] operatore, l'operatore & e la unaria * implicita dall'operatore [] non vengono valutati. Il risultato ha lo stesso effetto della rimozione dell'operatore & e della modifica dell'operatore [] in un + operatore. In caso contrario, il risultato è un puntatore all'oggetto o alla funzione definita dall'operando.

Esempi

Gli esempi seguenti usano le dichiarazioni comuni che seguono:

int *pa, x;
int a[20];

Questa istruzione usa l'operatore address-of (&) per accettare l'indirizzo del sesto elemento della matrice a. Il risultato viene archiviato nella variabile del puntatore pa:

pa = &a[5];

L'operatore di riferimento indiretto (*) viene usato in questo esempio per accedere al valore int all'indirizzo archiviato in pa. Il valore viene assegnato alla variabile Integer x:

x = *pa;

L'esempio dimostra che il risultato dell'applicazione dell'operatore di riferimento indiretto all'indirizzo di x è lo stesso di x:

assert( x == *&x );

Questo esempio illustra modi equivalenti di dichiarare un puntatore a una funzione:

int roundup( void );     /* Function declaration */

int  *proundup  = roundup;
int  *pround  = &roundup;
assert( pround == proundup );

Dopo che la funzione roundup è stata dichiarata, vengono dichiarati e inizializzati due puntatori a roundup. Il primo puntatore, proundup, viene inizializzata utilizzando solo il nome della funzione, mentre il secondo, pround, utilizza l'operatore address-of nell'inizializzazione. Le inizializzazioni sono equivalenti.

Vedi anche

Operatore di riferimento indiretto: *
Operatore Address-of: &