05_Joyanes_C++ 15/3/06 17:21 Página 77

CAPÍTULO 5

Estructuras
de control repetitivas
( while, for, do-while)
Introducción
En este capítulo se estudian las estructuras de control iterativas o repetitivas que realizan la iteración de acciones. C++ so-
porta tres tipos de estructuras de control: los bucles while, for y do–while. Estas estructuras de control o sentencias repeti-
tivas controlan el número de v eces que una sentencia o listas de sentencias se ejecutan.

5.1. La sentencia while

Un bucle while tiene una condición del bucle (expresión lógica) que controla la secuencia de repetición. La posición de esta
condición del bucle es delante del cuerpo del bucle y significa que un bucle while es un bucle pretest de modo que cuando se
ejecuta el mismo, se evalúa la condición antes de que se ejecute el cuerpo del b ucle.

falsa
condición
verdadera

sentencia (acción)

Figura 5.1. Diagrama del bucle while

Sintaxis
1 while (condición_bucle)
sentencia; cuerpo

77
05_Joyanes_C++ 15/3/06 17:21 Página 78

78 CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while)

2 while (condición_bucle)
{
sentencia-1;
sentencia-2;
.
. cuerpo
.
sentencia-n;
}

Las sentencias del cuerpo del b ucle se repiten mientras que la e xpresión lógica (condición del b ucle) sea v erdadera.
Cuando se evalúa la expresión lógica y resulta f alsa, se termina y se sale del bucle y se ejecuta la siguiente sentencia
de programa después de la sentencia while.

EJEMPLO 5.1. Bucle mientras para escribir de los números del 1 al 10. En cada iteración se escribe el símbolo ca-
rácter X, el contenido de x, se incrementa x en una unidad y se salta de línea. Comienza el bucle con el valor de x en 1
y se sale del bucle con el valor de x a 11, pero el último valor escrito es 10, ya que el incremento del valor de x en una
unidad se realiza después de haber sido escrito el valor de x.
int x = 1;

while ( x <= 10)

cout <<"X: " << x++ << endl;

EJEMPLO 5.2. Bucle infinito. El contador se inicializa a 1 (menor de 100) y como contador-- decrementa en 1 el
valor de contador en cada iteración, el valor del contador nunca llegará a valer 100, que es el valor necesario para
que la condición del bucle sea falsa.
int contador = 1;
while (contador < 100)
{
cout << contador << endl;
contador--; //decrementa en 1 contador
}

Bucles controlados por contadores

Son bucles en los cuales la variable de control contador se incrementa o decrementa en cada iteración en una cantidad cons-
tante. La variable de control contador se inicializa antes de comenzar el b ucle a un valor. Se comprueba el v alor de conta-
dor antes de que comience la repetición de cada b ucle, y en cada iteración o pasada se incrementa o decrementa en una can-
tidad constante.

EJEMPLO 5.3. La suma de la serie 1/2 + 1/3 + 1/4 + 1/5 + ... + 1/50 se realiza mediante el uso de un con-
tador n. Por cada valor de la variable contador n del rango 1 hasta 50 se ejecuta la sentencia de acumular en suma
el valor de 1/n. El fragmento de programa siguiente inicializa el acumulador suma a 0, el contador n a 1 posterior-
mente realiza la suma mediante el contador r eal n (obliga a que el cociente 1/n sea real) y presenta el resultado.
#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
05_Joyanes_C++ 15/3/06 17:21 Página 79

CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while) 79

float suma = 0, n = 1;

while (n <= 10)

{
// n es real para que el cociente 1/n sea en coma flotante
suma += 1 / n;
n++;
}
cout << suma ;
system("PAUSE");
return EXIT_SUCCESS;
}

El resultado de ejecución del programa anterior es: 2.92897

EJEMPLO 5.4. El bucle adecuado para resolver la tarea de sumar los enteros del intervalo 11..50, es un bucle con-
trolado por un contador n. Se inicializa el acumulador suma a 0. El contador enter o n se inicializa a 11, se incre-
menta en cada iter ación en una unidad hasta lle gar a 50. El contador n se acumula en el acumulador suma en cada
iteración del bucle while para los valores del rango comprendido entre 11 y 50.

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
int suma = 0, n = 11;

