curso de modula-2 (incompleto)

5/21/2018 Curso de Modula-2 (Incompleto)

1/171

Tema 3. Introduccin al lenguaje de programacin Modula-2 1

Informtica Facultad de Ciencias (Matemticas)

Departamento de Lenguajes y Ciencias dela Computacin

UNIVERSIDAD DE MLAGA

Apuntes para la asignatura

InformticaFacultad de Ciencias (Matemticas)

http://www.lcc.uma.es/personal/pepeg/mates

Tema 3. Introduccin al lenguaje de programacinModula-2

3.1 Valores y tipos ................................................................ ................................ ....3

3.2 Representacin de constantes ................................................................ ...........3

3.2.1 Valores numricos enteros................................................................ ............4

3.2.2 Valores numricos reales................................................................ .............. 4

3.2.3 Caracteres ................................................................ ................................ ....5

3.2.4 Cadenas de caracteres (Strings)................................................................ ...5

3.3 Tipos predefinidos ................................................................ .............................. 6

3.3.1 El tipo INTEGER................................................................ ........................... 6

3.3.2 El tipo CARDINAL................................................................ .........................7

3.3.3 El tipo REAL................................................................ ................................ ..7

3.3.4 El tipo LONGREAL................................................................ ........................ 8

3.3.5 El tipo CHAR................................................................................................ .9

3.4 Expresiones aritmticas......................................................................................9

3.5 Identificadores ................................................................ ................................ ..10

3.6 Constantes ................................................................ ................................ .......12

3.7 Variables................................................................ ................................ ...........13

3.7.1 Declaracin de variables ................................................................ ............

.143.7.2 Sentencia de asignacin ................................................................ .............14

3.8 Operaciones de Entrada y Salida. ................................ ................................ ....16

3.8.1 Operaciones de Salida................................................................ ................ 16

3.8.2 Operaciones de Entrada ................................................................ .............18

3.9 Estructura general de un programa ................................................................ ..20

Bibliografa

Programacin 1. Jos A. Cerrada y Manuel Collado. Universidad Nacional deEducacin a Distancia.


2/171

2 3.1 Valores y tipos

Jos E. Gallardo Ruiz Dpto. Lenguajes y Ciencias de la Computacin - UMACarmen M. Garca Lpez

Programming with TopSpeed Modula-2.Barry Cornelius. Addison-Wesley.


3/171



Introduccin

Modula-2 fue diseado por Niklaus Wirth y es uno de los lenguajes de programacin de altonivel ms utilizado actualmente para la enseanza de la programacin de ordenadores. Existen

varias versiones de este lenguaje. Nos centraremos en el resto del curso en el estudio de una delas versiones ms populares: TopSpeed Modula-2.

Una de las caractersticas que diferencia a un lenguaje de programacin de otras notacionespara expresar algoritmos, como el pseudocdigo, es la menor flexibilidad del primero. Enefecto, un programa escrito en un lenguaje de programacin de alto nivel consta de una serie deinstrucciones (o sentencias) que indican al ordenador los pasos a seguir para resolver ciertoproblema. Al conjunto de reglas que dictan cules son las instrucciones posibles y el modo decombinarlas se denomina sintaxis del lenguaje. En este tema comenzaremos el estudio de lasintaxis del lenguaje Modula-2. Para definir cada una de las reglas utilizaremos la notacinBNF. Finalizaremos el tema con un ejemplo completo de un programa escrito en Modula-2queel alumno podr probar en la primera prctica de la asignatura.

3.1 Valores y tipos

Todo programa de ordenador manipula una serie de datos para obtener unos resultados.Definimos dato como un elemento de informacin que puede tomar un valor entre variosposibles.

En programacin, un dato puede tomar valores de una sola clase. No tiene sentido decir que elnombre de una persona es 24. Tampoco lo tiene decir que el nmero de personas en una clasees Pedro. A las distintas clases de valores se denominan tipos. As, un dato tiene asociadoun tipo que representa cual es la clase de valores que puede tomar. Algunos ejemplos de tipos

son:

Valores numricos enteros positivos y negativos: 100, -24, 36, ...

Valores numricos enteros y positivos: 0, 1, 2, 3, ...

Valores numricos reales: 3.1415, -16.18,...

Valores carcter: a, b, c,...

Para cada tipo habr una serie de operaciones que se le pueda aplicar. As, tiene sentido sumardos valores numricos, pero no dos letras. Se llama tipo abstracto de datosa un conjuntode valores junto con las operaciones que permiten manipular stos.

Dentro de un programa existirn dos tipos de valores: Valores constantes: se trata de valores cuya magnitud no cambia durante cualquier

ejecucin del programa.

Valores variables: la magnitud puede tener distintos valores en distintos puntos delprograma.

3.2 Representacin de constantes

Uno de los objetivos de los lenguajes de programacin es evitar las ambigedades oimprecisiones que existen en los lenguajes naturales. Por ejemplo, los anglosajones utilizan la

coma para separar millares, mientras que nosotros la usamos para separar la parte entera de ladecimal:


4/171

4 3.2 Representacin de constantes


348,536 anglosajones trescientos cuarenta y ocho mil quinientos treinta y seis

Espaa trescientos cuarenta y ocho con quinientas treinta y seis

Estudiaremos a continuacin las distintas reglas que sigue el lenguaje Modula-2 pararepresentar valores de tipo numrico y de tipo carcter.

3.2.1 Valores numricos enteros

Los valores numricos enteros representan un nmero exacto de unidades y no pueden tenerparte fraccionaria. Un valor entero en Modula-2 se escribe con una secuencia de 1 o ms dgitosdel 0 al 9 no separados entre ellos y precedido opcionalmente de los signos mas (+) o menos (-).Ejemplos de valores vlidos son:

2

+56

0

-2345

1000

Ejemplos de valores no vlidos son:

123,32 NO se pueden insertar comas

22.56 NO se pueden insertar puntos

13B7 NO se pueden insertar letras

Usando la notacin BNF:

Valor_Entero ::= [ + | - ]Secuencia_Digitos

Secuencia_Digitos ::= Digito {Digito }

Digito ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

3.2.2 Valores numricos reales

Los valores numricos reales permiten expresar cualquier cantidad, incluyendo fracciones deunidad. En Modula-2, se pueden representar de dos modos: notacin decimal habitual onotacin cientfica.

En la notacin decimal habitual, un valor real se escribe con una parte entera terminada siempreen un punto (.) seguida, opcionalmente, por una secuencia de dgitos que constituyen la partedecimal. Ejemplos de valores vlidos son:

-0.78

5.

+234.53

En la notacin cientfica, un valor real se escribe como una mantisa, que es un nmero real ennotacin decimal habitual, seguido de la letra E y un exponente entero que indica la potencia de10 por la que se multiplica la mantisa. Ejemplos de valores vlidos son:

-0.78E+2 equivale a 0.78 x 102

5.E-3 equivale a 5.0 x 10-3 = 0.005

+234.53E4 equivale a 234.53 x 104

Ejemplos de valores no vlidos son:.234 Es necesario al menos un dgito en la parte entera


5/171



2,56 NO se pueden insertar comas

13.4B7 NO se puede insertar la letra B

Obsrvese que podemos escribir un mismo valor de distintos modos:

45.6 456.E-14.56E+1 45.60E+0 456000.00E-4

La definicin usando notacin BNF es:

Valor_Real ::= Valor_Real_Decimal |Valor_Real_Cientfica

Valor_Real_Decimal ::= Valor_Entero . [Secuencia_Digitos ]

Valor_Real_Cientfica ::= Valor_Real_Decimal Factor_Escala

Factor_Escala ::= E Valor_Entero

3.2.3 Caracteres

Adems de tipos numricos, el lenguaje de programacin Modula-2permite operar valores de

tipo carcter. Se trata de las letras y signos que constituyen un texto. El valor correspondiente aun carcter concreto se expresa en Modula-2 escribiendo dicho carcter entre comillas (situado en la tecla correspondiente al nmero 2 del teclado de un PC) o apstrofos ( situadoen la tecla correspondiente al cierre de interrogacin). Ejemplos de valores vlidos son:

a Representa a la letra a minscula

A Representa tambin a la letra a minscula

? Representa el carcter correspondiente al cierre de interrogacin

Ejemplos de valores no vlidos son:

a Deben ir entre comillas o apstrofes.

ab Solo puede ir una letra

a Debe empezar y acabar con el mismo delimitador

Algunas observaciones son:

El espacio en blanco ( ) es un carcter vlido. A veces lo representaremos con b.

Hay que distinguir entre el nmero entero 7 y la letra 7.

El valor correspondiente al carcter apstrofo solo se puede representar entre comillas( ) y viceversa ( )

Usando notacin BNF:

Valor_Caracter ::= Caracter_menos_apostrofo | Caracter_menos_comillas

Caracter_menos_comillas ::= a |b |c |... |1 |2 |3 |... smbolos

Caracter_menos_comillas ::= a |b |c |... |1 |2 |3 |... smbolos

3.2.4 Cadenas de caracteres (Strings)

Normalmente no es suficiente trabajar con caracteres sueltos. Suele interesar trabajar conpalabras o frases. Estos valores se representan con cadenas de caracteres o Strings. Una cadenade caracteres se escribe como una secuencia de caracteres entre apstrofos o comillas.Ejemplos vlidos son:

Coche Representa la palabra CocheCoche Idem al anterior


6/171

6 3.3 Tipos predefinidos


La casa es verde Representa una frase

Algunas observaciones son:

Si una cadena incluye apstrofos en su interior slo podr escribirse entre comillas yviceversa. Ejemplo Incluir entre apstrofos texto.

Es posible definir una cadena que no contenga ningn carcter. A sta se llama cadenavaca y se escribe como o .

Usando notacin BNF:

Valor_Cadena ::= {Caracter_menos_apostrofo } | {Caracter_menos_comillas }

3.3 Tipos predefinidos

En programacin, un dato puede tomar valores de una sola clase y que a dicha clase se llamatipo del dato. En Mdula-2 existen tipos de datos predefinidos y sentencias para que el

