Newsgroup: it.comp.lang.pascal
Titolo: Input da FILE: URGENTE!!!!!

Fra pochissimo ho un esame di informatica....
Vi prego rispondetemi:
Se il testo dell' esame dice:
"siano assegnati CON LETTURA DA FILE O DA TASTIERA un insieme di cifre
ottali ed un insieme di interi, di cardinalità assegnate....."
Come faccio in pascal ad avere input da FILE?
Nel programma devo introdurre una domanda che faccia scegliere il metodo di
input o no?
Se l'input deve essere da file, come si fa ad indicare il file,ovvero se il
programma deve dire:
----PREMI
1 PER INSERIRE I VALORI DA TASTIERA
2 PER INSERIRE I VALORI DA FILE
se si sceglie 2 , come si indica poi il percorso del file al programma?
SCUSATE L'IGNORANZA.....Ma vi prego rispondete,
CIAO
Davide.

se si sceglie 2 , come si indica poi il percorso del file al programma?
.
.
var f : file of integer ;
    n : string ;
    a : array [1..100] of integer ;
    i : integer ;
.
.
.
write ( 'come si chiama il file ? ' ) ;
readln ( n ) ;
assign ( f, n ) ;
reset ( f ) ;
i := 1 ;
while not eof ( f ) do read ( f, a[i] ) ;
close ( f ) ;
.
.

 
....
GRAZIE ,
vorrei solo sapere un' ultima cosa e poi non rompo più:
quando si scrive su un file con il pascal si deve sempre scrivere rewrite
che cancella tutto o c'è un modo per scrivere i dati accodandoli a quelli
preesistenti su un file?
ciao
p.s. dov'è la vostra faq?

p.s. dov'è la vostra faq?
Non c'e' ;)

*** Questo funziona nel caso  il file di input sia un file tipizato di
interi del Turbo pascal ***
Type
   FInt = File Of integer ; (*o quello che ti occorre*)
Var
    InputFile : FInt;
Procedure InputDaFile ( Var F: FInt );
Var
    Path : String;
    Errore : Integer;
Begin
(* questo se vuoi consentire all'utente di scegliere il file, altrimenti
imposta tu un valore a path e definiscila come costante anzichè come
variabile*)
  WriteLN('Inserisci il path e il nome del file ' +
                        'da considerare come input :');
  ReadLn ( Path );
  Assign ( F, Path );
  {$I-}
  Reset ( F );
  {$I+}
  Errore := ErrorLevel;
  If Errore <> 0
    Then If Errore = 2
                Then Write ( 'Il path o il nome del file sono errati ! ');
                Else Begin
                    Write ('Errore imprevisto nella gestione del file, ' +
                                    'il programma verrà terminiato !');
                    ReadLn;
                End;
  Close ( F );
End;
Function LeggiInputDaFile ( Var F : FInt; Pos : Longint ) : Integer;
(* Pos va da 1 a n *)
Var Buffer : Integer;
Begin
  {$I-}
  Reset ( F );
  {$I+}
  If ErrorLevel <> 0
    Then Begin
        Write ('Errore nell'apertura del file !');
        Write ('Il programma verrà terminato' );
        ReadLn;
        Halt ( 1 );
    End;
  Seek ( F, Pos - 1 );
  Read ( F, Buffer );
  Close ( F );
  LeggiInputDaFile := Buffer;
End;

l' APPEND per quanto ne so funziona solo con i file di testo.
E' sufficiente aprire il file pozionarsi sull'ultimo elemento, leggerlo e
iniziare a scrivere.
ES :
Reset ( f );
Seek ( F, filesize ( f ) - 1 );
la seek lavora da 0 a n-1, la filesize conta da 1 a n.
Inoltre la seek, si posta sulla posizione voluta ma senza leggerla,allora
per non perderla devi spostarti a quella successiva leggendola, perchè nel
caso l'elemento sia l'ultimo si genera un errore in quanto la posizione
sulla quale si vorrebbe andare non esiste.
read( F, bufferfile );
Write ( F, nuovodato );
close( f );
per eliminare tutti gli elementi da una determinata posizione basta
posizionarsi su di essa, leggerla e poi usare la funzione
truncate ( file );
ES:
Reset ( f );
Seek ( F, posizione_da_cui_cancellare );
(* tieni sempre presente che la seek comincia a contare da 0 quindi
se hai nel file 100 e vuoi cancellare gli ultimi 20, le posizioni vanno da 0
a 99 perciò posizione_da_cui_cancellare = 80. se ti posizioni sulla 79
dovrai poi leggerla per non perdere l'80esimo elemento.*)
truncate ( F );
close( f );
scusate per il mio essere prolisso.
Bye

>> 3) Chiudi il file mediante la variabile (procedura "Close") ;
Ma è proprio necessario chiudere il file ?
Perchè di solito si chiude?
______________________________
e-mail:  
Aur...@hotmail.com
ICQ:     16005054

 
......
Più che prolisso sei stato molto chiaro e utile;)
GRAZIEEEE

