Estructuras De RepeticióN

PUEBLA III

Estructuras de repetición.

En la solución de algunos problemas es necesario ejecutar repetidas veces una instrucción o un conjunto de instrucciones. En
algunos casos, el número de repeticiones se conoce con anterioridad, mientras que en otras depende de cálculos o estados de
variables que se dan dentro de la solución del problema.
Para solucionar este tipo de problemas se utiliza un tipo de estructuras a las que se conocen como estructuras de repetición,
bucles o ciclos.
Un ciclo consiste en un grupo de acciones que se ejecutan repetidas veces dependiendo del cumplimiento de una condición.
Ciclo Mientras
Este ciclo consiste en un conjunto de instrucciones que se repiten mientras se cumpla una condición. De igual manera que en
los condicionales, la condición es evaluada y retorna un valor lógico, que puede ser verdadero o falso. En el caso del ciclo
mientras las instrucciones contenidas en la estructura de repetición se ejecutarán solamente si al evaluar la condición se
genera un valor verdadero; es decir, si la condición se cumple; en caso contrario, se ejecutará la instrucción que aparece
después de Fin mientras.
A diferencia de otros ciclos, el ciclo mientras comienza evaluando la expresión condicional, si el resultado es verdadero se
ejecutarán las instrucciones que estén entre el mientras y el fin mientras, al encontrarse la línea fin mientras se volverá a
evaluar la condición, si se cumple se ejecutarán nuevamente las instrucciones y así sucesivamente hasta que la condición deje
de cumplirse, en cuyo caso, el control del programa pasa a la línea que aparece después de fin mientras.
Ciclo Para
Este ciclo, al igual que los demás, permite ejecutar repetidas veces una instrucción o un grupo de ellas, pero a diferencia de
otras instrucciones de repetición, ésta maneja el valor inicial, el valor de incremento o decremento y el valor final de la variable
de control como parte de la instrucción.
Cuando al ejecutarse un algoritmo se encuentra una instrucción para la variable de control (contador) toma el valor inicial, se
verifica que el valor inicial no sobrepase el valor final y luego se ejecutan las instrucciones del ciclo. Al encontrar la instrucción
fin para, se produce el incremento y se vuelve a verificar que la variable de control no haya superado el límite admitido, y se
vuelven a ejecutar las instrucciones que están dentro del ciclo, y así sucesivamente tantas veces como sea necesario hasta
que se supere el valor final establecido.
El ciclo para termina en el momento en que la variable de control (contador) sobrepasa el valor final; es decir, que la igualdad
está permitida y las instrucciones se ejecutan cuando el contador es igual al valor final.

Estructuras de repetición en C.

La estructura switch permite elegir ejecutar diferentes códigos dependiendo de un valor.

switch (valor) {
case ‘1’: ejecuta esto si valor es 1
break;
break;
break;
default: ejecuta esto si valor no es ninguno de los anteriores
break;
};

Programación Básica

PUEBLA III

Cada case puede ejecutar múltiples líneas de código. Todos deben terminan con un break, que indica que debe seguirse
la ejecución del programa luego de ejecutar las líneas superiores. La ejecución continúa luego de la estructura switch. El
caso default se ejecuta si no hubo coincidencia entre el contenido de valor y los case superiores.

Un ejemplo del uso de la estructura switch en C:

int hijos;
printf(“Ingrese la cantidad de hijos que usted tiene: n”);
scanf(“%d”, &hijos);

switch (hijos) {
case ‘0’:
printf(“No le corresponde asignación familiar por hijon”);
break;
case ‘1’:
printf(“Le corresponden $50 de asignación familiar por su único hijon”);
break;
case ‘2’:
printf(“Le corresponden $70 de asignación familiar por sus dos hijosn”);
break;
default:
printf(“Le corresponden $100 de asignación familiar por tener más de dos hijosn”);
break;
};

Se define la variable del tipo entero hijos, se le pide al usuario que ingrese el número de hijos que posee y luego entra en
acción la estructura switch, actuando de diferentes formas dependiendo del valor de la variable hijos en tiempo de
ejecución.

La estructura while de repetición le permite al programador especificar las veces que se repita una acción mientras una
condición se mantenga verdadera. La forma del while es:

while (condición)
{
bloque de instrucciones
};

Mientras la condición se mantenga verdadera, se ejecutará X cantidad de veces el bloque de instrucciones dentro de las
llaves. Es necesario que alguna vez la condición se haga falsa, pues de lo contrario se entraría en un ciclo infinito de
repeticiones y el programa se consideraría bloqueado. Por lo tanto es necesario que en el bloque de instrucciones dentro
de la estructura while se ejecute alguna acción que en algún momento haga que la condición sea falsa.

Veamos un ejemplo para ver funcionar la estructura de repetición while:

int num;

num = 0;
while (num<=10)


PUEBLA III

{
printf(“Repetición numero %dn”, num);
num = num + 1;
};

El código anterior imprimirá en pantalla:

Repetición numero 0

¿Por qué? Vemos que iniciamos la variable del tipo entero num en cero. Luego, se evalúa por primera vez si es menor o
igual a 10, al ser verdadera, se ejecuta el bloque dentro del while por primera vez. Se imprime Repetición numero 0,
pues el valor dentro de num es cero. Luego el proceso se repite hasta que num con valor 10 se le suma 1, y toma el
valor 11. Se evalúa la condición del while y se determina que NO se cumple, por lo tanto, salta el bloque y sigue la
ejecución del programa.

La estructura for sirve para repetir un código dependiendo de un contador. Veamos un ejemplo:

int contador;

