Déclarations de pointeur

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

Syntaxe

declarator :
  pointer _optezdirect-declarator

direct-declarator :
 identifier
  ( declarator )
  direct-declarator [ constant-expression _opter]
  direct-declarator ( parameter-type-list )
  direct-declarator ( identifier-list _opter)

pointer :
  * type-qualifier-list _opter
  * type-qualifier-list _opterpointer

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

Donne type-specifier le type de l’objet, qui peut être n’importe quel type de base, de structure ou d’union. Les variables de 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 de types de pointeurs plus complexes, reportez-vous à l’interprétation de déclarateurs plus complexes.)

En effectuant le type-specifiervoid, vous pouvez retarder la spécification du type auquel le pointeur fait référence. Un tel élément est appelé « pointeur vers void» et écrit en tant que void *. Une variable déclarée comme pointeur à void utiliser pour pointer vers un objet de n’importe quel type. Toutefois, pour effectuer 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 type et de type char *void * sont compatibles avec les affectations sans cast de type.) Cette conversion peut être effectuée avec un cast de type. Pour plus d’informations, consultez Type-Cast conversions.

Il type-qualifier peut s’agir de l’une const ou des volatiledeux. 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 au-delà du contrôle du programme (volatile). Pour plus d’informations sur const et volatile, consultez Qualificateurs de type.

Les declarator noms de la variable et peuvent inclure un modificateur de type. Par exemple, si elle 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 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 structure ou de la balise 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 de l’espace pour la variable de pointeur.

Exemples

Les exemples suivants illustrent les déclarations de pointeur.

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

Le message pointeur pointe vers une variable avec char type.

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

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

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

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

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

Le pointeur x peut être modifié pour pointer vers une int autre valeur, mais la valeur à laquelle elle 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 de ces déclarations est déclarée comme pointeur constant vers une int valeur. La valeur à laquelle il pointe peut être modifiée, mais le pointeur lui-même doit toujours pointer vers 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 une int valeur dont la valeur ne peut pas être modifiée par le programme. Le volatile spécificateur indique que bien que la valeur du const int pointé par z ne puisse pas être modifiée par le programme, elle peut légitimement être modifiée par un processus s’exécutant simultanément avec le programme. La déclaration de w spécifie que le programme ne peut pas modifier la valeur pointé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 de pointeur (next et previous) qui pointent vers le type listde structure. Cette déclaration peut apparaître avant la définition du list type de structure (voir l’exemple suivant), tant que la définition de list type 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 list type de structure a trois membres : le premier membre est un pointeur vers une char valeur, le second est une int valeur et le troisième est un pointeur vers une autre list structure.

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

La variable record a le type idde structure . pname est déclaré comme pointeur vers un autre type de structure nommé name. Cette déclaration peut apparaître avant la définition du name type.

Voir aussi

Déclarateurs et déclarations de variables