Los bucles en lenguaje C son estructuras de control que permiten repetir un determinado bloque de instrucciones varias veces. Son fundamentales en programación porque evitan tener que escribir el mismo código una y otra vez.

Por ejemplo, si queremos mostrar en pantalla los números del 1 al 10, podríamos escribir diez instrucciones printf(). Sin embargo, utilizando un bucle podemos conseguir el mismo resultado con unas pocas líneas de código.

En C existen principalmente tres estructuras de repetición: while, do while y for. Todas permiten repetir instrucciones, aunque cada una resulta especialmente apropiada para determinadas situaciones.

¿Qué es un bucle en C?

Un bucle, también denominado estructura de repetición, es una estructura que permite ejecutar varias veces un conjunto de instrucciones mientras se cumpla una determinada condición.

Un esquema sencillo sería:

Inicio
  ↓
Comprobar condición
  ↓
¿Se cumple?
 ┌───────┴───────┐
 Sí              No
 ↓                ↓
Ejecutar         Finalizar
instrucciones
 ↓
Actualizar contador
 ↓
Volver a comprobar

La condición determina si el programa debe continuar repitiendo las instrucciones.

Condición de un bucle

La condición es una expresión que determina si el bucle continúa o termina.

Por ejemplo:

contador <= 10

Mientras esta expresión sea verdadera, el programa puede continuar ejecutando el cuerpo del bucle.

Cuando pase a ser falsa, la repetición finalizará.

Podemos utilizar operadores de comparación como:

<
>
<=
>=
==
!=

Por ejemplo:

i < 10

significa que i debe ser menor que 10.

También podemos utilizar operadores lógicos para construir condiciones más complejas.

¿Qué es un contador?

Un contador es normalmente una variable que se modifica en cada repetición para controlar cuántas veces se ejecuta el bucle.

Un ejemplo muy habitual es:

int i;

y posteriormente:

i++;

El operador ++ incrementa el valor de la variable en una unidad.

Por ejemplo:

i = 1
i = 2
i = 3
i = 4
...

Gracias al contador podemos controlar cuándo debe terminar la repetición.

Es importante actualizar correctamente el contador. Si la condición nunca deja de cumplirse, podemos crear un bucle infinito.

El bucle while

La estructura while permite repetir un bloque de instrucciones mientras se cumpla una condición.

Su estructura básica es:

while (condicion) {
    instrucciones;
}

Por ejemplo:

#include <stdio.h>

int main() {
    int i = 1;

    while (i <= 10) {
        printf("%d\n", i);
        i++;
    }

    return 0;
}

El programa muestra:

1
2
3
4
5
6
7
8
9
10

El funcionamiento es sencillo:

i = 1
 ↓
¿i <= 10?
 ↓
Sí → mostrar i
 ↓
i++
 ↓
Volver a comprobar

Cuando i alcanza el valor 11, la condición i <= 10 deja de cumplirse y el bucle termina.

El bucle do while

El bucle do while es parecido a while, pero existe una diferencia importante: las instrucciones se ejecutan al menos una vez.

Su estructura es:

do {
    instrucciones;
} while (condicion);

Por ejemplo:

#include <stdio.h>

int main() {
    int i = 1;

    do {
        printf("%d\n", i);
        i++;
    } while (i <= 10);

    return 0;
}

El resultado será:

1
2
3
4
5
6
7
8
9
10

La diferencia se aprecia mejor cuando la condición inicialmente es falsa.

Por ejemplo:

int i = 20;

do {
    printf("%d\n", i);
} while (i <= 10);

Aunque 20 <= 10 sea falso, el programa mostrará una vez el número 20 porque el contenido del do se ejecuta antes de comprobar la condición.

Diferencia entre while y do while

La principal diferencia puede resumirse así:

Por ejemplo, while puede ser apropiado cuando solamente queremos ejecutar determinadas instrucciones si una condición se cumple desde el principio.

do while resulta útil cuando necesitamos que el bloque se ejecute al menos una vez.

El bucle for

El bucle for es especialmente útil cuando conocemos, o podemos establecer fácilmente, el número de repeticiones.

Su estructura habitual es:

