Manual de FreePascal (Parte 1) (página 3)

begin

for contador := 9 to 0 do

begin

Writeln('Hola'); // Esto no se ejecutará nunca

end;

end.

Como ejemplo final vamos a codificar un programa que
calcule la suma de potencias de forma manual y que
compruebe que el valor coincide
con el de la fórmula antes mostrada, r^0 +r^1 +r^2 …+
r^n-1 = (r^n -1)/ (r-1)

program Calcular_n_potencias;

var

r, n, i, suma : Integer;

begin

Writeln('R :');

Readln(r);

if r > 1 then

begin

Writeln('N :');

Readln(n);

Writeln('Resultado :');

Writeln((r**n-1) div (r-1));

// Método
mecánico

suma := 0;

for i := 0 to n-1 do

begin

suma := suma + r**i;

end;

Writeln('Resultado Mecánico :');

Writeln(suma);

end

else

begin

Writeln('R tiene que ser un valor mayor que 1');

end;

end.

Estructuras iterativas
condicionales

Las estructuras
iterativas condicionales basan su potencial en que el bucle
finaliza en función
del valor que toma una expresión booleana.

El bucle while..do

Este bucle no finaliza hasta que la condición que
ha permitido iniciarlo se vuelve falsa. La estructura de
while..do es la siguiente.

while expresionBooleana do Sentencia;

Veamos de ejemplo, el programa siguiente. Este programa
no finaliza hasta que el usuario no ha introducido un punto como
cadena de entrada.

var

cadena : string;

begin

cadena := ; // Una cadena
vacía

while cadena <> '.' do

begin

