Variables y tipos de datos básicos

Introducción

Las variables son uno de los conceptos fundamentales en cualquier lenguaje de programación, incluido C#. Podemos imaginarlas como "cajas" etiquetadas donde almacenamos información que necesitamos utilizar en nuestro programa. Cada variable tiene un nombre que utilizamos para referirnos a ella, un tipo que determina qué clase de datos puede contener, y un valor que es la información almacenada en un momento determinado. En este artículo, exploraremos cómo declarar y utilizar variables en C#, así como los tipos de datos básicos que ofrece el lenguaje para representar diferentes clases de información.

¿Qué son las variables?

Una variable es un espacio en la memoria del ordenador que tiene:

Un nombre (identificador) que utilizamos para referirnos a ella
Un tipo de dato que define qué clase de información puede almacenar
Un valor actual (el dato que contiene)

Cuando declaramos una variable, estamos reservando un espacio en la memoria y asignándole un nombre. Cuando le asignamos un valor, estamos guardando información en ese espacio.

Declaración de variables

En C#, para declarar una variable debemos especificar su tipo y su nombre:

tipo nombreVariable;

Por ejemplo, para declarar una variable que almacenará un número entero:

int edad;

También podemos asignar un valor inicial en el momento de la declaración:

int edad = 25;

Es posible declarar varias variables del mismo tipo en una sola línea:

int x, y, z;

O incluso inicializarlas a la vez:

int a = 5, b = 10, c = 15;

Reglas para nombrar variables

En C#, los nombres de variables deben seguir estas reglas:

Deben comenzar con una letra o un guion bajo (_)
Pueden contener letras, dígitos y guiones bajos
No pueden ser palabras reservadas del lenguaje (como if, class, int, etc.)
Son sensibles a mayúsculas/minúsculas (edad y Edad serían variables diferentes)

Además, existen convenciones de estilo que, aunque no son obligatorias, se recomiendan seguir:

Usar camelCase para variables locales y parámetros (primera letra minúscula, resto de palabras con primera letra mayúscula): nombreCompleto, edadUsuario
Usar nombres descriptivos que indiquen el propósito de la variable: contador en lugar de c

// Nombres válidos
int edad;
string nombreCompleto;
double _valorPi;
bool esValido123;

// Nombres no válidos
int 1numero;        // No puede comenzar con un número
string nombre-completo;  // No puede contener guiones
int class;          // No puede ser una palabra reservada

Tipos de datos básicos en C#

C# es un lenguaje de tipado estático, lo que significa que cada variable debe tener un tipo definido que no cambia. Los tipos de datos básicos se dividen en varias categorías:

Tipos numéricos enteros

Utilizados para números sin parte decimal:

Tipo	Tamaño	Rango	Uso común
`byte`	8 bits	0 a 255	Valores pequeños sin signo
`sbyte`	8 bits	-128 a 127	Valores pequeños con signo
`short`	16 bits	-32,768 a 32,767	Enteros pequeños
`ushort`	16 bits	0 a 65,535	Enteros pequeños sin signo
`int`	32 bits	-2,147,483,648 a 2,147,483,647	Uso general
`uint`	32 bits	0 a 4,294,967,295	Enteros grandes sin signo
`long`	64 bits	-9,223,372,036,854,775,808 a 9,223,372,036,854,775,807	Enteros muy grandes
`ulong`	64 bits	0 a 18,446,744,073,709,551,615	Enteros muy grandes sin signo

Ejemplos de uso:

byte edad = 25;
int poblacion = 47350000;  // Población aproximada de España
long distanciaEnKm = 149600000;  // Distancia aproximada de la Tierra al Sol en km

Tipos numéricos de punto flotante

Utilizados para números con parte decimal:

Tipo	Tamaño	Precisión	Uso común
`float`	32 bits	~7 dígitos	Precisión simple
`double`	64 bits	~15-16 dígitos	Precisión doble (uso general)
`decimal`	128 bits	28-29 dígitos decimales	Cálculos financieros

Ejemplos de uso:

float alturaEnMetros = 1.75f;  // Nota: se debe añadir 'f' al final
double pi = 3.14159265359;
decimal precioProducto = 19.99m;  // Nota: se debe añadir 'm' al final

Nota: En los literales de tipo float debemos añadir f al final, y en los de tipo decimal debemos añadir m. Si no lo hacemos, C# interpretará el número como double por defecto.

Tipo booleano

Representa valores lógicos verdadero/falso:

Tipo	Valores posibles
`bool`	`true` o `false`

Ejemplo:

bool esMayorDeEdad = true;
bool tieneLicencia = false;

Tipo carácter

Representa un único carácter Unicode:

Tipo	Descripción
`char`	Un carácter Unicode (16 bits)

Ejemplo:

char primeraLetra = 'A';
char simboloEuro = '€';

