UNIDAD III ESTRUCUTRAS DE FLUJO PROGRAMÁTICO · 2016. 9. 26. · UNIDAD III ESTRUCUTRAS DE FLUJO...

UNIDAD III ESTRUCUTRAS DE FLUJO PROGRAMÁTICO

Autores: Alejandra Gutierrez Reyes - Enrique Martínez Roldán - Academia de Computación – Ingenieria Eléctrica ESIME Zacatenco IPN

5

3.1. Estructuras de Decisión

Control de Flujo Las sentencias estudiadas hasta ahora son ejecutadas una tras otra. El control de flujo de un lenguaje especifica el orden en el que se ejecuta cada sentencia. Las sentencias para controlar el flujo que podemos encontrar son:

Estructuras de decisión o selección Estructuras de repetición

En C el carácter (;) representa el fin de una instrucción y se puede agrupar un grupo de sentencias utilizando las llaves ({ }) y formar lo que se conoce como una instrucción compuesta. Las estructuras de decisión, como su nombre lo indica, son estructuras que se usan en caso tal de que un algoritmo tenga alguna pregunta o tenga que decidir sobre una operación cualquiera. Para realizar las condiciones, se debe repasar los operadores relacionales: igual (=), mayor que (>), menor que (<), mayor igual que (> =), menor igual que (<=) y diferente (<>) o (!=). Las condiciones se pueden realizar de la siguiente manera: variable contra variable:

si (salario = salario_neto) entonces variable contra constante:

si (salario > 5´000.000) entonces constante contra variable:

si (500.000 < salario_neto) entonces variable contra cálculo:

si (salario >= salario+aumento) entonces cálculo contra variable:

si (salario–aumento <= salario_neto) entonces constante contra cálculo:

si (450.000 != salario - dismin) entonces Las estructuras de decisión permiten seleccionar la próxima sentencia a ejecutarse sobre la base de una decisión (expresión lógica o variable lógica), los tipos de estructuras de decisión que podemos encontrar son:

Simple Ramificada

Las sentencias de decisión o también llamadas de control de flujo son estructuras de control que realizan una pregunta la cual retorna verdadero o falso (evalúa una condición) y selecciona la siguiente instrucción a ejecutar dependiendo la respuesta o resultado. Estas sentencias de decisión en lenguaje C, son conocidas como ciclo if (simple y anidado) y ciclo switch (simple y anidado), las cuales se abordarán un poco más adelante.



5

3.1.1. Simple En algún momento dentro de nuestros algoritmos, es preciso cambiar el flujo de ejecución de las instrucciones, es decir, el orden en que las instrucciones son ejecutadas. Muchas de las veces tenemos que tomar una decisión en cuanto a que se debe ejecutar basándonos en una respuesta de verdadero o falso (condicional). La ejecución de las instrucciones, incluyendo una estructura de control como el condicional funcionan de esta manera: Las estructuras de control simple es cuando sólo se requiere de una sola estructura o una sola pregunta. Su sintaxis es la palabra Si, seguida de una pregunta o condición (la cual va encerrada en medio de paréntesis), y por último si la condición es verdadera se ejecuta la siguiente sentencia que se encuentra después de la condición, o se ejecuta el bloque de sentencias que se encuentran después de la condición, siempre y cuando estén encerradas entre llaves. Sabemos que un bloque de sentencias forzosamente están encerradas entre llaves, y estas se ejecutan juntas dentro de un ciclo condicional, así como todo algoritmo tiene su fin, todas las estructuras de decisión terminan o tiene su fin, con la llave final del bloque de sentencias. Estructura de Selección if simple En medio de la estructura, solo se colocan las instrucciones, cálculos u operaciones que se deban desarrollar cuando la pregunta sea verdadera. Las demás operaciones van fuera de la estructura de decisión. Las instrucciones o cálculos se deben colocar un poco corridos hacia la derecha para identificar perfectamente donde empieza la estructura y donde termina, esto solo para darle vista y entendimiento a nuestro programa. Las instrucciones comienzan a ejecutarse de forma secuencial (en orden) y cuando se llega a una estructura condicional, la cual esta asociada a una condición, se decide que camino tomar dependiendo siempre del resultado de la condición siendo esta falsa o verdadera. Cuando se termina de ejecutar este bloque de instrucciones se reanuda la ejecución en la instrucción siguiente a la de la condicional. Por lo tanto una estructura de decisión simple es una condición, esta estructura evalúa la condición, luego: Si la condición es cierta entonces ejecuta el conjunto de sentencias definidas entre las llaves de dicha sentencia. Si la condición es falsa entonces no ejecuta el conjunto de sentencias definidas dentro de las llaves y entonces se salta todo el bloque y continúa en la siguiente instrucción inmediata de donde termina el ciclo condicional. Veremos la sintaxis del ciclo if dentro del lenguaje C. si (condición) entonces sentencia si (condición) entonces { sentencias } En el caso de la sintaxis anterior la diferencia entre ambas es el número de sentencias que se encuentra en el bloque de instrucciones, en la primera solo hay una sentencia por lo tanto, no hay necesidad de utilizar llaves que representan un bloque de instrucciones, y en la segunda hay mas de una instrucción por lo cual se requiere del uso de llaves, ya que sin ellas le estaremos diciendo al compilador que bajo esa condición solo realice una instrucción, y si hay un bloque de instrucciones se le indica al compilador que bajo esa condición realice todo lo que se encuentra entre llaves.



5

Por lo tanto, llamamos sentencias a un bloque de instrucciones en el cual se pueden introducir operaciones, cálculos, escritura y lectura de variables, etc. También pueden incluir condiciones, que entonces se les llamarían ciclos anidados, los cuales más adelante se verán a detalle. Una de las estructuras más simples del ciclo if es la siguiente: si (condición) sentencia if (condición) sentencia Ejemplos del ciclo de selección if simple if (x>0.0) printf(“x es positivo \n”); if (a<b) {b+=a;} Nota: Observe que cuando hay una sola instrucción a ejecutarse dentro del if, las llaves son opcionales.

Diagrama de flujo de la condición if simple

Figura 2. Diagrama de flujo ciclo if simple Algoritmo: si (x > 0.0) entonces escribir ( ‘ x es positivo ‘ ) fin_si si (a<b) entonces b ← b + a fin_si Cuando hay dos o más sentencias asociadas al if van encerradas entre llaves { }, como en el ejemplo siguiente: Segmento de Programa:

Si condición

acciones

falso

cierto



5

if (nota > 15) { eliminado++; printf(“Estudiante eliminado \n”); } Algoritmo: si (nota > 15) entonces eliminado ← eliminado + 1 escribir ( ‘ Estudiante eliminado ‘ ) fin_si Otro ejemplo simple del ciclo if if (x >= 0.0) { y += x; cont++; } Algoritmo: si ( x > 0.0 ) entonces y ← y + x cont ← cont + 1 fin_si Ejemplo en el que se piden tres números desde el teclado y el programa nos diga si la suma de dos de ellos; es igual al tercero de ellos, si se dieran estos números 5 3 2 el programa daría iguales, ya que la suma de dos de ellos (3 2) nos dan el tercero, si se dieran estos números 6 2 1 el programa daría distintos. Algoritmo: inicio declarar variables enteras A, B, C escribir ( ‘ Introduzca tres números enteros ‘ ) leer A, B, C si ( A + B = C ) entonces escribir ( ‘ Iguales ‘ ) fin_si si ( A + C = B ) entonces printf( ‘ Iguales ‘ ) fin_si si ( B + C = A ) entonces escribir ( ‘ Iguales ‘ ) fin_si si ((A + B != C) && (A + C != B) && (B + C != A)) entonces escribir ( ‘ Distintos ‘ ) fin_si pausa fin Programa: #include <stdio.h> #include <conio.h>



5

int main () { int A, B, C; printf(“Introduzca tres números enteros\n”); scanf(“%i %i %i”, &A, &B, &C); if (A + B == C) printf(“Iguales”); if (A + C == B) printf(“Iguales”); if (B + C == A) printf(“Iguales”); if ((A + B != C) && (A + C != B) && (B + C != A)) printf(“Distintos”); return 0; getch(); } Otros ejemplos de estructura de selección if simple serian: Algoritmo: Inicio declarar variables enteras edad limpiar pantalla escribir ( ‘ ¿Qué edad tienes? ‘ )

leer edad

si ( edad > 20 ) entonces escribir ( ‘ Eres mayor de edad ‘ ) fin_si pausa fin Programa:

#include <iostream.h> #include <stdio.h> void main()

{ int edad; clrscr(); printf("¿Qué edad tienes? \n");

scanf(“%d”,&edad);

if ( edad > 20 ) printf("Eres mayor de edad"); getch(); } En el caso que sigue se muestra una modificación del ciclo if, teniendo ahora más de una línea. Algoritmo: inicio declarar variables enteras edad limpiar pantalla



6

escribir ( ‘ ¿Qué edad tienes? ‘ )

leer edad

si ( edad > 20 ) entonces escribir ( ‘ Eres mayor de edad ‘ ) escribir ( ‘ Te estas volviendo viejo ‘ ) fin_si pausa fin Programa:

#include <iostream.h> #include <stdio.h> void main() { int edad; clrscr(); printf("¿Qué edad tienes? \n");

sacnf(“%d”,&edad);

if ( edad > 20 ) { printf("Eres mayor de edad"); printf("Te estas volviendo viejo "); } getch(); }

La diferencia entre estos dos programas se situa dentro del ciclo “ if “, cuando este tiene una sentencia y cuando tiene dos o más, que es cuando se abren y cierran llaves. Estructura de Selección if – else Ahora veremos el ciclo if – else, que es agregar una sentencia de (en caso contrario), o parte falsa de la sentencia.

La estructura if / else lo que hace es ejecutar una acción si el resultado de la evaluación de la expresión es verdadera y otra acción si el resultado de la evaluación es falsa.

La diferencia con utilizar sólo la estructura if es que si la expresión evaluada es verdadera sólo en ese caso se ejecuta una acción de otro modo se pasa de largo. En cambio en la estructura if / else si la expresión es falsa entonces se ejecuta otra acción.

En síntesis lo que hace esta estructura es realizar una acción si la expresión es verdadera y otra si es falsa.

Su sintaxis sería:

