1. Fişiere.

1.1. Fişiere Pascal.

Fişierul poate fi considerat o colecţie de date stocate pe un suport extern (în general
magnetic) unde pot fi păstrate atâta timp cât este necesar. Un fişier este format dintr-o
succesiune de elemente (înregistrări sau articole numerotate de la 0, alcătuite la rândul lor din
câmpuri) având toate acelaşi tip, care constituie tipul de bază al fişierului. Transferul
informaţiilor între memoria internă şi cea externă (fişier) se realizează la nivel de articol.
Pentru aceasta, în memoria internă va trebui să declaram o variabilă având acelaşi tip cu tipul
înregistrărilor fişierului iar prin operaţiile de intrare/ieşire (Read/Write) se va realiza ctitirea
din, respectiv scrierea în, fişier.
Accesul la componentele
unui fişier poate fi secvenţial sau Art. F Write
direct. În acces secvenţial, 0 Memoria
1
articolele sunt prelucrate 2 Articol internă
(accesate) succesiv (unul după 3
altul), începând cu primul pană la Read
ultimul (Art.0, Art.1,...,Art.n-1).
Dacă în cazul accesului secvenţial ordinea de transfer a înregistrărilor este dată de
ordinea acestora în fişier, acessul direct permite transferul în orice ordine (aleator) prin
precizarea numărului de ordine din cadrul fişierului (0,1,...,n-1 , dacă fişierul are n articole).
În vederea prelucrării, fişierul va trebui deschis iar la terminarea operaţiilor fişierul va
trebui închis. La deschiderea fişierului, indicatorul (capul de citire-scriere) este poziţionat pe
prima componentă. Indicatorul se deplasează automat cu o poziţie spre sfârşit, la fiecare
operaţie de scriere sau citire din fişier.
Deschiderea unui fişier (pregatirea lui pentru lucru) se face în doua etape. În primul
rând va trebui să precizăm ce fişier se deschide (se face asocierea între variabila fişier şi
specificatorul de fişier, corespunzator fişierului dorit) utilizănd procedura Assign
(Variabila_Fişier, Specificator_Fişier). Acestă asociere fiind facută, de acum înainte vom
utiliza doar Variabila_Fişier pentru a referi fişierul de lucru (pe care o vom nota în continuare
mai simplu cu F ). Deschiderea propriuzisă se va efectua prin apelul procedurii Rewrite(F)
sau Reset(F) după cum fişierul care va fi deschis urmează să se creeze sau să se consulte .
Operaţiile de intrare / ieşire sunt Read(F,Art) respectiv Write(F,Art) unde am notat
prin Art variabila din memoria internă (declarată în program) în , sau din care se face
transferul din/în fişier. După terminarea operaţiilor de transfer, fişierul poate fi închis prin
Close(F). O functie utilă în programele care lucrează cu fişiere este funcţia booleană Eof(F)
care ne spune dacă s-a ajuns la sfârşitul fişierului (dacă a fost detectată marca de sfârşit de
fişier). În programele Pascal este posibilă ştergerea unui fişier apelând procedura Erase(F).
De asemenea, este posibilă schimbarea numelui unui fişier în timpul execuţiei unui program.
Această redenumire se poate realiza prin apelul Rename(F, Noul_Specificator_de_Fişier).
 1.2. Utilizarea fişierelor text.