sulla quale si vorrebbe andare non esiste.
Non e' vero.
Non e' necessario leggere l'ultimo elemento.
Seek lavora con le posizioni da 0 a n.
Se si vuole aggiungere un record a un file bisogna utilizzare 
Seek ( f, filesize ( f ) ) ;
write ( f, record ) ;

Perchè di solito si chiude?
Per svuotare eventuali buffer utilizzati per la scrittura e perche'
ogni sistema operativo puo' gestire un numero limitato di file aperti.

Seek ( F, filesize ( f ) - 1 );
Leggendo questi post ho capito di saperne ben poco di File e procedure
connesse...
A cosa serve la procedura Seek ?......e filesize ?



non c'e' :-)
bye!
-- 
Emanuele Cesena                 
http://www.penguinpowered.com/~ecesena
ece...@penguinpowered.com
                 Attenti all'antispam NOSPAM
"Se c'e'una possibilita' che varie cose vadano male, quella che causa il
danno maggiore sara' la prima a farlo", corollario 1 alla legge di Murphy

A cosa serve la procedura Seek ?......e filesize ?
Seek serve a spostare il puntatore del file su una certa posizione.
FileSize restituisce la dimensione in byte del file.

Io, ho provato diverse volte e il programma e sempre incappato, nella
lettura oltre il limite, o sono sfigato o c'era qualcosa che non andava nel
compilatore. Poi non ho più tentato, visto che anche i professori mi
dicevano che non era possibile. Poi non so.
Bye

seek serve per posizionarsi dove si vuole all'interno del file
es: ho 10 record voglio leggere il 5 farò una SEEK ( F, 4 ), funziona solo
con i file tipizati e non con quelli di testo (TEXT)
Filesize restituisce la posizione la dimensione del file, non inteso come
numero di byte occupati, ma come numero di registrazioni presenti.
Es:
F=file of record dove il record è di 200 byte.
se nel file ci sono 20 record, filesize (f ) restituisce 20, non 4000.
Bye

FileSize restituisce la dimensione in byte del file.
Se il file e' stato impostato con un tipo byte allora e' giusto.
Se il file contiene un insieme di record, allora restituisce il numero
di record.
Bye.
Joseph Parrello.

compilatore. 
Nella *lettura* e' cosi'.
Cioe' se ti posizioni con Seek ( f, filesize ( f ) ) e compi un Read()
e' ovvio che il programma si inceppi, in quanto non esiste nulla oltre
il limite che si possa leggere.
Ma per la *scrittura* non e' cosi'.
Per aggiungere dei dati al file devo proprio posizionarmi oltre il
limite perche' e' li' che voglio andare a scrivere.

di record.
Bravo Parrello, vedo che sei attento... quest'anno quasi quasi ti
promuovo ;)...