programador defina nuevos tipos. Algunos de los tipos de datos predefinidos se designan conlos siguientes nombres: INTEGER, CARDINAL, REAL, LONGREAL, CHAR y BOOLEAN.Estudiaremos los cinco primeros a continuacin. Estudiaremos el tipo BOOLEAN y losmecanismos para definir nuevos tipos en temas posteriores.

3.3.1 El tipo INTEGER

En TopSpeed Modula-2 los valores de este tipo son los valores numricos enteros positivos ynegativos comprendidos en el rango [-32768 , 32767]. La representacin de cualquiera de estosvalores en la memoria del ordenador es exacta (no se producen errores de precisin aloperarlos).

En caso de no recordar estos valores, podemos hacer referencia a ellos con las expresionesMIN(INTEGER)yMAX(INTEGER).

Las operaciones definidas para valores de este tipo son las siguientes:

a + b. Suma de los enteros a y b

a b. Diferencia de los enteros a y b

a * b. Producto de los enteros a y b

a DIVb. Cociente resultante de dividir el entero a por el entero b.

aMODb. Resto resultante de dividir el entero a por el entero b.

ABS(a). Valor absoluto del entero a.

+ a. Devuelve el valor del entero a inalterado.

- a. Devuelve el valor del entero a negado.

Como puede observarse, los signos + y tienen un doble significado segn se usen comooperadores infijosentre dos enteros o prefijosfrente a un nico entero.

El operador DIVdevuelve la parte entera resultante de dividir un nmero entero por otro.MODdevuelve el resto correspondiente. Cuando el divisor es cero se produce un error. Se cumplesiempre la siguiente regla:

aMODb = a b (a DIVb)

Algunos ejemplos de uso de estos operadores son los siguientes:


7/171



Operacin Resultado

10 DIV3 3

10MOD3 1

(-20) DIV(-7) 2

(-20)MOD(-7) -617 DIV(-3) -5

17MOD(-3) 2

10 DIV0 Error

ABS(-2) 2

Cuando se estn operando datos de tipo INTEGER hay que tener en cuenta el rango de valoresvlidos. Si durante algn momento se produce un resultado fuera de dicho rango, el programaacabar con un error (suponemos que la opcin de chequeo de rangos del compilador estactivada). Debido a esto, la propiedad asociativa no es vlida para los datos del tipo INTEGERy ciertos operadores. Por ejemplo

Operacin Resultado

(32767 + 1) 10 Error

32767 + (1-10) 32758

ya que en la primera expresin la suma se sale del rango vlido.

3.3.2 El tipo CARDINAL

En TopSpeed Modula-2 los valores de este tipo son los valores numricos enteros positivoscomprendidos en el rango [0 , 65535]. La representacin de cualquiera de estos valores en lamemoria del ordenador es exacta (no se producen errores de precisin al operarlos).

En caso de no recordar el valor mximo, podemos nombrarlo con la expresinMAX(CARDINAL).

Con excepcin de la operacin de cambio de signo o negacin las operaciones son las mismasque para el tipo INTEGER.

Es un error intentar operar un dato de tipo INTEGER con otro de tipo CARDINAL. Slo sepueden operar datos del mismo tipo.

3.3.3 El tipo REAL

En TopSpeed Modula-2 los valores de este tipo son los valores numricos reales positivos ynegativos comprendidos en el rango [-3.4x1038, +3.4x1038]. La representacin de estos valoresen la memoria del ordenador no es exacta (se producen errores de precisin al operarlos). Semanejan valores aproximados.

Las operaciones definidas para valores de este tipo son las siguientes:

a + b. Suma de los reales a y b

a b. Diferencia de los reales a y b

a * b. Producto de los reales a y b

a / b. Cociente de los reales a y b ABS(a). Valor absoluto del real a.


8/171

8 3.3 Tipos predefinidos


+ a. Devuelve el valor del real a inalterado

- a. Devuelve el valor del real a negado.

En el caso de los reales la divisin no devuelve el cociente entero, sino el valor real resultantede dividir el cociente por el divisor. Para el tipo REAL NO existen las operaciones DIVyMOD.

Operacin Resultado

10.5 / 0.2 52.5

-15.4E2 + 450.0 -1090.0

3.3.4 El tipo LONGREAL

En TopSpeed Modula-2 los valores de este tipo son los valores numricos reales positivos ynegativos comprendidos en el rango [-1.7x10308, +1.7x10308]. La representacin de estos valoresen la memoria del ordenador no es exacta (se producen errores de precisin al operarlos). Semanejan valores aproximados.

Las operaciones definidas para valores de este tipo son las mismas que para el tipo REAL. Paravalores de este tipo estn tambin definidas las siguientes operaciones:

Sin(a): Devuelve el seno del valor LONGREAL a como un valor de tipo LONGREAL.

Cos(a): Devuelve el coseno del valor LONGREAL a como un valor de tipoLONGREAL.

Tan(a): Devuelve la tangente del valor LONGREAL a como un valor de tipoLONGREAL.

ASin(a): Devuelve el arco-seno del valor LONGREAL a como un valor de tipoLONGREAL.

ACos(a): Devuelve el arco-coseno del valor LONGREAL a como un valor de tipoLONGREAL.

ATan(a): Devuelve la arco-tangente del valor LONGREAL a como un valor de tipoLONGREAL.

Sqrt(a): Devuelve la raz cuadrada del valor LONGREAL a como un valor de tipoLONGREAL.

Exp(a): Devuelve la funcin exponencial del valor LONGREAL a como un valor detipo LONGREAL.

Log(a): Devuelve el logaritmo en base e del valor LONGREAL a como un valor de tipo

LONGREAL. Log10(a): Devuelve el logaritmo en base 10 del valor LONGREAL a como un valor de

tipo LONGREAL.

En el caso de las funciones trigonomtricas, todos los ngulos que se manejan estn expresadosen radianes, NO en grados.

Estas operaciones, a diferencia de todas las vistas hasta el momento, no estn disponibles demodo directo. Se encuentran en un mdulo de biblioteca (MATHLIB) y es necesario quesean importadas por el programa antes de ser usadas. Veremos posteriormente como seimportan operaciones de una biblioteca.

NOTA: Estas operaciones NO estn definidas para valores del tipo REAL.


9/171



3.3.5 El tipo CHAR

Este tipo incluye como valores todos los caracteres disponibles en el ordenador. Adems de loscaracteres alfabticos (letras), se incluyen caracteres numricos y de puntuacin.

Existen tres operaciones definidas para valores de este tipo:

ORD(x): Toma como argumento un carcter y devuelve su posicin dentro de la tablaASCII.

CHR(x): Toma como argumento un valor entre 0 y 255 devuelve el carcter que ocupadicha posicin dentro de la tabla ASCII.

CAP(x): Toma como argumento un carcter y si ste es una letra minscula devuelve laletra mayscula correspondiente. En otro caso, devuelve el mismo carcter que tomacomo argumento.

Ntese que las funciones CHR y ORD son inversas la una de la otra:

CHR(ORD(x)) = x ORD(CHR(x)) = x.

Ejemplos de uso son:

Operacin Resultado

ORD(A) 65

CHR(65) A

CHR(66) B

CAP(q) Q

CAP(Q) Q

CAP(?) ?

3.4 Expresiones aritmticas

Una expresin aritmtica representa un clculo a realizar con valores. Para ello se combinanoperandos y operadores.

Si no se utilizan parntesis, el orden en que se realizan las operaciones es el siguiente:

1 Cambios de signos: + y como prefijos

2 Operadores multiplicativos *, /, DIV, yMOD

3 Operadores aditivos: + y como infijos

Si aparece ms de un operador del mismo nivel, las operaciones se realizan de izquierda aderecha. Si una expresin va precedida de un cambio de signo se entiende que solamente afectaal prximo operando. Si se quiere que ste afecte a toda la expresin, sta deber incluirse entreparntesis.

Algunos ejemplos son:

Expresin Equivale a

5 * 30 + 5 (4*30)+5

334 DIV 6 MOD 4 * 5 ((334 DIV 6) MOD 4) * 5

-5 * 10 MOD 3 ((-5) * 10) MOD 3

(5 + 10) * 4 + 5 ((5 + 10) * 4) + 5

En caso de duda es mejor utilizar los parntesis.


10/171

10 3.5 Identificadores


EnModula-2, es un error operar datos de tipos distintos con los operadores aritmticos. En casode que sea necesario operar valores de tipos distintos utilizaremos las funciones de conversinREALy TRUNC:

REAL(a): toma un valor de tipo INTEGER o CARDINAL y devuelve el REALequivalente.

TRUNC(a): toma un valor de tipo REAL y devuelve el INTEGER o CARDINALequivalente. Para ello elimina la parte decimal del nmero original.

Expresin Equivale a

5.5 + REAL(10) 15.5

5.0 + REAL(10) 15.0

5.0 + 10 ERROR

5 + TRUNC(10.5) 15

5 + TRUNC(10.0) 15Obsrvese que el tipo del resultado siempre coincide con el tipo de los operandos (REAL en losdos primeros casos e INTEGER o CARDINAL en los dos ltimos).

3.5 Identificadores

En cualquier programa aparece una serie de datos que son manipulados por ste. La manera dehacer referencia a los diferentes elementos que intervienen en un programa es darles un nombreparticular a cada uno de ellos. En programacin, se llaman identificadores a los nombresusados para identificar cada elemento del programa.

En Modula-2, un identificador es una palabra formada por caracteres alfabticos o numricosseguidos (sin espacios en blanco o signos de puntuacin intercalados) y que debe comenzar poruna letra. Pueden usarse las letras maysculas y minsculas del alfabeto ingls y los dgitos del0 al 9. No se puede usar ni la ee ni vocales acentuadas en un identificador, aunque s sepueden usar en valores de tipo carcter y cadenas de caracteres.

Ejemplos de identificadores vlidos son:

Indice DiaDelMes Ejemplo1IdentificadorMuyLargo

Ejemplos de identificadores no vlidos:

3Ejemplo No pueden comenzar por un dgitoEjemplo$ No se pueden usar signos de puntuacin

Dia Del Mes No se pueden intercalar espacios

Ao No se puede usar la ee

En Modula-2, se distinguen las letras maysculas y minsculas, por lo que son identificadoresdiferentes DiaSemana, Diasemanay DIASEMANA.

