Estructura general de programas en Pascal

2.1 Estructuras general de programas en Pascal
Pascal es un lenguaje de programación de alto nivel, que facilita la práctica de la
programación estructurada. Utiliza un traductor que produce código ejecutable, lo
cual disminuye los tiempos de ejecución de los programas.
El lenguaje Pascal fue desarrollado por Niklaus Wirth, con el propósito de ayudar a
los estudiantes en el manejo de las técnicas de la programación estructurada, pero en
la actualidad su aplicación es de propósitos generales.
La construcción de programas en Pascal se basa en módulos que guardan las
siguientes reglas de construcción :
Program identificador ; {cabecera opcional en Turbo Pascal}
Uses identificadores
Label lista de etiquetas ; {sección de etiquetas}
Const
definiciones de constantes
Type
declaración de tipos de datos definidos por el usuario
Var
declaración de variables
Procedure
definiciones de procedimientos
Function
definiciones de funciones
begin {cuerpo del programa}
sentencias
end.
Las cinco secciones de declaración -Label, Const, Type y Procedure y/o Function , así
como la cláusula Uses y Program, no tiene que estar presentes en todos los programas.
Turbo Pascal es muy flexible al momento de escribir las secciones de declaración, ya
que se pueden hacer en cualquier orden (en Pascal estándar ISO si se require este
orden). Sin embargo es conveniente seguir el orden establecido, le evitará futuros
problemas.
Ejemplo:
Program MiPrimerPrograma; {cabecera}
Uses
Crt; {declaraciones}
Const
iva =0.10;
Type
cadena =string[35];
meses =1..12;
Var
sueldo :real;
numero :integer;
1
nombre :cadena;
Nmes
:meses;
begin
ClrScr; {Limpia la pantalla}
Write ('Escribe tu nombre : ');
{Visualiza información en pantalla}
ReadLn(nombre);{Leer un dato del teclado}
WriteLn ('Bienvenido ', nombre);
{Visualiza información en pantalla}
Readkey; {Espera la pulsación de una tecla}
ClrScr
end.
Nota: Las declaraciones de constantes, tipos y variables también se pueden poner en
los procedimientos y/o funciones.
Todo objeto referenciado en un programa debe haber sido previamente definido.
Ejemplo:
Program Incorrecto; {cabecera}
Const
pi=3.141592;
Var
Meses:array [1..Max] of string[15];
begin
...................................
end.
El programa anterior es incorrecto ya que hacemos referencia a la constante Max en
la declaración de variables sin haberla definido en la declaración de constantes.
2.2 Identificadores
En la mayoría de los programas de computador, es necesario manejar datos de
entrada o de salida, los cuales necesitan almacenarse en la memoria principal del
computador en el tiempo de ejecución. Para poder manipular dichos datos,
necesitamos tener acceso a las localidades de memoria donde se encuentran
almacenados; esto se logra por medio de los nombres de los datos o
IDENTIFICADORES.
Los identificadores también se utilizan para los nombres de los programas, los
nombres de los procedimientos y los nombres de las funciones, así como para las
etiquetas, constantes y variables.
Las reglas para formar los identificadores en Pascal son las siguientes :
1. Pueden estar compuestos de caracteres alfabéticos, numéricos y el carácter de
subrayado ( _ ).
2. Deben comenzar con un carácter alfabético o el carácter de subrayado.
3. Puede ser de cualquier longitud (sólo los 63 primeros caracteres son
significativos).
4. No se hace distinción entre mayúsculas y minúsculas.
5. No se permite el uso de los IDENTIFICADORES RESERVADOS en los
nombres de variables, constantes, programas o sub-programas.
Identificadores válidos
Nombre
Cadena
2
Edad_Maxima
X_Y_Z
Etiqueta2
Identificadores no válidos
Num&Dias
X nombre
begin
eje@s
:
:
:
:
carácter & no válido
Contiene un blanco
es una palabra reservada
carácter @ no válido
Elección de identificadores
La elección de identificadores permite una mejor lectura y comprensión de un
programa. No es aconsejable utilizar identificadores que no sugieran ningún
significado.
La siguiente tabla muestra los IDENTIFICADORES RESERVADOS en TurboPascal. Los marcados con un asterisco no están definidos en Pascal estándar . Los
marcados con ? no se utilizan en Turbo-Pascal
*ABSOLUTE IN
VAR
RECORD
*AND
*OVERLAY GOTO
ELSE
ARRAY
*STRING
?PACKED
WHILE
*EXTERNAL BEGIN
TO
LABEL
FILE
FOR
DIV
REPEAT
FORWARD
OF
*INLINE
WITH
NIL
THEN
PROCEDURE END
*SHL
CASE
UNTIL
AND
FUNCTION DO
SET
FILE
OR
IF
*XOR
NOT
TYPE
PROGRAM
*SHR
CONST
DOWNTO
MOD
Turbo-Pascal define los siguientes IDENTIFICADORES ESTANDAR de tipos
predefinidos, constantes, variables, procedimientos y funciones. Cualquiera de ellos
puede ser redefinido, perdiéndose así la facilidad de utilizar su definición original.
ADDR
DELAY
LENGTH
RELEASE
ARCTAN
DELETE
LN
RENAME
ASSIGN
EOF
LO
RESET
AUX
EOLN
LOWVIDEO
REWRITE
AUXINPTR
ERASE
LST
ROUND
AUXOUTPTR
EXECUTE
LSTOUTPTR SEEK
BLOCKREAD
EXIT
MARK
SIN
3
BLOCKWRITE EXP
MAXINT
SIZEOF
BOOLEAN
FALSE
MEM
SEEKEOF
BUFLEN
FILEPOS
MEMAVAIL
SEEKEOLN
BYTE
FILESIZE
MOVE
SQR
CHAIN
FILLCHAR
NEW
SQRT
CHAR
FLUSH
NORMVIDEO STR
CHR
FRAC
ODD
SUCC
CLOSE
GETMEM
ORD
SWAP
CLREOL
GOTOXY
OUTPUT
TEXT
CLRSCR
HALT
PI
TRM
CON
HEAPPTR
PORT
TRUE
CONINPTR
HI
POS
TRUNC
CONOUTPTR
IORESULT
PRED
UPCASE
CONCAT
INPUT
PTR
USR
CONSTPTR
INSLINE
RANDOM
USRINPTR
COPY
INSERT
RANDOMIZE USROUTPTR
COS
INT
READ
VAL
CRTEXIT
INTEGER
READLN
WRITE
CRTINIT
KBD
REAL
WRITELN
DELLINE
KEYPRESSED
2.3 Declaración de etiquetas
En el remoto caso de que sea necesaria la utilización de la instrucción Goto, deberá
marcarse con una etiqueta la línea a donde desea enviarse el control de flujo del programa.
La declaración deberá encabezarse con el identificador reservado Label, seguido por la lista
de etiquetas separadas por comas y terminada por un punto y coma.
Pascal estándar sólo permite etiquetas formadas por números de 1 a 4 dígitos.
Turbo-Pascal permite la utilización de números y/o cualquier identificador, excepto los
identificadores reservados.
Su uso no está recomendado y en este tutorial no se empleará nunca.
2.4 Definición de constantes
En la definición de constantes se introducen identificadores que sirven como
sinónimos de valores fijos.
El identificador reservado Const debe encabezar la instrucción, seguido por una lista
de asignaciones de constantes. Cada asignación de constante debe consistir de un
identificador seguido por un signo de igual y un valor constante, como se muestra a
continuación:
Const
4
valor_maximo =255;
precision
=0.0001;
palabra_clave='Tutankamen';
encabezado
=' NOMBRE DIRECCION TELEFONO ';
Un valor constante puede consistir de un número ( entero o real ), o de una constante
de caracteres.
La constante de caracteres consiste de una secuencia de caracteres encerrada entre
apóstrofes ( ' ), y, en Turbo-Pascal, también puede formarse concatenándola con
caracteres de control ( sin separadores ), por ejemplo :
'Teclee su opción ==>'^G^G^G ;
Esta constante sirve para desplegar el mensaje :
Teclee su opción ==>
y a continuación suena el timbre tres veces.
Las constantes de caracteres pueden estar formadas por un solo carácter de control,
p.ej. :
hoja_nueva = ^L
Existen dos notaciones para los caracteres de control en Turbo Pascal, a saber :
1. El símbolo # seguido de un número entero entre 0 y 255
representa el carácter al que corresponde dicho valor decimal en el codigo
ASCII.
2. El símbolo ^ seguido por una letra, representa el correspondiente carácter de
control.
Ejemplos :
#12
representa el valor decimal 12
( hoja_nueva o alimentación de forma ).
#$1B representa el valor hexadecimal 1B ( escape ).
^G
representa el carácter del timbre o campana.
^M
representa el carácter de retorno de carro.
Pascal proporciona las siguientes CONSTANTES PREDEFINIDAS :
Nombre
Tipo
pi
real
false
boolean
true
boolean
Valor
3.1415926536 (Sólo en Turbo Pascal)
MaxInt integer 32767
idemás de las constantes literales para los tipos integer y real con representación
decimal y hexadecimal, y las constantes literales para el conjunto de caracteres
ASCII, más los caracteres especiales ( no incluidos en el conjunto estándar del ASCII )
2.5 Definición de tipos
Además de identificadores, los datos deben tener asignado algún tipo que indique el
espacio de memoria en que se almacenarán y que al mismo tiempo evita el error de
tratar de guardar un dato en un espacio insuficiente de memoria .
Un tipo de dato en Pascal puede ser cualquiera de los tipos predefinidos ( integer, real,
byte, boolean, char ), o algún otro definido por el programador en la parte de
definición de tipos .
5
Los tipos definidos por el programador deben basarse en los tipos estándar
predefinidos, para lo cual, debe iniciar con el identificador reservado Type , seguido
de una o más asignaciones de tipo separadas por punto y coma. Cada asignación de
tipo debe consistir de un identificador de tipo, seguido por un signo de igual y un
identificador de tipo previamente definido.
La asignación de tipos a los datos tiene dos objetivos principales:
1.
Detectar errores de operaciones en programas.
2.
Determinar cómo ejecutar las operaciones.
Pascal se conoce como un lenguaje "fuertemente tipeado" (strongly-typed) o de tipos
fuertes. Esto significa que todos los datos utilizados deben tener sus tipos declarados
explícitamente y el lenguaje limita la mezcla de tipos en las expresiones. Pascal detecta
muchos errores de programación antes de que el programa se ejecute.
Los tipos definidos por el programador pueden utilizarse para definir nuevos tipos,
por ejemplo :
Type
entero
= integer;
otro_entero = entero;
A continuación se hace una breve descripción de los tipos predefinidos .
Tipos enteros
Tipos enteros predefinidos
Tipo
byte
Rango
Formato
0 .. 255
8 bits sin signo
integer -32768 .. 32767
16 bits con signo
longint -247483648 .. 2147483647 32 bits con signo
shortint -128 .. 127
8 bits con signo
word
16 bits sin signo
0 .. 65535
BYTE
El tipo byte es un subconjunto del tipo integer, en el rango de 0 a 255 . Donde quiera
que se espere un valor byte, se puede colocar un valor integer; y viceversa
( EXCEPTO cuando cuando son pasados como PARAMETROS ). Asimismo, se
pueden mezclar identificadores de tipo byte y de tipo integer en las expresiones.
Los valores de tipo byte se guardan en UN OCTETO de memoria.
INTEGER
El rango de los valores definidos por el tipo integer , en Turbo Pascal, se encuentra
entre -32768 y 32767 .
Cada valor de este tipo se guarda en DOS OCTETOS de memoria.
LONGINT (enteros largos)
A partir de la versión 4.0 se han incorporado números que amplían el rango de
variación de los enteros a -2,147,483,648. Este tipo de datos se denomina longint
(enteros largos). Ocupan CUATRO OCTETOS de memoria. Existe una constante
predefinida de tipo longint, denominada MaxLongInt, cuyo valor es 2,147,483,647.
6
SHORTINT (enteros cortos)
En ciertos casos, puede ser práctico disponer de valores enteros positivos y negativos
cuyo alcance sea más restringido que el de los tipos enteros. Los tipos shortint pueden
tomar valores entre -128 y 127. Ocupan UN OCTETO de memoria.
WORD
Existen casos en los que se desea representar únicamente valores positivos. Este es el
caso. Por ejemplo, cuando se desea acceder desde un programa hasta una dirección de
memoria. En tal situación, no tiene sentido una dirección negativa. Turbo Pascal
dispone del tipo word (o palabra, de palabra de memoria), cuyo intervalo posible de
valores es de 0 a 65535. Ocupa DOS OCTETOS de memoria.
Tipos reales
REAL
En el contexto de Pascal, un número real es aquel que está compuesto de una parte
entera y una parte decimal, separadas por un punto. El rango de estos números está
dado entre los valores 1E-38 y 1E+38 . Cada valor de este tipo se guarda en SEIS
OCTETOS de memoria.
Durante una operación aritmética con números reales, un valor mayor que 1E+38
(sobreflujo) causará la detención del programa y desplegará un mensaje de error ;
mientras que un valor menor que 1E-38 (bajoflujo), producirá un resultado igual a
cero.
Deben tomarse en cuenta las siguentes restricciones para los valores de tipo real :
1. No pueden utilizarse como subindices en las definiciones del tipo estructurado
array.
2. No pueden formar subrangos.
3. No se pueden usar para definir el tipo base de un conjunto (tipo estructurado
set)
4. No deben utilizarse para el control de las instrucciones for y case.
5. Las funciones pred y succ no pueden tomarlos como argumentos.
Los números reales están siempre disponibles en Turbo Pascal, pero si su sistema
incluye un coprocesador matemático como 8087, 80287 u 80387, se dispone además de
otros tipos de números reales:
• real (real)
• single (real corto)
• comp (entero ampliado)
• double (real de doble precisión)
• extended (real ampliado)
Computadoras sin coprocesador matemático (emulación por software)
datos disponibles : real, comp, double, extended y single.
Computadoras con coprocesador matemático
datos disponibles : real, comp, double, extended y single (reales IEEE)
Desde la versión 5.0 se permite utilizar los datos tipo coprocesador matemático
aunque su computadora no lo tenga incorporado. La razón es que se emula dicho
7
coprocesador. Los diferentes tipos reales se diferencian por el dominio de definición,
el número de cifras significativas (precisión) y el espacio ocupado en memoria.
• Turbo Pascal 4.0 requiere obligatoriamente un chip coprocesador matemático
para hacer uso de números reales de coma flotante IEEE.
• Turbo Pascal 5.0 a 7.0 emula el chip coprocesador matemático totalmente en
software, permitiendo ejecutar tipos IEEE tanto si tiene como si no un chip
8087/287/387 instalado en su máquina.
Tipo
Rango
Cifras Tamaño y bytes
real
2.910 E -39 .. 1.710 E 38
11 -12
6
single
1.510 E -45 .. 3.410 E 38
7-8
4
double
5.010 E -324 .. 1.710 E 308
15 - 16
8
extended 1.910 E -4932 .. 1.110 E 4932 19 - 20
10
comp
8
-2 E 63 +1 .. 2 E 63 - 1
19 - 20
BOOLEAN
Un valor de tipo boolean puede asumir cualquiera de los valores de verdad denotados
por los identificadores true y false, los cuales están definidos de tal manera que false <
true .
Un valor de tipo boolean ocupa UN OCTETO en la memoria.
CHAR
Un valor de tipo char es cualquier carácter que se encuentre dentro del conjunto
ASCII ampliado, el cual está formado por los 128 caracteres del ASCII más los 128
caracteres especiales que presenta, en este caso, IBM.
Los valores ordinales del código ASCII ampliado se encuentran en el rango de 0 a 255.
Dichos valores pueden representarse escribiendo el carácter correspondiente
encerrado entre apóstrofes.
Así podemos escribir :
'A' < 'a'
Que significa : " El valor ordinal de A es menor que el de a " o " A está antes que a "
Un valor de tipo char se guarda en UN OCTETO de memoria.
CADENA (STRING)
Un tipo string (cadena) es una secuencia de caracteres de cero o más caracteres
correspondientes al código ASCII, escrito en una línea sobre el programa y encerrado
entre apóstrofos.
El tratamiento de cadenas es una característica muy potente de Turbo Pascal que
contiene ISO Pascal estándar.
Ejemplos:
'Turbo Pascal','Tecnológico', #13#10
Nota:
•
•
Una cadena sin nada entre los apóstrofos se llama cadena nula o cadena vacía.
La longitud de una cadena es el número de carácteres encerrados entre los
apóstrofos.
8
2.6 Operadores
Los operadores sirven para combinar los términos de las expresiones.
En Pascal, se manejan tres grupos de operadores :
1. ARITMÉTICOS
2. RELACIONALES
3. LÓGICOS
2.6.1 Operadores aritméticos
Son aquellos que sirven para operar términos numéricos. Estos operadores podemos
clasificarlos a su vez como :
a. UNARIOS
b. BINARIOS
Los operadores UNARIOS son aquellos que trabajan con UN OPERANDO.
Pascal permite el manejo de un operador unario llamado :
MENOS UNARIO
Este operador denota la negación del operando, y se representa por medio del signo
menos ( - ) colocado antes del operando.
Por ejemplo :
Si x tiene asignado el valor 100, -x dará como resultado -100 ; esto es que el resultado
es el inverso aditivo del operando.
Los operadores BINARIOS, son los que combinan DOS OPERANDOS , dando como
resultado un valor numérico cuyo tipo será igual al mayor de los tipos que tengan los
operandos.
La siguiente tabla muestra los símbolos de los operadores binarios de Pascal así como
los nombres de las operaciones que realizan.
Operadores aritméticos básicos
Operador
Operación
Operandos Ejemplo
Resultado
+
Suma
real , integer a + b
suma de a y b
-
Resta
real , integer a - b
Diferencia de a y b
*
Multiplicación
real , integer a * b
Producto de a por b
/
División
real , integer a / b
Cociente de a por b
div
División entera
integer
a div b
Cociente entero de a por
b
mod
Módulo
integer
a mod b Resto de a por b
shl
Desplazamiento a la
izquierda
a shl b
Desplazar a la izquierda b
bits
shr
Desplazamiento a la
derecha
a shr b
Desplazar a la derecha b
bits
Conviene observar lo siguiente :
9
1. Cuando los dos operandos sean del tipo integer, el resultado será de tipo
integer.
2. Cuando cualquiera de los dos operandos, o ambos, sean del tipo real, el
resultado será de tipo real.
3. Cuando, en la operación div, OPERANDO-1 y OPERANDO-2 tienen el mismo
signo, se obtiene un resultado con signo positivo; si los operandos difieren en
signo, el resultado es negativo y el truncamiento tiene lugar hacia el cero.
Ejemplos :
7
(-7)
(-7)
7
15.0
15
div
div
div
div
div
div
3
(-3)
3
(-3)
3.0
(4/2)
=
=
=
=
=
=
2
2
-2
-2
no válido
no válido
La operación div almacena sólo la parte entera del resultado, perdiéndose la parte
fraccionaria (truncamiento).
1. La operación MODULO está definida solamente para OPERANDO-2 positivo.
El resultado se dará como el entero no negativo más pequeño que puede ser
restado de OPERANDO-1 para obtener un múltiplo de OPERANDO-2 ; por
ejemplo :
6
7
(-6)
(-7)
(-5)
(-15)
mod
mod
mod
mod
mod
mod
3
3
3
3
3
(-7)
=
=
=
=
=
=
0
1
0
-1
-2
-1
En la operaciones aritméticas, debe asegurarse que el resultado de sumar, restar o
multiplicar dos valores, no produzca un resultado fuera de los rangos definidos por la
implementación para los diferentes tipos.
2.6.2 Operadores relacionales
Una RELACIÓN consiste de dos operandos separados por un operador relacional. Si
la relación es satisfecha, el resultado tendrá un valor booleano true ; si la relación no
se satisface, el resultado tendrá un valor false. Los operadores deben ser del mismo
tipo, aunque los valores de tipo real, integer y byte pueden combinarse como
operandos en las relaciones. A continuación se describen los operadores relacionales
utilizados en Pascal:
Símbolo
Significado
=
IGUAL que
<>
NO IGUAL que
<
MENOR que
>
MAYOR que
<=
MENOR o IGUAL que
>=
MAYOR o IGUAL que
10
Ejemplos:
Relación Resultado
20 = 11
false
15 < 20
true
PI > 3.14 true
'A' < 20 false
'A' = 65 true
2.6.3 Operadores lógicos
Al igual que las relaciones, en las operaciones con operadores lógicos se tienen
resultados cuyo valor de verdad toma uno de los valores booleanos true o false.
Los operadores lógicos en Pascal son :
NOT
Sintaxis : not operando
Descripción : Invierte el valor de verdad de operando.
Ejemplo :
Si bandera tiene un valor de verdad true, not bandera produce un resultado con valor
de verdad false.
AND
Sintaxis : operando.1 and operando.2
Descripción : Produce un resultado con valor de verdad true cuando ambos operandos
tienen valor de verdad true; en cualquier otro caso el resultado tendrá un valor de
verdad false.
OR
Sintaxis : operando.1 or operando.2
Descripción : Produce un resultado con valor de verdad false cuando ambos
operadores tienen valores de verdad false; en cualquier otro caso el resultado tendrá
un valor de verdad true.
XOR
Sintaxis : operando.1 xor operando.2
Descripción : Un operando debe tener valor de verdad true y el otro false para que el
resultado tenga valor de verdad true.
2.7 Expresiones
Las expresiones son secuencias de constantes y/o variables separadas por operadores
válidos.
11
Se puede construir una expresión válida por medio de :
1. Una sola constante o variable, la cual puede estar precedida por un signo + ó - .
2. Una secuencia de términos (constantes, variables, funciones) separados por
operadores.
Además debe considerarse que:
Toda variable utilizada en una expresión debe tener un valor almacenado para que la
expresión, al ser evaluada, dé como resultado un valor.
Cualquier constante o variable puede ser reemplazada por una llamada a una
función.
Como en las expresiones matemáticas, una expresión en Pascal se evalúa de acuerdo a
la precedencia de operadores. La siguiente tabla muestra la precedencia de los
operadores en Turbo Pascal:
Precedencia de operadores
5 - (Menos unario)
4 not
3 * / div mod and shl shr
2 + - or xor
1 = <> > < >= <=
Las reglas de evaluación para las expresiones son :
1. Si todos los operadores en una expresión tienen la misma precedencia, la
evaluación de las operaciones se realiza de izquierda a derecha.
2. Cuando los operadores sean de diferentes precedencias, se evalúan primero las
operaciones de más alta precedencia (en una base de izquierda a derecha ),
luego se evalúan las de precedencia siguiente, y así sucesivamente.
3. Las reglas 1) y 2) pueden ser anuladas por la inclusión de paréntesis en una
expresión.
Ejemplos :
1. 3 + 2*5
{*,+}
2. 4 + 10 =14
3. 20*4 div 5
4. {Igual prioridad de izquierda a derecha : *,div}
5. 80
div 5 = 16
6. 3 - 5 * (20+(6/2))
7. 3 - 5 * (20+(6/2)) = 3 - 5 * (20 + 3)
8. {paréntesis más interno}
9. = 3 - 5 * 23 {segundo paréntesis}
10. = 3 - 115 {Multiplicación}
11. = -112 {resta}
12.
2.8 Instrucciones
Aunque un programa en Pascal puede contar con una sola instrucción (también llamada
enunciado, sentencia o estatuto), normalmente incluye una cantidad considerable de ellas.
12
Uno de los tipos de instrucciones más importantes lo forman las instrucciones de
asignación; las cuales asignan a una variable (por medio del símbolo := ) , el resultado de la
evaluación de una expresión.
La sintaxis para las instrucciones de asignación es :
identificador := expresión ;
Al símbolo := le llamaremos, en lo sucesivo : "simbolo de asignación"
Los siguientes son ejemplos de instrucciones de asignacion :
numero
:= 100 ;
importe
:= precio * cantidad ;
hipotenusa := sqrt(sqr(cateto_op)+sqr(cateto_ad ));
Es posible construir una instrucción vacía escribiendo sólamente el punto y coma de una
instrucción.
Así podemos escribir :
valor := valor + 1;;
Lo que incluye las dos instrucciones :
valor := valor + 1;
y la instrucción vacía : ;
Bloques de instrucciones
En todo lugar donde sea válido utilizar una instrucción simple, es posible utilizar una
instrucción compuesta o bloque de instrucciones, el cual se forma agrupando varias
instrucciones simples por medio de los identificadores begin y end.
Por ejemplo:
begin
suma := 1000.0;
incr := 20.0;
total := suma + incr
{Obsérvese la ausencia de punto y coma
al final de la instrucción}
end.
No es necesario escribir el punto y coma antes de end ya que el punto y coma se usa para
separar instrucciones, no para terminarlas.
begin y end son delimitadores de bloque.
3.1 Procedimientos de entrada / salida
Desde el punto de vista del hardware, las instrucciones de entrada y salida le ayudan al
programa a comunicarse con un periférico de la computadora tal como una terminal,
una impresora o un disco.
Las instrucciones de entrada estándar, sirven para leer carácteres desde el teclado, y
las instrucciones de salida estándar despliegan carácteres en la pantalla.
En Pascal todas las operaciones de entrada/salida se realizan ejecutando unidades de
programa especiales denominados procedimientos de entrada/salida que forman parte
del compilador y sus nombres son identificadores estándar:
Procedimientos de entrada
Read
ReadLn
Procedimientos de salida
Write
WriteLn
13
3.2 Procedimientos Read y Readln
Los procedimientos predefinidos Read y ReadLn (contracción de Read Line),
constituyen la base para las instrucciones de entrada estándar.
Las instrucciones de entrada proporcionan datos durante la ejecución de un
programa. Las instrucciones para llamar a los procedimientos Read y ReadLn son de
la siguiente forma :
Read(lista_de_variables);
ReadLn(lista_de_variables);
donde :
lista_de_variables : es una lista de identificadores de variables separados por comas,
los datos que se pueden leer son : enteros, caracteres, o cadenas. No se puede leer un
boolean o un elemento de tipo enumerado.
Los datos estructurados , arrays, registros o conjuntos, no se pueden leer globalmente
y se suele recurrir a diseñar procedimientos específicos.
La acción de la instrucción es obtener, del teclado, tantos valores de datos como
elementos hay en lista_de_variables. Los datos deberán ser compatibles con los tipos
de las variables correspondientes en la lista.
Cada valor entero o real en el flujo de entrada puede ser representado como una
secuencia de caracteres en alguna de las formas permitidas para tales números, y
puede estar inmediatamente precedido por un signo más o un signo menos. Cada
valor entero o real puede ser precedido por cualquier cantidad de caracteres blancos o
fines de línea, pero no deberá haber blancos o fines de línea entre el signo y el número.
La diferencia entre las instrucciones Read y ReadLn consiste en que Read permite
que la siguiente instrucción continúe leyendo valores en la misma línea; mientras que,
con ReadLn la siguiente lectura se hará después de que se haya tecleado el carácter de
fin de línea.
Cuando se tienen datos de tipo char en una instrucción Read, los caracteres blancos y
los de fin de línea son considerados en el conteo de los elementos de las cadenas de
caracteres mientras no se complete el total especificado para cada una de ellas. Cada
fin de línea es tratado como un carácter, pero el valor asignado a la variable será un
carácter blanco.
Es aconsejable que cada cadena de caracteres se lea en una instrucción Read o
ReadLn por separado, para evitar el tener que ir contando hasta completar la
cantidad exacta de caracteres que forman la cadena ( o de lo contrario se tendrán
resultados sorpresivos y frustrantes al verificar los datos leídos ).
Ejemplo:
Var
nombre
:string[30] ;
edad
:integer;
estatura :real;
.
.
.
ReadLn(nombre);
ReadLn(edad);
ReadLn(estatura);
14
3.3 Procedimientos Write Y Writeln
La salida estándar se realiza en base a estos procedimientos predefinidos, y las
instrucciones para invocarlos toman las siguientes formas :
Write(lista_de_salida);
WriteLn(lista_de_salida);
donde :
lista_de_salida es una lista de variables, expresiones y/o constantes, cuyos valores van
a ser desplegados en la pantalla.
El procedimiento Write permite que la siguiente instrucción se realice en la misma
línea , mientras que WriteLn alimenta una nueva línea, antes de finalizar.
Por ejemplo, las instrucciones :
Write ('! HOLA ');
WriteLn('AMIGOS !');
producirán la salida :
! HOLA AMIGOS !
cursor en la siguiente línea.
Mientras que :
Write('TECLEE <CTRL> F PARA FINALIZAR ==> ');
desplegará :
TECLEE <CTRL> F PARA FINALIZAR ==>
CURSOR
Para producir un renglón en blanco, se debe escribir :
WriteLn ;
Un valor booleano desplegará cualquiera de las cadenas : TRUE o FALSE,
así :
Write('20 + 30 = ', 20 + 30 ,' ES ', 20 + 30 = 50);
producirá :
20 + 30 = 50 ES TRUE
dejando el cursor en la misma línea, al final de TRUE.
Cuando un valor de salida se escribe sin una especificación de longitud de campo, se
utilizará la especificación de campo por omisión.
La especificación de longitud de campo por omisión dependerá del tipo de valor de
salida y de la implementación de Pascal.
Así tenemos que, para todas las implementaciones :
1. La especificación de longitud de campo por omisión para los valores de tipo
char es 1
2. Si el valor a ser desplegado requiere menos del número de caracteres
especificado, se imprimirán tantos caracteres blancos como sean necesarios
para completar dicho número.
3. Si el valor a ser desplegado requiere un número de caracteres mayor que el
especificado, se usa la mínima especificación de longitud de campo que se
requiera para representar un valor de tipo real o entero, pero las cadenas serán
truncadas ajustándolas al campo especificado y desechará los caracteres en
exceso que se encuentren más a la derecha.
15
4. En el caso de valores de tipo real, se puede utilizar una especificación de
longitud de fracción.
Por omisión en Turbo Pascal, los valores de tipo real se desplegarán en formato de
punto flotante (también llamado exponencial), así :
1. Para el caso de valores positivos ( R >= 0.0 ), el formato es:
bbn.nnnnnnnnnnEsnn
b. Para valores negativos ( R < 0.0 ), el formato es :
b-n.nnnnnnnnnnEsnn
donde :
b = blanco
n = número ( 1-9 )
s = signo ( + ó - )
E = letra "E" para exponente
La especificación de campo mínima aceptada es :
• para R >= 0.0 , SIETE caracteres.
• para R < 0.0 , OCHO caracteres.
Ejemplos:
Sentencias
Resultados
WriteLn ('Hola Mundo');
Hola Mundo
WriteLn('22' + '20');
2220
WriteLn(pi);
3.1415926536E+00
WriteLn(3.0);
3.0000000000E+00
Debido a que Pascal alinea (justifica) las impresiones hacia la derecha del campo
correspondiente, cuando es necesario acomodar tabularmente los caracteres de
cadenas que no ocupan la totalidad de columnas especificadas.
Por ejemplo, suponiendo que nombre es un identificador de tipo string[20] (cadena
con formato de 20 caracteres), para que la impresión de todos los valores de nombre
empiece en la misma columna, podemos utilizar la instrucción :
WriteLn(numero,'.- ',nombre,
' ':20-length(nombre),calif:3);
y, al ejecutar el programa se tendrá algo parecido a :
1.- JUAN FLORES
90(Nótese la justificación de los nombres
2.- EGRID L. CASTRO
100hacia la izquierda y los números hacia
3.- RAMON RAMIREZ
99la derecha)
Formatos de salida
Formato 1 : WriteLn (ítem:anchura...);
Anchura: Expresión entera (literal, constante, variable o llamada a función) que
especifíca la anchura total del campo en que se escribe ítem.
16
Formato 2 : WriteLn (ítem:anchura:dígitos ...);
Dígitos: dígitos decimales de un número real
Anchura: Total de dígitos del número real contando parte entera, punto decimal y
dígitos decimales.
Ejemplos:
Valor:= 25.0776;
Sentencias
WriteLn (Valor);
WriteLn(Valor:2);
WriteLn(Valor:2:1);
WriteLn(Valor:2:4);
WriteLn(Valor:2:8);
WriteLn('Tec':1);
WriteLn('Tec':3);
WriteLn('Tec':5);
Resultados
2.5077600000E+01
2.5E+01
25.1
25.0776
25.07760000
Tec
Tec
_ _ Tec
Comentario
Notese el redondeo
Espacios vacios _
4.1 Secuencia
En este caso, las instrucciones se ejecutan una después de la otra sin omitir ninguna de
ellas.
La sintaxis para las instrucciones ejecutadas en secuencia es :
................
................
<instrucción.1> ;
<instrucción.2> ;
................
................
<instrucción.N> ;
................
................
4.2 Selección
La selección de alternativas en Pascal se realiza con alguna de las dos siguientes
formas :
1. La sentencia if
2. La sentencia case
4.2.1 IF-THEN-ELSE
Dado que una condición produce un valor verdadero o falso, se necesita una sentencia
de control que ejecute determinada sentencia si la condición es verdadera , y otra si es
falsa. En Pascal esta alternativa se realiza con la sentencia IF-THEN-ELSE. A
continuación se describe el diagrama de flujo y el formato de la sentencia.
17
Formatos de la sentencia IF:
if <condición>
if <condición> then
then
<instrucción_1>
<instrucción_1>
else
else
<instrucción_2>
<instrucción_2>
En este caso, primero se evalúa condición y si el resultado arroja un valor de
verdad(verdadero), se ejecuta instrucción_1 ; en caso contrario se ejecuta
instrucción_2.
La condición es una expresión Booleana que puede ser verdadera o falsa (true o false).
Una expresión Booleana se forma comparando valores de las expresiones utilizando
operadores de relación (relacionales) o comparación y los operadores lógicos vistos
anteriormente.
Ejemplos :
Omisión de cláusula else :
Program Edades;
Uses Crt;
Var
edad : integer ;
begin
WriteLn('Escribe tu edad : ');
ReadLn(edad);
if edad >= 18 then
WriteLn('!Eres Mayor de edad !');
WriteLn('Esta instrucción siempre se ejecuta');
ReadKey
end.
Nota: Antes de la palabra end no se debe anteponer un punto y coma
como se muestra en este ejemplo. El hacerlo generaria una sentencia
vacia (sentencia que no hace nada).
Utilización de cláusula else :
Program Edades;
Uses Crt;
18
Var
edad : integer ;
begin
WriteLn('Escribe tu edad : ') ;
ReadLn(edad) ;
if edad >= 18 then
WriteLn('!Eres Mayor de edad !')
else
WriteLn('!Eres Menor de edad !');
WriteLn('Esta instrucción siempre se ejecuta');
ReadKey
end.
Nota: Antes de la cláusula else no se antepone un punto y coma, si lo hubiese el
compilador producirá un mensaje de error, puesto que no existe ninguna sentencia en
Pascal que comience con else. La parte else es opcional, pero la ejecución siempre
continuará en otra instrucción.
En lugar de utilizar instrucciones simples, se pueden usar bloques de instrucciones,
como acontinuación se muestra :
Program Edades;
Uses Crt;
Var
edad : integer ;
begin
WriteLn('Escribe tu edad : ') ;
ReadLn(edad) ;
if edad >= 18 then
begin
WriteLn('!Eres Mayor de edad !');
WriteLn('!Ya puedes Votar!')
end
else
begin
WriteLn('!Eres Menor de edad !');
WriteLn('!Aún no puedes votar!')
end;
WriteLn('Esta instrucción siempre se ejecuta');
ReadKey
end.
Sentencia IF anidadas :
Program NumMayor;
Uses Crt;
Var
n1,n2,n3,mayor : integer ;
begin
WriteLn('Escribe tres numeros enteros : ');
ReadLn(n1,n2,n3);
if n1>n2 then
if n1>n3 then
mayor:=n1
else
mayor:=n3
else
if n2>n3 then
19
mayor:=n2
else
mayor:=n3;
WriteLn('El mayor es ',mayor);
ReadKey
end.
4.2.2 CASE-OF-ELSE
Esta forma es muy útil cuando se tiene que elegir entre más de dos opciones, por lo que
le llamaremos forma de selección múltiple.
La siguiente figura representa la selección múltiple.
Su formato es :
case <selector> of
constante.1 :
begin
<instrucciones>;
end;
constante.2 :
begin
<instrucciones> ;
end;
.....................
.....................
constante.N :
begin
<instrucciones> ;
end
else
begin
<instrucciones> ;
end;
end; { FIN DE CASE }
20
Dependiendo del valor que tenga la expresión selector, se ejecutarán las instrucciones
etiquetadas por constante .
Aquí también los bloques de instrucciones pueden ser reemplazados por instrucciones
simples.
Conviene tener presente que no debe escribirse punto y coma antes de la palabra else.
Reglas:
1. La expresión <selector> se evalúa y se compara con las constantes;las
constantes son listas de uno o más posibles valores de <selector> separados por
comas. Ejecutadas la(s) <instrucciones>, el control se pasa a la primera
instrucción a continuación de end (fin de case).
2. La cláusula else es opcional.
3. Si el valor de <selector> no está comprendido en ninguna lista de constantes y
no existe la cláusula else, no sucede nada y sigue el flujo del programa; si existe
la cláusula else se ejecutan la(s) <instrucciones> a continuación de la cláusula
else.
4. El selector debe ser un tipo ordinal ( integer, char, boolean o enumerado). Los
números reales no pueden ser utilizados ya que no son ordinales. Los valores
ordinales de los límites inferiores y superiores deben de estar dentro del rango
-32768 a 32767. Por consiguiente, los tipos string, longint y word no son válidos.
5. Todas las constantes case deben ser únicas y de un tipo ordinal compatible con
el tipo del selector.
6. Cada sentencia, excepto la última, deben ir seguidas del punto y coma.
Ejemplo:
Program Tecla;
{El siguiente programa lee un carácter del teclado
y despliega un mensaje en pantalla si es letra o
número o carácter especial}
Uses Crt;
Var
caracter : char;
begin
Write('Escribe un caracter : ');
caracter:=ReadKey;WriteLn;
case caracter of
'0'..'9'
: WriteLn('Es un número');
'a'..'z','A'..'Z' : WriteLn('Es una letra')
else
WriteLn('Es un caracter especial')
end;
ReadKey
end.
4.3 Iteración
Las formas de iteración sirven para ejecutar ciclos repetidamente, dependiendo de
que se cumplan ciertas condiciones. Una estructura de control que permite la
repetición de una serie determinada de sentencias se denomina bucle1 (lazo o ciclo).
21
El cuerpo del bucle contiene las sentencias que se repiten. Pascal proporciona tres
estructuras o sentencias de control para especificar la repetición:
1. While
2. Repeat
3. For
1
En inglés, loop.
4.3.1 WHILE-DO
La estructura repetitiva while(mientras) es aquella en la que el número de iteraciones
no se conoce por anticipado y el cuerpo del bucle se ejecuta repetidamente mientras
que una condición sea verdadera .
Su formato es :
while <condición> do
begin
<instrucciones>;
end;
y su diagrama :
Reglas de funcionamiento :
1. La condición se evalúa antes y después de cada ejecución del bucle. Si la
condición es verdadera, se ejecuta el bucle, y si es falsa, el control pasa a la
sentencia siguiente al bucle.
2. Si la condición se evalúa a falso cuando se ejecuta el bucle por primera vez, el
cuerpo del bucle no se ejecutará nunca.
3. Mientras la condición sea verdadera el bucle se ejecutará. Esto significa que el
bucle se ejecutará indefinidamente a menos que "algo" en el interior del bucle
modifique la condición haciendo que su valor pase a falso. Si la expresión
nunca cambia de valor, entonces el bucle no termina nunca y se denomina
bucle infinito lo cual no es deseable.
ejemplos:
Program Ej_While;
22
Uses Crt;
{El siguiente programa captura una cadena,
hasta que se presione la tecla Esc(escape),
cuyo ordinal es el #27.}
Const
Esc = #27;
Var
nombre : string[30];
tecla : char;
cont
: word;
begin
ClrScr;
cont:=1;
While (tecla<>Esc) do
begin
Write(cont,' Nombre : ');
ReadLn(nombre);
inc(cont);
tecla:=ReadKey
end
end.
4.3.2 REPEAT-UNTIL
La acción de repeat-until es repetir una serie de instrucciones hasta que se cumpla una
determinada condición .
Su formato es :
repeat
<instrucción.1> ;
<instrucción.2> ;
..................
..................
<instrucción.N> ;
until <condición>;
Aquí las palabras repeat y until sirven también como delimitadores de bloque.
Su diagrama de flujo es :
23
Reglas de funcionamiento:
1. La condición se evalúa al final del bucle, después de ejecutarse todas las
sentencias.
2. Si la condición es falsa, se vuelve a repetir el bucle y se ejecutan todas sus
instrucciones.
3. Si la condición es falsa, se sale del bucle y se ejecuta la siguiente instrucción a
until.
4. La sintaxis no requiere begin y end.
Analícense los diagramas de while-do y repeat-until, para comprender las diferencias
entre ambas formas.
Ejemplo:
Program Ej_Repeat;
Uses Crt;
{El siguiente programa captura una cadena,
hasta que se presione la tecla Esc(escape),
cuyo ordinal es el #27.}
Const
Esc = #27;
Var
nombre: string[30];
tecla : char;
cont : word;
begin
ClrScr;
cont:=1;
Repeat
Write(cont,' Nombre : ');
ReadLn(nombre);
inc(cont);
tecla:=ReadKey
Until (tecla=Esc)
end.
4.3.3 FOR-TO-DO
Cuando se sabe de antemano el número de veces que deberá ejecutarse un ciclo
determinado, ésta es la forma más conveniente.
El formato para for-to-do es :
for <contador>:=<expresión.1> to <expresión.2> do
begin
<instrucciones> ;
end;
Al ejecutarse la sentencia for la primera vez, a contador se le asigna un valor
inicial(expresion.1), y a continuación se ejecutan las intrucciones del interior del
bucle, enseguida se verifica si el valor final (expresión.2) es mayor que el valor inicial
(expresión.1); en caso de no ser así se incrementa contador en uno y se vuelven a
24
ejecutar las instrucciones, hasta que el contador sea mayor que el valor final, en cuyo
momento se termina el bucle.
Aquí, contador no puede ser de tipo real.
Ejemplo:
Program Ej_For;
Uses Crt;
{El siguiente programa despliega en pantalla el
numero de veces que se ejecuta las instrucciones
contenidas en el bucle for}
Var
Valor_final,contador : integer;
Begin
ClrScr;
Write('Escribe el número de iteraciones : ');
ReadLn(valor_final);
for contador:=1 to valor_final do
WriteLn('Iteración : ',contador);
ReadKey
end.
El contador se puede decrementar sustituyendo la palabra to por la palabra downto.
Formato:
for <contador>:=<expresión.1> downto <expresión.2> do
begin
<instrucciones> ;
end;
Ejemplo:
Program Ej_Downto;
Uses Crt;
{El siguiente programa despliega en pantalla el
numero de veces que se ejecuta las instrucciones
contenidas en el bucle for}
Var
Valor_final,contador : integer;
Begin
ClrScr;
Write('Escribe el número de iteraciones : ');
ReadLn(valor_final);
for contador:=valor_final downto 1 do
WriteLn('Iteración : ',contador);
ReadKey
end.
25