dicevano che non era possibile. Poi non so.
Be', lungi da me fare l'avvocato difensore del Laforgia [si aprirebbe
il cielo :-)))], pero' penso che abbia ragione, anche perche',
scherzetto, la cosa e' documentata ampiamente dall'help in linea del
Turbo Pascal nell'istruzione "seek".
Bye.
Joseph Parrello.

Sicuramente avrete ragione, puň essere che nel Pascal standar non funziona ?
Se cosě fosse ecco spiegato il prechč della rottura da parte del professore
in quanto, si noi programmiamo in turbo pascal, ma lei nella teroria dice
che noi non dobbiamo considerare un ragionare come se ci trovassimo con un
qualsiasi altro linguaggio, quindi a livello logico deve comunque funzionare
in ogni ambiente.
Se mi smentite anche questo, guiro che la prof. la uccido subito dopo gli
esami.
Grazie mille, ciao.

esami.
Il fatto di attenersi allo standard del linguaggio e' ovvio.
Non so se lo standard del linguaggio preveda una funzione Seek(), ma
comunque il principio e' lo stesso a livello standard, ovvero se il
file ha questa struttura :
Posizioni :   0   1   2   3   4  
Record    : | A | B | C | D |   |
La lunghezza del file e' di n = 4 record.
Nel caso mi mettessi sulla posizione n = 4  e tentassi di leggere,
incapperei in un errore, in quanto non c'e' nulla in quella posizione
da poter leggere.
Quindi in questo caso e' giusto che io mi possa spostare soltanto tra
0 e n-1, ovvero tra 0 e 3.
Mentre per la scrittura, nel caso volessi aggiungere elementi al file,
devo proprio posizionarmi sulla posizione n = 4 e scrivere.
In questo caso e' giusto che io mi possa spostare tra 0 e n, ovvero
tra 0 e 4.

Grazie mille, la prof č morta, figurati all'inizio lo facevo poi, secondo
quello che ho giŕ detto e il fatto che lo ritenesse un errore di
programmazione, ho smesso completamente di farlo e di verifacare se fosse
vero.
Bye

in ogni ambiente.
Beh, a questo punto buttate via il Turbo Pascal e dedicatevi al C. Il
Turbo Pascal e' nato col DOS, il C e' multipiattaforma. E' chiaro che
l'istruzione Seek e' dedicata al mondo del DOS. Se hai il Turbo
Debugger puoi benissimo leggerti il codice oggetto dell'istruzione
Seek e vedere che non e' altro che una banale chiamata all'INT21. Il
Turbo Pascal basa buona parte della gestione dell'I/O sul DOS, con
tutti i limiti e le potenzialita' di quest'ultimo. Se il Seek ha degli
effetti indesiderati, cio' e' da ricondurre a degli errori del DOS,
comunque leggibili e verificabili tramite la funzione IOResult. A me
personalmente sta' un po' sullo stomaco il fatto che le istruzioni che
hanno a che fare con l'I/O in Turbo Pascal siano procedure e non
funzioni. In C, dove non esiste il concetto stretto di procedura,
tutte le istruzioni per l'I/O restituiscono un valore che permette
immediatamente di controllare il buon esito di una funzione. In TP va'
effettuato un passaggio in piu' (anzi in alcuni casi piu' di uno visto
che spesso vanno inserite le direttive $I- ... $I+) leggendo proprio
il valore di IOResult. Ti puoi immaginare gli effetti disastrosi che
possono capitare ad un programma se una funzione sull'I/O non ha
funzionato come doveva. E' utile prevenire in tempo quindi altre
pericolose situazioni che possono portare al blocco del sistema, al
danneggiamento di file, e altro.
Saluti.
Joseph Parrello.

danneggiamento di file, e altro.
Questa non l'ho capita.
Il TP ti da' modo di intercettare gli errori proprio disabilitando le
routine di segnalazione d'errore di runtime predefinite, tramite
{$I-}.
Non vedo in quali "effetti disastrosi" un programma possa incappare.