C #: constantes y literales

Las constantes se refieren a valores fijos que el programa no puede alterar durante su ejecución. Estos valores fijos también se denominan literales. Las constantes pueden ser de cualquiera de los tipos de datos básicos, como una constante entera, una constante flotante, una constante de carácter o una cadena literal. También hay constantes de enumeración.

Las constantes se tratan como variables regulares, excepto que sus valores no se pueden modificar después de su definición.

Literales enteros

Un literal entero puede ser una constante decimal o hexadecimal. Un prefijo especifica la base o la raíz: 0x o 0X para hexadecimal, y no hay ID de prefijo para decimal.

Un literal entero también puede tener un sufijo que sea una combinación de U y L, para unsigned y long, respectivamente. El sufijo puede estar en mayúsculas o minúsculas y puede estar en cualquier orden.

Aquí hay algunos ejemplos de literales enteros:

212         /* Legal */
215u        /* Legal */
0xFeeL      /* Legal */

A continuación se muestran otros ejemplos de varios tipos de literales enteros:

85         /* decimal */
0x4b       /* hexadecimal */
30         /* int */
30u        /* unsigned int */
30l        /* long */
30ul       /* unsigned long */

Literales de coma flotante

Un literal de coma flotante tiene una parte entera, una coma decimal, una parte fraccionaria y una parte exponente. Puede representar literales de coma flotante en forma decimal o exponencial.

Aquí hay algunos ejemplos de literales de punto flotante:

3.14159       /* Legal */
314159E-5F    /* Legal */
510E          /* Illegal: incomplete exponent */
210f          /* Illegal: no decimal or exponent */
.e55          /* Illegal: missing integer or fraction */

Mientras representa en forma decimal, debe incluir el punto decimal, el exponente o ambos; y mientras representa en forma exponencial, debe incluir la parte entera, la parte fraccionaria o ambas. El exponente con signo se introduce mediante e o E.

Constantes de carácter

Los literales de caracteres se incluyen entre comillas simples. Por ejemplo, 'x' y se pueden almacenar en una variable simple de tipo char. Un literal de carácter puede ser un carácter simple (como 'x'), una secuencia de escape (como '\ t') o un carácter universal (como '\ u02C0').

Hay ciertos caracteres en C # cuando están precedidos por una barra invertida. Tienen un significado especial y se utilizan para representar como nueva línea (\ n) o tabulación (\ t). Aquí hay una lista de algunos de estos códigos de secuencia de escape:

Secuencia de escape	Sentido
\\	\ personaje
\ '	' personaje
\ "	" personaje
\?	? personaje
\un	Alerta o campana
\segundo	Retroceso
\F	Alimentación de formulario
\norte	Nueva línea
\ r	Retorno de carro
\ t	Pestaña horizontal
\ v	Pestaña vertical
\ xhh. . .	Número hexadecimal de uno o más dígitos

A continuación se muestra el ejemplo para mostrar algunos caracteres de secuencia de escape:

using System;

namespace EscapeChar {
   class Program {
      static void Main(string[] args) {
         Console.WriteLine("Hello\tWorld\n\n");
         Console.ReadLine();
      }
   }
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Hello   World

Literales de cadena

Los literales o constantes de cadena se encierran entre comillas dobles "" o con @ "". Una cadena contiene caracteres que son similares a los literales de caracteres: caracteres simples, secuencias de escape y caracteres universales.

Puede dividir una línea larga en varias líneas usando cadenas literales y separando las partes usando espacios en blanco.

A continuación, se muestran algunos ejemplos de cadenas literales. Las tres formas son cadenas idénticas.

"hello, dear"
"hello, \
dear"
"hello, " "d" "ear"
@"hello dear"

Definición de constantes

Las constantes se definen utilizando el constpalabra clave. La sintaxis para definir una constante es -

const <data_type> <constant_name> = value;

El siguiente programa demuestra la definición y el uso de una constante en su programa:

using System;

namespace DeclaringConstants {
   class Program {
      static void Main(string[] args) {
         const double pi = 3.14159;   
            
         // constant declaration 
         double r;
         Console.WriteLine("Enter Radius: ");
         r = Convert.ToDouble(Console.ReadLine());
            
         double areaCircle = pi * r * r;
         Console.WriteLine("Radius: {0}, Area: {1}", r, areaCircle);
         Console.ReadLine();
      }
   }
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

Enter Radius: 
3
Radius: 3, Area: 28.27431