Disponible la versión 6 de OrganiZATOR
Descubre un nuevo concepto en el manejo de la información.
La mejor ayuda para sobrevivir en la moderna jungla de datos la tienes aquí.

Curso C++

[Home]  [Inicio]  [Índice]


3.2.2  Identificadores

§1 Sinopsis

Recordemos ( 1.2.1) que un identificador es un conjunto de caracteres alfanuméricos de cualquier longitud que sirve para identificar las entidades del programa (clases, funciones, variables, tipos compuestos, Etc.)  Los identificadores pueden ser combinaciones de letras y números. Cada lenguaje tiene sus propias reglas que definen como pueden estar construidos. En el caso de C++, son las que se indican a continuación. Cuando un identificador se asocia a una entidad concreta, entonces es el "nombre" de dicha entidad, y en adelante la representa en el programa. Por supuesto puede ocurrir que varios identificadores se refieran a una misma entidad.

Nota: el concepto de "entidad" es muy amplio; corresponde a: un valor; clase; elemento de una matriz; variable; función; miembro de clase; instancia de clase; enumerador; plantilla, o espacio de nombres del programa.

§2 Identificadores C++

Los identificadores C++ pueden contener las letras a a z y A a Z,  el guión bajo "_" ("Underscore") y los dígitos 0 a 9.

Caracteres permitidos:
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
_

Dígitos permitidos
0 1 2 3 4 5 6 7 8 9

Solo hay dos restricciones en cuanto a la composición:

  • El primer carácter debe ser una letra o el guión bajo. El Estándar establece que los identificadores comenzando con guión bajo y mayúscula no deben ser utilizados. Este tipo de nombres se reserva para los compiladores y las Librerías Estándar. Tampoco se permite la utilización de nombres que contengan dos guiones bajos seguidos.

  • El estándar ANSI establece que como mínimo serán significativos los 31 primeros caracteres, aunque pueden ser más, según la implementación [1]. Es decir, para que un compilador se adhiera al estándar ANSI, debe considerar como significativos, al menos, los 31 primeros caracteres.

Nota: veremos que los identificadores de los operadores ( 4.9) son un caso especial que se aparta de estas reglas.


Los identificadores distinguen mayúsculas y minúsculas, así que Sum, sum y suM son distintos para el compilador. Sin embargo, C++Builder ofrece la opción de suspender la sensibilidad a mayúsculas / minúsculas, lo que permite la compatibilidad con lenguajes insensibles a esta cuestión, en este caso, las variables globales Sum, sum y suM serían consideradas idénticas, aunque podría resultar un mensaje de aviso "Duplicate symbol" durante el enlazado.

§2.1 Con los identificadores del tipo __pascal hay una excepción a esta regla, ya que son convertidos siempre a mayúsculas con vistas al enlazado.

Los identificadores globales importados desde otros módulos siguen las mismas reglas que los identificadores normales.


§3 Aunque los nombres de los identificadores pueden ser arbitrarios (dentro de las reglas señaladas),  se produce un error si se utiliza el mismo identificador dentro del mismo ámbito compartiendo el mismo espacio de nombres ( 4.1.11).  Los nombres duplicados son legales en diferentes espacios de nombres con independencia de las reglas de ámbito.

  Un identificador no puede coincidir con una palabra clave ( 3.2.1) o con el de ninguna función de biblioteca.


§4 El estándar ANSI distingue dos tipos de identificadores:

  • Identificadores internos; los nombres de macros de preprocesado y todas las que no tengan enlazado externo. El estándar establece que serán significativos, al menos, los primeros 31 caracteres.
  • Identificadores externos; los que corresponden a elementos que tengan enlazado externo. En este caso el estándar es más permisivo. Se acepta que el compilador identifique solo seis caracteres significativos y pueda ignorar la distinción mayúsculas/minúsculas (Enlazado 1.4.4).
§5 Reglas de estilo

Es bastante frecuente que en la enseñanza de C++ (y de cualquier otro lenguaje de programación) no se subraye suficientemente la importancia de la elección de los identificadores. En este sentido, los textos se suelen limitar a señalar las reglas formales que impone el lenguaje para la declaración de nombres. Sin embargo, como todos los que tienen que ver con la legibilidad del código, el asunto es de capital importancia. Sobre todo, si se trata de algo más que del consabido programita "Hola mundo", y desde luego resulta crítico en proyectos medianamente grandes en los que puedan trabajar más de un programador y/o deba ser mantenido por personas distintas de su creador original (lo que antes o después acaba ocurriendo en la informática empresarial).

C y C++ tienen sus propias reglas no escritas, sancionadas por la costumbre, en cuanto a ciertas formas concretas de usar los identificadores. Por ejemplo: Es costumbre utilizar minúsculas para los nombres de variables y funciones (1) (con frecuencia se utilizan combinaciones minúsculas/Mayúsculas - por ejemplo getRvalue o rColor-, aunque la inicial suele ser minúscula). Los identificadores de variables automáticas lo más cortos posibles (2); los de estáticas y globales más largos y descriptivos (3).  Los nombres de constantes simbólicas normalmente en mayúsculas (4).

Ejemplo:

void someFunc (int numero, char clave, int* puntero_a_clase); // (3)

static tipoCliente = 0;                // (3)

