La estructura de repetición for maneja de manera automática todos los detalles de la repetición controlada por contador. Para ilustrar los poderes de for, volvamos a escribir el programa anterior. El resultado se muestra a continuación.
/*****************************************************************/
/* */
/* CASIO fx-9860G SDK Library */
/* */
/* File name : estfor.c */
/* */
/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */
/* */
/*****************************************************************/
#include "fxlib.h"
#include "stdio.h"
//****************************************************************************
// AddIn_main (Sample program main function)
//
// param : isAppli : 1 = This application is launched by MAIN MENU.
// : 0 = This application is launched by a strip in eACT application.
//
// OptionNum : Strip number (0~3)
// (This parameter is only used when isAppli parameter is 0.)
//
// retval : 1 = No error / 0 = Error
//
//****************************************************************************
/* Repetición controlada por contador con la estructura for*/
int AddIn_main(int isAppli, unsigned short OptionNum)
{
unsigned int key, contador;
char scontador[17];
Bdisp_AllClr_DDVRAM();
/* Inicialización, condición de repetición, y incrmento*/
/* Todas ellas son incluidas en la estructura for */
for (contador = 1; contador <= 7; contador++){
sprintf(scontador, "%d", contador);
locate(1, contador);
Print((unsigned char*) scontador);
}
while(1){
GetKey(&key);
}
return 1;
}
//****************************************************************************
//************** ****************
//************** Notice! ****************
//************** ****************
//************** Please do not change the following source. ****************
//************** ****************
//****************************************************************************
#pragma section _BR_Size
unsigned long BR_Size;
#pragma section
#pragma section _TOP
//****************************************************************************
// InitializeSystem
//
// param : isAppli : 1 = Application / 0 = eActivity
// OptionNum : Option Number (only eActivity)
//
// retval : 1 = No error / 0 = Error
//
//****************************************************************************
int InitializeSystem(int isAppli, unsigned short OptionNum)
{
return INIT_ADDIN_APPLICATION(isAppli, OptionNum);
}
#pragma section
/*****************************************************************/
/* */
/* CASIO fx-9860G SDK Library */
/* */
/* File name : estfor.c */
/* */
/* Copyright (c) 2006 CASIO COMPUTER CO., LTD. */
/* */
/*****************************************************************/
#include "fxlib.h"
#include "stdio.h"
//****************************************************************************
// AddIn_main (Sample program main function)
//
// param : isAppli : 1 = This application is launched by MAIN MENU.
// : 0 = This application is launched by a strip in eACT application.
//
// OptionNum : Strip number (0~3)
// (This parameter is only used when isAppli parameter is 0.)
//
// retval : 1 = No error / 0 = Error
//
//****************************************************************************
/* Repetición controlada por contador con la estructura for*/
int AddIn_main(int isAppli, unsigned short OptionNum)
{
unsigned int key, contador;
char scontador[17];
Bdisp_AllClr_DDVRAM();
/* Inicialización, condición de repetición, y incrmento*/
/* Todas ellas son incluidas en la estructura for */
for (contador = 1; contador <= 7; contador++){
sprintf(scontador, "%d", contador);
locate(1, contador);
Print((unsigned char*) scontador);
}
while(1){
GetKey(&key);
}
return 1;
}
//****************************************************************************
//************** ****************
//************** Notice! ****************
//************** ****************
//************** Please do not change the following source. ****************
//************** ****************
//****************************************************************************
#pragma section _BR_Size
unsigned long BR_Size;
#pragma section
#pragma section _TOP
//****************************************************************************
// InitializeSystem
//
// param : isAppli : 1 = Application / 0 = eActivity
// OptionNum : Option Number (only eActivity)
//
// retval : 1 = No error / 0 = Error
//
//****************************************************************************
int InitializeSystem(int isAppli, unsigned short OptionNum)
{
return INIT_ADDIN_APPLICATION(isAppli, OptionNum);
}
#pragma section
El programa funciona como sigue: cuando la estructura for inicia su ejecución, la variable de control contador se inicializa a 1. A continuación, se verifica la condición de continuación de ciclo contador <= 7. Dado que el valor inicial de contador es 1, se satisface esta condición, por lo que los enunciados sprintf, locate y Print (imprime el valor de contador, es decir 1) se ejecutan.
A continuación la variable de control contador es incrementada por la expresión contador++, y el ciclo empieza otra vez, con la prueba de continuación de ciclo. Dado que la variable de control ahora es igual a 2, el valor final aún no es excedido, y el programa por lo tanto ejecuta otra vez los enunciados sprintf, locate y Print. Este proceso continúa hasta que la variable de control contador es incrementada a su valor final de 8 lo que hará que falle la prueba de continuación de ciclo y termine la repetición. El programa continúa ejecutando el primer enunciado que encuentra después de la estructura for (en este caso, el enunciado while).
En la siguiente figura se analiza más de cerca la estructura for del programa. Advierta que la estructura for "lo hace todo" especifica cada uno de los elementos necesarios para la repetición controlada por contador con una variable de control. Si en el cuerpo del for existe más de un enunciado, se requerirán de llaves para definir el cuerpo del ciclo.
Note que el programa utiliza la condición de continuación de ciclo contador <= 7. Si el programador hubiera escrito en forma incorrecta contador < 7, entonces el ciclo sólo se hubiera ejecutado 6 veces. Este es un error común de lógica, conocido como un error de diferencia por uno.
Error
Usar un operador relacional incorrecto o usar un valor final incorrecto de un contador de ciclo, en la condición de una estructura while o for, puede causar errores de diferencia por uno.
Práctica
Usar el valor final en la condición de una estructura while o for y utilizar el operador relacional <= auxiliará a evitar errores de diferencia por uno. Para un ciclo que se utilice para imprimir los valores del 1 al 7, por ejemplo, la condición de confirmación de ciclo debería ser contador <= 7 en vez de contador < 8 o bien contador < 7.
El formato general de la estructura for es
for (expresión1; expresión2; expresión3)
enunciado
enunciado
donde expresión1 inicializa la variable de control de ciclo, expresión2 es la condición de continuación del ciclo, y expresión3 incrementa la variable de control. En la mayor parte de los casos, la estructura for puede representarse mediante una estructura equivalente while, como sigue:
expresión1;
while (expresión2) {
enunciado
expresión3;
enunciado
expresión3;
)
Existe una excepción para esta regla, misma que se analizará en post siguientes.
A menudo, expresión1 y expresión3 son expresiones en listas separadas por coma. Las comas se utilizan aquí como operadores coma, garantizando que las listas de expresiones se evalúen de izquierda a derecha. El valor y el tipo de una lista de expresiones separada por coma, es el valor y el tipo de la expresión más a la derecha de dicha lista. El operador coma es utilizado prácticamente sólo en estructuras for. Su uso principal es permitir al programador utilizar múltiples expresiones de inicialización y/o múltiples incrementos. Por ejemplo, en una sola estructura for pudieran existir dos variables de control que deban ser inicializadas e incrementadas.
Práctica
Coloque sólo expresiones que involucren las variables de control en las secciones de inicialización y de incremento de una estructura for. Las manipulaciones de las demás variables deberían de aparecer, ya sea antes del ciclo (si se ejecutan una vez, como los enunciados de inicialización) o dentro del cuerpo del ciclo (si se ejecutan una vez en cada repetición, como son los enunciados incrementales o decrementales).
Las tres expresiones de la estructura for son opcionales. Si se omite expresión2, C supondrá que la condición es verdadera, creando por lo tanto un ciclo infinito. También se puede omitir la expresió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 de ningún incremento. La expresión incremental en la estructura for actúa como un enunciado de C independiente, al final del cuerpo del for. Por lo tanto, las expresiones
contador = contador + 1
contador += 1
++contador
contador ++
son equivalentes todas ellas, en la porción incremental de la estructura for. Muchos programadores C prefieren la forma contador++, porque el incremento ocurre después de que se haya ejecutado el cuerpo del ciclo. Por lo tanto, la forma postincremental parece más natural. Dado que la variable que se postincrementa o se preincrementa aquí no aparece en una expresión, ambas formas de incremento surten el mismo efecto. Los dos puntos y comas en la estructura for son requeridos.
contador += 1
++contador
contador ++
son equivalentes todas ellas, en la porción incremental de la estructura for. Muchos programadores C prefieren la forma contador++, porque el incremento ocurre después de que se haya ejecutado el cuerpo del ciclo. Por lo tanto, la forma postincremental parece más natural. Dado que la variable que se postincrementa o se preincrementa aquí no aparece en una expresión, ambas formas de incremento surten el mismo efecto. Los dos puntos y comas en la estructura for son requeridos.
Error
Usar comas en vez de puntos y coma en un encabezado for.
Error
Colocar un punto y coma de inmediato a la derecha de un encabezado for hace del cuerpo de esta estructura for un enunciado vació. Por lo regular esto es un error lógico
No hay comentarios:
Publicar un comentario