WHILE, FOR Y DO-WHILE

Una de las características de las computadoras que aumentan

considerablemente su potencia es su capacidad para ejecutar una
tarea muchas (repetidas) veces con gran velocidad, precisión y
fiabilidad.  
  
Las tareas repetitivas es algo que los humanos encontramos
difíciles y tediosas de realizar.  
  
En este capítulo se estudian las estructuras de control iterativas o
repetitivas que realizan la repetición o iteración de acciones.  
  
C soporta tres tipos de estructuras de control: los bucles  
o while,  
o for   
o do-while.  
Estas estructuras de control o sentencias repetitivas controlan el
número de veces que una sentencia o listas de sentencias se
ejecutan. 
  
  
LA SENTENCIA while  
  
Un bucle (ciclo) es cualquier construcción de programa que repite
una sentencia o secuencia de sentencias un número de veces. 
  
Cuerpo  del bucle 
La sentencia SIMPLE O COMPUESTA que se repiten en un bloque se
denomina cuerpo del bucle  
  
Iteración  del bucle. 
cada repetición del cuerpo del bucle se llama iteración del bucle.  
  
Las dos principales cuestiones de diseño en la construcción del
bucle son:  
o ¿Cuál es el cuerpo del bucle?  
o ¿Cuántas veces se iterará el cuerpo del bucle?  
  
