FUNCIONES DE LAS LIBRERIAS CAPITULO 7
Hasta ahora hemos ido viendo cómo hacer funciones y procedimientos en
Pascal, ahora que ya sabemos bien lo que son explicaré las funciones más básicas
que ya trae hechas el TP. Un librería no es más que un conjunto de funciones
metidas juntas en un archivo. Y el TP nos trae unas cuantas librerías que nos
ayudan bastante a la hora de hacer las funciones más básicas, como por ejemplo
escribir en la pantalla o leer las pulsaciones del teclado.
Yo no las explicaré todas ni mucho menos. Para obtener información sobre
ellas basta con ir a los contenidos de la ayuda del compilador, coger
"units" y escoger la librería de la que queremos chafardear las
funciones.
Algunas de las funciones básicas están en una librería llamada SYSTEM.TPU
que se incluye siempre en todos los programas que hagamos. Si usamos esas
librerías no necesitamos hacer nada, pero si usamos funciones de otra librería
tendremos que añadir el nombre de esta librería a la linea USE. Es decir, si usamos
funciones de las librerías DOS.TPU y CRT.TPU tendríamos que poner esto al
principio del programa:
USES Crt, Dos;
FUNCIONES DE
ENTRADA SALIDA
Para empezar tenemos Write y WriteLn, que se encargan de escribir algo en
la pantalla. La diferencia entre ellas es que WriteLn pasa a la línea siguiente
después de escribir mientras que Write deja el cursor en la posición donde
quede.
Podemos pasarles casi cualquier tipo de datos, así, un programa como este:
Var
A : Integer;
B : String;
Begin
A := 8;
B := ' duros.';
WriteLn('Tengo ',a,b);
End.
escribirá "Tengo 8 duros." (sí. ya sé que las frases de ejemplo
no son lo mio. ;)
Estas dos funciones están tanto en SYSTEM.TPU como en CRT.TPU. La diferencia
es que las funciones de CRT.TPU pueden escribir en color. Si os interesa buscad
en la ayuda sobre TextColor.
Para la entrada (lectura del teclado) tenemos Keypressed y ReadKey. La primera
es una función que nos devuelve un valor de tipo BOOLEAN, es decir, nos
devuelve cierto o falso según si se ha pulsado una tecla o no. Esta función ni
lee la tecla ni la saca del buffer del teclado.
La segunda también es una función, pero nos devuelve un valor de tipo char
que contiene el código ASCII de la tecla que se ha pulsado. Esta función sí que
saca la pulsación del buffer del teclado. En el caso de que no haya nada en el
buffer del teclado cuando se llama a esta función, el programa se detendrá
hasta que se pulse una tecla.
También tenemos Read y ReadLn. Su uso es inverso a Write y WriteLn. Con Read(A),
por ejemplo, el programa leerá UNA tecla y la almacenará en A (supongamos que A
es un CHAR). Mientras que ReadLn leería una linea entera y la almacenaría en el
parámetro. Esto no sólo puede usarse para caracteres y cadenas sino también
para números, por ejemplo:
Var
A : Integer;
Begin
ReadLn(A);
A := A + 1;
WriteLn('Has escrito el número anterior a ',A);
End.
Supongo que no hace falta que explique lo que hace este programa. Sólo tener
en cuenta que si como número escribimos, por ejemplo, "HOLA", el programa
dará un error de ejecución porque no sabrá como parar HOLA a
Integer.
FUNCIONES DE
LECTURA/ESCRITURA DE ARCHIVOS DE TEXTO
Para trabajar con archivos de texto tenemos que definir una variable de
tipo TEXT. A esta variable le "asignaremos" el archivo que queremos
tratar y lo abriremos o lo crearemos o continuaremos escribiendo en él. Para
asignarle un archivo a una variable haremos algo como esto:
ASSIGN(VariablaTEXT, 'Nombre.Ext');
Y después podemos escoger si queremos abrir un archivo (en este caso el archivo
debe existir, en caso contrario el programa se detendrá produciendo un error de
ejecución), podemos crearlo (con lo que si ya existe un archivo con ese nombre
lo sobrescribiremos) o podemos abrirlo para continuar escribiendo al final del archivo.
(en este último caso el archivo también debe existir)
Si abrimos el archivo sólo podremos leerlo. Si lo creamos sólo podremos escribirlo
y si lo abrimos para continuar escribiendo sólo podremos escribir a partir del
final del archivo.
Para abrirlo usaremos RESET(VariableTEXT), para crearlo usaremos REWRITE(VariableTEXT) y para continuar
escribiendo usaremos APPEND(VariableTEXT).
Una vez tenemos abierto el archivo podremos leer/escribir. Para eso usaremos
Write/WriteLn y Read/ReadLn. Las usaremos exactamente igual que antes sólo que
el primer parámetro que pasaremos será la variable de tipo TEXT que identifica
al archivo, por ejemplo:
A := 3;
WriteLn(VariableTEXT,'Hola!! He estado ',A,' veces en Madrid.);
Esto escribiría Hola!! He estado 3 veces en Madrid en el archivo de texto.
Y si queremos leer 3 valores enteros que están en una misma linea de un archivo
de texto podemos usar:
ReadLn(VariableTEXT, Valor1, Valor2, Valor3);
{Siendo Valor1, Valor2, Valor3 de tipo INTEGER}
Para cuando leamos disponemos de la función EOF(VariableTEXT), que nos devolverá
TRUE cuando hayamos llegado al final del archivo. Esto nos sirve para saber
cuándo hay que parar de leer.
Cuando hayamos terminado con el archivo debemos cerrarlo. Para ello usamos
CLOSE(VariableTEXT). Es importante no olvidarse de esto, ya que si no puede que
no se graben los últimos cambios que se hayan escrito al archivo.
FUNCIONES DE
LECTURA/ESCRITURA DE ARCHIVOS CON TIPO
En lugar del tipo TEXT podemos usar el tipo FILE OF para declarar un
archivo que no será ya de texto sino que contendrá elementos del tipo. Por
ejemplo, si queremos hacer un archivo que esté lleno de datos de tipo INTEGER
lo declararíamos así:
Var
Archivo : FILE OF Integer;
Lo asignaremos igual que los archivos de texto, pero a la hora de abrirlo
sólo podemos usar RESET y REWRITE. Pero en este caso en ambos modos podemos
leer y escribir indistintamente. La diferencia está en que RESET abre un archivo existente mientras que REWRITE crea/sobrescribe el
archivo.
Para leer/escribir en el archivo usaremos Write y Read, PERO NO WriteLn ni
ReadLn. Y, por supuesto, ahora ya no podemos escribir cualquier tipo de datos
sino que sólo podemos leer/escribir datos del tipo del que es el archivo. Así,
para llenar de ceros un archivo de Integers haríamos esto:
Var
Archivo : FILE OF Integer;
Contador : Integer;
Valor : Integer;
Begin
Assign(Archivo, 'Prueba.Pr');
ReWrite(Archivo);
Valor := 0;
For Contador := 1 to 10000 do
Write(Archivo,Valor);
Close(Archivo);
End.
Para archivos de este tipo disponemos de dos funciones muy cucas. Por un lado
tenemos FileSize(Archivo), que nos devuelve un Longint con el número de
elementos que cfontiene el archivo. Al final de el ejemplo anterior FileSize
devolvería que tenemos 10.000 Integers. (que ocuparían
20.000 bytes, pero FileSize no devuelve los bytes sino el número de elementos).
La otra instrucción es SEEK(Archivo, Posición) que lo que hace es movernos
al elemento del archivo. De esta manera, por ejemplo, podemos leer salteados
los elementos de un archivo, o podemos sobrescribir un elemento concreto.
Estas dos instrucciones también nos sirven para emular un APPEND. Para eso
sólo tendríamos que abrir un fichero e irnos a la última posición para seguir
escribiendo a partir de ahí. Algo como esto:
Begin
Assign(Archivo, 'Prueba.Pr');
Reset(Archivo);
Seek(Archivo,FileSize(Archivo));
End.
Atención a que saltamos a la posición Filesize(Archivo) y no a
FileSize(Archivo)+1, porque Seek considera que la primera posición del archivo
es el elemento 0.
En estos archivos no funciona EOF y hemos de cerrarlos igualmente.
Bien. Hasta aquí llegamos hoy. Hay montones de funciones más, pero estas son
las más básicas para ir haciendo cosas.
DESCARGAR CAPITULO 7 VERSIÓN PDF
CAPITULO 8
0 comentarios: