Programación en Pascal

Programación en Pascal
(Geometría Computacional, 3 er curso de I.T. Topografía)
Un programa en Pascal
El primer programa en Pascal que vamos a realizar es escribir en pantalla la frase "Hola
Mundo". Veremos como pasar un simple algoritmo en seudocódigo a un programa en Pascal.
algoritmo Dihola
inicio
ESCRIBIR "Hola Mundo"
fin
Tipos y estructuras de datos
program Dihola;
begin
writeln ('Hola Mundo');
end.
Un tipo de dato representa un conjunto de valores. Si una variable, constante o expresión son
de un tipo determinado, esto significa que sólo pueden tomar valores de ese conjunto.
En Pascal existen una serie de tipos básicos o primitivos proporcionados por el lenguaje:
boolean, char, integer y real. El usuario también puede definir sus propios tipos en una sección
TYPE.
Declaraciones de tipo
Sirven para declarar nuevos tipos, dándoles un nombre. Ej:
TYPE
VAR
TANIMAL = string [30];
animal : TANIMAL;
Sentencias condicionales
El flujo del programa no siempre es continuo sino que puede depender de ciertas condiciones,
hablamos de las sentencias condicionales. En seudocódigo estas sentencias se escribían con
SI-ENTONCES-SINO.
Supongamos que queremos calcular el punto de intersección entre dos rectas.
La ecuación de la primera recta es: y=m1x+c1 y la segunda y=m2x+c2. Podemos resolver el
problema mediante un simple sistema de dos ecuaciones con dos incognitas de la siguiente
manera:
1

sentencia
condicional
{y=m1x+c1; -> x=(c1-c2)/(m2-m1)
y=m2x+c2; -> y=m1x+c1
}
program Intersec_Rectas;
var x,y,m1,m2,c1,c2:real;
begin
writeln ('Datos de la primera recta');
write ('m1= '); readln(m1);
write ('c1= '); readln(c1);
writeln ('Datos de la segunda recta');
write ('m2= '); readln(m2);
write ('c2= '); readln(c2);
lectura de
datos
if abs(m2-m1) < 0.00001 (*rectas paralelas*)
then writeln ('Rectas Paralelas, no intersectan')
else begin
x:=(c1-c2)/(m2-m1);
y:=m1*x+c1;
writeln ('Punto de intersección: (',x:4:2,',',y:4:2,')');
end;
readln;
end.
comentarios
declaración de
variables
cálculos y
salida
formateada
Bucles
En muchas ocasiones los programas repiten una serie de sentencias un número determinado o
indeterminado de veces. Por ejemplo si deseamos leer por teclado los n vértices de un
polígono, bastaría con escribir una sentencia de lectura genérica, (por ejemplo que lea el
vértice número i) y repetirla un total de n veces. Si recordamos, en seudocódigo existen los
bucles PARA-REPETIR, MIENTRAS y REPETIR-HASTA. Veremos sus modificaciones a
Pascal.
Sentencia while (Mientras)
• Sintaxis:
while expresión_lógica do
sentencia1;
• sentencia1 puese ser una sentencia compuesta, en cuyo caso se escribiría:
while expresión_lógica do
begin
conjunto se sentencias;
end;
Sentencia for (Para-Repetir)
• Utilidad: escribir menos en ciclos controlados por una variable contador.
• Es menos genérica que while, existen ciclos, que por su condición de iteración, pueden
expresarse mediante una sentencia while, pero no mediante una for.
• Sintaxis:
for vcb := valor_inicial to/downto valor_final do
sentencia1;
• Características:
1) La variable de control del bucle (vcb) no debe cambiarse dentro del bucle. Sus valores
pueden utilizarse pero no deben cambiarse. Esto es, la vcb puede aparecer en una
expresión pero no debería aparecer en la parte izquierda de una sentencia de
asignación.
2

