Bucle for en C++: sintaxis, ejemplos y errores comunes

Por qué un bucle for

Un switch elige una rama para ejecutar una sola vez. Pero los programas reales necesitan hacer algo repetidamente: imprimir cada puntuación, sumar una lista de números, dibujar 10 filas de una cuadrícula. El bucle for es el caballo de batalla de C++ para repetir código un número conocido de veces, con un contador integrado que tú controlas.

Todo lo que un bucle for necesita vive en un encabezado compacto, por lo que toda la historia de "cuántas veces y cómo" queda visible de un vistazo.

El encabezado de tres partes

El encabezado de un bucle for tiene tres partes separadas por punto y coma: un inicializador, una condición y una actualización.

for (initializer; condition; update) {
    // cuerpo: se ejecuta mientras la condición sea verdadera
}

Se ejecutan en un orden específico: el inicializador se ejecuta una vez al principio; luego la condición se comprueba antes de cada iteración; el cuerpo se ejecuta solo si la condición es true; y la actualización se ejecuta al final de cada iteración, justo antes de que se vuelva a comprobar la condición.

#include <iostream>
using namespace std;

int main() {
    for (int i = 0; i < 5; i++) {
        cout << "i = " << i << "\n";
    }
    cout << "done\n";
}

Aquí int i = 0 se ejecuta una vez. Luego se comprueba i < 5: mientras se cumple, el cuerpo imprime e i++ incrementa el contador. Cuando i llega a 5 la condición es false, así que el bucle termina y se imprime done. El cuerpo se ejecuta exactamente 5 veces, con i tomando los valores 0 a 4.

Declarar el contador dentro del encabezado (int i = 0) mantiene a i con alcance limitado al bucle: no existe después de la llave de cierre, que es exactamente lo que quieres.

Contar hacia arriba, hacia abajo y por pasos

La parte de actualización no se limita a i++. Puedes contar hacia abajo, avanzar en cualquier cantidad o recorrer el índice de un array.

#include <iostream>
using namespace std;

int main() {
    // cuenta atrás
    for (int i = 5; i > 0; i--) {
        cout << i << " ";
    }
    cout << "liftoff\n";

    // avanza de 2 en 2 (números pares)
    for (int n = 0; n <= 10; n += 2) {
        cout << n << " ";
    }
    cout << "\n";
}

El primer bucle se ejecuta mientras i > 0, decrementando cada vez, así que imprime 5 4 3 2 1. El segundo suma 2 en cada pasada y usa <= 10 porque 10 es un valor que queremos incluir. Haz coincidir tu condición con tu actualización: contar hacia abajo va con > o >=, contar hacia arriba con < o <=.

Recorrer un array

El uso más común de un bucle de conteo es recorrer un array por índice. El contador hace las veces de la posición que lees.

#include <iostream>
using namespace std;

int main() {
    int scores[] = {88, 92, 75, 60, 100};
    int n = sizeof(scores) / sizeof(scores[0]);

    int total = 0;
    for (int i = 0; i < n; i++) {
        total += scores[i];
    }

    cout << "Sum: " << total << "\n";
    cout << "Average: " << total / n << "\n";
}

Observa que la condición es i < n, no i <= n. Un array de 5 elementos tiene índices válidos de 0 a 4; el índice 5 está más allá del final. Leer scores[5] es comportamiento indefinido: podría imprimir basura, fallar, o parecer que funciona y corromper memoria en silencio. El patrón i < n es el valor predeterminado seguro para cualquier array basado en cero.

Si solo necesitas los valores y no el índice, un for basado en rango es más limpio. Recurre al bucle indexado clásico cuando realmente necesites la posición.

break y continue

Dos palabras clave te permiten cambiar el flujo en mitad del bucle. break sale del bucle de inmediato; continue omite el resto de la iteración actual y salta a la actualización.

#include <iostream>
using namespace std;

int main() {
    // detente en el primer número divisible por 7
    for (int i = 1; i <= 100; i++) {
        if (i % 7 == 0) {
            cout << "First multiple of 7: " << i << "\n";
            break;
        }
    }

    // imprime solo los números impares, omitiendo los pares
    for (int i = 1; i <= 10; i++) {
        if (i % 2 == 0) {
            continue;
        }
        cout << i << " ";
    }
    cout << "\n";
}

El primer bucle se detiene en el momento en que encuentra 7 y nunca comprueba el resto. El segundo usa continue para omitir la impresión del cuerpo siempre que i sea par: la actualización i++ igual se ejecuta, así que el bucle sigue avanzando. Una trampa sutil: continue salta a la actualización, así que si alguna vez dependes de continue dentro de un bucle cuyo contador se actualiza dentro del cuerpo en lugar del encabezado, puedes saltarte esa actualización por accidente y dar vueltas para siempre.

Bucles anidados

Pon un for dentro de otro para trabajar con cuadrículas, tablas o pares. El bucle interno se ejecuta por completo en cada paso individual del bucle externo.

#include <iostream>
using namespace std;

int main() {
    for (int row = 1; row <= 3; row++) {
        for (int col = 1; col <= 3; col++) {
            cout << row * col << "\t";
        }
        cout << "\n";
    }
}

Esto imprime una cuadrícula de multiplicación de 3x3. El bucle externo fija una row, el bucle interno recorre cada col de esa fila, y luego un salto de línea cierra la fila. Da nombres distintos a los contadores (row/col, no i/i): reutilizar un nombre oculta el externo y produce errores desconcertantes. Vigila también el coste: anidar un bucle de n dentro de otro de n ejecuta el cuerpo n * n veces, lo que se acumula rápido.

Trampas comunes

Unas pocas trampas explican la mayoría de los errores de bucles for en C++:

• Desplazamiento por uno: i <= n con un tamaño basado en cero lee un elemento más allá del final. Usa i < n.
• Desbordamiento sin signo (underflow): contar hacia abajo con un tipo sin signo nunca llega a ser negativo. for (size_t i = n - 1; i >= 0; i--) se repite indefinidamente, porque i >= 0 siempre es verdadero para un valor sin signo: cuando i es 0, i-- da la vuelta a un número positivo enorme. Usa un int con signo para los conteos descendentes, o reescribe la condición.
• Modificar el contador dentro del cuerpo: cambiar i en el cuerpo además de en el encabezado hace que el conteo del bucle sea impredecible. Elige un solo sitio.

// BUG: infinite loop - unsigned i is never < 0
for (size_t i = n - 1; i >= 0; i--) {
    process(arr[i]);
}

Los contadores de punto flotante son otro peligro silencioso: for (double x = 0.0; x != 1.0; x += 0.1) puede que nunca alcance exactamente 1.0 porque 0.1 no se puede almacenar con precisión. Usa un conteo entero y calcula el valor dentro, o usa < en lugar de !=.

Siguiente: bucles while

El bucle for brilla cuando conoces el conteo de antemano. Pero a veces necesitas repetir hasta que una condición cambie (leer entrada hasta el fin de archivo, reintentar hasta tener éxito) sin un número fijo de pasos. Ese es el trabajo del bucle while, que reduce el encabezado a solo una condición. Es la siguiente página.