if (condición) { Serie de sentencias 1 //parte verdadera } else { Serie de sentencias 2 //parte falsa }



6

Que se lee, si la condición es verdadera realiza (la serie de sentencias 1), pero si la condición fuera falsa; entonces, realiza (la serie de sentencias 2). La estructura condicional if...else es la que nos elegir entre dos caminos dependiendo de la condición. Traducida literalmente del inglés, se la podría llamar la estructura "si...si no", es decir, "si se cumple la condición, haz esto, y si no, haz esto otro". Aquí se muestra un segmento de programa con el ciclo if – else, muy sencillo para poder entender esta definición y su sintaxis. Algoritmo: declarar variables enteras edad escribir ( ‘ Dame tu edad por favor ‘ )

leer ( edad )

si ( edad < 18 ) entonces escribir ( ‘ no puedes acceder, eres menor de edad ‘ ) si_no escribir ( ‘ Bienvenido acceso permitido ‘ ) fin_si Programa: int edad; printf(“ Dame tu edad por favor \n”); scanf(“%d”, &edad); if (edad < 18) printf("No puedes acceder, eres menor de edad \n"); else printf("Bienvenido acceso permitido \n");

Esta estructura de toma de decisión tiene un diagrama de flujo como el siguiente:

Diagrama de flujo ciclo if-else

Figura 3. Ciclo if-else

Aquí tenemos un ejemplo para ilustrar la estructura if / else.

INICIO

FIN

LEER N

N = 1 PROCESO BPROCESO A

SALIDA

SINO



6

Algoritmo:

Inicio limpiar pantalla declarar variables entera edad if ( edad > 20 ) entonces escribir ( ‘ Eres mayor de edad ‘ ) else escribir ( ‘ No eres mayor de edad ´) fin_si pausa fin Programa: #include <stdio.h> #include <conio.h> void main() { int edad; clrscr(); if ( edad > 20 ) printf("Eres mayor de edad"); else printf("No eres mayor de edad"); getch(); } El cual tendría un diagrama de flujo como el siguiente:

Diagrama de flujo if - else

Figura 4. Diagrama if - else

El anterior diagrama de flujo funciona de la siguiente manera:

1. Si Edad es mayor que 20 (verdadero) entonces se muestra: “Eres mayor de edad”.

2. Si no (falso) entonces se muestra: “No eres mayor de edad”.

Edad > 20 printf("Eres mayor de edad");

printf("No eres mayor de edad");

verdaderofalso



6

A continuación se verá otro ejemplo con if – else que nos proporciona de dos números cual es el menor, observe que el tipo de variables utilizadas son de tipo float, por lo tanto al leer las variables pedidas desde el teclado; el modificador que se usa es ( %f ) respectivamente, y por último al imprimir el valor de menor dentro de la comillas se incluye el modificador nuevamente ( %f ), para en ese preciso lugar imprimir el resultado de la variable ( menor ), que se encuentra después de las comillas.

Algoritmo:

inicio declarar variables flotantes a, b, menor limpiar pantalla menor ← 0.0 escribir ( ‘ Dame el valor para a: ‘ ) leer ( a ) escribir ( ‘ Dame el valor para b ‘ ) leer ( b ) si ( a >b ) entonces escribir ( ‘ a es el numero menor ‘ ) menor ← a si_no escribir ( ‘ b es el numero menor ‘ ) menor ← b fin_si escribir ( ‘ Tu valor menor es el siguiente: ‘ , menor ) pausa fin Programa: #include <stdio.h> #include <conio.h> void main() { float a,b,menor; clrscr(); menor=0.0; printf(“ Dame el valor para a : \n”); scanf(“%f”, &a); printf(“ Dame el valor para b : \n”); scanf(“%f”, &b); if ( a > b ) { printf(" a es el número menor "); menor=a; } else { printf(" b es el número menor "); menor=b; } printf(“ Tu valor menor es el siguiente: \t %f “, menor); getch(); }



6

El siguiente ejemplo transforma una cantidad dada a pesetas o a euros, dando como un valor constante de 166.7 a PTS_POR_EURO, que se declara al inicio. Algoritmo: declarar constante PTS_POR_EURO 166.7 inicio declarar variables flotantes CantidadOriginal, CantidadConvertida carácter PtsOEuros limpiar pantalla escribir ( ‘ Introduce P si quieres convetir pesetas ‘ ) escribir ( ‘ o E si quieres convertir euros ‘ ) PtsOEuros ← getchar( ) PtsOEuros ← toupper ( PtsOEuros ) si (PtsOEuros = ‘E’ ) entonces escribir ( ‘ cuantos Euros ?‘ ) si_no escribir ( ‘ cuantas pesetas ? ‘ ) leer ( CantiodadOriginal ) si (PtsOEuros = ‘P’ ) entonces escribir ( ‘ Son ‘ , CantidadConvertida , ‘ pesetas ‘ ) si_no escribir ( ‘ Son ‘ , CantidadConvertida , ‘ Euros ‘ ) pausa fin Programa: #define PTS_POR_EURO 166.7 void main() { float CantidadOriginal, CantidadConvertida; char PtsOEuros; /* Pide al usuario que elija si convertir pesetas o euros*/ Clrscr(); printf("Introduce P si quieres convertir pesetas, "); printf(" o E si quieres convertir euros:"); PtsOEuros=getchar(); /* Espera a que introduzca un caracter */ PtsOEuros=toupper(PtsOEuros); /* Pasa a mayusculas el caracter*/ /* El mensaje que muestra depende de PtsOEuros */ if (PtsOEuros=='E') printf("Cuantos euros ? ") else printf("Cuantas Pesetas ? "); scanf("%f", &CantidadOriginal); /* Lee la suma a convertir */ if (PtsOEuros=='E') /* el cálculo depende de PtsOEuros */ CantidadConvertida = CantidadOriginal*PTS_POR_EURO; else CantidadConvertida= CantidadOriginal/PTS_POR_EURO; if (PtsOEuros == 'P') /* El mensaje depende de PtsOEuros */ /* muestra el resultado con 3 decimales */ printf("Son %.3f pesetas\n ", CantidadConvertida);



6

else printf("Son %.3f Euros\n ", CantidadConvertida); getch(); } Estructura de Selección switch simple

El switch es una estructura de decisión múltiple, que permite elegir ejecutar diferentes códigos dependiendo de un valor.

En forma ocasional, un algoritmo tendrá una serie de decisiones, en las cuales una variable o expresión se probará por separado contra cada uno de los valores (constantes enteros) que pueda asumir, y se tomarán diferentes acciones. Para esta forma de toma de decisiones se proporciona una estructura de selección múltiple switch..case. La estructura switch está formada de una serie de etiquetas case, y de un caso opcional default. Estructura general: switch (variable) { case valor1: sentencia1; sentenciaN; break; case valor2: sentencia1; sentenciaN; break; case valorN: sentencia1; sentenciaN; break; default: sentencia1; sentenciaN; break; }; La variable a evaluar en la sentencia switch debe ser de tipo int o char únicamente. La palabra reservada switch es seguida por el nombre de la variable entre paréntesis. Esto se conoce como la expresión de control. Después de esta expresión se abre una llave { para el inicio de los cases. El valor de esta expresión es comparado con cada una de las etiquetas case. Si ocurre una coincidencia, se ejecutaran la sentencias correspondientes a dicho case, y de inmediato mediante el enunciado break se sale de la estructura switch. El enunciado break causa que el control del programa continúe con el primer enunciado que sigue después de la estructura switch. Se utiliza el enunciado break, porque de lo contrario los cases en un enunciado switch se ejecutarían juntos. Si en alguna parte de la estructura case no se utiliza break, entonces, cada vez que ocurre una coincidencia en la estructura se ejecutarían todos los enunciados de los cases restantes. Si no existe coincidencia, el caso default es ejecutado y se imprime por lo general un mensaje de error. Después de terminar con la sentencia de la expresión default se cierra la llave } del switch. La expresión default es opcional. Cada case puede tener una o mas sentencias. La estructura switch es diferente a todas las demás estructuras, en el sentido de que no se requieren llaves alrededor de varias sentencias dentro de un case. Se pueden utilizar varias etiquetas, que significa que el mismo conjunto de acciones ocurrirá para cualquiera de estos casos. Ejemplo:



6

case ‘D’ : case ‘d’ : printf(“ La letra es D ”); break; Al utilizar una estructura switch, recuerde que puede ser usada sólo para probar una expresión integral o caracter constante. Una constante de caracter se representa como un caracter especifico, entre comillas sencillas como ‘d’. Los caracteres deben ser encerrados dentro de comillas sencillas para que sean reconocidos como constantes de caracter. Las constantes enteras son solo números enteros.

Algoritmo:

switch (valor)

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

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:

Algoritmo:

inicio declarar variables entero hijos limpiar pantalla escribir ( ‘ Ingrese la cantidad de hijos que usted tiene: ‘ ) leer ( hijos ) según_sea ( hijos ) hacer ‘0’ : escribir ( ‘ No le corresponde asignacón familiar por hijos ‘ ) break; ‘1’ : escribir ( ‘ Le corresponde 500 pesos de asignacón familiar por su único hijo ‘ ) break; ‘2’ : escribir ( ‘ Le corresponden 750 pesos de asignacón familiar por sus dos hijos ‘ ) break; default : escribir ( ‘ Le corresponden 1000 pesos de asignacón familiar por tener mas de dos hijos ‘ ) break; fin_según_sea pausa fin

Programa:



6

int hijos; clrscr( ); 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 hijo\n”); break;

case ‘1’:

printf(“Le corresponden 500 pesos de asignación familiar por su único hijo\n”); break;

case ‘2’:

printf(“Le corresponden 750 pesos de asignación familiar por sus dos hijos\n”); break;

default: printf(“Le corresponden 1000 pesos de asignación familiar por tener más de dos hijos\n”); 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.

Otro ejemplo del switch sería el siguiente:

Algoritmo:

inicio declarar variables entero x carácter m limpiar pantalla escribir ( ‘ Seleccione una opción del menú ‘ ) escribir ( ‘ 1. Sumar ( ++ ) 2. Restar ( - - ) ‘ ) leer ( m ) según_sea ( m ) hacer ‘1’ : incrementar X en uno

escribir ( , x , ) break; ‘2’ : decrementar X en uno

escribir ( , x , ) break; fin_según_sea pausa fin Programa:



6

