Bucle while en C++: sintaxis, do-while y errores comunes

Cuando no tienes un contador

El bucle for se construye en torno a un contador que defines de antemano. Pero hay muchos bucles que no tienen una cuenta clara: seguir leyendo números hasta que se acabe la entrada, seguir pidiendo una contraseña hasta que sea correcta, seguir dividiendo un valor por la mitad hasta que llegue a 1. Para esos casos, el bucle while encaja de forma natural: simplemente repite mientras una condición siga siendo verdadera.

Un bucle while comprueba su condición antes de cada pasada, incluida la primera. Si la condición es falsa de entrada, el cuerpo no se ejecuta nunca.

#include <iostream>
using namespace std;

int main() {
    int count = 3;

    while (count > 0) {
        cout << "Liftoff in " << count << "\n";
        count--;
    }

    cout << "Go!\n";
}

La condición count > 0 se comprueba primero; si es verdadera, el cuerpo se ejecuta, luego volvemos atrás y comprobamos de nuevo. La línea count-- es lo que acaba haciendo falsa la condición: quítala y el bucle se ejecutará para siempre.

La anatomía de un bucle while

Compáralo con el bucle for de tres partes que ya conoces. Un bucle while separa esas tres tareas: haces la inicialización antes del bucle, la condición va entre los paréntesis y la actualización vive dentro del cuerpo.

int i = 0;          // inicialización - antes del bucle
while (i < 5) {     // condición - se comprueba en cada pasada
    cout << i << "\n";
    i++;            // actualización - debes recordarla tú mismo
}

Esa última parte es el truco. En un bucle for la actualización está justo al lado de la condición, así que es difícil olvidarla. En un bucle while es solo otra instrucción más dentro del cuerpo: el error más común es omitirla y dejar el programa colgado.

Una trampa de C++ que pilla a los principiantes: un punto y coma perdido justo después de la condición convierte el cuerpo en una instrucción vacía.

int i = 0;
while (i < 5);   // <-- este punto y coma es todo el cuerpo del bucle
{
    cout << i << "\n";
    i++;
}

Eso da vueltas para siempre sin hacer nada, porque el ; es el cuerpo e i nunca cambia. El bloque entre llaves se ejecuta entonces exactamente una vez. El compilador no te detendrá: es código perfectamente legal, solo que no es lo que querías.

do-while: ejecutar el cuerpo al menos una vez

A veces necesitas que el cuerpo se ejecute una vez antes de poder siquiera decidir si repetir. El bucle do-while comprueba su condición al final, así que el cuerpo siempre se ejecuta al menos una vez:

#include <iostream>
using namespace std;

int main() {
    int number;

    do {
        cout << "Enter a positive number: ";
        cin >> number;
    } while (number <= 0);

    cout << "Thanks! You entered " << number << "\n";
}

Tienes que pedir y leer al menos una vez antes de poder saber si la entrada es válida, que es exactamente lo que te da do-while. Fíjate en el punto y coma después de while (...): en C++ es obligatorio para do-while, y olvidarlo es un error de compilación frecuente.

La diferencia con un while simple se ve claramente cuando la condición empieza siendo falsa:

#include <iostream>
using namespace std;

int main() {
    int x = 10;

    // while: condición falsa de entrada -> el cuerpo no se ejecuta nunca
    while (x < 5) {
        cout << "while body\n";
    }

    // do-while: se ejecuta una vez y LUEGO comprueba -> el cuerpo se ejecuta exactamente una vez
    do {
        cout << "do-while body\n";
    } while (x < 5);
}

Solo se imprime do-while body. El bucle while se salta su cuerpo por completo porque x < 5 era falso antes de la primera comprobación.

Repetir hasta que cin falle

Un uso clásico de while es leer hasta que la entrada se detenga: no hay contador, simplemente sigues hasta que el flujo te dice que pares. En C++, cin >> value se evalúa como el propio flujo, que es verdadero mientras la lectura tenga éxito y falso en cuanto llega al final de la entrada o a un tipo que no coincide. Eso lo convierte en una condición de bucle limpia:

#include <iostream>
using namespace std;

int main() {
    int value;
    int sum = 0;

    cout << "Enter numbers to add (Ctrl+D / non-number to finish):\n";

    while (cin >> value) {
        sum += value;
    }

    cout << "Total: " << sum << "\n";
}

La condición cumple una doble función: lee y comprueba en un solo paso. Compáralo con un valor centinela, por ejemplo, parar al recibir 0. Ahí debes leer una vez antes del bucle y otra vez al final de cada pasada para que la condición siempre evalúe una entrada nueva:

#include <iostream>
using namespace std;

int main() {
    int value;
    int sum = 0;

    cout << "Enter numbers to add (0 to finish):\n";
    cin >> value;

    while (value != 0) {
        sum += value;
        cin >> value;   // olvida esta línea y 'value' nunca cambia -> bucle infinito
    }

    cout << "Total: " << sum << "\n";
}

Si olvidas la segunda lectura dentro del cuerpo, value nunca cambia y tienes un bucle infinito. La forma while (cin >> value) esquiva eso al integrar la lectura en la condición.

break y continue en bucles while

break y continue funcionan aquí igual que en un bucle for. break sale del bucle de inmediato; continue salta directamente a la comprobación de la condición, saltándose el resto de la pasada actual:

#include <iostream>
using namespace std;

int main() {
    int n = 0;

    while (true) {                  // "bucle infinito" intencionado
        n++;
        if (n % 2 == 0) continue;   // saltar los números pares
        if (n > 9) break;           // parar una vez pasado el 9
        cout << n << " ";
    }
    cout << "\n";
}

Esto imprime 1 3 5 7 9. El while (true) deliberadamente nunca se detiene por sí solo: el break es la única salida. Ten cuidado con continue en un bucle while: como la actualización forma parte del cuerpo, saltar de vuelta al inicio con continue antes de haber avanzado el contador es una forma silenciosa de colgar el bucle. En el ejemplo anterior n++ se ejecuta primero, así que es seguro.

Cuidado con los bucles infinitos

La condición tiene que acabar volviéndose falsa, y eso depende por completo de que algo dentro del cuerpo cambie. Los dos culpables habituales son olvidar la actualización y actualizar de un modo que se salta el valor de salida:

int i = 0;
while (i < 5) {
    cout << i << "\n";   // i nunca cambia -> se ejecuta para siempre
}

int i = 0;
while (i != 10) {
    i += 3;   // 0, 3, 6, 9, 12... pasa de largo el 10 -> se ejecuta para siempre
}

El primero se cuelga porque i nunca se actualiza. El segundo se cuelga porque el contador se salta el valor exacto que busca la condición: prefiere < o <= antes que != cuando el paso pueda no caer justo. Un while (true) está bien si tiene un break garantizado; uno accidental no es más que un error. Y recuerda la trampa del cuerpo vacío while (...); de antes: un punto y coma mal puesto produce un bucle infinito que a primera vista parece correcto.

A continuación: el bucle for basado en rangos

Un bucle while es la herramienta adecuada cuando repites hasta que una condición cambia y no hay una cuenta clara. Pero cuando simplemente quieres recorrer todos los elementos de un contenedor (un vector, un array, una string) sin un índice ni una condición que gestionar, el C++ moderno tiene algo más limpio: el bucle for basado en rangos (for (auto x : container)). De eso trata la siguiente página.