Tutorial CSharp: Operadores

Operadores aritméticos

Los operadores aritméticos en C# permiten realizar cálculos matemáticos básicos sobre valores numéricos. Estos operadores son fundamentales para cualquier tipo de procesamiento de datos que involucre operaciones matemáticas, desde simples sumas hasta cálculos más complejos.

C# proporciona un conjunto completo de operadores aritméticos que funcionan de manera similar a las operaciones matemáticas tradicionales. Estos operadores pueden aplicarse a todos los tipos numéricos del lenguaje, incluyendo enteros y números de punto flotante.

Operadores aritméticos básicos

C# incluye cinco operadores aritméticos principales:

• Suma (+): Añade dos valores.
• Resta (-): Sustrae el segundo valor del primero.
• Multiplicación (*): Multiplica dos valores.
• División (/): Divide el primer valor por el segundo.
• Módulo (%): Devuelve el resto de la división entera.

Veamos ejemplos de cada uno:

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 10/3)

Console.WriteLine($"Suma: {suma}");
Console.WriteLine($"Resta: {resta}");
Console.WriteLine($"Multiplicación: {multiplicacion}");
Console.WriteLine($"División: {division}");
Console.WriteLine($"Módulo: {modulo}");

Comportamiento de la división

Es importante entender que el operador de división se comporta de manera diferente según los tipos de datos que se utilicen:

• Con enteros: Realiza una división entera (trunca el resultado).
• Con punto flotante: Realiza una división con decimales.

int x = 10;
int y = 3;
double z = 3.0;

int divisionEntera = x / y;      // 3 (se trunca el decimal)
double divisionDecimal = x / z;  // 3.3333333333333335

Console.WriteLine($"División entera: {divisionEntera}");
Console.WriteLine($"División decimal: {divisionDecimal}");

Operador de negación unario

Además de los operadores binarios (que operan sobre dos valores), C# también proporciona el operador de negación unario (-) que cambia el signo de un valor:

int positivo = 5;
int negativo = -positivo;  // -5

Console.WriteLine($"Valor original: {positivo}");
Console.WriteLine($"Valor negado: {negativo}");

Precedencia de operadores

Los operadores aritméticos en C# siguen las reglas matemáticas estándar de precedencia:

1. Paréntesis ()
2. Operadores unarios como - (negación)
3. Multiplicación *, división / y módulo %
4. Suma + y resta -

int resultado1 = 2 + 3 * 4;      // 14 (3*4 se evalúa primero)
int resultado2 = (2 + 3) * 4;    // 20 (los paréntesis tienen prioridad)

Console.WriteLine($"2 + 3 * 4 = {resultado1}");
Console.WriteLine($"(2 + 3) * 4 = {resultado2}");

Desbordamiento en operaciones aritméticas

Un aspecto importante a considerar es el desbordamiento (overflow) que puede ocurrir cuando el resultado de una operación aritmética excede el rango del tipo de datos:

int maxValue = int.MaxValue;     // 2,147,483,647
int overflow = maxValue + 1;     // -2,147,483,648 (desbordamiento)

Console.WriteLine($"Valor máximo de int: {maxValue}");
Console.WriteLine($"Valor máximo + 1: {overflow}");

Para controlar este comportamiento, C# proporciona las palabras clave checked y unchecked:

int maxValue = int.MaxValue;

// Esto lanzará una excepción OverflowException
try
{
    checked
    {
        int willOverflow = maxValue + 1;
        Console.WriteLine(willOverflow);  // No se ejecutará
    }
}
catch (OverflowException ex)
{
    Console.WriteLine("Se produjo un desbordamiento: " + ex.Message);
}

// Esto permitirá el desbordamiento (comportamiento predeterminado)
unchecked
{
    int silentOverflow = maxValue + 1;
    Console.WriteLine($"Desbordamiento silencioso: {silentOverflow}");  // -2,147,483,648
}

