Vue d'ensemble des déclarateurs

les déclarateurs sont les composants d'une déclaration qui spécifient des noms des objets ou des fonctions.Les déclarateurs spécifient également si l'objet nommé est un objet, un pointeur, une référence ou un tableau.Alors que les déclarateurs ne spécifient pas le type de base, il modifie les informations de type dans le type de base pour spécifier les types dérivés tels que les pointeurs, les références, et des tableaux.Appliqué aux fonctions, les déclarateurs utilise le spécificateur de type pour spécifier complètement le type de retour d'une fonction pour représenter un objet, un pointeur, ou une référence.(Spécificateurs, présentés dans déclarations, offrent des propriétés telles que le type et la classe de stockage.Les modificateurs, présentés dans cette section et dans Modificateurs spécifiques, modifier les déclarateurs.) L'illustration suivante montre une déclaration complète d' MyFunction, et requiert que les composants de la déclaration.

spécificateurs, modificateurs, et déclarateurs

Spécifique à Microsoft

La plupart des mots clés étendus par Microsoft peuvent être utilisés comme modificateurs pour former des types dérivés ; ils ne sont pas des spécificateurs ou des déclarateurs.(Consultez Modificateurs spécifiques.)

détail de FIN Microsoft

les déclarateurs apparaissent dans la syntaxe de déclaration après une liste facultative de spécificateurs.Ces spécificateurs sont traités dans déclarations. Une déclaration peut contenir plusieurs déclarateur, mais chaque déclarateur déclare un seul nom.

La déclaration suivante d'exemple ci-dessous illustre comment des spécificateurs et les déclarateurs sont combinés pour former une déclaration complète :

const char *pch, ch;

Dans la déclaration précédente, les mots clés const et char composent la liste des spécificateurs.deux déclarateurs sont répertoriés : *pch et ch.Une déclaration qui déclare plusieurs entités se compose d'un spécificateur de type suivi d'une liste avec la virgule comme séparateur des déclarateurs, termine par un point-virgule.

déclarateurs pour les objets simples

Le déclarateur d'un objet simple tel qu'un int ou un double est simplement son nom, avec des parenthèses facultatives.

int i; // declarator is i

int (i); // declarator is (i)

Déclarateurs pour les pointeurs, les références et les tableaux

Les opérateurs de pointeur insérés devant le nom de l'objet pour être un pointeur ou une référence.L'opérateur de * déclare le nom en tant que pointeur ; & l'opérateur le déclare en tant que référence.

int *i; // declarator is *i
int &i; // declarator is &i
int **i; // declarator is **i;

En ajoutant const ou volatile attribuez au pointeur ces propriétés particulières.L'utilisation de ces spécificateurs dans un déclarateur (par opposition à dans un spécificateur de type) modifie les propriétés du pointeur, et non l'objet désigné :

char *const cpc; // const pointer to char 
const char *pcc; // pointer to const char 
const char *const cpcc; // const pointer to const char

Vous trouverez des informations supplémentaires dans pointeurs const et volatile.

Un pointeur vers un membre d'une classe ou un struct est déclaré avec le spécificateur imbriqué approprié de nom :

int X::* pIntMember; 
int ::X::* pIntMember; // the initial :: specifies X is in global scope
char Outer::Inner::* pIntMember; // pointer to char in a nested class

Parenthèses qui encadrent une expression constante facultative après que la cause de nom l'objet comme un tableau.Les parenthèses successives déclarent des dimensions supplémentaires au tableau.

int i[5]; // array with five elements of type int numbered from 0 to 4
int i[]; // array of unknown size
char *s[4]; // array of pointers to char
int i[2][2]; // two dimensional array

Déclarateurs pour les fonctions

Les parenthèses contenant la liste d'arguments sont utilisées après le nom de déclarer une fonction.Le code suivant déclare une fonction de type de retour int et trois arguments de type int.

int f(int a, int b, int c);

Pour plus d'informations sur les listes d'arguments, consultez déclarations de fonction.

Les pointeurs et les références aux fonctions sont déclarés en ajoutant le pointeur ou référencent l'opérateur au nom de la fonction comme indiqué ci-dessous.Les parenthèses, normalement facultatives, sont requises pour distinguer un pointeur vers une fonction d'une fonction qui retourne un pointeur :