for (inicializacion; condicion; incremento) {
    instrucciones;
}

Por ejemplo:

#include <stdio.h>

int main() {
    for (int i = 1; i <= 10; i++) {
        printf("%d\n", i);
    }

    return 0;
}

El resultado es:

1
2
3
4
5
6
7
8
9
10

En este caso tenemos tres partes:

for (int i = 1; i <= 10; i++)

Inicialización

int i = 1

Establece el valor inicial del contador.

Condición

i <= 10

Indica que el bucle continuará mientras i sea menor o igual que 10.

Incremento

i++

Aumenta el contador una unidad después de cada repetición.

Ejemplo sencillo con for

Podemos utilizar un for para mostrar los números pares del 2 al 20:

#include <stdio.h>

int main() {
    for (int i = 2; i <= 20; i += 2) {
        printf("%d\n", i);
    }

    return 0;
}

El resultado será:

2
4
6
8
10
12
14
16
18
20

En este caso el contador aumenta de dos en dos:

i += 2;

Contador y acumulador

No debemos confundir un contador con un acumulador.

El contador suele utilizarse para saber cuántas veces se ejecuta algo:

contador++;

Mientras que un acumulador se utiliza para ir sumando valores:

suma = suma + numero;

Por ejemplo:

#include <stdio.h>

int main() {
    int suma = 0;

    for (int i = 1; i <= 5; i++) {
        suma = suma + i;
    }

    printf("Suma: %d\n", suma);

    return 0;
}

El resultado será:

Suma: 15

Porque:

1 + 2 + 3 + 4 + 5 = 15

Tabla de multiplicar en C

Uno de los ejercicios clásicos para aprender bucles consiste en crear la tabla de multiplicar de un número.

Podemos pedir al usuario un número y utilizar un for para mostrar sus multiplicaciones del 1 al 10.

#include <stdio.h>

int main() {
    int numero;

    printf("Introduce un numero: ");
    scanf("%d", &numero);

    for (int i = 1; i <= 10; i++) {
        printf("%d x %d = %d\n", numero, i, numero * i);
    }

    return 0;
}

Si introducimos:

5

el programa mostrará:

5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

Aquí el contador i comienza en 1 y termina en 10.

La operación:

numero * i

calcula cada resultado de la tabla.

Tabla de multiplicar utilizando while

El mismo ejercicio puede realizarse utilizando while.

#include <stdio.h>

int main() {
    int numero;
    int i = 1;

    printf("Introduce un numero: ");
    scanf("%d", &numero);

    while (i <= 10) {
        printf("%d x %d = %d\n", numero, i, numero * i);
        i++;
    }

    return 0;
}

El resultado será el mismo.

La diferencia está principalmente en la forma de controlar el contador.

Con while tenemos que inicializar y modificar i de forma independiente:

int i = 1;

while (i <= 10) {
    ...
    i++;
}

Con for, estos elementos aparecen agrupados:

for (int i = 1; i <= 10; i++) {
    ...
}

Mostrar todas las tablas de multiplicar

También podemos utilizar dos bucles para mostrar las tablas del 1 al 10.

El primer bucle controla el número de la tabla y el segundo controla el multiplicador:

#include <stdio.h>

int main() {

    for (int tabla = 1; tabla <= 10; tabla++) {

        printf("\nTabla del %d\n", tabla);

        for (int i = 1; i <= 10; i++) {
            printf("%d x %d = %d\n", tabla, i, tabla * i);
        }
    }

    return 0;
}

Aquí tenemos un bucle dentro de otro bucle.

El primero:

for (int tabla = 1; tabla <= 10; tabla++)

controla las diferentes tablas.

El segundo:

for (int i = 1; i <= 10; i++)

controla las multiplicaciones de cada tabla.

Bucles anidados

Cuando colocamos un bucle dentro de otro hablamos de bucles anidados.

Por ejemplo:

for (int i = 1; i <= 3; i++) {

    for (int j = 1; j <= 3; j++) {
        printf("%d %d\n", i, j);
    }
}

El bucle interior se ejecuta completamente por cada repetición del bucle exterior.

Podemos representarlo así:

