C# | literales – Part 1

Los valores fijos se denominan Literal . Literal es un valor que utilizan las variables. Los valores pueden ser enteros, flotantes o strings, etc. 

// Here 100 is a constant/literal.
int x = 100; 

Los literales pueden ser de los siguientes tipos: 

• Literales enteros
• Literales de coma flotante
• Literales de caracteres
• Literales de string
• Literales nulos
• Literales booleanos

Literales enteros: Un literal de tipo entero se conoce como literal entero. Puede ser una constante octal, decimal, binaria o hexadecimal. No se requiere prefijo para los números decimales. También se puede usar un sufijo con los literales enteros como U o u se usan para números sin signo, mientras que l o L se usan para números largos. Por defecto, cada literal es de tipo int. Para los tipos de datos integrales (byte, short, int, long), podemos especificar literales de la siguiente manera:

• Literales decimales (Base 10): En este formulario, los dígitos permitidos son 0-9.

int x = 101;

• Literales octales (Base 8): En esta forma, los dígitos permitidos son 0-7.

// The octal number should be prefix with 0.
int x = 0146; 

• Literales hexadecimales (Base 16): en esta forma, los dígitos permitidos son 0-9 y los caracteres son af. Podemos utilizar tanto caracteres en mayúsculas como en minúsculas. Como sabemos, c# es un lenguaje de programación que distingue entre mayúsculas y minúsculas, pero aquí c# no distingue entre mayúsculas y minúsculas.

// The hexa-decimal number should be prefix
// with 0X or 0x.
int x = 0X123Face; 

• Literales binarios (Base 2): En esta forma, los dígitos permitidos son solo 1 y 0 .

// The binary number should be prefix with 0b.
int x = 0b101

Ejemplos: 

07778    // invalid: 8 is not an octal digit 
045uu    // invalid: suffix (u) is repeated
0b105    // invalid: 5 is not a binary digit
0b101    // valid binary literal
456      // valid decimal literal
02453    // valid octal literal 
0x65d    // valid hexadecimal literal 
12356    // valid int literal 
304U     // valid unsigned int literal 
3078L    // valid long literal 
965UL    // valid unsigned long literal 

Programa:

// C# program to illustrate the use of Integer Literals
using System;
 
class Geeks{
 
    // Main method
    public static void Main(String[] args)
    {
       
        // decimal-form literal
        int a = 101;
 
        // octal-form literal
        int b = 0145;
 
        // Hexa-decimal form literal
        int c = 0xFace;
       
        // binary-form literal
        int x = 0b101;
         
        Console.WriteLine(a);
        Console.WriteLine(b);
        Console.WriteLine(c);
        Console.WriteLine(x);
    }
}

101
145
64206
5

Literales de punto flotante: el literal que tiene una parte entera, un punto decimal, una parte fraccionaria y una parte exponencial se conoce como literal de punto flotante. Estos se pueden representar en forma decimal o exponencial.

Ejemplos:  

Double d = 3.14145       // Valid
Double d = 312569E-5      // Valid
Double d = 125E             // invalid: Incomplete exponent 
Double d = 784f            // valid
Double d = .e45           // invalid: missing integer or fraction

Programa:

// C# program to illustrate the use of
// floating-point literals
using System;
 
class Geeks {
 
    // Main Method
    public static void Main(String[] args)
    {
        // decimal-form literal
        double a = 101.230;
 
        // It also acts as decimal literal
        double b = 0123.222;
 
        Console.WriteLine(a);
        Console.WriteLine(b);
    }
}

Producción: 

101.23
123.222

Nota: De forma predeterminada, cada literal de coma flotante es de tipo doble y, por lo tanto, no podemos asignar directamente a la variable flotante. Pero podemos especificar el literal de punto flotante como tipo flotante con el sufijo f o F. Podemos especificar explícitamente el literal de punto flotante como el tipo doble con el sufijo d o D, por supuesto, esta convención no es necesaria.

Literales de caracteres: para los tipos de datos de caracteres, podemos especificar literales de 3 formas: 

• Comilla simple: podemos especificar el tipo de datos de literal a char como un solo carácter dentro de una comilla simple.

char ch = 'a';

• Representación Unicode: Podemos especificar caracteres literales en la representación Unicode ‘\uxxxx’. Aquí xxxx representa 4 números hexadecimales.

char ch = '\u0061';// Here /u0061 represent a.

• Secuencia de escape: cada carácter de escape se puede especificar como caracteres literales.

char ch = '\n';

Ejemplo : 

// C# program to illustrate the use of char literals
using System;
 
class Geeks {
 
    // Main Method
    public static void Main(String[] args)
    {
 
        // character literal within single quote
        char ch = 'a';
 
        // Unicode representation
        char c = '\u0061';
 
        Console.WriteLine(ch);
        Console.WriteLine(c);
 
        // Escape character literal
        Console.WriteLine("Hello\n\nGeeks\t!");
    }
}

a
a
Hello

Geeks    !

Literales de string: los literales que están entre comillas dobles («») o comienzan con @»» se conocen como literales de string. 

Ejemplos:  

String s1 = "Hello Geeks!";

String s2 = @"Hello Geeks!";

Programa: 

// C#  program to illustrate the use of String literals
using System;
 
class Geeks {
 
    // Main Method
    public static void Main(String[] args)
    {
 
        String s = "Hello Geeks!";
        String s2 = @"Hello Geeks!";
 
        // If we assign without "" then it
        // treats as a variable
        // and causes compiler error
        // String s1 = Geeks;
 
        Console.WriteLine(s);
        Console.WriteLine(s2);
    }
}

Producción: 

Hello Geeks!
Hello Geeks!

Literales booleanos: solo se permiten dos valores para los literales booleanos, es decir, verdadero y falso.

Ejemplo: 

bool b = true;
bool c = false;

Programa: 

// C# program to illustrate the use
// of boolean literals
using System;
 
class Geeks {
 
    // Main Method
    public static void Main(String[] args)
    {
        bool b = true;
        bool c = false;
 
        // these will give compile time error
        // bool d = 0;
        // bool e = 1;
        // Console.WriteLine(d);
        // Console.WriteLine(e);
 
        Console.WriteLine(b);
        Console.WriteLine(c);
    }
}

Producción: 

True
False