Lenguaje de programación de alto nivel: Pascal

El Pascal es un lenguaje de programación de alto nivel y de propósito general derivado del lenguaje de

programación llamado Algol-60 usado por la mayoría de las computadoras de las llamadas segunda y tercera generación entre los años 1960 y 1971 (Oficialmente, el año en que se desarrolló en un solo circuito integrado un microprocesador)

Sus instrucciones se componen de expresiones semi-algebraicas y de palabras en inglés (begin, end, read, write, if, then, repeat, while, do...) En este aspecto, el Pascal es bastante similar a otros lenguajes de alto nivel.

Sin embargo, éste lenguaje tiene una característica propia que consiste en la estructuración de los programas (Programación Estructurada)

El nombre Pascal, viene de Blaise Pascal (1623-1662), matemático y científico francés inventor por otra parte, de la primera máquina de calcular mecánica del mundo (La Pascalina)

El lenguaje fue desarrollado a principios de 1970 por Nyklaus Wirth en la Universidad Técnica de Zurich, en Suiza. La definición original del lenguaje debida a Wirth se conoce como Pascal Standard. Sin embargo, el lenguaje Pascal ha tenido algunos cambios que llevaron a la creación de distintos standards del mismo.

Estructura de un programa codificado en Pascal

Todo programa en Pascal, consta de una cabecera y un bloque. La cabecera comienza con la palabra Program

seguida de cierta información adicional necesaria. Esta parte del programa consta sólo de una línea. El bloque tiene dos partes principales, la parte declarativa y la de sentencias. La parte declarativa define los

diferentes elementos de datos que se usan en el programa. La parte de sentencias contiene las sentencias ejecutables que hacen que se efectúen acciones.

En todo programa en Pascal, se debe seguir esta estructura: Cabecera. Bloque: Declaraciones: Etiquetas. Constantes. Definiciones de tipo. Variables. Procedimientos y funciones. Sentencias.

Caracteres válidos Dentro de un programa en Pascal, son válidas las letras desde la A a la Z (incluso en minúsculas), los dígitos del

0 al 9 y algunos símbolos especiales, como bloques de construcción. Los símbolos especiales son:

+ . < ( : <= ) * ; > [ / , <= ] := ' <> { = ^ .. }

Palabras reservadas

En Pascal hay ciertas palabras reservadas que tienen un significado como ordenes dentro del lenguaje. Son:

AND DO FUNTION NUL PROGRAM TYPE ARRAY DOWNTO GOTO NOT RECORD UNTIL BEGIN ELSE IF OF REPEAT VAR CASE END IN OR SET WHILE CONST FILE LABEL PACKED THEN WITH DIV FOR MOD PROCEDURE TO

Identificadores Un identificador es un nombre dado a un elemento de programa, ya sea una constante, una variable un

procedimiento o un programa. Los identificadores están formados por letras o dígitos en cualquier, excepto que el primer carácter debe ser siempre una letra. Se permiten tanto letras mayúsculas como minúsculas, que se consideran indistinguibles (Case-Sensitive).

Un identificador puede ser deliberadamente largo pero en algunas versiones de Pascal, sólo reconocen los primeros ocho caracteres. Igualmente, el uso de identificadores extremadamente largos, resulta impráctico.

Validez de los identificadores

Los siguientes nombres son identificadores válidos: D F15 SUMA CALOR DIA AREA SUPERFICIE TABLA2 Los siguientes nombres son identificadores inválidos: 4TO No se permite iniciar un identificador con un dígito Array Se trata de una palabra reservada F DER No se pueden dejar espacios en blanco.

Identificadores estándar El lenguaje Pascal tiene una serie de identificadores estándar con un significado ya definido. Estos son: Abs false pack Sin arctan get page Sqr boolean input pred Sqrt char integer put Succ chr ln read Text cos maxint readln True dispose new real Trunc eof odd reset Unpack eoln ord rewrite Write exp output round Writeln Algunas versiones de Pascal incluyen identificadores estándar adicionales. De todas maneras, a diferencia de las

palabras reservadas (que nunca pueden redefinirse) los identificadores estándar pueden ser redefinidos por el programador. Esto se consigue mediante las declaraciones y definiciones apropiadas.

