Variables de C # y tipos de datos (primitivos)

En este tutorial, aprenderemos sobre las variables, cómo crear variables en C # y los diferentes tipos de datos que admite el lenguaje de programación C #.

Una variable es un nombre simbólico que se le da a una ubicación de memoria. Las variables se utilizan para almacenar datos en un programa de computadora.

¿Cómo declarar variables en C #?

Aquí hay un ejemplo para declarar una variable en C #.

 int age;

En este ejemplo, intse declara una edad de variable de tipo (entero) y solo puede almacenar valores enteros.

Podemos asignar un valor a la variable más adelante en nuestro programa como tal:

 int edad;……… edad = 24;

Sin embargo, la variable también se puede inicializar a algún valor durante la declaración. Por ejemplo,

 int edad = 24;

Aquí, una edad variable de tipo intse declara y se inicializa al 24mismo tiempo.

Dado que es una variable, también podemos cambiar el valor de las variables. Por ejemplo,

int edad = 24; edad = 35;

Aquí, el valor de la edad se cambia de 24 a 35.

Las variables en C # deben declararse antes de que puedan usarse. Esto significa que se debe conocer el nombre y el tipo de variable antes de poder asignar un valor. Es por eso que C # se denomina lenguaje de tipado estático.

Una vez declarado, el tipo de datos de una variable no se puede cambiar dentro de un ámbito. Un alcance se puede pensar como un bloque de código donde la variable está visible o disponible para su uso. Si no comprende la declaración anterior, no se preocupe, aprenderemos sobre los alcances en los capítulos posteriores.

Por ahora recuerde, no podemos hacer lo siguiente en C #:

int age; edad = 24;……… edad flotante;

Variables escritas implícitamente

Alternativamente, en C #, podemos declarar una variable sin conocer su tipo usando una varpalabra clave. Estas variables se denominan variables locales tipadas implícitamente .

Las variables declaradas mediante la varpalabra clave deben inicializarse en el momento de la declaración.

 valor de var = 5;

El compilador determina el tipo de variable a partir del valor que se asigna a la variable. En el ejemplo anterior, el valor es de tipo int. Esto es equivalente a:

valor int; valor = 5;

Puede obtener más información sobre las variables locales tipadas implícitamente.

Reglas para nombrar variables en C #

Hay ciertas reglas que debemos seguir al nombrar una variable. Las reglas para nombrar una variable en C # son:

  1. El nombre de la variable puede contener letras (mayúsculas y minúsculas), subrayado (_) y solo dígitos.
  2. El nombre de la variable debe comenzar con una letra, un guión bajo o un símbolo @. Por ejemplo, reglas para nombrar variables en C #
    Nombres de variables Observaciones
    nombre Válido
    sujeto101 Válido
    _años Válido (mejor práctica para nombrar variables de miembros privados)
    @descanso Válido (se usa si el nombre es una palabra clave reservada)
    101 sujeto No válido (comienza con un dígito)
    tu nombre Válido
    tu nombre No válido (contiene espacios en blanco)
  3. C # distingue entre mayúsculas y minúsculas. Significa edad y Edad se refiere a 2 variables diferentes.
  4. El nombre de una variable no debe ser una palabra clave de C #. Por ejemplo, if, for, usingno puede ser un nombre de variable. Discutiremos más sobre las palabras clave de C # en el próximo tutorial.

Mejores prácticas para nombrar una variable

  1. Elija un nombre de variable que tenga sentido. Por ejemplo, nombre, edad, tema tiene más sentido que n, ay s.
  2. Utilice la notación camelCase (comienza con una letra minúscula) para nombrar las variables locales. Por ejemplo, numberOfStudents, age, etc.
  3. Utilice PascalCase o CamelCase (comienza con una letra mayúscula) para nombrar las variables de miembros públicos. Por ejemplo, Nombre, Precio, etc.
  4. Utilice un guión bajo (_) seguido de la notación camelCase para nombrar las variables de miembros privados. Por ejemplo, _bankBalance, _emailAddress, etc.

Puede obtener más información sobre las convenciones de nomenclatura en C # aquí.

No se preocupe por las variables de miembros públicos y privados. Aprenderemos sobre ellos en capítulos posteriores.

