Operadores de comparación y lógicos

Los operadores son símbolos especiales que nos permiten realizar diferentes tipos de operaciones en nuestros programas. Mientras que los operadores aritméticos nos ayudan con cálculos matemáticos, los operadores de comparación y lógicos son fundamentales para tomar decisiones en nuestro código. Estos operadores nos permiten evaluar condiciones, comparar valores y crear expresiones más complejas que determinan el flujo de ejecución de nuestros programas.

Dominar estos operadores es esencial para escribir programas que puedan responder de manera inteligente a diferentes situaciones. Son la base de las estructuras de control que veremos en profundidad y nos permiten crear aplicaciones que pueden adaptarse a distintos escenarios según los datos que manejen.

Operadores de comparación

Los operadores de comparación, también conocidos como operadores relacionales, se utilizan para comparar dos valores y devuelven siempre un resultado de tipo bool: true o false. Estos operadores son la base para crear condiciones en nuestros programas.

Tabla de operadores de comparación

Operador	Descripción	Ejemplo	Resultado
`==`	Igual a	`5 == 5`	`true`
`!=`	Diferente de	`3 != 7`	`true`
`<`	Menor que	`2 < 8`	`true`
`>`	Mayor que	`10 > 4`	`true`
`<=`	Menor o igual que	`5 <= 5`	`true`
`>=`	Mayor o igual que	`7 >= 3`	`true`

Ejemplos prácticos de comparación

Veamos cómo utilizar estos operadores en situaciones reales:

using System;

class Program
{
    static void Main()
    {
        int edad = 25;
        int edadMinima = 18;
        string nombre1 = "Ana";
        string nombre2 = "Pedro";
        double precio = 29.99;
        double presupuesto = 30.00;
        
        // Comparaciones numéricas
        Console.WriteLine($"¿Es mayor de edad? {edad >= edadMinima}");
        Console.WriteLine($"¿Tiene exactamente 25 años? {edad == 25}");
        Console.WriteLine($"¿Es menor de 30? {edad < 30}");
        
        // Comparaciones de cadenas
        Console.WriteLine($"¿Los nombres son iguales? {nombre1 == nombre2}");
        Console.WriteLine($"¿Los nombres son diferentes? {nombre1 != nombre2}");
        
        // Comparaciones con decimales
        Console.WriteLine($"¿El precio está dentro del presupuesto? {precio <= presupuesto}");
        Console.WriteLine($"¿El precio es exactamente 30? {precio == 30.00}");
    }
}

Consideraciones importantes sobre las comparaciones:

Al comparar números de punto flotante (float, double), ten cuidado con la precisión. Es mejor usar rangos que comparaciones exactas.
Las cadenas de texto son sensibles a mayúsculas y minúsculas: "Ana" != "ana".
Los operadores == y != funcionan con todos los tipos de datos básicos.

Operadores lógicos

Los operadores lógicos nos permiten combinar múltiples condiciones para crear expresiones más complejas. Trabajan principalmente con valores booleanos y siguen las reglas del álgebra booleana.

Tabla de operadores lógicos

Operador	Nombre	Descripción	Ejemplo	Resultado
`&&`	AND (Y lógico)	True si ambas condiciones son true	`true && false`	`false`
`\|\|`	OR (O lógico)	True si al menos una condición es true	`true \|\| false`	`true`
`!`	NOT (Negación)	Invierte el valor booleano	`!true`	`false`

Tablas de verdad

Las tablas de verdad nos muestran todos los posibles resultados de las operaciones lógicas:

Operador AND (&&):

A	B	A && B
true	true	true
true	false	false
false	true	false
false	false	false

Operador OR (||):

A	B	A \|\| B
true	true	true
true	false	true
false	true	true
false	false	false

Operador NOT (!):

A	!A
true	false
false	true

Ejemplos prácticos de operadores lógicos

using System;

class Program
{
    static void Main()
    {
        int edad = 22;
        bool tieneCarnet = true;
        bool tieneDinero = false;
        string clima = "soleado";
        int temperatura = 25;
        
        // Operador AND (&&) - Ambas condiciones deben ser true
        bool puedeConducir = (edad >= 18) && tieneCarnet;
        Console.WriteLine($"¿Puede conducir? {puedeConducir}");
        
        bool puedeComprarCoche = (edad >= 18) && tieneCarnet && tieneDinero;
        Console.WriteLine($"¿Puede comprar un coche? {puedeComprarCoche}");
        
        // Operador OR (||) - Al menos una condición debe ser true
        bool esBuenDiaParaSalir = (clima == "soleado") || (temperatura > 20);
        Console.WriteLine($"¿Es buen día para salir? {esBuenDiaParaSalir}");
        
        bool necesitaAbrigo = (temperatura < 10) || (clima == "lluvioso");
        Console.WriteLine($"¿Necesita abrigo? {necesitaAbrigo}");
        
        // Operador NOT (!) - Invierte el resultado
        bool noTieneDinero = !tieneDinero;
        Console.WriteLine($"¿No tiene dinero? {noTieneDinero}");
        
        bool noEsMenorDeEdad = !(edad < 18);
        Console.WriteLine($"¿No es menor de edad? {noEsMenorDeEdad}");
        
        // Combinando múltiples operadores
        bool puedeIrDeFiesta = (edad >= 18) && ((tieneDinero) || (clima == "soleado"));
        Console.WriteLine($"¿Puede ir de fiesta? {puedeIrDeFiesta}");
    }
}

