if-else en C++: sentencias condicionales con ejemplos

Tomar decisiones con if

Los programas reaccionan constantemente a los datos: aprobado o suspenso, en stock o agotado, válido o no. La sentencia if es la forma en que C++ elige qué código ejecutar según una condición.

Un if recibe una condición entre paréntesis y ejecuta el bloque entre llaves solo cuando esa condición es verdadera:

#include <iostream>
using namespace std;

int main() {
    int score = 72;

    if (score >= 60) {
        cout << "You passed!" << endl;
    }

    cout << "Done grading." << endl;
    return 0;
}

La condición score >= 60 es verdadera, así que el mensaje se imprime. La línea que sigue a la llave de cierre siempre se ejecuta: está fuera del if. Cambia score a 40 y la línea de "passed" se omite por completo.

La condición se convierte a bool. Comparaciones como >, >=, ==, != ya devuelven un bool, pero C++ también trata cualquier número distinto de cero como verdadero y 0 como falso, de modo que if (count) significa "si count no es cero". Esa conversión implícita es cómoda, pero también es el origen de algunos errores clásicos que verás más abajo.

Añadir un else

else te da el camino del "en caso contrario": código que se ejecuta solo cuando la condición es falsa:

#include <iostream>
using namespace std;

int main() {
    int hour = 20;

    if (hour < 12) {
        cout << "Good morning" << endl;
    } else {
        cout << "Good evening" << endl;
    }
    return 0;
}

Se ejecuta exactamente uno de los dos bloques: nunca ambos, nunca ninguno. El else no tiene condición propia; simplemente atrapa todo lo que el if no atrapó.

Encadenar con else if

Cuando hay más de dos resultados posibles, encadena condiciones con else if. C++ las comprueba de arriba abajo y ejecuta el primer bloque cuya condición sea verdadera, luego omite el resto:

#include <iostream>
using namespace std;

int main() {
    int score = 84;
    char grade;

    if (score >= 90) {
        grade = 'A';
    } else if (score >= 80) {
        grade = 'B';
    } else if (score >= 70) {
        grade = 'C';
    } else {
        grade = 'F';
    }

    cout << "Grade: " << grade << endl;
    return 0;
}

El orden importa. Como 84 se compara primero con >= 90 (falso) y luego con >= 80 (verdadero), se detiene en B y nunca comprueba los límites inferiores. Por eso tampoco necesitas score >= 80 && score < 90: llegar a la segunda rama ya garantiza que score era menor que 90. Pon primero tu condición más restrictiva o de mayor prioridad.

Ten en cuenta que en C++ no existe la palabra clave elif: else if es literalmente un else cuyo cuerpo es otro if. Las llaves solo hacen que se lea como una sola escalera.

Una gran trampa: = frente a ==

El error de sentencia if más común en C y C++ es escribir = (asignación) donde querías == (comparación):

#include <iostream>
using namespace std;

int main() {
    int x = 0;

    if (x = 5) {   // ERROR: asigna 5 a x, luego evalúa 5 (siempre verdadero)
        cout << "This always runs, and x is now " << x << endl;
    }
    return 0;
}

x = 5 asigna 5 a x y toda la expresión se evalúa como 5, que se convierte en true, así que la rama siempre se ejecuta y has sobrescrito x sin darte cuenta. Esto compila; la mayoría de los compiladores solo emiten una advertencia. Dos defensas: activa las advertencias (-Wall) para que el compilador lo señale, y plantéate poner la constante delante —if (5 == x)— porque if (5 = x) es un error grave que el compilador detecta de inmediato.

La misma trampa se esconde con bool: if (ready = true) compila y asigna, mientras que if (ready == true) (o simplemente if (ready)) compara.

Combinar y anidar condiciones

Combina condiciones con && (y), || (o) y ! (no), o anida un if dentro de otro cuando una comprobación solo tiene sentido después de que otra anterior haya pasado:

#include <iostream>
using namespace std;