2) La vcb se incrementa o decrementa automáticamente en uno. Si necesita incrementar o
decrementar por otro valor debe usar while o repeat.
3) Si sentencia1 es compuesta debe ir encerrada entre un par begin-end.
Sentencia repeat (Repetir-Hasta)
• Sintaxis:
repeat
sentencia1;
until expresión_lógica;
• sentencia1 puede ser compuesta, en cuyo caso se utiliza la misma sintaxis. Existe una
diferencia fundamental con la sentencia while. Ahora el bucle se ejecuta al menos una vez
porque la condición está ubicada al final del bucle, y nada impide que pase el flujo del
programa la primera vez. Por otro lado, la condición de parada en un bucle suele ser justo la
contraria en un caso que en otro. Es lógico, uno es mientras ocurra una cosa y el otro es hasta
que esa cosa se cumpla.
Por ejemplo supongamos un algoritmo que lea las coordenadas de tres puntos y los mueva
tres puntos en la coordenada x y escriba el resultado en algún dispositivo de salida:
ALGORITMO lee_tres_vertices
ENTRADA: las coordenadas (x,y) de tres puntos
SALIDA: las coordenadas (x,y) de los tres puntos movidos 3 puntos hacia la
derecha.
VARIABLES: i:entera
x,y: real
INICIO
PARA i←1 HASTA 3 CON INCREMENTO +1
ESCRIBE "Abscisa del punto número ", i
LEER x
ESCRIBE "Ordenada del punto número ", i
LEER Y
ESCRIBE "El punto es (" x+3","y")"
FIN_PARA
FIN
El programa equivalente a este algoritmo se muestra a continuación. Como podemos apreciar
en un programa en Pascal es importantísimo no olvidar detalles de sintaxis. Por ejemplo cada
sentencia termina en punto y coma. De cualquier forma es inmediato apreciar los simples
cambios existentes.
program lee_tres_vertices;
var x,y:real;
i:integer;
begin
for i:=1 to 3 do
begin
write ('Abscisa del punto número ',i); readln(x);
write ('Ordenada del punto número ',i); readln(y);
writeln (' El punto es (',x+3,',',y,')');
end;
end;
Estructuras de datos: Arrays
Declaración de un tipo array: TYPE identificador = array[valor_inicial..valor_final] of tipo;
Declaración de una variable array:
VAR identificador : array[valor_inicial .. valor_final] of tipo;
3

VAR identificador : tipomatrizdefinidaenTYPE;
Si hay un único subrango tenemos un array unidimensional o vector. Si existen varios, un array
multidimensional.
Un elemento de un array puede ser utilizado en cualquier lugar donde se pueda poner una
variable, la sintaxis para acceder es:
identificador[expresión]
las expresiones deben coincidir con los valores permitidos del array correspondientes.
Aunque un array debe ser pasado por valor en un subprograma siempre que no vaya a ser
modificado, es preferible hacerlo por variable o referencia.
Ejemplos de arrays:
En nuestro caso hemos decidido definir tanto un punto como un polígono mediante arrays de la
siguiente forma:
TYPE
TipoPunto = array [0..1] of real;
TipoPoligono = array [0..MAX_PUNTOS_POLIGONO-1] of TipoPunto;
Pero recordar, esto sólo es la definición de los datos. Para poder utilizarlos se debe hacer
mediante la declaración de una varialble:
VAR
a,b,c:TipoPunto;
Ahora pueden operarse con a, b y c;
AreaTriangulo2 := (a[0]*b[1]-a[1]*b[0] +
b[0]*c[1]-b[1]*c[0] +
c[0]*a[1]-c[1]*a[0]) ;
Por supuesto también podemos hacer cosas como :
a[0]:=3;
b[1]:=5*a[1]-8;
write (a[1]);
readln( b[0]);
{etcétera}
La definición de TipoPolígono es algo más cojmpleja porque se trata de una matriz
bidimensional:
x y
Como ejemplo de uso, el siguiente código lee una serie de puntos de teclado para formar un
polígono:
TYPE x=0; y=1;
...
for i:=0 to n-1 do
begin
write('P[',i,',x]= '); read(p[i,x]);
write('P[',i,',y]='); readln(p[i,y]);
4

end;
Procedimientos y funciones
En el caso anterior hemos resuelto el problema realizando un programa. Sin embargo los
programas reales tienden a ser bastante más grandes. Para que se facilite la tarea de
programar sería adecuado dividir el problema en módulos, de modo que el programa no se
construyera con innumerables líneas de código sino con una serie de llamadas a
subalgoritmos, con las ventajas de la mejora de la claridad en los programas, la reutilización de
código y el mantenimiento de los programas.
Recordaremos que existen dos tipos de subalgoritmos, procedimientos y funciones. Para
decantarnos en utilizar un tipo u otro tendremos en cuenta la siguiente tabla.
Salida Simple Salida Estructurada
1 Salida Función Procedimiento
Más de una salida Procedimiento Procedimiento
Se considera un valor de salida a aquel que se obtiene dentro del subalgoritmo a partir de otros
de entrada. El tipo de dato de salida se considera simple cuando es un tipo definido por el
propio lenguaje, como los enteros, reales, lógicos, etc. Los tipos estructurados los suele crear
el usuario a partir de otros tipos de datos simples, por ejemplo un polígono, una lista de notas
de alumnos, etc. Existen otros datos definidos por el usuario que sin embargo pueden
considerarse simples, puestos que están compuestos de un número muy pequeño de
elementos, un punto, un número complejo, etc. Sin embargo nosotros lo consideraremos
estructurados para simplificar.
Por ejemplo la suma de tres valores enteros es una función porque independientemente del
número de elementos que entran sólo sale un valor y éste es simple
a
b
c
suma
Sin embargo un subalgoritmo que intercambie los contenidos de dos variables o que devuelva
un polígono, será un procedimiento. En el primer caso porque salen dos variables y en
segundo porque el tipo de dato de salida es estructurado.
a
b
Recordaremos brevemente los procedimientos y funciones en seudocódigo y sus equivalencias
en Pascal.
FUNCION Suma (a,b,c:entero):entero
ENTRADA; a,b,c
SALIDAD: a+b+c
VARIABLES:
INICIO
Suma ← a+b+c
FIN
b
a
FUNCTION Suma (a,b,c:integer):interger;
BEGIN
Suma := a+b+c;
END;
5

PROCEDIMIENTO Intercambio(var a,b:entero)
ENTRADA: a,b
SALIDA: a,b
VARIABLES: aux
INICIO
aux ← a
a ← b
b ← aux
FIN
PROCEDURE Intercambia(var a,b:integer);
VAR: aux
BEGIN
aux := a;
a := b;
b := aux;
END;
Como podemos observar el paso de seudocódigo a pascal es inmediato, sólo es necesario
recordar las reglas de sintáxis y algunos aspectos básicos.
• Los subalgoritmos terminan con (;) y no con (.)
• Los parámetros pasados por referencia se distinguen por llevar igualemente la partícula
var. Se pasan por valor en caso contrario.
• Nunca se realizan operaciones de entrada/salida en un procedimiento o función, toda la
información entra y sale como parámetro.
La pregunta ahora es determinar cuando un parámetro es pasado por valor o por referencia.
Para ello nos ayudará la siguiente tabla:
Para cada parámetro tipo de dato tipo de dato
simple
estructurado
de entrada por valor por referencia
de salida o de
entrada/salida
por referencia por referencia
Esto nos ayuda a saber porqué los parámetros a,b y c de la función está pasados por valor
(son de entrada y simples), mientras que los parámetros a y b del procedimiento son pasados
por referencia (son de entrada y salida al mismo tiempo).
Ahora estamos en disposición de modificar el programa que calcula el punto de intersección
entre dos rectas. Sería muy conveniente mantener un subalgoritmo con esta operación y
simplemente hacer una llamada siempre que nos interese, de este modo, basta con escribirlo
una vez y utilizarlo siempre que fuera necesario.
Atendiendo al programa, vemos que:
• El procedimiento queda después de la definición del programa, las constantes y variables y
antes del programa principal.
• Se consideran comentarios lo que quede entre llaves o entre los símbolos (*...*)
• La entrada/salida se realiza en el programa principal, no en el procedimiento, a no ser que
sea un procedimiento exclusivo de entrada o salidada.
• El procedimiento se invoca mediante una llamada. Los parámetros se corresponden por
posición, no por nombre. Así pendiente1 se corresponden con el parámetro m1, const1 con
c1, y así sucesivamente.
• Los parámetros x e y (coinciden en nombre por casualidad) son pasados por referencia
porque son de salida.
6