main() { int x; char m; clrscr( ); printf("Seleccione una opción del menú: "); printf("\n1.Sumar (++) \n 2.Restar(--) \n"); scanf ("%c" ,&m); printf("Teclee el numero"); scanf("%d" ,&x); switch (m) { case '1': /*Uso de comillas solas porque es como caraceter*/ x++; printf("%d", x); break; /*necesario sino se sigue hasta que encuentre un break*/ case '2': x--; printf("%d",x); break; } return 0; } 3.1.2. Ramificada Para hacer estructuras condicionales más complejas podemos anidar sentencias if, es decir, colocar estructuras if dentro de otras estructuras if. Con un solo if podemos evaluar y realizar una acción u otra según dos posibilidades, pero si tenemos más posibilidades que evaluar debemos anidar Ifs para crear el flujo de código necesario para decidir correctamente. Por ejemplo, si deseo comprobar si un número es mayor menor o igual que otro, tengo que evaluar tres posibilidades distintas. Primero puedo comprobar si los dos números son iguales, si lo son, ya he resuelto el problema, pero si no son iguales todavía tendré que ver cuál de los dos es mayor, en situaciones como ésta es cuando tenemos que utilizar y apoyarnos de estructuras anidadas, la sintaxis de estas condicionales sería: Sintaxis: if (condición1) sentencia1 else if (condición2) sentencia2 else if (condición3) sentencia3 Segmento de algoritmo: si (condición1) entonces



6

sentencias1 si_no si (condición2) entonces sentencias2 si_no si (condición3) entonces sentencias3 fin_si fin_si fin_si

A veces es importante utilizar las llaves para aclarar el sentido semántico de los if anidados, ya que estos empiezan a ser cada vez mas grandes y por ende tienen más líneas de código las cuales si no definimos bien en que parte del programa se quieren realizar, se revolverían y el código sería inentendible.

Ejemplo que determina de 3 números cual es el mayor, con el ciclo if – else, de esta manera hay que fijarse muy bien en el primer if que ejecuta todo su bloque de sentencias ( que es otro if – else ) una anidación de ciclos, y en el else del mismo if se vuelve a anidar otro if – else en otro bloque de sentencias, por lo cual se comparan perfectamente los tres números para dar el número mayor. Algoritmo: inicio declarar variables enteras A ← 0, B ← 0, C ← 0 limpiar pantalla escribir ( ‘ Ingrese 3 números ‘ ) leer ( A, B, C ) si ( A > C ) entonces si ( A > C ) entonces escribir ( ‘ A es el número mayor ‘ ) si_no escribir ( ‘ C es el número mayor ‘ ) fin_si si_no si ( B > C ) entonces escribir ( ‘ B es el número mayor ‘ ) si_no escribir ( ‘ C es el número mayor ‘ ) fin_si fin_si pausa fin Programa: #include <iostream.h> #include <stdio.h> #include <conio.h> void main() { int A=0, B=0, C=0; clrscr( ); printf(”Ingrese 3 números”);



7

scanf(“%d %d %d”,&A, &B, &C); //Lectura de valores por teclado if ( A > B ) {

if (A > C ) printf(”A es el número mayor \n”);

else printf(”C es el número mayor \n”); } else {

if ( B > C ) printf(”B es el número mayor \n”); else printf(”C es el número mayor \n”); } getch(); } Otro ejemplo en el cual se incluyen ifs anidados: Algoritmo: inicio declarar variables enteras numero1 ← 23, numero2 ← 63 limpiar pantalla si ( numero1 == numero2 ) entonces escribir ( ‘ Los dos números son iguales ‘ ) escribir ( numero1, numero2 ) si_no si ( numero1 > numero2 ) entonces escribir ( ‘ El primer número es mayor que el segundo ‘ ) escribir ( numero1, numero2 )

si_no escribir ( ‘ El primer número es menor que el segundo ‘ )

escribir ( numero1, numero2 ) fin_si

fin_si pausa fin Programa: int numero1=23, numero2=63; clrscr( ); if (numero1 == numero2) { printf(“Los dos números son iguales \n "); printf( “%d = %d “, numero1, numero2); } else { if (numero1 > numero2) { printf(“ El primer número es mayor que el segundo \n "); printf( “%d > %d “, numero1, numero2); }



7

else { printf("El primer número es menor que el segundo \n"); printf( “%d < %d “, numero1, numero2); } getch( ); } En el anterior segmento de programa, primero se evalúa si los dos números son iguales. En caso positivo se muestra un mensaje informándolo. En caso contrario ya sabemos que son distintos, pero aun debemos averiguar cuál de los dos en mayor. Para eso se hace otra comparación para saber si el primero es mayor que el segundo. Si esta comparación da resultados positivos mostramos un mensaje diciendo que el primero es mayor que el segundo, en caso contrario indicaremos que el primero es menor que el segundo. Los sangrados también son opcionales en todo caso y nos sirven sólo para ver el código de una manera más ordenada. Mantener el código muy bien estructurado y escrito de una manera comprensible es muy importante, ya que nos hará la vida más agradable a la hora de programar y sobre todo más adelante cuando tengamos que revisar programas más extensos. Se pueden colocar instrucciones de control dentro de otras instrucciones de control, por ejemplo un bloque If...Else dentro de otra sentencia de control If…Else o incluso dentro de otra sentencia de control llamada switch que vimos anteriormente y entonces así, crear anidaciones. Cuando una instrucción de control se coloca dentro de otra, se dice que está anidada.

Note que en el caso de este if anidado no se necesitan abrir y cerrar llaves en el if interno, ya que al abrir un if y enseguida volver a abrir otro; este se liga y solo que ubiera más de una instrucción a realizar en ese if interno se abrirían llaves de lo contrario queda como esta en este ejemplo. Para ver mejor lo dicho anteriormente se repetirá el ejercicio anterior con más de una instrucción dentro del if interno para notar claramente donde sería la modificación. Algoritmo: si ( condicion ) entonces si ( condicion ) entonces Instrucciones a ejecutar cuando la condición es verdadera En el caso de haber mas de una instrucción a realizar si_no Instrucciones a ejecutar cuando la condición es falsa En el caso de haber tres líneas o más a realizar Esta sería la tercera línea Y podríamos seguirnos cuantas líneas fueran necesarias Las llaves se abren al ser dos o más líneas

Fin_si si_no Instrucción a ejecutar cuando la condición es falsa fin_si Programa: if (condición) if (condición) {



7

Instrucciones a ejecutar cuando la condición es verdadera;

En el caso de haber mas de una instrucción a realizar; } else { Instrucciones a ejecutar cuando la condición es falsa; En el caso de haber tres líneas o más a realizar; Esta sería la tercera línea; Y podríamos seguirnos cuantas líneas fueran necesarias; Las llaves se abren al ser dos o más líneas; } else Instrucción a ejecutar cuando la condición es falsa; Programa que determina de cuatro números cual es el mayor: Ejemplo Algoritmo: inicio declarar variables enteras a, b, c, d, mayor limpiar pantalla escribir ( ‘ Programa que indica cual de los 4 números es mayor ‘ ) escribir ( ‘ Introduce 4 números enteros ‘ ) leer ( a, b, c, d ) si ( a > b ) entonces si ( a > c ) entonces si ( a > d ) entonces mayor ← a si_no mayor ← d fin_si si_no si ( c > d ) entonces mayor ← c si_no mayor ← d fin_si fin_si si_no si ( b > c ) entonces si ( b > d ) entonces mayor ← b si_no mayor ← a fin_si si_no si ( c > d ) entonces mayor ← c si_no mayor ← d fin_si fin_si fin_si escribir ( ‘ El mayor es ‘, mayor ) pausa fin



7

Ejemplo Programa:

#include <stdio.h> #include <conio.h> void main() { int a, b, c, d, mayor; clrscr (); printf ("Programa que indica cual de 4 numeros es el mayor\n"); printf ("Introduce 4 numeros enteros:\n"); scanf ("%i%i%i%i", &a, &b, &c, &d); if (a > b) if (a > c) if (a > d) mayor = a; else mayor = d; else if (c > d) mayor = c; else mayor = d; else if (b > c) if (b > d) mayor = b; else mayor = a; else if (c > d) mayor = c; else mayor = d; printf ("El mayor es %i", mayor); getch(); }

Este es un claro ejemplo en el cual se manipulan varios if’s anidados para dar solución a un problema de número mayor.

Si se desea ejecutar más de una instrucción, es posible ejecutar varias instrucciones en forma condicional al incluirlas en bloques mediante { }, al igual que en el ejemplo anterior.

Las instrucciones que se van a ejecutar como resultado de comprobar la condición pueden ser de cualquier tipo, incluida otra instrucción if anidada dentro de la instrucción if original. En las instrucciones if anidadas, la cláusula else pertenece a la última instrucción if que no tiene una cláusula else correspondiente. Por ejemplo:



7

if (x > 10)

if (y > 20)

printf(" El valor es mayor ");

else

printf( " El valor es menor ");

En este ejemplo, se mostrará El valor es menor si la condición (y > 20) se evalúa como false. No obstante, si desea asociar El valor es menor a la condición (x >10), deberá utilizar llaves, como se muestra a continuación:

if (x > 10) { if (y > 20) printf(" El valor es mayor "); } else printf( " El valor es menor ");

En este caso, se mostrará El valor es menor si la condición (x > 10) se evalúa como false.

La razón por la que los if’s anidados son tan problemáticos es que puede ser difícil saber que else se asocia con que if. Por ejemplo: if (x) if (y) printf ("1"); else printf("2"); ¿A qué if se refiere el else?

Afortunadamente, C proporciona una regla muy sencilla para resolver este tipo de situaciones. En C una sentencia else siempre se refiere al if precedente mas próximo que no tenga ya asociada una sentencia else. En este caso, el else esta asociado con la sentencia if(y).

Para asociar el else con el if(x), se debe usar llaves para saltarse la asociación normal, tal como se muestra aquí:

if (x) { if (y) printf ("1"); } else printf("2");

Ahora, el else esta asociado con el if(x), porque ya no pertenece al bloque del if (y). Debido a las reglas de alcance de C, ahora el else no tiene conocimiento de la sentencia if (y), ya que no están en el mismo bloque de código.

La escala if-else-if

Una construcción común en programación es la if-else-if. Su forma general es:



7

if (expresión) sentencia; else if (expresión) sentencia; else if (expresión) sentencia; . . . else sentencia; Utilizando una escala if-else-if, el programa del número mágico queda como: Algoritmo: inicio declarar variables enteras magico ← 123, intento limpiar pantalla escribir ( ‘ Adivine el número mágico: ‘ ) leer ( intento ) si ( intento == magico ) entonces escribir ( ‘ **** Correcto **** ‘ ) escribir ( magico, ‘ es el número mágico ‘ ) si_no si ( intento > magico ) entonces escribir ( ‘ Incorrecto . . Demasiado alto ‘ ) si_no escribir ( ‘ Incorrecto . . Demasiado bajo ‘ ) fin_si fin_si pausa fin Programa: #include <stdio.h> main (void) { int magico = 123; /* numero magico*/ int intento; printf("adivine el numero magico: "); scanf("%d ", &intento); if (intento == magico) { printf("** Correcto**"); printf(" %d es el número mágico ", magico); } else if (intento > magico) printf(".. Incorrecto .. Demasiado alto"); else printf(".. Incorrecto .. Demasiado bajo"); return 0; }



