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:
 pointer_Optaredirect-declarator

direct-declarator:
 identifier
 ( declarator )
 direct-declarator[constant-expression_Optare]
 direct-declarator ( parameter-type-list )
 direct-declarator(identifier-list_Optare)

pointer:
 *type-qualifier-list_Optare
 *type-qualifier-list_Optarepointer

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.

Facendo in modo che , è possibile ritardare la type-specifiervoidspecifica del tipo a cui fa riferimento il puntatore. Tale elemento viene definito "puntatore a void" e viene scritto come void *. Una variabile dichiarata come puntatore da void utilizzare 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 tipi. Tale conversione può essere eseguita con un cast di tipi. Per altre informazioni, vedere Conversioni di tipo cast.

Può type-qualifier essere const o volatile, o entrambi. Queste parole chiave specificano, rispettivamente, che il puntatore non può essere modificato dal programma stesso () o che il puntatore può essere legittimamente modificato da un processo oltre il controllo del programma (constvolatile). 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. Dichiarare il puntatore 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.

Esempio

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 include 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 per puntare a un valore diverso int , ma il valore a cui 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 che punta a può essere modificato, ma il puntatore stesso deve sempre puntare alla stessa posizione: l'indirizzo di fixed_object. Analogamente, z è un puntatore costante, ma è anche dichiarato per puntare a un int il cui valore non può essere modificato dal programma. L'identificatore volatile indica che, anche se il valore del const int puntato da z non può essere modificato dal programma, potrebbe essere modificato legittimamente da un processo in esecuzione simultaneamente con il 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 tipo di struttura (vedere l'esempio successivo), purché la list 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 valore, il secondo è un charint 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.

Vedi anche

Dichiaratori e dichiarazioni di variabili