enum formaPago { CONTADO, CREDITO };   // (4)

...

someFunc(int n, char k, int *ptr) {    // (1) (2)

   int z, y, z = 2;                    // (2)

}


Aparte de las manías o hábitos particulares que pueda tener cada programador, la mayoría de empresas de software medianamente serias disponen de sus propios "Manuales de estilo" o "Reglas de uso", en los que se recogen las convenciones que deben utilizarse para los identificadores, de forma que se mantenga la máxima homogeneidad posible en el código, lo que a la postre redunda en una mayor legibilidad y facilidad de mantenimiento. En este sentido cabría señalar que, dentro de ciertos límites, no es tan importante cuales sean estas reglas, sino que existan y se respeten.

En determinados entornos existen reglas consagradas por el uso. Por ejemplo, en la programación C/C++ para las plataformas Windows suelen seguirse determinadas convenciones conocidas como Notación Húngara [5], en la que el identificador de cada variable comienza con una o varias letras (minúsculas) que señalan el tipo de la variable. Por ejemplo, nValor.

Los nombres de clases se preceden siempre con una "C" mayúscula, y la siguiente letra también es mayúscula. Por ejemplo: CAboutDlg, CAprenderApp, CMainFrame, etc. Los nombres de variables comienzan por letras fijas según su tipo (ver cuadro adjunto), pero cuando se refieren a una propiedad de clase, los dos primeros caracteres son "m_" (ejemplo m_nValor, m_wndStatusBar, etc). Los nombres de funciones miembro de clase comienzan siempre con mayúscula, pero la siguiente letra es minúscula [6].  Por ejemplo: DoDataExchange(), InitInstance(), OnAppAbout(), etc.

Este tipo de notación presenta la ventaja de con un poco de práctica es mucha la información que puede extraerse de la simple lectura del código.

En el cuadro adjunto se incluyen algunas de estas convenciones.

Prefijo Tipo de dato/situación      

Ejemplo

a

Matriz (array) aValor, aX, aY

b

BOOL  (long) bValor, bA, bB

by

BYTE  (unsigned char) byValr, byA, byB

c / ch

carácter  (char) cValor, cA, cB, chA, chB

clr

COLORREF (unsigned long) [3] clrBgColor, clrFrgColor

cx, cy

Entero (short) [2] cxValor, cyValor, cxA, cyA

d

double dValor, dA, dB

dw

DWORD  (unsigned long) dwValor, dwA, dwB

fn

Función normal (los métodos siguen otra regla) fnGetx(), fnGety()

h

Handle [4] hWind, m_hWind

i

Entero (int) iValor, iX, iY

l

LONG  (long) lValor, lX, lY

m_

Propiedades de clases (member variable) m_nValor, m_szString

n

Entero (short int nValor, nX, nY

p

Puntero pValor, pA, pB

s

Cadena alfanumérica (string) sValor, sA, sB

sz

Cadena alfanumérica terminada en carácter nulo

al viejo estilo C ( 4.3.4)

szValor, szA, szB

u

Entero (unsigned int) uValor, uA, uB

x, y

Coordenadas x e y x, y

w

WORD  (unsigned short) wValor, wA, wB

C

Clases ( 4.11) la letra siguiente también mayúscula CDialog, CEditView, CButton


Nota
: la programación Windows utiliza sus propios tipos definidos mediante typedefs ( 3.2.1a).  Generalmente son identificadores expresados en mayúsculas ( Ejemplos).

  Inicio.


[1]  Los identificadores pueden ser más largos; de hecho en C++ pueden ser de cualquier longitud, pero el compilador solo considera los n primeros; es decir: considera iguales aquellos identificadores cuyos n primeros caracteres coinciden. C++Builder establece por defecto que son significativos los primeros 250 caracteres, pero este valor puede ser modificado utilizando la opción -in, donde n es un número entre 8 y 250; además el 0 significa el valor máximo.

Puesto que algunos compiladores utilizan valores diferentes (algunos compiladores UNIX solo consideran diferentes los 8 primeros), si se quiere escribir un código portable, es preferible establecer este parámetro a un valor más pequeño, a fin de que no ocurran colisiones de nombres largos cuando sean recortados por el compilador.

[2] Se utilizan para señalar distancias horizontales y verticales. Windows es un entorno de programación gráfico en el que este tipo de datos es de utilización constante; lo mismo que en la programación en modo texto son los datos de fila/columna (row/col). Estos valores se identifican con un short y están expresadas en píxeles.

[3] Por la razón antes expuesta, los datos de color son de utilización constante. La programación C++ para Windows utiliza normalmente 32 bits para almacenar los datos de color ( 4.9.3).

[4] Valor de 32 bits que referencia a una estructura de datos en la que Windows almacena información relativa a las ventanas, incluyendo estilo, tamaño y situación en la pantalla.

[5] En recuerdo de Charles Simonyi, durante mucho tiempo el "Arquitecto Jefe" de Microsoft que popularizó este estilo de notación dentro de dicha empresa.

[6] Una excepción a esta regla son los nombres de constructores y destructores. Evidentemente el constructor de la clase a pesar de ser una función tiene el mismo identificativo que la clase (las dos primeras letras son mayúsculas).

[7] Observe que esta definición de objeto es muy general, y no se refiere exclusivamente a la instancia de una clase.