Bucles y control de iteración en C

Qué es un bucle y qué partes lo componen

Un bucle (loop) repite un bloque de instrucciones mientras se cumpla una condición. En C, los bucles se construyen alrededor de tres piezas que conviene identificar siempre:

• Variable(s) de control: guardan el estado de la iteración (por ejemplo, un contador i o un acumulador suma).
• Condición de parada: expresión booleana que decide si se repite o se termina.
• Actualización: cambia el estado para acercarse a la parada (incrementar, decrementar, leer un nuevo dato, etc.).

La mayoría de errores en bucles ocurren cuando una de estas piezas está ausente, mal ubicada o no se ejecuta como se espera.

Bucle while: “repite mientras…”

while evalúa la condición antes de entrar al cuerpo. Si la condición es falsa desde el inicio, el cuerpo no se ejecuta ni una vez. Es ideal cuando no sabes cuántas iteraciones habrá y la repetición depende de una condición que se verifica al comienzo.

while (condicion) {    // cuerpo    // actualización}

Ejemplo: sumar del 1 al N (sumatoria)

Objetivo: calcular 1 + 2 + ... + N con un contador y un acumulador.

int n = 5;        // supón que ya tienes n válido (n >= 1)int i = 1;int suma = 0;while (i <= n) {    suma = suma + i;    i = i + 1;}/* al final: suma = 15 */

Trazado manual (para entender iteraciones)

Traza una tabla con el estado antes y después del cuerpo:

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

La condición es i <= n. Cuando i pasa a 6, la condición falla y el bucle termina.

Bucle do-while: “haz… y luego verifica”

do-while evalúa la condición después del cuerpo, por lo que el cuerpo se ejecuta al menos una vez. Es útil cuando necesitas ejecutar una acción y luego decidir si repetir (por ejemplo, repetir una operación hasta que el estado quede válido).

do {    // cuerpo    // actualización} while (condicion);

Ejemplo: contar dígitos de un entero no negativo

Incluso si el número es 0, debe contar 1 dígito. Aquí do-while encaja perfecto.

int x = 0;          // supón x >= 0int digitos = 0;do {    digitos = digitos + 1;    x = x / 10;} while (x > 0);/* si x era 0, digitos termina en 1 */

Si esto se hiciera con while (x > 0), el caso x == 0 no ejecutaría el cuerpo y daría 0 dígitos (incorrecto).

Bucle for: contador compacto (inicio; condición; actualización)

for agrupa las tres piezas típicas de un bucle contador en una sola línea: inicialización, condición y actualización. Es ideal cuando el número de iteraciones está controlado por un contador claro.

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

Ejemplo: tabla de valores (x y x²) de 1 a 5

for (int x = 1; x <= 5; x = x + 1) {    int cuadrado = x * x;    // imprimir x y cuadrado}

Equivalencia mental con while

Este for se puede leer como:

int x = 1;while (x <= 5) {    int cuadrado = x * x;    x = x + 1;}

Esta equivalencia ayuda a depurar: si algo falla, revisa si la condición o la actualización están bien colocadas.

¿Cuál elegir? Criterios prácticos

• Usa for cuando hay un contador y la actualización es simple y regular (recorrer rangos, índices de arreglos, tablas).
• Usa while cuando la repetición depende de un estado que se verifica al inicio y el número de iteraciones no es evidente (buscar hasta encontrar, procesar hasta que se cumpla una condición).
• Usa do-while cuando el cuerpo debe ejecutarse al menos una vez (procesar y luego decidir si repetir).

Errores comunes en bucles (y cómo detectarlos)

1) Bucle infinito

Ocurre cuando la condición nunca se vuelve falsa. Causas típicas:

• La actualización no existe o no se ejecuta.
• La actualización va en dirección contraria (decrementas cuando deberías incrementar).
• La condición está mal planteada.

Ejemplo problemático (olvida actualizar i):

int i = 1;while (i <= 5) {    // ...    // falta: i = i + 1;}

Guía de depuración rápida: escribe en papel los primeros 3 ciclos. Si i no cambia, ya encontraste el problema.

2) Error off-by-one (una iteración de más o de menos)

Suele ocurrir por confundir < con <= o por iniciar el contador en un valor incorrecto.

Ejemplo: sumar 1..N. Si haces i < n en lugar de i <= n, te faltará sumar N.

// Incorrecto para sumar 1..nint i = 1;int suma = 0;while (i < n) {    suma += i;    i++;}

Regla práctica: si el rango es “de 1 a N incluyendo N”, la condición típica es i <= N.

3) Modificación accidental del contador

Ocurre cuando cambias el contador dentro del cuerpo sin querer (o lo cambias dos veces: en el cuerpo y en la actualización del for).

for (int i = 0; i < 10; i++) {    // ...    i++; // accidental: ahora avanza de 2 en 2}

Consecuencia: se saltan elementos, se rompe una búsqueda o aparece un off-by-one difícil de ver.

break y continue: cuándo ayudan y cuándo estorban

break: salir del bucle inmediatamente

break termina el bucle actual (no solo una iteración). Es útil cuando encuentras lo que buscabas y no tiene sentido seguir.

Ejemplo: búsqueda lineal simple

Buscar un valor objetivo en un arreglo. Al encontrarlo, sales.

int a[] = {4, 7, 2, 9, 7};int n = 5;int objetivo = 9;int pos = -1;for (int i = 0; i < n; i++) {    if (a[i] == objetivo) {        pos = i;        break;    }}/* pos queda en 3 si se encontró */

Aquí break mejora claridad y eficiencia: expresa “ya terminé”.

Cuándo break puede empeorar claridad

Si hay múltiples break en diferentes ramas, el flujo se vuelve difícil de seguir. En esos casos, a veces es mejor usar una variable bandera (por ejemplo encontrado) o reorganizar la condición del bucle.

continue: saltar al siguiente ciclo

continue omite el resto del cuerpo y pasa a la siguiente iteración. Es útil para “filtrar” casos no deseados sin anidar demasiados if.

Ejemplo: sumar solo números pares del 1 al N

int n = 10;int suma = 0;for (int i = 1; i <= n; i++) {    if (i % 2 != 0) {        continue;    }    suma += i;}/* suma = 2+4+6+8+10 = 30 */

Cuándo continue puede empeorar claridad

Si el bucle ya es complejo, varios continue pueden ocultar qué líneas se ejecutan realmente. Como regla: si necesitas más de uno o dos continue, considera reescribir el cuerpo con condiciones más directas o dividir en funciones auxiliares.

Guía paso a paso para diseñar un bucle correcto

Paso 1: define el objetivo y el estado

¿Qué quieres producir? (por ejemplo, una suma, un conteo, una posición encontrada). Define variables: acumulador, contador, índice, etc.

Paso 2: elige el tipo de bucle

• Contador claro: for.
• Condición al inicio y no sabes cuántas vueltas: while.
• Debe ejecutarse al menos una vez: do-while.

Paso 3: escribe la condición de parada en lenguaje natural

Ejemplo: “mientras i sea menor o igual que n”. Luego tradúcelo a C.

Paso 4: asegura la actualización

Pregunta clave: “¿qué cambia en cada iteración para que eventualmente la condición falle?”

Paso 5: traza 3 a 5 iteraciones a mano

Antes de ejecutar, simula con una tabla. Esto detecta rápido off-by-one y bucles infinitos.

Ejercicios prácticos (con énfasis en trazado)

Ejercicio 1: sumatoria con condición

Calcula la suma de los múltiplos de 3 entre 1 y N (incluyendo N si aplica). Usa for y continue.

• Variables sugeridas: int suma = 0;
• Condición: recorrer i de 1 a N.
• Filtrado: si i % 3 != 0, saltar.

Traza manualmente para N=10: anota qué valores de i se suman y cómo cambia suma.

Ejercicio 2: conteo de ocurrencias

Dado un arreglo de enteros, cuenta cuántas veces aparece un valor objetivo.

int a[] = {1, 2, 2, 2, 5, 2};int n = 6;int objetivo = 2;int conteo = 0;// completa el bucle

Requisitos: usa for. Traza una tabla con columnas i, a[i], conteo.

Ejercicio 3: búsqueda lineal (primera aparición)

Implementa búsqueda lineal que devuelva la primera posición del objetivo o -1 si no está. Usa break al encontrar.

• Prueba mental con: {5, 1, 5, 9} buscando 5 (debe devolver 0).
• Luego prueba buscando 9 (debe devolver 3).
• Luego buscando 7 (debe devolver -1).

Traza cuántas iteraciones se ejecutan en cada caso y en cuál se activa el break.

Ejercicio 4: tabla de valores con paso (incremento distinto de 1)

Genera una tabla para x desde 0 hasta 20, de 2 en 2, y calcula y = 3*x + 1. Usa for con actualización x += 2.

for (int x = 0; x <= 20; x += 2) {    int y = 3 * x + 1;    // imprimir x y y}

Traza manualmente las primeras 4 filas y la última para verificar el límite x <= 20.

Ejercicio 5: detectar y corregir errores típicos

Para cada fragmento, identifica el error (infinito, off-by-one o modificación accidental) y reescribe la versión correcta.

// A) ¿Qué pasa aquí?int i = 10;while (i >= 0) {    // ...    i = i + 1;}

// B) Se quiere recorrer 0..n-1, pero:for (int i = 0; i <= n; i++) {    // usar a[i]}

// C) Se quiere sumar 1..n:int suma = 0;for (int i = 1; i <= n; i++) {    suma += i;    i = i + 1;}

Consejo: en cada caso, traza 2 o 3 iteraciones para ver el patrón del error.