Programación Estructurada

Práctica No. 5 Sentencias de iteración cíclicas.

Objetivo
El alumno generará programas que incluyan estructuras de iteración simples y anidadas en
lenguaje C.

Introducción teórica
Una de las características de las computadoras que aumentan considerablemente su potencia
es su capacidad para ejecutar una tarea muchas veces con gran velocidad, precisión y
fiabilidad. Las tareas repetitivas es algo que los humanos encontramos difíciles y tediosas de
realizar. En esta práctica se estudian las estructuras de control iterativas o repetitivas que
realizan la iteración de acciones. C y C++ soporta tres tipos de estructuras de control: los
bucles while, for y 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. La sentencia (o grupo de sentencias) que se repiten en un
bloque se denomina cuerpo del bucle y 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: ¿Cuál es el cuerpo del bucle? ¿Cuántas veces se iterará el cuerpo del bucle? Un bucle
while tienen 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.

Fig. 1 Diagrama de flujo de la sentencia “while”

Sintaxis
while(condición)
{
acción 1;
acción 2;
.
acción n;
}
El comportamiento o el funcionamiento de una sentencia while es:
1. Se evalúa la condición.
2. Si condición es verdadera:
a) La acción especificada, declarada en el cuerpo del bucle, se ejecuta.
b) Vuelve el control al paso 1.
3. En caso contrario: el control se transfiere a la sentencia siguiente.
Las sentencias del cuerpo del bucle se repiten while que la expresión lógica (condición) sea verdadera.
Cuando se evalúa la expresión lógica y resulta falsa, se termina y se sale del bucle y se ejecuta la
siguiente sentencia del programa después de la sentencia while.

/*Ejemplo 1*/
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
main()
{
int i=1;

while(i<=10)
{
printf("Hola mundo cruel y despiadado.!!!\n");
i++; //ó también así: i=i+1;
}
getchar( );
return 0;
}

Salida en pantalla:

/*Ejemplo 2*/
#include <stdio.h>
#include <stdlib.h>
main( )
{
int i,n;
printf("Cuantas veces deseas imprimir: ");
scanf(“%i”,&n);
i = 1;
while(i<=n)
{
printf("Bienvenido a la Programacion en C!!!",i);
printf"\n");
i++;
}
getchar( );
return 0;
}
Salida en pantalla:

La sentencia “for”
Además del bucle while, C y C++ proporciona otros dos tipos de bucle: for y do/while. El
bucle for es el más adecuado para implementar bucles controlados por contador que son
bucles en los que un grupo de sentencias se ejecutan una vez por cada valor de un rango
especificado, de acuerdo al algoritmo.
La sentencia 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 de bucle se sitúan
en un solo sitio: la cabecera de la sentencia.

for (inicialización; condición; incremento)

acción;

Fig. 2 Diagrama de flujo de la sentencia “while”

El bucle for contiene las siguientes partes:
1. Parte de inicialización: inicializa las variables de control del bucle.
2. Condición: Contiene una expresión lógica que hace que el bucle realice las iteraciones de las
sentencias, en tanto que la expresión se mantenga verdadera.
3. Parte de incremento: que incrementa o decrementa la variable de control del bucle.
4. Acciones: Acciones o sentencias que se ejecutarán por cada iteración del bucle.

/*Ejemplo 3*/
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
for(i=1;i<=10;i++)
printf("Hola mundo ingrato!!!\n");
getchar( );
return 0;
}
Salida en pantalla:

/*Ejemplo 4*/
#include<stdio.h>
#include<stdlib.h>
using namespace std;
main()
{
int i,n;
printf("Cuantas veces deseas imprimir: ");
scanf(“%i”,&n);
for(i=1;i<=n;i++)
printf("Hola mundo cruel!!!\n");
getchar( );
return 0;
}
Salida en pantalla:
El bucle “do-while”
La sentencia do--while se utiliza para especificar un bucle condicional que se ejecuta al menos una
vez aunque la condición que evalúa sea falsa. Esta situación 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 por
lo menos una vez.