La definicin de un identificador usando la notacin BNF es:


11/171



Identificador ::= Letra {Letra | Dgito }

Dgito ::= 0| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Letra ::= A| B| C| D| E| F| G| H| I| J| K| L| M| N| O|

P| Q| R| S| T| U| V| W| X| Y| Z|

a| b| c| d| e| f| g| h| i|j| k| l| m| n| o|

p| q| r| s| t| u| v| w| x| y| z|

Sin embargo, no todos los identificadores construidos usando la definicin anterior son vlidos.Existen una serie de palabras que tienen un significado especial y que, por tanto, no pueden serusadas como identificadores. Se trata de las palabras reservadas y los identificadorespredefinidos.

La lista de palabras reservadas en TopSpeed Modula-2es la siguiente:

AND FORWARD PROCEDURE

ARRAY FROM QUALIFIED

BEGIN GOTO RECORD

BY IF REPEAT

CASE IMPLEMENTATION RETURN

CONST IMPORT SET

DEFINITION IN THEN

DIV LABEL TO

DO LOOP TYPE

ELSE MOD UNTIL

ELSIF MODULE VAR

END NOT WHILE

EXIT OF WITH

EXPORT OR

FOR POINTER

La lista de identificadores predefinidos en TopSpeed Modula-2es la siguiente:

ABS FLOAT ODD

ADDRESS HALT ORD

ADR HIGH PROC

BITSET INC REAL

BOOLEAN INCL SHORTADDR

BYTE INTEGER SHORTCARD

CAP LONGCARD SHORTINT

CARDINAL LONGINT SIZE

CHAR LONGREAL TRUE

CHR LONGWORD TRUNC

DEC MAX VAL

DISPOSE MIN VSIZE

EXCL NEW WORD

FALSE NULLPROC

El programador puede redefinir los identificadores predefinidos, aunque esto no es una buenaprctica de programacin, ya que confundira a otros programadores que leyesen el programa y

esperasen el significado habitual. Por otro lado, no es posible redefinir las palabras reservadas.


12/171

12 3.6 Constantes


3.6 Constantes

Una constante es un valor fijo que se utiliza en un programa. El valor debe ser siempre elmismo en cualquier ejecucin del programa.

Algunos ejemplos de constantes son el nmero de meses del ao, el nmero de das de una

semana y la constante matemtica .

Es posible asociar un nombre a una constante mediante una declaracin de constante. Aspodemos asignar al identificador PIel valor 3.141592 mediante la siguiente declaracin:

CONSTPI = 3.141592;

La declaracin se inicia con la palabra reservada CONST, seguida del nombre de la constanteque se est definiendo, el signo igual y por ltimo, el valor asociado. La declaracin terminacon un punto y coma.

Una vez definida la constante puede utilizarse en expresiones. Las siguientes expresiones sonequivalentes:

2. * 3.141592 2. * PI

Tambin es posible declarar ms de una constante a la vez en un programa. Para ello secomienza con la palabra reservada CONST y se prosigue con las distintas declaracionesseparadas por punto y coma:

CONST

DIASSEMANA = 7;MESESANYO = 12;NUMEROE = 2.718281;LETRAPUNTO = '.';

Como puede observarse, es habitual definir una constante en cada lnea de texto y situar el

comienzo de cada declaracin de constante a la misma altura horizontal dentro de la lnea. Aesta prctica se llama indentacin. No es obligatoria pero si bastante conveniente ya quemejora la legibilidad del programa.

Cada constante tiene asociado de modo automtico un tipo:

DIASSEMANA Tipo INTEGER o CARDINAL

MESESANYO Tipo INTEGER o CARDINAL

NUMEROE Tipo REAL o LONGREAL

LETRAPUNTO Tipo CHAR

Es posible declarar el valor de una constante mediante una expresin siempre que todos los

operandos que intervengan en sta sean valores constantes y que las operaciones seanpredefinidas del lenguaje:

CONST

RADIO = 5.3;DIAMETRO = 2.0*RADIO;

La notacin BNF para las declaraciones de constantes es la siguiente:

Declaracin_de_Constantes ::= CONST {Asociacin_de_Constante ; }

Asociacin_de_Constante ::= Identificador = Expresin _Constante

Expresin_Constante ::= ...

Definiremos qu es una expresin constante en temas posteriores.


13/171



3.7 Variables

El concepto de variable en programacin es distinto al concepto de variable algebraica. Lasvariables algebraicas representan valores de modo que una vez asociada la variable a un valordeterminado dicho valor no cambia.

Ejemplo: Sea la siguiente ecuacin:

12 =x

el valor asociado a la variablexen este caso esx= .

En programacin el concepto de variable es distinto y est asociado a la memoria delordenador. La memoria del ordenador mantiene, adems de las instrucciones del programa, unaserie de datos. Una vez que el programa almacena un dato en una de las posiciones de lamemoria su valor se mantiene. Sin embargo, es posible modificar el valor cuantas veces sedesee.

Una variablerepresenta un valor almacenado en la memoria del ordenador, el cual puede serusado tantas veces como se desee. El valor de la variable puede ser modificado en cualquiermomento, y ser el nuevo valor el que estar almacenado en ella a partir de entonces.

Podemos ver una variable como una caja en la cual es posible almacenar un nico valor en unmomento dado. Es posible en todo momento consultar cul es el valor almacenado en la caja.Tambin es posible almacenar un nuevo valor en la caja de modo que el valor antiguo se pierdey el valor de la caja pasa a ser desde ese momento el nuevo valor almacenado.

Las variables de un programa se designan mediante nombres o identificadores. El identificadorde una variable representa el valor almacenado en dicha variable. El programador puede elegirlos nombres ms apropiados para las variables que utilice en su programa.

3.7.1 Declaracin de variables

En un programa enModula-2es necesario declarar cada una de las variables que se utilice. Paracada variable usada es necesario especificar su nombre y el tipo de valores que puede tomar.Esto quiere decir que si una variable se declara con tipo INTEGER, por ejemplo, podralmacenar en un momento un nico valor entero (un 3, un 20 15000) pero no podralmacenar un valor de otro tipo (CHAR o REAL, por ejemplo).

Ejemplo: Para usar una variable cuyo nombre sea Edad y que almacene un valor de tipoentero es necesario declararla del siguiente modo:

VAREdad : INTEGER;

Como puede observarse, una declaracin de variable consta de la palabra reservadaVARseguidadel nombre de la variable, un signo de dos puntos y el nombre del tipo de valor que puedetomar la variable. La declaracin termina con un punto y coma.

Es posible declarar ms de una variable usando una nica palabraVAR:

VAR Dia : INTEGER;Mes : INTEGER;Anyo : INTEGER;Letra : CHAR;


14/171

14 3.7 Variables


Si varias variables tienen el mismo tipo pueden declararse conjuntamente escribiendo susnombres seguidos, separados por comas. El ejemplo anterior puede escribirse de formaabreviada:

VAR Dia, Mes, Anyo : INTEGER;Letra : CHAR;

La descripcin BNF de la declaracin de variables es la siguiente:

Declaracin_de_Variables ::= VAR {Lista_de_Variables ; }

Lista_de_Variables ::= Lista_de_Identificadores : Tipo

Lista_de_Identificadores ::= Identificador {, Identificador}

Tipo ::= INTEGER |CARDINAL |REAL |LONGREAL |CHAR |...

La definicin de Tipo se completar en temas posteriores.

3.7.2 Sentencia de asignacinLa forma de conseguir que una variable guarde un nuevo valor es mediante la sentencia deasignacin. Mediante esta sentencia es posible:

Inicializar una variable: una variable declarada contiene un valor indeterminado hasta queexplcitamente se le da uno. Al hecho de dar un valor inicial a una variable se le llamainicializacinde la variable.

Modificar el valor que tenga: es posible modificar el valor que tenga una variable de modoque desde ese momento pase a contener un nuevo valor.

La forma de la sentencia de asignacin es la siguiente:

Sentencia_de_Asignacin ::= Nombre_de_Variable := Expresin

Nombre_de_Variable ::= Identificador

Expresin ::= ...

Una sentencia de asignacin consta del nombre de la variable que se quiere modificar, eloperador de asignacin (los caracteres dos puntos e igual seguidos y sin espacios entre ellos) yuna expresin que indica el nuevo valor de la variable.

El modo en el cual se ejecuta una sentencia de asignacin es el siguiente:

1) Se calcula el resultado correspondiente a la expresin que aparece a la derecha del

operador de asignacin.2) Se almacena el valor calculado en la variable cuyo nombre aparece a la izquierda del

operador de asignacin.

Para que una sentencia de asignacin sea correcta es imprescindible que el tipo de la expresina la derecha del operador de asignacin sea compatible con el tipo declarado para la variablecuyo nombre aparece a la izquierda. Suponiendo las siguientes declaraciones de variables:

VAR Num1 : INTEGERNum2 : CARDINAL;Num3 : REAL;Letra1, Letra2: CHAR;

son vlidas las siguientes sentencias de asignacin:Num1 := -10;


15/171



Num2 := 32+24;Num3 := 1.5E2;Letra1 := 1;Letra2 := ;

NOTA: En Modula-2 es necesario separar las distintas instrucciones del programa con el

smbolo punto y coma (;). Adems es habitual escribir cada instruccin en una lnea. Estoltimo no es obligatorio.

Sin embargo, las siguientes asignaciones no son vlidas:

Num1 := 40000; El valor mximo para un dato INTEGER es 32767

Num2 := -20; Un dato CARDINAL no puede tomar valores negativos.

Num3 := 10; La constante 10 es un entero y Num3es REAL;

Letra1 := 1; Letra1debe almacenar un carcter, no un nmero

Letra2 := ab; Letra2puede almacenar un nico carcter

Si intervienen variables o constantes en la expresin a la derecha de una sentencia deasignacin, se usar el valor que tengan en dicho momento. Por ejemplo la siguiente secuenciade asignaciones

CONST

DIASSEMANA = 7;VAR

a, b, c : INTEGER;

a := DIASSEMANA;b := 2 * a;c := a + b;

dejar como valores almacenados en las variables a, b y c los valores 7, 14 y 21respectivamente.

