Un tipo entero es un tipo de valor que representa un número completo, sin parte fraccionaria. Puede ser positivo, negativo o cero.
Los enteros son parte de los tipos de datos primitivos o básicos en C# y se utilizan para almacenar valores numéricos que no requieren precisión decimal.
Los tipos enteros en C# son Tipos de Valor (Value Types). Esto significa que se almacenan directamente en la Pila (Stack), lo que los hace muy rápidos y eficientes.
Tipos de enteros en C#
C# nos ofrece diferentes tamaños de enteros. Ademas existen versión con signo y sin signo.
- Los enteros con signo pueden representar tanto números positivos como negativos.
- Los enteros sin signo pueden representar solo números positivos.
Aquí tenéis la “familia completa” de los tipos enteros en C#:
| Palabra clave C# | Tipo .NET (System) | Tamaño | Con Signo? | Rango Aproximado |
|---|---|---|---|---|
sbyte | SByte | 8 bits | Sí | -128 a 127 |
byte | Byte | 8 bits | No | 0 a 255 |
short | Int16 | 16 bits | Sí | -32,768 a 32,767 |
ushort | UInt16 | 16 bits | No | 0 a 65,535 |
int | Int32 | 32 bits | Sí | -2 mil millones a 2 mil millones |
uint | UInt32 | 32 bits | No | 0 a 4 mil millones |
long | Int64 | 64 bits | Sí | Muy grande (±9 trillones) |
ulong | UInt64 | 64 bits | No | Absurdamente grande |
También existen nint y nuint (Native Integers), que dependen de la arquitectura del procesador (32 o 64 bits), pero eso es para temas avanzados de interop y punteros.
Con tantas opciones (short, int, long), ¿cuál elijo?
- Por defecto, usa
int: Los procesadores están optimizados para trabajar con bloques de 32 bits. Aunque guardes un número pequeño (ej. 5) en unlongo unshort, a veces es más lento que usarint. - Usa
longsi crees que el número puede superar los 2 mil millones (IDs de bases de datos, contadores globales, timestamps). - Usa
bytesolo si estás trabajando con arrays de datos binarios (archivos, imágenes, streams). - Evita los
unsigned(uint,ulong) para aritmética general. Las restas pueden dar resultados extraños si el resultado debiera ser negativo y da la vuelta al valor máximo.
Declaración e inicialización
Para declarar un entero usamos la palabra clave del tipo seguida del nombre de la variable.
int edad = 35;
long distanciaEstrellas = 9000000000000L;
Fijaos en esa L al final del número long. Eso es un sufijo literal.
Cuando escribimos un número “a pelo” en el código (como el 35), C# asume por defecto que es un int. Si el número es demasiado grande para un int, necesitamos decirle explícitamente “oye, esto es un long” usando el sufijo L.
Operaciones aritméticas
Los enteros en C# admiten una variedad de operaciones matemáticas, incluyendo suma, resta, multiplicación, división y módulo.
A continuación, se muestran ejemplos de estas operaciones:
int a = 10;
int b = 3;
int suma = a + b; // 13
int resta = a - b; // 7
int multiplicacion = a * b; // 30
int division = a / b; // 3 (división entera)
int modulo = a % b; // 1 (resto de la división)
Tener en cuenta que la división entre dos enteros en C# es una división entera, lo que significa que el resultado se trunca y no se incluye la parte decimal. Por ejemplo, 10 / 3 da como resultado 3, no 3.333....
Si necesitas decimales, al menos uno de los operandos debe ser un tipo de punto flotante (float, double o decimal).
Límites de los enteros
Cada tipo de entero en C# tiene un rango de valores específico. Si intentamos asignar un valor fuera de este rango, se producirá un error de compilación o un comportamiento inesperado en tiempo de ejecución.
El desbordamiento ocurre cuando intentamos almacenar un valor que excede el rango máximo permitido para un tipo de entero. Por ejemplo:
int maxInt = int.MaxValue; // 2,147,483,647
int overflow = maxInt + 1; // Esto causará un desbordamiento
En este caso, maxInt + 1 excede el valor máximo que puede almacenar un int, lo que resulta en un comportamiento indefinido.
En C#, por defecto, las operaciones aritméticas no comprueban el desbordamiento para ganar rendimiento. Los bits simplemente “dan la vuelta” (wrap around).
Para manejar el desbordamiento de manera segura, podemos utilizar la palabra clave checked:
checked
{
int maxInt = int.MaxValue;
int overflow = maxInt + 1; // Esto lanzará una excepción OverflowException
}
El subdesbordamiento ocurre cuando intentamos almacenar un valor que es menor que el rango mínimo permitido para un tipo de entero. Por ejemplo:
int minInt = int.MinValue; // -2,147,483,648
int underflow = minInt - 1; // Esto causará un subdesbordamiento
Al igual que con el desbordamiento, el subdesbordamiento puede manejarse utilizando la palabra clave checked.
Si estáis haciendo cálculos críticos (dinero, control de reactores nucleares, etc) y queréis que el programa avise si hay desbordamiento, podéis usar un bloque checked.
Ejemplos prácticos
Suma de dos números enteros
Este ejemplo muestra cómo sumar dos números enteros ingresados por el usuario:
Console.Write("Ingrese el primer número: ");
int num1 = int.Parse(Console.ReadLine());
Console.Write("Ingrese el segundo número: ");
int num2 = int.Parse(Console.ReadLine());
int suma = num1 + num2;
Console.WriteLine($"La suma es: {suma}");
Verificación de límites
Este ejemplo muestra cómo verificar si un número está dentro del rango permitido para un int:
int min = int.MinValue;
int max = int.MaxValue;
Console.Write("Ingrese un número: ");
int num = int.Parse(Console.ReadLine());
if (num >= min && num <= max)
{
Console.WriteLine("El número está dentro del rango permitido.");
}
else
{
Console.WriteLine("El número está fuera del rango permitido.");
}
Uso de checked para manejar desbordamientos
Este ejemplo muestra cómo utilizar checked para detectar desbordamientos:
checked
{
int maxInt = int.MaxValue;
try
{
int overflow = maxInt + 1;
}
catch (OverflowException)
{
Console.WriteLine("Se produjo un desbordamiento.");
}
}
