Sentencias de Iteración

Mientras que las decisiones condicionales permiten ejecutar bloques de código selectivamente, los sistemas complejos requieren ejecutar operaciones repetidamente. En el ecosistema de C, existen tres constructores principales para esta lógica iterativa: while, for y do-while.

1. Sentencia While

1.1 Sintaxis y Mecánica

La estructura while evalúa una condición antes de cada ejecución del bloque. Si la condición es verdadera (true), el cuerpo se ejecuta; si es falsa, la iteración termina.

while (condicion) {
    // Bloque de instrucciones
}

El proceso de evaluación ocurre secuencialmente. Consideremos un caso donde necesitamos listar valores numéricos hasta alcanzar un límite específico.

#include <stdio.h>

int funcion_principal() {
    int numero_actual = 1;
    while (numero_actual <= 5) {
        printf("%d\n", numero_actual);
        numero_actual++;
    }
    return 0;
}

Aquí, la variable numero_actual inicia en 1. El comparador verifica si el valor actual es menor o igual a 5. Al ser cierto, imprime el número y lo incrementa. Este ciclo continúa hasta que la variable supera el umbral definido.

1.2 Modificadores de Flujo: Break y Continue

Dentro del flujo de control, break fuerza la terminación inmediata del bucle más cercano, transferiendo el control al primer comando posterior a la estructura iterativa.

int main() {
    int x = 1;
    while (x <= 10) {
        if (x == 6) {
            break; 
        }
        printf("%d ", x);
        x++;
    }
    return 0;
}

Si x alcanza el valor 6, se ejecuta break, detaniendo el programa y omitiendo cualquier impresión adicional.

Por otro lado, continue no corta el bucle entero, sino que finaliza la iteración presente. Esto lleva la ejecución directamente a la comprobación de la condición de entrada nuevamente. Si la lógica interna incrementa una variable dentro del cuerpo del bucle pero continue se activa antes del incremento, puede provocar un bucle infinito ya que la condición nunca dejará de cumplirse.

int main() {
    int x = 1;
    while (x <= 10) {
        if (x == 6) {
            continue; 
        }
        printf("%d ", x);
        x++; 
    }
    return 0;
}

En este escenario, cuando x es 6, se salta el printf y el x++. x permanece en 6 eternamente verificando la condición, creando un estado de espera indefinida.

2. Ciclo For

2.1 Componentes de la Estructura

Aunque comparte la funcionalidad básica con while, for organiza la gestión del ciclo en tres partes definidas dentro de su cabecera:

• Inicialización
• Condición de continuación
• Actualización (al final de cada iteración)

for (inicializacion; condicion; actualizacion) {
    // cuerpo del bucle
}

Ejemplo práctico para imprimir números pares menores a 10:

#include <stdio.h>
#include <stdlib.h>

int funcion_principal() {
    for (int cont = 2; cont < 10; cont += 2) {
        printf("%d ", cont);
    }
    return 0;
}

La ventaja clave radica en la encapsulación de la lógica de inicio y fin dentro de la declaración misma, reduciendo errores de olvido al actualizar el contador externo.

2.2 Comparación de Comportamiento

Las sentencias break y continue funcionan de manera distinta entre tipos de bucles. En for, la parte de actualización siempre se ejecuta después de la iteración, incluso si continue está presente.

int main() {
    for (int n = 1; n <= 5; n++) {
        if (n == 3) {
            continue;
        }
        printf("%d ", n);
    }
    return 0;
}

Al llegar a n = 3, continue ignora la impresión, pero el sistema ejecuta automáticamente el paso de incremento (n++) antes de volver a evaluar la condición. Así evita el bucle infinito mencoinado en la versión while.

2.3 Convenciones de Rango

Es buena práctica utilizar rangos cerrados en el inicio y abiertos en el final (i < limite). Esto facilita cálculos matemáticos posteriores sobre la cantidad de iteraciones realizadas (el límite mismo representa el total de repeticiones).

// Estándar recomendado
for (int i = 0; i < 10; i++) {} 

// Alternativa equivalente pero menos intuitiva
for (int i = 0; i <= 9; i++) {}

3. Bucles Do-While

3.1 Ejecución Diferida

A diferencia de while, esta estructura comprueba la validez del bucle después de haber ejecuatdo el cuerpo. Esto garantiza que las instrucciones internas se ejecuten al menos una vez, sin importar la condición inicial.

do {
    // instrucciones a ejecutar
} while (verificacion);

Código ilustrativo:

int func() {
    int num = 5;
    do {
        printf("%d ", num);
        num++;
    } while (num <= 10);
    return 0;
}

3.2 Restricciones

Dado que la verificación posponida impide predecir el comportamiento si la condición falla desde el inicio (ejecutando siempre mínimo una vez), este tipo de loop tiene casos de uso muy específicos, como menús interactivos o lectura de datos donde la primera entrada es obligatoria.

3.3 Gestión de Salidas

Al igual que en while, la sentencia break termina el bucle inmediatamente. Sin embargo, continue fuerza el retorno directo a la condición while al final del bloque. Si hay un incremento de contador después de continue, este se omite, replicando el riesgo de bucle infinito existente en la variante while.