Literal entero en C/C++ (Prefijos y Sufijos)

El literal entero es un tipo de literal para un entero cuyo valor se representa directamente en el código fuente. Por ejemplo, en la sentencia de asignación x = 1 , la string 1 es un literal entero que indica el valor 1, mientras que en la sentencia x = 0x10 la string 0x10 es un literal entero que indica el valor 16 (en decimal), que se representa mediante 10 en hexadecimal (indicado por el prefijo 0x).
Además, en x = “1” , el “1” es un literal de string (no un carácter ni un literal entero), porque está entre comillas. El valor de la string es 1, que resulta ser una string entera.

Los literales enteros se expresan en dos tipos, es decir,

1. Prefijos que indican la base. Por ejemplo, 0x10 indica el valor 16 en hexadecimal con prefijo 0x .
2. Sufijos que indican el tipo. Por ejemplo, 12345678901234LL indica el valor 12345678901234 como un entero largo con el sufijo LL .

Sintaxis

• Prefijos: Básicamente se representan en cuatro tipos.
  1. Decimal-literal (base 10) : – un dígito decimal distinto de cero seguido de cero o más dígitos decimales (0, 1, 2, 3, 4, 5, 6, 7, 8, 9). Por ejemplo, 56, 78 .
  2. Octal-literal (base 8) : – un cero seguido de cero o más dígitos octales (0, 1, 2, 3, 4, 5, 6, 7). Por ejemplo, 045, 076, 06210 .
  3. Literal hexadecimal (base 16) : – 0x o 0X seguido 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). Por ejemplo, 0x23A, 0Xb4C, 0xFEA .
  4. Literal binario (base 2) : – 0b o 0B seguido de uno o más dígitos binarios (0, 1). Por ejemplo, 0b101, 0B111 .
• Sufijos: Se representan de muchas maneras según sus tipos de datos.
  1. int : – No se requiere sufijo porque la constante entera se asigna de forma predeterminada como tipo de datos int.
  2. int sin signo : carácter u o U al final de la constante entera.
  3. int largo : carácter l o L al final de la constante entera.
  4. int largo sin signo : carácter ul o UL al final de una constante entera.
  5. long long int : carácter ll o LL al final de una constante entera.
  6. unsigned long long int : carácter ull o ULL al final de una constante entera.

// C++ program to demonstrate the use of
// integer literal
#include <iostream>
using namespace std;
  
int main()
{
    // PREFIXES
    cout << 213   << '\n'  // decimal integer literal
         << 0213  << '\n'  // Octal integer literal
         << 0x213A << '\n' // hexadecimal integer literal
         << 0b101  << '\n' // binary integer literal
  
         // SUFFIXES
         // long long literal
         << 1234567890123456789LL << '\n'
  
         // unsigned long long literal
         << 12345678901234567890ull << '\n'
  
         // automatic conversion of unsigned long long even
         // without long long prefix
         << 12345678901234567890u;
  
    return 0;
}

Output:
213
139
8506
5
1234567890123456789
12345678901234567890
12345678901234567890
1221300

Separador de dígitos: en C++, los literales enteros pueden contener separadores de dígitos para permitir la agrupación de dígitos en formas más legibles. Esto es particularmente útil para los campos de bits y hace que sea más fácil ver el tamaño de los números grandes (como un millón) de un vistazo al subitizar en lugar de contar los dígitos. También es útil para los números que normalmente se agrupan, como el número de tarjeta de crédito o los números de seguridad social. [a] Los números muy largos se pueden agrupar aún más duplicando los separadores.
Por lo general, los números decimales (base 10) se agrupan en grupos de tres dígitos (que representan uno de 1000 valores posibles), números binarios (base 2) en grupos de cuatro dígitos (un nibble, que representa uno de 16 valores posibles) y números hexadecimales ( base-16) en grupos de dos dígitos (cada dígito es un nibble, por lo que dos dígitos son un byte, lo que representa uno de los 256 valores posibles). Los números de otros sistemas (como los números de identificación) se agrupan siguiendo cualquier convención que esté en uso.

// C++ program to demonstrate digit separator
#include <iostream>
using namespace std;
  
int main()
{
    cout << 12345678901245LL <<'\n'
  
         // long long int literal digit separator
         << 12'345'678'901'245LL <<'\n'
  
         // binary literal digit separator
         << 0b1000'111'0 <<'\n'
  
         // hexadecimal literal digit separator
         << 0X12A'2b4;
         return 0;
}

Output:
12345678901245
12345678901245
142
1221300

Referencia : – https://en.wikipedia.org/wiki/Integer_literal
Este artículo es una contribución de Shubham Bansal . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.