7.

Algoritmi de prelucrare a fiierelor organizate relativ

Prelucrarea fiierelor binare care necesit actualizare trebuie s asigure
posibilitatea tergerii articolelor i s elimine riscul de suprascriere a articolelor
adugate. Pentru aceasta, trebuie proiectate structuri particulare de articole i
concepute operaii de gestiune specifice. Organizarea fiierelor care asigur
identificarea articolelor prin numrul lor relativ se numete organizare relativ.
Fr a epuiza multitudinea soluiilor de rezolvare a problemelor de gestiune a
fiierelor care necesit actualizare, n continuare se prezint cteva dintre ele. n orice
situaie, limitrile de regsire prin acces secvenial sau relativ a articolelor n fiier
reduc aria folosirii limbajului n problemele de gestiune. Marele inconvenient l
constituie lipsa accesului dup cheie, cel care corespunde cel mai bine gestiunii n
sistemele reale.
Pentru a simula organizarea relativ n Pascal se poate utiliza o codificare
extern a cheilor relative (numerelor relative) ale articolelor, prin utilizarea unui
nomenclator de articole, care s conin numrul relativ al fiecruia dintre ele.
Nomenclatorul este elaborat extern (automat sau neautomat). Orice operaie de
regsire n acces direct presupune introducerea din exterior a numrului relativ. La
crearea iniial, fiecare articol este nscris la numrul su relativ predefinit. Asigurarea
tergerii i adugrii controlate poate fi fcut n mai multe moduri.

Extinderea articolelor logice cu un indicator de stare (un octet), ajungn-
du-se la forma din figura 7.1.

Indicator de
stare (is)
Articol propriu-zis

Fig. 7.1. Structura articolului care include indicatorul de stare

Indicatorul de stare (notat is) va avea o valoare din dou posibile (de exemplu
0 pentru articol inactiv - inexistent sau ters - i 1 pentru articol prezent). Cu aceast
structur, operaiile de acces la articole se realizeaz n urmtoarele condiii: scrierea
n fiier este permis numai pentru articolele cu is=0; citirea din fiier este permis
numai pentru articolele cu is=1.
Preformarea presupune deschiderea fiierului ca nou i crearea unui numr
de articole (la limit, zero) cu is=0. Includerea operaiei de preformare conduce la
dispariia distinciei dintre populare i adugare. Datorit faptului c fiierul se
deschide ca existent, orice operaie de scriere a unui nou articol se trateaz ca
adugare. ntr-un sistem de programe, deschiderea cu Rewrite a unui fiier se
realizeaz o singur dat, n procedura de preformare.
Scrierea n acces direct presupune furnizarea numrului relativ (nr) al
articolului. n funcie de valoarea lui nr se disting urmtoarele situaii:
Algoritmi n programare. Aplicaii
- dac nr<FileSize(f), se citete articolul respectiv din fiier i adugarea este
permis numai dac is=0;
- dac nrFileSize(f), are loc extinderea fiierului cu preformarea articolelor
cu numerele relative cuprinse n domeniul FileSize(f)..nr-1. Noul articol se scrie pe
poziia nr.
Se remarc faptul c scrierea n acces direct permite preformarea iniial cu
zero articole.
Scrierea n acces secvenial se face fr verificare de inexisten. Scrierea
are loc n poziia dat de pointerul curent. Procedura face is=1. Utilizarea ei se
recomand numai la popularea dens.
Citirea n acces direct presupune furnizarea numrului relativ (nr). Ea
verific dac is=1.
Citirea n acces secvenial analizeaz articolele ncepnd cu cel de la
pointerul curent. Articolele cu is=0 sunt ignorate, pn la ntlnirea primului articol cu
is=1 sau pn se ajunge la sfrit de fiier.
tergerea se realizeaz n acces direct. Ea presupune citirea articolului i
dac tergerea este permis (is=1), se modific indicatorul de stare (is=0) i se scrie
articolul pe vechiul loc.
Rescrierea realizeaz scrierea unui articol n poziia FilePos(f)-1, dac
vechiul articol din aceast poziie are is=1.

