Operadores Lógicos y de Comparación

¿Qué son las condiciones?

Piensa en tu vida diaria: tomas decisiones todo el tiempo basándote en condiciones.

• Si llueve, llevo paraguas.
• Si tengo hambre y hay comida, como.
• Si es sábado o domingo, no voy a la escuela.

En programación es exactamente igual. Tu programa necesita evaluar condiciones para tomar decisiones. Para eso usamos dos tipos de operadores: los de comparación y los lógicos.

Operadores de comparación

Estos operadores comparan dos valores y devuelven true (verdadero) o false (falso):

int edad = 16;

cout << (edad == 18) << endl;   // 0 (false)
cout << (edad != 18) << endl;   // 1 (true)
cout << (edad < 18) << endl;    // 1 (true)
cout << (edad >= 16) << endl;   // 1 (true)

Comparar caracteres y strings

Los caracteres se comparan por su valor ASCII:

cout << ('A' < 'B') << endl;    // 1 (true, porque 65 < 66)
cout << ('a' > 'Z') << endl;    // 1 (true, porque 97 > 90)
cout << ('5' < '9') << endl;    // 1 (true, porque 53 < 57)

Los strings se comparan lexicográficamente (como en un diccionario):

string a = "abc", b = "abd";
cout << (a < b) << endl;    // 1 (true, porque 'c' < 'd')

string c = "abc", d = "abcd";
cout << (c < d) << endl;    // 1 (true, "abc" viene antes que "abcd")

Operadores lógicos

Los operadores lógicos combinan condiciones:

AND (&&): "Y" lógico

Solo es true cuando AMBAS condiciones son verdaderas:

true  && true  → true
true  && false → false
false && true  → false
false && false → false

Ejemplo: Para inscribirte en la olimpiada necesitas tener 15 años o más Y estar en preparatoria:

int edad = 16;
bool enPrepa = true;

if (edad >= 15 && enPrepa) {
    cout << "Puedes inscribirte" << endl;
}

OR (||): "O" lógico

Es true cuando AL MENOS UNA condición es verdadera:

true  || true  → true
true  || false → true
false || true  → true
false || false → false

Ejemplo: Te puedes registrar si eres estudiante O si eres maestro:

bool esEstudiante = false;
bool esMaestro = true;

if (esEstudiante || esMaestro) {
    cout << "Puedes registrarte" << endl;  // Sí se imprime
}

NOT (!): "NO" lógico

Invierte el valor: verdadero se vuelve falso, y viceversa:

!true  → false
!false → true

bool llueve = false;

if (!llueve) {
    cout << "No llueve, sal sin paraguas" << endl;
}

Combinando operadores

Puedes combinar múltiples condiciones:

int edad = 16;
int promedio = 9;
bool tienePermiso = true;

// Ejemplo complejo
if ((edad >= 15 && edad <= 18) && (promedio >= 8 || tienePermiso)) {
    cout << "Aceptado" << endl;
}

Lectura: "Si la edad está entre 15 y 18 Y (el promedio es 8 o más O tiene permiso)".

Precedencia de operadores lógicos

De mayor a menor prioridad:

1. ! (NOT)
2. && (AND)
3. || (OR)

// Sin paréntesis:
true || false && false
// Se evalúa como: true || (false && false) = true || false = true

// Con paréntesis para cambiar el orden:
(true || false) && false
// Se evalúa como: true && false = false

Evaluación de cortocircuito (short-circuit)

C++ es "perezoso" al evaluar condiciones:

• Con &&: Si la primera condición es false, no evalúa la segunda (porque ya sabe que el resultado será false).
• Con ||: Si la primera condición es true, no evalúa la segunda (porque ya sabe que el resultado será true).

Esto es útil para evitar errores:

int n = 0;

// Sin cortocircuito, esto daría error (división entre cero)
// Pero gracias al cortocircuito, si n == 0, no evalúa la segunda parte
if (n != 0 && 10 / n > 2) {
    cout << "Entró" << endl;
}

Verificar rangos

Un patrón muy común es verificar si un número está dentro de un rango:

int x = 15;

// ❌ Incorrecto (error de principiante)
if (10 < x < 20) {  // Esto NO funciona como esperas

}

// ✅ Correcto
if (x > 10 && x < 20) {
    cout << "x está entre 10 y 20" << endl;
}

// ✅ Incluyendo los extremos
if (x >= 10 && x <= 20) {
    cout << "x está entre 10 y 20 (inclusive)" << endl;
}

¿Por qué 10 < x < 20 no funciona? Porque C++ evalúa de izquierda a derecha: primero 10 < x (que da true = 1), luego 1 < 20 (que siempre es true). ¡No es lo que querías!

Tabla de verdad completa

Para referencia, aquí están todas las combinaciones posibles:

Leyes de De Morgan

Estas leyes te ayudan a simplificar condiciones negadas:

• !(A && B) es equivalente a !A || !B
• !(A || B) es equivalente a !A && !B

Ejemplo práctico:

// Estas dos condiciones son equivalentes:
if (!(edad >= 18 && tieneID)) { ... }
if (edad < 18 || !tieneID) { ... }

// Y estas también:
if (!(esPar || esPositivo)) { ... }
if (!esPar && !esPositivo) { ... }

La segunda forma suele ser más legible.

Ejercicio de práctica

Lee tres números y determina si pueden ser los lados de un triángulo. Un triángulo es válido si la suma de cualesquiera dos lados es mayor que el tercero.

Entrada: 3 4 5 Salida: Si es un triangulo

Entrada: 1 2 10 Salida: No es un triangulo

#include <iostream>
using namespace std;

int main() {
    int a, b, c;
    cin >> a >> b >> c;

    if (a + b > c && a + c > b && b + c > a) {
        cout << "Si es un triangulo" << endl;
    } else {
        cout << "No es un triangulo" << endl;
    }

    return 0;
}

Siguiente paso

Ahora que sabes comparar y combinar condiciones, aprende a usarlas con If-Else para que tu programa tome decisiones.