i = 1
 ├── j = 1
 ├── j = 2
 └── j = 3

i = 2
 ├── j = 1
 ├── j = 2
 └── j = 3

i = 3
 ├── j = 1
 ├── j = 2
 └── j = 3

Los bucles anidados son muy utilizados para trabajar con matrices, tablas y estructuras de datos bidimensionales.

Cómo evitar un bucle infinito

Uno de los errores más habituales al empezar a trabajar con bucles es crear accidentalmente una repetición que nunca termina.

Por ejemplo:

int i = 1;

while (i <= 10) {
    printf("%d\n", i);
}

Aquí falta:

i++;

Como i siempre conserva el valor 1, la condición:

i <= 10

siempre será verdadera.

El programa continuará ejecutando el bucle indefinidamente.

La solución sería:

int i = 1;

while (i <= 10) {
    printf("%d\n", i);
    i++;
}

Ahora el contador cambia en cada repetición y finalmente la condición será falsa.

break para salir de un bucle

C permite utilizar break para abandonar inmediatamente un bucle.

Por ejemplo:

#include <stdio.h>

int main() {

    for (int i = 1; i <= 10; i++) {

        if (i == 6) {
            break;
        }

        printf("%d\n", i);
    }

    return 0;
}

El resultado será:

1
2
3
4
5

Cuando i llega a 6, se ejecuta:

break;

y el bucle termina.

continue para saltar una repetición

También existe continue, que permite saltar el resto de la iteración actual y continuar con la siguiente.

Por ejemplo:

#include <stdio.h>

int main() {

    for (int i = 1; i <= 10; i++) {

        if (i == 5) {
            continue;
        }

        printf("%d\n", i);
    }

    return 0;
}

El resultado será:

1
2
3
4
6
7
8
9
10

El número 5 no se muestra porque continue hace que esa iteración continúe directamente con la siguiente.

¿Qué estructura de repetición debo utilizar?

No existe una única estructura que haya que utilizar siempre.

Podemos utilizar una regla sencilla:

for suele ser muy cómodo cuando conocemos el número de repeticiones:

for (int i = 1; i <= 10; i++) {
    ...
}

while resulta apropiado cuando la repetición depende de una condición y no sabemos necesariamente cuántas veces se ejecutará:

while (condicion) {
    ...
}

do while es útil cuando necesitamos ejecutar el bloque al menos una vez:

do {
    ...
} while (condicion);

Errores habituales con los bucles en C

Al aprender estructuras de repetición es frecuente cometer algunos errores.

Olvidar actualizar el contador

while (i <= 10) {
    printf("%d", i);
}

Puede provocar un bucle infinito.

Utilizar una condición incorrecta

Por ejemplo:

for (int i = 1; i >= 10; i++) {
    printf("%d", i);
}

El bucle no llegará a ejecutarse porque la condición inicial 1 >= 10 es falsa.

Confundir = con ==

En C:

=

es el operador de asignación.

Mientras que:

==

es el operador de comparación.

Por ejemplo:

i = 5;

asigna el valor 5.

En cambio:

i == 5

comprueba si i tiene el valor 5.

En resumen

Los bucles en C permiten repetir un conjunto de instrucciones sin tener que escribirlas varias veces.

Las tres estructuras principales son:

while
do while
for

Todas utilizan una condición para determinar cuándo debe finalizar la repetición.

El contador es una variable que normalmente cambia en cada iteración y permite controlar el número de repeticiones. En un bucle for, por ejemplo, podemos encontrar las tres partes fundamentales juntas:

for (int i = 1; i <= 10; i++) {
    ...
}

La inicialización establece el valor inicial, la condición determina si el bucle continúa y el incremento modifica el contador.

Un ejemplo clásico es la tabla de multiplicar, que puede construirse fácilmente mediante un for:

for (int i = 1; i <= 10; i++) {
    printf("%d x %d = %d\n", numero, i, numero * i);
}

Una vez comprendidos los bucles, resulta mucho más sencillo abordar programas que necesitan procesar listas de números, realizar cálculos repetitivos, recorrer matrices, generar tablas o trabajar con grandes cantidades de datos.