Identifier

Un identificador es una secuencia arbitrariamente larga de dígitos, guiones bajos, letras latinas minúsculas y mayúsculas , y caracteres Unicode especificados usando la notación de \u y \U escape (desde C99) , de la clase XID_Continue (desde C23) . Un identificador válido debe comenzar con un carácter que no sea un dígito (letra latina, guion bajo , o carácter Unicode que no sea un dígito (desde C99) (hasta C23) , o carácter Unicode de la clase XID_Start ) (desde C23) ). Los identificadores distinguen entre mayúsculas y minúsculas (las letras minúsculas y mayúsculas son distintas). Cada identificador debe ajustarse a la Forma Normal C . (desde 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

Los identificadores pueden denotar los siguientes tipos de entidades:

• objetos
• funciones
• etiquetas ( struct , union , o enumerations )
• miembros de estructura o unión
• constantes de enumeración
• typedef nombres
• etiqueta nombres
• macro nombres
• parámetro de macro nombres

Cada identificador, excepto los nombres de macros o los nombres de parámetros de macros, tiene scope , pertenece a un name space , y puede tener linkage . El mismo identificador puede denotar diferentes entidades en diferentes puntos del programa, o puede denotar diferentes entidades en el mismo punto si las entidades están en diferentes name spaces.

Identificadores reservados

Los siguientes identificadores están reservados y no pueden declararse en un programa (hacerlo invoca comportamiento indefinido):

1. Los identificadores que son keywords no pueden utilizarse para otros propósitos. En particular, no se permite #define o #undef de un identificador idéntico a una keyword.
2. Todos los identificadores externos que comienzan con un guion bajo.
3. Todos los identificadores que comienzan con un guion bajo seguido de una letra mayúscula o de otro guion bajo (estos identificadores reservados permiten a la biblioteca utilizar numerosas macros y funciones internas no externas).
4. Todos los identificadores externos definidos por la biblioteca estándar (en entorno hospedado). Esto significa que no se permiten nombres externos proporcionados por el usuario que coincidan con ningún nombre de la biblioteca, ni siquiera al declarar una función idéntica a una función de la biblioteca.
5. Identificadores declarados como reservados para la implementación o uso futuro por la biblioteca estándar (ver más abajo).
6. Identificadores declarados como potencialmente reservados y proporcionados por la implementación (ver más abajo). (since C23)

Todos los demás identificadores están disponibles. Los identificadores que no están reservados o potencialmente reservados (desde C23) pueden usarse sin temor a colisiones inesperadas al mover programas de un compilador y biblioteca a otro.

Nota: en C++, los identificadores con un doble guion bajo en cualquier parte están reservados en todas partes; en C, solo los que comienzan con un doble guion bajo están reservados.

Identificadores reservados y potencialmente reservados en la biblioteca

La biblioteca estándar reserva cada identificador que proporciona. Los identificadores reservados que tienen enlace externo (por ejemplo, el nombre de cada función estándar) están reservados independientemente de qué cabecera se incluya. Otros identificadores reservados están reservados cuando se incluye cualquiera de sus cabeceras asociadas.

Los siguientes identificadores están reservados o potencialmente reservados (since C23) para la implementación o uso futuro por la biblioteca estándar.

• nombres de funciones , todos los cuales están potencialmente reservados (desde 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 (desde C23) y sus variantes con sufijos -f y -l, en <complex.h> (desde C99)
  • que comienzan con is o to seguidos de una letra minúscula, en <ctype.h> y <wctype.h> (desde C95)
  • que comienzan con str o wcs (desde C23) seguidos de una letra minúscula, en <stdlib.h> y <inttypes.h> (desde C23)
  • que comienzan con cr_ , en <math.h> (desde C23)
  • que comienzan con wcs seguidos de una letra minúscula, en <wchar.h> (desde C95)
  • que comienzan con atomic_ seguidos de una letra minúscula, en <stdatomic.h> (desde C11)
  • que comienzan con cnd_ , mtx_ , thrd_ o tss_ seguidos de una letra minúscula, en <threads.h> (desde C11)
• nombres de typedef , todos los cuales están potencialmente reservados (desde C23)
  • que comienzan con int o uint y terminan con _t , en <stdint.h> (desde C99)
  • que comienzan con atomic_ o memory_ seguidos de una letra minúscula, en <stdatomic.h> (desde C11)
  • que comienzan con cnd_ , mtx_ , thrd_ o tss_ seguidos de una letra minúscula, en <threads.h> (desde C11)
• nombres de macros
  • que comienzan con E seguido de un dígito o una letra mayúscula, en <errno.h>
  • que comienzan con FE_ seguido de una letra mayúscula, en <fenv.h> (desde C99)
  • que comienzan con DBL_ , DEC32_ , DEC64_ , DEC128_ , DEC_ , FLT_ , o LDBL_ seguido de una letra mayúscula, en <float.h> ; estos identificadores están potencialmente reservados (desde C23)
  • que comienzan con INT o UINT y terminan con _MAX , _MIN , _WIDTH (desde C23) , o _C , en <stdint.h> ; estos identificadores están potencialmente reservados (desde C23) (desde C99)
  • que comienzan con PRI o SCN seguido de una letra minúscula o la letra X , en <inttypes.h> ; estos identificadores están potencialmente reservados (desde C23) (desde C99)
  • que comienzan con LC_ seguido de una letra mayúscula, en <locale.h>
  • que comienzan con FP_ seguido de una letra mayúscula, en <math.h> (desde C23)
  • que comienzan con MATH_ seguido de una letra mayúscula, en <math.h> ; estos identificadores están potencialmente reservados (desde C23)
  • que comienzan con SIG o SIG_ seguido de una letra mayúscula, en <signal.h>
  • que comienzan con TIME_ seguido de una letra mayúscula, en <time.h> (desde C11)
  • que comienzan con ATOMIC_ seguido de una letra mayúscula, en <stdatomic.h> ; estos identificadores están potencialmente reservados (desde C23) (desde C11)
• constantes de enumeración , todas las cuales están potencialmente reservadas (desde C23)
  • que comienzan con memory_order_ seguido de una letra minúscula, en <stdatomic.h> (desde C11)
  • que comienzan con cnd_ , mtx_ , thrd_ o tss_ seguido de una letra minúscula, en <threads.h> (desde C11)

Límites de traducción

Aunque no existe un límite específico en la longitud de los identificadores, los primeros compiladores tenían límites en el número de caracteres iniciales significativos en los identificadores y los enlazadores imponían límites más estrictos en los nombres con enlace externo . C requiere que al menos los siguientes límites sean compatibles con cualquier implementación conforme al estándar:

Referencias

Véase también