Bitácora del desarrollo de mi clase de C++, en el que publicaré el material de la clase y recibiré comentarios y sugerencias de mis alumnos.

lunes, 12 de febrero de 2007

6.4. Estructura de repetición while y while anidados


Estructura de repetición while
Una estructura de repetición permite especificar que se repita una acción, mientras que una condición se mantenga verdadera. El enunciado o enunciados contenidos en la estructura de repetición while constituyen el cuerpo del while. El cuerpo de la estructura while puede ser un enunciado sencillo o un enunciado compuesto.

Ejemplo: deseamos obtener la primer potencia de 2 que sea mayor a 1000..
product = 2;
while (product (= 1000)
product = 2 * product;
printf(“La primer potencia de 2 mayor a 1000 es: %d\n”, product);

Este segmento de programa multiplicará 2 * 2 * 2 * ... hasta que el resultado (almacenado en la variable product sea mayor a 1000, una vez terminada la estructura de repetición while (ciclo) imprimirá el valor 1024, antes en cada pasada del ciclo product tomará los valores de 4, 8, 16, 32, 64, 128, 256, 512 y 1024, que hará que la condición sea falsa y el ciclo termine.

Formulación de algoritmos.

Ejemplo:

Una clase de diez alumnos hizo un examen. Las calificaciones (de 0 a 100) correspondientes a este examen están a su disposición. Determine el promedio de este exámen.

Lo que se necesita:
obtener de teclado las diez calificación
realizar el cálculo del promedio de las diez calificaciones
imprimir el resultado

Ya que conocemos el número de calificaciones que serán capturadas (10) necesitaremos una estructura de repetición que se ejecute 10 veces. Necesitaremos una variable que funcione como contador para esas 10 veces y una variable que vaya almacenando la sumatoria de las calificaciones capturadas.

La variable contador deberá ser iniciada en 1 la primera vez que se ejecute la petición de calificación y se vaya incrementando con cada calificación capturada. La variable donde almacenaremos la suma de las calificaciones deberá ser iniciada en 0 para ir sumando desde la primera hasta la calificación número 10.

El algoritmo en pseudocódigo sería:

Asignar 0 a total
Asignar 1 a contador
Mientras contador es menor o igual a 10
Introducir calificacion
Añadir calificación a total
Añadir uno a contador
Asignar a promedio total dividido entre 10
Imprimir el promedio

La solución escrita en lenguaje C es:

#include (stdio.h)
#include (conio.h)
main( )
{
int contador, calificacion, total, promedio;
/* Inicialización de variables*/
contador = 1;
total = 0;
/* captura y acumulación de las 10 calificaciones */
while (contador (= 10)
{
printf(“Introduzca calificación : “);
scanf(“%d”, &calificacion);
total = total + calificacion;
contador = contador + 1;
}
/*cálculo e impresión */
promedio = total / 10;
printf(“El promedio de clase es %d\n”, promedio);
getch ( );
return 0;
}

Hagamos ahora una variante al programa anterior. Que pueda obtener el promedio de un número no conocido de calificaciones. Esto nos obliga a programar un ciclo controlado no por un contador, sino por una variable que introduzca el usuario y que termine cuando tome cierto valor, una variable de tipo centinela.

En el ejemplo pediremos al usuario que termine introduciendo una calificación de -1.

#include (stdio.h)
#include (conio.h)
main( )
{
float promedio;
int contador, calificacion, total; total = 0;
contador = 0;
printf(“Introduzca una calificación o -1 para terminar: “);
scanf (“%d”, &calificacion);
while (calificacion != -1)
{
total = total + calificacion;
contador = contador + 1;
printf (“Introduzca una calificación o -1 para terminar: “);
scanf(“%d”, &calificacion);
}
if (contador != 0)
{
promedio = (float) total / contador;
printf ( “El promedio de clase es %.2f”, promedio”);
}
else
printf(“No se introdujeron calificaciones.\n”);
getch ( );
return 0;
}

Un nuevo tipo de dato es el float o número de punto flotante, que es un número que puede contener una parte entera, un punto decimal, una parte fraccionaria y una parte exponencial.en un rango desde 3.4 X 10-38 hasta 3.4 X 1038. En la línea: promedio = (float) total / contador; se está utilizando un operador (float) que genera una copia del entero total a su equivalente en decimal o en tipo float. En el enunciado printf ( “El promedio de clase es %.2f”, promedio”); se está utilizando una secuencia de escape de formato %.2f, que indica a printf la impresiòn de una expresión de tipo flotante con dos dígitos después del punto.

Operadores de asignación

C dispone de varios operadores de asignación para la abreviatura de las expresiones de asignación. Por ejemplo:

c = c + 4

puede ser abreviada utilizando el operador de asignación +=
c += 4

De manera general las asignaciones de tipo

variable = variable operador expresión;

pueden ser sustituidas por una expresión del tipo

variable operador= expresion;

donde operador puede ser cualquiera de los operadores binarios +, -, *, / ó %

Un ejemplo de cada operador se muestra en la siguiente tabla:
Tenemos las variables:

int c = 3, d = 5, e = 4, f = 6, g = 12;

Operador de asignación Asignación en el formato tradicional Asignación en el formato nuevo Valor asignado a la variable
+= c = c + 7 c += 7 10
-= d = d – 4 d -= 4 1
*= e = e * 5 e *= 5 20
/= f = f / 3 f /= 3 2
%= g = g % 9 g %= 9 3

Operadores de incremento y decremento
C también tiene el operador incremental unario, ++ y el operador decremental unario -- . Si una variable contador es incrementada en 1, el operador incremental puede ser utilizado en vez de las expresiones contador = contador + 1 o bien contador += 1 .Si los operadores incrementales o decrementales son colocados antes de una variable, se conocen como operadores de preincremento o de predecremento, respectivamente. Si los operadores de incremento o decremento se colocan después de una variable, se conocen como operadores de postincremento o de postdecremento respectivamente.

Estos operadores se resumen en la siguiente tabla:

Operador Expresión de muestra Explicación
++ ++a Se incrementa a en 1 y a continuación se utiliza el nuevo valor de a en la expresión en la cual resida.
++ a++ Utiliza el valor actual de a en la expresión en la cual reside a y después se incrementa a en 1.
-- --b Se decrementa b en 1 y a continuación se utiliza el nuevo valor de b en la expresión en la cual reside b.
-- b-- Se utiliza el valor actual de b en la expresión en la cual reside b y después se decrementa b en 1.

Para clarificar estos operadores se presenta un ejemplo en el cual se utiliza un operador preincremental y posteriormente se utiliza uno postincremental.

#include (stdio.h)
#include (conio.h)
main( )
{
int prueba;
prueba = 5;
printf(“%d\n”, prueba);
/* postincremental */
printf(“%d\n”, prueba++);
printf(“%d\n\n”, prueba);

prueba = 5;
printf(“%d\n”, prueba);
/* preincremental */
printf(“%d\n”, ++prueba);
printf(“%d\n”, prueba);
getch ( );
return 0;
}

De esta manera se tienen ya varias formas para incrementar una variable en uno.

contador = contador + 1;
contador += 1;
++ contador;
contador ++;

Es importante hacer notar que al incrementar o decrementar una variable en un enunciado por sí mismo, las formas de preincremento y postincremento tienen el mismo efecto. Es sólo cuando la variable aparece en el contexto de una expresión más grande que el preincrementar y postincrementar tiene efectos distintos. Sólo se puede utilizar un nombre simple de variable como operando de un operador de incremento o decremento, es decir no es correcto: ++ (x + 1)

Estructura de repetición do/while
La estructura de repetición do/while es similar a la estructura while. En la estructura while la condición de continuación de ciclo se prueba al principio del ciclo, antes de ejecutarse el cuerpo del mismo. La estructura do/while prueba la condición de continuación del ciclo, después de ejecutarse el cuerpo del ciclo, y por lo tanto, el cuerpo del ciclo se ejecutará por lo menos una vez. Cuando termina do/while, la ejecución continuará con el enunciado que aparezca dspués de la cláusula while. Nótese que en la estructura do/while no es necesario utilizar llaves, si en el cuerpo existe sólo un enunciado. Sin embargo, por lo regular las llaves se utilizan para evitar confusión entre las estructuras while y do/while. Un do/while sin llaves rodeando el cuerpo de un solo enunciado, aparece como:

do
enunciado;
while (condicion);

lo que podría ser motivo de confusión. La última línea while (condicion); pudiera ser confundida por una estructura while conteniendo un enunciado vacío. Por esta razón se acostumbra poner llaves en cualquier estructura do/while aunque el cuerpo del ciclo sólo contenga un enunciado de la siguiente forma:

do
{
enunciado;
} while (condicion);

Un ejemplo sencillo de esto es la captura validada de un entero positivo:

do
{
printf(“Introduzca un entero positivo: “);
scanf(“&d”, &num);
}
while (num<=0);

el segmento de programa pedirá una vez un entero positivo, y si no es así, insistirá hasta que el usuario introduzca un entero positivo.

Anteriormente se describió un programa que calcula el promedio de n calificaciones. Las calificaciones son introducidas y sumadas al total hasta que el usuario introduce una calificacion de -1, como valor de término:

#include (stdio.h)
#include (conio.h)
main( )
{
float promedio;
int contador, calificacion, total;
total = 0;
contador = 0;
printf(“Introduzca una calificación o -1 para terminar: “);
scanf (“%d”, &calificacion);
while (calificacion != -1)
{
total = total + calificacion;
contador = contador + 1;
printf (“Introduzca una calificación o -1 para terminar: “);
scanf(“%d”, &calificacion);
}
if (contador != 0 )
{
promedio = (float) total / contador;
printf ( “El promedio de clase es %.2f”, promedio”);
}
else
printf(“No se introdujeron calificaciones.\n”);
return 0;
}

En este ejemplo la petición de calificación debe hacerse dos veces, una para una primer calificación y otra dentro del cuerpo del ciclo, este es un ejemplo claro de algo que se desea ejecutar por lo menos una vez, y dependiendo de los valores obtenidos en el cuerpo del ciclo se ejecutará o no más veces.

En este caso podemos utilizar una estructura do/while para ejecutar el cuerpo del ciclo al menos una vez, sin embargo será necesario evaluar si en esa primera ejecución no se dio la condición de fin de ciclo, es decir, se introdujo una calificación de -1.

#include (stdio.h)
#include (conio.h)
main( )
{
float promedio;
int contador, calificacion, total;
total = 0;
contador = 0;
do
{
printf (“Introduzca una calificación o -1 para terminar: “);
scanf(“%d”, &calificacion);
if (calificacion != -1)
{
total += calificacion;
contador++;
}
}
while (calificacion != -1)
if (contador != 0 )
{
promedio = (float) total / contador;
printf ( “El promedio de clase es %.2f”, promedio”);
}
else
printf(“No se introdujeron calificaciones.\n”);
getch ( );
return 0;
}

Ejemplos:
Hacer un programa que pida 10 números enteros y al final muestre la suma de todos los pares y la suma de todos los nones que se hayan introducido.

#include (stdio.h)
#include (conio.h)
main( )
{
int pares, nones, numero, contador;
contador = 0;
pares = 0;
nones = 0;
while (contador menor 10)
{
printf ( “Introduzca un número entero: “);
scanf(“%d”, &numero);
contador ++;
if (numero % 2 == 0)
pares ++;
else
nones ++;
}
printf (“La suma de los números pares es %d\n”, pares);
printf (“La suma de los números nones es %d\n”, nones);
getch ( );
return 0;
}

Un programa que calcule el factorial de un número entero cualquiera que el usuario introduzca.

#include (stdio.h)
#include (conio.h)
main( )
{
int numero, factorial, siguientevalor;
printf(“Introduzca un número entero: “);
scanf(“%d”, &numero);
siguientevalor = numero;
factorial = numero;
if (numero>0)
{
while (numero>1)
factorial *= (--numero);
printf(“El factorial es %d\n”, factorial);
}
else
printf(“No es posible obtener el factorial de un número menor o igual a cero.\n”);
getch ( );
return 0;
}

/*Ejemplo de sumar 15 números y separar el
total en unidades, decenas, etc.*/

#include (stdio.h)
#include (conio.h)
main( )
{
int numero, suma, i;
i=1;
suma=0;
while (i<=15)
{
prinf(“Introduzca un número”);
scanf(“%d”,&numero);
suma += numero;
i++;
}
printf(“La suma es %d\n”, suma);
divisor=10;
while (suma >= 0)
{
printf(“%d\n”, suma % divisor);
suma -= (suma % divisor);
divisor *= 10;
}
}

0 comentarios:

Publicar un comentario en la entrada

Suscribirse a Enviar comentarios [Atom]

<< Página principal