Una  expresión lógica 
Un bucle while tiene una condición del bucle (una 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 bucle.  

  
La Figura.- representa el diagrama del bucle while. El diagrama
indica que la ejecución de la sentencia o sentencias expresadas
serepite mientras la condición del bucle
permanece verdadera ytermina cuando se hace falsa.  
  
También indica el diagrama anterior que la condición del bucle se
evalúa antes de que se ejecute el cuerpo del bucle y, por
consiguiente,  
o si esta condición es inicialmente falsa, el cuerpo del bucle
no se ejecutará. En otras palabras, el cuerpo de un bucle
while se ejecutará cero o más veces.  
  
While con sentencia simple  
 
While  (condición booleana)  sentencia simple   
  
Ej  
while (5<10)  
printf("hola");  Sentencia simple 
 
While con sentencia compuesta  
 
while (condición-bucle)  
{  
sentencia-1;  
sentencia -2 ; 
...  
sentencia -n ;  
} 
Continua.... 
 
Funcionamiento: al llegar a una sentencia while … el compilador  
1.  Evalúa la condición booleana 
2. Si el resultado es verdad ejecuta la(s) sentencia(s) 
3. Si el resultado es falso … no ejecuta nada y continua la
secuencia del programa 
  
Ejemplo /* visualizar n asteriscos */  
contador = O;   
n=10;                                // inicialización  
while (contador < n)                      //evalua la condición (0<10)? 
{  
printf (" * \n") ;  
contador++;                            //incrementa en 1 contador  
}                                                        //fin de while  
Continua... 
 _______________________________________ 
 
  
La variable que representa la condición del bucle se denomina
también variable de control del bucle debido a que su valor
determina si el cuerpo del bucle se repite.  
  
La variable de control del bucle debe ser:  
a. inicializada,  
b. comprobada,  
c. actualizada  
para que el cuerpo del bucle se ejecute adecuadamente.  
  
Cada etapa se resume así:  
a. Inicialización. Contador se establece a un valor inicial (se
inicializa a cero, aunque podría ser otro su valor  
b. Prueba/condición. Se comprueba el valor de contador
antes de que comience la repetición de cada bucle 
c. Actualización. Contador se actualiza (su valor se
incrementa en 1, mediante el operador ++) durante cada
iteración 
  
Si la variable de control no se actualiza el bucle se ejecutará
«siempre». Tal bucle se denomina bucle infinito.  
  
En otras palabras un bucle infinito (sin terminación) se producirá
cuando la condición del bucle permanece verdadera y no se hace
falsa en ninguna iteración.  
  
/* bucle infinito */  
contador = 1; 
 while (contador < 100)  
{  
printf ("%d \n', contador);  
contador- - ;                    //decrementa en 1 conductor  
} 
  
Ejemplo /* Bucle con while */  
  
#include <stdio.h> 
  
int main()  
{  
int contador = O;                                       /* inicializa la condición */  
while(contador < 5)                           /* condición de prueba */  
{  
contador ++;                                              /* cuerpo del bucle */  
printf ("contador: %d \n",contador) ;  
} 
printf("Termina Contador: %d \n",contador);  
return 0;  
}  
  
  
  
  
EL BUCLE
FOR_______________________________________ 
  
  
El bucle for de C ofrece más control sobre la inicialización y el
incremento de las variables de control del bucle.  
Además del bucle while, C proporciona otros dos tipos de bucles for
y do.  
  
El bucle for 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 variable-contador de un rango especifico:
ejecutar sentencias  
  
La sentencia for (bucle for) es un método para ejecutar un bloque
de sentencias un número fijo de veces.  
  
El bucle for se diferencia del bucle while en que las operaciones de
control del bucle se sitúan en un solo sitio: la cabecera de la
sentencia.  
  
Sintaxis  
for  ( Inicialización ;  Condición ;  Incremento)  sentencias ;  
  
Donde:  
a. Inicialización.- Inicializa la variable de control del bucle 
a. Debe ser tipo entero, (char)  
 b. Condición.- Expresión lógica que determina si las
sentencias se han de ejecutar mientras sea verdadera 
c. Incremento.-  Incrementa o decrementa la variable de
control del bucle   
d. Sentencias.-  sentencias a ejecutar en cada iteración del
bucle. 
a. Simples  
b. compuestas 
  
 ej. 
  
//imprime "hola 10 veces" 
 
for (i=0;i<10;i++) 
printf("hola!\n"); 
  
  
  
int i;  
for (i = 0;  i < 10; i++) 
{  
printf ("Hola !" ) ;  
printf("El valor del contador es =  %d\n", i +1) ;  
} 
  
  
#include <math.h> 
#include <stdio.h> 
#define M 15  
#define f(x) exp(2*x)-x  
  
int main()  
{  
int i;  
double x;  
for (i = 1; i <= M; i++); 
{ 
printf("Va1or de x: ");  
scanf ("%f",&x) ;  
printf ("f (%.f) = %f\n",x, f(x) ); 
}  
return 0;  
} 
  
  
  
Ejemplo de formato descendente  
int n;  
for (n = 10; n> 5; n--)  
printf("%d \t %d \n",n, n * n );  
  
La salida de este bucle es:  
10 100  
9 81  
8 64  
7 49  
6 36  
  
Suma de los 10 primeros números pares CON FOR  
Practica... 
  
#include  
  
int main()  
{ 
int n,  
suma = 0;  
for (n = 1; n <= 10; n++)  
{suma += 2*n; } 
printf('La suma de los 10 primeros números pares: %d",suma);  
return 0;  
}  
  
/*El bucle también lo podríamos haber diseñado con un
incremento de 2:  
for (n = 2; n <= 20; n+=2)  
suma += n; */ 
  
  
  
EL BUCLE do. .
.while____________________________________________
____ 
  
La sentencia do-while se utiliza para especificar un bucle
condicional que se ejecuta al menos una vez.  
  
Esta situación se suele dar en algunas circunstancias en las que se
ha de tener la seguridad de que una determinada acción se
ejecutará una o varias veces, pero al menos una vez.  
  
Sintaxis   
Acción (sentencia) a ejecutar al menos una vez Expresión lógica que
determina si la acción se repite /  
  
do  Sentencia  while (expresión)  
  
do sentencia while (expresión)  
 i. do comienza ejecutando la(s) sentencia(s).  
ii. a continuación Se evalúa  expresión.  
1. Si expresión es verdadera, entonces se repite la
ejecución de sentencia(s).  
2. Este proceso continúa hasta que expresión
es falsa.  
  
La semántica del bucle do se representa gráficamente: 
  

  
  
  
Ej.1  
Bucle para introducir un dígito.  
 
char digito, op; 
do  
{  
printf ("Introduzca un dígito (0-9) : ") ;  
fflush( stdin );  
scanf ("%c", &digito) ;  
printf("digito capturado =  %c\n",digito); 
printf("deseas continuar [s/n] = "); 
fflush( stdin ); //limpia el bufer  
scanf("%c",op); 
}  
while (op!= 'n'); 
  
Este bucle se realiza mientras se introduzcan dígitos y se termina
cuando se introduzca un carácter que no sea un dígito de '0'a '9'.  
  
ej. 2 
#include  
int main()  
{  
char opcion;  
do  
{ 
printf("Hola\n") ;  
printf("¿Desea otro tipo de saludo?\n") ;  
printf("Pulse s para si y n para no, ") ;  
printf ("y a continuación pulse intro: ");  
scanf ("%c", &opcion);  
} while (opcion == 's' II opcion == 'S') ;  
printf("adios");  
return O;  
} 
  
Una sentencia do-while es similar a una sentencia while excepto
que el cuerpo del bucle se ejecuta siempre al menos una vez  
  
Ejemplo  
#include<stdio.h> 
  
int main() 
{ 
    int x,y; 
    char op;   
        printf("que serie deseas = "); 
        fflush( stdin );  
        scanf("%i",&y); 
        x=y; 
        printf("\tserie del %i\n",y); 
        do   
        {  
            printf( "\t %d\n",y); 
            y=y+x; 
            printf("deseas ver el siguiente de la serie s/n] = ");  
            fflush(stdin);             //limpieza al buffer  
            scanf("%c",&op);  
        }   
        while (op=='s');  
    return 0; 
} 
  
Visualizar las potencias de 2 cuyos valores estén en el rango 1 a
1000.  
/* Realizado con do-while */  
  
potencia = 1;  
do  
{  
potencia =* 2;  
printf (“%d \n”,potencia) ;  
} while (potencia < 1000);  
  
PRACTICAS PARA EL PRIMER PARCIAL  
1. PROGRAMAS SECUENCIALES.- son aquellos programas  que
se ejecutan línea por línea hasta el final. Ej. calcular el área
de un triangulo.  
2. PROGRAMAS CON BIFURCACIÓN.- son los programas que
en sus sentencias cuentan al menos con una sentencia if o
switch.- calcular el área o el volumen de una figura
geométrica.   
3. PROGRAMAS CON SENTENCIAS ITERATIVAS O
REPETITIVAS.-son los programas que en sus sentencias
cuentan al menos con una sentencia for , while , o do-
while. .- calcular las tablas de multiplicar (for, while, do-
while)