7

Ahora bien dentro de las estructuras de decisión ramificadas también existe el ciclo switch como lo vimos anteriormente simple, pero ahora ramificado, recordaremos la sintaxis simple que se usa para de ella partir a la sintaxis ramificada:

switch (expresión entera) { case exp_constante_1:

acciones a realizar cuando la expresión tiene el valor exp_constante_1;

break; case exp_constante_2:

acciones a realizar cuando la expresión tiene el valor exp_constante_2;

break; ...especificar todos los casos default:

acciones a realizar cuando la expresión no coincide con ninguno de los casos;

break; } La sintaxis del switch anidado sería: Algoritmo: según_sea ( opción uno ) hacer 1 : según_sea ( opcion uno ) hacer

1 : escribir ( ‘ Mensaje ‘ ) break


3 : escribir ( ‘ Mensaje ‘ ) break default: escribir ( ‘ Mensaje ‘ ) fin_según_sea break 2 : según_sea ( opcion dos ) hacer



3 : escribir ( ‘ Mensaje ‘ ) break default: escribir ( ‘ Mensaje ‘ ) fin_según_sea break en caso contrario : break fin_según_sea Programa: switch(opcion)



7

{ case 1:switch(opcion uno) { case 1:printf("Mensaje");break; case 2:printf("Mensaje");break; case 3:printf("Mensaje");break; default: printf(“Mensaje”);break; } break; case 2:switch(opcion dos) { case 1:printf("Mensaje");break; case 2:printf("Mensaje");break; case 3:printf("Mensaje");break; default: printf(“Mensaje”);break; } break; default:break; } Y así podríamos continuar agregando más switch anidados, cuantos sean necesarios para resolver la problemática que se tenga, el ciclo switch anidado nos sirve para meter condiciones dentro de una ya establecida como en el ejemplo que sigue, nos da la conversión de números arábigos a números romanos de tal manera que se aniden los ciclos switch, en este primer ejemplo el ciclo switch tiene un pequeño error que se despeja en el ejercicio que le sigue, vamos a checar el primer caso: Ejemplo con switch anidado: Algoritmo: declarar función tranf (entera, entera) inicio declarar variables enteras um, c, d, u, n limpiar pantalla escribir ( ‘ Ingrese un número ‘ ) leer ( n ) um ← n/1000 c ← n/100%10 d ← n/10%10 u ← n%10 llamar a la función tranf(um,1) llamar a la función tranf(c,2) llamar a la función tranf(d,3) llamar a la función tranf(u,4) pausa fin función tranf (entera y, entera x ) inicio escribir ( ‘ Ingrese un número ‘ ) leer ( x ) según_sea ( x ) hacer 1 : según_sea ( y ) hacer

1 : escribir ( ‘ M ‘ )



7

break 2 : escribir ( ‘ MM ‘ )

break 3 : escribir ( ‘ MMM ‘ )

break default: break fin_según_sea break 2 : según_sea ( y ) hacer

1 : escribir ( ‘ C ‘ ) break

2 : escribir ( ‘ CC ‘ ) break

3 : escribir ( ‘ CCC ‘ ) Break

1 : escribir ( ‘ CD ‘ ) break

2 : escribir ( ‘ D ‘ ) break

3 : escribir ( ‘ DC ‘ ) break

1 : escribir ( ‘ DCC ‘ ) break

2 : escribir ( ‘ DCCC ‘ ) break break default: break fin_según_sea break 3 : según_sea ( y ) hacer

1 : escribir ( ‘ X ‘ ) break

2 : escribir ( ‘ XX ‘ ) break

3 : escribir ( ‘ XXX ‘ ) Break

4 : escribir ( ‘ XL ‘ ) break

5 : escribir ( ‘ L ‘ ) break

6 : escribir ( ‘ LX ‘ ) break

7 : escribir ( ‘ LXX ‘ ) break

8 : escribir ( ‘ LXXX ‘ ) break

9 : escribir ( ‘ CX ‘ ) break default: break fin_según_sea break 4 : según_sea ( y ) hacer 1 : escribir ( ‘ I ‘)

break 2 : escribir ( ‘ II ‘ )



7

break 3 : escribir ( ‘ III ‘ )

break 4 : escribir ( ‘ IV ‘ )

break 5 : escribir ( ‘ V ‘ )

break 6 : escribir ( ‘ VI ‘)

break 7 : escribir ( ‘ VII ‘ )

break 8 : escribir ( ‘ VIII ‘)

break 9 : escribir ( ‘ IX ‘)

break default:break;

fin_según_sea break default: break fin_según_sea Programa: #include<conio.h> #include<stdio.h> void tranf(int,int); void main(void) { int um,c,d,u,n; clrscr(); printf("ingrese numero"); scanf("%d",&n); um=n/1000; c=n/100%10; d=n/10%10; u=n%10; tranf(um,1); tranf(c,2); tranf(d,3); tranf(u,4); getch( ); } void tranf(int y, int x) { printf("ingrese numero"); scanf (“ %d “, &x); switch(x) { case 1:switch(y)

{ case 1:printf("M");break; case 2:printf("MM");break; case 3:printf("MMM");break; default:break; }



8

case 2:switch(y) { case 1:printf("C");break; case 2:printf("CC");break; case 3:printf("CCC");break; case 4:printf("CD");break; case 5:printf("D");break; case 6:printf("DC");break; case 7:printf("DCC");break; case 8:printf("DCC");break; case 9:printf("DCCC");break; default:break; }

case 3:switch(y) { case 1:printf("X");break; case 2:printf("XX");break; case 3:printf("XXX");break; case 4:printf("XL");break; case 5:printf("L");break; case 6:printf("LX");break; case 7:printf("LXX");break; case 8:printf("LXXX");break; case 9:printf("XC");break; default:break; }

case 4:switch(y) { case 1:printf("I");break; case 2:printf("II");break; case 3:printf("III");break; case 4:printf("IV");break; case 5:printf("V");break; case 6:printf("VI");break; case 7:printf("VII");break; case 8:printf("VIII");break; case 9:printf("IX");break; default:break; }

default:break; } El ejemplo anterior contiene un pequeño error de llaves (rango), si es que lo pudieron detectar solo hay que corregirlo, pero si no, el ejemplo siguiente nos da la modificación pertinente. El error radica en las llaves que le faltan al primer switch. Algoritmo: declarar función tranf (entera, entera) inicio declarar variables enteras um, c, d, u, n limpiar pantalla escribir ( ‘ Ingrese un número ‘ ) leer ( n )



8

um ← n/1000 c ← n/100%10 d ← n/10%10 u ← n%10 llamar a la función tranf(um,1) llamar a la función tranf(c,2) llamar a la función tranf(d,3) llamar a la función tranf(u,4) pausa fin función tranf (entera y, entera x ) inicio escribir ( ‘ Ingrese un número ‘ ) leer ( x ) según_sea ( x ) hacer 1 : según_sea ( y ) hacer

1 : escribir ( ‘ M ‘ ) break

2 : escribir ( ‘ MM ‘ ) break

3 : escribir ( ‘ MMM ‘ ) break default: break fin_según_sea break 2 : según_sea ( y ) hacer

1 : escribir ( ‘ C ‘ ) break

2 : escribir ( ‘ CC ‘ ) break

3 : escribir ( ‘ CCC ‘ ) Break

1 : escribir ( ‘ CD ‘ ) break

2 : escribir ( ‘ D ‘ ) break

3 : escribir ( ‘ DC ‘ ) break

1 : escribir ( ‘ DCC ‘ ) break

2 : escribir ( ‘ DCCC ‘ ) break break default: break fin_según_sea break 3 : según_sea ( y ) hacer

1 : escribir ( ‘ X ‘ ) break

2 : escribir ( ‘ XX ‘ ) break

3 : escribir ( ‘ XXX ‘ ) Break

4 : escribir ( ‘ XL ‘ ) break



8

5 : escribir ( ‘ L ‘ ) break

6 : escribir ( ‘ LX ‘ ) break

7 : escribir ( ‘ LXX ‘ ) break

8 : escribir ( ‘ LXXX ‘ ) break

9 : escribir ( ‘ CX ‘ ) break default: break fin_según_sea break 4 : según_sea ( y ) hacer 1 : escribir ( ‘ I ‘)

break 2 : escribir ( ‘ II ‘ )

break 3 : escribir ( ‘ III ‘ )

break 4 : escribir ( ‘ IV ‘ )

break 5 : escribir ( ‘ V ‘ )

break 6 : escribir ( ‘ VI ‘)

break 7 : escribir ( ‘ VII ‘ )

break 8 : escribir ( ‘ VIII ‘)

break 9 : escribir ( ‘ IX ‘)

break default:break;

fin_según_sea break default: break fin_según_sea pausa fin Programa: #include <stdio.h> #include <stdlib.h> void tranf(int,int); int main(void) { int um,c,d,u,n; system("cls"); printf("ingrese numero: "); scanf("%d",&n); um=n/1000; c=n/100%10; d=n/10%10; u=n%10;



8

tranf(um,1); tranf(c,2); tranf(d,3); tranf(u,4); putchar('\n'); system("pause"); return 0; } void tranf(int y, int x) { switch(x){ case 1:switch(y) { case 1:printf("M");break; case 2:printf("MM");break; case 3:printf("MMM");break; default:break; } break; case 2:switch(y) { case 1:printf("C");break; case 2:printf("CC");break; case 3:printf("CCC");break; case 4:printf("CD");break; case 5:printf("D");break; case 6:printf("DC");break; case 7:printf("DCC");break; case 8:printf("DCC");break; case 9:printf("DCCC");break; default:break; } break; case 3:switch(y) { case 1:printf("X");break; case 2:printf("XX");break; case 3:printf("XXX");break; case 4:printf("XL");break; case 5:printf("L");break; case 6:printf("LX");break; case 7:printf("LXX");break; case 8:printf("LXXX");break; case 9:printf("XC");break; default:break; } break; case 4:switch(y) { case 1:printf("I");break; case 2:printf("II");break; case 3:printf("III");break; case 4:printf("IV");break; case 5:printf("V");break; case 6:printf("VI");break;



8

case 7:printf("VII");break; case 8:printf("VIII");break; case 9:printf("IX");break; default:break; } break; default:break; } getch(); }

