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.3. Estructura de repetición for y for anidados



Conceptos básicos de repetición
En temas anteriores se mencionaban tres tipos de estructuras de control de programa: estructura de secuencia, de decisión y de repetición, las cuales permiten tomar diferentes caminos en la ejecución de los programas o tomar varias veces el mismo camino.

La mayor parte de los programas incluyen repeticiones o ciclos. Un ciclo es un grupo de instrucciones que la computadora ejecuta en forma repetida, en tanto se conserve verdadera alguna condición de continuación del ciclo. Se han analizado dos procedimientos de repetición: controlada por contador y controlada por centinela.

La repetición controlada por contador se denomina repetición definida, porque con anticipación se sabe con exactitud cuántas veces se ejecutará el ciclo. La repetición controlada por centinela se denomina repetición indefinida, porque no se sabe con anticipación cuantas veces el se ejecutará el ciclo.

En la repetición controlada por contador se utiliza una variable de control para contar el número de repeticiones. La variable de control es incrementada cada vez que se ejecuta todo el conjunto de instrucciones. Cuando el valor de la variable de control indica que se ha ejecutado el número correcto de repeticiones, se termina el ciclo y la computadora continúa ejecutando el enunciado siguiente al de la estructura de repetición.

Los valores centinela se utilizan para controlar la repetición cuando es desconocido el número preciso de repeticiones y cuando el ciclo incluye enunciados que deben obtener datos cada vez que el ciclo se ejecuta. El valor centinela en este caso indica “fin de datos”. Las variables centinela deben ser diferentes a los elementos normales de datos.

Repetición controlada por cuentas
La repetición controlada por contador requiere:
El nombre de una variable de control (o contador)
El valor inicial de la variable de control.
El incremento o decremento con el que será modificada la variable de control cada vez que se termine un ciclo.
La condición o límite que compruebe la existencia del valor final de la variable de control.

En el programa:

#include (stdio.h)
#include (conio.h)
main()
{
int contador;
contador=1;
while (counter menor o igual a 10)
{
printf(“%d\n”, contador);
contador ++;
}
getch ( );
return 0;
}
Se declara la variable de control llamada contador como un entero, se le da un valor inicial de 1, se incrementa en 1 en cada “pasada” del ciclo., hasta llegar hacer falsa la condición (o llegar al límite) del ciclo (counter <= 10).
Estructura de repetición for
La estructura de repetición for maneja automáticamente todos los detalles de la repetición controlada por contador:

Sintaxis
for ( expresion1; expresion2; expresion3)
enunciado;

Primero se evalúa expresion1 (comunmente el inicio del ciclo o el valor inicial del contador), posteriormente se evalúa expresion2, y si es verdadera se ejecuta el o los enunciados dentro de la estructura, posteriormente se evalúa expresión3, en las siguientes pasadas la expresion1 no se evaluará, solamente la expresion2 y expresion3, mientras la expresion2 resulte verdadera el o los enunciados dentro del ciclo se estarán ejecutando.

Anteriormente se vio un ejemplo de cálculo de promedio de 10 calificaciones capturadas utilizando la estructura de repetición while.

#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 menor o igual a 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;
}
Este mismo programa lo podemos escribir utilizando la estructura for, ya que el número de ejecuciones del ciclo es conocido (se capturarán y acumularán 10 calificaciones).
#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 */
for (contador = 1; contador menor o igual a 10; contador ++)
{
printf(“Introduzca calificación : “);
scanf(“%d”, &calificacion);
total = total + calificacion;
}
/*cálculo e impresión */
promedio = total / 10;
printf(“El promedio de clase es %d\n”, promedio);
getch ( );
return 0;
}
Volviendo a la sintaxis de la estructura for
for ( expresion1; expresion2; expresion3)
enunciado;

Las tres expresiones de la estructura for son opcionales. Si se omite expresion2, C supondrá que la condición es verdadera, creando por lo tanto un ciclo infinito. También se puede omitir la exresión1, si la variable de control se inicializa en alguna otra parte del programa. La expresión3 podría también omitirse, si el incremento se calcula mediante enunciados en el cuerpo de la estructura for, o si no se requiere ningún incremento.

