Estructuras condicionales: if, else if, else

Las estructuras condicionales permiten ejecutar secciones de código basadas en evaluaciones lógicas. Mediante un bloque if, el programa comprueba si una expresión booleana es verdadera o falsa. Este mecanismo resulta muy versátil cuando se requiere tomar decisiones dinámicas, ya sea comparando variables o analizando resultados de funciones.

La palabra clave if se acompaña siempre de paréntesis que encierran la condición a evaluar, seguida de un bloque de instrucciones entre llaves. Para ampliar la lógica, se pueden encadenar varios else if que introducen más condiciones por comprobar de forma secuencial. Finalmente, se emplea else para definir un bloque que se ejecuta solo si todas las condiciones previas resultan falsas.

En el siguiente snippet se puede observar la sintaxis general:

if (condicion1) {
    /* Código a ejecutar si condicion1 es verdadera */
} else if (condicion2) {
    /* Código a ejecutar si condicion1 es falsa y condicion2 es verdadera */
} else {
    /* Código a ejecutar si ninguna de las condiciones anteriores se cumple */
}

Es frecuente aprovechar estructuras anidadas de esta manera cuando existen dependencias lógicas complejas. Aun así, para facilitar la lectura, conviene organizar cada condición de forma clara y mantener el número de bloques en un nivel que resulte comprensible.

Estructura switch-case

La estructura switch-case permite evaluar el valor de una expresión y dirigir la ejecución a una rama específica sin necesidad de múltiples comparaciones separadas. Dicho valor suele ser un entero o un carácter, y cada caso se define con la palabra clave case, seguida de dos puntos y un bloque de instrucciones.

Para que el flujo de ejecución no continúe a los casos siguientes, se utiliza la sentencia break al final de cada rama. Si ninguno de los casos coincide, se ejecuta la rama marcada con la palabra clave default, que actúa como una especie de ruta por defecto. A continuación se muestra un ejemplo conciso:

switch (opcion) {
case 1:
    printf("Seleccionado 1\n");
    break;
case 2:
    printf("Seleccionado 2\n");
    break;
default:
    printf("Valor no contemplado\n");
    break;
}

Es habitual incluir el bloque default al final para manejar valores que no encajan en los casos listados previamente. Además, existen situaciones donde se desea la caída de un caso a otro, en cuyo caso se omite break, aunque se recomienda hacerlo con cuidado para evitar confusiones en el seguimiento del flujo del programa.

Bucles: while, do-while, for

Un bucle while revisa una condición antes de cada iteración, ejecutando el bloque de instrucciones mientras dicha expresión sea verdadera. De este modo, es común controlar la entrada de datos o repetir acciones hasta que un valor concreto cambie. Un ejemplo básico sería:

int contador = 0;
while (contador < 5) {
    printf("Valor de contador: %d\n", contador);
    contador++;
}

Un bucle do-while se diferencia en que el bloque de instrucciones se ejecuta al menos una vez. La evaluación de la condición se realiza al final de cada iteración, lo cual resulta útil cuando se desea acceder a un procedimiento antes de verificar si se continúa. Se puede ilustrar así:

int numero = 1;
do {
    printf("Número actual: %d\n", numero);
    numero++;
} while (numero <= 3);

El bucle for se utiliza con frecuencia cuando se requiere un contador explícito. En su encabezado se declaran e inicializan las variables, la condición y la forma de incrementar o decrementar el contador. Además, en el estándar C99 se permite declarar la variable de control directamente en la sección de inicialización. Este ejemplo lo muestra:

for (int i = 0; i < 4; i++) {
    printf("Iteración: %d\n", i);
}

Cada estructura de repetición se adapta a un esquema lógico distinto: el bucle while sobresale en verificaciones previas, el do-while asegura una primera ejecución y el for integra en su sintaxis los pasos esenciales de inicio, condición y actualización.

Sentencias de salto: break, continue

La sentencia break interrumpe inmediatamente la ejecución del bucle donde se encuentra, sin comprobar más iteraciones. Esto resulta útil cuando se ha obtenido el resultado esperado o se detecta una condición que hace innecesario continuar. En bucles anidados, solo finaliza el bucle interno en el que aparece.

Por ejemplo, puede emplearse para detener un recorrido dentro de un array en cuanto se cumpla un criterio específico:

int numeros[] = {10, 20, 30, 40, 50};
for (int i = 0; i < 5; i++) {
    if (numeros[i] == 30) {
        break; /* Sale del bucle al encontrar el valor 30 */
    }
    printf("Valor: %d\n", numeros[i]);
}

A diferencia de break, la sentencia continue no sale del bucle por completo, sino que salta directamente a la siguiente iteración. Así, evita las instrucciones posteriores en la iteración actual, pero vuelve a comprobar la condición de permanencia del bucle.

Se puede observar en este ejemplo, donde se omiten los números pares y se procesan únicamente los impares:

for (int j = 1; j <= 6; j++) {
    if (j % 2 == 0) {
        continue; /* Salta a la siguiente vuelta si j es par */
    }
    printf("Número impar: %d\n", j);
}

En la práctica, las sentencias break y continue simplifican la lógica de los bucles, sobre todo al manejar condiciones que exigen una salida temprana o el salto de una iteración concreta. Sin embargo, conviene usarlas con moderación y claridad para mantener el código legible y coherente.