Un caso que requiere cierta atencin es aqul en el que la variable que est siendo modificadaforma parte de la expresin. Por ejemplo:

a := DIASSEMANA;a := a + 1;

A la hora de ejecutar la segunda sentencia de asignacin se siguen los pasos que vimos alprincipio de este apartado:

1) Se calcula el valor de la expresin a la derecha del operador de asignacin: a + 1 = 7 +1 = 8

2) Se almacena dicho valor en la variable que aparece a la izquierda: el nuevo valor de lavariable apasa a ser 8.

Como puede observarse, la sentencia a := a + 1tiene como resultado que la variable avea suvalor incrementado en una unidad. Tambin es posible decrementar el valor de una variable enun unidad (a := a 1), o en cualquier nmero de unidades (a := a + 20hace que el valoralmacenado en la variable aaumente en veinte unidades).

Dado que es muy habitual incrementar y decrementar el valor de variables Modula-2 cuentacon dos instrucciones para ello INCy DEC:

INC(x) x := x + 1

DEC(x) x := x + 1INC(x, 10) x := x + 10


16/171

16 3.8 Operaciones de Entrada y Salida


DEC(x, 10) x := x - 10

Veamos un ejemplo de cmo van modificndose los valores de las variables durante laejecucin de un pequeo programa:

VAR Posi : CARDINAL;Dato : INTEGER;

EjeX, EjeY : REAL;

EjeX EJeY Dato Posi Sentencias

? ? ? ? Ejex := 34.89;

34.89 ? ? ? Dato := 67;

34.89 ? 67 ? Posi := TRUNC(EjeX) + Dato;

34.89 ? 67 101 Dato := TRUNC(EjeY) + Posi;

34.89 ? ? 101 EjeY := EjeX +REAL(Posi);

34.89 135.89 ? 101 Dato := PosiDIV5;

34.89 135.89 20 101

3.8 Operaciones de Entrada y Salida

La mayora de los programas necesitan una serie de datos. Estos datos suelen ser introducidospor una persona usando alguna unidad de entrada (generalmente el teclado del ordenador). Senecesitan instrucciones que permitan a un programa escrito enModula-2pedir un dato desde elteclado (o desde otra unidad de entrada) y guardarlo en una variable. A este tipo deinstrucciones se les llama operaciones de entrada.

De un modo similar, la mayora de los programas suelen calcular unos resultados que hay que

emitir al exterior a travs de una unidad de salida (generalmente la pantalla del ordenador).Necesitamos instrucciones que permitan a un programa escrito en Modula-2enviar resultadosal exterior. A este tipo de instrucciones se les denomina operaciones de salida.

En Mdula-2 las instrucciones para efectuar E/S se encuentran en mdulos de biblioteca, esdecir, mdulos preprogramados disponibles para el programador. La biblioteca donde estnimplementadas estas instrucciones depende del compilador de Modula-2que se utilice. En elcaso de Top Speed Modula-2estn contenidas en la biblioteca IO (Input-Output) y se describena continuacin.

3.8.1 Operaciones de Salida

Las principales operaciones de salida definidas en el modulo de biblioteca IO son lassiguientes:

WrChar(c): escribe en pantalla el valor de cque debe ser una expresin de tipo CHAR.

El siguiente trozo de programa:

WrChar(h);WrChar(o);WrChar(l);WrChar(a);WrChar(CHR(ORD(!)));

producir la siguiente salida en la pantalla del ordenador:

hola!


17/171



WrLn: hace que el resultado correspondiente a la prxima operacin de salida se muestre enla siguiente lnea de pantalla.


WrChar(h); WrLn;WrChar(o); WrLn;WrChar(l); WrLn;WrChar(a); WrLn;WrChar(CHR(ORD(!)));


h

o

l

a

!

WrStr(s): escribe la cadena de caracteres sen pantalla.


WrStr(holabqu hay?); WrLn;WrStr(entre comillas);


holabqu hay?

entre comillas

WrInt(i,a): escribe en pantalla el valor de i que debe ser una expresin de tipoINTEGER. El valor de a indica el nmero de posiciones reservadas para escribir i en lapantalla. En caso de que i requiera un nmero de posiciones menor del reservado, lasposiciones sobrantes se rellenarn con espacios en blanco. Si el nmero de posicionesindicado por a es menor que el nmero de caracteres necesarios para imprimir i, seimprimir iignorando lo indicado por a.


WrInt(123,5); WrLn;WrInt(45,1); WrLn;WrInt(67,0); WrLn;WrInt(-89,6); WrLn;WrInt(1000+500, 6);


bb123

45

67

bbb-89

bb1500

Es habitual utilizar un ancho cero, de este modo el valor ocupar tantas posiciones enpantalla como necesite.


18/171

18 3.8 Operaciones de Entrada y Salida


WrCard(c,a): idntico al anterior, pero el valor c debe ser de tipo CARDINAL.

WrReal(r,p,a): Escribe el valor de la expresin r, que debe ser de tipo REAL, enpantalla. Los nmeros reales siempre se muestran usando notacin cientfica y con un nicodgito en la parte entera. El significado de aes el mismo que en WrInt. Se mostrarn p-1cifras en la parte fraccionaria.


WrReal(1.2345, 1, 10); WrLn;WrReal(1.2345, 2, 10); WrLn;WrReal(12.345, 5, 0); WrLn;WrReal(12.345, 6, 0); WrLn;


bbbbb1.E+0

bbbb1.2E+0

1.2345E+1

1.23450E+1

WrLngReal(r,p,a): igual al anterior pero rdebe ser una expresin de tipo LONGREAL.

NOTA:El smbolo brepresenta un espacio en blanco.

3.8.2 Operaciones de Entrada

Las principales operaciones de entrada definidas en el mdulo de biblioteca IO son lassiguientes:

RdChar(): lee un dato de tipo CHAR del teclado.

RdInt(): lee un nmero de tipo INTEGER del teclado. RdCard(): lee un nmero de tipo CARDINAL del teclado.

RdReal(): lee un nmero de tipo REAL del teclado.

RdLngReal(): lee un nmero de tipo LONGREAL del teclado.

Estas instrucciones se usan de la misma forma que un valor dentro de programa, por lo que no

pueden aparecer como instrucciones aisladas dentro del mismo (cosa que ocurra con las de

salida vistas anteriormente) sino slo formando parte de una expresin.

El modo usual de utilizar estas operaciones es mediante una sentencia de asignacin, en cuya

parte izquierda aparece el nombre de la variable en la cual se quiere guardar el valor ledo delteclado. En la parte derecha de la sentencia de asignacin aparece la operacin de entrada. Eltipo de la variable en la parte izquierda debe coincidir con el tipo de dato que lee la operacin.

Tras cada llamada a una de estas funciones, el programa se detiene a la espera de que el usuariointroduzca un valor. Cuando el usuario introduce el dato y pulsa la tecla , elprograma contina ejecutndose y el valor es asignado a la variable en la parte izquierda de lasentencia de asignacin.

Tras cada una de estas operaciones de entrada es conveniente ejecutar la operacin RdLn(quedebe importarse tambin del mdulo de biblioteca IO) para evitar complicaciones.

El siguiente trozo de programa (suponiendo que la variable Num est declarada con tipo

INTEGER) lee un valor entero del teclado, lo almacena en la variable Num, suma 10 al valorledo y muestra el resultado por pantalla:


19/171



Num := RdInt();RdLn;Num := Num + 10;WrInt(Num, 0);

Al ejecutar el programa anterior, el ordenador se detiene al llegar a la instruccin RdInt()y

muestra un cursor parpadeante para indicar al usuario que est a la espera de que introduzca undato:

_

En este punto el usuario debe introducir el dato y pulsar la tecla :

120_

Al pulsar la tecla el dato 120 es asignado a la variable Num.. Adems, el cursor pasaa la siguiente lnea de pantalla de modo que la prxima operacin de salida comenzar en dichalnea:

120

_

La asignacin Num := Num + 10 hace que el valor de la variable Num pase a ser 130. Porltimo, la operacin WrInt(Num,0)muestra el valor de la variable Numcon el ancho que seanecesario:

120

130

Es normal preceder las operaciones de entrada con operaciones de salida que indiquen alusuario qu dato debe introducir. El siguiente programa resulta ms claro para el usuario:

WrStr(Introduzca un nmero entero: );Num := RdInt();RdLn;Num := Num + 10;WrStr(El nmero introducido ms diez es: );WrInt(Num, 0);

Al ejecutar este ltimo programa, el ordenador muestra el mensaje Introduzca un nmeroentero: y un cursor parpadeante, lo cual indica que est a la espera de que el usuariointroduzca un dato entero:

Introduzca un nmero entero: _

Una vez que el usuario introduce el nmero y pulsa la tecla el cursor pasa a lasiguiente lnea:

Introduzca un nmero entero: 120

_


20/171

20 3.9 Estructura general de un programa. Ejemplo


Por ltimo, se incrementa en diez el valor de la variable y ejecutan las dos operaciones desalida finales:

Introduzca un nmero entero: 120El nmero introducido ms diez es: 130

3.9 Estructura general de un programa. Ejemplo

Con los elementos introducidos en este tema es posible escribir programas completos enModula-2. El siguiente ejemplo muestra un programa que lee el radio de un crculo desde elteclado, calcula el rea de dicho crculo y lo escribe por pantalla:

MODULECirculo;FROMIO IMPORTWrStr, RdReal, RdLn, WrReal;CONST

PI = 3.1416; (* El nmero PI *) PRECISION = 5; (* N de dgitos al escribir reales *)

ANCHO = 0; (* Calcular ancho necesario automticamente *)VAR

Radio, Area :REAL;BEGIN

WrStr(Introduce el radio: ); Radio := RdReal();

RdLn; Area := PI*Radio*Radio;

WrStr(El rea del crculo es ); WrReal(Area,PRECISION,ANCHO)ENDCirculo.

Podemos distinguir las siguientes partes dentro del programa:

Cabecera: todo programa debe comenzar con la palabra reservada MODULE seguida deun identificador, que indica el nombre del programa, y un signo punto y coma. En elpresente ejemplo se ha elegido como nombre del programa el identificador Circulo. Elprograma debe finalizar con la palabra reservada END seguida del nombre del programa (elmismo identificador usado en la cabecera) y un punto.

