Fundamentos de Computación

Sentencias de ControlI 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ón Pseudo-código Lenguaje C

Leer un entero Read(n1); n1 = GetInteger();

Asignación de resultados

total = n1 + n2; total = n1 + n2;

Mostrar por pantalla

Write (“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 = 1d = 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 < 10 if ( 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 derechaLa evaluación termina una vez que el resultado pueda ser determinadoSi 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 && exp2 b) 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 h

ay

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(“Negativo”

)Escribir(“Positivor

”)

Fin

Escribir(“?”)

Escribir(“Cero”)

n> 0

n== 0

Inicio

n mod 2 == 0

Leer(n)

Escribir(“Imp

ar”)

Escribir(“Pa

r”)

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 c1:

sentencias1;break;

case c2:sentencias2;break;

…default:

sentenciasdef;break;

}

Select(e){case c1:

sentencias1;break;

case c2:sentencias2;break;

…default:

sentenciasdef;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.

SOLUCIONBegin(){ 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)