Integer literal

• 1 Sintaxis
• 2 Explicación
• 3 El tipo del literal
• 4 Notas
• 5 Ejemplo
• 6 Informes de defectos
• 7 Referencias
• 8 Véase también

Sintaxis

Un literal entero tiene la forma

donde

• decimal-literal 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 )
• octal-literal es el dígito cero ( 0 ) seguido de cero o más dígitos octales ( 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 )
• hex-literal 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 )
• binary-literal es la secuencia de caracteres 0b o la secuencia de caracteres 0B seguida de uno o más dígitos binarios ( 0 , 1 )
• integer-suffix , si se proporciona, puede contener uno o ambos de los siguientes (si se proporcionan ambos, pueden aparecer en cualquier orden:

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

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

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

Explicación

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

Ejemplo. Las siguientes variables se inicializan al 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 al 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

El tipo del literal

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

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

Notas

Las letras en los literales enteros no distinguen entre mayúsculas y minúsculas: 0xDeAdBeEfU y 0XdeadBEEFu representan el mismo número (una excepción es el long-long-suffix , que puede ser ll o LL , nunca lL o Ll ) (desde C++11) .

No existen literales de enteros negativos. Expresiones como - 1 aplican el operador unario de resta al valor representado por el literal, lo cual puede involucrar conversiones de tipo implícitas.

En C anterior a C99 (pero no en C++), los valores decimales sin sufijo que no caben en long int pueden tener el tipo unsigned long int .

Debido al maximal munch , los literales enteros hexadecimales que terminan en e y E , cuando van seguidos de los operadores + o - , deben separarse del operador con espacios en blanco o paréntesis en el código fuente:

auto x = 0xE+2.0;   // error
auto y = 0xa+2.0;   // OK
auto z = 0xE +2.0;  // OK
auto q = (0xE)+2.0; // OK

De lo contrario, se forma un único token de número de preprocesamiento no válido, lo que provoca que el análisis posterior falle.

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 el sufijo long long
//  std::cout << -9223372036854775808 << '\n'; // error: el valor
               // 9223372036854775808 no cabe en signed long long, que es el
               // tipo más grande permitido para literales enteros decimales sin sufijo
    std::cout << -9223372036854775808u << '\n'; // el menos unario aplicado a un valor
               // sin signo lo resta de 2^64, esto da 9223372036854775808
    std::cout << -9223372036854775807 - 1 << '\n'; // forma correcta de 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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Referencias

Véase también