BotonMenu
BotonIndice

Visita : http://www.conoce3000.com
Paypal : https://www.paypal.me/conoce3000/1

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL

PASCAL CON FREE PASCAL


9. ARCHIVOS.
9.5. ARCHIVOS SIN TIPO. (RUTINAS TRADICIONALES O ESTÁNDAR).
9. ARCHIVOS.
9.5. ARCHIVOS SIN TIPO. (RUTINAS TRADICIONALES O ESTÁNDAR).
9. ARCHIVOS.
9.5. ARCHIVOS SIN TIPO. (RUTINAS TRADICIONALES O ESTÁNDAR).

SIGUIENTE

SIGUIENTE

SIGUIENTE


‒ Archivos sin tipo. (Rutinas tradicionales o estándar)

Los archivos sin tipo son archivos de acceso aleatorio, al igual que los archivos con tipo, sólo se pueden asociar con dispositivos de almacenamiento u otro que permita el acceso aleatorio. Un archivo sin tipo es un archivo que no usa un tipo de dato para definir su contenido, y por ende cada vez que se hace una lectura o escritura se debe especificar la cantidad de bytes que se escriben o leen, sin importar lo que estos representen. Los archivos sin tipo solo se definen con el uso de la palabra reservada File.

La lectura y escritura de un archivo sin tipo se hace a través de bloques en donde el tamaño en bytes de un bloque se define cuando se usa una de las rutinas reset o rewrite. Las rutinas de lectura y escritura que se usan con los archivos sin tipo son Blockread y Blockwrite respectivamente, es decir no se pueden usar las rutinas write y read con este tipo de archivos.

Los archivos sin tipo son más rápidos en la lectura y escritura, ya que transfieren los bloques de bytes desde el archivo a la variable que los almacenará, sin ningun tipo de comprobación.

Los archivos sin tipo se asocian con un flujo del mismo modo como se hace con los archivos con tipo, es decir se usa el procedimiento assign, también se usan los procedimientos reset, rewrite y close. El procedimiento reset nos permite abrir el archivo, tanto para lectura como para escritura, y nos permite indicar en un parámetro opcional el tamaño en bytes que tendrá cada bloque cuando se haga una lectura o escritura. La rutina rewrite también permite indicar el tamaño en bytes que tendrá cada bloque, teniendo en cuenta que si se usa rewrite con un archivo existente este borrara su contenido. Si no se indica el tamaño en bytes que tendrá un bloque, entonces por defecto un bloque tendrá un tamaño de 128 bytes. La función close nos permite cerrar el archivo, esta función no tiene ningún cambio.

La función seek, que nos permite mover el puntero de archivo, moverá el puntero de archivo, de bloque en bloque, teniendo en cuenta el tamaño del bloque; es decir si el bloque es de 10 bytes, seek moverá el puntero de archivo de 10 bytes en 10 byets.

Del mismo modo que los archivos de texto y con tipo, en Windows los nombres de los archivos sin tipo sólo deben estar en ASCII o una de sus variantes ANSI. Ejemplo:


Descargar
{$codepage utf8}
{$ifdef win32}
   Uses sysutils;
{$endif}
{$ifdef Unix}
   Uses sysutils,cwstring;
{$endif}

Var 
   Arch:File;
   b:array [1..10] of longint;
   i:integer;
    
Begin
   Assign(Arch,'numeros.dat');
   {$ifdef Unix}
   Assign(Arch,'の番号.dat');
   {$endif}

   Rewrite(Arch,4); //cada bloque de 4 bytes
   Randomize;
   for i:=1 to 10 do    
     b[i]:=random(1000);     	     
   Blockwrite(Arch,b,10); //grabar los diez bloques

   Reset(Arch,4);
   Blockread(Arch,b,10);
   for i:=1 to 10 do    
     Writeln(b[i]);    
   close(Arch)
End.
Código fuente 11: Archivos sin tipo, uso de blockread y blockwrite.
Descargar

Lo primero que observamos del programa, es que usamos rewrite para crear el archivo con un bloque de 4 bytes, que se usará al momento de escribir en el archivo. Después del bucle for que guarda los números enteros generados aleatoriamente en la variable b, que es un arreglo de números enteros de tipo longint. Se hace la escritura de la variable b en el archivo con el uso del procedimiento Blockwrite, en el tercer parámetro de blockwrite se debe indicar la cantidad de bloques que se van a escribir en el archivo, en este caso son 10 bloques ya que cada elemento del arreglo tiene un tamaño de 4 bytes (longint = 4 bytes) que coincide con el tamaño de los bloques que se usaran, de esta manera se graban 40 bytes en el archivo en una sola operación.

