Estructuras de Repetición

Las estructuras de repetición las vamos a utilizar cuando deseemos que el programa realize cierto número de iteraciones, logrando así un código más pequeño y más estético. Existen las siguientes estructuras repetitivas:

• FOR (clic para ir a su sintaxis general)
• WHILE (clic para ir a su sintaxis general)
• DO-WHILE (clic para ir a su sintaxis general)
• BUCLES ANIDADOS (clic para ir a su sintaxis general)

-------------------------------------------------------------------------------------
Estructura de repetición FOR
La sintaxis de ésta estructura es la siguiente:

for (lista para inicializar;expresión;lista para alterar)
  instrucción;

Donde:

• lista para inicializar consiste en una sola instrucción que se usa para establecer el arranque (el valor inicial) de un conteo.
• expresión contiene el valor máximo o mínimo que puede tener el conteoy también va a determinar la estructura FOR.
• lista para alterar proporciona el valor de incremento que se suma o se resta al conteo cada vez que se ejecute esta estructura.

Un ejemplo claro de el uso de la estructura FOR sería el siguiente:

1. #include <iostream.h>
2.  
3. int main()
4.  {
5.    int cuenta;
6.  
7.   for (cuenta = 2; cuenta <= 20; cuenta = cuenta + 2)            
8.       // Cuando incializamos la estructura, el primer valor (cuenta =  2) indica que el conteo inicia desde ese valor, después observamos que indica que cuenta es menor o igual a 20, con esto indíca que el último valor al que se llegará será 20. Por último, observamos "cuenta = cuenta + 2" ésto indica que la lista para alterar va a ser que a lo que vale 'cuenta' se le sumará 2, después verifica si el valor es menor o igual que 20 y vuelve a hacer el incremento sumándole 2 al valor que antes generó.
9.    cout<<cuenta<<" ";
10.  
11. getch();
12.  }

Ver las estructuras de repetición.
-------------------------------------------------------------------------------------
Estructura de repetición WHILE
La sintaxis general de ésta estructura es la siguiente:

while (expresión)
instrucción;

La expresión dentro de los paréntesis es la condición se probará para determinar si se ejecuta la instrucción que sigue los paréntesis. La expresión se va a evaluar exáctamente como en la estructura selectiva IF-ELSE. Entonces si la expresión es verdadera, se procede a continuar con la instrucción.

Ahora bien, un ejemplo sobre el funcionamiento de esta estructura es el siguiente:

1. include <iostream.h>
2.  
3. int main();
4. {
5.  int i;
6.  
7. i = 10;                      // declaro que mi lista inicia desde 10
8.  while (i >= 1)
9. {
10.     cout<< i << " ";
11.     i--          // restar de 1 en 1.
12.  }
13.  
14. getch();
15.  
16. }

Ver las estructuras de repetición.
 -------------------------------------------------------------------------------------

Estructura de repetición DO-WHILE
La sintaxis general de ésta estructura es la siguiente:

do {
instrucción;
} while (expresión);      // Observese que finaliza con punto y coma.

Un ejemplo será el siguiente:

1. ~
2. ~
3. ~
4.  
5. main ()
6.  {
7.  int num;
8.  do
9.   {
10.     cout<<"INTRODUZCA UN NUMERO: \n";
11.     cin>>num;
12.      } while (num >= 10);  // en este caso, observamos que la estructura va a leer un numero que introduzcamos hasta que uno de ellos sea menor o igual que 10.
13. }

Ver las estructuras de repetición.
 -------------------------------------------------------------------------------------
Estructuras de  repetición anidadas.
Bueno, basándose en la aburrida teoría se puede hacer lo mismo que con los IF-ELSE ANIDADOS,  un ejemplo sobre éstos bucles anidados puede ser el siguiente, donde éste programa visualizará las primeras 4 potencias del 1 al 9:
#include <iostream.h>
main ( ) {
int i, j, k, temp;
cout << “ i 1^2 1^3 1^4 \n ” ;
for ( i = 1; i < 10; i++) { // sale del bucle
for ( j = 1; j < 5; j++) { // primer nivel de anidación
temp = 1;
for ( k = 0; k < j; k++) { // bucle más interno
temp = temp * i;
cout << temp;
}
cout << endl;
}
}


Ver las estructuras de repetición.