Fundamentos de Computación Sentencias de Control I Parte

Objetivos Comprender la relación entre sentencias y expresiones. Reconocer que el signo = es utilizado como operador de asignación en lenguaje C. Comprender que las sentencias pueden ser agrupadas en bloques. Reconocer que las sentencias de control se clasifican en: condicionales e iterativas. Aprender la manipulación de datos booleanos y apreciar su importancia. Incrementar la familiaridad con los operadores relacionales: ==, !=, >, >=, <, <=. Comprender el comportamiento de operadores: &&, || y !. Conocer los detalles de las sentencias de control condicionales: if y switch.

Introducción Las instrucciones u órdenes que le damos al computador también se conocen como sentencias. Algunas bien simples ya las hemos utilizado: asignar expresiones, imprimir en pantalla, leer datos ingresados por teclado. Existen otras sentencias más complejas, para ordenar la repetición de otras o que ayudan a elegir que sentencias ejecutar. Por ejemplo el for. De esta forma podemos concluir que las sentencias pueden clasificarse en dos grandes grupos: –Sentencias simples –Sentencias de control

Sentencias Simples Se utilizan para dar órdenes sencillas al computador: InstrucciónPseudo-códigoLenguaje C Leer un enteroRead(n1);n1 = GetInteger(); Asignación de resultados total = n1 + n2; Mostrar por pantallaWrite (“El total es “, total);printf (“El total es %d”, total); Al ejecutarse la sentencia, el resultado de la expresión se pierde. No es asignado!!!! En C las sentencias son expresiones que terminan con un ; Hay sentencias que se pueden escribir, pero que no son muy útiles: n1 + n2;

Asignaciones Las asignaciones, también expresiones, en las cuales interviene un operador (=) y dos operandos. El operador = es, así como el +, -, etc, un operador binario. El resultado de la operación de asignación es el mismo valor que se asigna al operando de la izquierda. Esta operación puede participar en una expresion, y ser evaluada: El resultado de esta expresión es 13 (x = 6) + (y = 7) Las asignaciones escritas como parte de una expresión más larga se conocen como asignaciones incrustadas. Se trata de no utilizar esta forma de trabajar, pues hace los programas difíciles de leer.

Asignaciones El uso más popular y conveniente de las asignaciones incrustadas es al efectuar una asignación múltiple. En este tipo de asignaciones se debe tener mucho cuidado con que las variables que intervienen sean del mismo tipo, para evitar conversiones de entre tipos: int i; double d; d = i = 1.5; i = 1 d = 1.0 n1 = n2 = n3 = 0; n1 = (n2 = (n3 = 0));

Bloques Una secuencia de pasos que se siguen para resolver un problema, forman una “unidad coherente”, o bloque de sentencias Un bloque de sentencias se encierra entre llaves { sentencia1; sentencia2; sentencia3; } Así, podemos ahora concluir que el grupo de sentencias del programa principal, es un bloque. Las sentencias dentro de una sentencia de control, se consideran también un bloque. C trata los bloques como una sola sentencia, por lo cual los bloques también se conocen como sentencias compuestas. Las sentencias dentro de un bloque conservan un margen con respecto a las llaves que las limitan

Sentencias de Control Las sentencias que afectan la forma como se ejecutan otras sentencias, se conocen como sentencias de control. Son de dos tipos: –Condicionales Nos permiten decidir que camino seguir, en base al resultado de una condición: if, select (if, switch) –Repetitivas Nos permiten repetir un grupo de sentencias un número específico de veces, o hasta que cierto evento se de: for, while, repeat, do… while().

Una sentencia de control, consiste de dos partes: –Línea de control Especifica la naturaleza de la repetición, o de la condición. –Cuerpo Formado por las sentencias que serán afectadas por la línea de control, conforman un bloque. En el caso de las sentencias condicionales, el cuerpo puede estar dividido en dos partes. Las sentencias que forman parte del cuerpo pueden ser simples, o de control, en cuyo caso se habla de sentencias anidadas. Sentencias de Control

Sentencias Condicionales: IF El resultado de una expresión que establece una condición es TRUE o FALSE. Para construir expresiones condicionales, se utilizan los operadores lógicos y los relacionales. Siempre es conveniente tener en cuenta lo siguiente: –No confundir el operador de asignación =, con el operador de equivalencia ==. if(x = 0) … if(x == 0) … Los operadores relacionales sólo pueden ser usados para comparar tipos de datos atómicos (que no están compuestos de otros tipos de datos). No pueden ser utilizados para comparar cadenas. Esta es la operación de asignación, asigna 0 a x, no compara. Esta es la operación relacional, pregunta si x es igual a 0.