Write('Escriba algo (Un punto para terminar) :
');

Readln(cadena);

end;

Writeln('Fin del programa');

end.

El bucle while ejecuta la sentencia o sentencias hasta
que la condición del while se vuelve falsa. Hasta que no
se ha terminado un ciclo no se evalúa de nuevo la
condición, por tanto, aunque en medio del código
la condición ya sea falsa se seguirán ejecutando
sentencias hasta que al finalizar el bloque se tenga que repetir
el bucle. Entonces la evaluación
daría falso y el código seguiría al punto
siguiente de después de la sentencias.

En el ejemplo anterior, es una expresión booleana
que se vuelve falsa cuando cadena es igual a un punto. Cuando el
usuario introduce un punto, el bucle ya no se repite y el usuario
ve impreso en la pantalla "Fin del programa".

Si la condición del bucle ya fuera falsa al
iniciarse por primera vez la sentencia while, el bucle ya no
empezaría. El código siguiente, por ejemplo, no se
ejecutaría nunca :

while false do

begin

Writeln('Esto no se ejecutará nunca');

end;

El literal false denota una expresión booleana
falsa, por lo que el bucle no empezará nunca. Vemos el
caso siguiente :

while true do

begin

Writeln('Esto no terminará nunca…');

end;

En este caso la expresión es siempre cierta por
tanto el bucle sería infinito. De momento no sabemos como
salir de un bucle infinito. Es importante asegurase de que la
condición de salida se cumplirá alguna vez cuando
diseñemos el algoritmo.

El bucle repeat..until

El bucle repeat..until es más o menos el
contrario del bucle while..do. El bucle repeat..until, va
ejecutando sentencias hasta que la condición del bucle es
cierta. Otra diferencia se encuentra en e l hecho de que la
evaluación de la condición del bucle se hace al
final del bucle y no al principio de éste. Esto provoca
que el código se ejecute al menos una vez antes de salir
del bucle. Cuando la condición del bucle se cumple
entonces éste termina.

Algunos autores consideran el uso de repeat..until
inapropiado para una buena programación. En cualquier caso, lo cierto,
es que toda estructura de tipo repeat..until es convertible en
una estructura de tipo while..do. Veamos un ejemplo de
repeat..until en el siguiente programa :

var

nombre : string;

begin

repeat

Write('Escriba su nombre : ');

Readln(nombre);

until nombre<>;

end.

En este caso podemos observar que si el usuario pulsa Intro sin
haber introducido nada la variable nombre no es diferente de la
cadena vacía () y por tanto el bucle vuelve a
empezar.

Tal como hemos comentado anteriormente todos los
repeat..until son transformables a while..do. La versión
con while..do del programa anterior sería la
siguiente :

var

nombre : string;

begin

nombre := ;

while nombre = do

begin

Write('Escriba su nombre : ');

Readln(nombre);

end;

end.

En este caso hay que asegurarse de que el código
del bucle se ejecutará al menos una vez. Para esto,
realizamos la asignación nombre := para que la
condición del bucle while se cumpla al menos la primera
vez.

Las funciones break y
continue.

Algunas veces, necesitaremos alterar el flujo de
ejecución de bucles for, while o repeat. Para este
cometido disponemos de las funciones break y continue.

La función break hace que el programa salga del
bucle y la función continue hace que el bucle procese la
siguiente iteración sin terminar la iteración
actual. Estas funciones sólo se pueden emplea r dentro de
bucles for, while y repeat y no se pueden emplear fuera de estos
ámbitos.

for numero := 1 to 10 do

begin

Writeln('Hola #', numero);

Continue;

Writeln('Adiós');

end;

while true do

begin

…

if Salir then break;

end;

En el primer caso 'Adiós' no se verá
impreso nunca en la pantalla pues el bucle continúa con la
siguiente iteración aunque el bloque de sentencias no haya
terminado.

En el segundo ejemplo podemos salir del bucle infinito
mediante una condición de salida Salir, que es booleana, y
la función break.

Hay que tener en cuenta de que aunque es posible poner
sentencias después de un break o continue, si estos forman
parte de un mismo bloque de sentencias éstas ya no se
ejecutarán, tal como hemos visto en el ejemplo
anterior.

El selector case

Muchas veces necesitaremos modificar el comportamiento
de un programa en función a los valores
que toma una variable. Con lo que conocemos de Pascal, la
única forma de hacerlo sería mediante if. Pero si
la variable en cuestión puede tomar varios valores y
necesitamos diferentes comportamientos entonces la sentencia if
es algo limitada. Siempre podríamos imaginar el caso
siguiente :

var

diasemana : Integer;

begin

Write('Introduzca el día de la semana :
');

Readln(diasemana);

if diasemana > 7 then begin Writeln('Número no
válido') else

if diasemana = 1 then begin Writeln('Lunes')
else

if diasemana = 2 then begin Writeln('Martes')

…

if diasemana = 7 then begin

Writeln('Domingo');

end.

Como se adivinará, esta no es la mejor forma de
resolver este problema y termina por confundir al programador.
Para este tipo de casos Pascal posee la estructura selectora
case. Case sólo puede trabajar con ordinales (booleanos,
caracteres y enteros) pero es una forma muy elegante de
implementar lo que queremos. La estructura de case es algo
más enrevesada que las anteriores pero muy sencilla a la
larga :

Case expresionOrdinal of

Constante1 : Sentencia1;

Constante2 : Sentencia2;

…

ConstanteN : SentenciaN;

else SentenciaElse;

end;

Pasemos a ver un ejemplo de como se implementaría
el problema de los días de la semana con un
case :

var

diasemana : Integer;

begin

Write('Introduzca el día de la semana :
');

Readln(diasemana);

case diasemana of

1 : begin

Writeln('Lunes');

end;

2 : begin

Writeln('Martes');

end;

3 : begin

Writeln('Miércoles');

end;

4 : begin

Writeln('Jueves');

end;

5 : begin

Writeln('Viernes');

end;

6 : begin

Writeln('Sábado');

end;

7 : begin

Writeln('Domingo');

end;

else

begin

Writeln('Número no válido');

end;

end;

end.

La estructura introducida por else se ejecutará
si el valor de diasemana no tiene un selector, por ejemplo si
introducimos un 0 o un 8.

Hay que tener en cuenta varias cuestiones a la hora de
escribir un case. Los valores ordinales de cada selector tienen
que ser valores literales o valores constantes o una
expresión evaluable en tiempo de
compilación. Así, no se permiten las variables. Por
ejemplo :

var

Numero1, Numero2 : Integer;

const Numero4 = 4;

begin

Numero1 := 3;

case Numero2 of

Numero1 : begin

… // Esta construcción no es valida

end;

Numero4 : begin

… // Esta sí que lo es

end;

Numero4+1 : begin

… // Esta también lo es

end;

end;

end.

Numero4+1 es válido pues es una expresión
evaluable en tiempo de compilación, en nuestro caso tiene
el valor 5. Como se puede ver, la estructura else se puede omitir
sin ningún problema. En este caso si Numero2 tiene un
valor sin selector no se hace nada. En una estructura case es
posible especificar más de un tipo ordinal para cada
selector, separándolos entre comas, o bien especificando
un rango ordinal para el selector, separados con dos puntos
seguidos (..).

Case Numero of

0..10 : begin

// Esto se ejecutaría con numero del 0 al 10
incluidos

end;

11, 13 : begin

// Sólo los valores 11 y 13

end;

12 : begin // Sólo el valor 12

end;

14..80, 82..90 : begin

// Los valores de 14 a 80 y de 82 a 90

end;

81, 91..100 : begin

// El valor 81 y del 91 al 100

end;

end;

No importa el orden en el que escribamos los selectores.
Lo importante es que no se repitan, si fuera el caso el
compilador nos advertiría del fallo. Este es uno de los
motivos por los cuales los valores de los selectores tienen que
ser evaluables en tiempo de compilación y no de
ejecución.

En todos los ejemplos anteriores hemos empleado enteros
ya que son ordinales por excelencia pero también podemos
emplear booleanos y caracteres, que como sabemos también
son ordinales.

uses Crt;

var

caracter : Char;

begin

Write('Introduzca un carácter…');

caracter := Readkey;

case caracter of

'A'..'Z', 'a'..'z' : begin Writeln('Es una
letra');

end;

'0'..'9' : begin

Writeln('Es un número');

end;

else begin

Writeln('Otro tipo de carácter');

end;

end.

La función ReadKey es una función de la
unit Crt que nos devuelve el carácter de la tecla que el
usuario ha pulsado.

Tipos de datos
estructurados

Los datos estructurados

Hasta el momento hemos trabajado todo el rato con
tipos de datos
básicos de Pascal : booleanos, caracteres, string,
enteros y reales. La mayoría de aplicaciones de la vida
real no emplean datos de uno en uno sino que emplean grupos de datos.
Para resolver este problema Pascal incorpora un conjunto de datos
estructurados : array (vectores o
tablas), registros y
conjuntos.
También son tipos de datos estructurados las clases y los
objetos pero que debido a su complejidad trataremos en otros
capítulos. Finalmente, los archivos
también son un tipo especial de datos estructurados que
trataremos aparte.

Declaraciones de tipo

Antes hemos hablado de tipos fundamentales, pero
también es posible definir nuevos tipos de datos que
podremos utilizar en nuestras variables. Con la palabra reservada
type podemos declarar nuevos tipos que podremos emplear cuando
declaremos variables, de forma que estas variables sean del tipo
definido. Veamos un ejemplo asaz inútil pero que
servirá para introducirse a los tipos de datos. Los tipos
se tendrían que declarar antes de las variables pero
dentro de la declaración de tipo no es necesario seguir un
orden especial.

type

Numero = Integer;

NumeroNoIdentico = type Integer;

var

N1 : Numero; // Esto es lo mismo que un
Integer

N2 : NumeroNoIdentico; // Esto no es exactamente un
Integer aunque funciona igual

begin

…

end.

Como se puede ver, la declaración de un tipo es
semejante a la declaración de una constante. En el primer
caso Numero no es más que otro nombre para Integer
mientras que en el segundo caso NumeroNoIdentico es un
símbolo nuevo para el compilador. Este último caso
sirve para forzar al compilador que sea capaz de distinguir entre
un Integer y NumeroNoIdentico mientras que Numero es imposible de
distinguir de Integer. Es un caso algo especial y se emplea pocas
veces. Sólo veremos este ejemplo.

Enumeraciones

El tipo enumerado permite construir datos con
propiedades ordinales. La característica del tipo
enumerado es que sólo puede tomar los valores de su
enumeración.

type

TMedioTransporte : (Pie, Bicicleta, Moto, Coche,
Camion, Tren, Barco, Avion);

var

MedioTransporte : TMedioTransporte;

begin

MedioTransporte := Camion;

{ Sólo es posible asignar a identificadores de la
enumeración }

case MedioTransporte of // Es posible ya que un
enumerado es un tipo ordinal

Pie : begin

end;

Bicicleta : begin

end;

…

end;

end.

Por convención, los tipos de datos se suelen
declarar con una T seguido del nombre. De esta forma, los
identificadores que empiezan por T se entiende que son tipos y no
variables.

Las enumeraciones se declaran con paréntesis y un
seguido de identificadores separados por comas la utilidad
más importante de las enumeraciones se encuentra
especialmente en los conjuntos.

Conjuntos

Un conjunto es una colección de elementos de un
mismo tipo ordinal. De esta forma podemos añadir y
suprimir elementos de un conjunto, comprobar si un elemento
determinado pertenece al conjunto, etc.

Los conjuntos, además, permiten realizar operaciones
propias de conjuntos como la unión, con el operador suma,
o la intersección con la operación producto.

Los literales de conjuntos se expresan con
claudátores y los identificadores del conjunto. Si
deseamos más de uno hay que separarlos entre comas. El
literal de conjunto vacío es [].

Dado el conjunto siguiente de comida rápida y dos
variables de tipo de este conjunto definimos las operaciones
siguientes :

type

TJunkFood = (Pizza, Donut, Frankfurt, Burguer); //
Enumeración

TSetJunkFood = set of TJunkFood; // Conjunto de la
enumeración anterior

var

JunkFood, JunkFood2 : TSetJunkFood;

Para comprobar que un elemento pertenece
a un determinado conjunto hay que emplear el operador
in :

if Burguer in JunkFood then { este operador devuelve
cierto si en JunkFood hay el elemento Burguer }

begin

…

end;

Arrays o vectores

Llamamos array, vector o tabla a una estructura de
datos formada por un conjunto de variables del mismo tipo a
los cuales podemos acceder mediante uno o más
índices.

Se declaran de la forma siguiente :

array [minElemento..maxElemento] of tipoDato;

Por ejemplo, en el caso siguiente :

var

MiArray : array [1..9] of Integer;

Hemos declarado un array de 9 elementos, del 1 al 9, al
cual podemos acceder en un momento determinado del programa de la
forma siguiente :

begin

MiArray[2] := 100;

MiArray[3] := 23;

MiArray[4] := MiArray[2] + MiArray[3];

end;

Hay que ir con cuidado a la hora de leer un elemento del
array porque puede ser que nos estemos leyendo un punto que no
está en el array :

begin

MiArray[10] := 4;// Error !!!

end.

Para saber el elemento máximo y mínimo de
un array podemos emplear las funciones High y Low sobre el
array :

begin

Writeln(Low(MiArray)); // Devuelve 1

Writeln(High(MiArray)); // Devuelve 9

end.

Podemos definir arrays multidimensionales concatenando
dos rangos, por ejemplo, definiremos dos arrays de Integer. El
primero será bidimensional de 3×2 y el segundo
tridimensional de 4x3x2.

var

Bidimensional : array [1..3, 1..2] of
Integer;

Tridimensional : array [1..4, 1..3, 1..2] of
Integer;

Llegados aquí puede ser algo complicado entender
como es un array bidimensional o un array multidimensional. Es
fácil de interpretar. Cada elemento del array indicado por
el primer índice es otro array el cual podemos acceder a
sus elementos mediante la combinación del primer
índice y el segundo. Por ejemplo si hacemos
Bidimensional[2] estamos accediendo al segundo array de 2
elementos. Podemos acceder al primer elemento de este array de 2
elementos mediante la construcción
siguiente :

En este caso, el segundo índice sólo es
valido para los valores 1 y 2. Obsérvese que si hace Low y
High directamente a Bidimensional obtendrá 1 y 3,
respectivamente, mientras que si los aplica a Bidimensional[1]
obtendrá 1 y 2.

En el caso de que necesitemos asignar el contenido de un
array a otro sólo es posible cuando tengan el mismo tipo
estrictamente, hay que tener en cuenta que para el compilador
igual declaración no implica el mismo tipo. Véase
el programa siguiente :

program CopiarArray;

type

TMiArray : array [0..3] of Integer;

var

Array1 : TMiArray;

Array2 : TMiArray;

Array3 : array [0..3] of Integer;

Array4 : array [0..3] of Integer;

Array5, Array6 : array [0..3] of
Integer;

begin

Array1 := Array2; // Compatible ya que el tipo es
el mismo

Array3 := Array4; { Incompatible, tiene la misma
declaración pero diferente tipo. Esto da un error de
compilación }

Array5 := Array6; { Compatible, la
declaración obliga al compilador a entender que las dos
variables son idénticas }

end.

En los ejemplos hemos empleado rangos numéricos
con enteros positivos pero también es posible definir el
rango del array con números negativos como por ejemplo
[-2..2] o bien [-5..-3]. Es importante recordar que el rango
inicial no puede ser nunca superior al final. Por tanto un array
con rango [5..3] es incorrecto.

Los string y los arrays*

Es posible acceder a los caracteres de un string (tanto
si es ShortString, AnsiString o String[n]) mediante una sintaxis
de array. Los string están indexados en cero pero el
primer carácter se encuentra en la posición
1.

Cadena := 'Hola buenos días';

Writeln(Cadena[2]); {o}

Writeln(Cadena[14]); {í}

El nombre de caracteres de una cadena se puede obtener
con la función Length. El valor que devuelve es el nombre
de caracteres dinámicos, o sea el nombre de caracteres que
tiene la cadena. En cambio no
devuelve el máximo de caracteres que puede obtener la
cadena :

var

Cadena : string[40];

begin

Cadena := 'Hola buenos días';

Writeln(Length(Cadena)); // Devuelve 16

end.

Para saber la longitud máxima de la cadena hay
que emplear la función High. La función Low siempre
devuelve cero con una cadena. Obsérvese que los elementos
de una cadena son caracteres y por tanto podemos asignar a un
Char el elemento de una cadena.

Registros o records

Un registro es un
tipo de dato que contiene un conjunto de campos que no son
más que un conjunto de identificadores reunidos bajo un
mismo nombre.

La declaración de un registro es de la forma
siguiente :

record

Variable1 : Tipo1;.

VariableN : TipoN;

end;

Por ejemplo si queremos almacenar datos referentes a un
cliente podemos
emplear el registro siguiente :

type

TDatosCliente = record

Nombre : string;

Apellidos : string;

NumTelefono : Integer;

end;

Ahora sólo hay que declarar una variable de este
tipo y emplear sus campos :

var

DatosCliente : TDatosCliente;

begin

Writeln('Introduzca los datos del cliente');

Write('Nombre : ');
Readln(DatosCliente.Nombre);

Write('Apellidos : ');
Readln(DatosCliente.Apellidos);

Write('Nm. Teléfono : ');
Readln(DatosCliente.NumTelefono);

end.

Como se puede ver, empleamos el punto para distinguir
con qué variable queremos trabajar. Así
DatosCliente.Nombre representa el campo Nombre que como hemos
visto en la declaración es de tipo String. Téngase
en cuenta que DatosCliente es de tipo TDatosCliente pero que los
campos de éste tienen su propio tipo, tal como se ha
declarado en el registro.

Podemos indicar al compilador que los identificadores
que no conozca los busque en el record mediante la palabra
reservada with. Podíamos haber escrito el código
así :

var

DatosCliente : TDatosCliente;

begin

Writeln('Introduzca los datos del cliente');

with DatosCliente do

begin

Write('Nombre : '); Readln(Nombre); // Esto
sólo puede ser

DatosCliente.Nombre

Write('Apellidos : '); Readln(Apellidos); //
DatosCliente.Apellidos

Write('Nm. Teléfono : ');
Readln(NumTelefono); // DatosCliente.NumTelefono

end;

end.

A menos que sea necesario, no se recomienda el uso de
with ya que confunde al programador. La utilización del
punto permite cualificar el identificador y evita confusiones.
También podemos cualificar el identificador en
función de su unit. Por ejemplo la función ReadKey
de la unit Crt se puede indicar como Crt.ReadKey. En este caso,
el punto es útil para determinar exactamente qué
variable o qué función estamos llamando,
especialmente cuando haya más de una en diferentes
units.

[]

Registros variantes

Pascal permite definir lo que se llaman registros con
partes variantes. Un registro con una parte variante consta de un
campo que llamaremos selector. El valor de este selector es
útil para el programador pues le permite saber cual de los
campos posibles se están empleando. El compilador no tiene
en cuenta el valor de este campo selector ya que permite el
acceso a todos los campos declarados en la parte
variante.

type

TConjuntoDatos = ( TCaracter, TCadena, TNumero,
TCadenayCaracter );

TCombinado = record

case ConjuntoDatos : TConjuntoDatos of

TCaracter : ( Caracter : Char);

TCadena : ( Cadena : string );

TNumero : ( Numero : integer);

end;

var

Combinado : TCombinado;

Por ejemplo podemos realizar lo siguiente
Combinado.Caracter := 'z'; y después
Combinado.ConjuntoDatos := TCaracter; para indicar
qué campo hay que leer. Por ejemplo, si hacemos la
asignación Combinado.Numero := 65; y después
hacemos Writeln(Combinado.Caracter); se escribirá en la
pantalla la letra A.

Este comportamiento, en apariencia tan raro, es debido a
que un registro con la parte variante sita los distintos campos
en una misma región de memoria de forma
que podamos trabajar con un Byte y un Boolean o trabajar con un
Cardinal y leer sus dos Word, el
superior y el inferior.

El uso de registros variantes está restringido a
usos muy concretos. Esta es la forma Pascal de implementar un
unión de C/C++.

Archivos

[editar]

La necesidad de los archivos

Los programas que
hemos desarrollado hasta ahora se caracterizan por poseer una
memoria volátil que se concretaba con las variables. Al
finalizar el programa, el valor de las variables, sea útil
o no, se pierde sin que haya forma de recuperarlo en una
posterior ejecución del mismo programa. Los archivos
permiten resolver este problema ya que permiten el almacenaje de
datos en soportes no volátiles, como son los disquetes,
los discos duros y
su posterior acceso y modificación.

Cómo trabajar con archivos en
Pascal

Todos los sistemas de
archivos permiten asignar un nombre a los archivos de forma que
lo podamos identificar de forma única dentro de un
directorio, por ejemplo.

En Pascal, en vez de operar directamente con los nombres
de archivos trabajaremos con un alias que no es nada más
que una variable que ha sido asignada a un nombre de archivo. Las
posteriores operaciones que queramos llevar a cabo sobre este
archivo tomarán como parámetro este alias y todas
las operaciones se realizarán al archivo al cual se
refiere este alias.

Tipos de archivos en Pascal

Los tres tipos de archivos con los cuales podemos
trabajar en Pascal son : archivos con tipo, archivo sin tipo
y archivos de texto.

Los archivos con tipo almacenan un único tipo de
dato y permiten los que se llama acceso aleatorio, en
contraposición con el acceso secuencial que obliga a leer
(o al menos pasar) por todos los datos anteriores a uno concreto. De
esta forma podemos situarnos en cualquier parte del archivo de
forma rápida y leer o escribir datos.

Los archivos sin tipo no almacenan, a la contra,
ningún tipo en concreto. El programador es quien decide
qué datos se leen y en qué orden se leen. El acceso
a datos de este tipo de archivos es totalmente secuencial aunque
es más versátil pues se permiten almacenar datos de
casi cualquier tipo.

Los archivos de texto permiten la lectura y
escritura de
archivos ASCII y
la conversión automática a cadenas String[255], o
ShortString, que en realidad no son cadenas
ASCII. El acceso a
estos archivos también es secuencial.

[editar]

Trabajar con archivos de
texto

Empezaremos con archivos de texto pues son más
simples que otros tipos de archivo.

El tipo de archivo de texto se define con el tipo Text.
Por tanto declarar un alias de archivo de texto es tan simple
como la declaración siguiente :

var

ArchivoTexto : Text;

Para asignar a un alias un nombre de archivo emplearemos
la función Assign^2 <#sdfootnote2sym>

Assign(ArchivoTexto, 'PRUEBA.TXT');

En este ejemplo hemos asignado la variable ArchivoTexto
al archivo PRUEBA.TXT. Hay que tener en cuenta de que en Windows los
archivos no son sensibles a las mayúsculas,
podíamos haber puesto prueba.txt y sería el mismo
archivo. Téngase en cuenta que en algunos sistemas
operativos (como Linux) esto puede
no ser cierto.

Ahora habrá que abrir el archivo para realizar
alguna operación. Básicamente distinguimos entre
dos tipos de operaciones en un archivo : operaciones de
lectura,
leemos el contenido, y operaciones de escritura, donde escribimos
el contenido.

Pascal, además permite abrir el archivos con
diferentes finalidades y con diferentes funciones. Si lo queremos
abrir de sólo lectura, sin poder realizar
escritura, emplearemos la función Reset. Si lo que
queremos es reescribir de nuevo el archivo, sin posibilidad de
leer, emplearemos Rewrite. Además, los archivos de texto
permiten añadir datos al final del archivo si este se abre
con la orden Append, la cual es exclusiva de los archivos de
texto. Las tres funciones toman como único
parámetro el alias del archivo.

Reset(ArchivoTexto); // Sólo podemos
leer

// o bien

Rewrite(ArchivoTexto); // Borramos el archivo y
sólo podemos escribir

// o bien

Append(ArchivoTexto); // Sólo podemos escribir al
final del archivo

La diferencia fundamental entre Rewrite y Append se
encuentra en que Rewrite borra todos los datos del archivo si ya
existiese, de lo contrario lo crea, mientras que Append crea el
archivo si no lo existe, de lo contrario se sita al final del
archivo. Reset sólo funciona con archivos que ya existen,
en caso contrario genera un error.

El llamado cursor de lectura/escritura se refiere al
punto desde el cual empieza nuestra lectura o escritura. Al abrir
con Reset o Rewrite el cursor siempre se encuentra al principio
del archivo. En el caso de Append el cursor se encuentra en el
final del archivo de texto de forma que la única cosa que
podemos hacer es escribir del final del fichero en adelante, o
sea alargándolo. Al leer o escribir en u n archivo el
cursor de lectura/escritura adelanta hacia el fin del fichero
tantas posiciones como el tamaño del dato escrito o
leído. En caso de lectura, leer más allá del
fin del archivo es incorrecto mientras que escribir a partir del
fin del fichero hace que éste crezca.

Los únicos datos que podemos escribir en un
archivo de texto son efectivamente cadenas de texto. La
estructura de los archivos de texto ASCII es bien simple. Constan de
líneas formadas por una tira de caracteres que terminan
con los caracteres ASCII número 13 y 10 (fin de
línea y retorno de carro).

Para leer o escribir una línea desde un archivo
de texto emplearemos las funciones Readln o Writeln
respectivamente, pero teniendo en cuenta de que la primera
variable especificada como parámetro sea el alias del
archivo y el segundo parámetro sea un String. Sólo
en el caso de Writeln, el segundo parámetro puede ser un
literal de String mientras que Readln exige una variable String
como segundo parámetro.

Una vez hemos finalizado el trabajo con
el archivo conviene cerrarlo para asegurarse de que los datos
escritos se escriben correctamente y para indicar que ya no lo
vamos a emplear más. La función Close^3
<#sdfootnote3sym>, que toma como parámetro el alias
del archivo, se encarga de esta tarea.

Por ejemplo este programa escribe la fecha actual a un
archivo de texto :

program EscribirFecha;

uses Dos, SysUtils;

{ La unit DOS se necesita para GetDate la unit SysUtils
es necesaria para IntToStr }

const

DiasSemana : array[0..6] of string = ('Domingo',
'Lunes', 'Martes','Miércoles', 'Jueves', 'Viernes',
'Sábado');

var

ArchivoTexto : Text;

Anyo, Mes, Dia, DiaSemana : Integer;

begin

Assign(ArchivoTexto, 'FECHA.TXT');

Rewrite(ArchivoTexto); // Lo abrimos para escritura
borrándolo todo.

GetDate(Anyo, Mes, Dia, DiaSemana);

Writeln(ArchivoTexto, DiasSemana[DiaSemana]+'
'+IntToStr(Dia)+'/'+IntToStr(Mes)+'/'+IntToStr(Anyo));

Close(ArchivoTexto);

end.

Antes de seguir hay que hacer un comentario sobre el
array DiasSemana que hemos empleado. Es posible declarar
constantes con tipo de forma que se especifica de qué tipo
son y su valor inicial, ya que las constantes con tipos pueden
ser modificadas a lo largo del programa, aunque no suele ser muy
usual. En el caso de los arrays la sintaxis obliga a separar los
literales entre paréntesis. En caso de arrays
multidimensionales hay que emplear la misma sintaxis y separarla
entre comas :

const

ArrayBi : array [0..1, 0..1] of integer = ((-3, 4),
(2, 7));

El array que hemos declarado lo empleamos para saber el
nombre del día de la semana. Los valores del día
actual se obtienen gracias a la función GetDate a la cual
le pasaremos cuatro variables: día, mes año y una
para el día de la semana. Mediante el array DiasSemana
podemos obtener el nombre de los días de la semana ya que
GetDate devuelve un valor entre 0 y 6 dónde cero es
domingo y el seis es sábado. De esta forma el día
de la semana devuelto por GetDate coincide con los nombres del
array.

En el Writeln posterior hemos concatenado el día
de la semana, el día, el mes y el año, aunque por
ser Writeln podríamos haber separado estos elementos por
comas como si fueran más parámetros.

Vamos a leer el archivo que hemos creado con otro
programa que lea una línea del archivo y la imprima por la
pantalla.

program LeerFecha;

var

ArchivoTexto : Text;

CadenaFecha : string;

begin

Assign(ArchivoTexto, 'FECHA.TXT');

Reset(ArchivoTexto); // Lo abrimos para sólo
lectura

Readln(ArchivoTexto, CadenaFecha);

Writeln(CadenaFecha);

Close(CadenaFecha);

end.

Leemos una sola línea del archivo de texto y la
almacenamos en la variable CadenaFecha. Después la
mostramos en pantalla para comprobar que el dato leído es
el que realmente había en el archivo. Finalmente cerramos
el archivo.

El uso de Read en vez de Readln no es recomendable ya
que puede tener un comportamiento extraño. En cambio, si
lo que queremos es añadir una cadena sin saltar de
línea podemos emplear Write con la misma sintaxis
Writeln.

Hay otras funciones muy interesantes y útiles
para los archivos de texto, todas toman como parámetro el
alias del archivo de texto. Eof (End of file) devuelve true si el
cursor del archivo ha llegado al final de éste. Eoln (End
of line) devuelve true si el cursor se encuentra al final de una
línea. Esta última función se suele emplear
cuando se lee con Read carácter a carácter. La
función Eof permite parar la lectura del archivo ya que
leer más allá del archivo genera un error de
ejecución.

La función Flush descarga los buffers internos
del archivo de texto al disco de forma que el buffer, o memoria
intermedia, se vacía y se actualiza el archivo.

Las funciones SeekEof y SeekEoln son parecidas a las
respectivas Eof y Eoln pero sin tener en cuenta los caracteres en
blanco, de forma que si desde la posición del cursor del
archivo hasta el fina l del archivo o final de línea todo
son blancos SeekEof y SeekEoln, respectivamente, devuelven
true.

Truncate suprime todos los datos posteriores a la
posición actual del cursor del archivo.

Trabajar con archivos con
tipo

Para declarar que un archivo está formado por
datos de un sólo tipo hay que declararlo con las palabras
reservadas file of y el tipo del archivo :

type

TAgenda = record

Nombre, Apellidos : string;

NumTelefono : Integer;

end;

var

Agenda : file of TAgenda;

De esta forma podríamos implementar una agenda
muy rudimentaria con sólo tres campos (Nombre, Apellidos y
NumTelefono). Para crear, escribir y leer del archivo el
funcionamiento es idéntico a los archivos de texto con la
diferencia que hay que leer los datos en una variable del tipo
del archivo. También hay pequeñas diferencias
respecto a la apertura del archivo. Reset permite la lectura y la
escritura, en archivos de texto sólo permitía
lectura. Append no se puede emplear en archivos que no sean de
texto y Rewrite se comporta igual que con los archivos de
texto.

Vamos a ver un ejemplo de como podemos añadir
datos al archivo de agenda :

program EscribirArchivoTipo;

uses SysUtils; // Para la función
FileExists

const

NombreArchivo = 'AGENDA.DAT';

type

TAgenda = record

Nombre, Apellidos : string;

NumTelefono : Cardinal;

end;

var

Agenda : file of TAgenda;

DatoTemporal : TAgenda;

NumVeces, i : Integer;

begin

Assign(Agenda, NombreArchivo); // Asignamos el
archivo

if not FileExists(NombreArchivo) then

begin

Rewrite(Agenda); // Si no existe lo creamos

end

else

begin

Reset(Agenda); // Lo abrimos para lectura
escritura

end;

Write('Cuantas entradas desea añadir en la
agenda ? ');

Readln(NumVeces);

for i := 1 to NumVeces do

begin

Write('Introduzca el nombre : ');
Readln(DatoTemporal.Nombre);

Write('Introduzca los apellidos : ');
Readln(DatoTemporal.Apellidos);

Write('Introduzca el teléfono : ');
Readln(DadaTemporal.NumTelefono);

Write(Agenda, DatoTemporal); // Escribimos DatoTemporal
al archivo

Writeln; // Equivale a Writeln(); hace un salto de
línea

end;

Close(Agenda); // Cerramos la agenda

end.

Observamos en el código de que cuando el archivo
no existe entonces lo creamos automáticamente con la
función Rewrite. En caso contrario lo podemos abrir con
Reset. La función FileExists permite saber si el archivo
especificado existe ya que devuelve true en caso
afirmativo.

Pedimos al usuario que nos diga cuantas fichas desea
introducir y solicitamos que introduzca los datos. Después
almacenamos la variable DatoTemporal al archivo agenda con una
llamada a Write. No es posible emplear Writeln en archivos con
tipo. Cuando llamamos a Writeln sin parámetros en pantalla
se ve un salto de línea. Lo empleamos para distinguir los
diferentes registros que vamos introduciendo al
archivo.

Un archivo con tipo se entiende que está formado
por un numero determinado de datos del tipo del archivo, en
nuestro caso son registros de tipo TAgenda.

Para saber el número de registros que tiene
nuestro archivo emplearemos la función FileSize como
parámetro el alias del archivo. El resultado que nos
devuelve esta función es el nombre de registros del
archivo. Emplearemos esta función en el ejemplo siguiente
de lectura del archivo.

program LeerArchivoTipo;

uses SysUtils; // Para la función
FileExists

const

NombreArchivo = 'AGENDA.DAT';

type

TAgenda = record

Nombre, Apellidos : Shortstring;

NumTelefono : Cardinal;

end;

var

Agenda : file of TAgenda;

DatoTemporal : TAgenda;

i : Integer;

begin

Assign(Agenda, NombreArchivo); // Asignamos el
archivo

if not FileExists(NombreArchivo) then

begin

Writeln('El archivo ', NombreArchivo, ' no
existe.');

end

else

begin

Reset(Agenda); // Lo abrimos para lectura y
escritura

for i := 1 to FileSize(Agenda) do

begin

Read(Agenda, DatoTemporal);

Writeln('Nom : ', DatoTemporal.Nombre);

Writeln('Cognoms : ',
DatoTemporal.Apellidos);

Writeln('Teléfon : ',
DatoTemporal.NumTelefono);

Writeln;

end;

Close(Agenda);

end;

end.

En este caso, vamos leyendo los registros guardando los
valores a la variable temporal DatoTemporal. Después
escribimos esta información en la pantalla. Siempre que el
archivo exista, claro.

Tal como hemos comentado antes, los archivos con tipo
son archivos de acceso aleatorio y podemos escribir y leer datos
en el orden que queramos. Para poder acceder a una
posición determinada del archivo hay que emplear la
función Seek.

Esta función necesita dos
parámetros : el primero es el alias del archivo y el
segundo el número del elemento al cual queremos acceder.
Hay que tener en cuenta que el primer elemento es el cero y el
último es el valor de FileSize menos 1.

Por ejemplo, para leer el archivo en sentido inverso al
habitual, puesto que Read adelanta el cursor de lectura
automáticamente que vamos leyendo, necesitaremos la
función Seek.

program LeerAlReves;

// Aquí van las declaraciones del ejemplo
anterior : TAgenda, Agenda,

begin

Assign(Agenda, NombreArchivo); // Asignamos el
archivo

if not FileExists(NombreArchivo) then

begin

Writeln('El archivo', NombreArchivo, ' no
existe.');

end

else

begin

Reset(Agenda); // Lo abrimos para lectura y
escritura

for i := FileSize(Agenda)-1 *downto* 0
do

begin

Seek(Agenda, i); // Nos movemos al punto especificado
por i

Read(Agenda, DatoTemporal);

Writeln('Nombre : ',
DatoTemporal.Nombre);

Writeln('Apellidos : ',
DatoTemporal.Apellidos);

Writeln('Teléfono : ',
DatoTemporal.NumTelefono);

Writeln;

end;

Close(Agenda);

end;

end.

Si en algún momento queremos saber la
posición del cursor del archivo tenemos que emplear la
función FilePos y el alias del archivo. Esta
función devuelve un entero que, a diferencia de Seek,
puede estar comprendido entre 1 y el valor de
FileSize.

Archivos sin tipo

Los archivos sin tipo no tienen ningún formato
especial y por tanto podemos leer de ellos los datos que
queramos. Hay que tener en cuenta, que en ninguno de los tres
tipos de archivos se hace ningún tipo de
comprobación de los datos que se escriben o se leen. De
forma que si abrimos un archivo de un tipo determinado, por
ejemplo de tipo Longint, con un alias de tipo
Byte los datos que
leamos corresponderán a los bytes del Longint.

Las funciones Write y Read no se pueden emplear con
archivos sin tipo. Es por este motivo que tenemos que emplear las
funciones BlockWrite y BlockRead. Estas funciones leen o escriben
un numero n, o menos en caso de lectura, de bloques de
tamaño b, en bytes, que conviene especificar en las
funciones Rewrite y Reset. Si no especificamos el valor del
bloque a Rewrite o Reset por defecto vale 128 bytes.

Como ejemplo, implementaremos dos programas. En el
primero escribiremos en un archivo un string de 35 caracteres y
después un entero. En el segundo nos limitaremos a recoger
estos datos y a escribirlos en pantalla.

program EscribirArchivoSinTipo;

const

NombreArchivo = 'DATOS.DAT';

var

Datos : file;

Nombre : string[35];

Edad : Integer;

begin

Assign(Datos, NombreArchivo); // Asignamos el
archivo

Rewrite(Datos, 1); { Especificamos 1 byte como
tamaño del bloque por comodidad }

Write('Introduzca un nombre : ');
Readln(Nombre);

Write('Introduzca una edad : ');
Readln(Edad);

BlockWrite(Datos, Nombre, SizeOf(Nombre));

BlockWrite(Datos, Edad, SizeOf(Edad));

Close(Datos);

end.

Obsérvese, que especificamos el tamaño del
registro en 1 ya que después necesitaremos especificar el
tamaño de los datos que vamos a escribir. Para esto
emplearemos la función SizeOf que toma como
parámetro cualquier tipo de variable y devuelve su
tamaño en bytes. Por tanto Edad tiene un tamaño de
2 bytes y el tamaño de Nombre es de 36 bytes. Este es el
valor que se pasa como tercer parámetro y que entiende que
queremos copiar 36 bloques de un byte y después 2 bloques
de un byte. Si no hubiéramos especificado el tamaño
del bloque, se tomaría por defecto 128 bytes de forma que
al escribir el entero coparíamos 2 bloques de 128 bytes (o
sea 256 bytes). La función BlockWrite admite cualquier
tipo de variable como segundo parámetro.

Para leer, la función BlockRead funciona de forma
parecida a BlockWrite. En este caso el segundo parámetro
también puede ser de cualquier tipo, pero no una
constante.

program LeerArchivoSinTipo;

const

NombreArchivo = 'DATOS.DAT';

var

Datos : file;

Nombre : string[35];

Edad : Integer;

begin

Assign(Datos, NombreArchivo); // Asignamos el
archivo

Reset(Datos, 1); { Especificamos el tamaño del
bloque de 1 byte por comodidad }

BlockRead(Datos, Nombre, SizeOf(Nombre));

BlockRead(Datos, Edad, SizeOf(Edad));

Writeln(Nombre, ' tiene ', Edad, '
años');

Close(Datos);

end.

Otras funciones que podemos emplear para los archivos
sin tipo incluyen : FileSize, FilePos y Seek. Todas tres
funciones trabajan con el valor del bloque, el tamaño del
cual hemos especificado en Reset o Rewrite. También
podemos emplear Eof para detectar el fin del archivo.

Gestión de archivos

A diferencia de crear archivos, escribir o leer datos
también podemos realizar otras operaciones como pueden ser
eliminar un archivo o cambiarle el nombre.

Eliminar un archivo

Eliminar un archivo es tan simple como emplear la
función Erase y el alias del archivo. Hay que tener en
cuenta de que el archivo tiene que estar cerrado para evitar un
error en tiempo de ejecución. Además, cerrar un
archivo ya cerrado da error de ejecución. Para asegurarse
de que un archivo está cerrado podemos abrirlo con Reset y
cerrarlo con Close. Nuevas llamadas a Reset con un archivo ya
abierto no dan error, simplemente sitúan el cursor del
archivo al inicio. Una vez está cerrado ya podemos llamar
a Erase.

Renombrar un archivo

La función Rename permite renombrar un archivo.
Hay que tener en cuenta de que el archivo también tiene
que estar cerrado.

var

archivo : file;

begin

Assign(archivo, 'NombreViejo.dat'); // Suponemos que
existe

Rename(archivo, 'NombreNuevo.dat');

end.

Capturar errores de archivos con
IOResult

Hasta ahora hemos operado con archivos suponiendo que el
archivo existía o bien no había ningún error
durante las operaciones de lectura o de escritura.

Existe una forma muy sencilla de capturar los errores de
las operaciones con archivos mediante la variable IOResult y la
directiva de compilador {$I}

Una directiva de compilador es un comentario que justo
después de la llave hay el símbolo de dólar
$ y una o más letras. Las directivas modifican el
comportamiento del compilador en tiempo de compilación.
Después de una directiva el compilador puede modificar su
comportamiento de muchas formas. Muchas veces van asociadas a la
llamada compilación condicional, que veremos más
adelante, en otras se refiere a como se estructuran los datos,
etc.

En el caso de $I es una directiva de
activación/desactivación. Por defecto $I
está activada con lo cual los errores de entrada/salida de
archivos provocan un error de ejecución (runtime error).
Los errores runtime son irrecuperables, o sea, provocan la
finalización inmediata y anormal del programa. Muy a
menudo, el error puede ser debido al usuario con lo cual hay que
procurar de no genera un error runtime ya que inmediatamente
terminaría el programa. Podemos evitar estos errores con
la desactivación de la directiva $I. Para activar una
directiva de activación/desactivación (llamada
switch) tenemos
que incluir la siguiente directiva en medio del
código.

{$I+}

Para desactivarla :

{$I-}

Es importante reactivar la directiva $I cuando ya no sea
necesaria. Cuando está desactivada podemos acceder a la
variable IOResult. Esta variable tiene el valor cero si la
operación con archivos se ha llevado a cabo con éxito.
En caso contrario, almacenará un valor distinto de cero.
Vamos a aplicar esta técnica al programa de cambio de
nombre :

var

archivo : file;

begin

Assign(archivo, 'NombreViejo.dat'); // Assign no da
nunca error

{$I-} // Desactivamos la directiva $I

Rename(archivo, 'NombreNuevo.dat');

if IOResult <> 0 then

begin Writeln('Este archivo no existe o no se ha podido
renombrar');

end;

{$I+} // Importante reactivar la directiva cuando ya no
sea necesaria

end.

Así de simple es capturar los errores de
lectura/escritura. Suele ser habitual, por ejemplo, emplearlo en
la función Reset ya que si el archivo no existe se produce
un error que se notifica en IOResult.

Es posible referirse a la directiva $I con su nombre
largo $IOCHECKS. Además FreePascal permite la
activación y desactivación mediante on y OFF en los
nombres largos de directivas.

{$I+} // Activar

{$I-} // Desactivar

{$IOCHECKS on} // Activar, cuidado el espacio

{$IOCHECKS OFF} // Desactivar

{$IOCHECKS +} // Activar, cuidado el espacio

{$IOCHECKS -} // Desactivar

Hay más directivas de compilador que veremos
más adelante.

Funciones y
procedimientos

Diseño descendiente

Se llama diseño
descendiente el método de diseño de algoritmos que
se basa en la filosofía de "divide y vencerás".
Donde el programa se divide en partes más pequeñas
que se van desarrollando con una cierta independencia
respecto a las otras partes del programa.

De esta forma podemos definir una especie de
subprogramas o subrutinas para ser ejecutada diversas veces
dentro del programa en si. Los problemas
pueden ser descompuestos en otros problemas más
pequeños pero también más fáciles de
resolver. Esto permite, también, aprovechar mejor el
código y permite modificarlo más cómodamente
pues no habrá que modificar todo el programa, sólo
el código del subprograma.

En Pascal el diseño descendiente se lleva a cabo
con dos elementos muy importantes : las funciones y los
procedimientos.

Funciones vs Procedimientos

La diferencia más importante entre un procedimiento y
una función es el hecho de que una función es una
expresión y como a tal se puede emplear dentro de otras
expresiones. Un procedimiento, en cambio, representa una
instrucción y no puede ser empleada dentro de un contexto
de expresión.

Las funciones devuelven siempre un valor de un tipo
determinado. Ya hemos visto el caso de la función
FileExists de la unit SysUtils. Esta función devuelve un
tipo booleano por lo que podíamos incluirla dentro de una
expresión booleana como esta :

if not FileExists(NombreArchivo) then

…

La función Write es, por ejemplo, un
procedimiento y por tanto no es sintácticamente legal
incluirla dentro de una expresión.

Aun así, la sintaxis de Pascal se ha relajado a
lo largo del tiempo y es posible emplear una función como
si de un procedimiento se tratara. En este caso se pierde el
valor que devuelve la función aunque se ejecuta
igualmente.

Por ejemplo, si queremos que un programa se pare hasta
que el usuario pulse una tecla podemos emplear la función
Readkey de la forma siguiente :

Readkey; // El programa se parará hasta que el
usuario pulse una tecla

El carácter que devuelve ReadKey, la tecla que ha
pulsado el usuario, se perderá a menos que incluyamos
ReadKey en una expresión.

Contexto de las funciones y los
procedimientos

Las funciones y los procedimientos tienen que declararse
siempre antes del módulo principal del programa. Si una
función, o procedimiento, se emplea en otra ésta
tendrá que estar declarada antes o bien encontrarse en una
unit de la clausula uses.

Funciones

Tanto las funciones como los procedimientos tienen que
tener un nombre que las identifique, que seguirá las
reglas de los identificadores de Pascal, y opcionalmente pueden
tener un conjunto de parámetros que modifique de alguna
forma el comportamiento de la función.

La declaración de una función sigue el
modelo
siguiente :

function NombreFuncion ( listaParametros ) :
tipoRetorno;

NombreFuncion es el identificador de la función y
es el nombre que emplearemos para llamarla. ListaParametros
representa el conjunto de parámetros que se pueden pasar a
la función. Para declarar más de un
parámetro los tenemos que separar entre puntos y comas y
teniendo en cuenta de que el último parámetro no
lleva nunca punto y coma. Estos parámetros reciben el
nombre de parámetros formales y es importante
distinguirlos de parámetros reales que representan los
parámetros con los que se ha llamado la función.
Finalmente, tipoRetorno representa el tipo de datos que devuelve
la función.

Vamos a definir una función muy sencilla max que
devuelva el valor del máximo de dos parámetros
enteros a y b.

function max(a : integer; b : integer) :
integer;

{ Podíamos haber escrito los parámetros
así : (a, b : integer) }

begin

if a >= b then

begin

max := a

end

else

begin

max := b;

end;

end;

Obsérvese con detenimiento el código de la
función max. Para empezar, las sentencias van entre un
begin y un end con punto y coma ya que no es el bloque principal
del programa. Nótese también que para especificar
el valor que tiene que devolver la función hacemos una
asignación al identificador de la función,
max.

Como ejemplo de empleo de esta
función, haremos un programa que pida dos enteros al
usuario e indique cual de los dos es máximo.

program Funciones;

var

n, m : integer;

function max(a, b : integer) :
integer;

begin

if a >= b then

begin

max := a

end

else

begin

max := b;

end;

end;

begin

Write('Introduzca el valor entero M : ');
readln(m);

Write('Introduzca el valor entero N : ');
readln(n);

Writeln('El máximo entre ', M, ' y ', N, ' es ',
max(m, n));

end.

Como se puede ver en la última línea del
código, a diferencia de la declaración y tal como
hemos llamado hasta ahora las funciones o procedimientos con
más de un parámetro, hay que separar los distintos
parámetros entre comas. Hay que tener en cuenta que los
parámetros reales m y n del ejemplo no tienen nada que ver
con los parámetros formales de max (a y b). De hecho los
parámetros formales sirven sólo para implementar la
función e indicar el orden de estos. No hay que decir que
en vez de una variable podemos emplear un literal.

Vamos a definir una nueva función min a partir de
max.

function min(a, b : integer);

begin

min := -max(-a, -b);

end;

Esta implementación se basa en que los
números negativos se ordenan al revés que los
positivos, por lo que cambiando dos veces el signo es
suficiente.

Es importante siempre incluir una asignación al
valor de retorno de la función ya que en caso contrario el
valor de la función podría quedar indeterminado.
Una forma segura es incluir la asignación al final de la
función, si es posible, o asegurarse de que en todos los
casos posibles de salida hay al menos una asignación de
este tipo.

Procedimientos

Los procedimientos se declaran de forma parecida a las
funciones pero sin especificar el tipo de salida ya que no
tienen. Por ejemplo el procedimiento Creditos escribiría
unos créditos en la pantalla :

procedure Creditos;

begin

Writeln('(C) Manual de FreePascal 1.00'

Writeln('Roger Ferrer Ibáñez –
2001');

end;

En vez de emplear la palabra reservada function
emplearemos procedure. Tampoco hay que realizar ninguna
asignación al identificador del procedimiento pues los
procedimientos no devuelven nada. Tanto en funciones como en
procedimientos, en caso de que no tengamos parámetros no
habrá que poner los paréntesis. En el caso de las
funciones antes del punto y coma tendrá que ir el tipo de
retorno.

Como ejemplo tenemos la definición de ReadKey
es :

function Readkey : Char;

En el momento de llamar a una función o
procedimiento sin parámetros podemos omitir los
paréntesis de parámetros o, si los queremos
escribir, sin nada en medio (sin contar los caracteres en
blanco).

Creditos; // Ambas llamadas son correctas

Creditos(); // Esta llamada tiene una sintaxis
más parecida a C

Tipos de parámetros

Hasta ahora hemos visto que una función puede
devolver un valor y que por tanto la podemos incluir dentro de
una expresión. Muchas veces nos puede interesar
especificar parámetros que impliquen un cambio en estos
parámetros y esto no es posible de implementar en una
simple función.

Supongamos un procedimientos en el cual pasando dos
parámetros de tipo entero queremos que se intercambien los
valores. Una forma de hacerlo es mediante sumas y restas.
Nosotros implementaremos un caso más general mediante el
uso de una tercera variable temporal.

procedure Intercambiar(a, b : integer);

var

temporal : integer;

begin

temporal := b;

b := a;

a := temporal;

end;

Si escribimos un programa para verificar si el
procedimiento funciona, nos daremos cuenta de que los
parámetros no se han modificado después de la
llamada. O sea, no ha habido intercambio.

a := 10;

b := 24;

Intercambiar(a, b);

// Ahora a aún vale 10 y b aún vale
24 !!!

Esto es porque hemos empleado un tipo de
parámetro llamado parámetro por valor. Los
parámetros por valor no son nada más que una copia
de los parámetros originales que se crean sólo para
la función o procedimiento. Una vez termina esta copia
desaparece, por lo que toda modificación que hagamos
dentro de la función o procedimiento se
perderá.

Para resolver este problema podemos emplear
parámetros por referencia. En este caso la función
o procedimiento conoce exactamente la posición de memoria
del parámetro por lo que las modificaciones que hagamos
dentro de la función o procedimiento permanecerán
después de la llamada. Para indicar que un
parámetro es por referencia incluiremos la palabra
reservada var delante del parámetro. El procedimiento
intercambiar quedaría así :

procedure Intercambiar(var a : integer; var
b : integer);

{ Podíamos haber escrito como parámetros
(var a, b : integer); }

var

temporal : integer;

begin

temporal := b;

b := a;

a := temporal;

end;

Una de las ventajas de los parámetros por
referencia es que no es necesario crear una copia cada vez que se
llama la función o procedimiento, con lo cual ahorramos
algo de tiempo sobretodo si el dato es grande (como arrays muy
extensos o registros con muchos campos). El riesgo, pero, es
que cualquier modificación (por accidental que sea)
permanecerá después de la llamada. Para minimizar
este riesgo disponemos de un tercer tipo de parámetro
llamado parámetro constante. En vez de var llevan la
palabra reservada const. El compilador no permitirá
ningún tipo de modificación fortuita de los datos
pero los parámetros se pasaran por referencia y por tanto
la función o procedimiento será más
eficiente.

En el caso anterior intentar compilar procedure
Intercambiar(const a, b : integer); daría un error de
compilación pues entendería a y b como
constantes.

Es importante remarcar que en caso de pasar variables
por referencia no es posible especificar literales o constantes
en este tipo de parámetros ya que si sufrieran alguna
modificación dentro de la función o procedimiento
no se podría almacenar en ningún sitio.
Además, el compilador es más estricto a la hora de
evaluar la compatibilidad del tipo. Por ejemplo si el
parámetro por referencia es de tipo Integer y pasamos una
variable Byte el
compilador lo considerará ilegal aunque ambos sean enteros
y, en general, un Byte
es compatible con un Integer.

En el caso de parámetros constantes, el
compilador no es tan estricto y permite pasar literales y
constantes.

Variables locales y globales

En el ejemplo anterior de intercambiar hemos definido
una variable temporal de tipo entero dentro del cuerpo del
procedimiento. Estas variables declaradas dentro de una
función o procedimiento reciben el nombre de variables
locales y sólo son accesibles dentro de las funciones o
procedimientos. Por lo que, intentar asignar un valor a temporal
fuera de intercambiar es sintácticamente incorrecto ya que
no es visible en este ámbito.

Las variables declaradas al principio del programa
reciben el nombre de variables globales. Estas variables se
pueden emplear tanto en funciones y procedimientos como en el
bloque principal.

También el bloque principal puede tener sus
propias variables locales si las declaramos justo antes de
éste.

Esta consideración para variables es extensiva a
tipos y constantes.

program Variables;

var

a : integer;

procedure Asignar;

var

b, c : integer;

begin

a := 15; // CORRECTO a es una variable
global

b := 10; // CORRECTO b es una variable
local

c := b; // CORRECTO c es una variable
local

d := b; { INCORRECTO d es una variable del bloque
principal que no se puede acceder desde aquí }

end;

var

b, d : integer;

begin

a := 10; // CORRECTO a es una variable
global

b := 5; // CORRECTO b es una variable local del
bloque principal

Asignar; // ATENCI"N!! b no cambiará su valor
después de la llamada (b=5)

c := 4; { INCORRECTO!! c no es accesible desde
aquí ya que es una variable local de Asignar }

end.

A banda de los diferentes errores sintácticos hay
que remarcar la diferencia entre b del procedimiento Asignar y b
del bloque principal. Ambas variables son totalmente
independientes entre ellas. Este es el único caso en que
es posible la existencia de dos variables con nombres iguales. Si
la variable b hubiera sido declarada global, juntamente con a, el
compilador no nos hubiera permitido declarar b en ningún
otro punto pues habría una redeclaración de
identificador y esto no es posible pues el compilador no
sabría como distinguir las variables. Veremos más
adelante, que en diferentes units se pueden declarar los mismos
identificadores pues se puede especificar que identificador
queremos.