Repetición controlada por contador

La repetición controlada por contador requiere:

1. El nombre de una variable de control (o contador del ciclo).
2. El valor inicial de la variable de control.
3. El incremento (o decremento) con el cual, cada vez que se termine un ciclo, la variable de control será modificada.
4. La condición que compruebe la existencia del valor final de la variable de control (es decir, si se debe o no seguir con el ciclo).

Considere el siguiente programa sencillo, que imprime los números de 1 a 7. 


/*****************************************************************/
/*                                                               */
/*   CASIO fx-9860G SDK Library                                  */
/*                                                               */
/*   File name : contador.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 */
int AddIn_main(int isAppli, unsigned short OptionNum)
{
    unsigned int key, contador = 1;                 /* inicialización*/ 
    char scontador[17];

    Bdisp_AllClr_DDVRAM();

    while (contador <= 7){                             /* Condición de repetición*/
        sprintf(scontador, "%d", contador);
        locate(1, contador); 
        Print((unsigned char*) scontador);
        ++contador;                                         /*incremento*/
    }
    
    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

La declaración

int contador = 1

le da nombre a la variable de control (contador), la declara como un entero, reserva espacio para la misma, y ajusta su valor inicial a 1. Esta declaración no es un enunciado ejecutable.

La declaración e inicialización de contador también podía haber sido hecha mediante los enunciados

int contador;

contador = 1;

La declaración no es ejecutable, pero la asignación si lo es. Se utilizarán ambos métodos para inicialización de variables. El enunciado

++contador;

incrementa en 1 el contador del ciclo, cada vez que este ciclo se ejecuta. La condición de continuación del ciclo existente en la estructura while prueba si el valor de la variable de control es menor o igual a 7 (el valor final en el cual la condición se hace verdadera). Note que el cuerpo de este while se ejecuta, aun cuando la variable de control llegue a 7. El ciclo se terminará cuando la variable de control exceda de 7 (es decir, contador se convierte en 8).

Los programadores de C por lo regular elaborarían el programa anterior de manera más concisa, inicializando contador a 0 y remplazando la estructura while con

while (++contador <= 7){
        sprintf(scontador, "%d", contador);
        locate(1, contador); 
        Print((unsigned char*) scontador);
    }

Este código ahorra un enunciado porque el incremento se efectúa de forma directa en la condición while, antes de que la condición sea probada. Para codificar de esta forma tan concisa y condensada, se requiere de algo de práctica.

Error

---

Dado que los valores en punto flotante pueden ser aproximados, el control de contador de ciclos con variables de punto flotante puede dar como resultado valores de contador no precisos y pruebas no exactas de terminación.

Práctica

---

Controlar el contador de ciclos con valores enteros.

Práctica

---

Hacer sangría en los enunciados en el cuerpo de cada estructura de control 

Práctica

---

Colocar.una línea en blanco antes y después de cada estructura de control principal, para que se destaque en el programa.

Práctica

---

Demasiados niveles anidados pueden dificultar la comprensión de un programa. Como regla general, procure evitar el uso de más de tres niveles de sangrías.

Práctica

---

La combinación de espaciamiento vertical antes y después de las estructuras de control y las sangrías de los cuerpos de las estructuras de control dentro de los encabezados de las estructuras de control, le da a los programas una apariencia bidimensional que mejora de manera significativa la legibilidad del programa.