Operaciones con diferentes tipos numéricos

Cuando realizas operaciones con diferentes tipos numéricos, C# aplica reglas de promoción de tipos:

int entero = 5;
double decimal = 2.5;
double resultado = entero + decimal;  // 7.5 (entero se convierte a double)

Console.WriteLine($"Resultado: {resultado}");

En este caso, el int se convierte implícitamente a double antes de realizar la operación, ya que double tiene mayor precisión.

Operaciones con literales numéricos

También puedes usar operadores aritméticos directamente con literales numéricos:

double resultado = 10.5 + 20.3;  // 30.8
Console.WriteLine($"10.5 + 20.3 = {resultado}");

int hexResult = 0xFF + 0x0A;     // 255 + 10 = 265
Console.WriteLine($"0xFF + 0x0A = {hexResult}");

Los operadores aritméticos son la base para construir expresiones más complejas en C#, y su comprensión es fundamental para realizar cualquier tipo de cálculo en tus programas.

Operadores lógicos

Los operadores lógicos en C# permiten evaluar condiciones complejas combinando expresiones booleanas. Estos operadores son esenciales para implementar la lógica de decisión en cualquier programa, ya que nos permiten crear condiciones más elaboradas que las simples comparaciones individuales.

C# proporciona tres operadores lógicos principales que trabajan con valores booleanos (true o false) y devuelven resultados booleanos.

Operador AND lógico (&&)

El operador && (AND lógico) devuelve true únicamente cuando ambas expresiones que conecta son verdaderas. Si cualquiera de las expresiones es false, el resultado será false.

bool condicion1 = true;
bool condicion2 = false;

bool resultadoAnd = condicion1 && condicion2;  // false

Console.WriteLine($"true && false = {resultadoAnd}");

Una característica importante del operador && es la evaluación de cortocircuito. Esto significa que si la primera expresión es false, la segunda expresión no se evalúa, ya que el resultado final será false independientemente del valor de la segunda expresión.

int x = 10;
bool resultado = (x < 5) && (x++ > 0);  // x++ no se ejecuta

Console.WriteLine($"Resultado: {resultado}");  // false
Console.WriteLine($"Valor de x: {x}");        // 10 (no se incrementó)

Operador OR lógico (||)

El operador || (OR lógico) devuelve true si al menos una de las expresiones que conecta es verdadera. Solo devuelve false cuando ambas expresiones son false.

bool condicion1 = true;
bool condicion2 = false;

bool resultadoOr = condicion1 || condicion2;  // true

Console.WriteLine($"true || false = {resultadoOr}");

Al igual que el operador &&, el operador || también implementa la evaluación de cortocircuito. Si la primera expresión es true, la segunda expresión no se evalúa, ya que el resultado final será true independientemente del valor de la segunda expresión.

int y = 10;
bool resultado = (y > 5) || (y++ < 20);  // y++ no se ejecuta

Console.WriteLine($"Resultado: {resultado}");  // true
Console.WriteLine($"Valor de y: {y}");        // 10 (no se incrementó)

Operador NOT lógico (!)

El operador ! (NOT lógico) es un operador unario que invierte el valor de una expresión booleana. Si la expresión es true, ! la convierte en false, y viceversa.

bool condicion = true;
bool resultadoNot = !condicion;  // false

Console.WriteLine($"!true = {resultadoNot}");

Este operador es útil para negar condiciones o para comprobar si algo no es verdadero:

bool estaActivo = false;
if (!estaActivo)
{
    Console.WriteLine("El sistema está inactivo");
}

Combinando operadores lógicos

Los operadores lógicos pueden combinarse para crear condiciones más complejas. Al hacerlo, es importante entender la precedencia de los operadores:

1. El operador ! (NOT) tiene la mayor precedencia
2. El operador && (AND) tiene precedencia media
3. El operador || (OR) tiene la menor precedencia

