La estructura de repetición for

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

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. 

Lo esencial de la repetición

Llegado a este punto, usted ya debería ya estar cómodo escribiendo programas en C simples pero completos. En los siguientes entradas al blog, estudiaremos con mayor detalle la repetición; se presentan estructuras adicionales de control de repetición, es decir, la estructura for y la estructura do/while. También se presenta la estructura de selección múltiple switch. Se analiza el enunciado break, para salir de inmediato y rápidamente de ciertas estructuras de control, así como el enunciado continue, para saltarse el resto del cuerpo de una estructura de repetición, continuando con la siguiente iteración del ciclo. La entradas siguientes del blog analizan operadores lógicos utilizados en la combinación de condiciones.

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. Hemos analizado dos procedimientos de repetición:

1. Repetición controlada por contador
2. Repetición controlada por centinela

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

Operadores incrementales y decrementales

C también tiene el operador incremental unario, ++, y el operador decremental unario -- que mostramos a continuación.

---

Operadores

Expresión de muestra

Explicación

---

++ ++ -- --

++a a++ --b b--

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 Se incrementa b en 1 y a contincuación se utiliza el nuevo valor de b en la expresión en la cual reside b Se utiliza el valor actual de b en la expresión en la cual reside b, y después se decrementa a b en 1

Si una variable c es incrementada en 1. el operador incremental + + puede ser utilizado en vez de las expresiones c = c + 1 o bien c += 1. Si los operadores incrementales o decrementales son colocados antes de una variable, se conocen como los operadores de preincremento o de predecremento, respectivamente. Si los operadores incrementales o decrementales se colocan después de una variable, se conocen como los operadores de postincremento o de postdecremento, respectivamente. El preincrementar (o predecrementar) una variable hace que la variable primero se incremente (o decremente) en 1, y a continuación el nuevo valor de la variable se utilizará en la expresión en la cual aparece. Si se postincrementa (o postdecrementa) la variable hace que el valor actual de la variable se utilice en la expresión en la cual aparece, y a continuación el valor de la variable se incrementará (o decrementará) en 1.

El siguiente programa demuestra la diferencia entre las versiones de preincremento y de postincremento del operador ++. Postincrementar la variable с hará que se incremente, después de su uso en el enunciado Print. Preincrementar la variable с hará que se incremente, antes de su uso en el enunciado Print.

Operadores de asignación

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

c = c + 3;

puede ser abreviado utilizando el operador de asignación += como 

c += 3;

El operador += añade el valor de la expresión, a la derecha del operador, al valor de la variable a la izquierda del operador, y almacena el resultado en la variable a la izquierda del operador. Cualquier enunciado de la forma

variable = variable operador expresión;

donde operador es uno de los operadores binarios +, -, *, / o %, pueden ser escritos de la forma

variable operador = expresión;

Por lo tanto la asignación c += 3 añade 3 a c. En la tabla siguiente aparecen los operadores de asignación aritméticos, con expresiones de muestra utilizando estos operadores y con explicaciones.

Cómo formular algoritmos con refinamiento descendente paso a paso: Estudio de caso 3 (estructuras de control anidadas)

Trabajemos otro problema completo. Volveremos a formular el algoritmo utilizando seudocódigo y refinamiento descendente paso a paso, y escribiremos el programa en C para calculadoras CASIO fx-9860G Series. Hemos visto que las estructuras de control pueden ser apiladas una encima de otra (en secuencia), de la misma forma que un niño apila bloques. En este estudio de caso veremos la única otra forma estructurada que en C pueden conectarse estructuras de control, es decir mediante el anidar una estructura de control dentro de otra.

Considere el siguiente enunciado de problema:

Una universidad ofrece un curso que prepara alumnos para el examen estatal de licenciatura para corredores de bienes raíces. El año pasado, varios de los alumnos que terminaron este curso hicieron el examen de licenciatura. Naturalmente, la universidad desea saber qué tan bien salieron sus alumnos en el examen. Se le ha pedido a usted que escriba un programa para resumir los resultados. Se le ha dado una lista de estos cinco alumnos. A continuación de cada nombre se ha escrito un 1 si el alumno pasó el examen y un 2 si no lo pasó.

Su programa deberá analizar los resultados del examen, como sigue:

Cómo formular algoritmos con refinamiento descendente paso a paso: Estudio del caso 2 (repetición controlada por centinela)

Generalicemos el problema de promedios de clase: considere el problema siguiente:

Desarrolle un programa de promedios de clase que pueda procesar un número arbitrario de notas, cada vez que se ejecute el programa.

En el primer ejemplo de promedio de clase (Estudio de caso 1), se sabía por anticipado el número de notas (5). En este ejemplo, no se da ninguna indicación de cuantas notas se tomarán. El programa debe ser capaz de procesar un número arbitrario de notas. ¿Cómo podrá el programa determinar cuándo parar la captura de notas? ¿Cuándo sabrá que debe calcular e imprimir el promedio de clase?

Una forma de resolver este problema es utilizar un valor especial llamado un valor centinela (también conocido como valor señal, un valor substituto, o un valor bandera) que indicará "fin de la captura de datos". El usuario escribirá notas hasta que haya capturado todas las notas. Entonces escribirá un valor centinela, a fin de indicar que ha sido introducida la última nota. La repetición controlada por centinela a menudo se llama repetición indefinida, porque antes de que se empiece a ejecutar el ciclo el número de repetición no es conocido.

Claramente, el valor centinela deberá ser seleccionado de tal forma que no se confunda con algún valor de entrada aceptable. Dado que normalmente las notas de un examen son enteros no negativos, para este problema, -1 resulta un valor centinela aceptable. Entonces, una ejecución del programa de promedios de clase pudiera procesar un flujo de entradas como 95, 96, 75, 74, y -1. El programa a continuación calcularía e imprimiría el promedio de clase para las notas 95, 96, 75, y 74 (-1 es el valor centinela y, por lo tanto, no debe entrar en el cálculo de promedio).