while (n <= 50)

{
suma = suma + n;
n++;
}
cout << suma ;
system("PAUSE");
return EXIT_SUCCESS;
}

La ejecución del programa anterior da como resultado: 1220.

Bucles controlados por centinelas

Un centinela es un valor definido y especificado que sirve para terminar el proceso del b ucle. Este valor debe ser elegido con
cuidado por el programador para que no sea un posible dato y además no afecte al normal funcionamiento del b ucle.

EJEMPLO 5.5. Leer las notas de un alumno usando como valor centinela par a la entrada de notas el valor de –1.
Se define una constante entera centinela con el valor de –1. En la variable nota se leen los datos de la entr ada. La
variable contador cuenta el número total de notas intr oducidas, y el acumulador suma contiene la suma total de las
notas introducidas. El bucle while está controlado por el valor de centinela. En cada iteración se incrementa el con-
tador de en una unidad, se lee una nueva nota y se acumula en suma. Obsérvese que la variable contador, siempre
contiene una unidad menos del número de datos que han sido intr oducidos.

#include <cstdlib>
#include <iostream>
using namespace std;
05_Joyanes_C++ 15/3/06 17:21 Página 80

80 CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while)

int main(int argc, char *argv[])

{
const int centinela = -1;
float nota, contador = 0, suma = 0;

cout << "Introduzca siguiente nota -1 centinela: ";

cin >> nota;
while (nota != centinela)
{
contador++;
suma += nota;
cout << "Introduzca la siguiente nota: -1 centinela: ";
cin >> nota;
} // fin de while
if (contador >0)
cout << "media = " << suma / contador << endl;
else
cout << " no hay notas ";
system("PAUSE");
return EXIT_SUCCESS;
}

Bucles controlados por indicadores (banderas)

Las variables tipo bool se utilizan como indicadores o banderas de estado. El valor del indicador se inicializa (normalmente
a false) antes de la entrada al bucle y se redefine (normalmente a true) cuando un suceso específico ocurre dentro del bucle.
Un bucle controlado por bandera-indicador se ejecuta hasta que se produce el suceso anticipado y se cambia el v alor del in-
dicador.

EJEMPLO 5.6. Se leen repetidamente caracteres del teclado y se detiene , cuando se introduce un dígito. Se def ine
una bandera digito_leido que se inicializa a false, y se cambia al valor de true cuando se lee un dígito. El b ucle
que resuelve el problema está controlado por la bander a digito_leido, y en cada iter ación solicita un carácter, se
lee en la variable car, y si es un dígito cambia el valor de la bander a. Al final del bucle se escribe el dígito leído.

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
char car;
bool digito_leido = false; // no se ha leído ningún dato

while (!digito_leido)
{
cout << "Introduzca un carácter dígito para salir del bucle :";
cin >> car;
digito_leido = (('0'<= car) && (car <= '9'));
} // fin de while
cout << car << " es el dígito leído" << endl;
system("PAUSE");
return EXIT_SUCCESS;
}
05_Joyanes_C++ 15/3/06 17:21 Página 81

CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while) 81

La sentencia break en los bucles

La sentencia break se utiliza, a veces, para realizar una terminación anormal del bucle. Dicho de otro modo, una terminación
antes de lo previsto. Su sintaxis es: break;

EJEMPLO 5.7. El siguiente código extrae y visualiza valores enteros de la entrada hasta que se encuentra un valor
entero especificado, previamente leído del teclado.
int Clave;
int Entrada_entera;

cin >> Clave;

while (cin >> Entrada_entera)
{
if (Entrada_entera != Clave)
cout << Entrada_entera << endl;
else
break;
} //Salida del bucle

5.2. Repetición: el bucle for

El bucle for es el más adecuado para implementar bucles controlados por contador que son bucles en los que un conjunto de
sentencias se ejecutan una vez por cada valor de un rango especificado, de acuerdo al algoritmo: por cada valor de una varia-
ble contador de un rango específ ico: ejecutar sentencias.

Sintaxis

for (Inicialización; CondiciónIteración; Incremento)

