Ciclos
Es muy común encontrar en los programas operaciones que se
deben ejecutar un número repetido de veces en períodos más o menos espaciados.
Si bien las instrucciones son las mismas, los datos sobre los que operan
varían. A nuestro alrededor, encontramos problemas que
presentan esas características, por ejemplo: el cálculo de la
nota final de los estudiantes de Programación I, se realizará tantas veces como
alumnos hayan inscritos en dicha asignatura, el cálculo del salario de los
empleados de una empresa, etc. En
estos casos la solución que se diseñe para un solo grupo de
datos se debe repetir tantas veces como sea necesario (de acuerdo al número de
estudiantes y de empleados para los ejemplos anteriores).
Los cálculos simples o la manipulación de pequeños conjuntos de
datos se pueden realizar fácilmente a mano, pero las tareas grandes o
repetitivas son realizadas con mayor eficacia por
una computadora, ya que
estas están especialmente preparadas para ello.
Para repetir varias veces un proceso determinado
haremos uso de los ciclos repetitivos, a los cuales se les conoce con el nombre
de estructura repetitiva, estructura iterativa, lazo o bucle.
(Tomado de Los guiones de clase de Introducción a la Informática. Universidad de El
Salvador. Año 2005)
En C, podemos encontrar tres tipos de ciclos:
·
Entrada Asegurada (while)
·
Ciclo Controlado Por Contador (for)
·
Hacer Mientras (do.. while)
Este último, no está lógicamente estructurado, por tanto no haremos
mucho hincapié en él.
Funcionamiento de Un Ciclo
Un ciclo, funciona de la siguiente manera: Evalúa una condición de
resultar cierta, realiza una acción o bloque de acciones, luego vuelve a
evaluar la condición y si nuevamente resulta cierta, realiza la (s) acción
(es). Cuando la condición de cómo resultado falso, se sale del ciclo y continúa
con la ejecución normal del programa.
Acumulador:
Es una variable, que , como su nombre lo indica se encarga de acumular valores. Esto se
vuelve muy útil, por ejemplo, cuando queremos encontrar la suma de los números
del 0 al 9, en el acumulador, vamos guardando los valores de
dichas cifras. Puede ser tanto real como entera. Su valor inicial, en la
mayoría de los casos es cero.
Contador:
Es una variable de tipo entero, que nos ayuda, en el programa a
contabilizar el número de ejecuciones de una misma acción, de un grupo de
alumnos etc. Un acumulador tiene tres valores distintos:
·
Valor Inicial: es el valor con el cual iniciamos
nuestro contador. Generalmente es cero. Esta asignación puede hacerse cuando se
declara la variable.
·
Valor Final: después de la ejecución del ciclo, el
valor del contador, será distinto a su valor inicial, este puede ser mayo o
menor que el mismo, todo depende si fue una cuenta creciente o decreciente.
·
Valor de Cambio: Es el
valor Constante, en el cual se irá incrementando nuestro
contador, este puede ser positivo o negativo; es decir, si la cuanta se realiza
de manera ascendente o descendente.
NOTA: el lector no debe confundirse entre las variables tipo acumulador
y tipo contador, estas se diferencian unas de otras en que: los contadores, su
valor de cambio es una constante, ya que aumenta y disminuyen en el mismo
valor, mientras que los acumuladores su valor de cambio no es constante. Un
acumulador necesariamente lo inicializamos con cero (o al menos en la mayoría
de los casos). Un contador puede iniciar con cualquier valor.
Bandera:
Las variables tipo bandera son aquellas que sólo admiten dos valores:
cierto o falso, true o false, hombre o mujer... etc
Ciclo de Entrada Asegurada
La sintaxis es la siguiente:
while(condición)
Acción;
Funciona de la siguiente manera: primero evalúa la condición, si da como
resultado cierta realiza la acción, luego vuelve a evaluar la condición, si su resultado
es falso, se sale del ciclo y continúa con la ejecución del programa.
Hay que tener mucho cuidado, cuando trabajamos con ciclos, ya que
podemos caer en un ciclo infinito, es decir que nunca se sale de él. Lo cual no
es un error de sintaxis sino de lógica. Por lo cual en las acciones debemos
siempre colocar algo que haga que se modifique el resultado de la condición, lo
cual puede ser una bandera, un contador o un acumulador.
Ejemplo
Diseñe un Programa que imprima los primeros 10 números.
#include <stdio.h>
#include <conio.h>
main()
{
int i=1; /*Declaramos nuestro contador con su Valor Inicial*/
while(i<=10) /*Mientras i sea menor o igual a 10:*/
{
printf("%d\t", i);/*Imprimir el valor de i*/
i+=1;/*Aumentar el contador en 1*/
}
getch();
return 0;
}
Ciclo Controlado por contador.
En algunas ocasiones, sabemos a ciencia cierta
el número de veces que se tiene que repetir una misma acción o bloque de
acciones. Y para ello es que nos sirve, esta estructura. Su sintaxis es la
siguiente:
for( valor inicial; condición; incremento)
accion;
Donde:
Valor inicial: es el valor con el cual inicializamos nuestra variable de control.
Condición: si la cumple, ejecuta la acción o acciones e incrementa o
decrementa la variable de control, sino la cumple la condición, se sale del
ciclo.
Incremento; que puede ser positivo o negativo (decremento).
Ejemplo
Este programa mostrará en pantalla 0 1 2 3 4 5
#include<stdio.h>
#include<conio.h>
int main()
{
int x=0;
for(x=0;x<=5;x++)
{
printf("%d ",x);
}
getch();
}
Ciclo Do... while
Es te ciclo funciona de la siguiente manera, realiza la acción o
conjunto de acciones, luego evalúa una condición de resultar cierta vuelve a
realizar la/s accion/es. Cuando sea falsa, se sale del ciclo. Esta estructura,
no está lógicamente, estructurada, por ello, no hablaremos mucho, sin embargo
realizaremos un par de ejemplos, de este ciclo.
Formato :
do {
sentencia;
.
} while(<expL>);
La diferencia fundamental, entre el ciclo while y do...while, es que en
este ultimo, las sentencias se realizarán por lo menos una vez, en cambio, con
while, solo se cumplirán mientras se cumpla la condición, lo
cual puede ser nunca.
Ejemplo .
Programa que determina si un año es bisiesto o no. Y un año es bisiesto
si es múltiplo de cuatro, pero excluyendo aquellos que son múltiplos de 100
pero no de 400
#include <stdio.h>
#include <conio.h>
main()
{
int anio;
char respuesta;
printf("\n\n\nINICIO DEL PROGRAMA\n\n\n");
printf("\n\nEl programa te pide un anio y te dice exactamente si es
bisiesto o no");
do
{
/*ENTRADA DE DATOS*/
printf("\n\nIntroduzca un anio determinado ");
scanf("%d",&anio);
/*PROCESO Y SALIDA DE DATOS*/
if ((anio%4==0 &&
anio%100!=0)||(anio%400==0)) printf("\n\nEl anio es bisiesto");
else printf("\n\nEl anio no es
bisiesto");
printf("\n\nDesea introducir más datos\n\n");
respuesta=getch();
} while(respuesta=='S' || respuesta=='s');
printf("\n\n\nFIN DEL PROGRAMA\n\n\n");
}
SELECCIÓN MÚLTIPLE
Como su nombre lo indica, permite seleccionar entre varios caminos para
llegar al final. En este caso se pueden elegir un camino o acción a ejecutar de
entre varios posibles que se debe de evaluar, llamada selector. Sintaxis:
switch(selector)
{
case Etiqueta A:
Acción A;
break;
case Etiqueta B:
Acción B;
break;
case Etiqueta n:
Acción n;
break;
default:
Excepción;
break;
}
En donde:
Selector: Variables,
expresiones simples de tipo ordinal, (enteros y caracteres –int y char-)
Etiqueta: Tiene que ser del mismo tipo de datos de
selecto. Estas deber ser constantes únicas y diferentes de otras.
Excepción: Es opcional.
Ejemplo
Diseñe un programa en C, que dado un número del 1 al 3, muestre en
pantalla y en letras, el mismo número:
include
<stdio.h>
#include
<conio.h>
main()
{
int n;
printf("El N£mero es:\n");
scanf("%d",
&n);
switch(n)
{
case 0:
puts("Cero");
break;
case 1:
puts("Uno");
break;
case 2:
puts("Dos");
break;
case 3:
puts("Tres");
break;
default:
puts("Dato No valido");
break;
}
getch();
return 0;
}
