Déclarations de pointeur

Une « déclaration de pointeur » nomme une variable pointeur et spécifie le type de l'objet auquel la variable pointe.Une variable déclarée en tant que pointeur contient une adresse mémoire.

Syntaxe

• declarator:
  *direct-déclarateuroptd'*pointer

• direct-déclarateur:
  identifier

  déclarateur ) de**(**

  expression constante**]** de**[** optde direct-déclarateur

  paramètre-type-liste ) de**(** de direct-déclarateur

  identificateur-liste**)de(** optde direct-déclarateur

• pointer:
  type-qualificateur-liste de*****opt

  type-qualificateur-listepointeroptde*****

• type-qualificateur-liste:
  type-qualificateur

  type-qualificateur de type-qualificateur-liste

Le spécificateur de type indique le type de l'objet, qui peut être tout le de base, structure, ou le type d'union.Les variables pointeur peuvent également indiquer des fonctions, des tableaux, et d'autres pointeurs.(Pour plus d'informations sur le déclarer et interpréter les types pointeur plus complexes, reportez -vous à Interprétation des déclarateurs plus complexes.)

En effectuant le spécificateur de typevoid, vous pouvez différer la spécification du type auquel le pointeur fait référence.Un tel élément est appelée « pointeur vers void » et est écrit sous void *.Une variable déclarée en tant que pointeur vers void peut être utilisée pour indiquer un objet de tout type.Toutefois, exécuter la plupart des opérations sur le pointeur ou sur l'objet sur lequel il pointe, le type sur lequel il pointe doit être spécifié explicitement pour chaque opération.(Les variables de type char * et du type void * sont devoir-compatibles sans cast de type.) Une telle conversion peut être effectuée avec un cast de type (consultez conversions de cast de type pour plus d'informations).

Le type-qualificateur peut être const ou volatile, ou les deux.Ils spécifient, respectivement, que le pointeur ne peut pas être modifié par le programme lui-même (const), ou que le pointeur est légitimement être modifié par un processus indépendant du seront du programme (volatile).(Consultez qualificateurs de type pour plus d'informations sur const et volatile.)

declarator nomme la variable et peut inclure un modificateur de type.Par exemple, si declarator représente un tableau, le type du pointeur est modifié pour être un pointeur vers un tableau.

Vous pouvez déclarer un pointeur vers une structure, une union, ou un type énumération avant de définir la structure, l'union, ou le type énumération.Vous déclarez le pointeur à l'aide de la balise ou de structure comme indiqué dans les exemples ci-dessous.Il permet de ces déclarations parce que le compilateur n'a pas besoin de connaître la taille de la structure ou l'union pour allouer de l'espace pour la variable pointeur.

Exemples

Les exemples suivants montrent les déclarations de pointeur.

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

Les points du pointeur d' message à une variable avec char type.

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

la matrice d' pointers a 10 éléments ; chaque élément est un pointeur vers une variable du type d' int .

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

Les points de variable pointeur vers un tableau avec 10 éléments.Chaque élément de cette matrice a le type d' int .

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

le pointeur x peut être modifié pour indiquer int une valeur différente, mais la valeur à laquelle il pointe ne peut pas être modifié.

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;

y variable dans ces déclarations est déclaré comme pointeur constant à une valeur d' int .La valeur qu'elle indique peut être modifié, mais le pointeur lui-même doit toujours pointer vers le même emplacement : l'adresse d' fixed_object.De même, z est un pointeur constante, mais il est également déclaré indiquer int dont la valeur ne peut pas être modifiée par le programme.Le spécificateur supplémentaire volatile indique que bien que la valeur d' int const désigné par z ne puisse pas être modifiées par le programme, il peut légitimement être modifié par un processus simultanément au programme.la déclaration d' w spécifie que le programme ne peut pas modifier la valeur pointée sur et que le programme ne peut pas modifier le pointeur.

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

cet exemple déclare deux variables pointeur, next et previous, qui indiquent le type listde structure.Cette déclaration peut apparaître avant que la définition du type de structure d' list (consultez l'exemple suivant), tant que la définition de type d' list a la même visibilité que la déclaration.

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

line variable a le type de structure nommé list.le type de structure d' list a trois membres : le premier membre est un pointeur vers une valeur d' char , le second est une valeur d' int , et le troisième est un pointeur vers une autre structure d' list .

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

record variable a le type idde structure.Notez qu' pname est déclaré comme un pointeur vers un autre type de structure nommé name.cette déclaration peut apparaître avant que le type d' name soit défini.

Voir aussi

Concepts

Déclarateurs et déclarations de variable