Sentencias;

El bucle for contiene las cuatro partes siguientes:

• La parte de Inicialización inicializa las variables de control del bucle.

• La parte de Condición de Iteración contiene una expresión lógica que hace que el bucle realice las iteraciones de las sen-
tencias.
• La parte de Incremento incrementa la variable o variables de control del bucle.
• Las Sentencias, acciones o sentencias que se ejecutarán por cada iteración del b ucle.

La sentencia for es equivalente al siguiente código while:

inicialización;
while (condiciónIteración)
{
sentencias del bucle for
incremento;
}

EJEMPLO 5.8. Bucle for ascendente que escribe los 5 primeros números naturales, su cuadrado y su cubo. Se ini-
cializa la variable enter a n a 1 y mientras el valor de n sea menor o igual a 5 se escribe el número n, su cuadrado y
su cubo. Posteriormente se incrementa en una unidad el valor de n.
#include <cstdlib>
#include <iostream>
using namespace std;
05_Joyanes_C++ 15/3/06 17:21 Página 82

82 CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while)

int main(int argc, char *argv[])

{
cout << "n n*n n*n*n" << endl;
for (int n = 1; n <= 5; n++)
cout << n << '\t' << n * n << '\t' << n * n* n <<endl;
system("PAUSE");
return EXIT_SUCCESS;
}

Resultados de ejecución:

EJEMPLO 5.9. Bucle for descendente que escribe números reales y su r aíz cuadrada. Se inicializa la variable n a
16. En cada iteración del bucle se decrementa n en 2.5. El bucle termina cuando n es menor que 1.

#include <cstdlib>
#include <iostream>
#include <math.h>
using namespace std;

int main(int argc, char *argv[])

{
float n;
cout << "n raiz(n)" << endl;
for (n = 16; n >= 1 ; n = n - 2.5)
cout << n << '\t' << sqrt (n) << endl;
system("PAUSE");
return EXIT_SUCCESS;
}

Resultados de ejecución:

EJEMPLO 5.10. Bucle for que no termina nunca. La salida del bucle se realiza con la sentencia break. Cuando se
v max 1
cumple la condición de salida del bucle. El ejemplo suma los vmax primeros términos de la serie Σ , siendo vmax
c=1 c * c

un dato de programa. En cada iteración se incrementa el contador c en una unidad, se acumula en suma el valor del
1 1
término de la serie . La condición if decide si hay que sumar el término a la serie o si hay que terminar
c*c c*c
mediante la ejecución de la sentencia break. El programa inicializa el contador c y el acumulador suma a 0 y en cada
iteración del bucle, cada vez que se suma un término a la serie pr esenta los valores del contador c y de la suma par-
cial del acumulador suma.
05_Joyanes_C++ 15/3/06 17:21 Página 83

CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while) 83

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
int c = 0;
float suma =0 ;
int vmax;
cout << "Cuantos terminos sumo de la serie ? ";
cin >> vmax;
for (;;) // bucle for que no termina nunca
{
if(c <= vmax) //test
{
c++; //incremento
suma +=1/(float)(c*c);
cout << c <<" "<< suma << endl;
}
else
break;
}
system("PAUSE");
return EXIT_SUCCESS;
}

Resultado de ejecución del programa anterior:

5.4. Repetición: el bucle do...while

La sentencia do-while se utiliza para especificar un bucle condicional que se ejecuta al menos una v ez.

Sintaxis Semántica

do
sentencia
Después de cada eje-
while (expresión) sentencia cución de sentencia se
evalúa expresión. Si es
verdadera se repite el
cuerpo del b ucle (seten-
cia). Si es f alsa, se ter-
verdadera
expresión mina el bucle y se ejecu-
ta la siguiente sentencia.
falsa

Figura 5.2. Diagrama de flujo de la sentencia do

05_Joyanes_C++ 15/3/06 17:21 Página 84

84 CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while)

EJEMPLO 5.11. Bucle que escribe las letras mayúsculas del alfabeto. Se inicializa la variable carácter car a 'A', y
mediante un bucle do while que termina cuando en car hay un carácter mayor que 'Z', se itera escribiendo el valor
de car e incrementando el valor de car en una unidad por lo que car toma el siguiente carácter del código ASCII.

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
char car = 'A';