2

Constantes.

A menudo, es conveniente asociar un dato simple, tal como el valor numérico o una cadena, a un identificador,

proporcionando así un nombre al dato. El identificador se dice que es una constante si se le asigna el dato permanente (es decir, el valor del dato permanece inalterado a lo largo del programa).

Una constante debe ser estar definida siempre antes de que aparezca en una sentencia. Esta definición cubre dos propósitos: Establece que el identificador es una constante y asocia un valor a la constante. El tipo de la constante estará determinado implícitamente por el dato.

La forma de definición de constantes se expresa: CONST nombre = valor donde nombre es un identificador que representa el nombre de la constante y valor es el dato efectivo que

se asigna a la constante.

Variables. Un identificador cuyo valor se permite que cambie durante la ejecución del programa se dice que es una

variable debe ser declarada (definida) individualmente antes de que aparezca en el programa. La declaración de variable establece el hecho de que el identificador es una variable (en lugar de una constante, u otro tipo) y especifica el tipo de la variable. A diferencia de una definición de constante en su declaración no se asocia un dato concreto, por ejemplo, un valor numérico o una constante a la variable.

La forma general de declaración de una variable es: VAR nombre : tipo o, en caso de haber más de una variable del mismo tipo, VAR nombre1, nombre2, nombre3,..., nombren : tipo donde nombre1, nombre2, nombre3, etc., son identificadores que representan nombres de

variables individuales y tipo se refiere al tipo de dato de las variables. Por ejemplo, suponiendo dos variables, fila y columna, cuyos valores serán números enteros, la variable valor,

con valores reales, y la variable marca con valor booleano. VAR fila,columna : integer; valor : real; marca : boolean; Si además, se declara la constante kilouni, CONST kilouni = 'Kg'; VAR fila,columna : integer; valor : real; marca : boolean;

Expresiones Una expresión es una colección de operandos (es decir, números, constantes, variables, etc.) enlazados por

ciertos operadores, para construir una fórmula algebraica que representa un valor (es decir, un dato simple). En Pascal, hay dos tipos de expresiones: numéricas y lógicas.

Por ejemplo, en la expresión numérica(b*b-4*4*a*c)/(2*a)los identificadores a,b,c y los números 4

y 2, son los operandos y los símbolos *,- y / son los operadores (que representan multiplicación, resta y división respectivamente). Los paréntesis se usan para indicar el orden de las operaciones. La expresión completa, representa un número. Suponiendo a,b,c valen 4, 5, y 6 respectivamente, la expresión representa el valor -8.875.

3

Las expresiones lógicas se usan en las estructuras de control tal como en la siguiente pregunta: IF VALOR<10 THEN WRITELN('Valor menor que 10'); En esta estructura, valor es una variable del tipo real, y el símbolo < es un operador lógico. Por otro lado,

valor y 10 son los operandos de ésta expresión lógica.

Sentencias

Una sentencia es una instrucción o un grupo de instrucciones que hacen que la computadora lleve a cabo ciertas

acciones. En este lenguaje hay dos tipos de sentencias: Simples y estructuradas. Las sentencias simples son esencialmente instrucciones únicas e incondicionales que afectan a una de las siguientes tareas:

1.- Asignar un dato a una variable. (Se llama sentencia de asignación). 2.- Acceder a un módulo de cálculo autónomo, llamado procedimiento. 3.- Transferir el control del programa incondicionalmente a otra parte del mismo (Sentencia goto). Las sentencias estructuradas consiste en una secuencia de dos o más sentencias consecutivas encerradas entre

las palabras claves BEGIN y END, y separadas por punto y coma [;]. Las sentencias individuales que intervienen en la sentencia compuesta, pueden ser simples o estructuradas.

Procedimientos y funciones

Los procedimientos y las funciones son elementos autónomos de programa, a los que a veces se llama módulos

y que realizan acciones señaladas. Estos módulos pueden ser invocados desde distintas partes de un programa y pueden recibir en cada invocación distintos datos y por lo tanto, generar cada vez que se los use, distintos resultados.

