Contadores, acumuladores, conmutadores

(Este artículo forma parte del Curso de Programación en C)

Asociadas a los bucles se encuentran a menudo algunas variables auxiliares. Como siempre se utilizan de la misma manera, las llamamos con un nombre propio (contador, acumulador, etc.), pero hay que dejar claro que no son más que variables comunes, aunque se usan de un modo especial.

Contadores

Un contador es una variable (casi siempre de tipo entero) cuyo valor se incrementa o decrementa en cada repetición de un bucle. Es habitual llamar a esta variable “cont” (de contador) o “i” (de índice).

El contador suele usarse de este modo:

Primero se inicializa antes de que comience el bucle. Es decir, se le da un valor inicial. Por ejemplo:

 cont = 5

Segundo, se modifica dentro del cuerpo del bucle. Lo más habitual es que se incremente su valor en una unidad. Por ejemplo:

 cont = cont + 1

Esto quiere decir que el valor de la variable “cont” se incrementa en una unidad y es asignado de nuevo a la variable contador. Es decir, si cont valía 5 antes de esta instrucción, cont valdrá 6 después.

Otra forma típica del contador es:

 cont = cont – 1

En este caso, la variable se decrementa en una unidad; si cont valía 5 antes de la instrucción, tendremos que cont valdrá 4 después de su ejecución.

El incremento o decremento no tiene por qué ser de una unidad. La cantidad que haya que incrementar o decrementar vendrá dada por la naturaleza del problema.

Tercero, se utiliza en la condición de salida del bucle. Normalmente, se compara con el valor máximo (o mínimo) que debe alcanzar el contador para dejar de repetir las instrucciones del bucle.

Ejemplo: Escribir un algoritmo que escriba la tabla de multiplicar hasta el 100 de un número N introducido por el usuario

 algoritmo tabla_multiplicar
 variables
   cont es entero
   N es entero
 inicio
   leer (N)
   cont = 1
   mientras (cont <= 100) hacer
   inicio
     escribir (N * cont)
     cont = cont + 1
   fin
 fin

El uso de contadores es casi obligado en bucles “mientras” y “repetir” que deben ejecutarse un determinado número de veces. Recuerde que siempre hay que asignar al contador un valor inicial para la primera ejecución del bucle (cont = 1 en nuestro ejemplo) e ir incrementándolo (o decrementándolo, según el algoritmo) en cada repetición con una instrucción del tipo cont = cont + 1 en el cuerpo del bucle. De lo contrario habremos escrito un bucle infinito.

Por último, hay que prestar atención a la condición de salida, que debe estar asociada al valor del contador en la última repetición del bucle (en nuestro caso, 100). Mucho cuidado con el operador relacional (<, >, <=, >=, etc) que usemos, porque el bucle se puede ejecutar más o menos veces de lo previsto

Acumuladores

Las variables acumuladoras tienen la misión de almacenar resultados sucesivos, es decir, de acumular resultados, de ahí su nombre.

Las variables acumuladores también debe ser inicializadas. Si llamamos “acum” a un acumulador, escribiremos antes de iniciar el bucle algo como esto:

 acum = 0

Por supuesto, el valor inicial puede cambiar, dependiendo de la naturaleza del problema. Más tarde, en el cuerpo del bucle, la forma en la que nos la solemos encontrar es:

 acum = acum + N

…siendo N otra variable. Si esta instrucción va seguida de otras:

 acum = acum + M
 acum = acum + P

… estaremos acumulando en la variable “acum” los valores de las variables M, N, P, etc, lo cual resulta a veces muy útil para resolver ciertos problemas repetitivos.

Ejemplo: Escribir un algoritmo que pida 10 números por el teclado y los sume, escribiendo el resultado

algoritmo sumar10
variables
   cont es entero
   suma es entero
   N es entero
 inicio
   suma = 0
   para cont desde 1 hasta 10 hacer
   inicio
     leer (N)
     suma = suma + N
   fin
   escribir (suma)
 fin

En este algoritmo, cont es una variable contador típica de bucle. Se ha usado un bucle “para”, que es lo más sencillo cuando conocemos previamente el número de repeticiones (10 en este caso). La variable Nsuma es el acumulador, donde se van sumando los diferentes valores que toma N en cada repetición. se usa para cada uno de los números introducidos por el teclado, y la variable

Observe como, al principio del algoritmo, se le asigna al acumulador el valor 0. Esta es una precaución importante que se debe tomar siempre porque el valor que tenga una variable que no haya sido usada antes es desconocido (no tiene por qué ser 0)

Conmutadores

Un conmutador (o interruptor) es una variable que sólo puede tomar dos valores. Pueden ser, por tanto, de tipo booleano, aunque también pueden usarse variables enteras o de tipo carácter.

La variable conmutador recibirá uno de los dos valores posibles antes de entrar en el bucle. Dentro del cuerpo del bucle, debe cambiarse ese valor bajo ciertas condiciones. Utilizando el conmuntador en la condición de salida del bucle, puede controlarse el número de repeticiones.

Ejemplo: Escribir un algoritmo que sume todos los números positivos introducidos por el usuario a través del teclado. Para terminar de introducir números, el usuario tecleará un número negativo.

 algoritmo sumar
 variables
   suma es entero
   N es entero
   terminar es lógico
 inicio
   suma = 0
   terminar = falso
   mientras (terminar == falso)
     inicio
       escribir ('Introduce un número (negativo para terminar)')
       leer (N)
       si (N >= 0) entonces
          suma = suma + N
       si_no
          terminar = verdadero
     fin
   fin
   escribir (suma)
 fin

Con este programa, el usuario puede ir introduciendo números indefinidamente, hasta que se canse. Para indicar al ordenador que ha terminado de introducir números, debe teclear un número negativo.

El bucle se controla por medio de la variable “terminar”: es el conmutador. Sólo puede tomar dos valores: “verdadero”, cuando el bucle debe terminar, y “falso”, cuando el bucle debe repetirse una vez más. Por lo tanto, “terminar” valdrá “falso” al principio, y sólo cambiará a “verdadero” cuando el usuario introduzca un número negativo.

A veces, el conmutador puede tomar más de dos valores. Entonces ya no se le debe llamar, estrictamente hablando, conmutador. Cuando la variable toma un determinado valor especial, el bucle termina. A ese “valor especial” se le suele denominar valor centinela.

Otro ejemplo: Escribir un algoritmo que sume todos los números positivos introducidos por el usuario a través del teclado. Para terminar de introducir números, el usuario tecleará un número negativo.

 algoritmo sumar
 variables
   suma es entero
   N es entero
 inicio
   suma = 0
   repetir
     inicio
       escribir ('Introduce un número (negativo para terminar)')
       leer (N)
       si (N >= 0) entonces
          suma = suma + N
     fin
   mientras que (N >= 0)
   escribir (suma)
 fin

Tenemos aquí un ejemplo de cómo no siempre es necesario usar contadores para terminar un bucle “mientras” (o “repetir”). Las repeticiones se controlan con la variable N, de modo que el bucle termina cuando N < 0. Ese es el valor centinela.