Manual FreePascal

De Gleducar, http://www.gleducar.org.ar

Este manual de FreePascal, Versión 1.2, es gratuito pero ha requerido un esfuerzo considerable. Si encuentras algún fallo en el código de los ejemplos de los programas o bien algún aspecto que consideres que hay que corregir no dudes en ponerte en contacto conmigo en pomuri@eresmas.net Gracias por tu colaboración.

El autor.

Roger Ferrer Ibáñez

© 2001

Modificado, corregido, actualizado, se agregó un �ndice Alfabético y un �ndice por Contenido, convertido al formato OpenOffice, HTML y a Microsoft Word, por Gunsett, Oscar Abel. Adaptado al formato de Mediawiki por Adrián Staffolani

Tabla de contenidos 1 Introducción a los lenguajes de programación 1.1 Etapas de la programación 1.2 El lenguaje Pascal y el compilador FreePascal 2 Instalar FreePascal y compilar un programa 2.1 Descarga e instalación del compilador 2.2 Compilación del primer programa 2.3 Buscando un IDE para FreePascal 3 Primeros pasos con Pascal 3.1 Programas y Unidades (units) 3.2 Estructura básica de un programa 3.2.1 Cabecera 3.2.2 Utilización de Unidades (units) 3.2.3 Declaración de constantes 3.2.4 El bloque principal del programa 3.3 Los primeros programas 4 Profundizando aspectos 4.1 Trabajando con variables y tipos de datos 4.2 Expresiones e instrucciones 5 Sentencias estructuradas 5.1 Introducción 5.2 La estructura condicional if 5.3 La estructura iterativa for 5.4 Estructuras iterativas condicionales 5.5 El selector case 6 Tipos de datos estructurados 6.1 Los datos estructurados 6.2 Declaraciones de tipo 6.3 Enumeraciones 6.4 Conjuntos 6.5 Arrays o vectores 6.6 Registros o records 7 Archivos 7.1 La necesidad de los archivos 7.2 Cómo trabajar con archivos en Pascal 7.3 Trabajar con archivos de texto 7.4 Trabajar con archivos con tipo 7.5 Archivos sin tipo 7.6 Gestión de archivos 8 Funciones y procedimientos 8.1 Diseño descendiente 8.1.1 Funciones vs Procedimientos 8.2 Funciones 8.3 Procedimientos 8.4 Tipos de parámetros 8.5 Variables locales y globales 8.6 Sobrecarga de procedimientos y funciones 8.7 Pasar parámetros de tipo open array 8.8 Funciones declaradas a posteriori 8.9 La función exit 9 Recursividad 9.1 Ventajas de la recursividad 9.2 Un ejemplo sencillo: el factorial 10 Punteros y memoria 10.1 Variables estáticas 10.2 Estructura de la memoria 10.3 Punteros con tipo 10.4 Punteros sin tipo 10.5 El tipo AnsiString 10.6 Cadenas finalizadas en carácter nulo 10.7 El tipo función/procedimiento 11 Unidades (Units) 11.1 La necesidad de las unidades (units) 11.2 Utilizar una unit 11.3 Crear una unit 11.4 Estructura de una unit 11.5 La parte interface 11.6 La parte implementation 11.7 Inicialización de una unit 11.8 Orden de inicialización y finalización 12 Librerías 12.1 Librerías vs. units 12.2 Archivos objeto 12.3 Librerías de enlace dinámico 13 Programación orientada a objetos 13.1 Programación procedimental vs. programación orientada a objetos 13.2 Encapsulación, herencia y polimorfismo 13.3 Clases y objetos 13.4 Las primeras clases 13.5 Hacer clases más robustas 14 Herencia y polimorfismo 14.1 Ventajas de la herencia en la POO 14.2 La clase TObject 14.3 Diseñar clases heredadas 14.4 Las clases abstractas 14.5 ¿Y el polimorfismo? 15 Conceptos avanzados de POO 15.1 Métodos de clase 15.2 Punteros a métodos 15.3 Paso de parámetros de tipo objeto 15.4 Referencias de clase 15.5 Los operadores de RTTI is y as 16 Gestión de excepciones 16.1 Errores en tiempo de ejecución 16.2 Lanzar excepciones 16.3 Trabajar con excepciones 17 Sobrecarga de operadores 17.1 Ampliar las capacidades del lenguaje 17.2 Un ejemplo completo: operaciones dentro del cuerpo de matrices 18 Programación de bajo nivel 18.1 Los operadores bit a bit 18.2 Empleo de código ensamblador 19 Compilación condicional, mensajes y macros 19.1 Compilación condicional 19.2 Mensajes, advertencias y errores 19.3 Macros 20 �ndice de contenido 21 �ndice alfabético

Introducción a los lenguajes de programación

Etapas de la programación

El proceso de programación consta, teóricamente, de tres partes :

• La primera, que recibe el nombre de Analisis, consiste en detallar qué tiene que hacer el programa o, dicho de otra forma, concretar qué problemas tiene que resolver nuestro programa.
• Una vez determinado qué hará nuestro programa empieza la fase de diseño. En la fase de diseño se escribe el algoritmo, que es el conjunto de pasos que hay que realizar para resolver el problema planteado en la fase de especificación. Puede haber varios algoritmos que hagan lo mismo; algunos serán más rápidos, otros más lentos, más simples o más complejos.
• Finalmente, hay que implementar el algoritmo en un lenguaje de programación. En la mayoría de los casos la implementación se realizará en un lenguaje de programación de alto nivel.

Los lenguajes de programación son un conjunto de reglas y símbolos que permiten la implementación de los algoritmos. En el caso de los lenguajes de alto nivel, estos son más cercanos a la sintaxis humana y al programador, mientras que los de bajo nivel son más cercanos a las órdenes que entiende la máquina y en general más alejados del lenguaje natural. A consecuencia de esto los lenguajes de alto nivel s e pueden emplear en más de un sistema mientras que los de bajo nivel tienen un ámbito más restringido.

Los programas escritos en lenguajes de alto nivel tienen que ser convertidos a lenguajes de bajo nivel para poder ser ejecutados en un sistema. Con esta finalidad existen los compiladores y los intérpretes. El compilador transforma el lenguaje de alto nivel en un lenguaje de bajo nivel que suele ser código máquina (o sea, directamente ejecutable por el procesador). Mientras que el intérprete codifica una o más instrucciones de forma secuencial, a medida que las va leyendo. Son lenguajes interpretados el BASIC y el LISP, mientras que el PASCAL, el C/C++ y muchos otros son compilados. Finalmente, existe una opción híbrida introducida por JAVA que dispone de compilador e intérprete de los bytecodes que el compilador genera.