do
{
cout <<car << ' ';
car ++;
} while (car <= 'Y');
system("PAUSE");
return EXIT_SUCCESS;
}

Resultado de la ejecución:

5.5. Comparación de bucles while, for y do–while

C++ proporciona tres sentencias para el control de b ucles: while, for y do–while. El bucle while se repite mientras la con-
dición de repetición del bucle sea verdadera; el bucle for se utiliza normalmente cuando el conteo esté implicado,o bien cuan-
do el número de iteraciones requeridas se puede determinar al principio de la ejecución del b ucle. El bucle do–while se eje-
cuta de un modo similar a while excepto que las sentencias del cuerpo del b ucle se ejecutan siempre al menos una v ez.

EJEMPLO 5.12. Se escriben los números 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, con un bucle while, con
un bucle for, y con un bucle do while en un mismo programa.

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
int num = 10;

while (num <= 100) //con bucle while

{
cout << num << " ";
num += 10;
}
cout << endl << endl; // con bucle for
for (num = 10;num <= 100;num += 10)
cout << num << " ";
cout << endl<< endl;
05_Joyanes_C++ 15/3/06 17:21 Página 85

CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while) 85

num = 10; //con bucle do while

do
{
cout << num << " ";
num += 10;
}
while (num <= 100);
system("PAUSE");
return EXIT_SUCCESS;
}

EJEMPLO 5.13. Leer un número entero positivo en un bucle do while y calcular su factorial, mediante un bucle for,
un bucle while y un bucle do while. (Nota: Factorial de n = n ∗ (n – 1) ∗ (n – 2) ∗ ... ∗ 2 ∗ 1).

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
int numero, i, factorial;

do
{
cout << "dame numero entero: ";
cin >> numero;
} while ( numero <= 0);
for( factorial = 1, i = 1; i <= numero; i++) //con bucle for
factorial *= i;
cout << factorial << endl;
factorial = 1; //con bucle while
i = 1;
while( i < numero)
{
i++;
factorial *= i ;
}
cout << factorial << endl;
factorial = 1; //con bucle do-while
i = 0 ;
do
{
i++;
factorial *= i;
} while(i < numero);
cout << factorial << endl;;
system("PAUSE");
return EXIT_SUCCESS;
}
05_Joyanes_C++ 15/3/06 17:21 Página 86

86 CAPÍTULO 5 Estructuras de control repetitivas ( while, for, do-while)

5.6. Bucles anidados

Los bucles anidados constan de un bucle externo con uno o más b ucles internos. Cada vez que se repite el b ucle externo, los
bucles internos iteran reevaluándose las componentes de control y ejecutándose las iteraciones requeridas.

EJEMPLO 5.14. El siguiente programa muestra dos bucles for anidados que presentan las tablas de multiplicar del
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, pero de forma inversa. Para cada valor de la variable n en el rango 1, 2, 3,
4, 5, 6, 7, 8, 9, 10, se ejecuta una orden de escritura y el bucle interno for controlado por la variable entera
m que toma los valores 10, 9, 8, 7, ..., 1, escribiendo en cada iteración los valores de n, m y su producto n * m.

#include <cstdlib>
#include <iostream>
using namespace std;

int main(int argc, char *argv[])

{
int n, m;

for (n = 1; n <= 10; n++)

{
cout << " tabla de multiplicar del " << n << endl;
for (m = 10; m >= 1; m--)
cout <<n << " veces " << m << " = " <<n * m << endl;
}
system("PAUSE");
return EXIT_SUCCESS;
}

EJERCICIOS
5.1. ¿Cuál es la salida del siguiente se gmento de programa?

for (int cuenta = 1; cuenta < 5; cuenta++)

cout << (2 * cuenta) << “ “;

5.2. ¿Cuál es la salida de los siguientes b ucles?

a) for (int n = 10; n > 0; n = n – 2)

{
cout << "Hola ";
cout << n << endl ;
}

b) for (double n = 2; n > 0; n = n - 0.5)

cout << m << " ";