Tipos de datos primitivos de C #

Las variables en C # se clasifican ampliamente en dos tipos: tipos de valor y tipos de referencia . En este tutorial discutiremos sobre tipos de datos primitivos (simples), que es una subclase de tipos de valor.

Los tipos de referencia se tratarán en tutoriales posteriores. Sin embargo, si desea obtener más información sobre los tipos de variables, visite Tipos y variables de C # (documentos oficiales de C #).

Booleano (bool)

  • El tipo de datos booleano tiene dos valores posibles: trueofalse
  • Valor predeterminado :false
  • Las variables booleanas se utilizan generalmente para comprobar condiciones como sentencias if, bucles, etc.

Por ejemplo:

 using System; namespace DataType ( class BooleanExample ( public static void Main(string() args) ( bool isValid = true; Console.WriteLine(isValid); ) ) )

Cuando ejecutamos el programa, la salida será:

 Cierto

Integral firmado

Estos tipos de datos contienen valores enteros (tanto positivos como negativos). Del total de bits disponibles, un bit se utiliza como signo.

1. sbyte

  • Tamaño : 8 bits
  • Rango : -128 a 127.
  • Valor predeterminado : 0

Por ejemplo:

 using System; namespace DataType ( class SByteExample ( public static void Main(string() args) ( sbyte level = 23; Console.WriteLine(level); ) ) )

Cuando ejecutamos el programa, la salida será:

 23

Intente asignar valores fuera de rango, es decir, menores que -128 o mayores que 127 y vea qué sucede.

2. corto

  • Tamaño : 16 bits
  • Rango : -32,768 a 32,767
  • Valor predeterminado : 0

Por ejemplo:

 using System; namespace DataType ( class ShortExample ( public static void Main(string() args) ( short value = -1109; Console.WriteLine(value); ) ) )

Cuando ejecutamos el programa, la salida será:

 -1109

3. int

  • Tamaño : 32 bits
  • Rango : -231 a 231-1
  • Valor predeterminado : 0

Por ejemplo:

 using System; namespace DataType ( class IntExample ( public static void Main(string() args) ( int score = 51092; Console.WriteLine(score); ) ) )

Cuando ejecutamos el programa, la salida será:

 51092

4. largo

  • Tamaño : 64 bits
  • Rango : -263 a 263-1
  • Valor predeterminado : 0L(L al final representa que el valor es de tipo largo)

Por ejemplo:

 using System; namespace DataType ( class LongExample ( public static void Main(string() args) ( long range = -7091821871L; Console.WriteLine(range); ) ) )

Cuando ejecutamos el programa, la salida será:

 -7091821871

Integral sin firmar

Estos tipos de datos solo contienen valores iguales o mayores que 0. Generalmente usamos estos tipos de datos para almacenar valores cuando estamos seguros de que no tendremos valores negativos.

1. byte

  • Tamaño : 8 bits
  • Range: 0 to 255.
  • Default value: 0

For example:

 using System; namespace DataType ( class ByteExample ( public static void Main(string() args) ( byte age = 62; Console.WriteLine(level); ) ) )

When we run the program, the output will be:

 62

2. ushort

  • Size: 16 bits
  • Range: 0 to 65,535
  • Default value: 0

For example:

 using System; namespace DataType ( class UShortExample ( public static void Main(string() args) ( ushort value = 42019; Console.WriteLine(value); ) ) )

When we run the program, the output will be:

 42019

3. uint

  • Size: 32 bits
  • Range: 0 to 232-1
  • Default value: 0

For example:

 using System; namespace DataType ( class UIntExample ( public static void Main(string() args) ( uint totalScore = 1151092; Console.WriteLine(totalScore); ) ) )

When we run the program, the output will be:

 1151092

4. ulong

  • Size: 64 bits
  • Range: 0 to 264-1
  • Default value: 0

For example:

 using System; namespace DataType ( class ULongExample ( public static void Main(string() args) ( ulong range = 17091821871L; Console.WriteLine(range); ) ) )

When we run the program, the output will be:

 17091821871

Floating Point

These data types hold floating point values i.e. numbers containing decimal values. For example, 12.36, -92.17, etc.