Folosirea articolului zero ca tabel de ocupare n fiier. Fiecrui articol
din fiier i corespunde cte un octet n primul articol: articolului cu numrul relativ i
i corespunde octetul a[i]. Primul articol are structura a:ARRAY[1..max] OF BYTE,
unde max este o constant care indic numrul maxim de articole pe care le poate
avea fiierul pe durata existenei sale. Dac articolul i este prezent, a[i]=1; dac
articolul i este inactiv (inexistent sau ters), a[i]=0. Cu aceast structur, operaiile de
acces la articole se realizeaz n urmtoarele condiii: scrierea n fiier a articolului cu
numrul relativ i este permis numai dac a[i]=0; citirea din fiier a articolului cu
numrul relativ i este permis numai dac a[i]=1.
tergerea articolului i presupune verificarea existenei sale (a[i]=1) i realiza-
rea operaiei a[i]=0. Adugarea unui articol i presupune verificarea inexistenei lui
(a[i]=0), nscrierea articolului i realizarea operaiei a[i]=1.
Utilizarea acestei modaliti necesit ncrcarea iniial n memoria principal
a articolului cu numrul relativ zero. n programele care realizeaz tergeri sau/i
adugri, nainte de nchiderea fiierului trebuie renscris articolul zero. Pentru ca
metoda s fie eficient, articolul zero trebuie s aib lungime cel mult egal cu
lungimea articolelor de date. Se pot concepe algoritmi prin care, pentru tabela de
ocupare n fiier, se aloc spaiu mai mic, fiecrui articol corespunzndu-i un bit, n
loc de un octet.

Exerciiul 7.1. S se realizeze un program multifuncional pentru crearea i
ntreinerea unui fiier referitor la angajaii unei organizaii economice, cu
urmtoarea structur logic de articol:
Algoritmi de prelucrare a fiierelor organizate relativ

Marc
angajat
Nume i prenume
angajat
Profesie
Loc de
munc
Salariu
de baz
Word String[20] String[10] Byte Longint

Marca angajatului indic numrul relativ al articolului corespunztor n
fiier. De aceea, se poate opta pentru metoda de organizare relativ, cheia relativ
fiind marca angajatului i se va utiliza codificarea extern prin numere relative.
Deoarece cheia relativ nu face parte din articolul memorat n fiier,
structura fizic va fi urmtoarea:

Indicator de
stare (is)
Nume i prenume
angajat
Profesie
Loc de
munc
Salariu
de baz
0..1 String[20] String[10] Byte Longint

Observaii:
1. Programul ofer utilizatorului funciuni de Creare, Adugare, Modificare i
tergere, realizate n acces direct dup cheia relativ. n meniul afiat pe ecran
exist i funciunea de terminare a programului.
2. Funciunile de Creare i Adugare sunt identice, cu deosebirea c pentru prima
fiierul se deschide ca nou (cu Rewrite), iar pentru cea de-a doua fiierul se
deschide ca existent (cu Reset).
3. La opiunea de tergere s-a inclus o confirmare suplimentar din partea
utilizatorului, pentru cazul n care cheia relativ introdus de la tastatur exist
n fiier, dar nu aparine angajatului care se dorete a fi ters.
4. Funciunea de modificare prevede posibilitatea modificrii valorii oricrui
cmp sau combinaie de cmpuri. Prin convenie, tastarea doar a lui <ENTER>
semnific nemodificarea cmpului respectiv.
5. Fiecare funciune a programului prevede posibilitatea relurii ei n interior, fr
a mai iei n meniul principal. Terminarea unei funciuni se realizeaz prin
tastarea caracterului CTRL/Z n cmpul marca (sfrit standard al tastaturii).
De aceea, la revenirea n meniul principal i la apelul unei noi funciuni,
tastatura (fiier TEXT standard de intrare) trebuie deschis cu procedura
Reset(Input).