Listas de importacin: a continuacin es necesario enumerar los mdulos de biblioteca

usados por el programa, especificando cada una de las operaciones utilizadas. Los mdulosde bibliotecas contienen elementos que se utilizan con frecuencia en el desarrollo dedistintos programas, por lo que estn disponibles en el lenguaje, y por lo tanto, no esnecesario programarlos. Para utilizarlos hay que indicarlo en la lista de importacin. Estose puede hacer de dos formas:

1. Forma implcita:

IMPORTNombreBiblioteca;

En este caso se puede utilizar cualquier elemento definido en la biblioteca refirindonos al mediante su nombre precedido por el del mdulo.

2. Forma explcita:FROM NombreBiblioteca IMPORTListaElementos;


21/171



En este caso slo se pueden utilizar los elementos especificados en ListaElementosrefirindonos a l slo por su nombre. Este es el caso del ejemplo.

Cada compilador deMdula-2tiene sus propias bibliotecas y define las caractersticas delos procedimientos que contiene. Este es un aspecto a revisar siempre que, aun usando elmismo lenguaje, cambiemos de compilador.

Declaraciones: en esta seccin se declaran las distintas constantes y variables que sonutilizadas en el programa. El programa ejemplo usa tres valores constantes (PI, PRECISIONy ANCHO) y dos variables de tipo REAL (Radioy Area).

Parte Ejecutiva: comienza con la palabra reservada BEGIN y en ella aparecen lasinstrucciones que constituyen el programa, separadas entre s con el signo punto y coma.

Es posible incluir en cualquier punto del programa un comentario. Un comentario es unasecuencia de caracteres que es ignorada por el compilador. Se usan para documentar elprograma, de manera que aunque no contribuyan a resolver el problema, s ayudan a mejorar lacomprensin del programa. Se insertan en el programa escribiendo un texto entre los smbolos(* y *).

Usando la notacin BNF, la estructura de un programa enModula-2es la siguiente:

Modulo_de_Programa ::= Cabecera_de_Programa

{Lista_de_Importacin }

{Declaraciones }

Parte_Ejecutiva

Fin_de_Programa

Cabecera_de_Programa ::= MODULE Nombre_de_Programa ;

Lista_de_Importacin ::= FROM Nombre_de_Biblioteca IMPORT Lista_de_Operaciones ; |

IMPORT Nombre_de_Biblioteca ;

Lista_de_Operaciones ::= Nombre_de_Operacin {, Nombre_de_Operacin }

Declaraciones ::= Declaracin_de_Constante |Declaracin_de_Variable

Parte_Ejecutiva ::= BEGIN Secuencia_de_Sentencias

Secuencia_de_Sentencias ::= Sentencia {; Sentencia }

Sentencia ::= Sentencia_de_Asignacin | ...

Fin_de_Programa ::= END Nombre_de_Programa .

Nombre_de_Programa ::= Identificador

Nombre_de_Biblioteca ::= Identificador

Nombre_de_Operacin ::= Identificador

Podemos observar que tanto la lista de importacin como las declaraciones pueden aparecercero, una o ms veces en un programa. Completaremos la definicin de sentencia a lo largo delcurso.


22/171


23/171

Relacin de problemas. Tema 3. 1


Relacin de Problemas (Tema 3)

1. Escribir un programa que lea desde el teclado dos valores de tipo INTEGER y escriba enpantalla su suma, su diferencia, su producto, su cociente y su resto.

2. Escribir un programa que pida una letra desde el teclado, la pase a mayscula e imprimael resultado por pantalla.

3. Escribir un programa que lea el radio y la altura de un cilindro desde el teclado y escribapor pantalla el rea y volumen correspondiente.

NOTA: El rea y volumen del cilindro de altura hy radioRes:

Area = 2R2+2Rh

Volumen = R2h

4. Escribir un programa que lea desde el teclado una cantidad de segundos y muestre por

pantalla el nmero de horas, minutos y segundos equivalentes.5. Escribir un programa que lea un carcter del teclado y escriba por pantalla su cdigo

dentro de la tabla ASCII.

6. a) Qu ocurre al ejecutar el siguiente programa?

MODULEPrueba;FROM IOIMPORTWrInt;VAR

Num : INTEGER;BEGIN

Num :=MAX(INTEGER); Num := Num + 10 100; WrInt (Num, 0)ENDPrueba.

b) Cmo puede solucionarse el problema?

c) Qu ocurre si cambiamos el programa por el siguiente?

MODULEPrueba;FROM IOIMPORTWrCard;VAR

Num : CARDINAL;BEGIN

Num :=MAX(INTEGER); Num := Num + 10 100; WrCard (Num, 0)ENDPrueba.

7. Escribe un programa que lea del teclado la longitud de los dos catetos de un tringulorectngulo, calcule la longitud de la hipotenusa y la escriba por pantalla.

8. Escribe un programa que lea la longitud del lado de un cuadrado y escriba en pantalla surea y su permetro.

9. Escribe un programa que lea un carcter del teclado y escriba en pantalla el carcter quele sigue en el cdigo ASCII.


24/171

2 3.9 Estructura general de un programa. Ejemplo


10. Encuentra los errores en el siguiente programa:

MODULEErroneo;FROMIO IMPORTWrInt;CONST

PRECISION = 2; ANCHO = 0;VAR

Num1 : INTEGER; Num2 : CARDINAL; Num3 : REAL;BEGIN

Num1 := 10; Num2 := -100; Num3 := 13.; Letra := A Num3 := Num3 + 1; WrStr(Valor nmero 1: );

WrInt(Num1, ANCHO); WrLn; WrStr(Valor nmero 2: ); WrCard(Num2, ANCHO); WrLn; WrStr(Valor nmero 3:); WrReal(Num3, PRECISION, ANCHO); WrLn; WrStr(Valor letra: ); WrChar(Letra); WrLnENDErroneo.


25/171

Tema 4. Diseo de Algoritmos. Estructuras de seleccin 1

Informtica. Facultad de Ciencias (Matemticas)






Tema 4. Diseo de Algoritmos. Estructuras deseleccin

4.1 Composicin secuencial de instrucciones........................................................... 2

4.2 Seleccin entre acciones alternativas................................................................ .2

4.2.1 El tipo BOOLEAN en Modula-2................................................................ .....3

4.2.2 Expresiones booleanas................................................................ ................. 3

4.2.2.1 Operadores relacionales ................................................................ .........3

4.2.2.2 Operadores booleanos................................................................ ............4

4.2.2.3 Evaluacin en cortocircuito................................................................ ......6

4.2.3 Sentencias de seleccin en Modula-2........................................................... 6

4.2.3.1 Sentencia IF THEN ELSIF ELSE............................................................. 6

4.2.3.2 Sentencia CASE................................................................ ....................10

Bibliografa



Fundamentos de programacin. L. Joyanes. McGraw-Hill


26/171

2 4.1 Composicin secuencial de instrucciones


4.1 Composicin secuencial de instrucciones

La forma ms simple de componer instrucciones en un lenguaje de programacin es lasecuencia: se ejecutan las distintas acciones una tras otra segn su orden fsico dentro del

programa. Podemos representar esta forma de composicin con el siguiente diagrama de flujo:

Instruccin A

Instruccin B

Figura 1.Composicin secuencial de A y B

En Modula-2 la composicin de dos instrucciones se consigue escribiendo una tras otra,separndolas por un carcter punto y coma. Por ejemplo, el siguiente programa compone dosinstrucciones de escritura secuencialmente:

MODULESecuencia;

FROMIO IMPORTWrStr;

BEGIN

WrStr ( A );

WrStr ( B )ENDSecuencia.

La sintaxis BNF de la estructura de secuencia en Modula-2es:

Secuencia_de_Sentencias ::= Sentencia {; Sentencia }

4.2 Seleccin entre acciones alternativas

A la hora de describir algoritmos, puede ser necesario especificar dos o ms caminosalternativos a seguir en funcin de cierta condicin. La estructura de seleccin permite ejecutaruna accin u otra, dependiendo de una determinada condicin que se analiza a la entrada de laestructura. El diagrama correspondiente a esta estructura es:


27/171



NoSCondicin

Accin A Accin B

Figura 2.Estructura de seleccin

Para ejecutar una estructura de seleccin, se evala primero la condicin. Si sta es cierta seejecutar la accin A. Si la condicin es falsa se ejecutar la accin B. Veremos posteriormenteque sta es slo una de las distintas instrucciones de seleccin disponibles en Modula-2.

La condicin debe ser una expresin booleana: expresin que puede ser cierta o falsa.Estudiamos las expresiones booleanas en los siguientes puntos.

4.2.1 El tipo BOOLEAN en Modula-2

El tipo BOOLEAN es el tipo de aquellas variables que slo pueden tomar dos valores:VERDADERO o FALSO, (TRUEy FALSEenModula-2).

Un ejemplo de uso de datos booleanos puede verse en el siguiente programa, que asigna a lavariable EsAltoel valor VERDADERO y a la variable EsRubioFALSO:

MODULEBooleano;

VAR

EsAlto, EsRubio : BOOLEAN;BEGIN

EsAlto := TRUE;EsRubio := FALSE

ENDBooleano.

Existe una funcin predefinida que devuelve un valor de tipo booleano. Se trata de la funcinODD. Esta funcin toma como argumento un nmero no REAL (de tipo INTEGER oCARDINAL) y devuelve el valor TRUE si el nmero es impar o FALSE si es par. No existe unafuncin predefinida para ver si un nmero es par, pero puede usarse la expresin NOT ODD.

4.2.2 Expresiones booleanas

Una de las formas de construir expresiones booleanas es mediante los operadores relacionales.

4.2.2.1 Operadores relacionales

Los operadores relacionales son operadores binariosque permiten comparar dos valores delmismo tipo. Son binarios porque tienen dos argumentos. Los operadores relacionales en

Modula-2son:


28/171

4 4.2 Seleccin entre acciones alternativas


> mayor que< menor que= igual a>= mayor o igual que

= 4 Es correcta slo si n es de tipoINTEGERo CARDINAL,y el resultado

