FILE TESTO
INPUT
+
DATI
PROGRAMMA
CARICAMENTO
DATI
PROGRAMMA
FILE DATI
PROGRAMMA
INPUT
OUTPUT
OUTPUT
FILE TESTO
- Contiene caratteri leggibili
- E’ etichettato con un nome
- Ha un indirizzo sull’unità di memoria di
massa
I File testo si possono caricare e modificare con
un Editor ad Es. quello del Turbo Pascal, il
Word, Note Pad purchè vengano salvati come
file testo (suffisso .txt), o con un appropriato
programma Pascal.
Esempio
La vispa Teresa
avea tra l’erbetta
a volo sorpresa
gentil farfalletta
In ogni programma Pascal ogni file è identificato attraverso una variabile.
PROGRAM EcoFile(output, InFile);
VAR
Infile : text;
Carattere: char;
{usato per estrarre i caratteri dal testo}
BEGIN
…………..
END.
UN FILE TESTO NON SI COMPILA PERCHE’
NON E’ UN PROGRAMMA !!!!
APERTURA DI UN FILE
procedure
assign
(
Identificatore
file
,
Nome file
)
assign (IdentificatoreFile,NomeFile)
assign( ProvaF,
’C:\TP\ESEMPI\TESTO.TXT');
PROGRAM EcoFile(output, ProvaF);
VAR
ProvaF : text;
}
BEGIN
assign( ProvaF, ’C:\TP\ESEMPI\TESTO.TXT');
…………..
END.
LETTURA DI UN FILE
Un file non può essere letto e scritto
contemporaneamente.
La procedura reset prepara il file alla lettura.
La chiamata alla procedura reset può variare da
dialetto a dialetto.
procedure
Identificatore
file
(
reset
VAX e standard Pascal
reset(Testo)
TURBO PASCAL
assign(Infile,’TESTO.txt’)
reset(Infile,’TESTO.txt’)
)
prepara file per la lettura
reset (IdentificatoreFile)
APPLE PASCAL
reset(Infile,’TESTO.txt’)
reset( ProvaF);
L
a
v
i
s
p
a
T
FILE TESTO
Il file testo (.txt) è caratterizzato dall’avere un carattere speciale quando termina un rigo, detto:
eoln (end-of-line); e da un carattere speciale che indica la fine del file detto: eof (end-of-file)
Esempio
La vispa Teresa
avea tra l’erbetta
a volo sorpresa
gentil farfalletta
L
a
a
e
Struttura del file testo
v
v
t
a
r
a
i
s
p
a
eoln
a
s
e
..
..
T
r
..
e
eoln
eoln
eoln
eoln
eof
L
L
a
a
v
i
s
p
a
Posizione e contenuto della finestra
di lettura dopo il reset(ProvaF).
Posizione e contenuto della finestra
di lettura dopo readln(ProLett,Carattere);
write(Carattere);
L
a
eoln
eoln(Prolett)
readln(Prolett,Carattere)
eoln(Prolett)
eoln
eof
FALSE
a
TRUE
a
eoln
eof
PROGRAM ProvaFiles(input,output,ProLett);
{legge dal file TESTO i caratteri uno alla volta e li mostra a video}
VAR
ProLett: text;
Carattere: char;
BEGIN
assign(ProLett,'C:\TP\ESEMPI\TESTO.TXT');
reset(ProLett);
WHILE NOT eof(ProLett) DO
BEGIN
WHILE NOT eoln(ProLett) DO
BEGIN
read(ProLett,Carattere);
write(Carattere)
END;
readln(ProLett);
writeln;
Terminata la lettura di una riga
END;
bisogna andare a capo
readln
END.
T
e
r
e
s
a
eoln
Valori
input
1°
2°
3°
4°
5°
6°
eoln
False
False
False
False
False
False
True
Finestra input
T
e
r
e
s
a
eoln
Ch letto
?
T
e
r
e
s
a
T
e
r
e
s
a
Ch mostrato
SCRITTURA DI UN FILE
La procedura rewrite prepara il file alla lettura.
La chiamata alla procedura rewrite può variare da dialetto a dialetto e risulta operativa
solo se il file aperto cui essa fa riferimento non contiene alcun carattere.
Quando si scrive un file si presuppone sempre di comnciare dall’inizio del file. Se questo
avesse già un contenuto questo verrebbe sovrascritto.
rewrite
(
Identificatore
file
)
rewrite (IdentificatoreFile)
prepara file per la scrittura
rewrite( ProvaF);
SCRITTURA DI UN FILE
procedure
close
Identificatore
file
(
close (IdentificatoreFile)
)
Si può copiare un file in un
altro anche leggendo un rigo
alla volta
close( Prodat);
CHIUSURA DI UN FILE
Dopo avere scritto un file è necessario chiuderlo.
La procedura close(InFile) chiude il file identificato dalla variabile InFile
PROGRAM ProvaFiles(input,output,ProInput,ProOut);
{esempio di lettura e scrittura di files}
{legge dal file TESTO una stringa Stringa e la scrive su COPIA}
CONST
LungMax=80; {massima lunghezza permessa alle stringhe }
TYPE
Stringa=STRING[LungMax]; {dipende dal dialetto}
VAR
ProInput,ProOut: text; {identificatori dei file di lettura e scrittura}
Rigo: Stringa; {linea del testo letta e riscritta}
BEGIN
assign(ProInput,'C:\TP\ESEMPI\TESTO.TXT');
assign(ProOut,'C:\TP\ESEMPI\COPIA.TXT');
reset(ProInput); {prepara file per la lettura}
rewrite(ProOut); {prepara file per la scrittura}
WHILE NOT eof(ProInput) DO
{verifica che non sia finito il file}
BEGIN
readln(ProInput,Rigo);
{leggi il rigo}
writeln(ProOut,Rigo)
{scrivi il rigo}
END;
close(ProInput);
{chiudi il file di input}
close(ProOut);
{chiudi il file di output}
writeln('File Duplicato ');
readln
END.
In lettura i caratteri vengono letti uno alla volta (read) o a gruppi
(readln) e la finestra di lettura si comporta come prima descritto.
In scrittura i caratteri letti vengono messi in un buffer del file
rappresentato dal nome della variabile del file. Il buffer contiene una
riga del testo, cioè dall’inizio fino a <eoln>.
Con write leggiamo carattere per carattere e lo aggiungiamo nel
buffer.
Con writeln prima carichiamo il buffer con una riga di testo e poi
scarichiamo il suo contenuto sul file di uscita aggiungendo
automaticamente alla fine un <eol>.
A questo punto il buffer si riempie di spazi vuoti ed è pronto a
continuare la lettura.
Con un read o readln la finestra di lettura fa sempre un passo avanti.
Con un write o writeln si aggiunge sempre un carattere al buffer.
ALGORITMI PER IL TRATTAMENTO DI FILE TESTO
read mode
L
a
v
i
s
p
a
Finestra di lettura
i
v
Variabile NomeFile
InFile
alla elaborazione
write mode
L
a
eoln
v
i
s
p
a
v
i
s
p
a
invio
buffer
eoln
Variabile NomeFile
OutFile
PROGRAM MostraFile(VispaTeresa, output);
{mostra il contenuto di un file su monitor}
VAR
VispaTeresa: text;
PROCEDURE CopiaFile(VAR InFile,OutFile:text);
{i file InFile e OutFile sono già stati preparati per essere
letti e scritti}
VAR Carattere: char; {carattere da leggere da InFile}
BEGIN
WHILE NOT eof(InFile) DO {verifica che non sia finito il file}
BEGIN
WHILE NOT eoln(InFile) DO
BEGIN
read(InFile,Carattere); {leggi il carattere}
write(OutFile,Carattere) {scrivi il carattere}
END;
readln(InFile);
writeln(OutFile)
END
END;
BEGIN
assign(VispaTeresa,’C:\TP\ESEMPI\TESTO.txt’)
reset(VispaTeresa);
CopiaFile(VispaTeresa,output);
close(VispaTeresa);
END.
CREAZIONE DI UN FILE TESTO DA TASTIERA
PROGRAM Digitato(input, output, FileDigitato);
{crea un file da tastiera e poi lo mostra }
VAR
FileDigitato: text;
Risposta : char; {per rispondere al quesito}
PROCEDURE Istruzioni;
BEGIN
writeln(‘Alla fine della digitazione premere CONTROL Z per chiudere il file)
END;
PROCEDURE CopiaFile(VAR InFile,OutFile: text);
BEGIN
{************* MAIN ********************}
*********************
BEGIN
END;
assign(FileDigitato,’C:/TP/ESEMPI/TESDIG.TXT);
rewrite(FileDigitato);
CopiaFile(input, FileDigitato);
close(FileDigitato);
reset(input); {necessario per alcuni dialetti}
write(‘Copia eseguita. Vuoi rivedere il testo ? S/N’);
readln(Risposta);
IF Risposta IN[‘S’,’s’] THEN
BEGIN
writeln;
reset(FileDigitato);
CopiaFile(FileDigitato,output)
END;
END.
COPIA DI DUE FILE IN UNO
PROGRAM CopiaDueFile(output;Teresa, Giacomo, TerGiac);
VAR
Teresa, Giacomo, TerGiac: text;
PROCEDURE CopiaFile(VAR InFile, OutFile: text);
BEGIN
*******************
END;
BEGIN
assign(Teresa,’C/TP/ESEMPI/TESTO1.txt’);
assign(Giacomo,’C/TP/ESEMPI/TESTO2.txt’);
assign(TerGiac,’C/TP/ESEMPI/TESTO3.txt’);
rewrite(TerGiac);
reset(Teresa);
CopiaFile(Teresa,TerGiac);
writeln(TerGiac);
reset(Giacomo);
CopiaFile(Giacomo,TerGiac);
LETTURA DEL NOME DEL FILE
writeln(‘ FINE’);
DURANTE L’ELABORAZIONE
close(TerGiac)
END.
PROCEDURE ChiamaFile(VAR NomeFile: StringType; VAR UnFile: text);
BEGIN
write(‘ Dammi il nome del file da elaborare: ‘);
readln(NomeFile);
assign(UnFile, NomeFile)
END;
USO DELLA FUNZIONE
eoln
Il valore di default della funzione eoln è il file input, cioè se non
è dichiarato il nome del file, allora la funzione eoln sarà vera quando
battiamo il tasto invio. In questo caso sia per eoln che per read o readln
non è necessario mettere il parametro relativo al file.
Lettura di un rigo di un file carattere per carattere
Senza questa istruzione se c’è un altro
read verrà letto un blank.
WHILE NOT eoln(UnFile) DO
read(UnFile, Carattere)
elabora carattere
readln(UnFile)
{azzera la finestra di lettura}
Alla fine del loop tutti i caratteri del rigo sono stati letti e il carattere eoln
è il nuovo candidato ad essere letto. Questo provoca la lettura di uno
spazio che in realtà non esiste. Per evitare questo si pone readln(UnFile)
ESEMPIO
Contare il numero di caratteri digitati e il numero degli spazi.
ContaSpazi:=0;
Notare che abbiamo usato il file di
ContaCaratteri:=0;
default input.
WHILE NOT eoln DO
BEGIN
read(Carattere);
ContaCaratteri:=ContaCaratteri+1;
IF Carattere = ‘ ‘ THEN
ContaSpazi:=ContaSpazi+1;
END;
readln;
write(‘Il numero di caratteri totali digitati e’’’,ContaCaratteri,
‘di cui ’,ContaSpazi,’ spazi.’);
Leggere caratteri fin quando non si incontra eoln
Carattere  ‘ ‘;
IF NOT eoln(UnFile) THEN
read(UnFile, Carattere);
ELSE
Carattere  ‘ ‘
Trovare il primo carattere diverso da blank
Carattere  ‘ ‘;
WHILE (Carattere =‘ ‘) AND NOT eoln(UnFile) DO
read(UnFile, Carattere);
readln;