Los datos que se transfieren a un procedimiento, ya sean constantes o variables, se llaman parámetros. La transferencia de la lista de parámetros se hace indicando entre paréntesis y separados por coma, inmediatamente después del nombre del procedimiento.

Algunos de los parámetros pueden ser utilizados para representar la nueva información que el procedimiento genere, por lo tanto, los parámetros pueden ser información que se pasa al procedimiento o, información que se pasa desde el procedimiento al programa.

En el lenguaje Pascal, se pueden definir procedimientos propios como así también usar los procedimientos que el lenguaje provee. Aun así, ambos tipos de procedimientos deben ser invocados por una sentencia simple, que consiste en el nombre del procedimiento y la lista de parámetros opcionales.

Operadores aritméticos

El Pascal provee una serie de operadores aritméticos destinados a la resolución de cálculos matemáticos, ya sea

con operandos reales o enteros.

Operador Efecto Tipo de operandos Tipo de resultado + Adición Entero Entero - Sustracción Entero Entero + Adición Real Real - Sustracción Real Real / División Entero Real * Multiplicación Entero Entero / División Real Real * Multiplicación Real Real DIV División truncada Entero Entero MOD Resto de la división Entero Entero

Note que el operador /, siempre da como resultado un dato real, y por otro lado, que no hay operador

exponencial.

4

Ahora supongamos que a dos variables enteras, a y b, se le asignen los valores 14 y 4 respectivamente.

Expresión Valor a+b 17 a-b 11 a*b 42

a DIV b 3 a MOD b 2

Funciones estándar

Este lenguaje provee una serie de funciones que se emplean con diferentes tipos de datos simples. Algunas

utilizan un parámetro y devuelven un valor del mismo tipo del parámetro dado, y otras, devuelven un valor de distinto tipo que el parámetro de entrada.

Función Efecto Dato de entrada Dato de salida abs(x) Calcula el valor absoluto entero-real igual que x arctan(X) Calcula la arco tangente de x entero-real real chr(x) Determina el carácter x entero-real char cos(x) Calcula el coseno de x entero-real real exp(x) Calcula ex donde x=2.7182818 entero-real real ln(x) Calcula el logaritmo de x

(x>0) entero-real Real

odd(x) Determina si x es par o impar entero-real booleano ord(x) Determina el entero decimal

que se usa para codificar el char x

Char Entero

pred(x) Determina el predecesor de x Entero-char Igual que x – booleano

round(x) Redondea el valor x al entero más próximo

Real Entero

sin(x) Calcula el seno de x Entero-real real sqr(x) Calcula el cuadrado de x Entero-real igual que x sqrt(x) Calcula la raíz cuadrada de x

(x>0) Entero-real real

succ(x) Determina el sucesor de x Entero-char igual que x-booleano

trunc(x) Trunca x (es decir, suprime la parte decimal de x)

Real entero

Asignación de valores a variables

Asignar es dar a una variable un determinado valor. Se puede asignar a una variable una constante o el valor de

otra variable. Los tipos de datos que se asignen deben corresponder con el tipo de variable, salvo el caso de los datos enteros que pueden ser asignados a variables reales.

variable:=dato

Ejemplo: area:=3.14159*SQR(radio); Suponiendo que radio=4 la variable area tomará el valor 6.2831 Por otro lado, el (;) que figura al final de la instrucción, es un separador que se usa en todas las sentencias del

lenguaje Pascal.

5

Asignación de variables tipo Char

Supongamos que nombre es una variable tipo char nombre:='Margarita'; Esta instrucción hará que nombre tome el valor de esa cadena.

Asignación de variables tipo Boolean Supongamos que hab es una variable tipo boolena y que x e y son dos variables enteras, la sentencia: hab:=(x>134) or (y=543); Esta instrucción hará que hab tome el valor verdadero o falso, según el resultado de esa expresión lógica.

Incrementos de variables tipo Integer o Real El incremento de una variable, es el proceso por el cual, al valor actual de la variable se le suma un valor

determinado.

Ejemplos: contar:=contar + 1; contar:=succ (cuenta); En este caso, ambas sentencias tienen como resultado que el valor final de la variable contar es el valor

anterior de contar más 1

