Dichiarazioni di puntatoriPointer Declarations

Una "dichiarazione di puntatore" denomina una variabile puntatore e specifica il tipo dell'oggetto a cui fa riferimento la variabile.A "pointer declaration" names a pointer variable and specifies the type of the object to which the variable points. Una variabile dichiarata come puntatore contiene un indirizzo di memoria.A variable declared as a pointer holds a memory address.

SintassiSyntax

declarator:declarator:
  pointeropt direct-declarator  pointeropt direct-declarator

direct-declarator:direct-declarator:
  identifier  identifier

  ( declarator )  ( declarator )

  direct-declarator [ constant-expressionopt ]  direct-declarator [ constant-expressionopt ]

  direct-declarator ( parameter-type-list )  direct-declarator ( parameter-type-list )

  direct-declarator ( identifier-listopt )  direct-declarator ( identifier-listopt )

pointer:pointer:
  \* type-qualifier-listopt  \* type-qualifier-listopt

  \* type-qualifier-listopt pointer  \* type-qualifier-listopt pointer

type-qualifier-list:type-qualifier-list:
  type-qualifier  type-qualifier

  type-qualifier-list type-qualifier  type-qualifier-list type-qualifier

type-specifier specifica il tipo dell'oggetto, che può essere qualsiasi tipo di base, struttura o unione.The type-specifier gives the type of the object, which can be any basic, structure, or union type. Le variabili puntatore possono inoltre fare riferimento a funzioni, matrici e altri puntatori.Pointer variables can also point to functions, arrays, and other pointers. Per informazioni sulla dichiarazione e l'interpretazione di tipi di puntatore più complessi, vedere Interpretazione di più dichiaratori complessi.(For information on declaring and interpreting more complex pointer types, refer to Interpreting More Complex Declarators.)

Rendendo type-specifier void, è possibile ritardare la specifica del tipo a cui fa riferimento il puntatore.By making the type-specifier void, you can delay specification of the type to which the pointer refers. Tale elemento viene definito "puntatore a void" e viene scritto come void *.Such an item is referred to as a "pointer to void" and is written as void *. Una variabile dichiarata come puntatore a void può essere usata per fare riferimento a un oggetto di qualsiasi tipo.A variable declared as a pointer to void can be used to point to an object of any type. 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.However, to perform most operations on the pointer or on the object to which it points, the type to which it points must be explicitly specified for each operation. Le variabili di tipo char\* e di tipo void \* sono compatibili con l'assegnazione senza un cast di tipo. Tale conversione può essere eseguita tramite un cast di tipo. Per altre informazioni, vedere Conversioni di cast di tipo.(Variables of type char \* and type void \* are assignment-compatible without a type cast.) Such conversion can be accomplished with a type cast (see Type-Cast Conversions for more information).

type-qualifier può essere const o volatile, oppure entrambi.The type-qualifier can be either const or volatile, or both. Tali qualificatori specificano rispettivamente che il puntatore non può essere modificato dal programma stesso (const) o che il puntatore può essere modificato in modo legittimo da un processo che esula dal controllo del programma (volatile).These specify, respectively, that the pointer cannot be modified by the program itself (const), or that the pointer can legitimately be modified by some process beyond the control of the program (volatile). Vedere Qualificatori di tipo per altre informazioni su const e volatile.(See Type Qualifiers for more information on const and volatile.)

declarator assegna un nome alla variabile e può includere un modificatore di tipo.The declarator names the variable and can include a type modifier. Ad esempio, se declarator rappresenta una matrice, il tipo del puntatore viene modificato per rappresentare un puntatore a una matrice.For example, if declarator represents an array, the type of the pointer is modified to be a pointer to an array.

È possibile dichiarare un puntatore a un tipo di struttura, unione o enumerazione prima di definire il tipo di struttura, unione o enumerazione.You can declare a pointer to a structure, union, or enumeration type before you define the structure, union, or enumeration type. Il puntatore viene dichiarato tramite il tag di unione o della struttura come illustrato negli esempi riportati di seguito.You declare the pointer by using the structure or union tag as shown in the examples below. Tali dichiarazioni sono consentite perché non è necessario che il compilatore conosca le dimensioni della struttura o dell'unione per allocare lo spazio per la variabile puntatore.Such declarations are allowed because the compiler does not need to know the size of the structure or union to allocate space for the pointer variable.

