Tipos de literales en C/C++ con ejemplos

Los valores asignados a cada variable constante se denominan literales . Generalmente, ambos términos, constantes y literales se usan indistintamente. 

Por ejemplo, “const int = 5;“, es una expresión constante y el valor 5 se denomina literal entero constante. Hay 4 tipos de literales en C y cinco tipos de literales en C++. 

1 ) Literales enteros

Estos se utilizan para representar y almacenar los valores enteros. Los literales enteros se expresan en dos tipos, es decir

A) Prefijos: El Prefijo del literal entero indica la base en que se debe leer.

Por ejemplo:

0x10 = 16

Porque el prefijo 0x representa una base hexadecimal. Entonces 10 en HexaDecimal es 16 en Decimal. De ahí el valor 16. 

Básicamente se representan en 4 tipos.

una. Literal decimal (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).

Ejemplo:

56, 78

b. Octal-literal (base 8): un 0 seguido de cero o más dígitos octales (0, 1, 2, 3, 4, 5, 6, 7).

Ejemplo:

045, 076, 06210

C. 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).

Ejemplo:

0x23A, 0Xb4C, 0xFEA

d. Literal binario (base 2): 0b o 0B seguido de uno o más dígitos binarios (0, 1).

Ejemplo:

0b101, 0B111

B) Sufijos: El Prefijo del literal entero indica el tipo en que se va a leer.

Por ejemplo:

12345678901234LL 

indica un valor entero largo largo 12345678901234 debido al sufijo LL

Estos se representan de muchas maneras según sus tipos de datos.

• int: no se requiere sufijo porque la constante entera se asigna de forma predeterminada como un tipo de datos int.
• int sin signo: carácter u o U al final de una constante entera.
• long int: carácter l o L al final de una constante entera.
• int largo sin signo: carácter ul o UL al final de una constante entera.
• long long int: carácter ll o LL al final de una constante entera.
• unsigned long long int: carácter ull o ULL al final de una constante entera.

Ejemplo:

#include <stdio.h>
 
int main()
{
 
    // constant integer literal
    const int intVal = 10;
 
    printf("Integer Literal:%d \n",
            intVal);
    return 0;
}

#include <iostream>
using namespace std;
 
int main()
{
    // constant integer literal
    const int intVal = 10;
    cout << "Integer Literal: "
         << intVal << "\n";
 
    return 0;
}

Producción:

Integer Literal:10

2) Literales de coma flotante

Estos se utilizan para representar y almacenar números reales. El número real tiene una parte entera, una parte real, una parte fraccionaria y una parte exponencial. Los literales de coma flotante se pueden almacenar en forma decimal o exponencial. Al representar los decimales de punto flotante, se deben tener en cuenta dos cosas para producir un literal válido:

• En la forma decimal, se debe incluir el punto decimal, la parte del exponente o ambos, de lo contrario, dará lugar a un error.
• En la forma exponencial, se debe incluir la parte entera, la parte fraccionaria o ambas, de lo contrario, dará lugar a un error.

Algunas representaciones literales de coma flotante se muestran a continuación:

Literales flotantes válidos:

10.125
1.215-10L
10.5E-3

Literales flotantes no válidos:

123E
1250f
0.e879

Ejemplo:

#include <iostream>
using namespace std;
 
int main()
{
    // Real literal
    const float floatVal = 4.14;
 
    cout << "Floating-point literal: "
         << floatVal << "\n";
    return 0;
}

#include <stdio.h>
 
int main()
{
    // constant float literal
    const float floatVal = 4.14;
 
    printf("Floating point literal: %.2f\n",
        floatVal);
    return 0;
}

Producción:

Floating point literal: 4.14

3) Caracteres literales

Esto se refiere al literal que se usa para almacenar un solo carácter dentro de una comilla simple. Para almacenar varios caracteres, se necesita usar una array de caracteres. Almacenar más de un carácter dentro de una comilla simple generará una advertencia y mostrará solo el último carácter del literal. Da lugar a las dos representaciones siguientes:

A. tipo char: se utiliza para almacenar literales de caracteres normales o literales de caracteres estrechos. Esto es compatible tanto con C como con C++.

Ejemplo:

// For C
char chr = 'G';

// For C++
char chr = 'G';

B. tipo wchar_t: este literal solo se admite en C++ y no en C . Si el carácter va seguido de L, entonces el literal debe almacenarse en wchar_t. Esto representa un literal de caracteres anchos.

Ejemplo:

// Not Supported For C

// For C++
wchar_t chr = L'G';

Ejemplo:

#include <stdio.h>
 
int main()
{
    // constant char literal
    const char charVal = 'A';
 
    printf("Character Literal: %c\n",
        charVal);
    return 0;
}

#include <iostream>
using namespace std;
   
int main()
{
    // constant char literal
    const char charVal = 'A';
   
    // wide char literal
    const wchar_t charVal1 = L'A';
   
    cout << "Character Literal: "
         << charVal << "\n";
    cout << "Wide_Character Literal: "
         << charVal1 << "\n";
   
    return 0;
}
 
// output
// Character Literal: A
// Wide_Character Literal: 65

Producción:

Character Literal: A

Secuencias de escape :hay varios caracteres especiales que se pueden usar para realizar varias operaciones.

4) Literales de string

Los literales de string son similares a los literales de caracteres, excepto que pueden almacenar varios caracteres y usan comillas dobles para almacenar lo mismo. También puede acomodar los caracteres especiales y las secuencias de escape mencionadas en la tabla anterior.

Ejemplo:

// For C
char stringVal[] = "GeeksforGeeks";

// For C++
string stringVal = "GeeksforGeeks"

Ejemplo:

#include <iostream>
using namespace std;
 
int main()
{
    const string str
        = "Welcome\nTo\nGeeks\tFor\tGeeks";
    cout << str;
    return 0;
}

#include <stdio.h>
 
int main()
{
    const char str[]
        = "Welcome\nTo\nGeeks\tFor\tGeeks";
    printf("%s", str);
    return 0;
}

Producción:

Welcome
To
Geeks    For    Geeks

5) Literales booleanos

Este literal se proporciona solo en C++ y no en C . Se utilizan para representar los tipos de datos booleanos. Estos pueden tener dos valores:

• verdadero: para representar el valor verdadero. Esto no debe considerarse igual a int 1.
• falso: para representar el valor falso. Esto no debe considerarse igual a int 0.

Ejemplo:

// C++ program to show Boolean literals
 
#include <iostream>
using namespace std;
 
int main()
{
    const bool isTrue = true;
    const bool isFalse = false;
 
    cout << "isTrue? "
        << isTrue << "\n";
    cout << "isFalse? "
        << isFalse << "\n";
 
    return 0;
}

Producción:

isTrue? 1
isFalse? 0

Artículos relacionados sobre constantes/literales en C/C++:

• Literales definidos por el usuario.
• Literal de string sin formato en C++
• Literales octales en C
• Literales compuestos en C
• Tipo diferencia de caracteres literales C++.