1. float

  • Single-precision floating point type
  • Size: 32 bits
  • Range: 1.5 × 10−45 to 3.4 × 1038
  • Default value: 0.0F (F at the end represent the value is of float type)

For example:

 using System; namespace DataType ( class FloatExample ( public static void Main(string() args) ( float number = 43.27F; Console.WriteLine(number); ) ) )

When we run the program, the output will be:

 43.27

2. double

  • Double-precision floating point type. What is the difference between single and double precision floating point?
  • Size: 64 bits
  • Range: 5.0 × 10−324 to 1.7 × 10308
  • Default value: 0.0D (D at the end represent the value is of double type)

For example:

 using System; namespace DataType ( class DoubleExample ( public static void Main(string() args) ( double value = -11092.53D; Console.WriteLine(value); ) ) )

When we run the program, the output will be:

 -11092.53

Character (char)

  • It represents a 16 bit unicode character.
  • Size: 16 bits
  • Default value: ''
  • Range: U+0000 ('u0000') to U+FFFF ('uffff')

For example: 

 using System; namespace DataType ( class CharExample ( public static void Main(string() args) ( char ch1 ='u0042'; char ch2 = 'x'; Console.WriteLine(ch1); Console.WriteLine(ch2); ) ) )

When we run the program, the output will be:

 B x

The unicode value of 'B' is 'u0042', hence printing ch1 will print 'B'.

Decimal

  • Decimal type has more precision and a smaller range as compared to floating point types (double and float). So it is appropriate for monetary calculations.
  • Size: 128 bits
  • Default value: 0.0M (M at the end represent the value is of decimal type)
  • Range: (-7.9 x 1028 to 7.9 x 1028) / (100 to 28)

For example: 

 using System; namespace DataType ( class DecimalExample ( public static void Main(string() args) ( decimal bankBalance = 53005.25M; Console.WriteLine(bankBalance); ) ) )

When we run the program, the output will be:

 53005.25

The suffix M or m must be added at the end otherwise the value will be treated as a double and an error will be generated.

C# Literals

Let's look at the following statement:

 int number = 41;

Here,

  • int is a data type
  • number is a variable and
  • 41 is a literal

Literals are fixed values that appear in the program. They do not require any computation. For example, 5, false, 'w' are literals that appear in a program directly without any computation.

Boolean Literals

  • true and false are the available boolean literals.
  • They are used to initialize boolean variables.

For example:

 bool isValid = true; bool isPresent = false;

Integer Literals

  • Integer literals are used to initialize variables of integer data types i.e. sbyte, short, int, long, byte, ushort, uint and ulong.
  • If an integer literal ends with L or l, it is of type long. For best practice use L (not l). 
     long value1 = 4200910L; long value2 = -10928190L;
  • If an integer literal starts with a 0x, it represents hexadecimal value. Number with no prefixes are treated as decimal value. Octal and binary representation are not allowed in C#. 
     int decimalValue = 25; int hexValue = 0x11c;// decimal value 284

Floating Point Literals

  • Floating point literals are used to initialize variables of float and double data types.
  • If a floating point literal ends with a suffix f or F, it is of type float. Similarly, if it ends with d or D, it is of type double. If neither of the suffix is present, it is of type double by default.
  • These literals contains e or E when expressed in scientific notation. 
     double number = 24.67;// double by default float value = -12.29F; double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

Character and String Literals

  • Character literals are used to initialize variables of char data types.
  • Character literals are enclosed in single quotes. For example, 'x', 'p', etc.
  • They can be represented as character, hexadecimal escape sequence, unicode representation or integral values casted to char. 
     char ch1 = 'R'; // carácter char ch2 = ' x0072'; // hexadecimal char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // emitido desde un entero
  • Los literales de cadena son la colección de literales de caracteres.
  • Están entre comillas dobles. Por ejemplo, "Hola", "Programación fácil", etc. 
    string firstName = "Richard"; string lastName = "Feynman";
  • C # también admite caracteres de secuencia de escape como:
    Personaje Sentido
    \' Una frase
    " Cotización doble
    \ Barra invertida
    Nueva línea
    Retorno de carro
    Ficha horizontal
    a Alerta
     Retroceso

Articulos interesantes...