Conţinutul unui fişier text poate fi înţeles ca un text dintr-o carte, organizat pe un
număr de linii compuse din caractere (rânduri de tip string). Într-un fişier text sfârşitul fiecărei
linii este marcat prin două caractere speciale CR (de la Carriage Return) şi LF (de la Line
Feed). Avantajul folosirii acestor fişiere constă în faptul că ele se pot vizualiza din Norton
Commander sau Turbo Pascal şi chiar pot fi corectate folosind funcţia de editare a acestora.
Declararea unui fişier text se realizează simplu prin scrierea cuvântului cheie Text.
De exemplu :
Var f, g : Text;
Citirea datelor dintr-un fişier text se poate efectua prin apelul procedurii :
Read (F, Listă_Var_Intrare); sau Readln(F, Listă_Var_Intrare);
transferul făcându-se din fişierul F , în aceeaşi manieră ca şi de la tastaură.
Scrierea datelor într-un fişier text se poate efectua prin apelul procedurii :
Write(F,Listă_Expresii_Ieşire); sau Writeln(F Listă_Expr._Ieşire);
scrierea făcându-se în fişierul F ca şi pe ecran.
Un prim exemplu îl constituie o procedură care citeşte o matrice (dimensiunile şi
valorile acesteia) dintr-un fişier text. Considerăm că aceste date sunt organizate în fişierul
‘Matrice.Txt’ astfel :
- primul rând conţine numărul de linii şi numărul de coloane (m şi n),
- următoarele m rânduri conţin valorile corespunzatoare fiecărei linii ale matricei.
Procedure Cit_Mat (Var A :matrice; Var m,n : Integer);
Var i, j : Integer; F : Text;
Begin
Assign (F,’Matrice.Txt’); Reset (F);
Readln (F,m,n);
For i:=1 To m Do
For j:= 1 To n Do
Read (F,A[i,j]);
Close (F)
End;

Următorul exemplu este un program Pascal care traduce un text aflat într-un fişier
conform unui dicţionar (care se află stocat într-un fişier text având numele ‘Dictio.Txt’).
Dicţionarul este compus dintr-un şir de perechi de cuvinte de forma (St,Dr) şi se
construieşte citind câte un rând de forma Stânga=Dreapta din fişierul text.
De exemplu, conţinutul fişierului ‘Dictio.Txt’, tipărit în continuare, poate “traduce”
un Program Pascal.

Program=Algoritmul
Readln=Date
Read=Date
Writeln=Rezultate
Write=Rezultate
For=Pentru
Do=Executa
Repeat=Repeta
Until=Pana_Cand
While=Cat_Timp
End.=Sfarsit.
...

1
 Pentru a realiza o traducere, se citeste câte un rând din fişierul iniţial, se traduce
conform dicţionarului, după care se depune (rândul tradus) în fişierul final (tradus).
Traducerea unui rând se execută astfel : se ia fiecare cuvânt din dicţionar (aflat în
partea stangă) şi se verifică dacă acesta se află în rândul curent. Dacă da, atunci se va
înlocui în rând cuvântul găsit cu perechea acestuia (partea dreaptă din dictionar).
Programul Pascal este următorul :
Program Traducere_Text;
Const Mc = 100;
Type Sc = String[10]; Rd = Record St, Dr : Sc End; { (St,Dr) }
Var Fis, Tra, Dic : Text; Numei,Numef : String[20];
Dict : Record Nrc : Byte; { Numarul de cuvinte din dictionar }
Cuv : Array [1..Mc] Of Rd
End;
Rând : String; { un rând din dictionar de forma St = Dr }
p,i : Integer; { p memoreaza pozitia semnului = în Rând }

Begin { ( delimiteaza partea stanga de partea drepta) }

Assign (Dic,'Dictio.Txt'); Reset (Dic); { Deschide Dictionarul }
With Dict Do Begin { Constr. Dictionarul în memorie în variabila Dict.}
Nrc:=0;
While Not Eof(Dic) Do Begin
Readln (Dic,Rând); p:=Pos('=',Rând); { Cuv[Nrc] → Dict }
Nrc:=Nrc+1;
With Cuv[Nrc] Do Begin
St:=Copy(Rând,1,p-1); { St := ... p }
Dr:=Copy(Rând,p+1,Length(Rând)-p) { Dr := p ... }
End
End
End;

