Identificadores

Un identificador es una secuencia arbitrariamente larga de dígitos, guiones bajos, letras latinas mayúsculas y minúsculas, y la mayoría de los caracteres Unicode. Un identificador válido debe comenzar con un carácter que no sea un dígito (letra latina, guión bajo o carácter Unicode de clase XID_Start)) y puede contener caracteres que no son dígitos y caracteres Unicode de clase XID_Continue en posiciones no iniciales. Los identificadores distinguen entre mayúsculas y minúsculas (las letras minúsculas y mayúsculas son distintas) y cada carácter es significativo. Cada identificador debe ajustarse a la Forma de normalización C..

Nota: El apoyo de identificadores Unicode es limitado en la mayoría de las implementaciones, por ejemplo, gcc (hasta la versión 10).

[editar] En las declaraciones

Un identificador se puede usar para denominar objetos, referencias, funciones, enumeraciones, tipos, miembros de clase, espacios de nombres, plantillas, especializaciones de plantillas, paquetes de parámetros, etiquetas goto, y otras entidades, con las siguientes excepciones:

• los identificadores que son palabras clave no se pueden utilizar para otros propósitos;
  • el único lugar donde se pueden usar como palabras no-clave es en un token-de-atributo (p. ej., [[private]] es un atributo válido). (desde C++11)
• los identificadores que son representaciones alternativas para ciertos operadores y puntuadores no se pueden utilizar para otros fines.

• los identificadores con doble guión bajo en cualquier lugar están reservados;
• los identificadores que comienzan on un guión bajo seguido de una letra mayúscula están reservados;
• Los identificadores que comienzan con un guión bajo está reservados en el espacio de nombres global.

Reservado significa que los archivos de encabezado de la biblioteca estándar #define o declara estos identificadores para sus necesidades internas, el compilador puede predefinir identificadores no estándar de este tipo, y ese algoritmo de creación de nombres puede suponer que algunos de estos identificadores no están en uso. Si el programador utiliza estos identificadores, el comportamiento no está definido.

Además, el comportamiento no está definido en el caso de utilizar #define o #undef con ciertos nombres en una unidad de traducción; véase nombres de macros reservados para más detalles.

[editar] Identificadores zombies

A partir de C++14, algunos identificadores se eliminan de la biblioteca estándar de C ++. Se enumeran en la lista de nombres zombie.

Sin embargo, estos identificadores todavía están reservados para una estandarización previa en un contexto determinado. Los nombres de funciones miembros eliminados no pueden usarse como un nombre para macros similares a funciones, y otros nombres miembro eliminados no pueden usarse como un nombre para macros similares a objetos en código portátil.

[editar] En expresiones

Un identificador que denomina a una variable, una función, especialización de un concepto, (desde C++20) o un enumerador puede usarse como una expresión. El resultado de una expresión que consta solo del identificador es la entidad nombrada por el identificador. La categoría de valor de la expresión es l-valor si el identificador denomina una función, una variable, un objeto parámetro de plantilla (desde C++20), o un dato miembro, y pr-valor de lo contrario (por ejemplo, un enumerador es una expresión pr-valor, una especialización de un concepto es un pr-valor bool (desde C++20)). El tipo de la expresión se determina de la manera siguiente:

void f() {
  float x, &r = x;
  [=] {
    decltype(x) y1;             // y1 tiene tipo float
    decltype((x)) y2 = y1;      // y2 tiene tipo float const& por esta lambda
                                // is not mutable and x es un l-valor
    decltype(r) r1 = y1;        // r1 tiene tipo float&
    decltype((r)) r2 = y2;      // r2 tiene tipo float const&
  };
}

• De lo contrario, el tipo de expresión es el mismo que el tipo de entidad denominada.

Dentro del cuerpo de una función miembro no estática, cada identificador que denomina un miembro no estático se transforma implícitamente en una expresión de acceso a miembro de clase this-> member.

[editar] Identificadores no calificados

Además de los identificadores debidamente declarados, se puede utilizar lo siguiente en expresiones con el mismo rol:

• un nombre de operador sobrecargado en notación de función, como operator+ u operator new;
• un nombre de función de conversión definida por el usuario, como operator bool;
• un nombre de operador de literal definido por el usuario, como operator "" _km;
• un nombre de plantilla seguido del listado de sus argumentos, como MiPlantilla<int>;
• el carácter ~ seguido de un nombre de clase, como ~MiClase;
• el carácter ~ seguido de un especificador decltype, como ~decltype(str).

Junto con los identificadores, se los conoce como expresiones-id no calificadas.

[editar] Identificadores calificados

Una expresión-id calificada es una expresión-id no calificada precedida de un operador de resolución de ámbito ::, y opcionalmente, una secuencia de enumeración, (desde C++11)clase o nombres de espacios de nombres o expresiones decltype (desde C++11) separados por el operador de resolución de ámbito. Por ejemplo, la expresión std::string::npos es una expresión que denomina al miembro estático npos en la clase string en el espacio de nombres std. La expresión ::tolower denomina a la función tolower en el espacio de nombres global. La expresión ::std::cout denomina a la variable global cout en el espacio de nombres std, que es un espacio de nombres de primer nivel. La expresión boost::signals2::connection denomina el tipo connection declarado en el espacio de nombres signals2, que está declarado en el espacio de nombres boost.

La palabra clave template puede aparecer en identificadores calificados según sea necesario para eliminar la ambigüedad de los nombres de plantilla dependientes.

Véase la búsqueda de nombre calificado para detalles sobre la búsqueda de nombres para identificadores calificados.

[editar] Nombres

Un nombre es el uso de uno de los siguientes, para referirse a una entidad:

• un identificador;
• un nombre de operador sobrecargado en notación de función (operator+, operator new);
• un nombre de función de conversión definida por el usuario (operator bool);
• un nombre de operador de literal definido por el usuario (operator "" _km);
• un nombre de plantilla seguido por la lista de argumentos (MiPlantilla<int>).

Cada nombre se introduce en el programa mediante una declaración. Un nombre usado en más de una unidad de traducción puede referirse a la misma entidad o a entidades diferentes, dependiendo del enlazamiento.

Cuando el compilador encuentra un nombre desconocido en un programa, lo asocia con la declaración que introdujo el nombre por medio de búsqueda de nombres, excepto para los nombres dependientes en declaraciones y definiciones de plantillas (para esos nombres, el compilador determina si nombran un tipo, una plantilla o alguna otra entidad, que puede requerir una desambiguación explícita).

[editar] Véase también