Este es un ejemplo que se resuelve mediante dos formas con if’s anidados y con switch anidados. Para demostrar que lo que se realiza con un ciclo if se puede realizar de la misma manera con un ciclo switch y viceversa. Ejemplo: Un restaurante ofrece el siguiente menú, con los siguientes costos por platillo: 1.-Carne en su Jugo 89.60 2.- Hígado encebollado 60.25 Adicionalmente el cliente puede elegir uno de los siguientes postres, por los cuales se agregará al costo del platillo las cantidades que se indican: 1) Flan 5.00 2) Gelatina 3.50 3) No desea postre (el cliente pagará 10.00 pesos menos por su platillo). El programa deberá pedir la información referente al platillo y al postre, a través de un menú y al final mostrará un mensaje con el monto que el cliente deberá pagar. El siguiente programa soluciona el problema anterior con estructuras if anidadas. Algoritmo: inicio declarar variables enteras postre carácter platillo real postre ← 0.0 limpiar pantalla escribir ( ‘ Que platillo desea el cliente ‘ ) escribir ( ‘ a)Carne en su Jugo ó b)Hígado encebollado ‘ ) escribir ( ‘ Proporcione la Opción (a ó b): [ ] ‘ ) leer ( platillo ) si ( platillo = 1 ) hacer escribir ( ‘ Que postre desea el cliente: ‘ ) escribir ( ‘ 1) Flan, 2) Gelatina 3) No desea postre ‘ ) escribir ( ‘ Proporcione la Opción (1,2 ó 3): [ ] ‘ ) leer ( postre ) si ( postre = 1 ) entonces costo ← 89.60+5.00 si_no si ( postre = 2 ) entonces costo ← 89.60+3.50 si_no si ( postre = 3 ) entonces costo ← 89.60-10.00 si_no escribir ( ‘ Error en la selección del postre ‘ ) si_no si ( platillo = 2 ) entonces



8

escribir ( ‘ Seleccione postre ‘ ) escribir ( ‘ Seleccione la opción [ 1,2 ó 3 ] : ‘ ) leer ( postre ) si ( postre = 1 ) entonces costo=60.25+5.00 si( postre = 2 ) entonces costo=60.25+3.50 si( postre = 3 ) entonces costo=60.25-10.00 si_no escribir ( ‘ Error en la selección del platillo ‘ ) fin_si fin_si escribir ( ‘ El total a pagar es ‘ ,costo ) pausa fin Programa: #include <stdio.h> #include<conio.h> void main() { int platillo,postre; float costo=0.0; printf("\n\n Que platillo desea el cliente\n"); printf(" 1)Carne en su Jugo ó 2)Hígado encebollado\n"); printf("Proporcione la Opción (1 ó 2): [ ]\b\b"); scanf("%d", &platillo); if(platillo==1) { printf("\n Seleccione postre\n"); printf("1-Flan, 2-Gelatina 3-No desea postre)\n"); printf("Proporcione la Opción (1,2 ó 3): [ ]\b\b"); scanf("%d",&postre); if (postre==1) costo=89.60+5.00; else if (postre==2) costo=89.60+3.50; else if (postre==3) costo=89.60-10.00; else printf("\n Existe un error en la selección del postre\n"); } else if(platillo==2) { printf("\n Seleccione postre\n"); printf("Proporcione la Opción (1,2 ó 3): [ ]\b\b"); scanf("%d", &postre); if (postre==1) costo=60.25+5.00; if (postre==2) costo=60.25+3.50; if (postre==3) costo=60.25-10.00; } else printf("Error en la selección del platillo\n"); printf("\n El total a pagar es %8.2f \n",costo);



8

getch(); } Solución con estructuras switch anidadas, las opciones del platillo serán ahora a y b. Algoritmo: inicio declarar variables enteras postre carácter platillo real postre ← 0.0 limpiar pantalla escribir ( ‘ Que platillo desea el cliente ‘ ) escribir ( ‘ a)Carne en su Jugo ó b)Hígado encebollado ‘ ) escribir ( ‘ Proporcione la Opción (a ó b): [ ] ‘ ) leer ( platillo ) según_sea ( platillo ) hacer ‘ A ‘ : escribir ( ‘ Que postre desea el cliente: ‘ ) escribir ( ‘ 1) Flan, 2) Gelatina 3) No desea postre ‘ ) escribir ( ‘ Proporcione la Opción (1,2 ó 3): [ ] ‘ ) leer ( postre ) según_sea ( postre ) hacer 1 : costo ← 89.60+5.00 break; 2 : costo ← 89.60+3.50 break; 3 : costo ← 89.60-10.00 break; default: escribir ( ‘ Error en la selección del postre ‘ ) break fin_según_sea break ‘ B ‘ : escribir ( ‘ Que postre desea el cliente: ‘ ) escribir ( ‘ 1) Flan, 2) Gelatina 3) No desea postre ‘ ) escribir ( ‘ Proporcione la Opción (1,2 ó 3): [ ] ‘ ) leer ( postre ) según_sea ( postre ) hacer 1 : costo ← 60.25+5.00 break; 2 : costo ← 60.25+3.50 break; 3 : costo ← 60.25-10.00 break; default: escribir ( ‘ Error en selección del postre ‘ ) break fin_según_sea break default : escribir ( ‘ Error en la selección del platillo ‘ ) fin_según_sea break escirbir ( ‘ El total a pagar es : ‘ , costo ) pausa fin Programa: #include <stdio.h>



8

#include<conio.h> void main() { char platillo; int postre; float costo=0.0; clrscr(); printf("\n\nQue platillo desea el cliente\n"); printf(" a)Carne en su Jugo ó b)Hígado encebollado\n"); printf("Proporcione la Opción (a ó b): [ ]\b\b"); scanf("%c",&platillo); switch(platillo) { case 'A': printf("\n\n Que postre desea el cliente:\n"); printf("1) Flan, 2) Gelatina 3) No desea postre\n"); printf("Proporcione la Opción (1,2 ó 3): [ ]\b\b\b"); scanf("%d", &postre); switch(postre) { case 1:costo=89.60+5.00; break; case 2:costo=89.60+3.50; break; case 3:costo=89.60-10.00; break; default:printf("\n Error en la selección del postre\n"); } break; case 'B': printf("\n\n Que postre desea el cliente:\n"); printf("1) Flan, 2) Gelatina 3) No desea postre\n"); printf("Proporcione la Opción (1,2 ó 3): [ ]\b\b\b"); scanf("%d", &postre); switch(postre) { case 1:costo=60.25+5.00; break; case 2:costo=60.25+3.50; break; case 3:costo=60.25-10.00; break; default:printf("\n Error en selección del postre\n"); } break; default: printf("\n Error en la selección del platillo\n"); } printf("\nEl total a pagar es %8.2f \n", costo); getch(); }

3.2. Estructuras de Iteración Todos los programas que se han visto a lo largo de este manual se ejecutan en forma secuencial, es decir una sentencia después de la otra y así sucesivamente. Cada instrucción empezando en el inicio se ejecutan una seguida de la otra y algo muy importante, ninguna de ellas se repite, por lo tanto se dice que s un programa secuencial porque sus instrucciones van ejecutándose una por una continuamente hasta llegar al final del programa.



8

Así, esta programación es muy sencilla y se realizan programas a su vez sencillos, por otro lado poco a poco se va requiriendo de una programación más controlada, en la cual podamos decidir en que momento ejecutamos una serie de instrucciones y bajo que condición. En lenguaje C existen otras sentencias bajo las cuales se pueden repetir una serie de instrucciones mientras se cumpla una determinada condición y características. Las estructuras de iteración son también llamados ciclos y se usan en la programación para realizar una y otra vez un conjunto de instrucciones hasta que se cumpla una determinada condición. Estos ciclos de iteración o repetición son muy utilizados, ya que permiten al programador repetir un segmento de código las veces que se desee; sin necesidad de volver a escribir cada vez que se va a utilizar y así lograr simplificar código de programación. Lenguaje C soporta tres tipos de estructuras de iteración que son: while, do-while y for, los cuáles describiremos a continuación. Dentro de estos tres tipos, existen los llamados pre – condicionales y post – condicionales que son el ciclo while y do – while respectivamente y en lo que respecta al ciclo for, este puede entrar en cualquiera de los dos ya que con una serie de modificaciones en su estructura puede llegar a ser pre – condicional o post – condicional. El nombrar pre – condicional a un ciclo quiere decir que primero va a evaluar la condición para luego ver si realiza el bloque de sentencias, si esta condición es verdadera o se cumple, entonces entramos a realizar el bloque de sentencias de dicho ciclo, pero si esta condición es falsa desde el inicio, nunca entramos a realizar ninguna tarea del bloque de sentencias; esto es un ciclo pre – condicional es el cual va a evaluar la condición antes de realizar el bloque de sentencias, un ejemplo claro de esto es un ciclo while, y cuando se habla de un ciclo post – condicional se dice que es cuando la condición se evalúa al final del bloque de sentencias. Una vez que ya se realizó el bloque de sentencias en la parte final se encuantra la condición, en ese momento se evalúa y si es falsa deja de repetir el bloque de sentencias, pero si es verdadera continúa repitiendo el bloque de sentencias; por lo tanto un ejemplo de este ciclo es el do – while; el cual primero realiza el bloque de sentencias sin importar la condición y al final evalúa la condición. En este caso el ciclo do – while por fuerza siempre realiza al menos una vez todas las sentencias que se encuentran dentro de él, sin importar que la expresión de la condición sea falsa desde un principio, mientras que el ciclo while si su condición es falsa en un principio nunca se ejecuta el bloque de sentencias ni una sola vez, solo cuando esta sea verdadera. Estructura de Iteración while Analizaremos el ciclo while por primera instancia el cual primero evalúa la condición para luego entonces, si ésta se cumple o es (verdadera) realice el bloque de sentencias de dicha estructura, de lo contrario el control del programa pasará a la siguiente instrucción inmediata después del ciclo de repetición, ejemplo de esto es el siguiente diagrama de flujo donde se muestra como el ciclo while para poder realizar un bloque de sentencias determinado, primero tiene que evaluar su condición (expresión lógica) mientras esta sea verdadera se ejecuta el bloque de sentencias y si está condición es falsa el programa dirige su flujo a la sentencia siguiente instrucción inmediata después del ciclo de repetición como se muestra a continuación.

Diagrama de Flujo del ciclo While



