Identifier

Un identifiant est une séquence arbitrairement longue de chiffres, de traits de soulignement, de lettres latines minuscules et majuscules , et de caractères Unicode spécifiés en utilisant \u et \U escape notation (depuis C99) , de la classe XID_Continue (depuis C23) . Un identifiant valide doit commencer par un caractère non numérique (lettre latine, trait de soulignement , ou caractère Unicode non numérique (depuis C99) (jusqu'à C23) , ou caractère Unicode de la classe XID_Start ) (depuis C23) ). Les identifiants sont sensibles à la casse (les lettres minuscules et majuscules sont distinctes). Chaque identifiant doit être conforme à la Normalization Form C . (depuis C23)

char *\U0001f431 = "cat"; // supported
char *🐱 = "cat"; // implementation-defined
                  // (e.g. works with Clang, but not GCC prior to version 10)
                  // both are ill formed in C23. Emoji are not XID_Start characters

Les identifiants peuvent désigner les types d'entités suivants :

• objets
• fonctions
• étiquettes ( struct , union , ou enumerations )
• membres de structure ou d'union
• constantes d'énumération
• typedef noms
• étiquette noms
• macro noms
• paramètre de macro noms

Tout identifiant autre que les noms de macros ou les noms de paramètres de macro possède une portée , appartient à un espace de noms , et peut avoir une liaison . Le même identifiant peut désigner différentes entités à différents endroits du programme, ou peut désigner différentes entités au même endroit si les entités se trouvent dans des espaces de noms différents.

Identifiants réservés

Les identifiants suivants sont réservés et ne peuvent pas être déclarés dans un programme (le faire invoque un comportement indéfini) :

1. Les identifiants qui sont des mots-clés ne peuvent pas être utilisés à d'autres fins. En particulier, #define ou #undef d'un identifiant identique à un mot-clé n'est pas autorisé.
2. Tous les identifiants externes qui commencent par un trait de soulignement.
3. Tous les identifiants qui commencent par un trait de soulignement suivi d'une lettre majuscule ou d'un autre trait de soulignement (ces identifiants réservés permettent à la bibliothèque d'utiliser de nombreuses macros et fonctions internes non externes).
4. Tous les identifiants externes définis par la bibliothèque standard (dans un environnement hébergé). Cela signifie qu'aucun nom externe fourni par l'utilisateur ne peut correspondre à un nom de bibliothèque, même en déclarant une fonction identique à une fonction de bibliothèque.
5. Les identifiants déclarés comme réservés à l'implémentation ou à une utilisation future par la bibliothèque standard (voir ci-dessous).
6. Les identifiants déclarés comme potentiellement réservés et fournis par l'implémentation (voir ci-dessous). (depuis C23)

Tous les autres identificateurs sont disponibles. Les identificateurs qui ne sont pas réservés ou potentiellement réservés (depuis C23) peuvent être utilisés sans crainte de collisions inattendues lors du transfert de programmes d'un compilateur et d'une bibliothèque à un autre.

Note : en C++, les identifiants avec un double soulignement n'importe où sont réservés partout ; en C, seuls ceux qui commencent par un double soulignement sont réservés.

Identifiants réservés et potentiellement réservés dans la bibliothèque

La bibliothèque standard réserve chaque identifiant qu'elle fournit. Les identifiants réservés qui ont une liaison externe (par exemple le nom de chaque fonction standard) sont réservés quel que soit l'en-tête inclus. Les autres identifiants réservés sont réservés lorsque l'un de leurs en-têtes associés est inclus.

Les identifiants suivants sont réservés ou potentiellement réservés (depuis C23) pour l'implémentation ou l'utilisation future par la bibliothèque standard.

• noms de fonctions , tous potentiellement réservés (depuis C23)
  • cerf , cerfc , cexp2 , cexpm1 , clog10 , clog1p , clog2 , clgamma , ctgamma , csinpi , ccospi , ctanpi , casinpi , cacospi , catanpi , ccompoundn , cpown , cpowr , crootn , crsqrt , cexp10m1 , cexp10 , cexp2m1 , clog10p1 , clog2p1 , clogp1 (depuis C23) et leurs variantes suffixées -f et -l, dans <complex.h> (depuis C99)
  • commençant par is ou to suivi d'une lettre minuscule, dans <ctype.h> et <wctype.h> (depuis C95)
  • commençant par str ou wcs (depuis C23) suivi d'une lettre minuscule, dans <stdlib.h> et <inttypes.h> (depuis C23)
  • commençant par cr_ , dans <math.h> (depuis C23)
  • commençant par wcs suivi d'une lettre minuscule, dans <wchar.h> (depuis C95)
  • commençant par atomic_ suivi d'une lettre minuscule, dans <stdatomic.h> (depuis C11)
  • commençant par cnd_ , mtx_ , thrd_ ou tss_ suivi d'une lettre minuscule, dans <threads.h> (depuis C11)
• noms typedef , tous potentiellement réservés (depuis C23)
  • commençant par int ou uint et se terminant par _t , dans <stdint.h> (depuis C99)
  • commençant par atomic_ ou memory_ suivi d'une lettre minuscule, dans <stdatomic.h> (depuis C11)
  • commençant par cnd_ , mtx_ , thrd_ ou tss_ suivi d'une lettre minuscule, dans <threads.h> (depuis C11)
• noms de macros
  • commençant par E suivi d'un chiffre ou d'une lettre majuscule, dans <errno.h>
  • commençant par FE_ suivi d'une lettre majuscule, dans <fenv.h> (depuis C99)
  • commençant par DBL_ , DEC32_ , DEC64_ , DEC128_ , DEC_ , FLT_ , ou LDBL_ suivi d'une lettre majuscule, dans <float.h> ; ces identifiants sont potentiellement réservés (depuis C23)
  • commençant par INT ou UINT et se terminant par _MAX , _MIN , _WIDTH (depuis C23) , ou _C , dans <stdint.h> ; ces identifiants sont potentiellement réservés (depuis C23) (depuis C99)
  • commençant par PRI ou SCN suivi d'une lettre minuscule ou de la lettre X , dans <inttypes.h> ; ces identifiants sont potentiellement réservés (depuis C23) (depuis C99)
  • commençant par LC_ suivi d'une lettre majuscule, dans <locale.h>
  • commençant par FP_ suivi d'une lettre majuscule, dans <math.h> (depuis C23)
  • commençant par MATH_ suivi d'une lettre majuscule, dans <math.h> ; ces identifiants sont potentiellement réservés (depuis C23)
  • commençant par SIG ou SIG_ suivi d'une lettre majuscule, dans <signal.h>
  • commençant par TIME_ suivi d'une lettre majuscule, dans <time.h> (depuis C11)
  • commençant par ATOMIC_ suivi d'une lettre majuscule, dans <stdatomic.h> ; ces identifiants sont potentiellement réservés (depuis C23) (depuis C11)
• constantes d'énumération , toutes potentiellement réservées (depuis C23)
  • commençant par memory_order_ suivi d'une lettre minuscule, dans <stdatomic.h> (depuis C11)
  • commençant par cnd_ , mtx_ , thrd_ ou tss_ suivi d'une lettre minuscule, dans <threads.h> (depuis C11)

Limites de traduction

Bien qu'il n'y ait pas de limite spécifique sur la longueur des identifiants, les premiers compilateurs avaient des limites sur le nombre de caractères initiaux significatifs dans les identifiants et les éditeurs de liens imposaient des limites plus strictes sur les noms avec liaison externe . Le C exige qu'au moins les limites suivantes soient prises en charge par toute implémentation conforme au standard :

Références

Voir aussi