Write (' Numele fişierului de tradus : '); Readln (Numei); { Fiş. de tradus }
Write (' Numele fişierului rezultat : '); Readln (Numef); { Fiş. tradus }
Assign(Fis, Numei); Reset (Fis); { Deschide fişierele }
Assign(Tra, Numef); ReWrite(Tra);
While Not Eof(Fis) Do Begin
Readln (Fis,Rând);
With Dict Do { Traduce Rând }
For i:=1 To Nrc Do With Cuv[i] Do
Repeat
p := Pos (St,Rând);
If p>0 Then Begin { Exista cuvantul St în Rând ? }
Delete (Rând,p,Length(St)); { Inlocuieste St cu Dr }
Insert (Dr,Rând,p)
End
Until p = 0;
Writeln(Tra,Rând) { Scrie Rând-ul tradus }
End;
Close (Fis); Close (Tra) { Inchide fişierele }
End.

2
 11.3. Fişiere cu tip

Declararea unui fişier se realizează astfel :

<Fişier> ::= File Of <Tip_bază>

unde <Tip_bază> este tipul de bază al fişierului (tipul inregistrărilor), ca în exemplul următor:

Type Student = Record

Nr_Leg : Word;
Nume : String [25];
Medie : Real
End;

Var F_Stud : File Of Student ;

Un_Stud : Student;

Pentru fişierele cu tip mai există câteva funcţii şi proceduri utile, pe care le prezentăm
în continuare :
• Funcţia FileSize (F) returnează numărul articolelor fişierului F ;

• Procedura Seek (F,n) poziţionează indicatorul din fişierul F la începutul componentei cu

numărul n (poziţia primei componente este 0) ;
• Funcţia Filepos (F) returnează poziţia curentă a indicatorului în fişierul F .

11.4. Operaţii cu fişiere.

Principalele operaţii asupra fişierelor sunt :

• Creere (generarea unui fişier, care se execută o singură dată, când ia fiinţă fişierul),
• Actualizare (corectarea fişierului, punerea la punct în cazul în care datele nu sunt corecte sau
nu mai sunt actuale), şi
• Listare (etapa finală de obţinere a rezulatatelor, a situaţiilor finale).

Actualizarea fişierelor poate fi efectuată secvenţial (articol după articol) sau direct
(aleator, precizând numărul de ordine al unui articol). În operaţia de actualizare se poate
efectua :
• Adăugarea de noi articole,
• Modificarea unor articole (prin modificări de câmpuri ale acestora), sau
• Stergerea de articole.

Operaţiile descrise anterior vor fi exemplificate în cele ce urmează prin programe

Pascal.

În exemplul următor se doreşte creerea Nr_Leg Nume Medie

fişierului ‘Grupa111.Dat’, cu articole de forma: Word String[25] Real
Pentru a crea acest fişier, se citeşte de
la tastatură câte un articol (care conţine .........
.........
......... Creere
informaţiile despre un student) apoi acesta se Grupa111.Dat
scrie în fişier.

Program Cre_Fis;
Type Student = Record Nr_Leg : Word; Nume : String [25]; Medie : Real End;

3
Var F_Stud : File Of Student; Un_Stud : Student;
Function Citit(Var Un_Stud:Student):Boolean; { Citeste un articol }
Begin With Un_Stud Do Begin
Write (' Numele st.: '); Readln (Nume);
If Nume='' Then Citit:=False Else Begin Citit:=True;
Write (' Nr.Leg. , Medie : '); Readln(Nr_Leg,Medie)
End End
End;
Begin
Assign (F_Stud,'Grupa111.Dat'); ReWrite(F_Stud);
While Citit(Un_Stud) Do Write(F_Stud,Un_Stud);
Close (F_Stud)
End.

Următorul program realizează listarea (tipărirea articolelor) fişierului Grupa111.Dat pe

ecran.
Pentru a tipări acest fişier, se ... .......... ....
citeşte din acesta câte un articol, apoi Grupa111.Dat Listare ... .......... ....
... .......... ....
acesta se afişează pe ecran :

Program Lis_Fis;
Type Student = Record Nr_Leg:Word; Nume:String [25]; Medie:Real End;
Var F_Stud : File Of Student; Un_Stud : Student;

