Literal entero

Permite que valores de tipo entero se usen directamente en expresiones.

[editar] Sintaxis

Un literal entero tiene la forma

donde

• literal-decimal es un dígito decimal distinto de cero (1, 2, 3, 4, 5, 6, 7, 8, 9), seguido de cero o más dígitos decimales (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
• literal-octal es el dígito cero (0) seguido de cero o más dígitos octales: (0, 1, 2, 3, 4, 5, 6, 7);
• literal-hex es la secuencia de caracteres 0x o la secuencia de caracteres 0X seguida de uno o más dígitos hexadecimales (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C, d, D, e, E, f, F);
• literal-binario es la secuencia de caracteres 0b o la secuencia de caracteres 0B seguida de uno o más dígitos binarios (0, 1);
• sufijo-entero, si se proporciona, puede contener uno o ambos de los siguientes (si ambos se proporcionan, pueden aparecer en cualquier orden):

• sufijo-sin-signo (el carácter u o el carácter U);
• uno de

• sufijo-long (el carácter l o el carácter L);

Un literal entero (como cualquier literal) es una expresión primaria.

[editar] Explicación

El primer dígito de un literal entero es el más significativo.

Ejemplo. Las siguientes variables se inicializan en el mismo valor:

int d = 42;
int o = 052;
int x = 0x2a;
int X = 0X2A;
int b = 0b101010; // C++14

Ejemplo. Las siguientes variables también se inicializan en el mismo valor:

unsigned long long l1 = 18446744073709550592ull;       // C++11
unsigned long long l2 = 18'446'744'073'709'550'592llu; // C++14
unsigned long long l3 = 1844'6744'0737'0955'0592uLL;   // C++14
unsigned long long l4 = 184467'440737'0'95505'92LLU;   // C++14

[editar] El tipo del literal

El tipo del literal entero es el primer tipo en el cual el valor puede encajar, de la lista de tipos, que depende de cuál base numérica y cuál sufijo-entero se usó:

Si el valor del literal entero que no tiene sufijo-de-tamaño (desde C++23) es demasiado grande para encajar en cualquiera de los tipos permitidos por la combinación sufijo/base y el compilador admite un tipo entero extendido (como __int128) que puede representar el valor del literal, se le puede dar al literal ese tipo entero extendido; de lo contrario, el programa estará mal formado.

[editar] Notas

Las letras en los literales enteros no son sensibles a las mayúsculas o minúsculas: 0xDeAdBeEfU y 0XdeadBEEFu representan el mismo número (una excepción es el sufijo-long-long, que es ya sea ll o LL, nunca lL o Ll) (desde C++11).

No existen literales enteros negativos. Las expresiones como -1 aplican el operador menos unario al valor representado por el literal, lo que puede implicar conversiones de tipo implícitas.

En C antes de C99 (pero no en C++), los valores decimales sin sufijo que no encajan en long int se les permite que tengan el tipo unsigned long int.

Debido a la mascada máxima, los literales enteros hexadecimales que terminan en e y E, cuando están seguidos de los operadores + o -, deben estar separados del operador con espacio en blanco o paréntesis en el código fuente:

auto x = 0xE+2.0;   // ERROR
auto y = 0xa+2.0;   // de acuerdo
auto z = 0xE +2.0;  // de acuerdo
auto q = (0xE)+2.0; // de acuerdo

De lo contrario, se forma un solo símbolo numérico de preprocesamiento inválido, que provoca que falle un análisis posterior.

[editar] Ejemplo

#include <cstddef>
#include <iostream>
#include <type_traits>
 
int main()
{
std::cout << 123    << '\n'
          << 0123   << '\n'
          << 0x123  << '\n'
          << 0b10   << '\n'
          << 12345678901234567890ull << '\n'
          << 12345678901234567890u   << '\n'; // el tipo es unsigned long long 
                                              // incluso sin un sufijo long long
 
//   std::cout << -9223372036854775808 << '\n'; // ERROR: el valor
                // 9223372036854775808 no puede encajar en long long con signo, que es el
                // tipo más grande permitido para un literal decimal entero sin sufijo
     std::cout << -9223372036854775808u << '\n'; // el menos unario aplicado al valor
                // sin signo lo sustrae de 2^64, esto da 9223372036854775808
     std::cout << -9223372036854775807 - 1 << '\n'; // manera correcta para calcular
                                                    // el valor -9223372036854775808
 
#if __cpp_size_t_suffix >= 202011L // C++23
     static_assert(std::is_same_v<decltype(0UZ), std::size_t>);
     static_assert(std::is_same_v<decltype(0Z), std::make_signed_t<std::size_t>>);
#endif
}

123
83
291
2
12345678901234567890
12345678901234567890
9223372036854775808
-9223372036854775808

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Referencias

[editar] Véase también