–Debemos tener mucho cuidado al interpretar las condiciones, recordando siempre las Leyes de Morgan: Si x no es igual a 2 ni a 3 if (x!=2 && x!=3)... Otro error común se da al trasladar expresiones relacionales matemáticas: 0 < x < 10if ( 0 < x && x < 10)... Sentencias Condicionales: IF

Evaluando Condiciones En lenguaje C, las expresiones que usan && y || se evalúan de la siguiente forma: Las subexpresiones son evaluadas de izquierda a derecha La evaluación termina una vez que el resultado pueda ser determinado Si exp1 es falso en el caso a), entonces toda la expresión es falsa, y allí termina la evaluación. Si exp1 es verdadera en el caso b), entonces toda la expresión es verdadera. Se desea crear una condición para saber si y es divisible para x, pero revisando que x no sea cero. a)exp1 && exp2b)exp1 || exp2 if ((x!=0) && (y%x == 0))

Banderas Las variables de tipo Bool, se denominan también banderas. La variable bool done: Puede ser “activar” o “desactivar” para indicar terminos o inicios de fases en un programa bool done; done = TRUE; A una variable tipo bool también se le puede asignar el resultado de cualquier expresión relacional y/o lógica done = ( x == 0); done = ( x !=0 && y%x == 0);

Redundancias Al utilizar condiciones, un programador novato puede cometer algunas “redundancias”, que debe evitar, para mejorar la legibilidad, y la repeticion innecesaria de sentencias if (x == 0) { done = TRUE; } else { done = FALSE; } end if si (done == TRUE)…. Sin redundar if (done)...done = (x == 0); Sin redundar

Ejercicio en Clase Se desea que la computadora nos ayude a determinar si un año dado es o no bisiesto. Los años bisiestos se dan cada 4 años, con la excepción de los años que terminan en 00, que solo son bisiestos si son divisibles para 400. El 1900 no era un año bisiesto, a pesar de que 1900 era divisible para 4. El año 2000 fue bisiesto, porque es divisible para 400

inicio Lee(año ) ((año%4 == 0) &&(año%100!= 0)) || (y%400== 0) Escribe(“Es bisiesto”) Escribe(“No es bisiesto”) fin Begin { int anio; bool EsBisiesto; Write(“Programa para determinar año bisiesto”); Write(“Ingrese año:”); Read(anio); EsBisiesto = ((anio%4 == 0) && (anio%100!=0)) || (anio%400 == 0) if (EsBisiesto) Write(anio,”es bisiesto”); else Write(anio,”no es bisiesto”); } End void main() { int anio; bool EsBisiesto; printf(“Programa para determinar a%co bisiesto\n”,163); printf(“Ingrese anio:”); anio = GetInteger(); EsBisiesto = ((anio%4 == 0) && (anio%100!=0)) || (y%400 == 0) if(EsBisiesto) printf(” %d es bisiesto\n”, anio); else printf(” %d no es bisiesto\n”, anio); } Las condiciones para que un año sea bisiesto son: –Si es divisible para 4 y no termina en 00 (divisible para 100) –Si es divisible para 400. ((anio%4 == 0) && (anio%100!=0)) || (anio%400 == 0) Solución

Sentencias Condicionales: IF En su forma mas simple, la sintaxis de la sentencia if: if (condicion) sentencia; Sin embargo, si cuando la condición se cumple, se desea ejecutar un grupo de sentencias, la forma sería: if(condicion) { sentencia1; sentencia2; } if(condicion) { sentencia1; sentencia2; } else { sentencia1; sentencia2; } La clausula “entonces”. Las sentencias se ejecutan si se cumple la condicion La clausula “else”. Las sentencias dentro, se ejecutan cuando no se cumple la condicion

Formas de la Sentencia IF Varias sentencias, encerradas en un bloque. Cuando el cuerpo consista de mas de una sentencia. Una sentencia si-sino(if-else), siempre usara bloques para encerrar sus sentencias if(condicion) sentencia; if(condicion){ sentencias; } if(condicion){ sentenciasT; } else { sentenciasF; } Una sola sentencia, se usa solo cuando no existe cláusula else, y el cuerpo de la sentencia esta compuesto por una sola línea En cascada. La cláusula else consiste de sentencia if. Se utiliza cuando hay que elegir entre mas de dos opciones. Si el programa entra al ultimo else, es porque las otras posibilidades fueron todas falsas if(condicion1){ sentencias1; } else if(condicion2){ sentencias2; } else if(condicion3){ sentencias3; } else { sentencias; } No hay l í mite