Manejo de datos de E/S Entendiendo como dato de entrada a todo aquel dato que se introduce a un programa y como dato de salida a

todo aquel dato que se extrae del programa, en Pascal, es necesario definir en la cabecera del mismo si vamos a manejar únicamente datos de entrada, únicamente datos de salida o ambos.

Por lo general, la mayoría de los programas de una u otra forma utilizan algún método que permite extraer resultados, pero no siempre son necesarios datos de entrada externos al programa para generar datos de salida.

Pascal considera a los datos, ya sean de entrada como de salida, algo externo al programa.

Ejemplo: PROGRAM SUMA (output); Suponiendo que esta cabecera se refiere a un programa en Pascal cuyo objetivo es sumar dos números. Sin no se

dispone de datos de entrada, únicamente sumará los constantes que el programa posea. En cambio, en el ejemplo siguiente:

PROGRAM SUMAR(input,output); en este caso, al estar declarado que se ingresaran datos, es posible modificar el programa para que sume

cualquier número.

6

Ingreso de datos usando Read Esta sentencia se usa para leer datos y asignarlas en una variable o más variables del tipo char, integer o real. La

sintaxis general es: read (variable1,variable2,variable3,..variableX); Los nombres de las variables deben separarse por comas y no pueden ingresarse variables tipo boolean.

Suponiendo el siguiente bloque de programa: VAR fila,columna : integer; valor : real; . . . read (fila,columna,valor); Según ésta sentencia read, se leerán dos valores que se asignarán a las variables fila y columna, que

corresponden según se declaró a dos variables enteras (integer) y se leerá un tercer valor que se asignará en la variable valor (Según lo declarado, real).

Los datos numéricos que se ingresen, deben ir separados unos de otros por espacios en blanco o por una indicación de fin de línea. Los números reales pueden escribirse con o sin exponente. Asimismo, los números reales que representen cantidades enteras (caso 2.0) pueden ser escritos como enteros (es decir, 2) Cualquier número puede ir precedido por su signo, ya sea (+) o (-), pero sin un espacio entre el signo y el número.

Los datos tipo char que se ingresen se tratan como una única cadena, por lo que todos los datos son significativos. No se deben separar los datos por espacios o indicación de fin de línea, ya que se interpreta como un carácter más dentro de la cadena.

Ejemplo:

VAR fila,columna : integer; nombre,apellido : char; . . . read (fila,columna,nombre,apellido); Suponiendo que los valores a entrar son:

Variable Valor Fila 1 Columna 3 Nombre Marcela Apellido Molina

Los datos pueden ser ingresados de la siguiente manera: 1 3 MarcelaMolina Si una sentencia va seguida de otra, la segunda sentencia read, comienza donde la primera terminó. Es decir, la

sentencia read, comenzará leyendo el dato siguiente al último leído por la sentencia read anterior. Una nueva sentencia read no necesariamente tiene por qué comenzar leyendo una nueva línea de datos.

7

Ejemplo: VAR fila,columna : integer; nombre,apellido : char; . . . read (fila,columna); read (nombre,apellido);

Ingreso de datos usando Readln

La sentencia readln, al igual que la sentencia, se utiliza para leer datos externos. La sintaxis es la misma que la

sentencia read: readln (variable1,variable2,variable3,..variableX); La diferencia entre ambas, radica en que ésta sentencia hace que la próxima sentencia read o readln comience

leyendo una nueva línea de datos, mientras que la sentencia read, permitía que la siguiente sentencia (ya sea read o readln) comenzara en la misma línea.

Ejemplo:

VAR fila,columna,dia,mes : integer; . . . read (fila,columna); read (dia,mes); Suponiendo ésta entrada: 1 4 13 11 2 5 4 5 Las sentencias read, asiginarian los valores 1 4 13 11 a las variables fila,columna,dia y mes. Si

reemplazamos esas sentencias read por readln:

Ejemplo: VAR fila,columna,dia,mes : integer; . . . readln (fila,columna); readln (dia,mes); Las sentencias readln provocarían (suponiendo la misma entrada anterior) que los valores 1 y 4 se asignaran

en las variables fila y columna pero en las variables dia y mes se asignarían los valores 2 y 5.