program actualizare_fisier_relativ;
uses crt;
type
art=record
is:0..1;
nume:string[20];
prof:string[10];
loc:byte;
sal:longint
end;
Algoritmi n programare. Aplicaii
var
f:file of art; x:art; opt,r:char;
marca,i,err:word; aux:string[20];
procedure meniu;
begin
reset(input); clrscr;
gotoxy(30,7); write('Functiunile programului');
gotoxy(36,9); write('1. Creare');
gotoxy(36,10); write('2. Adaugare');
gotoxy(36,11); write('3. Modificare');
gotoxy(36,12); write('4. Stergere');
gotoxy(36,13); write('5. Terminare');
gotoxy(30,16); write('Functia aleasa:');
gotoxy(46,16); readln(opt)
end;
procedure citire_campuri;
begin
write('Nume si prenume: '); readln(x.nume);
write('Profesie: '); readln(x.prof);
write('Loc de munca: '); readln(x.loc);
write('Salariu: '); readln(x.sal);
x.is:=1
end;
procedure preformare;
begin
seek(f,filesize(f));
x.is:=0;
for i:=filesize(f) to marca-1 do write(f,x)
end;
procedure creare;
begin
reset(input); assign(f,'pers.dat');
if opt='1' then rewrite(f) else reset(f);
checkeof:=true; clrscr;
with x do begin
write('Marca: ');
while not eof do
begin
readln(marca);
if marca<filesize(f) then
begin
seek(f,marca); read(f,x);
if is=0 then
begin
citire_campuri;
seek(f,marca);
write(f,x)
end
else writeln('Marca alocata !')
end
Algoritmi de prelucrare a fiierelor organizate relativ
else begin
preformare;
citire_campuri;
write(f,x)
end;
write('Marca (sau ^Z): ')
end
end;
close(f)
end;
procedure stergere;
begin
reset(input); assign(f,'pers.dat'); reset(f);
checkeof:=true; clrscr;
with x do begin
write('Marca: ');
while not eof do
begin
readln(marca);
if marca<filesize(f) then
begin
seek(f,marca); read(f,x);
if is=1 then
begin
writeln(nume,' ',loc,' ',prof);
write('Confirmati stergerea ? (d/n): ');
readln(r);
if upcase(r)='D' then
begin
is:=0;
seek(f,marca);
write(f,x)
end
end
else writeln('Angajat inexistent in fisier !')
end
else writeln('Marca eronata !');
write('Marca (sau ^Z): ')
end
end;
close(f)
end;
procedure modif_campuri;
begin
with x do begin
write('Nume si prenume: ',nume,' '); readln(aux);
if aux<>'' then nume:=aux;
write('Profesie: ',prof,' '); readln(aux);
if length(aux)<>0 then prof:=aux;
write('Loc de munca: ',loc,' '); readln(aux);
Algoritmi n programare. Aplicaii
if aux[0]<>#0 then val(aux,loc,err);
write('Salariu: ',sal,' '); readln(aux);
if aux[0]<>#0 then val(aux,sal,err);
seek(f,marca); write(f,x)
end
end;
procedure modificare;
begin
reset(input); assign(f,'pers.dat'); reset(f);
checkeof:=true; clrscr;
with x do begin
write('Marca: ');
while not eof do
begin
readln(marca);
if marca<filesize(f) then
begin
seek(f,marca); read(f,x);
if is=1 then modif_campuri
else writeln('Angajat inexistent in fisier !')
end
else writeln('Marca eronata !');
write('Marca (sau ^Z): ')
end
end;
close(f)
end;
{programul principal}
begin
meniu;
while opt<>'5' do
begin
case opt of
'1','2': creare;
'3': modificare;
'4': stergere
else begin gotoxy(25,23);
write('Functie inexistenta !',#7) end
end;
meniu
end
end.

Exerciiul 7.2. S se realizeze programul pentru afiarea pe monitor a informaiilor
existente despre acei angajai ale cror mrci se introduc de la tastatur. Se va
utiliza fiierul creat la exerciiul 7.1.
Observaie: Sfritul introducerii de la tastatur va fi marcat standard (CTRL/Z n
cmpul marca). Programul codific un algoritm de consultare n acces direct dup
cheia relativ.
Algoritmi de prelucrare a fiierelor organizate relativ
program vizualizare_angajat;
uses crt;
type
art=record
is:0..1;
nume:string[20];
prof:string[10];
loc:byte;
sal:longint
end;
var
f:file of art;
x:art;
marca:word;
vb:boolean;
begin
assign(f,'pers.dat'); reset(f);
checkeof:=true; clrscr;
with x do begin
gotoxy(30,10); write('Marca: ');
while not eof do
begin
readln(marca);
if marca<filesize(f) then
begin
seek(f,marca);
read(f,x);
if is=1 then
begin
gotoxy(25,15);
writeln(nume,' ',prof,' ',loc,' ',sal)
end
else
begin
gotoxy(30,12);
writeln('Angajat inexistent!',#7)
end
end
else
begin
gotoxy(30,12);
writeln('Marca eronata !',#7)
end;
readln; clrscr; gotoxy(30,10);
write('Marca(sau ^Z): ')
end
end;
close(f)
end.
Algoritmi n programare. Aplicaii
Exerciiul 7.3. S se realizeze programul pentru afiarea pe monitor a informaiilor
existente (marc, nume i prenume, loc de munc i salariu) pentru acei angajai a
cror profesie este identic cu o valoare introdus de la tastatur. Se va utiliza
fiierul creat la exerciiul 7.1.
Observaie: Programul prevede posibilitatea relurii procesului pentru o nou
profesie, fie pentru c se dorete un nou tabel, fie pentru c profesia introdus a
fost eronat (nu exist nici un angajat cu profesia cerut). Sfritul introducerii de
la tastatur va fi marcat standard (CTRL/Z n cmpul prof). Programul codific un
algoritm de consultare n acces secvenial cu selecie dubl: dup indicatorul de
stare i dup profesie. Pentru fiecare profesie, fiierul va fi consultat de la primul la
ultimul articol.

program vizualizare_profesie;
uses crt;
type art=record
is:0..1;
nume:string[20]; prof:string[10];
loc:byte; sal:longint
end;
var
f:file of art; x:art; prof_t:string[10]; aux:string[20];
vb,sw:boolean; i:byte;
begin
assign(f,'pers.dat'); reset(f);
checkeof:=true; clrscr; i:=0;
with x do begin
write('Profesia: ');
while not eof do
begin
readln(prof_t);
seek(f,0); sw:=true; i:=0; vb:=false;
while not eof(f) do
begin
read(f,x);
if (is=1) and (prof=prof_t) then
begin
if sw then begin {prima scriere in tabel}
gotoxy(20,10);
writeln('Marca Nume si prenume Loc Salariu');
sw:=false
end;
inc(i); gotoxy(20,12+i); fillchar(aux,21,' ');
aux:=nume; aux[0]:=#20;
writeln((filepos(f)-1):5,' ',aux,' ',loc:3,
' ',sal:7);
vb:=true
end
end;
Algoritmi de prelucrare a fiierelor organizate relativ
if not vb then
begin
gotoxy(30,15);
writeln('Profesie inexistenta !',#7)
end;
readln; clrscr;
write('Profesia (sau ^Z): ')
end {while}
end {with};
close(f)
end.

Exerciiul 7.4. S se realizeze programul pentru afiarea informaiilor existente
despre toi angajaii, n ordine alfabetic a numelui i grupai pe profesii. Se va
utiliza fiierul creat la exerciiul 7.1.
Observaii:
1. Pentru a obine lista dorit, fiierul de date trebuie sortat dup dou chei. Cheia
principal este profesia, iar cheia secundar este numele i prenumele.
2. Pentru a nu afecta organizarea relativ, sortarea se va realiza ntr-un fiier de
manevr, organizat secvenial, cu memorare dens. Structura articolului asociat
manevrei este structura logic a fiierului de date. Valorile cmpului marca
sunt date de poziia curent a articolului n fiierul iniial. La sfritul
programului, fiierul de manevr va fi ters din director.
3. Pentru a obine lista pe mediu magnetic (pentru imprimri ulterioare), n
program se va modifica afiarea pe ecran cu scrierea ntr-un fiier TEXT
magnetic.

program sortare_dupa_doua_campuri;
uses crt;
type
artf=record
is:0..1;
nume:string[20];
prof:string[10];
loc:byte;
sal:longint
end;
artm=record
marca:word;
nume:string[20];
prof:string[10];
loc:byte;
sal:longint
end;
var
f:file of artf;
m:file of artm;
z:artf; x,y:artm;
Algoritmi n programare. Aplicaii
n,i,j:word;
aux1:string[10];
aux2:string[20];
procedure creare_manevra;
begin
assign(f,'pers.dat');
reset(f);
assign(m,'manevra.tmp');
rewrite(m);
while not eof(f) do
begin
read(f,z);
if z.is=1 then
begin
x.marca:=filepos(f)-1;
x.nume:=z.nume;
x.prof:=z.prof;
x.loc:=z.loc;
x.sal:=z.sal;
write(m,x)
end
end;
close(f)
end;
procedure sortare_manevra;
begin
n:=filesize(m);
for i:=1 to n-1 do
begin
seek(m,i-1); read(m,x);
for j:=i+1 to n do
begin
seek(m,j-1); read(m,y);
if x.prof>y.prof then
begin
seek(m,i-1); write(m,y);
seek(m,j-1); write(m,x);
x:=y
end
else if x.prof=y.prof then
if x.nume>y.nume then
begin
seek(m,i-1); write(m,y);
seek(m,j-1); write(m,x);
x:=y
end
end
end
end;

Algoritmi de prelucrare a fiierelor organizate relativ
procedure listare_manevra;
begin
with x do begin
seek(m,0); i:=0;
clrscr; gotoxy(25,2);
writeln('Tabel cu angajatii pe profesii');
gotoxy(17,4);
writeln(' PROFESIE MARCA NUME SI PRENUME LOC',
' SALARIU');
while not eof(m) do
begin
read(m,x);
fillchar(aux1,11,#32); aux1:=prof; aux1[0]:=#10;
fillchar(aux2,21,#32); aux2:=nume; aux2[0]:=#20;
gotoxy(17,6+i); inc(i);
writeln(aux1,' ',marca:4,' ',aux2,
' ',loc:3,' ',sal:7)
end
end;
close(m); erase(m)
end;
{programul principal}
begin
creare_manevra;
sortare_manevra;
listare_manevra
end.

Exerciiul 7.5. S se realizeze programul pentru indexarea salariului tuturor
angajailor existeni n fiier, cu un procent introdus de la tastatur. Se va utiliza
fiierul creat la exerciiul 7.1.
Observaie: Programul codific un algoritm de modificare n acces secvenial.

program modificare_secventiala;
uses crt;
type
art=record
is:0..1;
nume:string[20];
prof:string[10];
loc:byte;
sal:longint
end;
var
f:file of art; x:art; indice:real;
begin
assign(f,'pers.dat'); reset(f);
with x do begin
write('Indicele de crestere (%): '); readln(indice);
Algoritmi n programare. Aplicaii
while not eof(f) do
begin
read(f,x);
if is=1 then
begin
sal:=trunc(sal*(1+indice/100));
seek(f,filepos(f)-1);
write(f,x)
end
end
end;
close(f)
end.

Programele din exerciiile 7.1-7.5, care codific algoritmi de prelucrare a
fiierelor organizate relativ, includ explicit gestionarea indicatorului de stare n
toate cazurile, fapt ce constituie un efort suplimentar din partea programatorului. n
continuare, se prezint o unitate Pascal (relativ), n care sunt incluse o serie de
proceduri (primitive), care gestioneaz prelucrarea fiierelor organizate relativ,
degrevnd astfel programatorul de prelucrri suplimentare. Primitivele pot fi
folosite n orice program al utilizatorului, schimbndu-se doar tipul fiier i tipul
articol. Unitatea cuprinde primitive pentru urmtoarele operaii de gestiune:
preformare, scriere n acces direct, scriere n acces secvenial, citire n acces direct,
citire n acces secvenial, tergere n acces direct i rescriere.
n afara procedurii Preformare, care este o operaie la nivel de fiier, toate
celelalte sunt operaii de acces la articole i presupun fiierul deschis corespunztor
(cu Reset). n unitate sunt fcute publice dou tipuri: tipf, pentru tipul fiierului i
tipa, pentru tipul articolului. Programele apelatoare lucreaz numai cu cmpurile
articolului propriu-zis, gestiunea indicatorului de stare fcndu-se integral n unitate.
Unitatea ar putea fi perfecionat, astfel nct programele apelatoare s
descrie numai articolul propriu-zis, procedurile atand fizic octetul de stare. n felul
acesta, programele apelatoare lucreaz cu un tip de articol (logic) i procedurile
asigur conversia la/de la un alt tip de articol (fizic). Articolul fizic difer de cel logic
prin indicatorul is.

Procedura de preformare

OpenNew(VAR f:tipf;VAR nume:STRING; n:WORD; VAR ivk:BOOLEAN)

F este fiierul, nume este identificatorul su extern, iar n este numrul relativ
al ultimului articol preformat. Ivk este indicator de eroare i are valorile: FALSE, dac
fiierul se poate deschide ca nou (nu exist n directorul precizat, implicit sau explicit,
prin identificatorul extern) sau TRUE, dac fiierul nu se poate deschide ca nou
(exist n directorul precizat prin identificatorul extern).
Procedura deschide ca nou un fiier inexistent i scrie articolele cu numerele
relative cuprinse n domeniul 0..n, fcnd, pentru ele, is=0.
Algoritmi de prelucrare a fiierelor organizate relativ
Procedura de scriere n acces direct

WriteD(VAR f:tipf; VAR z:tipa; nr:WORD; VAR ivk:BOOLEAN)

F este fiierul, z este articolul care se scrie n poziia relativ nr. Ivk este
indicator de eroare i are valorile: FALSE, dac articolul s-a putut scrie sau TRUE,
dac articolul nu s-a putut scrie (este prezent n fiier). Procedura verific inexistena
articolului i realizeaz nscrierea lui n fiier.
Dac nr<FileSize(f), se citete articolul din poziia nr, ntr-o zon z1 i dac
z1.is=0, se scrie articolul z n poziia nr i se face ivk:=FALSE, iar dac z1.is=1 se
face ivk:=TRUE. Citirea se face n zona z1, pentru a nu se distruge articolul care este
constituit n z, pentru adugare. Dac nrFileSize(f), se preformeaz articolele cu
numerele relative cuprinse n intervalul FileSize(f)..nr-1, se scrie articolul z n poziia
nr i se face ivk:=FALSE.

Procedura de scriere n acces secvenial

WriteS(VAR f:tipf; VAR z:tipa)

F este fiierul, iar z este zona din care se preia articolul care se scrie. Scrierea
se face fr nici o verificare. De aceea, procedura se folosete numai la popularea
iniial a fiierului sau la adugarea compact de articole la sfritul lui. Pentru
articolul scris se face z.is=1. Dup scriere, pointerul indic urmtorul articol din fiier.

Procedura de citire n acces direct

ReadD(VAR f:tipf; VAR z:tipa; nr:WORD; VAR ivk:BOOLEAN)

F este fiierul, z este zona n care se transfer articolul i nr este numrul su
relativ. Ivk este indicator de eroare i are valorile: FALSE, dac articolul s-a citit (este
prezent n fiier) sau TRUE, dac articolul nu s-a citit logic (este absent din fiier).
Procedura verific existena articolului i realizeaz citirea lui din fiier.
Dac nr<FileSize(f), se citete articolul i dac z.is=1, se face ivk:=FALSE,
iar dac z.is=0, se face ivk:=TRUE. Dac nrFilesize(f), se face ivk:=TRUE.

Procedura de citire n acces secvenial

ReadS(VAR f:tipf; VAR z:tipa; VAR sf:BOOLEAN)

F este fiierul, iar z este zona n care se citete primul articol prezent n fiier,
ncepnd de la pointerul curent. Sf este un indicator de semnalare a atingerii sfritului
de fiier i are valorile: FALSE, dac articolul s-a citit (i nu este sfrit de fiier) sau
TRUE, dac s-a ajuns la sfrit de fiier. Procedura citete secvenial, ncepnd de la
pointerul curent pn la primul articol care are z.is=1 sau pn se ajunge la sfrit de
Algoritmi n programare. Aplicaii
fiier. Dup citirea articolului, pointerul indic urmtorul articol fizic din fiier
(prezent sau nu logic).

Procedura de tergere n acces direct

DeleteD(VAR f:tipf; nr:WORD; VAR ivk:BOOLEAN)

F este fiierul i nr este numrul relativ al articolului care urmeaz s se
tearg. Ivk este indicator de eroare i are valorile: FALSE, dac articolul s-a ters
(este prezent n fiier) sau TRUE, dac articolul nu s-a ters (este absent din fiier).
Procedura realizeaz verificri asemntoare procedurii ReadD. Cnd articolul este
prezent, se face z.is:=0 i se rescrie n poziia nr.

Procedura de rescriere

RewriteS(VAR f:tipf; VAR z:tipa; VAR ivk:BOOLEAN)

F este fiierul, iar z este articolul care se scrie n poziia FilePos(f)-1. Ivk este
indicator de eroare i are valorile: FALSE, dac articolul se poate rescrie (articolul din
poziia FilePos(f)-1 este prezent n fiier) sau TRUE, dac articolul nu se poate rescrie
(articolul din poziia FilePos(f)-1 este absent).
Procedura presupune execuia anterioar a unei citiri (cu ReadD sau ReadS).
Ea rescrie un articol n poziia anterioar pointerului curent, dac acesta are cmpul
is=1 i dac FilePos(f)-1<FileSize(f).

unit relativ;
INTERFACE
type
tipa=record
is:byte;
np:string[20];
prof:string[10];
loc:byte;
sal:longint
end;
tipf=file of tipa;
procedure opennew(var f:tipf; var nume:string; n:word;
var ivk:boolean);
procedure writed(var f:tipf; var z:tipa; nr:word;
var ivk: boolean);
procedure writes(var f:tipf; var z:tipa);
procedure readd(var f:tipf; var z:tipa; nr:word;
var ivk:boolean);
procedure reads(var f:tipf; var z:tipa; var sf:boolean);
procedure deleted(var f:tipf; nr:word; var ivk:boolean);
procedure rewrites(var f:tipf; var z:tipa; var ivk:boolean);

Algoritmi de prelucrare a fiierelor organizate relativ
IMPLEMENTATION
procedure opennew;
var
i:word; z1:tipa;
begin
ivk:=false;
assign(f,nume);
{$i-} reset(f); {$i+}
if ioresult <>0 then
begin
rewrite(f);
z1.is:=0;
for i:= 0 to n do write(f,z1);
close(f)
end
else ivk:=true
end;
procedure writed;
var
z1:tipa;
i:word;
begin
ivk:=false;
if nr < filesize(f) then
begin
seek(f,nr);
read(f,z1);
if z1.is=0 then
begin
z.is:=1;
seek (f,nr);
write (f,z)
end
else
ivk:=true
end
else
begin
seek(f,filesize(f));
z1.is:=0;
for i:=filesize(f) to nr-1 do write(f,z1);
z.is:=1;
write(f,z)
end
end;
procedure writes;
begin
z.is:=1;
write(f,z)
end;
Algoritmi n programare. Aplicaii
procedure readd;
begin
ivk:=false;
if nr < filesize(f) then
begin
seek(f,nr);
read(f,z);
if z.is=0 then ivk:=true
end
else
ivk:=true
end;
procedure reads;
begin
sf:=false;
repeat
{$i-} read(f,z); {$i+}
if ioresult <>0 then sf:=true
until (z.is=1) or sf
end;
procedure deleted;
var
z1: tipa;
begin
ivk:=false;
if nr < filesize(f) then
begin
seek(f,nr);
read(f,z1);
if z1.is=0
then ivk:=true
else
begin
z1.is:=0;
seek(f,nr);
write(f,z1)
end
end
else ivk:=true
end;
procedure rewrites;
var
z1:tipa;
begin
ivk:=false;
if (filepos(f)-1) < filesize(f) then
begin
seek(f,filepos(f)-1);
read(f,z1);
if z1.is=0
Algoritmi de prelucrare a fiierelor organizate relativ
then ivk:=true
else
begin
seek(f,filepos(f)-1);
z.is:=1;
write(f,z)
end
end
else ivk:=true
end
end.

Exerciiul 7.6. S se realizeze programul pentru afiarea informaiilor existente n
fiier despre acei angajai ale cror coduri se introduc de la tastatur. Se va utiliza
fiierul creat la exerciiul 7.1.
Observaii:
1. Sfritul introducerii va fi marcat standard (CTRL/Z n cmpul marca).
2. Se va utiliza primitiva de citire n acces direct din unitatea relativ.

program vizualizare_persoana;
uses crt,relativ;
var
f:tipf;
x:tipa;
marca:word;
ivk:boolean;
begin
assign(f,'pers.dat'); reset(f);
checkeof:=true; clrscr;
with x do begin
gotoxy(30,10); write('Marca: ');
while not eof do
begin
readln(marca);
readD(f,x,marca,ivk);
if not ivk then begin
gotoxy(25,15);
writeln(np,' ',prof,' ',loc,' ',sal)
end
else begin
gotoxy(30,12);
writeln('Angajat inexistent!')
end;
readln; clrscr; gotoxy(30,10);
write('Marca(sau ^Z): ')
end
end;
close(f)
end.
Algoritmi n programare. Aplicaii
Exerciiul 7.7. S se realizeze programul pentru afiarea informaiilor existente n
fiier despre angajaii dintr-un anumit loc de munc, al crui cod se introduce de la
tastatur. Se va utiliza fiierul creat la exerciiul 7.1.
Observaii:
1. Se va asigura posibilitatea relurii introducerii de coduri pentru mai multe locuri
de munc. Sfritul introducerii va fi marcat standard (CTRL/Z n cmpul loc de
munc).
2. Se va utiliza primitiva de citire n acces secvenial din unitatea relativ.
3. Algoritmul codificat n program este bazat pe varianta schemei logice de
prelucrare cu fiier conductor cu o citire iniial i o citire curent, la sfritul
modulului Prelucrare.

program vizualizare_loc_de_munca;
uses crt,relativ;
var
f:tipf; x:tipa; loc_t,i:byte; aux:string[20];
vb,sw,sf:boolean;
begin
assign(f,'pers.dat'); reset(f);
checkeof:=true; clrscr;
with x do begin
write('Loc de munca: ');
while not eof do {repetitiva dupa sfarsit de tastatura}
begin
readln(loc_t);
seek(f,0);
sw:=true; i:=0;
vb:=false;
sf:=false;
readS(f,x,sf);
while not sf do {repetitiva dupa sfarsit fisier magnetic}
begin
if (is=1) and (loc=loc_t) then begin
if sw then begin {prima scriere in tabel}
gotoxy(20,10);
writeln('Marca Nume si prenume Loc Salariu');
sw:=false
end;
{scriere rand curent in tabel}
inc(i); gotoxy(20,12+i);
fillchar(aux,21,' ');
aux:=np; aux[0]:=#20;
writeln((filepos(f)-1):5,' ',aux,' ',loc:3,
' ',sal:7);
vb:=true
end;
readS(f,x,sf)
end;
Algoritmi de prelucrare a fiierelor organizate relativ
if not vb then
begin
gotoxy(30,15);
writeln('Loc de munca eronat !',#7)
end {while dupa sf};
readln; clrscr; write('Loc de munca (sau ^Z): ')
end {dupa eof}
end {with};
close(f)
end.

Exerciiul 7.8. S se realizeze programul multifuncional pentru realizarea operaiilor
de creare, adugare, modificare i tergere, pentru un fiier cu articole avnd structura
similar celui de la exerciiul 7.1.
Observaii: Operaiile sunt similare exerciiului 7.1, cu deosebirea c sunt utilizate
primitive din unitatea relativ: preformare (deschidere fiier nou), citire n acces
direct, scriere n acces direct, tergere n acces direct, rescriere.

program actualizare_fisier_relativ;
uses crt,relativ;
var
f:tipf;
x:tipa;
opt,r:char;
ivk:boolean;
marca,i,err:word;
aux:string[20];
const
numefis:string='pers.dat';
procedure meniu;
begin
reset(input);
clrscr;
gotoxy(30,7); write('Functiile programului');
gotoxy(36,9); write('1. Creare');
gotoxy(36,10); write('2. Adaugare');
gotoxy(36,11); write('3. Modificare');
gotoxy(36,12); write('4. Stergere');
gotoxy(36,13); write('5. Terminare');
gotoxy(30,16); write('Functia aleasa:');
gotoxy(46,16);
readln(opt)
end;
procedure citire_campuri;
begin
write('Nume si prenume: ');
readln(x.np);
write('Profesie: ');
readln(x.prof);
Algoritmi n programare. Aplicaii
write('Loc de munca: ');
readln(x.loc);
write('Salariu: ');
readln(x.sal)
end;
procedure creare;
begin
reset(input);
if opt='1' then openNew(f,numefis,2500,ivk)
else
begin
assign(f,'pers.dat');
reset(f)
end;
checkeof:=true;
clrscr;
with x do begin
write('Marca: ');
while not eof do
begin
readln(marca);
readD(f,x,marca,ivk);
if ivk then
begin
citire_campuri;
writeD(f,x,marca,ivk)
end
else writeln('Marca alocata altui angajat !');
write('Marca (sau ^Z): ')
end {while}
end {with};
close(f);
end;
procedure stergere;
begin
reset(input);
assign(f,'pers.dat');
reset(f);
checkeof:=true;
clrscr;
with x do begin
write('Marca: ');
while not eof do
begin
readln(marca);
readD(f,x,marca,ivk);
if not ivk then
begin
writeln(np,' ',loc,' ',prof);
write('Confirmati stergerea ? (d/n): ');
Algoritmi de prelucrare a fiierelor organizate relativ
readln(r);
if upcase(r)='D' then deleteD(f,marca,ivk)
end
else
writeln('Angajat inexistent in fisier !');
write('Marca (sau ^Z): ')
end {while}
end {with};
close(f);
end;
procedure modif_campuri;
begin
with x do begin
write('Nume si prenume: ',np,' ');
readln(aux);
if aux<>'' then np:=aux;
write('Profesie: ',prof,' ');
readln(aux);
if length(aux)<>0 then prof:=aux;
write('Loc de munca: ',loc,' ');
readln(aux);
if aux[0]<>#0 then val(aux,loc,err);
write('Salariu: ',sal,' ');
readln(aux);
if aux[0]<>#0 then val(aux,sal,err);
rewrites(f,x,ivk)
end
end;
procedure modificare;
begin
reset(input);
assign(f,'pers.dat');
reset(f);
checkeof:=true;
clrscr;
with x do begin
write('Marca: ');
while not eof do
begin
readln(marca);
readd(f,x,marca,ivk);
if not ivk then modif_campuri
else writeln('Angajat inexistent in fisier !');
write('Marca (sau ^Z): ')
end {while}
end {with};
close(f);
end;


Algoritmi n programare. Aplicaii
{programul principal}
begin
meniu;
while opt<>'5' do
begin
case opt of
'1','2': creare;
'3' : modificare;
'4' : stergere
else
begin
gotoxy(25,23);
write('Functie inexistenta !',#7)
end
end;
meniu
end
end.