depende del valor de n.

a < d TRUE

A < 25 Error, ya que A tiene tipo CHAR y 25 tiene tipo INTEGER oCARDINAL

n*m


29/171



A B A AND B A OR B NOT A

TRUE TRUE TRUE TRUE FALSE

TRUE FALSE FALSE TRUE

FALSE TRUE FALSE TRUE TRUE

FALSE FALSE FALSE FALSE

Figura 3. Tabla de verdad de los operadores booleanos

Podemos construir expresiones complejas combinando estos operadores con los relacionales:

(x>=5)AND(x=5)AND(x=20)AND(x = >=


30/171



Dentro del mismo nivel las expresiones se evalan en el orden en que estn escritas, es decir, deizquierda a derecha.

El ejemplo citado anteriormente se corresponde con (NOT X) AND Y. Si hubisemos queridoexpresar la otra posibilidad deberamos haber usado parntesis: NOT (X AND Y). Es buenacostumbre usar parntesis, aunque no sean necesarios, para aclarar el significado de

expresiones complejas.Por ltimo, veamos la sintaxis para las expresiones (booleanas y aritmticas) enModula-2(porahora):

Expresin ::= Expresin_simple [ Operador_Comparador Expresin_Simple]

Expresin_Simple ::= [+|- ]Termino {Operador_Sumador Trmino}

Trmino ::= Factor {Operador_Multiplicador Factor}

Factor ::= Identificador_de_Variable | Identificador_de_Constante |

Valor_Constante | (Expresin) | (NOT | ~) Factor

Operador_Comparador ::= > |< |= |>= | 10)AND(aMODb = 0)

si bes menor o igual que 10, no se evaluar la segunda parte de la expresin. Lo mismo ocurresi la expresin global es una disyuncin (OR) y la primera subexpresiones es TRUE. En estecaso, la expresin global tendr como resultado TRUE sin que se evale el resto de laexpresin.

Debido a esto, la propiedad conmutativa no se cumple en general al utilizar operadoresbooleanos. Por ejemplo, la expresin (10 > 7) OR(100 DIV0 = 3)ser evaluada a TRUE,ya que, al evaluarse la primera parte de la disyuncin (10 > 7)a TRUE, la segunda parte (100DIV0 = 3) no es evaluada. Sin embargo, la evaluacin de la expresin (100 DIV0 = 3)OR(10 > 7)hace que se produzca un error, ya que al intentar evaluar la primera parte (100DIV0 = 3)se produce un error debido a la divisin por cero.

4.2.3 Sentencias de seleccin en Modula-2

Existen dos sentencias de seleccin en Modula-2: la binaria y la mltiple. Pasamos a estudiarcada una de ellas.

4.2.3.1 Sentencia IF THEN ELSIF ELSE

EnModula-2la sentencia de seleccin binaria puede adoptar la siguiente forma:


31/171



IFCondicin THEN

Accin A

ELSE

Accin B

END

La ejecucin de esta sentencia consiste en evaluar primero la condicin. Si sta es verdadera(TRUE), se ejecuta la accin A. En otro caso, si la condicin fuese falsa (FALSE), se ejecutarala accin B. Siempre se ejecuta alguna accin, o bien A o bien B, pero nunca ambas. Eldiagrama de flujo correspondiente es:

NoSCondicin

Accin A Accin B

Figura 5. Seleccin binaria

La condicin debe ser una expresin de tipo BOOLEAN. Las palabras IF THEN ELSE ENDsepararan las distintas partes de la sentencia (condicin, accin A y accin B). Un ejemplo deuso de la sentencia es el siguiente:

IFODD(N) THEN

WrStr (El n es impar)

ELSE

WrStr (El n es par)END

A veces no es necesario hacer nada si la condicin no se cumple. En este caso la sentencia deseleccin puede carecer de la parte ELSE:

IFCondicin THEN

AccinEND

El diagrama de flujo en este caso es:


32/171



NoSCondicin

Accin

Figura 6. Seleccin simplificada

No hay restricciones sobre el tipo de sentencias que puede aparecer en una rama de unasentencia de seleccin. Puede, por ejemplo, aparecer una secuencia de sentencias

IFx < 0 THEN

x := -x;WrStr (Signo cambiado)

ELSE

WrStr (Signo sin cambiar)END

Tambin puede aparecer otra sentencia de seleccin. A esto es lo que se llama anidamientode sentencias de seleccin. Un ejemplo de anidamiento es el siguiente trozo de programa,que escribe la calificacin correspondiente a la nota contenida en la variable REAL Nota:

IFNota < 5.0 THEN

WrStr (Suspenso)ELSE

IFNota < 7.0 THEN

WrStr (Aprobado)ELSE

IFNota < 9.0 THEN

WrStr (Notable)ELSE

IFNota < 10.0 THEN

WrStr (Sobresaliente)ELSE

WrStr (Matrcula)

END

END

END

END

A la estructura anterior tambin se llama seleccin en cascada. El diagrama de flujocorrespondiente al ejemplo es:


33/171



NoSNota < 5.0

EscribirSuspenso

NoS

Nota < 7.0

EscribirAprobado

NoSNota < 9.0

Escribir Notable

NoSNota < 10.0

EscribirSobresaliente

EscribirMatrcula

Figura 7. Seleccin en cascada

Este tipo de situaciones es habitual, por lo que Modula-2posee una sintaxis ms simple paraestos casos. Se usa para ello la palabra reservada ELSIF. El ejemplo anterior se puede escribirtambin del siguiente modo:

IFNota < 5.0 THEN

WrStr (Suspenso)

ELSIFNota < 7.0 THEN

WrStr (Aprobado)ELSIFNota < 9.0 THEN

WrStr (Notable)ELSIFNota < 10.0 THEN

WrStr (Sobresaliente)ELSE

WrStr (Matrcula)

END

Obsrvese que el significado de la seleccin en cascada es distinto al del siguiente cdigo (quese corresponde con una secuencia de sentencias de seleccin):

IFNota < 5.0 THEN

WrStr (Suspenso)END;

IF(Nota >= 5.0)AND(Nota < 7.0) THEN

WrStr (Aprobado)END;


WrStr (Notable)END;


WrStr (Sobresaliente)

END;

IFNota = 10.0 THEN

WrStr (Matrcula)END;

El diagrama de flujo para ste ltimo trozo de cdigo es:


34/171



NoSNota < 5.0

Escribir

Suspenso

NoSNota [5.0,7.0)

EscribirAprobado

NoSNota = 10.0

EscribirMatrcula

Figura 8. Seleccin NO en cascada

En la seleccin en cascada, una vez que una condicin es cierta no se comprueba ninguna otra.Aqu siempre se comprueban todas las condiciones. La seleccin en cascada es ms eficiente.

La sintaxis BNF de la sentencia de seleccin es:

Sentencia_IF ::= IF Expresin THEN Secuencia_de_Sentencias

{ ELSIF Expresin THEN Secuencia_de_Sentencias }

[ ELSE Secuencia_de_Sentencias ]

END

donde Expresin debe ser obligatoriamente de tipo BOOLEAN.4.2.3.2 Sentencia CASE

La sentencia de seleccin mltiple se utiliza para ejecutar distintas sentencias en funcin de losdistintos valores que pueda tomar una expresin. El esquema de esta sentencia es:

CASEExpresin OF

listas de valores : accin|

listas de valores : accin|

ELSE

accin por defectoEND

Para ejecutar esta sentencia, se evala primero la expresin. A continuacin, se inspeccionanlas distintas listas de valores, hasta encontrar una con un valor que coincida con el resultado de


35/171



la expresin. La accin correspondiente a ese valor es ejecutada. Si el resultado de la expresinno aparece en ninguna de las listas, se ejecuta la accin por defecto.

El siguiente ejemplo muestra el cdigo para un trozo de programa que escribe el nombre del dade la semana almacenado en la variable Dia (de tipo CARDINAL):

CASEDia OF

1 : WrStr (Lunes) |

2 : WrStr (Martes) |

3 : WrStr (Miercoles)|

4 : WrStr (Jueves) |

5 : WrStr (Viernes) |

6 : WrStr (Sbado) |

7 : WrStr (Domingo)ELSE

WrStr (Error: da no vlido)

END;

A cada caso se puede asociar ms de un valor. Esto puede hacerse de tres formas:

Separando distintos valores con comas. (por ejemplo 1,2,3) Escribiendo dos valores separados por dos puntos. En este caso se est especificando

un rango de valores. (por ejemplo 1..5)

Combinando estas dos formas. (por ejemplo 1, 3..4)

La siguiente sentencia escribe si el nmero almacenado en la variable Diacorresponde a un dalaborable o no:

CASEDia OF

1..5 : WrStr (Laborable) |

6 : WrStr (Depende) |

7 : WrStr (Festivo)

ELSEWrStr (Error: da no vlido)

END;

Algunas reglas relativas a esta sentencia son:

La alternativa ELSE puede no aparecer, pero si el resultado de la expresin no coincidecon ninguno de los casos, el programa acabar con un error (sin embargo, esto noocurre en TopSpeed Modula-2). Si queremos que para ciertos valores no se haga nada,entonces estos valores se deben de asociar con una accin vaca.

Un mismo valor nuncapuede aparecer en distintas alternativas.

El tipo de la expresin a evaluar no puede ser REAL. Ha de ser un tipo ordinal.

Los distintos valores en las alternativas son expresiones constantes (no puedenintervenir variables)

El tipo de la expresin y de los distintos valores debe coincidir.

La sintaxis BNF para esta sentencia es:


36/171



Sentencia_CASE ::= CASE Expresin OF

Caso {| Caso}

[ELSE Secuencia_de_sentencias ]

END

Caso ::= Lista_de_Valores : Secuencia_de_Sentencias

Lista_de_Valores ::= Valores {, Valores }

Valores ::= Expresin_Constante [.. Expresin_Constante ]

La sentencia de seleccin mltiple es equivalente a la seleccin en cascada (esta ltima ser laque debamos usar cuando el tipo de expresin sea REAL):

CASEExpresin OF

v1 :

SentenciaA |

v2..v4 :SentenciaB |

v5,v6,v7 :

SentenciaC |

...

ELSE