Escritura de datos usando Write La sentencia write se usa para escribir datos en algún dispositivo de salida. La sintaxis de la sentencia es: write (datos de salida); Los datos de salida pueden ser cadenas, constantes numéricas o valores de variables o expresiones. Pueden ser

datos de cualquier tipo y las cadenas, deben ir encerradas entre apóstrofos. Los datos, si son más de uno, deben estar separados por (,) comas.

8

Ejemplo: write ('Total=',tot); De esa manera, suponiendo que la variable tot tiene el valor 1311.79 la sentencia write escribiría en el

dispositivo de salida lo siguiente: Total=1.31179E+03 También, si tuviéramos: write ('Total=',stot+iva); Hace que el valor de la expresión numérica stot+iva se escriba en el dispositivo de salida. De esa manera, si

stot=3 e iva=1 la sentencia write, producirá: Total= 4 Los números reales pueden visualizarse de diferentes maneras, aunque el formato por defecto es la notación

científica o exponencial, como puede deducirse del primer ejemplo. Los datos booleanos, dependiendo de sus valores, podrán ser representados por los identificadores estándar True o False.

La mayoría de las versiones comerciales de Pascal, utilizan un ancho de campo para representar datos. Este ancho es diferente según el tipo de dato y también según la versión utilizada de Pascal. Los valores más frecuentes son:

Dato Ancho Real 14 (7 dígitos a la derecha del punto decimal) Entero 8 Booleano 6 Si el campo es mayor de lo necesario, el dato es colocado a la derecha, dejando los lugares vacíos, como se vio

en el ejemplo anterior. Si tratamos con datos tipo char, el ancho del campo será el mismo que la longitud de la cadena. No habrá en ese caso ningún espacio en blanco, a menos que lo conformen como parte de la cadena.

Ejemplo:

write ('DALE',' UNA',' OPORTUNIDAD',' A',' LA',' PAZ'); Generaría ésta salida: DALE UNA OPORTUNIDAD A LA PAZ Nótese que los espacios en blanco que contienen cada una de las cadenas hacen de separadores entre cada una

de ellas, si no hubieran espacios vacíos, es decir:

Ejemplo: write ('DALE','UNA','OPORTUNIDAD','A','LA','PAZ'); Generaría ésta salida: DALEUNAOPORTUNIDADALAPAZ Si una sentencia write va seguida de otra, la segunda sentencia comenzará donde termine la primera. Es decir

que el primer dato escrito por la segunda sentencia, estará a continuación del último dato escrito por la primer sentencia write, por lo que una sentencia write, no necesariamente genera una nueva línea de salida.

9

Ejemplo: VAR fila,columna : integer; nombre,apellido : char;

. . . read (fila,columna); read (nombre,apellido);

. . . write ('Fila=',fila,'Columna',columna); write ('Nombre:',nombre,'Apellido:',apellido); Suponiendo que los datos son los mismos que los del ejemplo se obtendría: Fila= 1Columna= 3Nombre:MarcelaApellido:Molina Escritura de datos usando Writeln La sentencia writeln es similar a la sentencia write, con la diferencia que ésta, agrega un carácter de fin de línea

al último dato, por lo que una nueva sentencia write o writeln, comenzarán en una nueva línea de salida. La sintaxis es:

writeln (datos de salida);

Ejemplo: VAR fila,columna : integer; nombre,apellido : char; . . . read (fila,columna); read (nombre,apellido); . . . writeln ('Fila=',fila,' Columna',columna); write ('Nombre: ',nombre,' Apellido: ',apellido); Suponiendo los mismos datos del ejemplo anterior, la salida que se obtendría sería: Fila= 1 Columna= 3 Nombre: Marcela Apellido: Molina

Modificación de los campos de escritura. La longitud de los campos de escritura de cada tipo de dato pueden ser variados utilizando las sentencias write

y writeln. En general, cada dato puede ir seguido de (:) dos puntos y una cantidad positiva que indique el ancho de campo

a usar para ese dato en particular.

10

Ejemplo: write ('Total=',tot :5); Suponiendo tot=-134, obtendríamos: Total= -134 El espacio en blanco, está comprendido dentro del ancho del campo especificado.