int main() {
    int age = 25;
    bool hasLicense = true;

    if (age >= 18 && hasLicense) {
        cout << "Can drive" << endl;
    } else {
        cout << "Cannot drive" << endl;
    }

    // anidamiento: solo comprueba lo segundo si lo primero se cumple
    if (age >= 18) {
        if (hasLicense) {
            cout << "Eligible and licensed" << endl;
        }
    }
    return 0;
}

&& y || evalúan en cortocircuito: en a && b, si a es falso C++ nunca evalúa b. Eso es esencial para protegerse contra accesos a memoria incorrectos: if (ptr != nullptr && ptr->ready) es seguro porque la desreferencia del puntero se omite cuando ptr es nulo. Prefiere aplanar con && antes que anidar en profundidad cuando puedas; una condición plana se lee con más claridad que una pirámide de llaves.

Cuidado con el encadenamiento de comparaciones que no significa lo que parece: if (0 < x < 10) no comprueba un rango. Evalúa 0 < x como un bool (0 o 1) y luego lo compara con 10: siempre verdadero. Escribe if (0 < x && x < 10) en su lugar.

El operador ternario

Cuando lo único que quieres es elegir entre dos valores, el operador ternario ?: es una línea compacta. Lee condition ? a : b como "si la condición es verdadera, entonces a, si no, b":

#include <iostream>
#include <string>
using namespace std;

int main() {
    int age = 15;

    string label = age >= 18 ? "adult" : "minor";
    cout << label << endl;

    int a = 7, b = 3;
    int largest = a > b ? a : b;
    cout << "largest = " << largest << endl;
    return 0;
}

El ternario produce un valor que puedes asignar, pasar o imprimir directamente, algo que un if simple no puede hacer. Resérvalo para selecciones sencillas: si alguna rama necesita varias sentencias o lógica real, un if-else completo sigue siendo legible donde un ternario anidado pronto se convierte en un acertijo. (Un matiz: ambas ramas deben compartir un tipo común, así que no mezcles, por ejemplo, un string y un int.)

if con un inicializador (C++17)

Desde C++17 puedes declarar una variable justo dentro del if, con un ámbito limitado al if/else. Esto evita que ayudantes de vida corta se filtren al código circundante:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string text = "hello world";

    if (size_t pos = text.find("world"); pos != string::npos) {
        cout << "found at index " << pos << endl;
    } else {
        cout << "not found" << endl;
    }

    // pos está fuera de ámbito aquí: solo existía dentro del if/else
    return 0;
}

La parte anterior al ; se ejecuta una vez y su resultado es visible tanto en la condición como en el else. Esto es ideal para patrones de "calcular algo y luego ramificar según ello"; además, como la conversión del resultado ocurre una sola vez al principio, evitas recalcular o reutilizar accidentalmente un valor obsoleto más adelante. Recurre a ello siempre que un temporal solo se necesite para la ramificación.

Una trampa: el problema de las llaves colgantes

C++ te permite omitir las llaves cuando una rama tiene una sola sentencia, pero esto invita a un error sutil: la indentación miente:

if (loggedIn)
    cout << "Welcome\n";
    cout << "Loading dashboard\n";   // ¡NO forma parte del if!

Solo la primera línea está controlada por el if; la segunda siempre se ejecuta, sin importar loggedIn, a pesar de que la indentación sugiera lo contrario. Un clásico relacionado es el punto y coma extraviado: if (x > 0); termina el if con un cuerpo vacío, así que el bloque que sigue se ejecuta incondicionalmente. Usa siempre llaves —incluso para una sola línea— y la mayoría de los errores de este tipo desaparecen.

Siguiente: switch

Las cadenas if-else if son perfectas cuando cada rama evalúa una condición diferente. Pero cuando estás comprobando un único valor contra muchas posibilidades fijas —una opción de menú, un enum, un código de estado— una larga escalera de else if se vuelve repetitiva y fácil de desordenar. La sentencia switch está hecha justo para eso, y de eso trata la siguiente página.