for (contador = 1; contador<=10; contador++)
{
printf(“Repetición numero %dn”, contador);
};

Primero se crea la variable contador de tipo entero (será la variable de control en el for). Luego se ejecuta la estructura
for iniciando la variable contador en 1. Luego se verifica que se cumple la condición contador<=10 y se ejecuta el
bloque dentro de la estructura, o sea, imprime en pantalla Repetición número 1.

Luego la variable contador es incrementada en uno con la expresión contador++ y el ciclo se inicia otra vez. La variable
contador ahora vale 2, por lo tanto se verifica la condición y se vuelve a ejecutar el código. Este proceso se ejecuta
hasta que contador toma el número 11 y la condición se hace falsa y no ejecuta el bloque.

Este código imprimirá en pantalla lo siguiente:



PUEBLA III


Las tres expresiones que componen la estructura for en C son opcionales, por lo tanto se pueden omitir en ciertos casos.
Si se omite la primera (la inicialización de la variable de control), significa que la variable se inicializa en otra parte del
programa. Si se omite la segunda expresión, la estructura for entraría en un ciclo infinito, lo cual es considerado un error.
Si se omite la tercera expresión significa que la variable de control es calculada dentro del bloque de for.

La tercera expresión puede ser tanto un incremento como un decremento en uno o más. También puede ser más
compleja agregando más instrucciones con el uso de la coma. Por ejemplo:

for (contador = 1; contador<=10; suma += contador, contador += 2)

Como vemos, la tercera expresión no sólo suma contador de dos en dos sino que además en cada repetición ejecuta la
operación suma += contador.

Esta estructura de repetición es similar a la estructura while. En while la condición para que se repita el bloque de
instrucciones se evalúa desde el principio del ciclo de repeticiones, en cambio, en la estructura do-while, al principio se
ejecuta el bloque y luego se evalúa la condición para ver si se sigue ejecutando o no. Esto significa que el bloque se
ejecutará por lo menos una vez.

La forma de esta estructura es:

do {
bloque de enunciados
} while (condición);

Veamos un ejemplo en donde se imprimen los números del 1 al 10 usando esta estructura. Al final también se imprime
en pantalla el valor contenido en la variable principal a fin de mostrar cuál es su valor final.

num = 1;
do {
printf(“%dn”, num);
num = num + 1;

} while (num<=10);

printf(“La variable num vale: %dn”, num);

Esto imprime en pantalla:

1
2
3
4
5


PUEBLA III

6
7
8
9
10
La variable num vale: 11

Los enunciados break y continue son utilizados para modificar el flujo de control dentro de un programa.

El break utilizado dentro de las estructuras de control causa la inmediata salida de dicha estructura (por lo tanto no sigue
repitiéndose el bloque y continúa la ejecución de las instrucciones que le siguen a la estructura de control).

Veamos un ejemplo del uso de break:

int num;

num = 1;
while (num <= 10)
{
if (num == 5)
{
break;
};

printf(“%d - ”, num);
num = num + 1;
};

El código anterior imprime:
1–2–3–4–

Lo que sucede es que cuando la variable num toma el valor 5, la condición del while se cumple, al ingresar al bloque se
evalúa en la estructura if si num es igual a 5 y se ejecuta el break saliendo del bloque while. Num termina valiendo 5
pues jamás se ejecuta la suma num = num + 1.

Por otra parte, el enunciado continue, dentro de las estructuras de repetición, al ser ejecutado salta las instrucciones
que siguen en el bloque y ejecuta la siguiente repetición en el ciclo. Veamos un ejemplo para aclarar el funcionamiento
de continue:

int num;

num = 0;
while (num <= 7)
{
num = num + 1;
if (num == 5) {
continue;
};


PUEBLA III

printf(“%d - ”, num);
};

El código anterior imprime en pantalla:

1–2–3–4–6–7

Como vemos, en una de las repeticiones se saltea la impresión del número 5.

Algunos programadores dicen que el uso del break y del continue dentro de las estructuras de control (excepto el break
en la estructura switch) viola las normas de la programación estructurada. Lo cierto es que no es necesario el uso de
break y continue si se utilizan las estructuras correctas

Los operadores lógicos se representan en un verdadero (true) o un falso (false) al usarse con números o variables,
estos eran:

== operador de igualdad en C
!= operador de desigualdad
> mayor
< menor
>= mayor o igual
<= menor o igual

Con estos se pueden construir expresiones sencillas como: numero <= 7, dependiendo del valor de la variable numero
esa expresión puede ser verdadera o falsa. Este tipo de expresiones se utilizan para las condiciones en las estructuras
de repetición y de selección.

Pero es posible construir expresiones más complejas utilizando otros operadores lógicos:
&& ( Y lógico)
// (O lógico)
! (NO lógico o negación lógica)

Veamos qué significan cada uno de ellos:

valor = (expresion1 && expresion2)
En este caso si expresion1 y expresion2 son verdaderas, valor resulta verdadero (true).
Si alguna o ambas de las expresiones son falsas, valor resulta en falso (false).

valor = (expresion1 // expresion2)
En este caso si ambas expresiones son verdaderas, valor resulta verdadero.
Si una de las expresiones es verdadera y la otra falsa, valor resulta verdadero.
Si las dos expresiones son falsas, valor resulta falso.

valor = (!expresion1)


PUEBLA III

En este caso si la expresión es verdadera, valor resulta falso.
Si la expresión es falsa, valor resulta falso.

Se puede usar && de la siguiente manera:
if (edad >= 12 && edad <= 20)
{
printf(“Usted es adolescente”);
}


Estructuras De RepeticióN

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Estructuras De RepeticióN

Estructuras De RepeticióN