8

Figura 5. Diagrama de flujo ciclo While La sintaxis o forma general del ciclo de repetición while en su forma simple o más sencilla es la del inciso a), mientras que el inciso b) muestra la forma más estructurada de un ciclo while el cual consta de una serie de sentencias (bloque de sentencias) que van encerradas entre llaves { }, si la sentencia a ejecutar en el ciclo while es únicamente una no se utilizan la llaves, pero si el bloque consta de más de una sentencia se le debe poner las llaves para indicar que todo ese bloque de sentencias se realizará cuando la condición sea verdadera. Sintaxis: a) mientras (condición) hacer Sentencia; b) mientras (condición) hacer { Sentencia1; Sentencia2; . . . SentenciaN; } En lenguaje de programación meramente Lenguaje C se escribiría como sigue, tomando en cuenta lo anterior respectivamente: a) while (condición) sentencia; b) while (condición) { Sentencia1; Sentencia2;

falsa

sentencia

sentencia

sentencia

sentencia

mientras condición

Sentencia siguiente

verdadera



9

Sentencia3; . . . sentenciaN; } Nótese que al terminar la línea del while no se pone un punto y coma, mientras que en las demás instrucciones todas al final terminan con un punto y coma, exceptuando también las llaves; esto es debido a que un punto y coma ( ; ) indica la terminación de una instrucción concluida y por lo tanto la línea del while no es una instrucción para terminar, si no por el contrario; es el inicio del ciclo de repetición. En esta estructura el conjunto de instrucciones que forma parte del bucle (un ciclo) se repite mientras se cumple una determinada condición. Como es bien sabido la finalidad de la palabra reservada while es ejecutar una instrucción una y otra vez mientras que una condición dada sea cierta, cuando la condición de ciclo while ya no es lógicamente verdadera, el ciclo termina. Veamos ahora un ejemplo de la estructura de repetición while. Este segmento de programa nos indica cuantas veces se ejecuta un ciclo de repetición y lo muestra en pantalla. Algoritmo: R = 0 mientras ( R < 6 ) hacer escribir ( R ) incrementar R en uno fin_mientras Programa: R = 0; while (R < 6) { printf(“ \n %d “, R); R = R + 1; } La salida de este programa es el valor de la variable R, que va incrementándose de uno en uno cada vez que se ejecuta el bloque de sentencias ( conjunto de instrucciones dentro de las llaves) del ciclo y nos da: 0, 1, 2, 3, 4 y 5. Por lo tanto el bucle se repite seis veces. Este es otro ejemplo que contará los números enteros positivos dados desde el teclado, en el momento en el que se teclee un número negativo se detiene la iteración y da por terminado el programa. Algoritmo: algoritmo enteros variables enteras número, contador inicio escribir( ‘ Programa que cuenta los números enteros positivos ‘ ) contador 0 leer (numero) mientras ( numero > 0 ) hacer contador contador + 1 leer (numero)



9

fin_mientras escribir ( ‘ El número de enteros dados fue ‘, contador ) pausa fin Programa Enteros: #include <stdio.h> #include<conio.h> void main() { int numero, contador; printf("\n\n Programa que cuenta los números enteros positivos\n"); contador=0; printf(" Dame un número \n"); scanf("%d",&numero); while ( numero > 0 ) { contador = contador + 1; scanf(“%d”,&numero); } printf(“ El número de enteros dados fue : \t %d “, contador); getch(); } El programa anterior al final muestra cuantos números enteros se introdujeron, dicho valor lo tiene la variable contador, que actúa como un contador (término que más adelante se describe) dando la acumulación de uno en uno durante cada vuelta del ciclo. Una condición está formada básicamente por una serie de estructuras llamadas expresiones estas a su vez están formadas por cualquier sentencia que devuelve una operación booleana que como resultado dentro del paréntesis nos den un dato expresado en falso o verdadero, en true or false o en cero o uno, para poder determinar si la condición proporcionada se cumple o no se cumple y poder así saber, si se ejecuta el bloque de sentencias o no. La condición también puede ser el nombre de una variable y el valor de la expresión dependerá del contenido de la variable. Aunque sea una variable no booleana, siempre se podrá usar, si vale 0 será como si la condición no se cumpliera, y siempre que sea diferente de 0, se considerará que la condición se cumple. Dentro de estas expresiones se usan los operadores aritméticos y lógicos vistos con anterioridad, y para saber que resultado arroja cada expresión podemos hacer uso de nuestras tablas de verdad, que a continuación se muestran. Dentro de las formas más usadas es sin duda las sentencias comparativas en donde se emplean implícitamente las tablas de verdad que es el resultado de una operación lógica. Tablas de verdad And:

A B A&&B F F F F V F V F F V V V

Tabla 20. Tabla de verdad And Or:

A B A || B



9

F F F F V V V F V V V V

Tabla 21. Tabla de verdad Or Not:

A ! A F V V F

Tabla 22. Tabla de verdad Not Los operadores relacionales se usan para expresar condiciones y describir la relación entre dos valores, son muy útiles porque con ellas la expresión se vuelve más exacta, es decir; el rando ya no queda abierto sino tiene un límite de inicio y fin con el cual se puede dar por terminado el ciclo de repetición.

Tabla 23. Operadores Relacionales También para describir expresiones más exactas y precisas en las condiciones se usan los operadores lógicos and, or y not, los cuales se pueden utilizar conjuntamente con los operadores relacionales para construir expresiones exactas a lo que queremos construir dentro de los programas.

OPERADOR DESCRIPCIÓN < Menor que > Mayor que <= Menor o igual que >= Mayor o igual que == !=

Igual Diferente que

OPERADOR DESCRIPCIÓN ! Not && And != Or



9

Tabla 24. Operadores Lógicos Ejecución de un bucle cero veces: Véase que en una estructura mientras (while) la primera cosa que ocurre es la evaluación de la expresión (condición) booleana; si esta condición se evalúa a falsa en ese momento, entonces el cuerpo del bucle nunca se ejecuta. Puede parecer inútil ejecutar el cuerpo del bucle cero veces, ya que no tendría efecto alguno el realizar un programa en donde nunca entraremos al cuerpo del while. Sin embargo, a veces es la operación querida. Ejemplo: Algoritmo: K ← 0 escribir ( ‘ Dame un número ‘ ) leer (numero) mientras ( numero > 0 ) hacer K ← k + 1 leer ( numero ) fin_mientras Este ciclo de repetición nunca se ejecutará si el primer número leído desde el teclado es un número negativo o es igual a cero. Programa: K = 0; printf( “ Dame un número: \n “); scanf(“%d”, &numero); while ( numero > 0) { K++; scanf (“%d”, &numero); } Bucles infinitos: Algunos bucles no exigen un fin y otros nunca encuentran el fin porque tienen un error en su diseño. Por ejemplo, en una estación de tren se requiere de un programa que requiere del registro de altas y bajas de sus pasajeros, este ciclo se está repitiendo constantemente y nunca termina hasta que la computadora se apague y por el contrario puede haber un programa que nunca se repita o que nunca termine su repetición porque nunca se cumpla la condición. Un ciclo que nunca termine se le llama ciclo infinito o sin fin. Los ciclos infinitos que no son intencionalmente provocados, son dañinos para la programación ya que en muchas ocasiones no sabemos porque sucede un error en el ciclo sobre todo cuando se empieza a programar, muchos de estos errores no provocados se empiezan a comprender más cuando tenemos un poco de práctica al programar. Consideremos el ejemplo de tasa de interes con un incremento de dos, en un rango entre 20 y 40 por 100. Algoritmo: escribir ( ‘ Dame el capital total que gustes ‘ ) leer (total_cap)



9

tasa_int ← 20 escribir ( ‘ Programa que realiza una tasa de interes ‘ ) mientras (tasa_int < > 40 ) hacer interes ← tasa_int * 0.01 * total_cap //el capital es capital/100 (0.01) escribir ( ‘ El interes que se produjo es: ‘ , interes) tasa_int ← tasa_int + 2 fin_mientras escribir ( ‘ Linea siguiente ‘ ) Los valores que siguen a la tasa_int serían 20, 22, 24, 26, 28, 30, 32, 34, 36, 38 y 40, de manera que al tomar la variable tasa_int el valor de 40 este bucle mientras (while) se termina y se va la ejecución del programa a la siguiente instrucción después del ciclo de repetición que es el mensaje “Línea siguiente”. Programa: printf(“ Dame el capital total que gustes \n\n”); scanf(“%d”, &total_cap); tasa_int = 20; printf(“ Programa que realiza una tasa de interes \n\n “); while (tasa_int < > 40 ) { interes = tasa_int * 0.01 * total_cap; printf(“ El interes que se produjo es : \t %d “, interes); tasa_int = tasa_int + 2; } printf(“ Línea siguiente \n “); Supongamos que la línea de ( tas_int = tasa_int + 2 ), se cambiara por ( tasa_int = tasa_int + 3), entonces aquí los valores de la tasa_int serían: 23, 26, 29, 32, 35, 38, 41… , por lo tanto la condición del ciclo while nunca se cumplira y el bucle se vuelve infinito. Problemas como este nos determinan las maneras en que podemos terminar un ciclo de repetición, sobre todo si utilizamos los operadores relacionales de menor o igual y mayor o igual podremos tener expresiones más exactas. En el siguiente ejemplo se utilizan los operadores relacionales para que la condición tenga un límite determinado, realiza una suma acumulativa de números dados desde el teclado, hay que poner atención a la condición para que se aprecie como está funcionando ahora esa condición. Algoritmo: escribir ( ‘ Programa que suma N cantidad de números ‘ ) suma ← 0 escribir ( ‘ Existen otros números en la lista s/n ‘ ) leer (opcion) mientras ( opcion = S ) o ( opcion = s ) hacer escribir ( ‘ Dame un numero ‘ ) leer (numero) suma ← suma + numero escribir ( ‘ Hay más numeros s/n ‘ ) leer (opcion) fin_mientras escribir ( ‘ El total de los numeros sumados es: ‘, suma ) Programa: printf(“ Programa que suma N cantidad de numeros \n\n “); suma = 0;



9