program interseccion;
const infinito=9.9e9;
var pendiente1, pendiente2, const1, const2,x,y:real;
procedure Intersec_Rectas (m1,c1,m2,c2:real; VAR x,y:real);
begin
if abs(m2-m1) < 0.00001 (*pendiente infinita*)
then begin
x:=infinito; y:=infinito;
end
else begin
x:=(c1-c2)/(m2-m1);
y:=m1*x+c1;
end;
end;
{ -------------------PROGRAMA PRINCIPAL------------------}
begin
writeln ('Datos de la primera recta');
write ('pendiente1= '); readln(pendiente1);
write ('const1= '); readln(const1);
writeln ('Datos de la segunda recta');
write ('pendiente2= '); readln(pendiente2);
write ('const2= '); readln(const2);
Intersec_Rectas(pendiente1,const1,pendiente2,const2, x,y);
if x=infinito
then writeln ('rectas paralelas')
else writeln ('intersección en (',x:4:2,',',y:4:2,')');
readln;
end.
Comentarios:
Como no puede tratarse computacionalmente el valor infinito, supongamos que tomamos un
valor constante cualquiera suficientemente alto. De esta forma trataremos el problema.
Ejemplo: Intersección de dos segmentos
Si quisieramos conocer si intersectan o no dos segmentos definidos por los sus puntos
extremos, tendremos que realizar los pasos siguientes:
1. conocer las ecuaciones de la recta que pasan que pasan por ambos segmentos
2. calcular el punto de intersección entre las dos rectas que contiene a ambos segmentos
3. ver si el punto de intersección de ambas rectas queda dentro de los segmentos.
Como vemos, el paso número 2 ya está implementado con el procedimiento Intersec_Rectas,
una de las ventajas que tiene la programación modular. También sería interesante realizar un
subalgoritmo que dado un segmento construya devuelva la ecuación de la recta que lo
contiene. Una vez construido dicho procedimiento se llamará dos veces, una para cada
segmento implicado.
Como hemos visto en teoría, es siempre más recomendable utilizar la aritmética de enteros
que la de reales, sin embargo, si lo que deseamos es conocer el punto de intersección de dos
rectas o segmentos no hay más remedio que emplear esta última.
program Interseccion_Segmentos;
CONST x=0; y=1;
infinito=9.9e9;
TYPE
TipoPunto = array [0..1] of real;
var
a,b,c,d:TipoPunto;
xx,yy:real;
7

