¿Qué son los bucles en C y cómo usarlos?

Bienvenidos, STEAMdiantes. Hoy vamos a multiplicar su productividad.

Imagina que eres un Ingeniero Civil y tienes que calcular la carga de soporte de 100 columnas idénticas. ¿Escribirías el cálculo 100 veces en tu código? Por supuesto que no. Escribes la fórmula una vez y le dices a la computadora: “Repite esto 100 veces”.

En programación, a esta repetición controlada se le llama bucle (o ciclo). Es una estructura que repite un bloque de código mientras se cumpla una condición específica.

En C, tenemos tres herramientas principales para esto: while, do-while y for. Cada una tiene su especialidad.

Bucle while (“mientras…”)

Es el bucle más instintivo. Su lógica es: “mientras la condición sea verdadera, sigue ejecutando el bloque”.

La característica clave es que pregunta antes de actuar. Si la condición es falsa desde el principio, el código de adentro nunca se ejecuta.

Sintaxis:

while (condicion) {
    // Código a repetir
    // IMPORTANTE: Algo aquí adentro debe cambiar la condición eventualmente
}

Ejemplo: llenado de un tanque:

int nivel_agua = 0;

// Mientras el nivel sea menor a 100 litros...
while (nivel_agua < 100) {
    printf("Nivel actual: %d. Llenando...\n", nivel_agua);
    nivel_agua += 10; // Incrementamos el nivel (Si olvidamos esto, el bucle es infinito)
}
printf("Tanque lleno.\n");

Bucle do-while (“hacer… hasta”)

Este es el hermano rebelde del while. Su lógica es: “haz el trabajo primero, y luego pregunta si debemos repetirlo”.

La diferencia crítica es que el do-while garantiza que el código se ejecutará al menos una vez, sin importar la condición.

Sintaxis (¡cuidado con el punto y coma final!):

do {
    // Código a ejecutar
} while (condicion); // <--- Este punto y coma es OBLIGATORIO

Ejemplo: validación de Entrada (Menús). Si le pides a un usuario que ingrese un valor positivo, primero debes dejar que lo ingrese (Hacer) y luego verificar si se equivocó (While).

int valor_presion;

do {
    printf("Ingrese presion del sistema (debe ser positiva): ");
    scanf("%d", &valor_presion); // Leemos el dato
} while (valor_presion <= 0); // Repetir SI el usuario puso 0 o negativos

printf("Presion valida ingresada: %d\n", valor_presion);

Bucle for (el contador de precisión)

Es el favorito de los ingenieros para iteraciones matemáticas o cuando sabemos exactamente cuántas veces queremos repetir algo (ej: recorrer un arreglo de 10 posiciones).

El for compacta toda la gestión del bucle en una sola línea.

Sintaxis: for (inicialización; condición; incremento)

1. Inicialización: se ejecuta una sola vez al principio (ej: i = 0).
2. Condición: se evalúa antes de cada vuelta. Si es falsa, termina (ej: i < 10).
3. Incremento: se ejecuta al final de cada vuelta (ej: i++).

Ejemplo: análisis de 5 muestras.

// "Para i empezando en 1; mientras i sea menor o igual a 5; incrementa i en 1"
for (int i = 1; i <= 5; i++) {
    printf("Analizando muestra numero: %d\n", i);
}

Control de emergencia para los bucles: break y continue

A veces necesitamos alterar el flujo normal del bucle.

• break (Freno de mano): Rompe el bucle inmediatamente y se sale de él. Útil para búsquedas (“Ya encontré el dato, deja de buscar”).
• continue (Saltar vuelta): Ignora el resto del código en esta vuelta y salta a la siguiente iteración. Útil para filtrar errores (“Este dato es ruido, ignóralo y ve al siguiente”).

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue; // Salta el 5, no imprime nada, va al 6
    }
    if (i == 8) {
        break; // Al llegar al 8, mata el bucle por completo.
    }
    printf("%d ", i);
}
// Salida: 0 1 2 3 4 6 7

Bucle infinito

Si olvidas actualizar la variable que controla la condición, o si escribes una condición que siempre es verdadera, crearás un agujero negro. El programa se “congelará” y nunca terminará.

// ¡PELIGRO!
while (nivel < 100) {
    printf("Llenando...");
    // Olvidamos subir el nivel (nivel += 10)
    // Esto imprimirá "Llenando..." para siempre hasta que fuerces el cierre.
}

Nota: en microcontroladores (como Arduino), a veces queremos un bucle infinito (void loop()) porque el robot nunca debe “terminar” su trabajo mientras tenga energía. Pero en software de PC, suele ser un error grave.

Práctica: calculadora de promedios

Vamos a Visual Studio. Crearemos un programa que pida al ingeniero cuántas mediciones va a ingresar, las sume todas usando un bucle, y calcule el promedio.

#include <stdio.h>

int main() {
    int total_mediciones;
    float medicion_actual;
    float suma_total = 0; // Importante inicializar en 0

    // 1. Preguntar cuántas veces vamos a iterar
    printf("¿Cuantas mediciones va a ingresar? ");
    scanf("%d", &total_mediciones);

    // 2. Bucle FOR para pedir los datos uno por uno
    for (int i = 1; i <= total_mediciones; i++) {
        printf("Ingrese valor de medicion #%d: ", i);
        scanf("%f", &medicion_actual);

        // Validación simple dentro del bucle
        if (medicion_actual < 0) {
            printf("  Error: Valor negativo ignorado.\n");
            i--; // Truco: Retrocedemos el contador para repetir esta vuelta
            continue; // Saltamos la suma
        }

        // Acumular la suma
        suma_total += medicion_actual; 
    }

    // 3. Calcular y mostrar promedio
    if (total_mediciones > 0) {
        float promedio = suma_total / total_mediciones;
        printf("\n--- RESULTADOS ---\n");
        printf("Suma total: %.2f\n", suma_total);
        printf("Promedio final: %.2f\n", promedio);
    }

    return 0;
}

Reto: ejecuta el código e ingresa un valor negativo. Observa cómo el continue y el truco de i– te obligan a reingresar el dato correctamente.

¡Ya dominas el flujo! Sabes tomar decisiones (if) y automatizar repeticiones (for). Pero, ¿qué pasa si queremos organizar ese código en bloques reutilizables para no tener todo amontonado en el main? En el siguiente artículo, aprenderemos la base de la programación modular.

Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Facebook o WhatsApp para más…
¡Hasta la próxima!