Déclarations de pointeur

Une déclaration de pointeur nomme une variable de pointeur et spécifie le type de l’objet vers lequel pointe la variable. Une variable déclarée comme pointeur contient une adresse mémoire.

Syntaxe

declarator:
 pointer_optdirect-declarator

direct-declarator:
 identifier
 ( declarator )
 direct-declarator[constant-expression_opt]
 direct-declarator ( parameter-type-list )
 direct-declarator(identifier-list_opt)

pointer:
 *type-qualifier-list_opt
 *type-qualifier-list_optpointer

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

Le type-specifier donne le type de l’objet, qui peut être tout type base, structure ou union. Les variables pointeur peuvent également pointer vers des fonctions, des tableaux et d'autres pointeurs. Pour plus d’informations sur la déclaration et l’interprétation des types pointeur plus complexes, consultez Interprétation de déclarateurs plus complexes.

En définissant le type-specifiervoid, vous pouvez différer la spécification du type auquel le pointeur se rapporte. Cet élément est appelé « pointeur vers void » et s’écrit void *. Une variable déclarée comme pointeur vers void peut être utilisée pour indiquer un objet de tout type. Toutefois, pour exécuter la plupart des opérations sur le pointeur ou sur l'objet vers lequel il pointe, le type vers lequel il pointe doit être spécifié explicitement pour chaque opération. (Les variables de types char * et void * sont compatibles pour l’affectation sans cast de type.) Cette conversion peut être effectuée avec un cast de type. Pour plus d’informations, consultez Conversions par cast de type.

type-qualifier peut être const ou volatile, ou les deux. Ces mots clés spécifient, respectivement, que le pointeur ne peut pas être modifié par le programme lui-même (const) ou que le pointeur peut légitimement être modifié par un processus en dehors du contrôle du programme (volatile). Pour plus d’informations sur const et volatile, consultez Qualificateurs de type.

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 pointer vers un tableau.

Vous pouvez déclarer un pointeur vers une structure, une union ou un type d'énumération avant de définir la structure, l'union ou le type d'énumération. Vous déclarez le pointeur à l’aide de la balise de structure ou d’union, comme indiqué dans les exemples. Ces déclarations sont autorisées car le compilateur n’a pas besoin de connaître la taille de la structure ou de l’union pour allouer l’espace pour la variable pointeur.

Exemples

Les exemples suivants illustrent les déclarations de pointeur.

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

Le pointeur message pointe vers une variable de type char.

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

Le tableau pointers contient 10 éléments ; chaque élément est un pointeur vers une variable de type int.

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

Le variable pointer pointe vers un tableau de 10 éléments. Chaque élément de ce tableau a le type int.

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

Le pointeur x peut être modifié pour pointer vers une valeur int différente, mais la valeur vers laquelle il pointe ne peut pas être modifiée.

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 variable y dans ces déclarations est déclarée comme pointeur constant vers une valeur int. La valeur qu’elle indique peut être modifiée, mais le pointeur doit toujours indiquer le même emplacement : l’adresse de fixed_object. De même, z est un pointeur constant, mais il est également déclaré pour pointer vers un int dont la valeur ne peut pas être modifiée par le programme. Le spécificateur volatile indique que, bien que la valeur de const int qui est indiquée par z ne puisse pas être modifiée par le programme, elle peut légitimement être modifiée par un processus en même temps que le programme. La déclaration de w spécifie que le programme ne peut pas modifier la valeur désignée 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 de structure list. Cette déclaration peut apparaître avant la définition du type de structure list (voir l’exemple suivant), tant que la définition de type list a la même visibilité que la déclaration.

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

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

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

La variable record a le type de structure id. 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 name soit défini.

Voir aussi

Déclarateurs et déclarations de variable