Ejemplo: write ('Total=',tot :lar+3); Suponiendo tot=-134 y lar=3 , obtendríamos: Total= -134 Nótese que ahora hay dos espacios en blanco y el dato fue desplazado a la derecha. De otra manera, en caso que

el ancho de campo no alcance, se agregan los espacios necesarios para que el dato no se corte.

Ejemplo: write ('Total=',tot :5); Suponiendo tot=900134, obtendríamos: Total= 900134 Ahora, se han añadido 2 espacios al ancho del campo para que el número de 6 dígitos y su signo se escriban

correctamente. Un número de tipo real puede escribirse sin exponente si se incluye un segundo término en el formato. Así, el

formato completo para un número real es (:) dos puntos seguido de un entero que indica el ancho total del campo, seguido por (:) dos puntos y un segundo entero que indica a su vez, la cantidad de lugares a la derecha del punto decimal. La parte decimal, se redondea automáticamente.

Ejemplo:

Suponiendo que nodo es una variable real a la que se le ha asignado el número 35200.203, el número se

escribirá según la sentencia write usada en cada caso como sigue a continuación:

Sentencia Resultado writeln ('Nodo=',nodo); Nodo= 3.5200203E+04 writeln ('Nodo=',nodo : 12); Nodo= 3.52002E+04 writeln ('Nodo=',nodo : 18); Nodo= 3.52002030000E+04 writeln ('Nodo=',nodo : 10 : 3); Nodo= 35200.203 writeln ('Nodo=',nodo : 8 : 1); Nodo= 35200.2

Del pseudocódigo al programa fuente en Pascal.

Una vez que se ha formulado la estrategia general y se ha escrito el pseudocódigo del programa a desarrollar, se

puede pasar a la traducción del mismo a un lenguaje de programación, en este caso, Pascal. En este punto, cada pseudoinstrucción del pseudocódigo, se cambiará por la instrucción equivalente en Pascal.

Si el pseudocódigo es lo suficientemente detallado y correcto, el trabajo es mínimo. Sin embargo, cuando se escribe un programa en Pascal hay que mantener presentes el esquema fijo que deberá

tener nuestro programa. En la escritura de las sentencias ejecutables, se permite una gran libertad sintáctica. El único requerimiento fijo

es que las sentencias ejecutables deben ir incluidas dentro de una sentencia compuesta general (es decir, BEGIN...END). Así todo programa debe tener una sentencia BEGIN...END. Otras sentencias compuestas pueden incluirse -si se desea- en esta secuencia compuesta general. Cada sentencia compuesta puede incluir una variedad de

11

sentencias o grupos de sentencias ejecutables. También debe prestarse atención a la puntuación, particularmente al uso del (;) punto y coma.

Las reglas básicas se pueden resumir como:

1. El (;) punto y coma se usa como separador en Pascal. De aquí que se use entre sentencias y declaraciones sucesivas, más que como fin de cada sentencia. 2. A BEGIN y END se les aplican reglas especiales. Son dos elementos generalmente llaves que indican el comienzo y el fin de una sentencia compuesta. Por esto BEGIN, no necesita ir seguido de (;) punto y coma, lo mismo que END no necesita ser precedido por (;) punto y coma. 3. Un (;) punto y coma innecesario (por ejemplo, precediendo a una llave END) se interpretaría como una sentencia nula. Generalmente, esto no tendrá efecto apreciable en la ejecución del programa, aunque hay situaciones en las que la lógica del programa puede ser alterada intencionalmente, por lo que deben ser evitados. 4. Todo programa completo debe terminar con un (.) punto. Así, la llave END final debe ir seguida de un punto.

Construcción de un programa en Pascal. Retomando el ejemplo del pseudocódigo de la página 2 del apunte anterior

inicio leer base,altura sup=(base*altura)/2 fin

imprimir sup

Teniendo en cuenta el tipo de variables a utilizar, todas variables reales, podemos encarar la traducción a Pascal. PROGRAM TRIANG (input,output); VAR base,altura,sup:real; BEGIN read (base,altura); sup :=(base * altura)/2; write('La superficie es=',sup); E ND.