SentenciaHEND

Valor := Expresin;IFValor = v1 THEN

SentenciaA

ELSIF(Valor >= v2)AND (Valor


37/171

Relacin de Problemas (Tema 4) 1


Relacin de Problemas (Tema 4)

1. Si la variable valor es de tipo BOOLEAN, cmo se puede escribir de otro modo lacondicin o pregunta valor = TRUE?, y valor = FALSE?.

2. Si la variable cierto es de tipo BOOLEAN, y a, b son de tipo INTEGER, a qu sonequivalentes las siguientes expresiones ?

i) cierto := (a


38/171

2 Relacin de Problemas (Tema 4)


el nmero de letras que las separan

la letra o dos letras centrales del intervalo que determinan, pero en maysculas

11. Escribe un programa que determine si un ao es bisiesto. Un ao es bisiesto si es mltiplode 4 (por ejemplo 1984). Sin embargo, los aos mltiplos de 100 slo son bisiestos

cuando a su vez son mltiplos de 400 (por ejemplo 1800 no es bisiesto, mientras que 2000lo ser).

12. Escribe un programa que calcule el nmero de das de un mes, dados los valoresnumricos del mes y ao.

NOTA:considera los aos bisiestos para Febrero.

13. El domingo de Pascua es el primer domingo despus de la primera luna llena posterior alequinoccio de primavera, y se determina mediante el siguiente clculo sencillo:

A= ao MOD 19

B= ao MOD 4

C= ao MOD 7D= (19 *A+ 24) MOD 30

E= (2 *B+ 4 * C+ 6 *D+ 5) MOD 7

N= (22 +D+E)

DondeNindica el da del mes de Marzo siNes menor o igual que 31 o Abril si es mayorque 31 (el 32 indicara el 1 de Abril). Construye un programa que determine fechas dedomingos de Pascua.

14. Escribe un programa que dados los conjuntos de puntos pertenecientes a la circunferenciacuya ecuacin esx2+y2= 16, a la elipsex2/36 +y2/16 = 1 y a la rectay= 2x+ 1, indique

para una pareja de coordenadas xe y , ledas desde el teclado, el conjunto o conjuntos alos que pertenece.

15. Un sistema de ecuaciones lineales:

ax+ by= c

dx+ ey=f

se puede resolver con las siguientes frmulas:

x= (ce- bf) / (ae- bd)

y = (af- cd) / (ae- bd)

Disea el programa que lea los coeficientes a, b, c, d, e,f y muestre los valores dexey.NOTA:Estudia el caso en que (ae- bd) = 0.

16. Desarrolla un programa que calcule las races correspondientes a una ecuacin desegundo grado ax2+ bx+ c= 0.

NOTA:Estudia el caso de races complejas (valor del discriminante < 0) y el caso a= 0.

17. Escribe un programa que lea un nmero de tipo CARDINAL, y si tiene exactamentecuatro cifras, escriba si es capica o no.

18. Escribe un programa que lea un nmero de tipo CARDINAL, y si tiene exactamentecuatro cifras, escriba si el nmero es igual a la suma de los cuadrados de sus cifras.


39/171

Tema 5. Estructuras iterativas 1







Tema 5. Estructuras iterativas

5.1 Bucles................................................................ .................................................2

5.2 Estructuras iterativas en Modula-2................................................................ ......35.2.1 La sentencia FOR................................................................ .........................3

5.2.2 La sentencia WHILE ................................................................ .....................7

5.2.3 La sentencia REPEAT................................................................ ................... 8

5.2.4 Las sentencias LOOP y EXIT................................................................ ......10

5.3 Diseo de bucles ................................................................ .............................. 13

5.3.1 Anidamiento de bucles................................................................ ................ 13

5.3.2 Bucles infinitos................................................................ ............................ 14

Bibliografa



Fundamentos de programacin.L. Joyanes. McGraw-Hill.


40/171

2 5.1 Bucles


Introduccin

Las estructuras de seleccin, estudiadas en el tema anterior, no son suficientes para describircualquier algoritmo. Es habitual que ciertas partes de un algoritmo deban repetirse varias veces

con objeto de resolver un problema. La repeticin es un concepto importante a la hora dedescribir algoritmos. Los lenguajes de programacin disponen de una serie de sentencias quepermiten repetir varias veces algunos segmentos del programa. A este tipo de sentencias se lesdenomina sentencias iterativas. En este tema, estudiamos las sentencias iterativas queposee el lenguaje de programacinModula-2.

5.1 Bucles

Un trmino muy utilizado en el argot informtico es bucle. Un bucle es un segmento dealgoritmo que se repite varias veces. Podemos distinguir dos tipos de bucles:

Bucles deterministas: son aquellos para los cuales el nmero de repeticiones esconocido a priori.

Ejemplo: Supongamos que tenemos un ordenador que slo es capaz de sumaruna unidad a un nmero. Escribir un algoritmo que lea un nmero del teclado, lesume diez y muestre el resultado por pantalla.

Un posible algoritmo que utiliza un bucle determinista para resolver este problemaes el siguiente:

1. Leer un nmero desde el teclado

2. Repetir 10 veces

2.1. Sumar uno al valor del nmero3. Escribir el valor del nmero

Bucles no deterministas o indeterministas: son aquellos para los cuales nose conoce a priori el nmero de veces que se van a repetir. El bucle se repite hastaque se alcanza cierta condicin. La condicin es conocida a priori, pero no sabemoscuntas veces es necesario repetir el bucle para que la condicin se alcance.

Ejemplo: Escribir un algoritmo que lea nmeros desde teclado hasta que se leaun valor cero. El algoritmo debe calcular la suma total de los nmeros ledos y

mostrar el resultado por pantalla.Un algoritmo que utiliza un bucle no determinista para resolver este problema es elsiguiente:

1. Guardar el valor cero en la variable suma

2. Leer un nmero desde el teclado

3. Mientras que el valor del nmero ledo sea distinto de cero

3.1. Sumar el valor del nmero ledo a la variable suma

3.2. Volver a leer el nmero desde el teclado

4. Escribir el valor de la variable suma


41/171



En este caso, no sabemos a priori cuntas veces se repetirn los pasos 3.1 y 3.2. Sinembargo, sabemos que dichos pasos dejarn de repetirse en el momento en que selea un valor cero desde el teclado. Conocemos a priori la condicin pero no elnmero de repeticiones.

5.2 Estructuras iterativas en Modula-2

Modula-2 dispone de cuatro sentencias iterativas distintas. Pasemos a estudiar cada una deellas.

5.2.1 La sentencia FOR

La sentencia FOR permite repetir, un nmero de veces conocido a priori, una serie deinstrucciones. La sentencia FOR es el modo ms adecuado de expresar bucles definidos en

Modula-2.

La forma ms simple que toma esta sentencia es la siguiente:

FORVariable := Valor1 TOValor2 DO

Acciones

END

Las palabras FOR, TO, DO y END son palabras reservadas del lenguaje y delimitan cada unade las partes de la sentencia. La variable que aparece a la izquierda del signo de asignacin sellama variable de controldel bucle. El valor de esta variable se modifica en cada repeticindel bucle. El conjunto de acciones que aparecen entre las palabras DO y END constituyen elcuerpo del bucle.

El significado de la sentencia FOR es el siguiente: se ejecutan las acciones entre las palabrasDO y END tantas veces como indique la expresin (Valor2-Valor1+1). La primera vez que seejecuten estas acciones, el valor de la variable de control es Valor1. La segunda vez que seejecuten las acciones, el valor de la variable de control es Valor1+1. El valor de la variable decontrol es incrementado en una unidad tras cada repeticin, de modo que la ltima vez que seejecuten las acciones el valor de la variable de control es Valor2.

Ejemplo: Escribir un programa en Modula-2que lea un nmero Numdel teclado y calcule elsumatorio de los nmeros naturales menores o iguales a Num ( 1+2+3+ ... + (Num-1)+Num).El programa debe mostrar el resultado del sumatorio por pantalla.

Supongamos que no conocemos la siguiente equivalencia:

=

=N

i

NNi

1 2)1(

Para calcular el sumatorio anterior podemos utilizar una variable Suma cuyo valor inicial seacero. Primero, sumaremos a esta variable el valor uno. A continuacin, el valor dos.Repetiremos este paso hasta sumar el valor Num. El algoritmo que calcula el sumatorio es:

Suma := 0;Suma := Suma + 1;Suma := Suma + 2;...Suma := Suma + (Num-1);Suma := Suma + Num;

o de un modo ms breve:


42/171

4 5.2 Estructuras iterativas en Modula-2


1.Asignar a la variable Sumael valor cero.

2.Repetir Numveces (variando el valor de idesde uno hasta Num)

2.1.Sumar ial valor de la variable Suma

El modo ms adecuado de expresar el paso 2 de este algoritmo en Modula-2 es usando la

sentencia FOR. Se obtiene el siguiente programa:MODULESuma;

FROMIO IMPORTRdCard, RdLn, WrCard, WrStr;

VAR

Num, Suma, i :CARDINAL;

BEGIN

WrStr(Dame un nmero: );Num := RdCard(); RdLn;

Suma := 0;

FORi := 1 TONum DO

Suma := Suma + iEND;

WrStr(La suma de los primeros );WrCard(Num,0);WrStr( nmeros naturales es );WrCard(Suma,0)

ENDSuma.

Podemos especificar que la variable de control se incremente en un valor distinto a uno trascada repeticin de las acciones dentro del bucle. Para ello se utiliza la palabra reservada BYseguida del valor a sumar a la variable de control.

Ejemplo: Escribir un programa en Modula-2 que lea del teclado un nmero impar Num ycalcule el sumatorio de los nmeros naturales impares menores o iguales a Num ( 1+3+ ... +(Num-2)+Num).

Para calcular el sumatorio anterior podemos utilizar una variable Suma cuyo valor inicial seacero. Sumaremos primero a esta variable el valor uno. A continuacin el valor tres.Repetiremos este paso hasta sumar el valor Num. El algoritmo que calcula el sumatorio es:

1. Asignar a la variable Sumael valor cero.

2. Repetir (variando el valor de idesde uno hasta Num de dos en dos)

2.1. Sumar ial valor de la variable Suma

Se obtiene el siguiente programa:

MODULESuma;


VAR

Num, Suma, i :CARDINAL;

BEGIN

WrStr(Dame un nmero: );Num := RdCard(); RdLn;

IFNOTODD(Num) THEN

WrStr(El nmero no es impar)ELSE

Suma := 0;FORi := 1 TONum BY2 DO

Suma := Suma + i

END;


43/171



WrStr(La suma de los primeros );WrCard(Num,0);WrStr( nmeros impares naturales es );WrCard(Suma, 0)

END

ENDSuma.

El valor que aparece tras la palabra reservada BY puede ser tambin negativo. En dicho caso, lavariable de control del bucle es decrementada en el valor indicado tras cada repeticin delbucle.

La sintaxis BNF para la sentencia FOR es la siguiente:

Sentencia_FOR ::= FOR Identificador_de_Variable :=

Expresin_Inicial TO Expresion_Final [BY Paso] DO

Secuencia_de_Sentencias

END

Expresin_Inicial ::= Expresin

Expresin_Final ::= Expresin

Paso ::= Expresin_Constante

Obsrvese que la expresin que aparece tras la palabra BY debe ser una expresin constante(no puede contener ni variables ni operadores no predefinidos).

El diagrama de flujo que representa la sentencia FOR depende del signo de la expresinconstante Paso:

No

SVariable > Final

Inicial Valor1Final Valor2

Variable Inicial

Acciones

VariableVariable+Paso

No

SVariable < Final

Inicial Valor1Final Valor2

Variable Inicial

Acciones

VariableVariable+Paso

Figura 1.Bucle FOR con paso positivo. Figura 2. Bucle FOR con paso negativo.

La condicin de salida del bucle es que el valor de la variable de control sea estrictamentemayor (o menor en el caso de que el Paso sea negativo) que el valor de la expresin que

aparece tras la palabra TO. Advirtase que dicha expresin se calcula una sola vez, antes decomprobar la condicin del bucle por primera vez. En cada repeticin del bucle, la condicin es


44/171



comprobada antes de ejecutar el cuerpo del bucle. La variable de control es actualizada trasejecutar el cuerpo del bucle, antes de volver a comprobar la condicin.

Ejemplo: El cuerpo del siguiente bucle se ejecuta cero veces, ya que la condicin de salida escierta la primera vez.

FORi := 1 TO0 DOWrCard(i,0); WrLnEND

Ejemplo: El cuerpo del siguiente bucle se ejecuta dos veces (con valores para la variable ideuno y tres) ya que la condicin de salida es cierta la tercera vez.

FORi := 1 TO4 BY2 DO

WrCard(i,0); WrLn

END

Ejemplo: El cuerpo del siguiente bucle se ejecuta diez veces (con valores para la variable ientre uno y diez) ya que el valor para la expresin que aparece tras la palabra TO es calculadouna nica vez y no se vuelve a calcular tras cada repeticin.

Fin := 5;FORi := 1 TO2*Fin DO

WrCard(i,0); WrLn;Fin := 15

END

Algunas consideraciones sobre la sentencia FOR son las siguientes:

El tipo de la variable de control puede ser bsico (excepto REAL y LONGREAL),enumerado o subrango (ver tema sobre tipos definidos por el programador).

Ejemplo: El siguiente bucle muestra por pantalla todas las letras maysculas(excepto la letra ee mayscula que est fuera del rango [A..Z] en la tablaASCII).

FORLetra := A TOZ DO

WrChar(Letra)

END

Los tipos de las expresiones Valor1y Valor2deben ser compatibles con el tipo dela variable de control.

El tipo de la expresin constante Pasodebe ser entero.

La variable de control no puede ser:

1) Una componente de una variable estructurada (ver tema sobre arrays).

