Constantes enteras (Informática)

Decimal

Se permiten constantes enteras en formato decimal (base 10) dentro del rango 0 a 4, 294, 967, 295; las que excedan este límite serán truncadas. Las constantes decimales no pueden comenzar con cero, porque serían interpretadas como octales.

              int i = 10; // decimal 10

              int i = 010; // decimal 8 (octal 10)

              int i = 0; // decimal 0 = octal 0

Tipos adoptados por las constantes decimales en función del valor declarado (en ausencia de sufijos L o U)

              0                      a 32,767                int

              32,768              a 2,147,483,647     long

              2,147,483,648   a 4,294,967,295     unsigned long

              >4294967295                                truncado

Octal

Todas las constantes que empiecen por cero se suponen en octal (base 8). Si una constante de este tipo contiene dígitos ilegales (8 o 9), se produce un mensaje de error, las que exceden del valor máximo 037777777777 son truncadas.

Tipos adoptados por las constantes Octales en función del valor declarado (en ausencia de sufijos L o U).

              00                      a 077777                int

              010000               a 0177777              unsigned int

              02000000            a 017777777777     long

              020000000000     a 037777777777     unsigned long

              > 037777777777                               truncado.

Hexadecimal

Cualquier constante que comience por 0x o 0X es considerada hexadecimal, base 16, después se pueden incluir los dígitos válidos (0...9, a...f, A...F). Las que excedan del valor máximo 0xFFFFFFFF son truncadas.

Tipos adoptados por las constantes hexadecimales en función del valor declarado (en ausencia de sufijos L o U).

             0x0000           a 0x7FFF           int

             0x8000           a 0xFFFF           unsigned int

             0x10000         a 0x7FFFFFFF    long

             0x80000000    a 0xFFFFFFFF   unsigned long

             >0xFFFFFFFF                          truncado

Sufijos: long (L) y unsigned (U)

La adición de sufijos en la definición de una constante puede forzar que esta sea de un tipo específico, así pues, los sufijos funcionan como una especie de "casting" para las constantes. Se utilizan las letras U u L l. Estos sufijos se pueden utilizar juntos y en cualquier orden o grafía (ul, lu, Ul, lU, uL, Lu, LU o UL).

Los sufijos L / l después de una constante la fuerzan a ser declarada como long. Ejemplo:

             const x = 7L; // x es long

Los sufijos U / u la fuerzan a que sea declarada como unsigned; en este caso, con independencia de la base utilizada, la constante será considerada unsigned long si el valor del número es mayor que el decimal 65,535. Ejemplo:

            const x = 7U; // x es unsigned int

            const y = 66000U; // y es unsigned long

En ausencia de alguno de estos sufijos el tipo de la constante es el primero de los que se señalan que pueda albergar su valor.

            Decimal:         int, long int, unsigned long int

            Octal:             int, unsigned int, long int, unsigned long int

            Hexadecimal:  int, unsigned int, long int, unsigned long int

Si la constante tiene un sufijo U o u, su tipo es unsigned int, unsigned long o int (el primero que pueda albergar el valor).

Si tiene un sufijo L o l, su tipo es long int o unsigned long int (el primero que pueda albergar el valor). Si la constante tiene ambos sufijos, u e l (ul, lu, Ul, lU, uL, Lu, LU o UL), su tipo de es unsigned long int. Ejemplo:

           const z = 0UL; // z es unsigned long

Como puede verse, las constantes enteras sin L o U compendian la representación de constantes enteras en cualquiera de los tres sistemas de numeración (en C++Builder).

Algunos compiladores utilizan los sufijos ll/LL y ull/ULL para referirse a los enteros extendidos long long y unsigned long long respectivamente.