Después se usa reset, indicando el tamaño en bytes de los bloque que se van a usar para la lectura, después se hace la lectura con el procedimiento Blockread, indicando en su tercer parámetro la cantidad de bloques a leerse, para colocarlos en la variable b, que en este caso serán 10 bloques.

Blockread y Blockwrite tienen un 4to parámetro opcional que nos devuelve la cantidad de bloques leídos o escritos en el archivo realmente, estos valores devueltos son de utilidad si queremos saber si la operación se realiza con éxito.

El siguiente programa es igual que el anterior pero haciendo uso del 4to parámetro de las rutinas blockread y blockwrite:


Descargar
{$codepage utf8}
{$ifdef win32}
   Uses sysutils;
{$endif}
{$ifdef Unix}
   Uses sysutils,cwstring;
{$endif}

Var 
   Arch:File;
   b:array [1..10] of longint;
   i:integer;
   bloquesleidos,bloquesescritos:longint;    
Begin
   Assign(Arch,'numeros.dat');
   {$ifdef Unix}
   Assign(Arch,'の番号.dat');
   {$endif}

   Rewrite(Arch,4); //cada bloque de 4 bytes
   Randomize;
   for i:=1 to 10 do    
     b[i]:=random(1000);
   Blockwrite(Arch,b,10,bloquesescritos); //grabar los diez bloques

   //si se escribieron los 10 bloques entonces mostrarlos
   if bloquesescritos=10 then 
    Begin   
     Reset(Arch,4);
     Blockread(Arch,b,10,bloquesleidos);
     for i:=1 to bloquesleidos do    
          Writeln(b[i]); 
   End; 
   close(Arch)
End.
Código fuente 12: Archivos sin tipo, uso de blockread y blockwrite con el cuarto parámetro.
Descargar

En este caso el programa usa la variable bloquesescritos para verificar la cantidad de bloques escritos, si estos coinciden con 10 entonces la operación de escritura se realizó con éxito, se grabaron los 10 bloques. Luego la variable bloquesleidos se usa en el bucle for para mostrar sólo la cantidad de bloques que se pudieron leer con Blockread.

El siguiente programa es un ejemplo de cómo sacar una copia de cualquier archivo, usando los archivos sin tipo:


Descargar
{$codepage utf8}
{$ifdef win32}
   Uses sysutils;
{$endif}
{$ifdef Unix}
   Uses sysutils,cwstring;
{$endif}
 var
   Arch01,Arch02: file;
   BloquesLeidos,BloquesEscritos: longint;
   NombreArch01,NombreArch02: String;
   B: array[1..2048] of byte; 
 begin
   Write('Nombre del archivo a copiar: ');
   ReadLn(NombreArch01);
   Write('Nuevo nombre del archivo copiado: ');
   ReadLn(NombreArch02);
   Assign(Arch01,NombreArch01);
   Reset(Arch01,1);     //bloques de 1 byte          
   Assign(Arch02,NombreArch02);
   Rewrite(Arch02,1);  //bloques de 1 byte             
   repeat
     BlockRead(Arch01,B,SizeOf(B),BloquesLeidos);
     BlockWrite(Arch02,B,BloquesLeidos,BloquesEscritos);
     Write('.')
   until (BloquesLeidos = 0) or (BloquesEscritos <> BloquesLeidos);
   Close(Arch01);
   Close(Arch02);
 end.
Código fuente 13: Uso de archivos sin tipo para copiar o duplicar cualquier archivo.
Descargar

En este caso se definen los bloques con un tamaño de 1 byte, tanto para lectura como escritura. Esto nos facilita la lectura de cualquier archivo con cualquier tamaño. Blockread siempre hará una lectura de 2048 bytes que es el tamaño de la variable B aunque el archivo sea de menor tamaño que este la cantidad real de bytes leídos se obtiene en BloquesLeidos y el procedimiento Blockwrite usará la variable BloquesLeidos, para escribir dicha cantidad de bytes en el nuevo archivo.

Ambos procedimientos se encuentran dentro de un bucle Repeat, este bucle finalizará cuando BloquesLeidos tenga el valor 0 que indica que ya no se pudieron leer más bytes del archivo a copiar, o cuando se produce un error de escritura es decir cuando los Bloquesleidos y BloquesEscritos no coincidan. Al final se cierran ambos archivos.