bool a = true;
bool b = false;
bool c = true;

bool resultado = a || b && c;    // true (equivale a: a || (b && c))
bool resultado2 = (a || b) && c; // true (los paréntesis alteran la precedencia)

Console.WriteLine($"a || b && c = {resultado}");
Console.WriteLine($"(a || b) && c = {resultado2}");

Operadores lógicos a nivel de bits

Además de los operadores lógicos booleanos, C# proporciona operadores lógicos a nivel de bits que operan sobre los bits individuales de valores enteros:

• & (AND a nivel de bits): Compara cada bit y devuelve 1 si ambos bits son 1
• | (OR a nivel de bits): Compara cada bit y devuelve 1 si al menos uno de los bits es 1
• ^ (XOR a nivel de bits): Compara cada bit y devuelve 1 si los bits son diferentes
• ~ (NOT a nivel de bits): Invierte todos los bits

int binario1 = 0b1100;  // 12 en decimal
int binario2 = 0b1010;  // 10 en decimal

int resultadoAnd = binario1 & binario2;  // 0b1000 (8 en decimal)
int resultadoOr = binario1 | binario2;   // 0b1110 (14 en decimal)
int resultadoXor = binario1 ^ binario2;  // 0b0110 (6 en decimal)
int resultadoNot = ~binario1;            // -13 en decimal (complemento a dos)

Console.WriteLine($"AND a nivel de bits: {resultadoAnd}");
Console.WriteLine($"OR a nivel de bits: {resultadoOr}");
Console.WriteLine($"XOR a nivel de bits: {resultadoXor}");
Console.WriteLine($"NOT a nivel de bits: {resultadoNot}");

Operadores lógicos condicionales (sin cortocircuito)

C# también proporciona versiones de los operadores AND y OR que evalúan ambas expresiones independientemente del resultado de la primera:

• & (AND lógico condicional): Evalúa ambas expresiones y devuelve true solo si ambas son true
• | (OR lógico condicional): Evalúa ambas expresiones y devuelve true si al menos una es true

int m = 5;
int n = 10;

bool resultadoAnd = (m > 10) & (n++ > 5);  // false, pero n se incrementa
bool resultadoOr = (m < 10) | (n++ > 15);  // true, y n se incrementa

Console.WriteLine($"Resultado AND condicional: {resultadoAnd}");
Console.WriteLine($"Resultado OR condicional: {resultadoOr}");
Console.WriteLine($"Valor de n: {n}");  // 12 (se incrementó dos veces)

Uso práctico de operadores lógicos

Los operadores lógicos son fundamentales para implementar la lógica de decisión en programas:

int edad = 25;
bool tieneLicencia = true;

// Verificar si una persona puede conducir
if (edad >= 18 && tieneLicencia)
{
    Console.WriteLine("Puede conducir");
}

// Verificar si una persona necesita atención especial
bool esMenor = edad < 18;
bool esMayor65 = edad > 65;
if (esMenor || esMayor65)
{
    Console.WriteLine("Necesita atención especial");
}

// Verificar si una persona está en edad laboral activa
if (!(esMenor || esMayor65))
{
    Console.WriteLine("Está en edad laboral activa");
}

Los operadores lógicos son herramientas poderosas que permiten crear condiciones complejas para controlar el flujo de ejecución de un programa, facilitando la implementación de reglas de negocio y lógica de decisión en aplicaciones C#.

Comparación y asignación

Los operadores de comparación y asignación son elementos fundamentales en C# que permiten evaluar relaciones entre valores y asignar datos a variables. Estos operadores son esenciales para controlar el flujo de ejecución y manipular el estado de las aplicaciones.

Operadores de comparación

Los operadores de comparación evalúan la relación entre dos valores y devuelven un resultado booleano (true o false). Estos operadores son la base para construir condiciones en estructuras de control como if, while y for.

C# proporciona seis operadores de comparación principales:

