Operadores de comparación y operadores lógicos en C++

¿Qué es y para qué sirve?

Imagina que estás jugando un videojuego. Tienes 100 vidas. Cuando te encuentras con un monstruo, el juego verifica: "¿Vidas mayores que 0?". Si es así, puedes luchar. Si no, el juego dice: "Game Over".

En programación, estas comprobaciones las realizan los operadores de comparación y los operadores lógicos. Ayudan al programa a tomar decisiones. Por ejemplo:

• Verificar si hay suficiente dinero en la cuenta
• Saber si ha llegado la noche
• Entender si el jugador puede abrir la puerta (si tiene la llave O sabe el código)

Sin ellos, el programa sería como un robot que hace lo mismo sin mirar lo que sucede a su alrededor. ¡Con ellos, se vuelve inteligente!

Sintaxis y ejemplos de código

En C++, los operadores de comparación se ven así:

==  // igual (¡atención: dos signos igual!)
!=  // no igual
>   // mayor que
<   // menor que
>=  // mayor o igual que
<=  // menor o igual que

Y los operadores lógicos conectan varias condiciones:

&&  // Y (ambas condiciones deben ser true)
||  // O (al menos una condición debe ser true)
!   // NO (cambia true a false y viceversa)

Ejemplo 1: Verificación de edad

#include <iostream>
using namespace std;

int main() {
    int age = 14;
    
    // Verificamos: ¿edad mayor o igual a 18?
    if (age >= 18) {
        cout << "¡Eres adulto!" << endl;
    } else {
        cout << "Todavía eres un niño." << endl;
    }
    // Salida: "Todavía eres un niño."
    // Porque 14 no es mayor o igual a 18
    return 0;
}

Ejemplo 2: Y lógico (&&)

#include <iostream>
using namespace std;

int main() {
    bool tiene_llave = true;
    bool sabe_codigo = false;
    
    // Para abrir la puerta, se necesita Y la llave Y el código
    if (tiene_llave && sabe_codigo) {
        cout << "¡Puerta abierta!" << endl;
    } else {
        cout << "Acceso denegado." << endl;
    }
    // Salida: "Acceso denegado."
    // Porque sabe_codigo = false
    return 0;
}

Ejemplo 3: O lógico (||)

#include <iostream>
using namespace std;

int main() {
    int temperatura = 30; // grados
    
    // Salimos a pasear si hace calor O está seco
    if (temperatura > 20 || temperatura < 10) {
        cout << "¡Vamos a pasear!" << endl;
    } else {
        cout << "Nos quedamos en casa." << endl;
    }
    // Salida: "¡Vamos a pasear!"
    // Porque 30 > 20 (la primera condición es true)
    return 0;
}

Ejemplo 4: NO lógico (!)

#include <iostream>
using namespace std;

int main() {
    bool llueve = false;
    
    // Si NO llueve, salimos a pasear
    if (!llueve) {
        cout << "¡Hurra, a pasear!" << endl;
    } else {
        cout << "Cogemos el paraguas." << endl;
    }
    // Salida: "¡Hurra, a pasear!"
    // Porque !false = true
    return 0;
}

Ejemplo 5: Condición compleja

#include <iostream>
using namespace std;

int main() {
    int edad = 16;
    bool tiene_licencia = false;
    bool con_padres = true;
    
    // Puede conducir un coche si:
    // (edad >= 18 Y tiene licencia) O (con padres)
    if ((edad >= 18 && tiene_licencia) || con_padres) {
        cout << "¡Puede ponerse al volante!" << endl;
    } else {
        cout << "No puede conducir." << endl;
    }
    // Salida: "¡Puede ponerse al volante!"
    // Porque con_padres = true
    return 0;
}

Comparación con Python

En Python, los mismos operadores se ven casi igual, pero hay diferencias importantes:

Ejemplo en Python:

age = 14
if age >= 18:
    print("¡Eres adulto!")
else:
    print("Todavía eres un niño.")
# Salida: "Todavía eres un niño."

La principal diferencia: en Python, los operadores lógicos se escriben con palabras (and, or, not), mientras que en C++ se escriben con símbolos (&&, ||, !). Además, en Python no se necesitan puntos y coma ni llaves; en su lugar se usan sangrías.

Errores típicos de principiantes

Error 1: Confundir = y ==

Un signo igual (=) es asignación. Dos (==) es comparación.

// INCORRECTO:
if (x = 5) { ... }  // ¡Error! Asigna 5 a la variable x

// CORRECTO:
if (x == 5) { ... }  // Verifica si x es igual a cinco

Error 2: Olvidar la prioridad de operaciones

Como en matemáticas: primero la multiplicación, luego la suma. En lógica también hay un orden: primero !, luego &&, luego ||.

// Puede no estar claro:
if (a || b && c) // Primero se ejecuta b && c, luego a || resultado

// Es mejor usar paréntesis:
if (a || (b && c)) // Ahora está claro

Error 3: Comparar tipos diferentes

int x = 5;
double y = 5.0;
if (x == y) { ... } // Funciona, pero puede ser inesperado

// Es mejor convertir a un mismo tipo:
if (x == (int)y) { ... }

Error 4: Usar =