El lenguaje Pascal y el compilador FreePascal

El lenguaje de programación de alto nivel Pascal fue diseñado en el año 1968 por Niklaus Wirth con una finalidad eminentemente pedagógica. En 1983, el Pascal fue estandarizado llamándose ISO Pascal, justo en el mismo año en que la empresa Borland lanzaba al mercado el compilador Turbo Pascal 1.0, el cual sería el origen de una saga de éxitos que constó de 7 versiones para el entorno MS-DOS. En sucesivas versiones, Borland aprovechó para corregir algunas deficiencias del Pascal original, que Niklaus Wirth había corregido ya en su otro lenguaje MODULA-2, transformándolo en un lenguaje de programación de propósito general, fácil de aprender, potente y que se ha adaptado a los nuevos paradigmas de programación, tales como la programación orientada a objetos y clases.

El compilador FreePascal nació el julio de 1993 impulsado por su autor, Florian Klaempfl. En el año 1996 fue lanzado a internet y en julio del 2000, casi 7 años después de su inicio, salió la versión 1.00 del compilador, suficientemente estable como para poder desarrollar aplicaciones. Se distribuye bajo licencia GNU GPL, la cual permite, básicamente, su distribución gratuita, incluyendo el código fuente, sin ningún costo, aunque los autores retienen el "copyright".