Precedencia de operadores

Cuando combinamos múltiples operadores en una expresión, es importante conocer el orden en que se evalúan. C# sigue un orden de precedencia específico:

Tabla de precedencia (de mayor a menor)

Precedencia	Operadores	Descripción
1	`!`	Negación lógica
2	`<`, `>`, `<=`, `>=`	Comparación
3	`==`, `!=`	Igualdad
4	`&&`	AND lógico
5	`\|\|`	OR lógico

Uso de paréntesis para claridad

Aunque la precedencia determina el orden de evaluación, es una buena práctica usar paréntesis para hacer nuestras intenciones más claras:

using System;

class Program
{
    static void Main()
    {
        int edad = 25;
        bool estudiante = true;
        double ingresos = 15000;
        
        // Sin paréntesis (se basa en precedencia)
        bool descuentoSinParentesis = edad < 30 && estudiante || ingresos < 20000;
        
        // Con paréntesis (más claro)
        bool descuentoConParentesis = (edad < 30 && estudiante) || (ingresos < 20000);
        
        Console.WriteLine($"Resultado sin paréntesis: {descuentoSinParentesis}");
        Console.WriteLine($"Resultado con paréntesis: {descuentoConParentesis}");
        
        // Ejemplo más complejo con paréntesis para claridad
        bool condicionCompleja = ((edad >= 18) && (edad <= 65)) && 
                                 ((estudiante && ingresos < 25000) || 
                                  (!estudiante && ingresos < 40000));
        
        Console.WriteLine($"¿Cumple condición compleja? {condicionCompleja}");
    }
}

Evaluación en cortocircuito

C# utiliza evaluación en cortocircuito (short-circuit evaluation) para los operadores && y ||. Esto significa que:

En una expresión A && B, si A es false, B no se evalúa porque el resultado ya será false.
En una expresión A || B, si A es true, B no se evalúa porque el resultado ya será true.

Esta característica puede ser útil para optimizar el rendimiento y evitar errores:

using System;

class Program
{
    static void Main()
    {
        int[] numeros = {1, 2, 3, 4, 5};
        int indice = 10;
        
        // Evaluación segura - evita error de índice fuera de rango
        if (indice < numeros.Length && numeros[indice] > 0)
        {
            Console.WriteLine("El número es positivo");
        }
        else
        {
            Console.WriteLine("Índice inválido o número no positivo");
        }
        
        // Ejemplo con OR
        bool esValido = false;
        bool esAdmin = true;
        
        // Si esValido es true, no se evalúa esAdmin
        if (esValido || esAdmin)
        {
            Console.WriteLine("Acceso concedido");
        }
    }
}

Ejercicios prácticos

Para consolidar estos conceptos, prueba a resolver estos pequeños ejercicios:

Sistema de calificaciones: Crea un programa que determine si un estudiante ha aprobado (nota >= 5) y si tiene mención especial (nota >= 9).
Validador de edad: Escribe código que verifique si una persona puede votar (>= 18 años) y si puede jubilarse (>= 65 años).
Control de acceso: Implementa una lógica que permita el acceso si el usuario es administrador O si es un usuario regular con permisos especiales.

// Ejemplo de solución para el ejercicio 1
using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Introduce tu calificación (0-10):");
        double nota = Convert.ToDouble(Console.ReadLine());
        
        bool aprobado = nota >= 5;
        bool mencionEspecial = nota >= 9;
        bool notaValida = nota >= 0 && nota <= 10;
        
        if (!notaValida)
        {
            Console.WriteLine("Nota inválida. Debe estar entre 0 y 10.");
        }
        else
        {
            Console.WriteLine($"Aprobado: {aprobado}");
            Console.WriteLine($"Mención especial: {mencionEspecial}");
            
            if (aprobado && mencionEspecial)
            {
                Console.WriteLine("¡Excelente trabajo!");
            }
            else if (aprobado)
            {
                Console.WriteLine("¡Bien hecho!");
            }
            else
            {
                Console.WriteLine("Necesitas estudiar más.");
            }
        }
    }
}

Resumen

Los operadores de comparación y lógicos son herramientas esenciales para crear programas que puedan tomar decisiones. Los operadores de comparación (==, !=, <, >, <=, >=) nos permiten evaluar relaciones entre valores, mientras que los operadores lógicos (&&, ||, !) nos ayudan a combinar múltiples condiciones para crear expresiones más sofisticadas.

La comprensión de la precedencia de operadores y el uso adecuado de paréntesis nos permite escribir código más claro y predecible. Además, la evaluación en cortocircuito nos proporciona tanto optimización como seguridad en nuestras expresiones lógicas. Estos conceptos serán la base fundamental para las estructuras de decisión que exploraremos en el próximo tema, donde aprenderemos a utilizar estas comparaciones para controlar el flujo de ejecución de nuestros programas.