Ejemplos de estructura for:

Variar la variable de control de 1 a 100 en incrementos de 1.
for(i=1; i menor o igual a100; i++)
Variar la variable de control de 100 a 1 en incrementos de -1
for(i=100; i mayor o igua a 1; i--)
Variar la variable de control de 7 a 77 en pasos de 7.
for(i=7; i menor o igua a 77; i+=7)
Variar la variable de control de 20 a 2 en pasos de -2.
for(i=20; i mayor o igual a 2, i-=2)
Variar la variable de control a lo largo de la siguiente secuencia de valores: 2, 5, 8, 11, 14, 17, 20.
for(i=2; i menor o igual a 20, i+=3)
Variar la variable de control de acuerdo a la siguiente secuencia de valores: 99, 88, 77, 66, 55, 44, 33, 22, 11, 0.
for(i=99; i mayor o igual a 0, i-=11)

/* Programa que suma los números pares de 2 a 100 */
#include (stdio.h)
#include (conio.h)
main()
{
int sum=0, num;
for (num=2; num menor o igual 100; num+=2)
     sum+=num;
printf(“La suma es %d\n”, sum);
getch ();
return 0;
}

El programa anterior también puede escribirse de la siguiente manera:

/* Programa que suma los números pares de 2 a 100 */
#include (stdio.h)
#include (conio.h)
main( )
{
int sum=0, num;
for (num=2; num menor o igual100; sum+=num, num+=2);
printf(“La suma es %d\n”, sum);
getch ();
return 0;
}

Las diferencias con el primer ejemplo son: 1.- Dentro de la estructura for, en la tercera expresión aparte de hacer el incremento de la varable de control se está realizando también el incremento de la variable sum, es decir se está integrando un enunciado que antes pertenecía al cuerpo del ciclo como parte de la estructura. 2.- La estructura for tiene un ; (punto y coma) al final que indica que ahí termina el ciclo, es decir, no existe ningún enunciado como cuerpo del ciclo. Aunque es válido tener estructuras for semejantes, incluso con más de una variable de inicio, los programas resultan menos legibles y también se debe tener cuidado el orden de las expresiones.

En el ejemplo anterior si se escribe num+=2 antes de sum+=num, el primer incremento de sum será con 4 y no con 2 como ocurría en la primera presentación del mismo programa.

/*Programa que calcula el interés mensual de un depósito para presentar el saldo acumulado en base a un interés mensual de 5% y un depósito inicial de 1000 */
#include (stdio.h)
#include (conio.h)
main( )
{
int mes;
double deposito=1000, interes=0.05;
clrscr( );
printf(“%4s%10s\n”,”Mes”, “Depósito”);
for (mes=1; mes menor o igual a 12; mes++)
  {
   deposito *= (1+interes);
   printf(“%4d%10.2f\n”,mes,deposito);
  }
getch ();
return 0;
}

Ejemplo: Programa que muestra el resultado de las potencias de 11, 22, 33, 44, 55.

#include (stdio.h)
#include (conio.h)
main( )
{
int num, i;
long potencia;
clrscr();
for (num=1, num menor o igual a5; num++)
   {
    potencia=num;
    for (i=1, i menor o igual a num-1; i++)
        potencia *= num;
    printf(“La potencia de %d a la %d es %d\n”,num,num,potencia);
   }
getch ();
return 0;
}

En este caso el primer ciclo for lleva la variable num desde 1 hasta 5, para imprimir la cada número elevado a la misma potencia, es decir, la variable num toma la base de cada potencia. En el segundo ciclo (el mas interno o anidado), se realiza la multiplicación para cada base un número de veces igual al número menos 1, ya que el equivalente a la potencia 1 se obtiene al asignar el valor de num a la variable potencia.

0 comentarios:

Publicar un comentario

Suscribirse a Enviar comentarios [Atom]

<< Inicio