Written by Microges2000 Dicembre 01, 2011, 10:32:00 am23634 ViewsRating: 0 (0 Rates)Print
Vediamo un po' di capire come sono strutturati i file e come si riescono a gestire in Lazarus....
Un po' di teoria:
Un file non è altro che una sequenza di byte memorizzata su un supporto di massa, puo' essere strutturato con record di dimensione fissa, variabile, mista o solamente come archivio informazioni; quasi tutti i file con estenzione conosciuta (txt, jpg, doc, pdf, exe, ...) sono strutturati con una parte a record fissa ed una parte come contenitore dati.
Si vabbè ma che significa dimensione fissa, variabile e mista:
I file con record a dimensione fissa sono composti da una sequenza di byte (sempre quella) che corrisponde ad un pacchetto informazioni.
In Lazarus l'accesso a questi tipi di file è reso immediato in quanto il compilatore gestisce i puntatori di salto all'interno del file in maniera automatica, in base alla dimensione della struttura record che lo compone.
I file a dimensione variabile o mista sono composti da una serie di strutture di dimensioni differenti, l'accesso a questi è dato attraverso librerie specifiche di gestione (come quelle di caricamento immagini o quelle di gestione dei file di testo)
Esempio di file con struttura variabile:
Il file di testo è l'esempio più eclatante di file a struttura variabile. E composto da una sequenza ordinata di caratteri e deve sottostare solamente ad una regola: la linea termina con la coppia di caratteri Return (13) e LineFeed (10) in Windows o solamente con LineFeed sotto Linux
Per la gestione di questi tipi di file Lazarus ci viene in aiuto con l'utilizzo del tipo TextFile; se un file è identificato in questo modo è Lazarus che si occupa di controllare i caratteri di fine linea ed è sempre lui a gestire i salti.
Bene, dopo la teoria, la pratica:
Funzioni di base per la gestione dei file
AssignFile(File, Nome)
Serve ad assegnare un determinato nome file alla mia variabile
Esempio: AssignFile(F, 'C:\Temp\Dati.dat') : Assegna alla variabie F il file memorizzato in 'C:\Temp\Dati.dat'
Reset(File, Dimensione)
Apre un file in lettura/scrittura e mette il puntatore all'inizio
note:
.Nei file tipizzati o di testo il campo dimensione non deve essere inserito
.Nei file identificati solamente come File la dimesione deve essere impostata
.Nei file di testo apre il file solamente in lettura
.Se il file non esiste viene generata un'eccezione
Esempio: Reset(F)
Rewrite(File)
Come reset ma se il file esiste lo cancella e, se non esiste, lo crea
Esempio: Rewrite(F)
Append(File)
Apre un file di testo in scrittura e si pone alla fine dello stesso
Esempio: Append(F)
Read(File, Dato)
Legge la struttura record Dato dal file partendo dalla posizione attuale ed incrementa il puntatore
Esempio: Read(F, Rec)
ReadLn(File, Stringa)
Legge una linea da un file di testo e si posiziana sulla successiva
Esempio: ReadLn(F, Stringa)
Write(File, Dato)
Scrive la struttura Dato nel file alla posizione attuale e sposta il puntatore a +1
Esempio: Write(F, Rec)
WriteLn(File, Stringa)
Aggiunge una linea al file di testo
Esempio: WriteLn('F, 'Linea numero x');
Seek(File, Posizione)
Sposta il puntatore attuale del file alla posizione Posizione
Nota: il primo puntatore è 0
Esempio: Seek(F, 12)
CloseFile(File)
Chiude il file
Esempio: CloseFile(F)
Eof(File)
Ritorna se siamo giunti alla fine del file
Esempio: If Eof(F) Then Messaggio := 'Fine File';
FileSize(File)
Ritorna il numero di record presenti all'interno del file
Esempio: Dimensione := FileSize(F);
FilePos(File)
Ritorna la posizione corrente al file
Esempio: Corrente := FilePos(F)
BlockRead(File, Dato, NumByte, Risultato)
Legge, partendo dalla posizione attuale del file, NumByte caratteri e li memorizza nella variabile Dato.
Se Risultato è passato ritorna il numero di caratteri realmente letti
Se Risultato non è passato ed il numero di caratteri letti e minore di quanto aspettato viene generata un'accezione
BlockWrite(File, Dato, NumByte, Risultato)
Scrive, partendo dalla posizione attuale del file, NumByte caratteri prelevati dalla variabile Dato.
Se Risultato è passato ritorna il numero di caratteri realmente scritti
Se Risultato non è passato ed il numero di caratteri scritti e minore di quanto aspettato viene generata un'accezione
FileGetAttr(NomeFile)
Ritornano gli attributi del file (sistema, nascosto, sola lettura, ...)
Esempio: If (FileGetAttr('C:\Pippo.txt') And faReadOnly) <> 0 Then Messaggio := 'File di sola lettura';
FileSetAttr(NomeFile, Attributi)
Modifica gli attributi del file
Esempio: FileSetAttr('C:\Pippo.txt', faReadOnly or faSysFile);
Gestire file con record a dimensione fissa
Per prima cosa dobbiamo create un tipo che identifichi la nostra struttura (nota che in una struttura per file le stringhe DEVONO avere dimensione prefissata)
Type
MioRecord = Record
Nome : String[30];
Eta : Byte;
Stipendio : Integer;
End;
Abbiamo creato la nostra prima struttura che ci dice che i primi 30+1 byte identificano i caratteri di una stringa contenuta nel campo Nome (uno in più per la lunghezza), il byte che segue identifica il campo eta e gli ultimi due identificano il campo stipendio.
Var
F : File of MioRecord;
R : MioRecord;
con questa dichiarazione abbiamo detto che la variabile F è il gestore di file con strutture record uguali a MioRecord e la variabile R è una struttura di tipo MioRecord
AssignFile(F, 'C:\Pippo.dat');
ora abbiamo detto al compilatore che F deve puntare al file che è o sarà memorizzato in 'C:\Pippo.dat'
If FileExists('C:\Pippo.dat')
Then
Reset(F)
Else
Rewrite(F);
per aprirlo caccciamo un controllo iniziale, ovvero se esiste lo apriamo normalmente altrimenti lo creiamo
While not Eof(F) Do Read(F, R)
questo è un ciclo di lettura dalla posizione corrente (se lo abbiamo appena aperto è la 0) alla fine del file
se vogliamo leggere un record ad una posizione specifica basta fare
Seek(F, Posizione);
Read(F, R);
idem per scriverlo
Seek(F, Posizione);
Write(F, R);
Gestire file di testo
Questa è la gestione più semplice in assoluto anche se ha alcune limitazioni:
1) Non si possono eseguire salti a posizioni prefissate
2) Non si puo' sapere a priori quante linee contiene
3) Si deve decidere all'inizio se leggere o aggiungere linee
comunque per prima cosa dichiariamo la nostra variabile
Var
F : TextFile;
ora lo apriamo in lettura e leggiamo le linee
AssignFile(F, 'C:\Pippo.txt');
Reset(F);
While Not EOF(F) Do ReadLn(F, Stringa);
facile facile, unica cosa notate il ReadLn al posto del Read usato per i file tipizzati
atro esempio: lo apriamo in scrittura ed aggiungiamo alcune linee
bene, dopo aver dichiarato le strutture andiamo a gestire il file
Var
F : File; // Variabile di gestione file
RH : Header; // Struttura Header
RI : Intestata; // Struttura Intestata
Numero : Word; // Numero di byte da leggere
Dato : Byte; // Singolo byte letto
Conta : Word; // Contatore di lettura
Begin
// ------------------------------------------------------
// Assegnazione file
// ------------------------------------------------------
AssignFile(F, 'C:\Pippo.dat');
// ------------------------------------------------------
// Apertura file impostando la lunghezza record ad 1
// ------------------------------------------------------
Reset(F, 1);
// ------------------------------------------------------
// Lettura della struttura Header
// ------------------------------------------------------
BlockRead(F, RH, SizeOf(RH));
// ------------------------------------------------------
// Lettura della struttura Intestata
// ------------------------------------------------------
BlockRead(F, RI, SizeOf(RI));
// ------------------------------------------------------
// Lettura del numero di byte da leggere
// ------------------------------------------------------
BlockRead(F, Numero, SizeOf(Numero));
// ------------------------------------------------------
// Lettura di tutti i byte validi
// ------------------------------------------------------
For Conta := 1 To Numero Do BlockRead(F, Dato, SizeOf(Dato));
// ------------------------------------------------------
// Chiusura del file
// ------------------------------------------------------
CloseFile(F);
End;
Per ultimo, ma non meno importante, gestiamo i file con strutture record diffferenti ma dimensione fissa.
mettiamo che abbiamo un file che vogliamo strutturare cosi':
abbiamo una struttura di anagrafica (nome, cognome, eta', e similari) ma, se è un adulto la struttura che segue è composta da una serie di dati sull'abitazione, mentre se è un minore la struttura che segue è una serie di dati sui suoi giocattoli.
Potremmo gestirla come nel caso di file con dimensioni variabili ma ci complicheremmo la vita, allora il pascal ci aiuta con un piccolo artifizio:
Dichiariamo le strutture dati primarie:
Type
Anagrafica = Record
Nome : String[30];
Cognome : String[30];
Eta : Byte;
End;
Bambino = Record
NumeroGiocattoli : Integeger;
GiocattoloPreferito : String[50];
End;
bene ed ora dichiariamo il record per l'accesso al file
Type
MioRecord = Record
Dati : Anagrafica;
Case Integer Of
0 : (Abitazione : Adulto);
1 : (Giochi : Bambino);
End;
notate il Case nella dichiarazione? Questo dice al compilatore che MioRecord puo' essere cosi'
Record
Dati : Anagrafica;
Abitazione : Adulto;
End
oppure cosi'
Record
Dati : Anagrafica;
Giochi : Adulto;
End
tenete presente che la dimensione reale della struttura dati sarà pari alla combinazione piu' grande.
Con questa tecnica la gestione è identica a quella dei file con record a dimensione fissa ma si possono avere informazioni differenti a seconda del caso
// ------------------------------------------------------
// Posizionamento all'interno del file
// ------------------------------------------------------
Seek(F, Posizione);
// ------------------------------------------------------
// Lettura e scrittura record
// ------------------------------------------------------
Read(F, Rec);
Write(F, Rec);
l'unica cosa che spettta a noi è l'accesso alla struttura dati esatta a seconda del caso
// ------------------------------------------------------
// Lettura record
// ------------------------------------------------------
Read(F, Rec);
// ------------------------------------------------------
// Esempio per dati anagrafica
// ------------------------------------------------------
Inserisci_Anagrafica(Rec.Dati);
// ------------------------------------------------------
// Controllo se minorenne ed inserimento dati specifici
// ------------------------------------------------------
If Rec.Dati.Eta < 18
Then
Inserisci_Giochi(Rec.Giochi)
Else
Inserisci_Abitazione(Rec.Abitazione);
// ------------------------------------------------------
// Scrittura record
// ------------------------------------------------------
Write(F, Rec);
Conclusioni:
Sbizzarritevi con la fantasia e create librerie di accesso a qualsiasi tipo di file - tutto è possibile -
About the author
Microges2000 registered at Italian community of Lazarus and Free Pascal on Novembre 29, 2011, 09:04:00 am and has posted 130 posts in the boards since then. Last visit was Gennaio 29, 2021, 09:31:53 am.
Questo blog non rappresenta una testata giornalistica poiché viene
aggiornato senza alcuna periodicità. Non può pertanto considerarsi un
prodotto editoriale ai sensi della legge n. 62/2001.
Questo sito utilizza cookie, anche di terze parti, per offriti servizi in linea con le tue preferenze. Chiudendo questo banner, scorrendo questa pagina, cliccando su un link o proseguendo la navigazione in altra maniera, acconsenti all’uso dei cookie.