Dichiarazioni di puntatori
Una dichiarazione di puntatore denomina una variabile puntatore e specifica il tipo dell'oggetto a cui fa riferimento la variabile. Una variabile dichiarata come puntatore contiene un indirizzo di memoria.
Sintassi
declarator:
pointeroptare direct-declarator
direct-declarator:
identifier
( declarator )
direct-declarator[ constant-expressionoptare ]
direct-declarator ( parameter-type-list )
direct-declarator( identifier-listoptare )
pointer:
*type-qualifier-listoptare
*type-qualifier-listoptare pointer
type-qualifier-list:
type-qualifier
type-qualifier-list type-qualifier
Fornisce type-specifier il tipo dell'oggetto, che può essere qualsiasi tipo di base, struttura o unione. Le variabili puntatore possono inoltre fare riferimento a funzioni, matrici e altri puntatori. Per informazioni sulla dichiarazione e l'interpretazione di tipi di puntatore più complessi, vedere Interpretazione di più dichiaratori complessi.
Se si crea type-specifier void, è possibile ritardare la specifica del tipo a cui fa riferimento il puntatore. Un elemento di questo tipo viene definito "puntatore a void" e viene scritto come void *. Una variabile dichiarata come puntatore a void può essere usata per puntare a un oggetto di qualsiasi tipo. Tuttavia, per eseguire la maggior parte delle operazioni sul puntatore o sull'oggetto ai quali fa riferimento, il tipo a cui fa riferimento deve essere specificato in modo esplicito per ogni operazione. Le variabili di tipo char * e tipo void * sono compatibili con l'assegnazione senza un cast di tipo. Tale conversione può essere eseguita con un cast di tipo. Per altre informazioni, vedere Conversioni di cast di tipi.
type-qualifier può essere const o volatileo entrambi. Queste parole chiave specificano, rispettivamente, che il puntatore non può essere modificato dal programma stesso (const) o che il puntatore può essere modificato legittimamente da un processo oltre il controllo del programma (volatile). Per altre informazioni su const e volatile, vedere Qualificatori di tipo.
I declarator nomi della variabile e possono includere un modificatore di tipo. Ad esempio, se declarator rappresenta una matrice, il tipo del puntatore viene modificato in modo che sia un puntatore a una matrice.
È possibile dichiarare un puntatore a un tipo di struttura, unione o enumerazione prima di definire il tipo di struttura, unione o enumerazione. Il puntatore viene dichiarato usando la struttura o il tag di unione, come illustrato negli esempi. Tali dichiarazioni sono consentite perché il compilatore non deve conoscere le dimensioni della struttura o dell'unione per allocare spazio per la variabile puntatore.
Esempi
Negli esempi riportati di seguito vengono illustrate le dichiarazioni di puntatore:
char *message; /* Declares a pointer variable named message */
Il message puntatore punta a una variabile con char tipo.
int *pointers[10]; /* Declares an array of pointers */
La pointers matrice ha 10 elementi. Ogni elemento è un puntatore a una variabile con int tipo.
int (*pointer)[10]; /* Declares a pointer to an array of 10 elements */
La pointer variabile punta a una matrice con 10 elementi. Ogni elemento in questa matrice ha int tipo.
int const *x; /* Declares a pointer variable, x,
to a constant value */
Il puntatore x può essere modificato in modo da puntare a un valore diverso int , ma il valore a cui punta non può essere modificato.
const int some_object = 5 ;
int other_object = 37;
int *const y = &fixed_object;
int volatile *const z = &some_object;
int *const volatile w = &some_object;
La variabile in queste dichiarazioni viene dichiarata come puntatore y costante a un int valore. Il valore da cui punta può essere modificato, ma il puntatore stesso deve sempre puntare alla stessa posizione: l'indirizzo di fixed_object. Analogamente, z è un puntatore costante, ma viene anche dichiarato in modo che punti a un int il cui valore non può essere modificato dal programma. L'identificatore volatile indica che, anche se il valore dell'oggetto const int a cui z punta non può essere modificato dal programma, potrebbe essere modificato legittimamente da un processo in esecuzione contemporaneamente al programma. La dichiarazione di w specifica che il programma non può modificare il valore a cui punta e che il programma non può modificare il puntatore.
struct list *next, *previous; /* Uses the tag for list */
In questo esempio vengono dichiarate due variabili puntatore (next e previous) che puntano al tipo di liststruttura . Questa dichiarazione può essere visualizzata prima della definizione del list tipo di struttura (vedere l'esempio successivo), purché la definizione del list tipo abbia la stessa visibilità della dichiarazione.
struct list
{
char *token;
int count;
struct list *next;
} line;
La variabile line ha il tipo di struttura denominato list. Il list tipo di struttura ha tre membri: il primo membro è un puntatore a un char valore, il secondo è un int valore e il terzo è un puntatore a un'altra list struttura.
struct id
{
unsigned int id_no;
struct name *pname;
} record;
La variabile record ha il tipo di idstruttura . pname viene dichiarato come puntatore a un altro tipo di struttura denominato name. Questa dichiarazione può essere visualizzata prima della definizione del name tipo.