TEMA 3: Sentencias Las sentencias o instrucciones se pueden dividir principalmente en tres grandes grupos: - Sentencias Simples. - Sentencias Compuestas. - Sentencias de control del flujo del algoritmo. Las Sentencias Simples son del tipo de: - Asignación de Variables y Constantes. - Llamadas a Procedimientos y Funciones, dentro de estas últimas englobamos todas las funciones y procedimientos que conforman la librería general de sentencias que veremos posteriormente. Las Sentencias Compuestas: - Son aquellas que están limitas dentro de Procedimientos o Funciones. Las Sentencias de Control de Flujo: - Sentencias Reiterativas: Mientras, Repetir, Para. - Sentencias Condicionales: Si, Case... of 3.1 Aritméticas y varias funciones. Dentro de la asignaciones de variables juega un gran papel los operadores y funciones matemáticas, tales como: +-------------+-----------------------------------------------+ | + | Suma | | - | Resta | | * | Producto | | / | División (devuelve un valor real) | | div | División (devuelve un valor entero) | | mod | Cálculo del módulo aritmético. | | log | Logaritmo en base 10 | | ln | Logaritmo neperiano | | exp | Exponencial de un número | | pow | Potencia de un número | | random | Obtención de un número aleatorio | | abs | Obtenemos el valor absoluto de un número | | sqr | Obtención del cuadrado de un número | | sqrt | Obtención de la raíz cuadrada | | sin,cos,tan | Funciones trigonométricas | | chr/toascii | Obtenemos un carácter a partir de un número | | ord | Obtenemos el número correspondiente al código | | | ASCII | +-------------+-----------------------------------------------+ Lógicamente, existen más funciones aritméticas que veremos más adelante. 3.2 Sentencias de Control. Como ya dijimos en la introducción del tema 3, las sentencias de control son aquellas que interrumpen la ejecución secuencial de las instrucciones de un algoritmo, permitiendo la generación de reiteraciones. 3.2.1 Condicionales (Si y Case). La función SI, viene acompañada por una serie de elementos que son los operadores relacionales y operadores booleanos. Los operadores relacionales son los siguientes: +----+-----------------+ | = | Igual a | | < | menor que | | > | mayor que | | <= | menor o igual a | | >= | mayor o igual a | | <> | distinto de | +----+-----------------+ Estos operadores nos van a servir generalmente para comparar y comprobar los valores que toman las variables a lo largo del algoritmo, y dependiendo de los resultados, realizar una cosa u otra. Operadores booleanos: Los operadores booleanos nos permiten generar condiciones compuestas. (AND, OR, XOR, NOT) Ejemplo: ¨Es la variable b mayor que 12 y la variable d igual a cierto? Operador AND: (debe cumplirse las dos condiciones) +--------------------------+ | true AND true -> true | | true AND false -> false | | false AND true -> false | | false AND false -> false | +--------------------------+ Operador OR: (debe cumplirse una de las dos condiciones) +-------------------------+ | true OR true -> true | | true OR false -> true | | false OR true -> true | | false OR false -> false | +-------------------------+ Operador XOR: (se cumple cuando las dos condiciones son distintas) +--------------------------+ | true XOR true -> false | | true XOR false -> true | | false XOR true -> true | | false XOR false -> false | +--------------------------+ Operador NOT: (niega el resultado de una condicion) +--------------------+ | NOT true -> false | | NOT false -> true | +--------------------+ - La sentencias SI puede tener las siguientes estructuras: +-Si (condición) entonces | ... +-Sino | ... +-Finsi También puede aparecer en estructuras más complejas: +-Si (condición1) entonces | +-Si (condición2) entonces | | ... | +-Finsi +-Sino | ... | +-Si (condición3) entonces | | ... | +-Sino | | ... | +-Finsi +-Finsi A este tipo de estructuras se le denomina "anidamiento o encadenamiento de sentencias SI". - En cuanto a la sentencia EN CASO hay que decir, que se trata de una simplificación de sentencias SI anidadas. De esta forma, sea una variable A tenemos la siguiente estructura de Si encadenados. +-Si (condición1) entonces | acción1 +-Sino Si (condición2) entonces | acción2 +-Sino Si (condición3) entonces | acción3 +-Sino | acción4 +-Finsi Con una estructura del tipo EN CASO, tendríamos el problema resuelto de la siguiente forma: +-En Caso de Variable | condición1: Acción1 | condición2: Acción2 | condición3: Acción3 +-En Otro Caso | Acción4 +-Fincaso 3.2.2 Bucles Mientras, Repetir y Para. Las iteraciones son otro tipo de sentencias de control. Las que veremos son las siguientes: Mientras, Repetir y Para. Siendo este último uno de los más usados. La utilización de un bucle en un programa permite la posibilidad de realizar iteraciones de secciones de código, evitando así andar con condiciones, etiquetas y la sentencia GOTO. Esta última sentencia GOTO, hay que evitarla en por todos los medios. Cualquier programa puede ser realizado sin tener que utilizar dicha sentencia; ya que su uso crea confusión a la hora de seguir la ejecución secuencial de las sentencias de un algoritmo. 3.2.2.1 Bucle Mientras. El bucle Mientras se caracteriza por ser utilizado cuando no conocemos el número de iteraciones con antelación. Es por ello que nos ayudamos de una comprobación o condición para la entrada/salida del mismo antes de realizar la ejecución de la sección del código a repetir; esto último nos posibilita el caso de no efectuar ninguna iteración (iteración=0). +-Algoritmo Multiplicar (mult1,mult2,resul) | Parámetros reales mult1,mult2,resul | | resul=0 | +-Mientras mult2>0 hacer | | resul=resul+mult1 | | mult2=mult2-1 | +-Finmientras +-Final 3.2.2.2 Bucle Repetir. El bucle Repetir se caracteriza porque al igual que el anterior no sabemos el número de iteraciones que debemos realizar, es por ello que se apoya en condiciones para salir del mismo. Al contrario que el anterior, la comprobación va al final del bucle, de esta forma, como mínimo siempre se produce una iteración. Veamos el algoritmo anterior utilizando el bucle repetir. +-Algoritmo Multiplicar (mult1,mult2,resul) | Parámetros reales mult1,mult2,resul | | resul=0 | +-Repetir | | resul=resul+mult1 | | mult2=mult2-1 | +-Hasta que mult2<=0 (o también hasta que not (mult2 >0) ) +-Final Una forma muy sencilla para pasar un bucle Mientras a Repetir, es hallando la condición opuesta, o bien poniendo un not en la comprobación, negando así la condición del mientras. También se puede hallar teniendo en cuenta el significado de los operadores relacionales y booleanos. +----------+----+ | NOT (<) | >= | | NOT (<=) | > | | NOT (>) | <= | ¦ * Negación de lo operadores ralacionales. | NOT (>=) | < | | NOT (=) | <> | | NOT (<>) | = | +----------+----+ 3.2.2.3 Bucle Para Lo que caracteriza al bucle Para es que ya sabemos con antelación el número de iteraciones a realizar. Es por ello que no nos hace falta una comprobación de salida y/o entrada. También existe la posibilidad de realizar 0 iteraciones, cuando la variable secundaria es menor que la primaria. Otra característica, es la posibilidad de realizar incrementos de n en n en el contador del bucle. Pasemos a ver el algoritmo anterior mediante un bucle Para. +-Algoritmo Multiplicar (mult1,mult2,resul) | Parámetros reales mult1,mult2,resul | Variable Local loop | resul=0 | +-Para loop=1 hasta mult2 de incremento 1 hacer | | resul=resul+mult1 | | mult2=mult2-1 | +-Finpara +-Final En este caso, la variable primaria es "loop" y la secundaria es "mult2". Si esta última toma un valor inferior a la primaria, entonces el bucle no se realiza. Obsérvese que hemos puesto el incremento= 1, este es el valor que posee el bucle Para por defecto, es por ello que cuando el incremento es de 1 en 1, no se debe especificar.