printf( “ Existen otros numeros en a lista \n\n “); scanf( “%c”, &opcion); while (( opcion = ‘S’) || (opcion = ‘s’)) { printf(“ Dame un numero: \n\t “); scanf( “%f”, &numero); suma = suma + numero; printf(“ Hay más números s/n “); scanf( “%c”, &opcion); } printf(“ El total de los numeros sumados es: %f \n “, suma ); Este método es muy bueno pero poco eficaz sobre todo cuando una lista es demasiado grande, entonces se usan variables que tengan una señal de parada como las vistas anteriormente. Un método muy interesante y eficaz para detener un ciclo de repetición es usar un valor centinela. Un valor centinela es un valor específico para indicar el final de una lista de datos. Por ejemplo, supongamos que tenemos una lista de calificaciones de los alumnos del tercer semestre de la carrera de ingeniería que entran en un rango de 0 a 10 de las cuales tenemos que obtener sus promedios, entonces un valor centinela es o podría ser -9, ya que esta jamás podrá ser una calificación valida para un alumno y por lo tanto cuando este valor aparezca se dará por terminada la lista y por ende el bucle. Si la lista es de números positivos un valor centínela podría ser un número negativo que índique el final de la lista. El siguiente ejemplo muestra como se usa un valor centinela en una lista de calificaciones. Algortimo: suma_calif ← 0; Cont ← 0 escribir ( ‘ Da la calificaión: ‘ ) leer (calif) mientras ( calif >= 0 ) hacer suma_calif ← suma_calif + calif escribir ( ‘ Da la calificación: ‘) leer (calif) cont ← cont + 1 fin_mientras prom ← suma_calif / cont escribir ( ‘ Tu promedio es de : ‘ , prom) Programa: suma_calif = 0; cont = 0; prinf(“ Da la calificación: \n ”); scanf(“ %f “, &calif); while (calif > = 0) { suma_calif = suma_calif + calif; cont = cont + 1; printf(“ Da la calificación: \n “); scanf (“ %f “, &calif ); } prom = suma_calif / cont; printf(“ Tu promedio es de: \t %f “,prom);



9

Cuando se usa un valor centinela se podrían dar por ejemplo los siguientes valores 10, 5.5, 7, 3.5, 9, y -9, entonces nuestro valor centinela sería -9 que es un valor que se lee pero no se suma en la lista, nótese tambien que el pedir la calificación (valor que estamos comprobando) se hace al final del bloque de sentencias, esto para poder comprobar de inmediato el valor al entrar al while, si este es un valor negativo como lo es el -9 de inmediato el ciclo se detiene. Hay que poner atención tambien en que el promedio de estas calificaciones se realiza fuera del ciclo de repetición, para tener primero la acumulación del número de calificaciones el cual es llevado por la variable cont; y luego la suma de las calificaciones la divide entre el número de calificaciones que son dando entonces un promedio de claificaciones final. Otros ejemplos para detener un ciclo de repetición es dar una condición en la cual ya no sea probable que existan más datos de entrada, como el ejemplo siguiente: a) Algoritmo: i = 0; mientras ( i < 6 ) hacer escribir ( ‘ El valor de i es : ‘ , i ) i = i + 1 fin_mientras b) Algoritmo: i = 0 mientras ( i < 6 ) hacer i = i + 1 escribir ( i ) fin_mientras

a) Programa: i = 0; while ( i < 6 ) { printf(“ El valor de i es : \t %d “, i); i = i + 1; }

b) Programa: i = 0; while ( i < 6 ) { i = i + 1; printf ( “ %d “, &i ); } Estos algoritmos nos indican cuantas veces se ejecuta un ciclo de repetición (bucle). El algoritmo “a” y el algoritmo “b” muestran exactamente lo mismo; las vueltas que da un ciclo de repetición, pero el acomodar las líneas del contador y el printf de diferente manera nos muestra una salida diferente como se muestra a continuación: La salida en el inciso “ a) “ es el valor que toma la variable de control “ i “ al inicio de cada ejecución del ciclo: 0, 1, 2, 3, 4 y 5. Por lo tanto el bucle se ejecuta sies veces, mientras en inciso “ b) “ se ejecuta exactamente las mismas veces pero el contador “ i “ lleva los



9

siguientes valores: 1, 2, 3, 4, 5 y 6 debido a que en este caso el incremento de la variable “ i “ es primero y luego imprime el valor en pantalla por eso es el cambio de los valores.

Estructura de iteración Do – While: El ciclo hacer – mientras (do – while ), es muy similar al ciclo while antes visto ambos realizan un ciclo de repetición, solo cambia la manera en que se acomoda la condición dentro del ciclo de repetición. A veces es importante que un ciclo de repetición se ejecute al menos una vez antes de comprobar la condición, en el ciclo while si la expresión booleana era falsa no se ejecutaba el bloque de sentencias, por eso en ocasiones es necesario contar con otro tipo de estructuras de repetición. Sintaxis: hacer { Bloque de sentencias; } mientras ( condición ) hacer sentencia; mientras ( condición ) Nótese que la diferencia entre los dos tipos de sintaxis es que en una mientras haya más de una instrucción (línea de codigo), se tienen que poner llaves que engloben al bloque de sentencias, mientras en el que solo hay una instrucción no se agregan llaves, la línea se ejecuta automáticamente como parte del ciclo de repetición. El ciclo do – while repite todo el bloque de sentencias al menos una vez ya que al entrar a este nunca evalúa alguna condición, por lo tanto, entra y empieza a ejecutar las sentencias; hasta llegar al final de estas, es entonces donde compara la condición para determinar si ésta es falsa o verdadera. Si la condición es falsa el flujo del programa continúa en la siguiente instrucción fuera del ciclo de repetición, pero si esta es verdadera entonces regresa el flujo al bloque inicial de instrucciónes del ciclo de repetición y vuelve a repetirlas hasta llegar otra vez a la condición y así sucesivamente mientras la condición sea verdadera. Diagrama de Flujo:

falsa

sentencia

sentencia

sentencia

sentencia

mientras condición

S t i i i t

verdadera



9

Figura 6. Diagrama de Flujo del Ciclo Do

Ejemplo: Algoritmo que desarrolla el factorial de un número N con la formula: N! = N . (N-1) . (N-2), … , 3 . 2 . 1 Algoritmo factorial_numero inicio declarar variables enteras Q, N real factorial escribir ( ‘ Programa que da el factorial de un numero dado desde el teclado ‘ ) escribir ( ‘ Da el número para obtener el factorial ‘ ) leer ( N ) factorial ← 1 Q ← 1 hacer

factorial ← factorial * Q Q ← Q + 1

mientras ( Q < = N ) escribir ( ‘ El factorial del número ‘ N ‘ es: ‘ , factorial ) pausa fin Programa factorial_numero #include <stdio.h> #include<conio.h> void main() { int Q, N; float factorial; printf("\n\n Programa que da el factorial de un numero dado desde el teclado ‘ ); printf( “ Da el número para obtener el factorial \n “); scanf("%d",&N); factorial = 1; Q = 1; do { factorial = factorial * Q; Q = Q + 1; } while ( Q < = N); printf(“ El factorial del número %d es: %f “, N , factorial ); getch(); }



9

En un ciclo de repetición como lo es el do-while primero se ejecuta el cuerpo del bucle siempre al menos una vez. Cuando este se ejecuta lo primero que se realiza es el bloque de sentencias, para al final evaluar la expresión booleana resultante de la condición, si dicha condición es falsa se ejecuta al menos una vez el bloque y si la condición se evalúa a verdadera se regresa el control al inicio del bloque de sentencias y se vuelven a ejecutar todas para llegar de nueva cuenta a la evaluación de la condición; si esta sigue siendo verdadera se vuelve a repetir y así sucesivamente hasta que la condición resulte ser falsa y da por terminado el proceso. El siguiente programa imprime los 100 primeros números Algoritmo: Algoritmo cien_numeros inicio declarar variables enteras numero numero ← 1 escribir ( ‘ Programa cien números ‘) hacer escribir ( ‘ numero ‘ ) numero ← numero + 1 mientras ( numero < = 100 ) pausa fin Programa: #include <stdio.h> #include<conio.h> void main() { int numero; numero = 1; printf ( “ Programa cien numerous \n “ ); do { printf( “ %d \n “, numero); numero = numero + 1; } while ( numero < = 100); getch(); } Diferencias de la estructura while y do-while:

o La estructura while ejecuta el bloque de sentencias mientras la condición sea verdadera, como esta se encuentra al inicio del ciclo; si esta es falsa nunca se ejecuta el bloque de sentencias.

o La estructura do-while ejecuta siempre el bloque de sentencias al menos una vez, sin importar la condición que tenga, ya que esta se evalúa al final del ciclo de repetición (después de todas las sentencias).

o La estructura do-while se ejecuta al menos una vez, por el contrario, la estructura while es más general y permite la posibilidad de que nunca se ejecute el bucle.

3.3. Estructuras de Control



1

Las estructuras de control de un lenguaje de programación se refieren a él orden en que las instrucciones de un algoritmo se ejecutarán. El orden de ejecución de las sentencias o instrucciones determina el flujo de control.

Estas estructuras de control son por consiguiente fundamentales en los lenguajes de programación y en los diseños de algoritmos especialmente los pseudocódigos.

Las tres estructuras de control básico son:

• secuencia • selección • repetición

Figura 7. Estructuras de Control

Por lo regular en un programa los enunciados son ejecutados uno después del otro, en el orden en que aparecen escritos. Esto se conoce como ejecución secuencial. Sin embargo, existen enunciados que le permiten al programador especificar que el enunciado siguiente a ejecutar pueda ser otro diferente al que sigue en secuencia. Esto se conoce como transferencia de control.

Todos los programas pueden ser escritos en términos de solo tres estructuras de control, a saber, la estructura de secuencia, la estructura de selección y la estructura de repetición o bucle.

Hay dos tipos de sentencias condicionales o de selección, la sentencia if y switch, por otro lado para las de iteración se encuentran los bucles for, while, do-while.

Sentencia if

Sintaxis en su forma simple: si ( condición ) entonces Sentencia1 fin_si Sintaxis en su forma compuesta: si ( condición ) entonces

A

B

C

Secuencia

C

A B

Si No

Selección Iteración

C

B

No

Si



1

Sentencia1 si_no Sentencia2 fin_si La forma general de estas sentencias es: if (expresión) sentencia1 if (expresión) sentencia1 /*bloque1*/ else sentencia2 /*bloque2*/ Cuando dentro de cada sentencia se ejecutará más de una proceso, se deben de poner llaves para delimitar cuantas sentencias ejecutará cada bloque y en donde han de terminar estas. Sintaxis del ciclo if con más de una sentencia: si ( condición ) entonces {

bloque de Sentencias } fin_si Sintaxis en su forma compuesta: si ( condición ) entonces { bloque de sentencias } si_no { bloque de sentencias } fin_si La forma general de estas sentencias es: if (expresión) { sentencia1; sentencia2; sentencia3; . . . SentenciaN; } if (expresión) { sentencia1a; /*bloque1*/ sentencia2a; sentencia3a; .



1

. . sentenciaNa; } else { Sentencia1b; Sentencia2b; /*bloque2*/ Sentencia3b; . . . sentenciaNb; } Si la ejecución es verdadera se ejecuta la sentencia1 bloque1, si es falsa se ejecuta la sentencia 2 o bloque2. En donde los objetos de if y else son sentencias simples. La sentencia if es opcional. Es importante saber que solo se ejecutará una sentencia o un bloque, nunca ambos. Diagrama de Flujo del ciclo If:

