Interprétation des déclarateurs plus complexes
Vous pouvez placer n'importe quel déclarateur entre parenthèses pour spécifier une translation particulière « déclarateur d'un complexe. » Un déclarateur complexe est un identificateur qualifié par plusieurs tableau, pointeur, ou modificateur de fonction.Vous pouvez appliquer différentes combinaisons de tableau, d'un pointeur, et de modificateurs de fonction à un identificateur unique.En général typedef peut être utilisée pour simplifier les déclarations.Consultez déclarations de typedef.
En interprétant les déclarateurs complexes, les parenthèses et les parenthèses (autrement dit, modificateurs à droite de l'identificateur) sont prioritaires sur les astérisques (autrement dit, modificateurs à gauche de l'identificateur).les parenthèses et les parenthèses ont la même priorité et s'associent de gauche à droite.Une fois le déclarateur a été entièrement interprétée, le spécificateur de type est appliqué comme dernière étape.En utilisant des parenthèses vous pouvez substituer la commande par défaut d'association et forcer une translation particulière.N'utilisez jamais les crochets, toutefois, autour d'un nom de l'identificateur par lui-même.Cela peut être interprète à tort comme une liste de paramètres.
Un moyen simple d'interpréter les déclarateurs complexes est de les afficher « de l'intérieur, » à l'aide de les quatre étapes suivantes :
Commencez avec l'identificateur et l'apparence directement vers la droite pour les parenthèses ou des parenthèses (le cas échéant).
Interpréter ces parenthèses ou parenthèses, puis les examinez vers la gauche pour les astérisques.
Si vous rencontrez une parenthèse fermante à toute étape, revenez et appliquez les règles 1 et 2 à tout entre parenthèses.
appliquez le spécificateur de type.
char *( *(*var)() )[10]; ^ ^ ^ ^ ^ ^ ^ 7 6 4 2 1 3 5
Dans cet exemple, les étapes sont numérotées dans la commande et peuvent être interprétées comme suit :
L'identificateur var est déclaré comme
un pointeur vers
retour de fonction
un pointeur vers
un tableau de 10 éléments, qui sont
pointeurs vers
valeurs d'char .
Exemples
Les exemples suivants illustrent les autres déclarations et indiquent complexes comment les parenthèses peuvent affecter la signification d'une déclaration.
int *var[5]; /* Array of pointers to int values */
Le modificateur de tableau a une priorité élevée que le modificateur de pointeur, ce var est déclaré comme un tableau.Le modificateur de pointeur s'applique au type des éléments du tableau ; par conséquent, les éléments du tableau sont des pointeurs vers les valeurs d' int .
int (*var)[5]; /* Pointer to array of int values */
Dans cette déclaration pour var, les parenthèses permettent la priorité supérieure de modificateur de pointeur que le modificateur de tableau, et var est déclaré pour être un pointeur vers un tableau de cinq valeurs d' int .
long *var( long, long ); /* Function returning pointer to long */
Les modificateurs de fonctions ont également la priorité élevée que les modificateurs de pointeur, cette déclaration pour var déclare var pour être une fonction qui retourne un pointeur vers une valeur de long .la fonction est déclarée pour prendre deux valeurs de long comme arguments.
long (*var)( long, long ); /* Pointer to function returning long */
Cet exemple est semblable au précédent.Les parenthèses permettent la priorité supérieure de modificateur de pointeur que le modificateur de fonction, et var est déclaré pour être un pointeur vers une fonction qui retourne une valeur de long .De même, la fonction prend deux arguments de long .
struct both /* Array of pointers to functions */
{ /* returning structures */
int a;
char b;
} ( *var[5] )( struct both, struct both );
Les éléments d'un tableau ne peuvent pas être des fonctions, mais cette déclaration indique comment déclarer un tableau de pointeurs vers des fonctions à la place.Dans cet exemple, var est déclaré comme un tableau de cinq pointeurs vers des fonctions qui les structures de retour avec deux membres.Les arguments aux fonctions sont déclarés comme étant deux structures avec le même type structure, both.Notez que les parenthèses entourent *var[5] sont requises.Sans ceux-ci, la déclaration est une tentative non conforme de déclarer un tableau de fonctions, comme indiqué ci-dessous :
/* ILLEGAL */
struct both *var[5]( struct both, struct both );
L'instruction suivante déclare un tableau de pointeurs.
unsigned int *(* const *name[5][10] ) ( void );
la matrice d' name a 50 éléments organisés dans un tableau multidimensionnel.Les éléments sont des pointeurs vers un pointeur qui est une constante.Points de constante de ce pointeur vers une fonction qui n'a aucun paramètre et retourne un pointeur vers un type non signé.
Cet exemple suivant est une fonction qui retourne un pointeur vers un tableau de trois valeurs de double .
double ( *var( double (*)[3] ) )[3];
Dans cette déclaration, une fonction retourne un pointeur vers un tableau, comme les fonctions qui retournent des tableaux sont pas conformes.Ici var est déclaré pour être une fonction qui retourne un pointeur vers un tableau de trois valeurs de double .la fonction var prend un argument.L'argument, comme la valeur de retour, est un pointeur vers un tableau de trois valeurs de double .Le type d'argument est fourni par un résumé-déclarateurcomplexe.Les parenthèses autour de l'astérisque dans le type d'arguments sont requises ; sans elles, le type d'argument est un tableau de trois pointeurs vers les valeurs de double .Pour plus d'informations et des exemples des déclarateurs abstraits, consultez déclarateurs abstraits.
union sign /* Array of arrays of pointers */
{ /* to pointers to unions */
int x;
unsigned y;
} **var[5][5];
Comme le montre l'exemple ci-dessus illustre, un pointeur peut pointer vers un autre pointeur, et un tableau peut contenir des tableaux comme éléments.Ici var est un tableau de cinq éléments.Chaque élément est un tableau de cinq-élément de pointeurs vers des pointeurs vers des unions avec deux membres.
union sign *(*var[5])[5]; /* Array of pointers to arrays
of pointers to unions */
cet exemple montre comment le positionnement des parenthèses modifie la signification de la déclaration.Dans cet exemple, var est un tableau de cinq-élément de pointeurs vers les tableaux de cinq-élément de pointeurs vers des unions.Pour obtenir des exemples d'utilisation de typedef pour éviter les déclarations complexes, consultez déclarations de typedef.