Newsgroup: it.comp.lang.pascal
Titolo: Domanda sul costruttore \' file of \'

Qualcuno sa darmi in modo esauriente una spiegazione di cosa serva questo costruttore di tipi di dato?Potete anche farmi un esempio di programmazione in cui si deve leggere da un file agenda che contenga nome,cognome,numero di telefono?Grazie.
------------------------------------------------------------------------
Questo messaggio e' stato inviato tramite i Newsgroup di Punto
http://www.punto.it
------------------------------------------------------------------------

 ha scritto nel messaggio
news:ab075d$jn1$1...@zap-news.punto...


dato che forse sopra ho perso un po' il contatto con la realta'
(troppa polenta con gli spezzatini) aggiungo qua la 2a parte :-)
type
  campo_agenda = record
    nome, cognome, telefono: string[16];
  end;
var
 f : file of campo_agenda;
 c : campo_agenda;
...
 assign (f, 'agenda.dat');
 reset (f); {il file e' typed, non ci va la dimensione del record}
 while not eof(f) do
  begin
    read (f, c);
    writeln (" - ",c.nome,#32,c.cognome," : ",c.telefono );
   end;
...
[codice inventato sul momento non assicuro sintatticamente corretto :-) ]
--
Dreadnaut
(Life would be easier if I had the source code)

-- Tutto quello che mi e' venuto in mente sui files, una domenica
   pomeriggio che non sono uscito con la mia ragazza --  ver 0.1
( scusa ufficiale: era brutto tempo )
( scusa reale: al momento non ne ho una )
by Dreadnaut
<premessa>
parlo di `file' e `file of', i `text' sono altra cosa (un po' come i device
a blocchi ed i device a caratteri sotto unix/linux)  e mi riferisco al tp7,
per altri dialetti non confermo/assicuro nulla
</premessa>
Il tipo `file' in pascal e' un tipo complesso, che corrisponde poi ad un
record di informazioni, di solito invisibili, utilizzate dalla unit system
per accedere al file. Se volete accedere ai campi dovete passare per
il casting:  ad esempio `with TFileRec(f) do etc etc' con var f: file;
 type
  { Typed and untyped files }
    TFileRec = record
      Handle: Word;
      Mode: Word;
      RecSize: Word;
      Private: array[1..26] of Byte;
      UserData: array[1..16] of Byte;
      Name: array[0..79] of Char;
    end;
ma questo, sebbene spunto di interessanti paranoie, poco importa.
La struttura e' un po' diversa per i file `text' ma si possono fare cose
molto piu' divertenti... ma questa e' un'altra storia... (*)
Una variabile dichiarata semplicemente `file' e' un file *non tipato*,
cioe' costituito da record di lunghezza fissata ma senza una particolare
struttura (aka tipo) interna.
La dimensione del record e' specificata al momento della Reset:
reset ( f, [<rec_size>]);
se il parametro viene omesso la dimensione di default e' 128 bytes.
La lettura/scrittura su file non tipati e' permessa soltanto attraverso
blockread e blockwrite:
blockread ( <file>, <buffer>, <num_blocchi>, [risultato] );
la procedura si occupera' di caricare dal file <num_blocchi> della
dimensione sopra definita e infilarli in <buffer> (una qualsiasi variabile,
dinamica statica e' lo stesso basta che sia grande a sufficienza: il massimo
che potete caricare e' cmq limitato ai soliti ~64kb).
Se aggiungete la variabile risultato (:word) questa conterra' il numero di
blocchi effettivamente caricati dal file (utile da confrontare con il valore
di <num_blocchi>, cioe' il numero di blocchi che _vorreste_ fossero stati
caricati)
i files non tipati sono molto comodi per aprire file di formati generici,
cioe' costituiti da parti eterogenee ma comunque separabili in `blocchi':
fissando la dimensione del record ad 1 byte, possiamo caricare qualsiasi
struttura dal file con `blockread (f, varA, sizeof(varA));' e siamo legati
solo al byte, cioe' alla struttura minima di cui puo' essere costituito un
file. [ definire un file come `file of byte/char' potrebbe sembrare
equivalente, ma blockread/write accettano solo file untyped !! ]
Definendo invece variabili di tipo `file of <tipo>' fissiamo la struttura
interna del file ad una serie di record tutti dello stesso <tipo>: possiamo
leggere e scrivere ovunque nel file (ci aiuta `seek', permettendoci di
saltare all' n-esimo blocco [vale anche per i file untyped] ) ma sempre
blocchi strutturati allineati con la dimensione del record.
Ottimo per un file costituito da campi identici, un database, un agenda,
ma di certo poco flessibile: non potra' ad esempio esistere nel file un
header, a meno di non `schiacciarlo' nel <tipo> che regna incontrastato.
Su files tipati e' possibile operare con le normali read e write
(ricordandosi di specificare come primo parametro il file) ma cmq per
leggere un solo record alla volta. Niente letture violente di intere array,
ne bufferizzazioni: un record per volta come se leggessimo un carattere
da tastiera.
La differenza implementativa tra file tipati e non tipati e' semplicemente
sulle restrinzioni sulle procedure di accesso:
 - i file tipati possono solo leggere record uno per volta
(read)
 - i file untyped possono leggere solo blocchi di record (da 1 a 2^16)
(blockread)
ad entrambi si accede in modalita' promisqua: la lettura e' sequenziale
ma e' possibile saltare da una posizione all'altra tramite seek ed ottenere
l'accesso random [ chi si ricorda GET file,#n,... in basic ? com'era ? :-) ]
Entrambi sono suddivisi in blocchi di identica dimensione:
i typed fissano anche la struttura di questi blocchi, ma fra casting,
puntatori e absolute chi ci fa' caso ? :-)
gli untyped permettono di lavorare su multipli del tipo base, e quindi
su strutture complesse e variabili a run-time, e quindi sono piu' versatili
se applicati a tipi di file complessi: ovunque ci sia la necessita' di
leggere un header, valutarne il contenuto, leggere blocchi di diverse
dimensioni in base all'header (cioe' il 90% dei formati di file comunemente
usati) l'uso di variabili `file' tipate beh... e' un po' masochista ;-)
Nella gestione di strutture fissate e dimensionalmente invariabili e' invece
molto comodo non doversi preoccupare dell'implementazione del <tipo>
e quindi la versione typed si rivela molto piu' comoda: non e' piu'
necessario conoscere il record che ci apprestiamo a leggere/scrivere ma
lo consideriamo semplicemente come una scatola chiusa, tranquilli che
nel file sara' circondato solo da suoi simili, e quindi potremmo comportarci
in modo omogeneo = meno sbattimento.
-\eof\- 05/04/02 - (c) 2002, Dreadnaut production :-ţ
il contenuto di questo documento e da considerarsi esclusivamente
invenzione dell'autore, ogni riferimento a cose o persone realmente
esistenti e' puramente casuale e non voluto.


 Qualcuno sa darmi in modo esauriente una spiegazione di cosa serva questo
costruttore di tipi di dato?
Esistono 2 modalità di scrittura di file
1) Il file viene strutturato  in testa al file vi è la strutta e di seguito
i dati
2) Il file viene visto come flusso di byte
Il Pascal come il C vedono i file binari nel secondo modo, quando dichiari
file of qualcosa  indichi al compilatore che i byte devono essere
intepretati come record di qualcosa
Mi sa che ho scritto in maniera incomprensibile....

Mi dispiace per la tua ragazza (mmm forse è il caso di dispiacersi per
te!), ma queste perle di saggezza spakkano!
Grazie Dreadnaut!
NM

no dai che mi commuovo, e se piango sulla tastiera sono cavoli amari :°)