Nota: Los caracteres se delimitan con comillas simples ('), a diferencia de las cadenas de texto que usan comillas dobles (").

Tipo cadena

Representa una secuencia de caracteres:

Tipo	Descripción
`string`	Secuencia de caracteres

Ejemplo:

string nombre = "Ana";
string direccion = "Calle Mayor, 10";

Tipo objeto

El tipo object es la base de todos los tipos en C#:

object cualquierValor = 42;  // Puede almacenar cualquier tipo

Asignación de valores a variables

Una vez declarada una variable, podemos asignarle un valor utilizando el operador de asignación (=):

int edad;  // Declaración
edad = 30;  // Asignación

string nombre = "Carlos";  // Declaración y asignación
nombre = "David";  // Reasignación (cambio de valor)

Variables con var (inferencia de tipos)

C# permite declarar variables utilizando la palabra clave var. En este caso, el compilador infiere el tipo automáticamente a partir del valor asignado:

var edad = 25;  // El compilador infiere que es de tipo int
var nombre = "Laura";  // El compilador infiere que es de tipo string
var pi = 3.14159;  // El compilador infiere que es de tipo double

Es importante entender que:

var no significa que la variable sea de "tipo variable" o que pueda cambiar de tipo.
El tipo se determina en tiempo de compilación y no puede cambiar.
Es necesario asignar un valor inicial para que el compilador pueda inferir el tipo.

Literales de datos

Los literales son representaciones fijas de valores en el código:

// Literales enteros
int decimal = 42;
int hexadecimal = 0x2A;  // Prefijo 0x para hexadecimal
int binario = 0b101010;  // Prefijo 0b para binario

// Literales de punto flotante
double d1 = 0.42;
double d2 = 4.2e-1;  // Notación científica (4.2 × 10^-1)

// Literales de caracteres
char c1 = 'A';
char c2 = '\n';  // Carácter de nueva línea
char c3 = '\u0041';  // Representación Unicode de 'A'

// Literales de cadenas
string s1 = "Hola mundo";
string s2 = @"C:\archivos\nuevo";  // Cadena textual (no interpreta secuencias de escape)
string s3 = $"Hola, {nombre}";  // Cadena interpolada (sustituye variables)

Constantes

Si necesitamos un valor que no cambie durante la ejecución del programa, podemos usar constantes:

const double PI = 3.14159265359;
const int DIAS_SEMANA = 7;
const string MENSAJE_BIENVENIDA = "Bienvenido a mi aplicación";

Las constantes:

Deben inicializarse en el momento de la declaración
No pueden modificarse posteriormente
Generalmente se nombran en MAYÚSCULAS (por convención)

Ejemplo práctico: trabajando con variables

Veamos un ejemplo completo que utiliza diversos tipos de variables:

using System;

namespace VariablesYTipos
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaración e inicialización de variables
            string nombreProducto = "Portátil";
            int cantidadDisponible = 10;
            decimal precioUnitario = 899.99m;
            bool disponibleEnTienda = true;
            
            // Cálculos con variables
            decimal valorTotal = cantidadDisponible * precioUnitario;
            int cantidadRestante = cantidadDisponible - 2;
            
            // Uso de constantes
            const double IVA = 0.21;
            decimal precioConIVA = precioUnitario * (decimal)(1 + IVA);
            
            // Mostrar información
            Console.WriteLine("Información del producto:");
            Console.WriteLine($"Nombre: {nombreProducto}");
            Console.WriteLine($"Precio unitario: {precioUnitario:C}");
            Console.WriteLine($"Precio con IVA: {precioConIVA:C}");
            Console.WriteLine($"Disponible en tienda: {disponibleEnTienda}");
            Console.WriteLine($"Cantidad disponible: {cantidadDisponible} unidades");
            Console.WriteLine($"Valor total del inventario: {valorTotal:C}");
            
            // Inferencia de tipos con var
            var mensaje = "Gracias por consultar nuestro inventario";
            var fechaActual = DateTime.Now;
            
            Console.WriteLine(mensaje);
            Console.WriteLine($"Fecha actual: {fechaActual:dd/MM/yyyy}");
            
            // Esperar a que el usuario presione una tecla
            Console.ReadKey();
        }
    }
}

Conversión entre tipos de datos

En C# existen dos tipos principales de conversiones entre tipos:

Conversiones implícitas (seguras)

Ocurren automáticamente cuando se pasa de un tipo "menor" a uno "mayor" (sin pérdida de datos):

int entero = 42;
long numeroLargo = entero;  // Conversión implícita de int a long

float numeroFloat = 3.14f;
double numeroDouble = numeroFloat;  // Conversión implícita de float a double

Conversiones explícitas (casting)

Necesarias cuando puede haber pérdida de datos:

double pi = 3.14159;
int piAproximado = (int)pi;  // Conversión explícita de double a int (piAproximado = 3)

long numeroGrande = 1234567890;
int numeroNormal = (int)numeroGrande;  // Cuidado: puede haber pérdida de datos

Valores por defecto

Cada tipo de datos tiene un valor por defecto:

Tipo	Valor por defecto
Tipos numéricos	`0` (o `0.0`)
`bool`	`false`
`char`	`'\0'` (null char)
`string`	`null`
Tipos objeto	`null`

Podemos inicializar explícitamente una variable a su valor por defecto:

int contador = default(int);  // contador = 0
bool finalizado = default;  // finalizado = false

Resumen

En este artículo hemos explorado los conceptos fundamentales de variables y tipos de datos en C#. Hemos aprendido que las variables son espacios nombrados en memoria que almacenan valores de un tipo específico. Conocimos los tipos de datos básicos como enteros, decimales, booleanos, caracteres y cadenas, así como cómo declararlos, inicializarlos y utilizarlos en nuestros programas.

La correcta elección y uso de variables y tipos de datos es esencial para crear programas eficientes y precisos. A medida que avances en tu aprendizaje de C#, estos conceptos seguirán siendo la base sobre la que construirás estructuras y algoritmos más complejos.