Ejercicios en Clase Ejercicio 1: Se desea determinar si un número entero ingresado por teclado es par. Ejercicio 2: Se desea determinar si un número entero, ingresado por teclado es positivo, negativo, o cero.

Inicio n< 0 Leer(n) Escribir (“Nega tivo”) Escribi r(“Posi tivor”) Fin Escribir(“?”) Escribi r(“Cer o”) n> 0 n== 0 Inicio n mod 2 == 0 Leer(n) Escribir (“Impa r”) Escribi r(“Par” ) Fin Escribir(“?”) Begin() { int n; Write(“Ingrese numero:”); Read(n); If (n>0){ Write(“Es positivo”); } else if (n<0){ Write(“Es negativo”); } else { Write(“Es nulo”); } }End void main() { int n; printf(“Ingrese numero:”); n = GetInteger(); if(n< 0){ printf(“%d es negativo”,n); }else if(n >0){ printf(“%d es positivo”,n); }else{ printf(“%d es nulo”,n); } Solución Begin() { int n; Write(“Ingrese numero:”); Read(n); If(n mod 2 == 0){ Write(“El numero es par”); }else{ Write(“El numero es impar”); } }End main() { int n; printf(“Ingrese un numero:”); n = GetInteger(); if(n%2 == 0){ printf(“%d es par”,n); }else{ printf(“%d es impar”,n); }

Investigación Investigar sobre el operador ?: –¿Para qué sirve? –¿Cuántos operandos necesita? –Exprese las siguientes sentencias, usando el operador ?: if(nItems > 1) { printf(“%d items encontrados.\n”,nItems); } else { printf(“%d item encontrado.\n”,nItems); } if(grade >= 60) { printf(“Aprobado”); } else { printf(“Reprobado”); }

Sentencias Condicionales: Select (SWITCH) La sentencia if es ideal para poder elegir entre dos opciones, sin embargo, frente a mas opciones, se vuelve un poco tediosa y confusa La sentencia select(switch en C) es mucho mas práctica en estos casos La línea de control indica de quien va a depender la decisión, y el cuerpo, indica las opciones disponibles switch(e){ case c 1 : sentencias 1 ; break; case c 2 : sentencias 2 ; break; … default: sentencias def ; break; } Select(e){ case c 1 : sentencias 1 ; break; case c 2 : sentencias 2 ; break; … default: sentencias def ; break; } e es una expresión, puede ser una sola variable o una llamada a una función, o una expresión completa Cada ci se refiere a un valor constante entero, no puede ser expresión Select(e), significa que las decisiones se tomaran dependiendo del valor de e Este grupo de sentencias se ejecutaran solo si e coincide con c1 El caso debe terminar, para salir de la sentencia. Si no se termina, el programa pasara al siguiente caso Este caso es opcional. Las sentencias de este caso se ejecutaran solo si e no coincide con ninguna otra opción

Ejercicio en Clase Ejercicio 3: Dados tres números enteros denominados OP, A y B, se pide en función del valor de OP calcular la operación entre A y B según se indica a continuación: –Si OP es igual 0 entonces A y B se suman –Si OP es igual 1 entonces A y B se restan –Si OP es igual 2 entonces A y B se multiplican –Si OP es igual a 3 entonces A se divide para B –Si OP es distinto a los valores anteriores, el programa mostrará un mensaje indicando que la opción no es válida.

SOLUCION Begin() { int a, b, op; Write(“Ingrese la operacion:”); Read(op); Write(“Ingrese A:”); Read(a); Write(“Ingrese B:”); Read(b); select(op){ case 0: Write(a+b); break; case 1: Write(a-b); break; case 2: Write(a*b); break; case 3: Write(a/b); break; default: Write(“No valido”); } }End void main() { int a, b, op; printf(“Ingrese la operacion:”); op = GetInteger(); printf(“Ingrese A:”); a = GetInteger(); printf(“Ingrese B:”); b = GetInteger(); switch(op){ case 0: printf(“La suma es: %d”, a+b); break; case 1: printf(“La resta es: %d”, a-b); break; case 2: printf(“La multiplicacion es: %d”, a*b); break; case 3: printf(“La division es: %.2f”, a/b); break; default: printf(“No valido”); } Escribir(“No valido”) Inicio Fin Leer(a); Leer(b); Leer(op); Escribir(a+b ) op == 0 op == 1 op == 2 op == 3 Escribir(a- b) Escribir(a*b ) Escribir(a/b )