Sintaxis
do
{
acción;
} while (condición);
La construcción do comienza ejecutando acción. Se evalúa a continuación condición. Si condición es
verdadera, entonces se
repite la ejecución de acción. Este proceso continúa hasta que condición sea falsa. La semántica del
bucle do se representa gráficamente en la siguiente figura 3:

Fig. 3 Diagrama de flujo de la sentencia “do--while”

/*Ejemplo 5*/
#include <stdio.h>
#include <stdlib.h>
main()
{
int i;
i = 1;
do
{
Printf("Hola mundo desquiciado!!!\n");
i++;
}while(i<=10);
getchar( );
return 0;
}
Salida en pantalla:
/*Ejemplo 6*/
#include <stdioo.h>
#include <stdlib.h>
main()
{
int i,n;
printf("Cuantas veces deseas imprimir: ");
scanf(“%i”,&n);
i = 1;
do
{
printf("Hola mundo desquiciado!!!\n");
i++;
}while(i <= n);
getchar( );
return 0;
}
Salida en pantalla:

Desarrollo Práctico

1. Realizar un programa que determine si un número introducido por pantalla es primo o no, se sugiere
utilizar el ciclo while y un if.
2. Hacer un programa en C que muestre en pantalla la tabla de multiplicar de un número introducido
por el usuario. El número a ingresar solo es permitido entre 1 y 9, si no, se muestra un mensaje de
error y termina el programa. A continuación se muestra parte del programa, es necesario completarlo.
//Programa que muestra tabla de multiplicar.
#include<stdio.h>
#include<stdlib.h>
#include<math>

main( ){
/*Numero para ver su tabla de multiplicar (TM)*/
“ “
/*Contador usado para generar TM del N anterior. */
 “ “
/* Valor de multiplicar contador por N */
“ “
printf("Ver tabla de multiplicar\n\n");
printf("Ingrese un numero entre 1 y 9:\t");
scanf(“%i”,&N);

if((N>=1)&&(N<=9)){
printf("Tabla de multiplicar del ",N);
/* La estructura for controla la cantidad de veces que se realizará la operación */
/* multiplicación.*/

“ “ {

“ “ /*Operación o proceso de multiplicación.*/

printf(“\n N x i es =%i”,mul); /*Mostrando la salida.*/

}/* Fin for i.*/

}else{
printf("\n\nError, numero incorrecto.!!!");
}/*fin if */
printf("\n");
getchar( );
return 0;
}

3. Escribe un programa que calcule la serie de ULAM para cualquier entero positivo.
/*Práctica */
#include <stdio.h>
#include <stdlib.h>
main()
{
int n,i;
printf("Teclea un numero: ");
scanf(“%i”,&n);
printf("Serie de ULAM:\n");

do
{
printf(“%d”,n);
if(n%2==0)
n=n/2;
else
n=(n*3)+1;
}while(n>1);
printf("\n");
getchar( );
return 0;
}
Salida en pantalla:
Cuestionario
Llene cada uno delos siguientes espacios en blanco.
1. La estructura de repetición ( ) especifica que un enunciado o grupo de enunciados debe ser
ejecutado de forma repetidamente, en tanto cierta condición se mantenga verdadera.
2. La repetición de un conjunto de instrucciones un número específico de veces, se conoce como
una repetición ( ).
3. Cuando no se conoce por anticipado cuantas veces debe repetirse un conjunto de enunciados, se
puede utilizar un valor ( ) para terminar la repetición.
4. La repetición controlada por contador también se conoce como repetición ( ), porque se sabe por
anticipado cuántas veces se ejecutará el ciclo.
5. La repetición controlada por centinela también se conoce como ( ), porque no se sabe con
anticipación cuántas veces se ejecutará el ciclo.
6. Investigar qué es la serie de ULAM.

Conclusiones Individuales.