int (*pf)(int); // pointer to function returning int
int *f(int i); // function returning pointer to int
int (&pf)(int); // reference to function 

Les pointeurs vers des fonctions membres se distinguent par les spécificateurs imbriqués de nom :

int (X::* pmf)(); // pointer to member function of X returning int
int* (X::* pmf)(); // pointer to member function returning pointer to int

Consultez également le Pointeurs vers des membres.

fonctions et objets dans la même déclaration

Les fonctions et les objets peuvent être déclarés dans la même déclaration comme suit :

int i, *j, f(int k);  // int, pointer to int, function returning int

la syntaxe peut être fallacieuse dans certaines circonstances.la déclaration suivante

int* i, f(int k);  // pointer to int, function returning int (not int*)

peut ressembler à la déclaration d'un pointeur d' int et une fonction retourner int*, mais il n'est pas.Cela est dû au fait que * fait partie du déclarateur pour i, pas partie du déclarateur pour f.

Simplifier la syntaxe des déclarateurs avec le typedef

Une meilleure technique, toutefois, est d'utiliser typedef ou une combinaison des parenthèses et le mot clé d' typedef .Vous devez déclarer un tableau de pointeurs vers des fonctions :

//  Function returning type int that takes one 
//   argument of type char *.
typedef int (*PIFN)( char * );
//  Declare an array of 7 pointers to functions 
//   returning int and taking one argument of type 
//   char *.
PIFN pifnDispatchArray[7];

La déclaration équivalente peut être écrite sans déclaration d' typedef , mais il est très complexe que le risque d'erreurs dépasse tous les avantages :

int ( *pifnDispatchArray[7] )( char * );

Pour plus d'informations sur le typedef, consultez spécificateur de typedef.

Les pointeurs, les références, choix d'un type de base unique peuvent être combinés dans une déclaration unique (séparée par des virgules) comme

int i, *i, &i, i[5];

une syntaxe plus complexe de déclarateur

• Le pointeur, la référence, le tableau, et les déclarateurs de fonction peuvent être combinés pour spécifier des objets tels que les tableaux de pointeurs vers des fonctions, de pointeurs vers les tableaux, etc.

• La grammaire récursive suivante décrit la syntaxe des déclarateurs de pointeur intégralement.

• declarator est défini comme un de :

1. identifier 
2. qualified-name 
3. declarator ( argument-list ) [cv-qualfiers] [exception-spec]
4. declarator [ [ constant-expression ] ] 

5. pointer-operator declarator 
6. ( declarator )

• et le pointeur- opérateur a un ans de :

* [cv-qualifiers]
& [cv-qualifiers]
:: nested-name-specifier * [cv-qualfiers]

Étant donné qu'un déclarateur peut contenir des déclarateurs, il est possible de construire des types dérivés plus complexes tels que les tableaux de pointeurs, des fonctions qui retournent des tableaux de pointeurs fonction, à l'aide de les règles ci-dessus.Pour former chaque étape de la construction, commencez par l'identificateur qui représente le type de données de base et appliquez la règle de syntaxe ci-dessus avec l'expression précédente comme declarator.La commande que vous appliquez les règles de syntaxe doit être l'inverse de la manière dont l'expression est énoncée en anglais.Si l'application de la règle de syntaxe de pointeur-opérateur à une expression de tableau ou de fonction, utilisez des parenthèses si vous souhaitez un pointeur vers le tableau ou la fonction, comme dans la dernière ligne dans le tableau ci-dessous.

L'exemple suivant illustre la construction de « pointeur vers le tableau de 10 pointeurs vers l'int ».

expression verbale	déclarateur	règle de syntaxe appliquée
	i	1
pointeurs vers	*i	5
tableau de 10	(*i)[10]	4
pointeur vers	*((*i)[10])	6 puis 5

Lorsque plusieurs modificateurs de pointeur, de référence, de tableau ou de fonction sont utilisés, les déclarateurs peuvent devenir assez compliqués.La rubrique Interprétation des déclarateurs plus complexes décrit comment lire une syntaxe plus complexe de déclarateur.La rubrique s'applique à C et à C++, bien que en C++, n'importe où * est utilisé pour indiquer un pointeur, un nom qualifié comme MyClass : : * peut être utilisé pour spécifier un pointeur vers un membre d'une classe.

Voir aussi

Référence

Déclarateurs