Figura 8. Sentencia if Un ejemplo de uso de esta sentencia es el siguiente fragmento de programa, que decide si un número es par: Algoritmo: declarar variables enteras numero ← 0 esPar ← 0 si ( ( numero % 2 ) = 0 ) entonces esPar ← 1 fin_si Programa: int numero = 0, esPar = 0;

Condición

Sentencia 2 Sentencia 1

Si No



1

if ((numero % 2) == 0) esPar = 1;

Sentencia Switch:

Esta sentencia es de decisión con bifurcación múltiple, compara sucesivamente una variable con una lista de enteros. Cuando se obtiene una igualdad, se ejecuta una sentencia o bloque de sentencias. El default se ejecuta si no se encuentran igualdades. El default es opcional y si no esta presente no tiene lugar ninguna opción cuando todas las comprobaciones fallan. El switch defiere del if del que solo puede probar una igualdad, mientras que if puede evaluar una expresión relacional o lógica. La sentencia break se utiliza dentro de cada case, originando que el control del programa salga de la sentencia completa del switch y continua en la sentencia siguiente al switch, si no se encuentran las sentencias break, todas las sentencias antes y después de la igualdad se ejecutarán. Se puede pensar que case es una etiqueta para indicar donde debe seguir la ejecución, después de leer una opción desde el teclado. La forma general de esta sentencia es: según_sea (expresión exp) hacer { exp 1 : sentencia 1a; sentencia 2a; . . . break

exp 2 : sentencia 1b; sentencia 2b; . . . break

exp 3 : sentencia 1c; sentencia 2c; . . . break default : sentencia 1x break fin_según_sea Su representación en programación es: switch (expresión) { case exp 1: sentencia 1; sentencia 2; break; case exp 2: sentencia 1; sentencia 2; break;



1

case exp N: sentencia N; break; default: sentencia D; }

Diagrama de Flujo:

Figura 9. Estructura Switch Sentencia for Esta sentencia tiene como característica que permite la declaración de las variables dentro de su estructura. Ayudando a ser más entendible y legible su ejecución, como en él se inicializan los valores de las variables, se pueden dar incrementos o decrementos en las cantidades que uno desee al instante, esto es, antes de entrar al ciclo de repetición el programador ya sabe como va empezar y terminar con exactitud el ciclo y de cuanto en cuanto va a ir avanzando la variable. Sintaxis: para ( inicialización; condición; incremento) hacer sentencia Con más de una sentencia dentro del cuerpo del ciclo for quedaría: para ( inicialización; condición; incremento) hacer { bloque de sentencias } En Lenguaje C propiamente estaría:

sentencias

break break

Inicio

Evalúa Expresión

Case 1 Case 1 Case 1 Case 1

sentencias sentencias sentencias

break break

fin

sentencias

break break



1

for simple: for (expresion 1; expresion 2; expresion 3) sentencia; for compuesto por mas de una sentencia: for (expresion 1; expresion 2; expresion 3) { Sentencia1; Sentencia2; Sentencia3; . . . sentenciaN; } Expresión1 (inicialización).- declaración de las variables y asignación de valores iniciales. Expresión2 (condición).- instrucción que puede evaluarse de tal forma que se obtenga como resultado un valor de verdad (falso/true), mientras la condición se cumpla, se ejecutará. Expresión3 (control).- es el conjunto de instrucciones, separadas por comas, que controlan la variación de los valores de las variables utilizadas. Diagrama de Flujo del ciclo For

Sentencias

I ← vi I > vf I ← vi + y

Sentencias

Sentencias

No

Si



1

Figura 10. Estructura for En el diagram de flujo anterior se expresa el ciclo for con las literales siguientes: I = variable, vi = valor inicial, vf = valor final y Y = como un valor cualquiera de incremento para que nos ayude a salir del ciclo de repetición. Si la variable no cumple la condición, el ciclo se seguirá repitiendo, hasta que la condición se cumpla o sea verdadera el ciclo (bucle) se dará por terminado y por ende continúa el programa en la siguiente instrucción después del ciclo for. Algoritmo: inicio declarar entero contador para ( contador = 1; contador <= 10; contador++ ) hacer escribir ( ‘ contador ‘ ) fin_para Programa: #include <stdio.h> main() { int contador; for (contador=1; contador<=10; contador++) printf("%d ", contador); } Sentencia while Si se desea hacer que una parte del programa se repita mientras se cumpla una cierta condición, se puede usar la sentencia “while”. Mientras la condición se mantenga verdadera, el bloque de instrucciones se ejecutará ‘x’ cantidad de veces. Es necesario que alguna vez la condición se haga falsa, pues de lo contrario se haría un bucle infinito, por lo tanto es necesario que en el bloque se ejecute alguna acción que haga falsa la condición. La forma general de esta sentencia es: while (expresión) sentencia;



1

Algoritmo: De un mientras simple mientras ( condición ) hacer sentencia Algoritmo: De un mientras compuesto con más de una línea en el cuerpo del bucle mientras ( condición ) hacer { bloque de sentencias }

Diagrama de Flujo del While

Figura 11. Sentencia While Un ejemplo que nos diga si cada número que tecleemos es positivo o negativo, y que pare cuando tecleemos el número 0, podría ser: Algoritmo: inicio declarar variable

entera numero escribir ( ‘ Teclea un número (0 para salir) ‘ ) leer numero mientras numero > 0 hacer si numero > 0 escribir ( ‘ Es positivo ‘ ) si_no

sentencias

Mientras condición

Cuerpo del programa

(sentencias)

No

Si



1

escribir ( ‘ Es negativo ‘ ) fin_si escribir ( ‘ Teclea otro numero ( 0 para salir ) ‘ ) leer numero fin_mientras fin Programa: #include <stdio.h> main() { int numero; printf("Teclea un número (0 para salir): "); scanf("%d", &numero); while (numero!=0) { if (numero > 0) printf("Es positivo\n"); else printf("Es negativo\n"); printf("Teclea otro número (0 para salir): "); scanf("%d", &numero); } } Sentencia do-while Tiene un comportamiento similar al while, solo que en este caso la sentencia do-while, primero ejecutará la serie de instrucciones y después se evalúa la condición, con esto se asegura que el bloque se ejecutará al menos una sola vez. Sintaxis: hacer sentencias mientras (condición) En lenguaje C es así: do sentencia; while (condición); En el caso de la siguiente sintaxis se abren y cierran llaves debido a que no solo es una sentencia la que se va a realizar dentro del ciclo de repetición, sino que se ejecutarán muchas líneas de código (sentencias). do { bloque de sentencias; }while (condición);

Diagrama de Flujo del ciclo Do – While

Sentencias

Acciones

Mientras condición

verdadera

Falsa



1

Figura 12. Estructura do-while Veremos ahora un ejemplo en el cual se va a requerir una clave de acceso y no se va a dejar entrar hasta que se teclee la opción correcta. Algoritmo: inicio declarar variables Enteras valida = 711, clave hacer escribir ( ‘ Introduzca su clave numérica: ‘ ) leer clave si clave != valida escribir ( ‘ No válida ! ‘ ) fin_si mientras_que ( clave != valida ) escribir ( ‘ Aceptada. ‘ ) fin Programa: #include <stdio.h> int main() { int valida = 711; int clave; do { printf("Introduzca su clave numérica: "); scanf("%d", &clave); if (clave != valida) printf("No válida!\n"); } while (clave != valida); printf("Aceptada.\n"); } 3.3.1 Ruptura de un Lazo

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



1

Sentencia break

La sentencia break tiene dos usos. El primer uso es terminar un case en la sentencia del switch. El segundo es ser 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).

Cuando se encuentra la sentencia break en un bucle, la computadora termina inmediatamente el bucle y el control del programa vuelve a la sentencia siguiente del bucle, por ejemplo:

Algoritmo: inicio declarar variables entero t para ( t = 0;t < 100;t++ ) hacer escribir ( ‘ t ‘ ) si ( t = 10 ) entonces

romper fin_si fin_para pausa fin Programa: int main() { int t; for(t=0;t<100;t++) { printf(“%d”,t); if(t==10) break; } getch(); } Este programa imprime el número de 0 a 10 en la pantalla y después termina porque el break causa la salida inmediata del bucle. El break salta la prueba condicional t<100 construida en el bucle. Sentencia continue La sentencia continue funciona de manera similar a la sentencia break. Sin embargo, en vez de forzar la continuación, continue fuerza la siguiente iteración y salta cualquier código entre medias. Por ejemplo, el siguiente programa solo visualiza los números pares. Algoritmo: inicio declarar variables entero x para ( x = 0; x < 100; x++ ) hacer si ( x % 2 ) entonces continua fin_si



1

escribir ( ‘ x ‘ ) fin_para pausa fin Programa: int main() { int x; for(x=0;x<100;x++) { if(x%2) continue; printf(“%d”,x); } getch(); } Cada vez que el programa genera un número impar, la sentencia if ejecuta ya que el resto de un numero impar entre 2 es igual a 1, que es verdad. Así un número impar provoca la ejecución de continue, que provocará que ocurra la siguiente iteración, saltando la sentencia printf. En los bucles while y do - while, una sentencia continue provoca que el control del programa vaya directo a la prueba condicional y después continue el proceso del bucle. En el caso del for la computadora realiza primero la parte de incremento del bucle y después la prueba condicional, después continúa finalmente el bucle. Se puede usar continue para expeditar la terminación de un bucle forzando a la computadora a realizar la prueba condicional tan pronto como encuentra alguna condición de terminación.

UNIDAD III ESTRUCUTRAS DE FLUJO PROGRAMÁTICO · 2016. 9. 26. · UNIDAD III ESTRUCUTRAS DE FLUJO...

Documents

Transcript of UNIDAD III ESTRUCUTRAS DE FLUJO PROGRAMÁTICO · 2016. 9. 26. · UNIDAD III ESTRUCUTRAS DE FLUJO...