La función truncate también se puede usar con este tipo de archivos del mismo modo que como se hace con los archivos con tipo, Ejemplo:


Descargar
{$codepage utf8}
{$ifdef win32}
   Uses sysutils;
{$endif}
{$ifdef Unix}
   Uses sysutils,cwstring;
{$endif}

Var
   Arch:File;
   b:array [0..10] of longint;   
   i:integer;
   bloquesleidos,bloquesescritos:longint;    
Begin
   Assign(Arch,'numeros.dat');
   {$ifdef Unix}
   Assign(Arch,'の番号.dat');
   {$endif}

   Writeln('Creando el archivo');
   Rewrite(Arch,4); //cada bloque de 4 bytes
   Randomize;
   for i:=0 to 10 do b[i]:=i;
   Blockwrite(Arch,b,11,bloquesescritos); //grabar los diez bloques

   

   Writeln('Mostrando');	 
   if bloquesescritos=11 then 
    Begin   
    //si se escribieron los 11 bloques entonces continuar
     Reset(Arch,4);
     Blockread(Arch,b,11,bloquesleidos);
     for i:=0 to bloquesleidos-1 do Writeln(b[i]); 

       
     Writeln('Truncando hasta 5');	 
     seek(Arch,5);
     truncate(Arch);
     Reset(Arch,4);
     Blockread(Arch,b,11,bloquesleidos); //Se intenta leer 11 bloques
     for i:=0 to bloquesleidos-1 do Writeln(b[i]); 
   End; 
   
   close(Arch)

End.
Código fuente 14: Uso de truncate con archivos sin tipo.
Descargar

Se debe tener presente que cada vez que se usa Blockread o Blockwrite, este siempre moverá el puntero de archivo al siguiente bloque. Del ejemplo anterior se puede observar que se usa seek para colocar el puntero de archivo en el bloque 5, para después eliminar todos los bloques desde el bloque 5 hasta el final, esta operación se hace con el procedimiento truncate. Se debe tener presente que truncate cierra el archivo, después de truncar su tamaño.

El ejemplo anterior hace uso de arreglos estáticos pero también se pueden usar arreglos dinámicos, y se debe usar el primer elemento del arreglo y no la variable, con los procedimientos Blockread y BlockWrite. Ejemplo:


Descargar
{$codepage utf8}
{$ifdef win32}
   Uses sysutils;
{$endif}
{$ifdef Unix}
   Uses sysutils,cwstring;
{$endif}

Var
   Arch:File;

   b:array of longint;
   i:integer;
   bloquesleidos,bloquesescritos:longint;    
Begin
   Setlength(b,11);  //de 0 a 10
   Assign(Arch,'numeros.dat');
   {$ifdef Unix}
   Assign(Arch,'の番号.dat');
   {$endif}

   Writeln('Creando el archivo');
   Rewrite(Arch,4); //cada bloque de 4 bytes
   Randomize;
   for i:=0 to High(b) do b[i]:=i;
   Blockwrite(Arch,b,length(b),bloquesescritos); 

   
   //si se escribieron los 11 bloques entonces mostrarlos
   Writeln('Mostrando');	   
   if bloquesescritos=11 then 
    Begin   
     Reset(Arch,4);
     Blockread(Arch,b,length(b),bloquesleidos);
     for i:=0 to bloquesleidos-1 do Writeln(b[i]);         
     Writeln('Truncando hasta 5');	 
     seek(Arch,5);
     truncate(Arch);
     Reset(Arch,4);
     Blockread(Arch,b,length(b),bloquesleidos); //Se intenta leer 11 bloques
   for i:=0 to bloquesleidos-1 do Writeln(b[i]); 
   End;    
   close(Arch)
End.
Código fuente 15: Arreglos dinámicos con archivos sin tipo.
Descargar




SIGUIENTE
SIGUIENTE
SIGUIENTE



 
‒ Comentarios y sugerencias.

Agradezco de antemano, todo comentario, sugerencia, y donativo (a través de Paypal me), que ayude a mejorar los contenidos educativos de Conoce 3000. Además, cualquier pregunta o duda que tengas lo puedes hacer por este medio. Pero, todo contenido que pueda resultar ofensivo, malicioso, racista, sexista, discriminatorio, obsceno, vulgar será eliminado.


Comments System WIDGET PACK






PORTADA |  INTERESANTE |  APUNTES |  LIBROS |  GALERIA


Creative Commons License


Todos los textos, imágenes y videos de Conoce3000 estan colocados bajo una licencia : Creative Commons Reconocimiento-NoComercial 3.0 Unported License.