• Igual a (==): Comprueba si dos valores son iguales.
• Distinto de (!=): Comprueba si dos valores son diferentes.
• Mayor que (>): Comprueba si el primer valor es mayor que el segundo.
• Menor que (<): Comprueba si el primer valor es menor que el segundo.
• Mayor o igual que (>=): Comprueba si el primer valor es mayor o igual que el segundo.
• Menor o igual que (<=): Comprueba si el primer valor es menor o igual que el segundo.

Veamos ejemplos de cada uno:

int a = 5;
int b = 10;

bool esIgual = (a == b);         // false
bool esDiferente = (a != b);     // true
bool esMayor = (a > b);          // false
bool esMenor = (a < b);          // true
bool esMayorIgual = (a >= b);    // false
bool esMenorIgual = (a <= b);    // true

Console.WriteLine($"¿5 == 10? {esIgual}");
Console.WriteLine($"¿5 != 10? {esDiferente}");
Console.WriteLine($"¿5 > 10? {esMayor}");
Console.WriteLine($"¿5 < 10? {esMenor}");
Console.WriteLine($"¿5 >= 10? {esMayorIgual}");
Console.WriteLine($"¿5 <= 10? {esMenorIgual}");

Estos operadores son particularmente útiles en estructuras de control:

int edad = 18;

if (edad >= 18)
{
    Console.WriteLine("Es mayor de edad");
}
else
{
    Console.WriteLine("Es menor de edad");
}

Comparación de tipos por referencia

Cuando se comparan tipos por referencia (como objetos), el operador == compara las referencias, no el contenido:

string texto1 = "Hola";
string texto2 = "Hola";
string texto3 = texto1;

bool sonIgualesReferencia1 = (texto1 == texto2);  // true (caso especial para strings)
bool sonIgualesReferencia2 = (texto1 == texto3);  // true

Console.WriteLine($"¿texto1 == texto2? {sonIgualesReferencia1}");
Console.WriteLine($"¿texto1 == texto3? {sonIgualesReferencia2}");

Para las cadenas, C# realiza una comparación de contenido por defecto, pero para otros tipos de objetos, debes usar el método Equals() para comparar contenido:

// Para objetos personalizados
var punto1 = new { X = 10, Y = 20 };
var punto2 = new { X = 10, Y = 20 };

bool referenciaIgual = (punto1 == punto2);      // false (referencias diferentes)
bool contenidoIgual = punto1.Equals(punto2);    // true (contenido igual)

Console.WriteLine($"Referencia igual: {referenciaIgual}");
Console.WriteLine($"Contenido igual: {contenidoIgual}");

Operadores de asignación

Los operadores de asignación permiten almacenar valores en variables. El operador básico de asignación es el signo igual (=):

int numero = 10;  // Asigna el valor 10 a la variable numero

C# también proporciona operadores de asignación compuesta que combinan una operación aritmética o de otro tipo con la asignación:

• +=: Suma y asigna
• -=: Resta y asigna
• ***=**: Multiplica y asigna
• /=: Divide y asigna
• %=: Calcula el módulo y asigna
• &=: Realiza AND a nivel de bits y asigna
• |=: Realiza OR a nivel de bits y asigna
• ^=: Realiza XOR a nivel de bits y asigna
• <<=: Desplaza bits a la izquierda y asigna
• >>=: Desplaza bits a la derecha y asigna

Estos operadores simplifican el código al combinar dos operaciones en una sola:

int x = 5;

x += 3;  // Equivale a: x = x + 3;
Console.WriteLine($"Después de += 3: {x}");  // 8

x -= 2;  // Equivale a: x = x - 2;
Console.WriteLine($"Después de -= 2: {x}");  // 6

x *= 4;  // Equivale a: x = x * 4;
Console.WriteLine($"Después de *= 4: {x}");  // 24

x /= 3;  // Equivale a: x = x / 3;
Console.WriteLine($"Después de /= 3: {x}");  // 8