{--------------------------------------------------------------------}
{(x,y) ser el punto de intersecci¢n de las rectas (m1,c1) y (m2,c2)
si son paralelas x e y son igual a infinito}
procedure Intersec_Rectas (m1,c1,m2,c2:real; VAR x,y:real);
begin
if (m1=infinito) and (m2=infinito) {rectas verticales paralelas}
then begin
x:=infinito; y:=infinito;
end
else if m1=infinito {la ecuación de la recta es x=c1}
then begin
x:=c1; y:=m2*x+c2;
end
else if m2=infinito
then begin
x:=c2; y:=m1*x+c1;
end
else if abs(m2-m1) < 0.00001 (*son rectas paralelas*)
then begin
x:=infinito; y:=infinito;
end
else begin
x:=(c1-c2)/(m2-m1);
y:=m1*x+c1;
end;
end;
{-------------------------------------------------------------------------}
{devuelve la ecuación de la recta (m,c) que forma un segmento dado por los
puntos (p1,p2); si la recta resultante es vertical, la pendiente m=infinito}
procedure SegmentoARecta (var p1,p2:TipoPunto; var m,c:real);
begin
if abs(p2[x]-p1[x]) < 0.00001 (*pendiente infinita *)
then begin
m:=infinito; {la ecuación de la recta es x=x1, hacemos x=c1}
c:=p1[x];
end
else begin
m:=(p2[y]-p1[y])/(p2[x]-p1[x]); {m=(y2-y1)/(x2-x1)}
c:=p1[y]-m*p1[x]; {c=y1-mx1}
end;
end;
{--------------------------------------------------------------------}
{indica el punto en que intersectan dos segmentos, en el caso de no hacerlo
xx e yy son igual a infinito}
procedure Intersec_Segmentos (var a,b,c,d:TipoPunto; var xx,yy:Real);
var
m1,m2,c1,c2:real;
begin
SegmentoARecta(a,b,m1,c1);
SegmentoARecta(c,d,m2,c2);
Intersec_Rectas (m1,c1,m2,c2,xx,yy);
{la x está en el rango del segmento (a,b)}
if not (((a[x]

writeln ('Datos del primer segmento');
writeln ('Datos del primer punto del segmento');
write ('x1= '); readln(a[x]);
write ('y1= '); readln(a[y]);
writeln ('Datos del segundo punto del segmento');
write ('x2= '); readln(b[x]);
write ('y2= '); readln(b[y]);
writeln ('Datos del segundo segmento');
writeln ('Datos del primer punto del segmento');
write ('x1= '); readln(c[x]);
write ('y1= '); readln(c[y]);
writeln ('Datos del segundo punto del segmento');
write ('x2= '); readln(d[x]);
write ('y2= '); readln(d[y]);
Intersec_Segmentos (a,b,c,d,xx,yy);
writeln ('intersecci¢n en el punto (',xx:4:2,',',yy:4:2,')');
readln;
end.
Registros
Los registros permiten mantener información de distinto tipo bajo el mismo concepto. Por
ejemplo, el registro alumno tendría el nombre y apellidos, el DNI, las asignaturas cursadas en
el curso actual, la calificaciones, etc. Todos estos datos son de distinta naturaleza (enteros,
cadenas de caracteres, etc), sin embargo, poseen la característica de pertenecer a la entidad
alumno. Por tanto, tiene sentido almacenarse bajo un mismo nombre alumno, y eso lo
conseguiremos definiendo un registro. Cada uno de los elementos definidos dentro de un
registro se llaman campos. Veamos de forma genérica la definición.
TYPE nombre_tipo = RECORD
identificadorCampo1 : tipo1;
...
identificadorCampoN : tipoN;
END;
Identificador de campo: es el nombre de una componente de un registro.
Por ejemplo, un punto, una recta, un número complejo, etc. son tipos de datos estructurados
porque están compuestos a su vez de otros tipos de datos. Ya hemos visto que
computacionalmente hablando, es mejor definir un punto mediante un array de dos posiciones.
Esto es posible hacerlo porque sus dos campos son del mismo tipo. Vamos a definir para
variar, el tipo de dato TipoRecta como un registro con dos campos, la pendiente y la constante
según indica la fórmula y=mx+c.
type
TipoRecta = RECORD
m,c:real;
end;
Cuando deseemos declarar una variable de tipo TipoRecta, lo haremos de la siguiente forma:
var
r:TipoRecta;
Para acceder a cada uno de los campos de un registro utilizaremos:
. . En el ejemplo anterior:
y=r.m*x+r.c
9

ya que tanto m como c son campos del registro r.
Las unidades en Pascal (UNIT)
Una unidad en Pascal no es más que una librería de funciones y procedimientos que el usuario
tiene definidos y que utiliza en cada programa cuando lo necesite. Por ejemplo, pensemos en
una librería de funciones matemáticas sobre manejo de matrices. Una vez que la operación de
suma de matrices esté definida y funcione perfectamente, bastará con incluir la unidad donde
está escrita y hacer la llamada a la función como si estuviera ubicada en el mismo fichero del
programa principal.
Una unidad se denomina unit y posee dos partes. La denominada INTERFACE donde se
definen los tipos de datos, las constantes necesarias y las cabeceras de los procedimientos y
funciones. Posteriormente aparece la palabra reservada IMPLEMENTATION, a partir de donde
se escriben todas las funciones y procedimientos completos cuyas cabeceras están en la zona
interface.
Vamos a escribir una unidad completa con una serie de procedimientos y funciones válidos en
nuestra asignatura de geometría computacional. Posee las funciones ya previamente vistas, la
de intersección de dos rectas y dos segmentos. Pero además aparecen otras que pueden ser
igualemente útiles:
UNIT GEOMLIB;
INTERFACE
CONST x=0; y=1;
infinito=9.9e9;
MAX_PUNTOS_POLIGONO = 100;
TYPE
TipoPunto = array [0..1] of real;
TipoPoligono = array [0..MAX_PUNTOS_POLIGONO-1] of TipoPunto;
TipoRecta = RECORD
m,c:real;
end;
TipoSegmento = array [0..1] of TipoPunto;
procedure Intersec_Rectas (r1,r2:TipoRecta; VAR x,y:real);
procedure SegmentoARecta (var p1,p2:TipoPunto; var r:TipoRecta);
procedure Intersec_Segmentos (var a,b,c,d:TipoPunto; var xx,yy:Real);
function AreaPoligono2 (var p:TipoPoligono; n:integer): real;
function AreaTriangulo2 (var a,b,c:TipoPunto) : real;
procedure LeerPoligonoTeclado (var p:TipoPoligono; var n:integer);
procedure LeerPoligonoFichero (var f:string; var p:TipoPoligono; var
n:integer);
procedure EscribirPoligonoFichero (var f:string; var p:TipoPoligono;
n:integer);
procedure EscribirPoligonoPantalla (var p:TipoPoligono; n:integer);
IMPLEMENTATION
{(x,y) ser el punto de intersección de las rectas (m1,c1) y (m2,c2)
si son paralelas x e y son igual a infinito}
procedure Intersec_Rectas (r1,r2:TipoRecta; VAR x,y:real);
begin
if (r1.m=infinito) and (r2.m=infinito) {rectas verticales paralelas}
then begin
x:=infinito; y:=infinito;
end
else if r1.m=infinito {la ecuación de la recta es x=c1}
then begin
x:=r1.c; y:=r2.m*x+r2.c;
end
else if r2.m=infinito
10

then begin
x:=r2.c; y:=r1.m*x+r1.c;
end
else if abs(r2.m-r1.m) < 0.00001 (*son rectas paralelas,
intersectan en el infinito*)
then begin
x:=infinito; y:=infinito;
end
else begin
x:=(r1.c-r2.c)/(r2.m-r1.m);
y:=r1.m*x+r1.c;
end;
end;
{devuelve la ecuación de la recta (m,c) que forma un segmento dado por los
puntos (p1,p2); si la recta resultante es vertical, la pendiente m=infinito}
procedure SegmentoARecta (var p1,p2:TipoPunto; var r:TipoRecta);
begin
if abs(p2[x]-p1[x]) < 0.00001 (*son rectas paralelas, intersectan en el
infinito*)
then begin
r.m:=infinito; {la ecuación de la recta es x=x1, pero lo dejamos en c}
r.c:=p1[x];
end
else begin
r.m:=(p2[y]-p1[y])/(p2[x]-p1[x]); {m=(y2-y1)/(x2-x1)}
r.c:=p1[y]-r.m*p1[x]; {c=y1-mx1}
end;
end;
procedure Intersec_Segmentos (var a,b,c,d:TipoPunto; var xx,yy:Real);
var
r1, r2: TipoRecta;
begin
SegmentoARecta(a,b,r1);
SegmentoARecta(c,d,r2);
Intersec_Rectas (r1,r2,xx,yy);
if not (((a[x]

AreaPoligono2 := suma;
end;
procedure LeerPoligonoTeclado (var p:TipoPoligono; var n:integer);
var i:integer;
begin
write ('Número de vértices del polígono: '); readln (n);
for i:=0 to n-1 do
begin
write('P[',i,',x]= '); read(p[i,x]);
write('P[',i,',y]='); readln(p[i,y]);
end;
end;
procedure EscribirPoligonoPantalla (var p:TipoPoligono; n:integer);
var i:integer;
begin
writeln ('Escribiremos el polígono de ',n,' v‚rtices');
for i:=0 to n-1 do
begin
write('P[',i,',x]= ',p[i,x]:4:2); write(' '); writeln('P[',i,',y]=
',p[i,y]:4:2);
end;
end;
procedure LeerPoligonoFichero (var f:string; var p:TipoPoligono; var
n:integer);
var i:integer;
fich: TEXT;
begin
assign (fich, f);
reset (fich);
readln (fich,n);
for i:=0 to n-1 do
read(fich,p[i,x]); readln(fich,p[i,y]);
close (fich);
end;
procedure EscribirPoligonoFichero (var f:string; var p:TipoPoligono;
n:integer);
var i:integer;
fich: TEXT;
begin
assign (fich, f);
rewrite (fich);
writeln (fich,n);
for i:=0 to n-1 do
write(fich,p[i,x]:4:2); write(fich,' ');writeln(fich,p[i,y]:4:2);
close (fich);
end;
end.
FICHEROS
Para terminar aclararemos dos de los procedimientos anteriormente implementados en la
unidad geomlib.pas, se trata de los procedimientos LeerPoligonoFichero y
EscribirPoligonoFichero que utilizan ficheros.
Si nos fijamos son muy similares a los de leer de teclado y escribir en pantalla, sin embargo, la
entrada y salida será ahora a través de fichero. Esto significa que los datos de entrada, los
puntos, estarán dispuestos en un fichero de texto (lo escribe el usuario con cualquier editor de
textos); la salida, los resultados, también serán llevados a un fichero.
12

Cuando el fichero sirve de entrada al programa, los datos deben estar en el fichero antes de la
ejecución del programa. Cuando el fichero es de salida, éste comienza estando vacío y termina
con los resultados del programa.
En nuestro ejemplo, el fichero de entrada y de salida posee la siguiente estructura:
n
x0 y0
x2 y2
x3 y3
....
xn-1 yn-1
Por ejemplo para un polígono de 4 vértices:
4
0 0
5 1
3 4
-3 2
Todo fichero debe tener un nombre datos.dat, poligono.dat, valores.txt, o cualquier otro que el
usuario decida. El nombre del fichero será en estos procedimientos el primer parámetro, la
cadena de caracteres o string. La operación assign asigna un nombre de fichero a una variable
fichero. Luego se puede abrir el fichero para leer (reset) o para escribir en él (rewrite). El resto
de operaciones, leer y escribir, son idénticas a las correspondientes para pantalla y teclado, sin
embargo, observamos que el primer parámetro es el nombre de la variable fichero. Hay que
tener especial cuidado con el formato del fichero. Para que no haya problemas utilizaremos la
terminación ln en las operaciones de write y read siempre que después haya que realizar un
salto de línea.
13