EsempiExamples

Negli esempi riportati di seguito vengono illustrate le dichiarazioni di puntatore:The following examples illustrate pointer declarations.

char *message; /* Declares a pointer variable named message */  

Il puntatore message fa riferimento a una variabile con il tipo char.The message pointer points to a variable with char type.

int *pointers[10];  /* Declares an array of pointers */  

La matrice pointers contiene 10 elementi. Ogni elemento è un puntatore a una variabile con il tipo int.The pointers array has 10 elements; each element is a pointer to a variable with int type.

int (*pointer)[10]; /* Declares a pointer to an array of 10 elements */  

La variabile pointer fa riferimento a una matrice con 10 elementi.The pointer variable points to an array with 10 elements. Ogni elemento di questa matrice ha il tipo int.Each element in this array has int type.

int const *x;      /* Declares a pointer variable, x,  
                      to a constant value */   

Il puntatore x può essere modificato per fare riferimento a un valore int diverso, ma il valore a cui fa riferimento non può essere modificato.The pointer x can be modified to point to a different int value, but the value to which it points cannot be modified.

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 y in queste dichiarazioni viene dichiarata come puntatore costante a un valore int.The variable y in these declarations is declared as a constant pointer to an int value. Il valore a cui fa riferimento può essere modificato, ma il puntatore deve sempre fare riferimento alla stessa posizione, vale a dire all'indirizzo di fixed_object.The value it points to can be modified, but the pointer itself must always point to the same location: the address of fixed_object. Allo stesso modo, z è un puntatore costante, ma viene anche dichiarato per fare riferimento a un oggetto int il cui valore non può essere modificato dal programma.Similarly, z is a constant pointer, but it is also declared to point to an int whose value cannot be modified by the program. L'identificatore aggiuntivo volatile indica che anche se il valore di const int a cui fa riferimento z non può essere modificato dal programma, potrebbe essere modificato in modo legittimo da un processo in esecuzione simultanea al programma.The additional specifier volatile indicates that although the value of the const int pointed to by z cannot be modified by the program, it could legitimately be modified by a process running concurrently with the program. La dichiarazione di w specifica che il programma non può modificare né il valore a cui viene fatto riferimento, né il puntatore.The declaration of w specifies that the program cannot change the value pointed to and that the program cannot modify the pointer.

struct list *next, *previous; /* Uses the tag for list */  

In questo esempio vengono dichiarate due variabili puntatore, next e previous, che fanno riferimento al tipo di struttura list.This example declares two pointer variables, next and previous, that point to the structure type list. Questa dichiarazione può essere visualizzata prima della definizione del tipo di struttura list (vedere l'esempio successivo), purché la definizione di tipo list abbia la stessa visibilità della dichiarazione.This declaration can appear before the definition of the list structure type (see the next example), as long as the list type definition has the same visibility as the declaration.

struct list   
{  
    char *token;  
    int count;  
    struct list *next;  
} line;  

La variabile line ha il tipo di struttura denominato list.The variable line has the structure type named list. Il tipo di struttura list ha tre membri. Il primo membro è un puntatore a un valore char, il secondo è un valore int e il terzo è un puntatore a un'altra struttura list.The list structure type has three members: the first member is a pointer to a char value, the second is an int value, and the third is a pointer to another list structure.

struct id   
{  
    unsigned int id_no;  
    struct name *pname;  
} record;  

La variabile record ha il tipo di struttura id. Si noti che pname viene dichiarato puntatore a un altro tipo di struttura denominato name.The variable record has the structure type id. Note that pname is declared as a pointer to another structure type named name. Questa dichiarazione può essere visualizzata prima che venga definito il tipo name.This declaration can appear before the name type is defined.

Vedere ancheSee Also

Dichiaratori e dichiarazioni di variabiliDeclarators and Variable Declarations