fisiere text
DESCRIPTION
fisiere PascalTRANSCRIPT
FIŞIERE TEXT ÎN PASCALStudiu de specialitate
POPESCU MIHAELA - CORINA
Colegiul Naţional “TUDOR ARGHEZI” Tg.- Cărbuneşti, Judeţul Gorj
Studiul de faţă a fost scris pentru a veni în sprijinul elevilor familiarizaţi cu noţiunea
de fişier, dar care consideră că nu înţeleg suficient noţiunile legate de fişiere text şi doresc să
la aprofundeze. Din acest punct de vedere am încercat o cât mai amplă detaliere a acestora.
Noţiunile prezentate sunt cele cuprinse în programa şcolară la disciplina informatică
şi sunt expuse cu ajutorul exemplelor, a reprezentării în memorie, a programelor, etc.
Studiul abordează şi noţiuni adiacente noţiunii de fişier, care apar în document ca
note de subsol sau ca surse bibliografice şi au ca scop abordarea unitară a subiectului analizat.
1. Noţiuni introductive
Rolul unui fişier este de a stoca date , cu ajutorul operaţiilor de citire/scriere.
Fişierul este utilizat din mai multe considerente:
Datele nu mai sunt introduse manual de catre utilizator, sunt preluate
automat, astfel sunt evitate erorile de introducere a datelor, se reduce timpul
de lucru prin sporirea vitezei de execuţie;
Datele pot fi stocate pe termen lung şi pot fi distribuite la terţe părţi;
Pentru a crea un fişier text putem folosi orice editor de texte, fie din mediul integrat1
al limbajului Pascal fie alte editoare, precum Notepad. După ce am creat fişierul cu ajutorul
unui editor , acesta trebuie salvat cu una din extensiile .txt, .in, .out. Dacă fişierul îl creăm în
Free Pascal, salvarea o realizăm astfel:
File -> Save as -> Se introduce de la tastatură: nume_fişier_de _intrare.extensie
(extensia este obligatorie, altfel se salvează cu extensia implicită, .pas).
Modul de lucru cu fişiere este următorul:
se editează fişierul de intrare, din care se vor prelua datele – se salvează în
mod explicit cu una din extensiile permise
se editează fişierul sursă, se compliează şi se rulează
se deschide fişierul de ieşire, în care se vor vizualiza rezultatele de la meniul
File -> Open -> nume_fisier_de_iesire.extensie
1 IDE(eng. Integrated Development Environment) mediu de dezvoltare a programelor pe calculator, aplicaţie care permite editarea , compilarea, depanarea şi execuţia unui program.
În cazul în care datele se citesc de la tastatură şi se afişează pe monitor, modul de
lucru variază, deoarece nu se mai creează fişiere, programul se rulează şi în cadrul rulării se
parcurg etapele:
se introduc datele de la tastatură, asociată cu fişierul standard de intrare
INPUT
se vizulizează rezultatele pe monitor, după încheierea rulării, cu combinaţia
de taste ALT+F5. Monitorul este asociat cu fişierul standard de ieşire,
OUTPUT.
Fişierele de intrare/ieşire nu sunt fişiere care se compilează, spre deosebire de
fişierele sursă, cu extensia .pas, deoarece ele au rolul de a asigua stocarea datelor pe suporturi
externe şi nu de a executa instrucţiuni ca fişierele sursă. Relaţia dintre fişierele I/O şi fişierul
sursă în cadrul fluxului de execuţie a unui program se poate urmări în următoarea schemă:
Fig.1. Flux de execuţie
Pentru a putea fi prelucrat, un fişier trebuie încărcat în memoria de execuţie alocată
programului. Acest lucru se realizează în două etape:
transferarea fişierului într-o zonă tampon din memoria de execuţie alocată, numită
buffer de fişier
preluarea câmpurilor fişierului, din bufferul de fişier, prin intermediul unui pointer de
fişier, în variabila în care se realizează citirea
Aceleaşi etape se parcurg şi pentru scrierea în fişier, numai că în ordine inversă.
2. Structura unui fişier text
Un fişier text este o succesiune de caractere terminată cu combinaţia de caractere ^Z
sau mai este definit ca o structură de date cu conţinut omogen.
Fig.2. Exemplu de fişier text
Un fişier text este alcătuit din caractere, aşezate pe linii( în cazul nostru fişierul are 4
linii ). O linie se numeşte înregistrare sau articol [4].
Liniile, cu excepţia ultimei, se termină cu un marcator de sfârşit de linie – notat
EOLN(End of Line), alcătuit din două caractere: CR(eng. Carriage Return), cu codul ASCII
13 şi caracterul LF(eng. Line Feed ), cu codul ASCII 10, vezi tabelul ASCII [1]. Marcatorul
se introduce în fişier atunci când apăsăm tasta Enter şi este transparent pentru utilizator(adică,
nu este vizibil în fişierul nostru). Marcatorul poate fi văzut la depanarea unui program, adică,
atunci când accesăm direct conţintul unei variabile la rulare. Marcatorul nu poate fi printat.
Pentru a vedea marcatorii de sfârşit de linie şi de fişier, depanăm programul următor:
var f:text;c:integer;caracter:char;
begin
assign(f,'text.in');
reset(f);
c:=0;
while caracter<>#26 do
begin
read(f,caracter);
c:=c+1;
end;
write(c);
close(f);
end.
cu următorul conţinut al fişierului de intrare, text.in:
acesta este un fisier
va fi prelucrat
Vom parcurge etapele:
adăugăm fereastra în care vom urmări conţinutul variabilelor, Debug/Watches
adăugăm variabilele pe care le vom urmări, Debug/Add watch/caracter şi
Debug/Add watch/c, caracter şi c se editează în câmpul Expression to watch
din fereastra Edit watch
variabilele caracter şi c sunt adăugate în fereastra de urmărire - Watches
rulăm pas cu pas, în varianta Run/Trace Into, tasta F7
observăm în fereatrsa Watches conţinutul variabilelor la rulare, respectiv
conţinutul marcatorilor:
Fig.3. Vizibilitatea marcatorilor la depanare
Fiecare linie este alcătuită din câmpuri. Câmpurile pot fi un caracter, un string sau
un număr, în funcţie de conţinutul fişierului şi de modalitatea de prelucrare. Fişierul se
termină cu un marcator de sfârşit de fişier– notat EOF(eng. End Of File) şi anume
caracterul amintit mai sus, ^Z(CTRL +Z) cu codul ASCII 26. Marcatorul de sfârşit de fişier
se poate introduce automat de compilator, sau manual, de utilizator, la crearea unui fişier citit
de la tastatura, cu ajutorul combinaţiei de taste Ctrl+Z.
Programul care creează un fişier citit de la tastatură, este următorul:
var f:text;c:char;
begin
assign(f,'text.out');
rewrite(f);
while not eof do
begin
while not eoln do
begin
read(c);
write(f,c);
end;
writeln(f);
readln;
end;
close(f);
end.
La rulare, pentru a încheia citirea de la tastatură şi implicit execuţia programului,
apăsăm Ctrl+Z.
Campurile sunt despărţite prin separatori, caractere care ajută la distincţia dintre
câmpurile unei linii, cu scopul analizării şi prelucrării valorilor câmpurilor pe care le separă.
Separatorii pot fi spaţiu ,TAB sau CR/LF. Spaţiul se introduce în fişier prin apăsarea tastei
Space. Deoarece spaţiul nu se vede efectiv, mulţi elevi tind să considere că nu există, dar el
trebuie privit ca orice alt caracter. Codul ASCII al caracterului Space este 32. În cazul în care
fişierul prelucrează caractere şi nu prelucrează numere, spaţiul nu se consideră separator de
câmp, este considerat ca un caracter oarecare, deci trebuie tratat corespunzător.
Astfel, în funcţie de cum sunt prelucrate datele din fişier, precum şi de conţinutul
fişierului, apar următoarele situaţii:
a) Dacă datele din fişier sunt prelucrate la nivel de caracter, atunci nu contează
conţinutul acestuia, poate conţine orice tip de caracter(litere, cifre sau caratere
speciale) şi în acest caz caracterul spaţiu nu este separator. Drept consecinţă, nu
putem avea acces la câmpuri, adică nu putem accesa direct campul ‘acesta ’ din
fişierul din Fig.2., el se construieşte prin concatenare, literă cu literă, până se
înâlneşte spaţiu.
Pentru a construi un singur cuvânt, caracter cu caracter, putem folosi secvenţa:
{folosim variabila cuvant pentru a reţine cuvintele construite şi variabila litera, care va
parcurge fişierul}
{iniţializăm cu şirul vid variabilele cuvant şi litera}
cuvant:=’’;
litera:=’’;
while litera<> ‘ ‘ do {cât timp nu am ajuns la spatiu}
begin
read(f,litera); {se citeşte litera din fişier}
cuvant:=cuvant + litera; {se adaugă litera citită la cuvant}
end;
Iar pentru a citi toate cuvintele din fişier vom avea programul care citeşte datele
dintr-un fişier text pe linii, cuvânt cu cuvânt şi le afişează în acelaşi format pe monitor:
program citire_char_var1;
var f:text;c:char;
begin
assign(f,'text.in');
reset(f);
while not eof(f)do
begin
while not eoln(f)do
begin
read(f,c);
write(c);
end;
writeln;
readln(f);
end;close(f);
end.
Programul poate fi scris şi în varianta în care analizăm şi conţinutul separatorilor:
program citire_char_var2;
var f:text;
cuvant:string;
litera:char;
BEGIN
assign(f,'date.txt');
reset(f);
while not eof(f) do {cât timp nu s-a treminat fişierul }
begin
{la începutul fiecărui rând iniţializăm variabila cuvant cu şirul vid, altfel se păstrează ultimul
cuvânt din linia precedentă }
cuvant:='';
{citim prima literă a liniei}
read(f,litera);
{adăugăm litera la cuvant}
cuvant:=cuvant+litera;
{cât timp nu s-a terminat linia(#13) şi nu am ajuns la sfârşitul fişierului}
while (litera<>#13) and not eof(f) do
begin
{citesc următoarea literă}
read(f,litera);
if litera=' ' then
begin
{dacă este spaţiu, inchei cuvântul prin afişare}
write(cuvant,' ');
{deplasez pointerul de fişier la prima literă de după spaţiu}
read(f,litera);
{reiniţializez cuvântul}
cuvant:=litera;
end
else
if litera<> #13 then
{dacă nu am ajuns la sfârşitul liniei, concatenez litera la
cuvânt}
cuvant:=cuvant + litera
else
{ altfel, afişez ultimul cuvânt din linie}
writeln (cuvant);
end;
{deplasez pointerul de fişier pe rândul următor }
readln(f)
end;
close(f);
END.
Fig.4.Execuţia programului citire_char_var2;
Concluzie:
În cazul citirii caracter cu caracter, trebuie să gestionăm caracterele care reprezintă
separatorii, în exemplul nostru spatiul, sfârşitul de linie(numai primul caracter) şi sfârşitul de
fişier, altfel apar erori de citire.
b) Dacă fişierul conţine numai numere, atunci caracterul spaţiu este considerat
separator de camp.
De exemplu, dacă avem fişierul:
Atunci, citirea read(f,x), unde x este o variabilă de un tip numeric, va avea ca efect
depunerea în variabila x a lui 17 , sau 251, sau 10, etc. Şi nu a câte unei cifre din aceste
numere, cum s-ar fi înâmplat dacă x era de tip caracter.
Programul care citeşte datele din acest fişier, şi le afişează pe monitor în acelaşi
format, este:
program citire_nr;
var f:text;x:integer;
begin
assign(f,'numere.in');
reset(f);
while not eof(f)do
begin
while not eoln(f)do
begin
read(f,x);
write(x,' ');
end;
readln(f);
writeln;
end;
close(f);
end.
Fig.5. Execuţia programului citire_nr;
Concluzie:
Un câmp este gestionat ca şi număr numai dacă fişierul conţine numai numere, altfel,
este gestionat ca şir de caractere şi trebuie citit caracter cu caracter.
3. Accesul la datele din fişier
Pentru a întelege modul cum este asigurat accesul la datele din fişier, trebuie să ne
imaginăm fişierul ca pe o foaie de matematică, în care fiecare căsuţă conţine câte un caracter.
Fiecare linie poate conţine maxim 255 de caractere.
1 2 3 4 5 6 7 8 9 1
0
1
1
1
2
13 1
4
1
5
16 17 18 1
9
2
0
2
1
22 23 ....... 255
a c e s t a e s t e u n f i s i e r #13 #10
v a f i p r e l u c r a t #26
Pentru un fişier care conţine n linii, fiecare linie având lungimea Li, numărul de
caractere din fişier este egal cu L1+L2+...Ln+(n-1)*2+1, unde (n-1)*2 reprezintă numărul
marcatorilor de sfârsit de linie(câte 2 pentru fiecare linie, numai n-1 linii au marcator de
sfârşit de linie, iar ultima linie are numai marcator de sfârşit de fişier) şi 1 reprezintă
marcatorul de sfârşit de fişier.
În cazul nostru, numărul de caractere din fişier este 39, deoarece prima linie are
lungimea 21, a doua are lungimea 15, adăugăm 2 marcatori de sfârşit de linie(2*1 linie) şi
marcatorul de sfărşit de fişier.
Programul următor calculează câte caratere, inclusiv marcatorii, există în fişierul de
mai sus:
var f:text;c:integer;caracter:char;
begin
assign(f,'text.in');
reset(f);
c:=0;
while caracter<>#26 do
begin
read(f,caracter);
c:=c+1;
end;
write(c);
close(f);
end.
Observaţie:
Dacă în loc de #26 folosim eof(f), atunci nu se mai numără marcatorul de sfârşit de
fişier, deoarece funcţia eof(f) testează dacă indicatoul de fişier arată către marcatorul de sfârşit
de fişier. Deci, rezultatul în acest caz va fi 38 în loc de 39.
Concluzie:
În cazul general, un fişier text are următoarea structură:
L1 #13 #10
L2 #13 #10
..... ...... .....
Ln-1 #13 #10
Ln #26
Observăm în urma acestui exemplu, ca marcatorul de fişier se numără cu #26 şi se
testează cu eof(f). Am ajuns astfel la a analiza cum sunt prelucrate datele în fişier.
Fişierul text este o structură de date cu acces secvenţial, adică pentru a prelucra un
element oarecare al fişierului, trebuie să le prelucrăm pe toate cele precedente acestuia. Adică,
acesta este
un fisier
pentru fişierul nostru, dacă dorim să-l prelucrăm pe ‘v’ de pe linia 2, trebuie să prelucrăm
toate caracterele până la ‘v’.
Accesul secvenţial se realizează cu ajutorul cursorului de fişier(eng. File pointer)
care reţine, pe parcursul prelucrării fişierului, numărul de ordine al câmpului/caracterului
curent. Prelucrarea datelor dintr-un fişier se realizează prin intermediul
pointerului/indicatorului de fişier, care traversează fişierul, reţinând de fiecare dată poziţia
elementului curent, de exemplu, dacă conţinutul fişierului ar fi:
şi fişierul se prelucrează la nivel de caracter, atunci
indicatorul de fişier va lua succesiv poziţiile elementelor din fişier, de la 0 la 22.
4. Oper
aţii cu fişiere
Prelucrarea informaţiilor dintr-un fişier aflat pe un suport extern se realizează
parcurgând următoarele etape:
furnizarea specificatorului de fişier( calea şi numele fişierului inclusiv
extensia, despărţite prin \ )
declararea unei variabile de tip fişier
asignarea la variabila fişier ( numele logic al fişierului ) a fişierului fizic,
identificat prin specificatorul de fişier
deschiderea fişierului în vederea permiterii accesului la informaţiile din fişier
prelucrarea efectivă a informaţiilor din fişier, prin operaţii de citire/scriere,
ştergere, redenumire
închiderea fişierului
4.1. Declararea unui fişier
Pentru a putea utiliza un fişier într-un program, acesta trebuie declarat astfel:
var f:text;
0 1 2 3 4 5 6 7 8 9 10 11 12
a c e s t a e s t e #13 #10
13 14 15 16 17 18 19 20 21 22
u n f i s i e r #26
se creează de compilator o variabilă de tip înregistrare numită bloc de informaţii FIB( eng.
File Information Block ), care reţine informaţii despre fişier (denumire, poziţia pointerului
buffer-ului de fişier, dimensiune buffer-ului, starea fişierului, etc). Tipul de date TextRec,
definit în unit-ul DOS, defineşte structura FIB:
TextRec =RECORDHandle : WORD;Mode : WORD;BufSize : WORD;Private : WORD;BufPos : WORD;BufEnd : WORD;BufPtr : ^TextBuf;OpenFunc : Pointer;InOutFunc : Pointer;FlushFunc : Pointer;UserData : ARRAY[1...16] OF BYTE;Name : ARRAY[0...79] OF CHAR;Buffer : TextBuf;
END;Pentru a avea acces la informaţiile din FIB pentru un fişier oarecare f, folosim
declaraţia:
uses DOS;
var f:text; fib_f: TextRec ABSOLUTE f;
accesul la câmpurile FIB se fac respectând sintaxa. Fiecare fişier are un bloc FIB
corespunzător, cu ajutorul căruia este prelucrat la execuţie.
4.2. Asignarea unui fişier
Sintaxa:
ASSIGN(f, ‘specificator de fişier’);
unde: f – trebuie să fie o variabilă de tip text
specificator de fişier – structura de foldere, subfoldere, unde se găseşte
fişierul, nume fişier.extensie, de ex: C:\FPC\2.6.2\bin\i386-win32\text.in. Acesta este un
string, deci va fi scris în assign între apostrofuri.
Procedura Assign are ca efect punerea în corespondenţă a variabilei logice f,
declarată în program, cu fişierul fizic existent pe suportul de memorie externă, în blocul FIB
asociat fişierului, în câmpul Name, se scrie specificatorul de fişier. În urma asignării, orice
referire la fişierul fizic în program se realizează numai prin intermediul variabilei f.
4.3. Deschiderea fişierului
Operaţia de deschidere a unui fişier este obligatorie, dacă dorim să prelucrăm datele
din fişier. Efectul operaţiei de deschidere este asocierea unui descriptor de fişier sau handle.
Câmpul HANDLE din blocul FIB este o valoare întreagă care reprezintă identificatorul pentru
fişiere deschise. Valorile 1-7 sunt utilizate pentru dispozitivele standard de I/E (intrare,
ieşire,auxiliar, imprimantă, fişierele în curs de folosire cu comanda PRINT din DOS şi
dereţea). Fişierele deschise ale utilizatorului au valori pentru handle începând cu 8. Fişierele
nedeschise au handle=0.
Un fişier are asociat cursorul de fişier (file pointer) care indică poziţia curentă în
cadrul fişierului. Cursorul de fişier este un întreg care reprezintă deplasamentul (offset-ul) faţă
de începutul fişierului [5].
Operaţia de deschidere se poate realiza în trei variante, în funcţie de scopul pentru
care deschidem fişierul. Câmpul MODE din blocul FIB poate avea valorile FMClosed,
FMInput, FMOutput, în funcţie de starea fişierului, închis, deschis pentru citire, deschis
pentru scriere.
Deschidere pentru citire
RESET(f); - poziţionează cursorul de fişier pe prima poziţie în fişierul de
intrare
Deschidere pentru scriere
REWRITE(f); - dacă fişierul nu există fizic, atunci îl creează, şi poziţionează
cursorul pentru fişierul de ieşire pe prima poziţie;
-dacă fişierul exista anterior, îi şterg conţinutul şi poziţionează
cursorul pentru fişierul de ieşire pe prima poziţie;
Deschidere pentru adăugare
APPEND(f); - deschide fişierul pentru adăugare, poziţionează cursorul de
fişier la sfârşitul fişierului
4.4. Operaţia de citire din fişier
Prin operaţia de citire se realizează transferul fişierului în buffer şi transmiterea
datelor din buffer-ul de fişier în variabila în care se citeşte.
Sintaxa:
READ([f], v1,v2, …,vn);
READLN([f], v1,v2, …,vn);
unde:
f este fişierul din care se preiau datele, f este opţional, dacă citirea se face de
la
tastatură, acesta se poate omite
vi, i=1,n, sunt variabile în care se depun datele citite din f
Efect:
1. Se copiază valoarea curentă din fişier (valoarea spre care indică pointerul de
fişier) şi se depune în v1
2. Se deplasează pointerul de fişier la următorul câmp
3. Se repetă paşii anteriori până se încheie citirea în vi, i=2,n
Readln , are acelaşi efect ca Read, numai că, după ce se termină citirea din fişier,
deplasează pointerul de fişier la începutul rândului următor.
Citirea datelor se realizează cu ajutorul unei variabile, prin intermediul căreia se
preiau datele din fişier, în funcţie de tipul acesteia, citirea din fişier se paote face în 3 variante:
1. Citire la nivel de caracter, cand variabila în care citim este un caracter( vezi
programul citire_char )
2. Citirea numerelor dintr-un text( vezi programul citire_char )
3. Citirea linie cu linie, în acest caz, vom folosi o variabilă de tip string, în care
vom citi. Programul este:
var f:text;
s:string;
begin
assign(f,'date.in');
reset(f);
while not eof(f)do
begin
readln(f,s);
writeln(s);
end;
close(f);
end.
Pentru a întelege efectul citirii, putem exersa pe un număr practic nelimitat de
exemple, astfel:
Exemplu 1( testăm read cu numere )
Se dă secvenţa, în care dorim să citim întregi:
read(a,b);
read(c,d,e);
Se dau de la tastatură valorile, în această ordine:
a) 12 13 14 15 16 17
b) 12
13
14 15 16
c) 12
13
14
15
16
Ce valori vor avea a, b, c, d, e ?
Soluţie:
a) efectul lui Read(a,b) este:
12 se depune în a, pointerul arată către 13
13 se depune în b, pointerul arată către 14, se încheie citirea Read(a,b)
efectul lui Read(c,d,e) este:
14 se depune în c, pointerul arată către 15
15 se depune în d, pointerul arată către 16
16 se depune în e, pointerul arată către 17, se incheie citirea, şi valoarea 17
rămâne necitită
b) efectul lui Read(a,b) este:
12 se depune în a, se ignoră marcatorul EOLN, pointerul arată către 13
13 se depune în b, se ignoră marcatorul EOLN, pointerul arată către 14, se
încheie citirea Read(a,b)
efectul lui Read(c,d,e) este:
14 se depune în c, pointerul arată către 15
15 se depune în d, pointerul arată către 16
16 se depune în e, se incheie citirea
c) efectul lui Read(a,b) este:
12 se depune în a, se ignoră marcatorul EOLN, pointerul arată către 13
13 se depune în b, se ignoră marcatorul EOLN, pointerul arată către 14, se
încheie citirea Read(a,b)
efectul lui Read(c,d,e) este:
14 se depune în c, se ignoră marcatorul EOLN, pointerul arată către 15
15 se depune în d, se ignoră marcatorul EOLN, pointerul arată către 16
16 se depune în e, se incheie citirea
Programul de test este următorul:
var a,b,c,d,e:integer;
begin
read(a,b);
read(c,d,e);
write(a,' ',b,' ',c,' ',d,' ',e);
end.
Concluzie:
Dacă citim numere observăm că Read ignoră marcatorii de sfârşit de linie, caută să-
şi completeze variabilele în care se citeşte, Space este tratat la fel ca Enter. Indiferent cum
este structurat fişierul de intrare, citirea se încheie numai după ce s-au completat toate
variabilele v1,... vn, altfel nu se incheie.
Exemplu 2( testăm read cu char )
Se dă secvenţa, în care dorim să citim caractere:
read(a,b);
read(c,d,e);
Se dau de la tastatură valorile, în această ordine:
a) a n a a r e m e r e
b) a
n
c) a
n a a r e
Ce valori vor avea a, b, c, d, e ?
Soluţie( unde SP este space):
a) efectul lui Read(a,b) este:
‘a’se depune în a
‘ SP’ se depune în b
efectul lui Read(c,d,e) este:
‘n’ se depune în c
‘SP’ se depune în d
‘a’ se depune în e
b) efectul lui read(a,b) este:
‘a’se depune în a
#13 se depune în b
efectul lui Read(c,d,e) este:
#10 se depune în c
‘n’ se depune în d
#13 se depune în e
c) efectul lui read(a,b) este:
‘a’se depune în a
#13 se depune în b
efectul lui Read(c,d,e) este:
#10 se depune în c
‘n’ se depune în d
‘SP’ se depune în e
Programul de test este următorul:
var a,b,c,d,e:char;
begin
read(a,b);
read(c,d,e);
writeln('a=',a);
writeln('b=',b);
writeln('c=',c);
writeln('d=',d);
writeln('e=',e);
end.
Concluzie:
Dacă citim caractere observăm că Read nu ignoră marcatorii de sfârşit de linie.
Dacă dorim să citim valori de tipuri diferite trebuie să folosim readln în loc de read,
altfel apare eroarea I/O cu numărul 106 - invalid number. În acest caz programul de test este:
var a,c:integer;b,d,e:char;
begin
readln(a);
readln(b);
readln(c);
readln(d);
readln(e);
writeln('a=',a);
writeln('b=',b);
writeln('c=',c);
writeln('d=',d);
writeln('e=',e);
end.
Exemplu 3( testăm readln cu numere )
Se dă secvenţa, în care dorim să citim întregi:
read(a,b);
readln(c,d,e);
read(f,g);
Se dau de la tastatură valorile, în această ordine:
d) 12 13 14 15 16 17 18
19 20 21 22
e) 12
13
14 15 16 17 18 19
20
21
f) 12
13
14
15
16
17
18
Ce valori vor avea a, b, c, d, e , f, g?
Soluţie:
d) Rezultatul va fi: 12, 13, 14, 15, 16, 19, 20
e) Rezultatul va fi: 12, 13, 14, 15, 16, 20, 21
f) Rezultatul va fi: 12, 13, 14, 15, 16, 17, 18
Exemplu 4( testăm readln cu char )
Se dă secvenţa, în care dorim să citim caractere:
read(a,b);
readln(c,d,e);
read(f,g);
Se dau de la tastatură valorile, în această ordine:
d) ana are mere
si pere
e) a
na are
mere
Ce valori vor avea a, b, c, d, e, f, g ?
Soluţie:
d) Rezultatul va fi: a=’a’; b=’n’; c=’a’; d=’SP’; e=’a’; f=’s’; g=’i’
e) Rezultatul va fi: a=’a’; b=’#13’; c=’#10’; d=’n’; e=’a’; f=’m’; g=’e’
4.5. Operaţia de scriere în fişier
Prin operaţia de scriere se realizează transferul datelor din variabila în care se scrie în
buffer-ul de fişier, şi din buffer în fişierul de ieşire.
Sintaxa:
WRITE([f], e1,e2, …,en);
WRITELN([f], e1,e2, …,en);
unde:
f este fişierul în care se depun datele, f este opţional, dacă scrierea se face pe
monitor, acesta se poate omite
ei, i=1,n, sunt expresii al căror valori se depun în f
Efect:
1. Se evaluează expresia e1 şi rezultatul obţinut se scrie în f
2. Se deplasează pointerul de fişier la sfârşit
3. Se repetă paşii anteriori până se încheie scrierea tuturor expresiilor ei, i=2,n
Writeln , are acelaşi efect ca Write, numai că, după ce se termină scrierea în fişier,
inserează un maractor de sfârşit de fişier şi scrierea se va continua pe rând nou.
4.6. Fişiere standard
Fişierele implicite care asigură schimbul de date cu exteriorul se numesc fişiere
standard de intrare/ieşiere, care au asociate variabilele de tip text INPUT, respectiv
OUTPUT, declarate în unit-ul System. Dacă se omite f din instrucţiunile de citire/scriere,
atunci acestea sunt echivalente cu:
READ / READLN(v1,v2, …,vn); READ / READLN(INPUT,v1,v2, …,vn);
WRITE / WITELN(e1,e2, …,en); WRITE / WITELN(OUTPUT,e1,e2, …,en);
Fişierul Input este asociat cu tastatura iar fişierul Output este asociat cu monitorul.
BIBLIOGRAFIE
1. Tabel ASCII, http://www.asciitable.com/, accesat 2014
2. Pointer de fişier, http://software.ucv.ro/~mburicea/luc5p09.html, accesat 2014
3.Tutorial Pascal în limba engleză
http://www.baskent.edu.tr/~tkaracay/etudio/ders/prg/pascal/PasHTM1/pas/pasles01.html , accesat 2014
4. Tehnici de programare /Grigore Albeanu, Luminiţa Rîpeanu,Luminiţa Radu, Alexandru Averian. -
Bucureşti: Editura Fundaţiei România de Mâine, 2003
5. Descriptori de fişier http://cursuri.cs.pub.ro/~so/index.php?section=Laboratoare&file=02.%20Operatii
%20IO%20simple, accesat 2014