Si bien éste programa está completo, no presentará en la práctica algunas características deseables para cualquier programa. Agreguemos a ese mismo programa, comentarios que den una idea a otro programador que se encontrara con él para modificarlo. Los comentarios permitirán que se de una idea de que es lo que se está desarrollando en cada paso. Los comentarios se encierran entre () paréntesis o entre {} llaves, según la versión de Pascal.

PROGRAM TRIANG (input,output); {*Calculo de la superficie de un triángulo*} VAR base,altura,sup:real;

12

{*Declaración de las variables*} BEGIN {*Comienzo de las sentencias ejecutables*} read (base,altura); {*Leer los valores de base y altura*} sup :=(base * altura)/2; {*Multiplicar base por altura y dividir por 2. asignar ese valor a la variable sup*} write('La superficie es=',sup); {*Escribir el valor calculado de la superficie*} END. {*Fin de las sentencias ejecutables y del programa*}

Estructuras de Control - Iteración

De lo expuesto referente a estructuras que permitían controlar en lógicamente los algoritmos, se llega a la

codificación en Pascal de esas estructuras. Las estructuras que fueron tratadas en particular, obtienen una codificación muy similar a lo visto, con lo cual,

no hay demasiada dificultad para obtener códigos en base a esos algoritmos con estructuras de control

Decisiones simples (If-Then) Tal como se explicó anteriormente esta estructura permite condicionar una acción en base a una condición

lógica. La forma simple es: IF expresión lógica THEN sentencia

Ejemplos: If a>b then write (a); If a<b then

BEGIN Read m,n; Writeln(m+n);

End; END.

Decisiones dobles (If-Then-Else) La estructura de control vista en el apunte anterior en la página 5 se puede codificar en Pascal de la siguiente

manera: IF expresión lógica THEN sentencia1 ELSE sentencia2 El ejemplo 3, de la misma página del apunte anterior, quedaría codificado en Pascal: PROGRAM EJEMPLO(INPUT,OUTPUT); VAR a,b,x:=real BEGIN Read (a,b); if a<b then x:=a*b else x:=a+b; write (x); END.

13

Decisiones Múltiples (Case)

La estructura CASE, vista en la página 7 del apunte anterior, se codifica en pascal en forma general: CASE expresión OF selector1: sentencia1; selector2: sentencia2; selector3: sentencia3; selector4: sentencia4; : : : selectorn: sentencian END La expresión puede ser cualquier tipo que no sea real. A menudo, se trata de una sola variable de tipo simple. Los selectores, representan valores posibles de la expresión. Así si la expresión es de tipo entero, los selectores