x %= 5;  // Equivale a: x = x % 5;
Console.WriteLine($"Después de %= 5: {x}");  // 3

Operadores de asignación con bits

Los operadores de asignación compuesta también funcionan con operaciones a nivel de bits:

int bits = 0b1010;  // 10 en decimal

bits &= 0b1100;  // AND a nivel de bits: 0b1000 (8 en decimal)
Console.WriteLine($"Después de &= 0b1100: {bits}");

bits |= 0b0011;  // OR a nivel de bits: 0b1011 (11 en decimal)
Console.WriteLine($"Después de |= 0b0011: {bits}");

bits ^= 0b0101;  // XOR a nivel de bits: 0b1110 (14 en decimal)
Console.WriteLine($"Después de ^= 0b0101: {bits}");

bits <<= 2;  // Desplazamiento a la izquierda: 0b111000 (56 en decimal)
Console.WriteLine($"Después de <<= 2: {bits}");

bits >>= 3;  // Desplazamiento a la derecha: 0b111 (7 en decimal)
Console.WriteLine($"Después de >>= 3: {bits}");

Operador de asignación nula (??=)

A partir de C# 8.0, se introdujo el operador de asignación nula (??=), que asigna el valor del lado derecho solo si el lado izquierdo es null:

string nombre = null;
nombre ??= "Usuario";  // Asigna "Usuario" porque nombre es null
Console.WriteLine($"Nombre: {nombre}");  // Usuario

nombre ??= "Administrador";  // No hace nada porque nombre ya no es null
Console.WriteLine($"Nombre: {nombre}");  // Usuario

Este operador es especialmente útil para inicializar variables que podrían ser nulas:

// Inicialización de configuración con valores predeterminados
Dictionary<string, string> configuracion = new Dictionary<string, string>();
configuracion["tema"] = "claro";

string tema = configuracion.GetValueOrDefault("tema");
string idioma = configuracion.GetValueOrDefault("idioma");

idioma ??= "es-ES";  // Asigna el valor predeterminado si es null

Console.WriteLine($"Tema: {tema}");    // claro
Console.WriteLine($"Idioma: {idioma}"); // es-ES

Operador de asignación condicional (? :)

El operador ternario (? :) permite asignar valores basados en una condición:

int edad = 20;
string estado = (edad >= 18) ? "Mayor de edad" : "Menor de edad";

Console.WriteLine($"Estado: {estado}");  // Mayor de edad

Este operador es una forma concisa de escribir una estructura if-else para asignaciones simples:

// Equivalente usando if-else
string estadoConIf;
if (edad >= 18)
{
    estadoConIf = "Mayor de edad";
}
else
{
    estadoConIf = "Menor de edad";
}

Uso combinado de operadores de comparación y asignación

Los operadores de comparación y asignación a menudo se utilizan juntos para implementar lógica condicional:

int puntuacion = 85;
string calificacion;

if (puntuacion >= 90)
{
    calificacion = "A";
}
else if (puntuacion >= 80)
{
    calificacion = "B";
}
else if (puntuacion >= 70)
{
    calificacion = "C";
}
else if (puntuacion >= 60)
{
    calificacion = "D";
}
else
{
    calificacion = "F";
}

Console.WriteLine($"Calificación: {calificacion}");  // B

También se pueden combinar con operadores lógicos para crear condiciones más complejas:

int temperatura = 28;
bool esDiaLaboral = true;

string actividad = (temperatura > 25 && !esDiaLaboral) 
    ? "Ir a la playa" 
    : (temperatura > 25) 
        ? "Trabajar con aire acondicionado" 
        : "Quedarse en casa";

Console.WriteLine($"Actividad recomendada: {actividad}");

Los operadores de comparación y asignación son herramientas esenciales en C# que permiten implementar la lógica de decisión y manipular datos de manera eficiente en tus aplicaciones.