Function Sp(s:String; n:Byte):String; { Adauga (n-|s|) spatii daca |s|<n }

Begin
While Length(s)<n Do s:=s+' '; Sp:=s
End;

Procedure Tipar (Un_Stud : Student); { Tipareste un articol pe ecran}

Begin With Un_Stud Do
Writeln (FilePos(F_Stud):3,Nr_Leg:9,Sp(Nume,26):28,Medie:7:2);
End; { Tipareste Nr.Crt., Leg, Nume, Medie.}

Begin
Writeln ('Nr.Crt. Nr.Leg.',Sp(' Nume',28),'Medie '); Writeln; { Cap tabel }
Assign (F_Stud,'Grupa111.Dat'); ReSet(F_Stud);
While Not Eof(F_Stud) Do Begin
Read (F_Stud,Un_Stud);
Tipar(Un_Stud) End;
Close (F_Stud); Readln
End.

Următoarele exemple sunt

dedicate actualizării fişierului ...............
...............
................. Actualizare
‘Grupa111.Dat’. Pentru aceasta, se citesc Grupa111.Dat
de la tastatură datele (care conţin
informaţiile necesare actualizării)
conform cărora se corectează fişierul.
Prima operaţie (de actualizare a fişierului), descrisă în continuare este modificarea,
prin care se urmăreşte corectarea mediei. În cazul în care se doreşte ca această operaţie să fie
efectuată pentru toţi studenţii, secvenţial, atunci se citeşte din fişier fiecare articol, se modifică
media (se introduce de la tastatură noua medie) apoi se rescrie în fişier articolul modificat.
Pentru că după o citire indicatorul de fişier avansează la noul articol (se poziţionează
pe următorul articol) trebuie să readucem acest indicator (apelând procedura Seek) la începutul
ultimului articol citit (care se afla pe pozitia p-1, iar pozitia curentă p se poate afla apelând
funcţia FilePos).
4
Program Mod_Secv_Fis;
Type Student=Record Nr_Leg:Word; Nume:String[25]; Medie:Real End;
Var F_Stud : File Of Student; Un_Stud : Student;

Function Sp (s : String; n : Byte) : String;

Begin While Length(s)<n Do s:=s+' '; Sp:=s End;

Procedure Modific (Var Un_Stud : Student); { Mod. media unui student }

Begin With Un_Stud Do Begin
Write (Nr_Leg:6,Sp(Nume,26):28,' Media : ');
Readln(Medie) End
End;