presentarán valores enteros dentro de un rango determinado. Los selectores pueden o no presentarse en orden, pero no deben repetirse. Las sentencias pueden ser simples o estructuradas. El uso de sentencias estructuradas es bastante común. Las sentencias no tienen porque ser únicas (Una misma sentencia se puede usar con dos o más selectores. Cada sentencia se ejecutará solamente si el selector coincide con la expresión.

El ejemplo de la pagina 7 del apunte anterior, queda codificado: PROGRAM EJEMPLO2(INPUT,OUTPUT); VAR nota:integer; BEGIN read (nota);

if (nota >= 1) and (nota <= 10) then Begin

CASE nota OF 1,2,3: write('Aplazado'); 4,5: write('Regular'); 6,7,8,9,10: write('Aprobado');

end; end;

END.

Lazo condicional (While-Do) La estructura de While-Do permite un control repetitivo condicional. La forma general de ésta estructura es: WHILE expresión lógica DO sentencia La parte de la sentencia de la estructura se ejecutará repetidamente en tanto la expresión lógica sea cierta. La sentencia puede ser simple o estructurada, aunque generalmente, es una sentencia compuesta que puede

modificar el valor de la expresión lógica.

14

El ejemplo de la página, queda entonces como: PROGRAM SUMA_ITERATIVA(INPUT,OUTPUT); VAR n,cant:integer; VAR suma,numero:real; BEGIN read (n); cant:=0; suma:=0; WHILE cant<n DO

BEGIN read (numero); suma:=suma+numero; cant:=cant+1;

end; write(suma); end.

Lazo condicional (Repeat-Until)

La estructura de Repeat-Until permite un control repetitivo condicional similar al proporcionado por la

estrutura While-Do. La forma general de expresar el lazo es: REPEAT sentencias UNTIL expresión lógica Las sentencias se ejecutarán hasta que la expresión lógica sea cierta. Nótese que al menos una vez, las

sentencias se ejecutarán, ya que la estructura chequea la expresión lógica recién al final de la misma. Otra diferencia entre While-Do y Repeat-Until es que mientras la primera sólo permite una sentencia (Aunque

permite que sea compuesta), la estructura Repeat-Until permite que las sentencias no estén comprendidas entre Begin-End.

Utilizando esta estructura, el ejemplo de la página, queda codificado: PROGRAM SUMA_ITERATIVA_REP(INPUT,OUTPUT); VAR n,cant:integer; VAR suma,numero:real; BEGIN read (n); cant:=0; suma:=0; REPEAT

read (numero); suma:=suma+numero; cant:=cant+1;

UNTIL CANT=N; write(suma); end.

Estructura repetitiva (For) La estructura For (ver Parte 3 Pag18) se emplea para realizar bucles incondicionales en Pascal. Es decir, esta

estructura permite que una acción se repita una determinada cantidad de veces. La forma general de la estructura es: FOR variable de control := valor1 TO valor2 DO sentencia La sentencia de la estructura puede ser simple o estructurada, aunque generalmente es una sentencia compuesta

que puede incluir estructuras de control. Esta sentencia se ejecutará para cada uno de los valores sucesivos asignados

15

a la variable de control. El número de valores asignados a la variable de control determina el número de veces que la sentencia se ejecutará.

La variable de control debe ser una variable simple de cualquier tipo, menos real. Normalmente, será una variable entera. Inicialmente, a ésta variable, se le asigna el valor1. La variable de control toma automáticamente el valor siguiente cada vez que el lazo se cierra, hasta que alcanza el valor2.Si la variable de control es entera, se incrementará en 1 cada vez que se complete el bucle, por lo que la sentencia se ejecutara (valor2 - valor1 + 1) veces.

Usando esta estructura, el ejemplo de la página 12 del apunte anterior, queda codificado: PROGRAM SUMA_ITERATIVA_DESDE(INPUT,OUTPUT); VAR n,cant:Integer; VAR suma,numero:Real; BEGIN read (n); suma:=0; FOR cant:=1 TO N DO

begin read(numero); suma:=suma+numero;

end; write ('La suma de los ',N,' n£meros es ',suma); end. Otra manera de usar ésta estructura permite que el incremento de la variable de control sea negativo. Eso se

logra utilizando -en lugar de TO- la palabra DownTO. Como resultado, la expresión de la estructura quedaría de la siguiente manera: FOR variable de control := valor1 DOWNTO valor2 DO sentencia La operación es similar a la anterior, excepto que la variable de control decrementa su valor desde valor1

hasta llegar al valor2. Si ambos valores son iguales, la sentencia se ejecutará sólo una vez; y si valor1 es menor que valor2 la sentencia no se ejecutará nunca. El decremento de la variable de control se hace cada vez que se cierra un bucle y es de -1.

Si en el ejemplo anterior, modificamos la línea que contiene la sentencia For, el programa funcionaria de la misma manera, salvo que la variable de control estaría tomando valores en el orden inverso al del caso anterior. Por lo tanto, en vez de contar desde 1 hasta n, contaría desde n hasta 1, decrementando el valor de n en 1 cada vez que el bucle se completa.

Debe entenderse que el valor1 y valor2 se evalúan sólo una vez, antes del primer paso por el bucle. Finalmente, una vez que concluye el bucle, la variable de control toma un valor indefinido, que suele ser el

valor final del bucle + 1 PROGRAM SUMA_ITERATIVA_DESDE_DEC(INPUT,OUTPUT); VAR n,cant:Integer; VAR suma,numero:Real; BEGIN read (n); suma:=0; FOR cant:=n DOWNTO 1 DO

begin read(numero); suma:=suma+numero;

end; write ('La suma de los ',N,' n£meros es ',suma); end.

16