2) Una variable annima (ver tema sobrepunteros).

3) Una variable importada de otro mdulo (ver tema sobre mdulos).

4) Un parmetro formal (ver tema sobre subprogramas).

El programador no debe escribir en el cuerpo del bucle ninguna sentencia quemodifique el valor de la variable de control.


45/171



El valor de la variable de control est indefinido tras la finalizacin del bucle FOR.

Ejemplo: No sabemos qu valor se escribe por pantalla tras del siguiente bucle.

FORi := 1 TO10 DO

...END;

WrInt(i, 0);

5.2.2 La sentencia WHILE

La sentencia WHILE permite repetir, mientras que sea cierta una condicin, una serie deinstrucciones. La sentencia WHILE debe utilizarse exclusivamente para expresar buclesindefinidos.

La forma que toma esta sentencia es la siguiente:

WHILECondicin DO

AccionesEND

Las palabras WHILE, DO y END son palabras reservadas del lenguaje y delimitan cada una delas partes de la sentencia. La condicin que aparece entre las palabras WHILE y DO esdenominada condicin de permanenciadel bucle. La condicin de permanencia debe seruna expresin de tipo booleano. El conjunto de acciones que aparecen entre las palabras DO yEND constituyen el cuerpo del bucle.

El diagrama de flujo correspondiente a esta sentencia es el siguiente:

S

NoCondicin

Acciones

Figura 3.La sentencia WHILE.

Obsrvese que la condicin se vuelve a evaluar, para cada repeticin del bucle, antes de ejecutar elcuerpo. Se permanece dentro del bucle mientras que la condicin sea cierta (es por esto que lacondicin se llama de permanencia). Podra ocurrir que el cuerpo del bucle no llegara a ejecutarse,en caso de que la condicin fuese falsa la primera vez que se comprueba.

La sintaxis de la sentencia WHILE, utilizando la notacin BNF, es:


46/171



Sentencia_WHILE ::= WHILE Condicin DO


END

Condicin ::= Expresin

Ejemplo: Escribir un programa que, dado un nmero natural Tope, calcule el mnimo valor deNtal que 0+1+2+...+(N-1)+N Tope.

Un posible algoritmo para resolver este problema es el siguiente:

1. Leer del teclado el valor de la variable Tope

2. Guardar el valor cero en la variable Suma

3. Guardar el valor cero en la variable N

4. Mientras que el valor de la variable Sumasea menor al de la variable Tope

4.1. Sumar uno a la variable N

4.2. Sumar N a la variable Suma

5. Escribir el valor de la variable N

Este algoritmo da lugar al siguiente diagrama de flujo y su correspondiente programa enModula-2:

MODULESuma;


VAR

Tope, N, Suma :CARDINAL;

BEGIN

WrStr(Dame el tope a sumar: );

Tope := RdCard(); RdLn;

Suma := 0;N := 0;

WHILESuma < Tope DO

N := N+1;Suma := Suma + N

END;

WrStr(El mnimo N que cumple la condicin es );WrCard(N,0)

ENDSuma.

S

No

INICIO

Suma < Tope

EscribirN

FIN

suma 0N 0

N N + 1Suma Suma + N

LeerTope

5.2.3 La sentencia REPEAT

La sentencia REPEAT permite repetir una serie de instrucciones hasta que cierta condicin sea

cierta. La sentencia REPEAT debe utilizarse exclusivamente para expresar bucles indefinidos.La forma que toma esta sentencia es la siguiente:


47/171



REPEAT

Acciones

UNTIL Condicin

Las palabras REPEAT y UNTIL son palabras reservadas del lenguaje y delimitan cada una delas partes de la sentencia. La condicin que aparece tras la palabras UNTIL es denominada

condicin de salida del bucle. La condicin de salida debe ser una expresin de tipobooleano. El conjunto de acciones que aparecen entre las palabras REPEAT y UNTILconstituyen el cuerpo del bucle.

El diagrama de flujo correspondiente a esta sentencia es el siguiente:

S

NoCondicin

Acciones

Figura 4.La sentencia REPEAT.

Obsrvese que la condicin se vuelve a evaluar, para cada repeticin del bucle, despus deejecutar el cuerpo. Se sale del bucle una vez que la condicin sea cierta (es por esto que lacondicin se llama de salida). El cuerpo del bucle se ejecuta al menos una vez.

La sintaxis de la sentencia REPEAT, utilizando la notacin BNF, es:

Sentencia_REPEAT ::= REPEAT


UNTIL Condicin

Ejemplo: Escribir un programa que calcule una aproximacin al nmero e utilizando lasiguiente igualdad:

+++==

= !2

1

!1

11

!

1

0i ie

Dado que es imposible sumar infinitos trminos, el programa dejar de sumar trminos una vezque el valor del ltimo trmino sumado sea menor a una diezmilsima.

Llamemos trmino i-simo al trmino 1/i!. Es interesante observar que, conocido el valor deltrmino i-simo, basta con multiplicar ste por 1/(i+1) para obtener el valor del trminosiguiente.

En el algoritmo utilizaremos tres variables. La variable iindicar, en todo momento, el ordendel trmino que estemos sumando. La variable Termino almacenar siempre el valor deltrmino actual. Por ltimo, la variable Sumair acumulando la suma de trminos.

El diagrama de flujo correspondiente al algoritmo y su correspondiente programa en Modula-2

son los siguientes:


48/171



MODULENumeroE;

FROMIO IMPORTWrLngReal, WrStr;

CONST

DIEZMILESIMA = 1.0/10000.0;PRECISION = 10;

ANCHO = 0;

VARi, Termino, Suma :LONGREAL;

BEGIN

i := 0.;Termino := 1.;Suma := Termino;REPEAT

i := i+1.;Termino := Termino * (1.0/i);Suma := Suma + Termino

UNTILTermino < DIEZMILESIMA;

WrStr(La aproximacin al nmero e es );WrLngReal(Suma,PRECISION,ANCHO)

ENDNumeroE.

S

No

INICIO

Trmino Menor THEN

EXIT

END;

WrStr(Debe ser mayor. Prueba de nuevo)END

WrStr(Los nmeros son: );WrInt(Menor,0);WrStr( y );WrInt(Mayor,0)

ENDNumeros.

No

S

INICIO

Mayor > Menor

EscribirMenor y Mayor

FIN

LeerMenor

EscribirDame un n

EscribirDame otro mayor

LeerMayor

EscribirPrueba otra vez

5/21/2018 Curso de Modula-2 (Incomplet

curso de modula-2 (incompleto)

Documents