Begin
Writeln (' Nr.Leg.',Sp(' Nume',28),'Medie '); Writeln;
Assign (F_Stud,'Grupa111.Dat'); ReSet(F_Stud);
While Not Eof(F_Stud) Do Begin
Read (F_Stud,Un_Stud);
Modific (Un_Stud);
Seek (F_Stud,FilePos(F_Stud)-1); { repozitioneaza }
Write (F_Stud,Un_Stud) End; { pentru a rescrie crect }
Close (F_Stud); Readln
End.
Dacă se doreşte ca această operaţie să nu fie efectuată pentru toţi studenţii, ci doar
pentru câţiva, este mult mai eficient să se precizeze pentru fiecare student, pentru care se
doreşte modificarea mediei, numărul de ordine al acestuia (poziţia p a articolului din cadrul
fişierului (0,1,...,n-1).
Cunoscând această poziţie, se va citi articolul aflat pe poziţia p ( Seek(Fis,p);
Read(Fis,Art) ), se vor modifica anumite câmpuri ale articolului citit, apoi se va rescrie
articolul modificat pe aceeaşi poziţie p (Seek (Fis,p); Write (Fis,Art) ), aşa cum se poate vedea
în exemplul prezentat în continuare.
Program Mod_Directa_Fis; { Access Random }
Type Student = Record ... End;
Var F_Stud : File Of Student; Un_Stud : Student;
Nr_Crt : Integer; { Nr. de ordine = 1,...,n }
Function Sp (s : String; n : Byte) : String;
Begin While Length(s)<n Do s:=s+' '; Sp:=s End;
Procedure Modific (Var Un_Stud : Student);
Begin With Un_Stud Do Begin
Write (Nr_Leg:6,Sp(Nume,26):28,' Media : '); Readln(Medie) End
End;
Begin
Writeln (' Nr.Leg.',Sp(' Nume',28),'Medie '); Writeln;
Assign (F_Stud,'Grupa111.Dat'); ReSet(F_Stud);
Repeat
Write (' Nr.Crt.:'); Readln (Nr_Crt);
If Nr_Crt>0 Then Begin
Seek (F_Stud,Nr_Crt-1); Read (F_Stud,Un_Stud); {p=Nr_crt-1}
Modific (Un_Stud);
Seek (F_Stud,Nr_Crt-1); Write (F_Stud,Un_Stud) End;
Until Nr_Crt=0;
Close (F_Stud)
End.
Atât pentru ştergerea de articole dintr-un fişier cât şi pentru adăugarea de noi articole
este necasară utilizarea unui fişier temporar, aşa cum se poate vedea în figura următoare:
...............
...............
.................

Ştergere / 5
Grupa111.Dat Adăugare Grupa111.Tmp
 Dacă se doreşte ştergerea aleatoare a unor articole din fişier, numărul curent al acestor
articole va fi introdus de la tastatură. Aceste articole vor fi omise la copierea articolelor din
fişierul iniţial (‘Grupa111.Dat’) în fişierul temporar (‘Grupa111.Tmp’).
Pentru ca fişierul actualizat să poarte acelaşi nume iniţial, se va proceda astfel: fişierul
iniţial se şterge (Erase(Fis_Vechi)) iar fişierul final se va redenumi
(Rename(Fis_Temporar,Nume_Fişier)) aşa cum se poate vedea în exemplul următor.

Program Stergere_Directa_Fis; { Access Random }

Type Student = Record ... End;
Var F, G : File Of Student;
Un_Stud : Student;
Nr_Crt : Integer;
Function Sp (s : String; n : Byte) : String;
Begin While Length(s)<n Do s:=s+' '; Sp:=s
End;
Procedure Tipar (Var Un_Stud : Student);
Begin With Un_Stud Do
Writeln (Nr_Leg:6,Sp(Nume,26):28,Medie:7:2,' Sters')
End;
Begin
Assign (F,'Grupa111.Dat'); ReSet (F);
Assign (G,'Grupa111.Tmp'); ReWrite(G);
Repeat
Write (' Nr.Crt.:'); Readln (Nr_Crt);
If Nr_Crt>0 Then Begin
While FilePos(F)+1<Nr_Crt Do Begin
Read (F,Un_Stud);
Write(G,Un_Stud)
End;
Read (F,Un_Stud);
Tipar(Un_Stud)
End
Until Nr_Crt=0;
While Not Eof(F) Do Begin
Read (F,Un_Stud);
Write(G,Un_Stud)
End;
Close(F); Close(G);
Erase(F);
Rename(G,'Grupa111.Dat')
End.

6
 Programul pentru adăugarea de noi articole în fişier este prezentat în continuare şi
lucrează în felul următor : citeşte de la tastatură câte un articol pe care îl adaugă înaintea
articolului cu numărul de ordine Nr_Crt (introdus tot de la tastatură).
Toate articolele până la cel precizat se copiază din fişierul iniţial în cel temporar, apoi
se scrie noul articol (citit anterior). Se citeşte din nou alt articol care va fi adăugat şi aşa mai
departe până când nu mai sunt articole de adăugat. Restul articolelor care au mai rămas în
fişierul iniţial se vor copia şi ele în fişierul final.
Aşa cum s-a procedat şi la Stergere, se vor depune datele obţinute în fişierul iniţial
(apelând Erase... şi Rename...) .

Program Adaugare_Directa_Fis; { Access Random }

Type Student = Record . . . End;
Var F, G : File Of Student;
Un_Stud, UnStud:Student; {Un_Stud este Articolul Nou, iar }
Nr_Crt : Integer; { UnStud este Articolul Vechi }
Function Citit (Var Un_Stud : Student) : Boolean; {Citeste Un_Stud }
Begin
With Un_Stud Do Begin
Write (' Numele st.: '); Readln (Nume);
If Nume='' Then Citit:=False Else Begin
Citit:=True;
Write (' Nr.Leg. , Medie : ');
Readln(Nr_Leg,Medie)
End { If }
End {With}
End;
Begin
Assign (F,'Grupa111.Dat'); ReSet (F); { Fişier Initial }
Assign (G,'Grupa111.Tmp'); ReWrite(G); { Fişierul temporar }
While Citit(Un_Stud) Do Begin
Write (' Nr.Crt. (',FilePos(F)+1,',..,',FileSize(F)+1,') : ');
Readln (Nr_Crt); { Citeste pozitia inaintea careia }
While FilePos(F)+1<Nr_Crt Do Begin { se adauga noul articol }
Read(F,UnStud); { Copiaza vechile articole }
Write(G,UnStud)
End;
Write (G,Un_Stud) { Scrie Noul Articol }
End;
While Not Eof(F) Do Begin
Read(F,UnStud);
Write(G,UnStud) { Copiaza restul articolelor }
End;
Close(F); Close(G);
Erase(F);
Rename(G,'Grupa111.Dat') { Reface fişierul }
End.

7
 Tema I
1. Fişier text.

1.  Să se scrie un program Pascal care să poată codifica sau decodifica un
fişier text dat. Rezultatul se va depune în alt fişier (Numele celor două fişiere se vor introduce de la
tastatură).
a) Codificarea se va realiza prin înlocuirea fiecărui caracter după regula :
- fiecare vocală se înlocuieşte cu următoarea vocală din alfabet:
(a,e,i,o,u, A,E,I,O,U) → (e,i,o,u,a, E,I,O,U,A) ,
- fiecare consoană se înlocuieşte cu următoarea consoană:
(b,c,d,...,x,y,z, B,C,D,...,X,Y,Z) → (c,d,f,...,y,z,b,C,D,F,Y,Z,B),
- fiecare cifră se înlocuieşte cu următoarea cifră:
(0,1,2,3,4,5,6,7,8,9) → (1,2,3,4,5,6,7,8,9,0),
- restul caracterelor rămân neschimbate.
b) Decodificarea se va realiza prin înlocuirea fiecărui caracter după regula
inversă.
 Exemplu : ‘Sesiunea de iarna ! ’ ←→ ‘Titoapie fi oespe ! ’
‘Unu’ ←→ ‘Apa’ ←→ ‘Ere’

1'.  Se dau două numere întregi a şi b. Pentru un fişier text (F1, cu nume
cunoscut) având pe fiecare rând două numere n1 şi n2 între acolade si apoi un
text:
{ n1 } { n2 } Mesaj
să se construiască un alt fişier text (F2) având aceeaşi formă:
{ m1 } { m2 } Mesaj
unde:
m1,2=n1,2*a+b
 Exemplu :
F1: F2:
{123412}{123455} La Examen {123522}{123565} La Examen
{234555}{234589} - Trageti un bilet ... {234665}{234699} - Trageti un bilet ...
{898900}{898989} - Carnetul, va rog! {899010}{899099} - Carnetul, va rog!
{1898978}{1898989} - L-am uitat acasa! {1899088}{1899099} - L-am uitat acasa!
{2345678}{2345900} - La revedere! {2345788}{2346010} - La revedere!
{123456789}{123459876} S f â r ş i t {123456899}{123459986} S f â r ş i t

8
 Cuprins
Pag.
1. Fişiere Pascal. Utilizarea fişierelor text. ........................................………. 48
2. Fişiere cu tip , operaţii cu fişiere. ...................................................……... 51