Actualmente FreePascal se encuentra por la versión 2.0.4. Para mas información : visitar (http://www.freepascal.org/).

El compilador FreePascal, existe para plataformas MS-DOS, Windows de 32-bits, Linux, Linux de 64 bits, OS/2, AmigaOs, FreeBSD y otros. Está limitado a las arquitecturas Intel y Motorola. Como característica interesante hay que decir que soporta muchas de las características del Pascal de Borland y de ObjectPascal de Delphi, y además incluye nuevas posibilidades inexistentes en estos compiladores, tales como la sobrecarga de operadores. También aporta una librería estándar que funciona en todas las plataformas en donde el compilador funciona.

En este manual se explicará cómo programar en Pascal y cómo aprovechar al máximo todas las posibilidades que el compilador FreePascal brinda al usuario, sin olvidar las que tratan del entorno Win32.

Instalar FreePascal y compilar un programa

En este apartado daremos algunas recomendaciones, para que la tarea de instalación y preparación del entorno sea más fácil para los usuarios.

Descarga e instalación del compilador

1. Descargar el Compilador.

El compilador se puede descargar gratuitamente desde el área de descarga de la web principal de FreePascal : (http://www.freepascal.org/download.var).

Se tiene que descargar el compilador para la plataforma que se desea usar :

• fpc-2.0.4.i386-win32.exe para Win32 (ftp://ftp.freepascal.org/pub/fpc/dist/i386-win32-2.0.4/fpc-2.0.4.i386-win32.exe)
• fpc-2.0.4.i386-linux.tar para linux (ftp://ftp.freepascal.org/pub/fpc/dist/i386-linux-2.0.4/fpc-2.0.4.i386-linux.tar)

2.- Instalar el Compilador.

• Windows

Simplemente ejecute el programa fpc-2.0.4.i386-win32.exe y siga los pasos que le vaya indicando el asistente, por omisión o defecto el compilador se instala en C:\FPC\2.0.4

• linux

Simplemente debes descomprimir el archivo fpc-2.0.4.i386-linux.tar, en la carpeta donde se descargo, después ejecutar el script install.sh, todo del siguiente modo, tar -xvf fpc-2.0.4.i386-linux.tar, para desempaquetar el archivo y sh install.sh para instalarlo. Por omisión o defecto el compilador se instala en /usr/local.

Nota: Para Debian el paquete a instalar será: fp-compiler, disponible en los repositorios oficiales debian. Descarga e instalación con: apt-get install fp-compiler

Compilación del primer programa

En este ejemplo compilaremos uno de los programas de ejemplo que lleva FreePascal. Este ejemplo es el típico Hola mundo(Hello.pp),

• Windows

Usando la consola del terminal escriba lo siguiente para indicarle que text sea nuestra carpeta de trabajo.

cd c:\fpcp\2.0.4\demo\text

Para compilar el archivo escriba en la línea de comandos lo siguiente :

ppc386 hello.pp

ó

fpc hello.pp

En unos instantes, si todo ha ido bien durante la compilación y el enlazado, obtendrá un archivo ejecutable con el nombre hello.exe. Si lo ejecuta desde el interprete de comandos obtendra la siguiente salida :

Hello world

• linux

Usando la consola del terminal escriba lo siguiente para indicarle que text sea nuestra carpeta de trabajo.

cd /usr/local/share/doc/fpc-2.0.4/examples/share/doc/fpc-2.0.4/demo/text

En las instalaciones realizadas en debian con apt-get, la carpeta de trabajo será:

cd /usr/share/doc/fp-compiler/text

Para compilar el archivo escriba en la línea de comandos lo siguiente :

ppc386 hello.pp

ó

fpc hello.pp

En unos instantes, si todo ha ido bien durante la compilación y el enlazado, obtendrá un archivo ejecutable con el nombre hello. Si lo ejecuta desde el interprete de comandos (./hello) obtendra la siguiente salida :

Hello world

Buscando un IDE para FreePascal

FreePascal incorpora un entorno de desarrollo integrado (IDE) en modo texto; también se puede emplear, por ejemplo los siguientes IDE :

• El Programmers Notepad para Windows (http://www.pnotepad.org).
• BloodShed's Dev-Pascal (http://www.bloodshed.net) bajo licencia GNU (hay que indicar que ya lleva su propia distribución del compilador FreePascal).
• El PsPad (http://www.pspad.com/es).
• Lazarus (http://souceforge.net/projects/lazarus/) bajo licencia GPL/LGPL (Disponible también en los repositorios debian oficiales e instalable con apt-get install lazarus , instala también fp-compiler) Más información: Tutorial Lazarus

En cualquier caso es muy recomendable que el IDE o editor permita :

• Resaltar la sintaxis de Pascal.
• Ejecutar el compilador directamente desde el editor. Consulte la documentación del editor sobre cómo aprovecharse de esta característica.

Primeros pasos con Pascal

Programas y Unidades (units)

Pascal define dos tipos básicos de archivos que se pueden compilar: los programas y las units. En estos primeros capítulos nos limitaremos a trabajar con programas y dejaremos el tema de creación de units para más adelante. Los archivos de código fuente que se escriben con un editor (o IDE) conviene que tengan extensión.PP o bien .PAS. Al compilar programas a Win32 obtendremos archivos .EXE; mientras que si compilamos units obtendremos archivos .PPW que no son ejecutables.

Estructura básica de un programa

Cabecera

Todos los programas tienen la misma estructura. Para indicar al compilador que se trata de un programa tenemos que escribir la palabra program seguida de un espacio y de un nombre (que puede tener letras y números) y que tiene que terminar en un punto y coma. Por ejemplo:

program EjemploNumero6;

Es importante indicar que el nombre que demos al programa tiene que seguir unas reglas, ya que en caso contrario no será válido para el compilador:

• El primer carácter tiene que ser una letra y no una cifra, ya que en caso contrario el compilador pensaría que es un número. Por ejemplo, no es válido el nombre siguiente:

program 6Ejemplo;

• El único carácter no alfanumérico válido es el guión bajo. No se admiten caracteres como exclamaciones o signos de interrogación, etc.
• Tampoco se admiten vocales acentuadas o letras que no pertenezcan al alfabeto inglés. Por ejemplo la Ã? y la ñ no se admiten.
• Finalmente, el nombre del programa no tiene que coincidir con otras variables o constantes del programa. Estas las veremos más adelante.

Utilización de Unidades (units)

En algunos casos nos puede interesar emplear diferentes funciones y procedimientos que están definidos en otros archivos. Esta especie de almacenes de rutinas se llaman units y hay que explicitarlas cuando queremos emplear alguna de sus rutinas en nuestro programa. Las units estándar que incorpora FreePascal son las siguientes:

PARA TODAS LAS PLATAFORMAS
GETOPTS	Permite recuperar los parámetros pasados en la línea de órdenes de un programa.
MMX	Aporta funcionalidad básica para el uso de las extensiones multimedia de los procesadores INTEL.
OBJECTS	Incorpora rutinas para gestionar objetos.
OBJPAS	Se emplea automáticamente cuando se activa el soporte Delphi.
PORTS	Da acceso a los puertos I/O de la PC. No se recomienda su uso en Win32.
STRINGS	Permite emplear el tipo de cadena PCHAR.
SYSUTILS	Implementación alternativa de la unit del mismo nombre en Delphi.
TYPINFO	Permite acceder a la información de tipo en tiempo de ejecución, como en Delphi.

PARA WINDOWS 32-BIT
DOS	Lleva rutinas de emulación de acceso al sistema DOS mediante funciones del sistema de Windows.
CRT	Rutinas básicas de gestión de la pantalla en modo texto.
GRAPH	Gestión básica de gráficos.
WINDOWS	Esta unit permite acceder a las funciones de la API de 32-BIT de Windows.
OPENGL	Accede a les funciones de bajo nivel OpenGL de Windows 32-BIT.
WINMOUSE	Funciones para emplear el mouse en Windows 32-BIT.
OLE2	Implementa las posibilidades OLE de Windows 32-BIT.
WINSOCK	Interfaz a la API winsock de Windows 32-BIT.
SOCKETS	Encapsulación de WINSOCK de forma que sea compatible en Windows 32-BIT y en Linux.

En la mayoría de ejemplos sólo emplearemos la unit CRT para mostrar datos en modo texto. Para incluir una unit en nuestro programa emplearemos la palabra reservada uses. Por ejemplo, si queremos incluir las units CRT y GRAPH sólo habrá que añadir la siguiente cláusula debajo de program:

uses CRT, GRAPH;

Cuando se emplee más de una unit habrá que separarlas con comas. La línea siempre hay que finalizarla en punto y coma.

Declaración de constantes

Muchas veces puede ser útil emplear un valor numérico o un texto determinado varias veces en un programa. Para evitar tener que definirlo en cada punto en que lo necesitemos, emplearemos una referencia única en todo el programa, a la que llamaremos constante. Las constantes no varían en todo el programa y se declaran seguidas de la palabra reservada const, un signo igual y el valor que representan. Por ejemplo:

const
máximo = 1000;
e = 2.71828;
nombre = 'Roger Ferrer';
letra = 'b';

Lo que va después del signo igual recibe el nombre de literal. Un literal es un valor incluido directamente en el código. En el primer caso es el número entero 1000, la constante máximo vale 1000. En el caso de la constante e, es el número real 2.71828. Finalmente nombre representa una cadena de caracteres con el texto Roger Ferrer.

La declaración de literales se rige por normas sencillas:

• Las cifras que no lleven decimales son automáticamente entendidas por el compilador como un entero.
• Las cifras con notación decimal inglesa, o sea, un punto decimal en vez de una coma decimal, son siempre cifras reales.
• Las cadenas de caracteres siempre empiezan y terminan con un apóstrofo o comilla simple ('). Para escribir el signo apóstrofe dentro de una cadena de caracteres hay que duplicar el apóstrofe. Eje : 'Tira palante'
• Si una cadena de caracteres tiene un sólo carácter, el compilador lo entiende también como un tipo carácter. Los caracteres son compatibles con las cadenas de caracteres pero no a la inversa.
• Podemos escribir caracteres con su código ASCII en decimal añadiendo el símbolo # delante del número. Por ejemplo #7 es el carácter BEEP que al escribirse emite un ruido por el altavoz, #65 es la letra A mayúscula. Podemos combinar caracteres escritos así y literales normales, por ejemplo 'L'#65 equivale a 'LA'.
• Los tipos enteros que empiecen con un signo de dólar $ se interpretarán como cifras hexadecimales. Las cifras que empiecen con un signo de porcentaje % se interpretarán como nombres binarios. En el caso de los hexadecimales se permite el uso de todas las cifras en base 16 (0..9, A..F) y en el caso de los binarios sólo son válidas la cifras 0 y 1.

const
NumeroBase10 = 1522;
NumeroBase16 = $5F2;
NumeroBase2 = %10111110010;

En este caso las tres constantes NumeroBase10, NumeroBase16 y NumeroBase2 representan el mismo número, aunque escrito en bases distintas. En Pascal, los nombres de constantes pueden estar en mayúsculas o minúsculas, es indiferente. Por tanto, en el ejemplo anterior maximo, MAXIMO y maXIMo representan lo mismo para el compilador. Hay que ir con cuidado para no duplicar nombres. Por ejemplo, esto es incorrecto.

const
Maximo = 1000;
MAXIMO = 5000;

Ya que MAXIMO y máximo son lo mismo y se está redeclarando una constante ya declarada. Esta independencia sintáctica a las mayúsculas está presente en todos los aspectos de Pascal excepto, claro está, en las cadenas de caracteres. Es usual, debido a la notación de C, que las constantes se declaren totalmente en mayúsculas y en los programas se empleen en mayúsculas para distinguirlas de las variables, como veremos más adelante, aunque no sea necesario hacerlo.

Headline text

Headline text
Headline text 
Headline text 

Headline text de variables. Tipos de datos fundamentales 

Si pensamos en muchas fórmulas matemáticas veremos que emplean variables en su expresión. Por ejemplo, el área del triángulo es AT b h . Cuando queremos calcular el área de un triángulo dado nos limitamos a sustituir estas variables. En Pascal, y programación ocurre algo parecido. Pascal exige que se declaren las variables que se emplearán. Las variables pueden modificar su valor a lo largo del programa. Cada variable tiene que ser de un tipo determinado. Los tipos de variables, llamados tipos de datos, se dividen en cuatro grandes grupos fundamentales:

• Numéricos. Enteros o reales.
• Alfanuméricos. Un carácter o una cadena de caracteres.
• Booleanos. Sólo pueden valer cierto o falso.

Los tipos numéricos enteros que incorpora FreePascal son los siguientes:

Tipos	Rango numérico	Bytes (BIts)
Byte	0..255	1 (8)

También tenemos tipos reales

Tipos	Rango real	Decimales significativos	Bytes (Bits)
Single	1.5-45 .. 3.438	7 – 8	4 (32)
Real	5.0-324 .. 1.7308	15-16	8 (64)
Double	5.0-324 .. 1.7308	15-16	8 (64)
Extended	1.9-4951 .. 1.14932	19-20	10 (80)
Comp	-264+1 .. 263-1	19-20	8 (64)

El tipo Comp es un tipo especial de entero con propiedades de real. Los decimales significativos indican cuántos decimales se tienen en cuenta a la hora de hacer cálculos. Los tipos alfanuméricos que implementa FreePascal son los siguientes:

Tipos	Contenido	Bytes
Char	Un solo carácter	1
ShortString	Una cadena de 255 caracteres	256
String[n]	Una cadena de n caracteres 1≤n≤255	n+1
AnsiString	Nombre ilimitado de caracteres	Concepto no aplicable en este caso
Pchar	Cadena finalizada en NULL	Concepto no aplicable en este caso

Los tipos AnsiString y PChar permiten almacenar datos alfanuméricos pero su funcionamiento y uso es más especial. El tipo String puede representar un ShortString o un AnsiString en función del modo en qué se encuentre el compilador. Finalmente, los tipos booleanos implementados son Boolean, ByteBool, WordBool y LongBool. Los tres últimos sólo tienen sentido en programación de la API de Windows y el tipo Boolean es el que se emplea más habitualmente. Para declarar variables emplearemos la palabra reservada var, los nombres de las variables seguidas de dos puntos y del tipo de variable.

Por ejemplo:

var
Base : Integer;
Altura : Integer;
NombreUsuario : ShortString;

Todo lo que era aplicable a los nombres de las constantes también lo es para los nombre de variable. Por tanto altura, ALTURA y altura serían equivalentes. La declaración anterior se podía haber simplificado de la forma siguiente:

var
Base, Altura : Integer;
NombreUsuario : ShortString;

Podemos declarar dos o más variables del mismo tipo a la vez separándolas entre comas. Hay que tener en cuenta de que no se pueden emplear las siguientes palabras para nombres de variables o constantes ya que son palabras reservadas para Pascal.

absolute const export implementation abstract constructor exports in alias continue external index and default false inherited array destructor far initialization as dispose file inline asm div finalization interface assembler do finally is begin downto for label break else forward library case end function mod cdecl except goto name class exit if near new private repeat try nil procedure saveregisters type not program self unit object property set until of protected shl uses on public shr var operator published stdcall virtual or raise string while override read then with packed record to write pascal register true xor popstack

En esta lista se incluyen todas las palabras reservadas de FreePascal, Turbo Pascal y Delphi. Aunque la lista parece muy grande, no es nada complicado encontrar nuevos nombres para constantes y variables.

El bloque principal del programa

Una vez hemos declarado la etiqueta program, la cláusula uses y las declaraciones de constantes y variables sólo falta el bloque principal de código del programa. El bloque donde se ejecutarán las órdenes. Este bloque, a diferencia de los anteriores, no se puede dejar de poner en un programa Pascal. El bloque principal del programa se define entre las palabras begin y end. Por ejemplo estas dos líneas ya son un programa válido para el compilador aunque no haga nada:

begin
end.

Nótese que el end tiene que llevar un punto final indicando que termina el programa. Es entre estas dos palabras que incluiremos nuestro código. Todas las órdenes que se incluyen en este bloque reciben el nombre de sentencias.

Los primeros programas

Vamos a hacer un programa que calcule el área de un triángulo dadas la base y la altura. El código podría ser el siguiente:

program Calcular_Area_del_triangulo;
var
base, altura, área : real;
begin
  base := 2.4;
  altura := 5.3;
  area := 0.5*base*altura;
  Writeln(area);
end.
 

Antes de comentar nada obsérvese que todas las líneas de Pascal suelen terminar en un punto y coma. Como excepciones notables tenemos en nuestro caso a var y begin. Declaramos las variables base, altura y área de tipo real. Dentro del bloque de código asignamos el valor 2.4 a la variable base mediante el operador de asignación. Este operador := permite asignar valores a las variables. En la siguiente línea se hace lo mismo con la variable altura. En la variable área se almacena el valor del producto de por la base por la altura. Finalmente esta variable la mostramos en la pantalla mediante la función Writeln. Las funciones que necesitan parámetros se especifican entre paréntesis. Si tuviéramos que añadir más de un parámetro lo separaríamos entre comas. El resultado que obtenemos en pantalla no es muy profesional, pero más adelante ya veremos como especificar los decimales que queremos obtener.

6.359999999999999E+000

Ya que el resultado de la operación 0.5*base*altura; es un real y Writeln puede mostrar reales podíamos haber simplificado el programa de la forma siguiente:

program Calcular_Area_del_triangulo;
var
base, altura : real;
  begin
  base := 2.4;
  altura := 5.3;
  Writeln(0.5*base*altura);
end.

Hemos empleado el asterisco * para indicar producto. Pero FreePascal incorpora más operadores aritméticos. Los operadores se distinguen por unarios, que sólo trabajan con un sólo elemento, o binarios, que trabajan con dos elementos.

Operadores unarios Operación + Identidad de signo. - Inversión del signo.

Operadores binarios Operación Tipo de dato resultante + Suma aritmética Admite operandos reales y enteros. Si los dos operandos son enteros el resultado es un entero. En caso contrario es un real. - Resta aritmética

Producto aritmético.

Potencia. Ex 2**3 = 23 Sólo admite operandos enteros y el resultado es un entero. div División entera mod Residuo de la división entera / División real Admite operandos enteros y reales. El resultado siempre es un real.

Los operadores tienen las mismas prioridades que en las operaciones matemáticas habituales. Si deseamos calcular 3+4 y multiplicarlo por 5 tendremos que hacer (3+4)*5 = 35 ya que si hacemos 3+4*5 = 23. Los paréntesis se pueden colocar en medio de la operación para modificar el orden de prioridad de los operadores.

begin
 Writeln(3+4*5);
 Writeln((3+4)*5);
 Writeln((3+4)*5+6);
 Writeln((3+4)*(5+6));
end.

En este aspecto hay que remarcar que los operadores con mayor prioridad son **, *, /, div y mod. Mientras que la suma y la resta son los que menos tienen. En el caso que todos tengan la misma prioridad la operación se lleva a cabo de izquierda a derecha.

Writeln(4*20 div 5); Writeln(4*(20 div 5)); Writeln((4*20) div 5);

En este caso los tres resultados son idénticos y los paréntesis sólo tienen una finalidad esclarecedora. En los dos últimos casos la operación empezará siempre por el elemento que tenga paréntesis o que tenga más que los otros.

3.3.1. Introducción de datos

El programa de cálculo de áreas que hemos hecho antes funciona correctamente pero siempre devuelve el mismo resultado. Por ejemplo, vamos a hacer un programa que calcule la suma de n potencias de r > 1. O sea que nos diga el resultado de r0+r1+r2...+ rn-1 = (rn-1)/ (r-1).

program Calcular_n_potencias;
 var
  r, n : Integer;
 begin
  Writeln('R :');
  Readln(r);
  Writeln('N :');
  Readln(n);
  Writeln('Resultado :');
  Writeln((r**n-1) div (r-1));
end.

En el anterior ejemplo hemos empleado la orden Readln para leer una entrada del teclado y almacenarla en la variable especificada en los parámetros de Readln. El usuario tiene que introducir un par de números. Por ejemplo si ejecutamos el programa e introducimos los datos siguientes obtendremos:

R :
5
N :
4
Resultado :
156

3.3.2. Comentarios en el código

Los programadores pueden situar comentarios en el código que no se compilará. Para indicar al compilador que un elemento es un comentario es necesario rodearlo de llaves { } o de los conjuntos siguientes (* y *). Finalmente si el comentario va desde un punto cualquiera hasta el final de la línea podemos emplear dos barras oblicuas //. No mezcle los caracteres { y } con (* y *) ni tampoco escriba un espacio entre el paréntesis y el asterisco porque entonces no se entiende como un comentario.

program Calcular_Area_del_triangulo;
 { Este comentario está hecho con llaves }
 var
  r, n : Integer;
  (* Este, en cambio, emplea la notación antigua de Pascal *)
 begin
  Writeln('R :'); // Desde las 2 barras hasta el final de línea es un comentario
  Readln(r);
  Writeln('N :');
  Readln(n);
  Writeln('Resultado :');
  Writeln((r**n-1) div (r-1));
 end.

Profundizando aspectos

Trabajando con variables y tipos de datos

Hemos visto en ejemplos anteriores que trabajar con variables es tan sencillo como declararlas y después referirse en el código, por ejemplo, en una asignación o en una operación. Aun así, hay otras cuestiones que debemos conocer cuando trabajemos con variables.

4.1.1. Gestión de las variables

Los tipos de variables que estamos empleando no precisan de ningún tipo de operación de inicialización o de finalización. El compilador se encarga de todos estos aspectos reservando la memoria necesaria para las variables.

4.1.2. Compatibilidad y tipos de variables

Pascal es un lenguaje fuertemente tipificado. Esto quiere decir que las comprobaciones de tipos de datos son bastante estrictas. Por este motivo no podemos asignar cualquier valor a las variables sino variables o literales que sean compatibles. El programa siguiente es incorrecto sintácticamente:

var cadena : string; número : Integer; begin cadena := 10; // No podemos asignar un numero a un string número := '10'; // No se puede asignar un string a un numero cadena := número; // Tipos incompatibles por asignación end.

Para resolver algunos de los problemas de tipos que se presentan en Pascal tenemos dos formas. Escoger una u otra dependerá de la situación en la que nos encontremos:

• Si los dos datos incompatibles representan una misma estructura de datos podemos probar un typecasting. Por ejemplo, los diferentes tipos de cadenas o de nombres enteros.

• Si los dos datos son de naturaleza distinta podemos recurrir a alguna función que transforme los datos. Por ejemplo, pasar un entero a cadena o un real a entero.

Algunas veces no será necesario realizar ninguna transformación. Es el caso de los enteros. Los enteros son compatibles "de abajo arriba". O sea, podemos emplear enteros pequeños como el Byte en asignaciones de enteros mayores como Integer o Cardinal. Habrá que tener en cuenta también si el entero es con signo o sin signo. Hay que observar también que el proceso contrario, "de arriba abajo", no siempre es posible.

var pequeño : Byte; grande : Longint; begin pequeno := 200; grande := pequeño; Writeln(grande); // 200 grande := 500; pequeño := grande; Writeln(pequeño); // 244 ! end.

La causa por la cual obtenemos 244 en el último caso es debido al rango del Byte 0..255 que no llega a 500. Los enteros, los caracteres y los booleanos, son tipos de datos llamados ordinales. Esto quiere decir que sus valores tienen un orden cíclico (en los reales, por ejemplo, no tiene sentido hablar de ordinalidad) y por tanto en un Byte después de 255 viene un 0. Por tanto 255 + 1 = 0. Cuando asignamos 500 mediante el Longint resulta que 500 = 256 + 224 = 0 + 224 = 224. O Expresado de otra forma 500 mod 256 = 224. Es importante tener en cuenta este hecho ya que es un error bastante habitual asignar tipos enteros demasiado pequeños que suelen dar comportamientos erráticos y difíciles de detectar. A menos que sea imprescindible (que podría ser), es recomendable emplear Integer o Longint en vez de Byte o Shortint.

4.1.3.Typecasting

En muchos casos trabajar con un tipo u otro de entero no reviste ninguna importancia excepto por el rango en el que trabajemos. Algunas veces es necesario que nuestro entero tenga el tamaño adecuado. Para "amoldar" el tamaño de las variables podemos emplear el typecasting. Para realizar un typecasting sólo hay que rodear la variable a amoldar con el nombre del tipo de dato al cual queremos ajustar. Los typecasting son habituales cuando se trabaja con clases y objetos. He aquí un ejemplo de typecasting con booleanos:

var var_bool : Boolean; begin var_bool := Boolean(0); Writeln(var_bool); // Escribe FALSE var_bool := Boolean(1); Writeln(var_bool); // Escribe TRUE var_bool := Boolean(12); Writeln(var_bool); // Escribe TRUE end.

Esto es sintácticamente correcto ya que un booleano es nada más que un Byte que se interpreta cierto cuando tiene un valor distinto a cero. Otro typecasting muy usual es el de la conversión de caracteres a su valor ASCII. Por ejemplo:

var carácter : Char; begin Write('Introduzca un carácter : '); Readln(carácter); Writeln('Su código ASCII es ', Integer(carácter)); end.

La instrucción Write es idéntica a Writeln pero no hace saltar el cursor a la línea siguiente. Write y Writeln permiten concatenar más de un parámetro separados por comas, en este caso un string y un Integer. Esta característica es única de Write, Writeln, Read y Readln aunque sólo se suele emplear en Write y Writeln. En el caso anterior, si introducimos una A mayúscula obtendremos el valor 65 del código ASCII. Esto también es correcto ya que un carácter no es nada más que un Byte. Escribiendo Integer hacemos que Writeln lo interprete como si de una variable Integer se tratara.

4.1.4. Funciones de conversión de tipo

Qué tenemos que hacer cuando necesitamos convertir una cadena de texto que tiene un número a un entero o convertir un real a string? Para esto tendremos que emplear las funciones que incorpora la unit SysUtils. Las funciones que nos interesarán más son IntToStr, StrToInt, FloatToStr, FloatToStrF y FloatToText.

Convertir de entero a string

Nos puede interesar convertir un entero a string, ya que muchas funciones sólo permiten strings como parámetros. Además, los strings se pueden concatenar con el operador +.

begin Writeln('Hola '+'qué tal?'); end.

En el caso de Writeln no sería necesario pero muchas funciones sólo admiten un string, y ésta es una forma sencilla de añadir más de una, o, como veremos, añadir enteros. La función IntToStr toma como parámetro un entero y devuelve un string. Veamos el caso siguiente.

uses SysUtils; // IntToStr está definida en SysUtils var cadena : string; anyos : Integer; begin Write('Cuántos años tienes ? '); Readln(anyos); cadena := 'Tienes ' + IntToStr(anyos) + ' años'; Writeln(cadena); end.

El punto y coma del final de cada sentencia nos permite agruparlas en una sola línea, aunque no es recomendable, generalmente. Obsérvese la enorme diferencia entre anyos y 'años' pues la primera es una variable y la segunda una cadena de texto. Ya que IntToStr devuelve un string lo puedo operar como si de un string se tratara, por ejemplo concatenándolo con el operador +.

Convertir de string a entero

En este caso la conversión no es tan simple pues corremos el riesgo de que la cadena de texto no pueda ser convertida a un entero. En este caso la función StrToInt lanzará una excepción. La gestión de excepciones la veremos más adelante; a pesar de eso, veamos un ejemplo sencillo:

uses SysUtils; var sum_a, sum_b, total : string; begin sum_a := '100'; sum_b := '400'; total := IntToStr( StrToInt(sum_a) + StrToInt(sum_a) ); Writeln(total); end.

Obsérvese la tercera sentencia que tiene una estructura muy interesante. Primero convertimos los string sum_a, sum_b a enteros mediante StrToInt. Ahora la suma es aritmética, ya que los dos valores son enteros. Una vez hecha la suma transformamos de nuevo el entero en un string y lo almacenamos en una variable de tipo string. En este ejemplo, los enteros contienen números válidos que pueden ser convertidos a enteros sin problemas.

Convertir un real a string

Para convertir un real a string tenemos tres funciones: FloatToStr, FloatToStrF i FloatToText. Las dos últimas son más complejas ante la simplicidad de FloatToStr.

uses SysUtils; var prueba : real; cadena : string; begin prueba := 10.5; cadena := 'El valor es '+FloatToStr(prueba); Writeln(cadena); end.

4.1.5. Trabajar con constantes

A las constantes se les pueden aplicar muchas de las cuestiones expuestas para las variables. Mientras la función de conversión no modifique el parámetro, se verá más adelante cómo, es posible sustituir una variable por una constante.

uses SysUtils; const NUMERO = 1000; begin Writeln('El numero es '+ IntToStr(NUMERO)); end.

4.1.6. Asignaciones aritméticas de variables

Antes hemos visto el operador := que es el operador de asignación por excelencia. Habitualmente, se emplean construcciones parecidas que se han simplificado en otros operadores de asignación. La tabla siguiente muestra la lista de operadores de asignación aritméticos de FreePascal. Estos operadores están disponibles sólo cuando añadimos el parámetro -Sc al compilador.

Expresión Operación Equivalencia x += y; Suma "y" a "x" y lo guarda en "x". x := x + y; x -= y; Resta "y" a "x" y lo guarda en "x". x := x - y; x *= y; Multiplica "x" por "y" y lo almacena en "x". x := x * y; x /= y; Divide "x" entre "y" y lo almacena en "x". x := x / y;

Veamos un ejemplo:

var a : Integer; begin a := 10; a+=1; Writeln(a); // 11 a := a + 1; Writeln(b); // 12 end.

Expresiones e instrucciones

Hasta ahora hemos visto muchos ejemplos de expresiones (por ejemplo a*b + c*d) combinadas con instrucciones (por ejemplo a := 10;). Una expresión es siempre algo que tiene un valor, ya sea una operación matemática simple como las que hemos visto antes. El valor de la expresión viene determinado por los elementos que intervienen en la operación que suelen ser variables, literales, constantes y operadores. Así el producto de dos enteros es un entero mientras que un entero por un real es una expresión real.

Las instrucciones son acciones que se realizan en el programa. Las instrucciones en Pascal reciben el nombre de sentencias. Hasta ahora hemos visto dos sentencias muy habituales: las sentencias de asignación y la sentencia de llamada de funciones y procedimientos. Pascal, afortunadamente, dispone de un conjunto de sentencias más elaborado que veremos en el siguiente capítulo.

Sentencias estructuradas

Introducción

Las sentencias estructuradas, basadas en más de una sentencia, son de hecho sentencias con construcciones especiales que permiten, básicamente, alterar la ejecución secuencial de las sentencias de un programa.

La estructura condicional if

Antes hemos visto por ejemplo calcular r0+r1+r2...+rn-1=(rn-1) / (r-1) cuando r > 1. En un código anterior no hemos comprobado en ningún momento que r fuera mayor que 1. Si r = 1 el programa fallaba, ya que se produce una división entre cero. Para evitar que el usuario introduzca un valor menor o igual que 1 tendremos que comprobar es mayor que 1. Con la finalidad de comprobar la certeza o falsedad de una condición Pascal (y muchos lenguajes de programación) dispone de la sentencia if.

La estructura de if es la siguiente:

if expresionBooleana then sentencias;

Es importante que la expresión entre if y then sea una expresión booleana. Vamos a ver el código del programa una vez modificado:

program Calcular_n_potencias; var r, n : Integer; begin Writeln('R :'); Readln(r); if r > 1 then begin Writeln('N :'); Readln(n); Writeln('Resultado :'); Writeln((r**n-1) div (r-1)); end; end.

Obsérvese que en este caso la expresión booleana r > 1 sólo es cierta cuando r es mayor que 1. Si es cierta se ejecuta lo que se encuentra después del then. En este caso es un bloque de sentencias. En Pascal los bloques de sentencias, aparte del principal, van entre un begin y un end con punto y coma. Si r > 1 no es cierto entonces no se ejecutará nada más. Habitualmente, precisaremos de código que se ejecutará cuando la condición no se cumpla. Para hacerlo hay que emplear la estructura siguiente:

if expresionBooleana then sentencias else sentencias;

Por ejemplo modificando el programa anterior tendríamos:

program Calcular_n_potencias; var r, n : Integer; begin Writeln('R :'); Readln(r); if r > 1 then begin Writeln('N :'); Readln(n); Writeln('Resultado :'); Writeln((r**n-1) div (r-1)); end else begin Writeln('R tiene que ser un valor superior a 1'); end; end. Si el usuario introduce un valor menor o igual a 1 entonces obtiene el mensaje que "R tiene que ser un valor superior a 1". Obsérvese también que sólo en este caso end tiene que ir sin ningún punto y coma pues va seguido de else. Si el número de sentencias de then o else es sólo una es posible omitir begin y end. Pero sólo en este caso. Si deseamos que se ejecute más de una sentencia no tendremos más remedio que emplear begin y end. En cualquier caso, el uso de begin y end es mejor pues evita muchos errores típicos.

var numero : Integer; begin Write('Introduzca un número : '); Readln(número); if numero mod 5 = 0 then Writeln('Es divisible por 5') else Writeln('No es divisible por 5'); end.

Observe que tampoco la sentencia anterior a else tiene que llevar un punto y coma. Un número es divisible por otro si su residuo (operación mod) es cero. De las estructuras condicionales anteriores hemos visto unos pocos operadores llamados relacionales que permiten construir expresiones booleanas más o menos complicadas.

5.2.1. Operadores lógicos booleanos

Pascal incorpora un conjunto de operadores booleanos lógicos que permiten modificar las expresiones booleanas. Las tres operaciones booleanas que se pueden aplicar a expresiones booleanas son las clásicas de la lógica: not (negación), and (conjunción) y or (disyunción). Not es un operador unario (con un solo operando) y devuelve el valor contrario a la expresión booleana.

not true (verdadero) false (falso) false (falso) true (verdadero) Los operadores and y or son operadores binarios, trabajan sobre dos operandos. And devuelve true si los dos operandos son true y or retorna true si alguno de los operandos lo es.

and or false false false false false true false true true false false true true true true true Finalmente disponemos de un tercer operador binario xor, disyunción exclusiva, este devuelve cierto cuando los dos elementos tienen valores diferentes.

xor false false false false true true true false true true true false Los operadores booleanos combinados con los operadores relacionales, de los cuales hemos visto antes el operador > y el =, permiten construir expresiones booleanas muy eficientes. Los operadores relacionales relacionan dos elementos y devuelven una expresión booleana.

Operador Tipos de datos Resultado = Todos los ordinales, reales y string. Enteros y Reales. Cierto si los dos operandos son idénticos. Caracteres. Si el valor ASCII de los dos caracteres es el mismo. Booleanos. Si las dos expresiones booleanas tienen el mismo valor. String. Si las dos cadenas comparadas son idénticas incluso en las mayúsculas. <> Todos los ordinales, reales y string. Devuelve true cuando = ha devuelto false y viceversa. < Todos los ordinales, reales y string. Enteros y reales. Devuelve cierto si el primer operando es menor que el segundo. Devuelve cierto si el valor ASCII del primer carácter es menor al valor del segundo. String. Devuelve cierto si la primera cadena es alfabéticamente anterior a la segunda. El alfabeto de referencia es el ASCII1. Booleanos. Si el primer operador es false y el segundo true entonces el resultado es cierto. Téngase en cuenta que false es menor que true y true es mayor que false. ya que los booleanos son ordinales. > Todos los ordinales, reales y strings. Enteros y reales. Devuelve cierto si el primer operando es mayor al segundo. Caracteres. Devuelve cierto si el valor ASCII del primer operando es mayor al segundo. String. Devuelve cierto si la primera cadena es alfabéticamente posterior a la segunda. El alfabeto de referencia es el ASCII. Booleanos. Si el primer operador es true y el segundo false entonces el resultado es cierto. <= Todos los ordinales, reales y string. Enteros y reales. Devuelve cierto si el primer operando es menor o igual al segundo. Caracteres. Devuelve cierto si el valor ASCII del primer operando es menor o igual al segundo. String. Devuelve cierto si la primera cadena es alfabéticamente anterior o idéntica a la segunda. El alfabeto de referencia es el ASCII. Booleanos. Sólo devuelve falso si el primer operador es true y el segundo false. En otros casos devuelve cierto. >= Todos los ordinales, reales y string. Enteros y reales. Devuelve cierto si el primer operando es mayor o igual al segundo. String. Devuelve cierto si la primera cadena es alfabéticamente posterior o idéntica a la segunda. El alfabeto de referencia es el ASCII. Booleanos. Sólo devuelve false si el primer operando es false y el segundo es true. En otros casos es siempre cierto. Vamos a ver ejemplos de combinación de operadores relacionales. Por ejemplo, para determinar si un número es 0 ≤ x ≤ 10 (mayor o igual que cero y menor o igual que diez). Podríamos hacerlo de la forma siguiente:

if numero >= 0 then begin if numero <= 10 then begin ... end; end;

Este ejemplo funcionaría perfectamente pero es mucho mejor combinar operadores booleanos y relacionales para obtener un código más eficiente:

if (numero >= 0) and (numero <= 10) then begin ... end;

En este caso hemos empleado el operador booleano and ya que nuestro número es "mayor o igual que cero y menor o igual que 10". Obsérvese que en este caso se necesitan paréntesis para separar las diferentes operaciones, ya que los operadores relacionales tienen la misma prioridad que los booleanos y es necesario que los relacionales sean resueltos primero. Supongamos que disponemos de una variable de tipo carácter. Queremos comprobar que la variable contiene una 'a' minúscula o una 'A' mayúscula, entonces una forma de hacerlo es:

if (Caracter = 'a') or (Caracter = 'A') then begin ... end;

Finalmente, como ejemplo, vamos a definir la operación xor con and y or. En este caso las dos estructuras siguientes son equivalentes:

var a, b : Boolean; begin if a xor b then begin ... end;

if ((not a) or b) or (a or (not b)) then begin ... end; end;

La estructura iterativa for

Muchas veces nos interesará realizar una misma o parecida operación dentro de un conjunto limitado de valores. Con esta finalidad Pascal posee la estructura for. Para poder realizar la estructura for es necesario emplear una variable contadora que variará en 1 y que tiene que ser de tipo entero necesariamente. Veamos un ejemplo simple:

var numero : Integer; begin for numero := 1 to 4 do begin Writeln('Repetición número ', numero); end; end.

La salida del programa es la que sigue: Como se ve, el código de dentro del bucle se ha ejecutado empezando desde el valor 1 de la variable número hasta el valor 4, momento en el cual el bucle termina. Repetición número 1 Repetición número 2 Repetición número 3 Repetición número 4 En el caso anterior podíamos haber escrito este código equivalente, pues el bloque begin y end sólo tiene una sentencia, pero sólo en este caso:

for numero := 1 to 4 do Writeln('Repetición número ', numero);

Obsérvese que si hace for numero := 1 to 4 do; con punto y coma después de do, el compilador entenderá que es una sentencia vacía y no hará nada más que incrementar la variable. Si en vez de incrementar la variable queremos decrementarla hay que cambiar to por downto a la vez que cambiar el origen y el final.

for numero := 4 downto 1 do Writeln('Repetición número ', numero);

Si los parámetros origen y final del contador son incorrectos, es decir que el origen es superior al final y tenemos un to, el for ya ni empezará, y continuará con la sentencia siguiente después del for.

var contador : Integer; 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, r0+r1+r2...+ rn-1 = (rn-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.

5.4.1. 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, como ejemplo, el programa siguiente. Este programa no finaliza hasta que el usuario no ha introducido un punto como cadena de entrada. 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 después de las sentencias. 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.

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 cómo salir de un bucle infinito. Es importante asegurarse de que la condición de salida se cumplirá alguna vez cuando diseñemos el algoritmo.

5.4.2. 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 el hecho de que la evaluación de la condición del bucle se hace al final del bucle y no al principio de este. 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 este 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.

5.4.3. 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 emplear 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 estas 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 cómo 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 válida 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 número 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 debido a su complejidad los 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 a 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 seguida 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;

Operación Sintaxis ¿Qué hace? Asignación directa JunkFood := [Pizza, Donut]; Si queremos el conjunto vacío : JunkFood := []; Asigna un conjunto de valores al conjunto de forma que estos pertenezcan a él. Unión de conjuntos o elementos. Si añadimos elementos: JunkFood := JunkFood + [Burguer]; Si unimos conjuntos del mismo tipo : JunkFood := JunkFood + JunkFood2; Une un conjunto con otro de forma que el resultado es el conjunto unión. Diferencia Si suprimimos elementos : JunkFood := JunkFood - [Burguer]; Suprimimos los elementos de JunkFood2 que hay en JunkFood : JunkFood := JunkFood - JunkFood2; Suprime los elementos del segundo conjunto que se encuentran en el primero y devuelve el conjunto resultado. Intersección Intersección de un conjunto y un literal : JunkFood := JunkFood * [Burguer]; (Si en JunkFood no hubiera Burguer obtendríamos el conjunto vacío). Intersección de dos conjuntos. JunkFood := JunkFood * JunkFood2; Devuelve un conjunto que contiene los elementos que pertenecen a ambos conjuntos intersecados.

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 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 3x2 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 cómo 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¸ y 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:

Bidimensional[2, 1]

En este caso, el segundo índice sólo es válido 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.

6.5.1. 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.

6.6.1. 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 cuál 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 sitúa 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

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 cada uno de 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.

7.2.1. 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 lo 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, por el contrario, 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 permite 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.

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 Assign2

Assign(ArchivoTexto, 'PRUEBA.TXT');

En este ejemplo hemos asignado la variable ArchivoTexto al archivo PRUEBA.TXT. Hay que tener en cuenta que en Windows los archivos no son sensibles a las mayúsculas: podrí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 archivo con diferentes finalidades y con diferentes funciones. Si lo queremos abrir de sólo lectura, sin la posibilidad de escribir, 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 existe, de lo contrario se cita 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 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 que finalizamos el trabajo con el archivo conviene cerrarlo para asegurarnos de que los datos escritos se escriben correctamente y para indicar que ya no lo vamos a emplear más. La función Close3, 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 es 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, donde 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(ArchivoTexto); Close(ArchivoTexto); 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 este. 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 final 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 solo 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 de que hay que leer los datos en una variable del tipo del archivo. También hay pequeñas diferencias respecto de 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 cómo 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 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 cuántas 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 en el archivo. Un archivo con tipo se entiende que está formado por un número 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 y como parámetro, el alias del archivo. El resultado que nos devuelve esta función, es el número 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 mientras 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.

<