Frecuentemente nos encontramos con situaciones en las que el número de

iteraciones que deseamos que ejecute el bucle es previsible y puede ser controlado
utilizando una variable de control. En estos casos la solución queda más clara si
utilizamos un tipo de bucle que permita conocer fácilmente qué variable se utiliza
para controlar cuando acaba la ejecución, y cómo va evolucionando.
La sentencia for puede ser vista como una construcción especializada de la
sentencia while presentada anteriormente, pero con una sintaxis diferente para
hacer más explícito los casos en los que la iteración está controlada por los valores
que toma una determinada variable de control, de tal forma que existe una clara
inicialización y una clara modificación (incremento) de la variable de control, hasta
llegar al caso final.
La sentencia for sigue el siguiente esquema:
Para utilizar adecuadamente la estructura for es necesario que el comportamiento
iterativo del bucle quede claramente especificado utilizando únicamente los tres
componentes (inicialización, condición de fin e incremento) de la cabecera de la
sentencia. De esta forma, el programador podrá conocer el comportamiento del
bucle sin necesidad de analizar el cuerpo del mismo. Así, nunca debemos modificar
la variable de control de un bucle for dentro del cuerpo del mismo.
A continuación un programa que toma como entrada un número n y muestra por pantalla la serie de
números 0 1 2 ...n.
#include <iostream>
using namespace std ;
int main ()
{
int n ;
cin >> n ;
for (int i = 0 ; i < n ; ++i)
{ cout << i << " " ;
}
// i NO es visible aquí cout << endl ;
}
El programa anterior también podría haber sido descrito en base a la sentencia while de la siguiente forma:
#include <iostream>
using namespace std ;
int main ()
{
int n ; cin >> n ;
int i = 0;
while (i < n)
{ cout << i << " " ;
++i;
}
// i SI es visible aquí cout << endl ;
}
Ambas soluciones son correctas y a primera vista puede parecer que de similar
claridad. Sin embargo, la primera solución es mejor que la segunda: en el primer
caso toda la información necesaria para analizar el comportamiento del bucle está
claramente localizable, mientras que en el segundo es necesario localizarla
estudiando cómo se inicializa la variable y cómo se incrementa. Aunque en este
ejemplo ello está claro, piense que en otras situaciones esta información puede
estar mucha más oculta y, por tanto, ser más difícil de obtener.
Al igual que ocurre con la sentencia for, esta sentencia puede ser vista como una
construcción especializada para determinadas situaciones que, aunque admiten una
solución en base a la sentencia while, presentan una solución más clara con do-
while.
En este caso, a diferencia de la sentencia while, en la que primero se evalúa la
expresión lógica y después, en caso de ser cierta, se ejecuta la secuencia de
sentencias, en la estructura do-while primero se ejecuta la secuencia de sentencias
y posteriormente se evalúa la expresión lógica y, si ésta es cierta, se repite el
proceso. En este caso, el flujo de ejecución alcanza la expresión lógica después de
ejecutar el cuerpo del bucle al menos una vez. Ello hace que se utilice para
situaciones en las que sabemos que siempre queremos que el cuerpo del bucle se
ejecute al menos una vez. Por ejemplo, si queremos diseñar un programa que lea un
número y se asegure de que es par, repitiendo la lectura en caso de no serlo,
podríamos hacer lo siguiente:
#include <iostream>
using namespace std;
int main ()
{
int num ;
do { cout << "Tecle un número par: " ;
cin >> num ; }
while ((num % 2) != 0) ;
cout << "El número par es " << num << endl ;
}
También sería posible obtener una versión alternativa de este programa haciendo uso de una sentencia while, de la
siguiente forma
#include <iostream>
using namespace std;
int main ()
{
int num ;
cout << "Tecle un número par: " ;
cin >> num ;
while ((num % 2) != 0){
cout << "Tecle un número par: " ; cin >> num ;
}
cout << "El número par es " << num << endl ;
}
Sin embargo, como puede observarse, la primera versión se adapta mejor al
problema a resolver. Si ya sabemos que el cuerpo del bucle se va a repetir al menos
una vez, ¿por qué no utilizar un tipo de sentencia de iteración que ya lo expresa? El
segundo programa se basa en sacar una iteración fuera del bucle y utilizar un tipo de
bucle que se repite cero o más veces. Aunque el comportamiento es equivalente, la
solución parece un poco forzada.
Realizar un programa que lea por teclado dos números y muestre por pantalla su
producto. Como queremos que este ejemplo nos sirva como ejemplo de estructuras
de iteración, supondremos que no es posible utilizar el operador de multiplicación
(*) directamente.
Realizar un programa para calcular el factorial de un número dado como entrada
(n! = 1 * 2 * ... * n).
Dados dos números tomados como entrada, mostrar por pantalla su división entera
(cociente y resto). De nuevo, en este programa evitaremos utilizar los operadores
predefinidos disponibles en C++ para ello (/ y %). En su lugar, aprovecharemos que
la división entera no es más que el resultado de una serie de restas sucesivas del
divisor al dividendo, hasta que no sea posible continuar. Nuestro programa
comprueba que el divisor no es cero, mostrando un mensaje de error en caso
contrario.