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
opt direct-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
opt pointer
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-specifier
void
, 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.