9.

Aplicaţie informatică cu prelucrare de fişiere

Capitolul prezintă un model de aplicaţie care simulează activitatea

informaţională la nivelul unei organizaţii economico-sociale de dimensiuni medii.
Din perspectivă sistemică, orice organizaţie poate fi privită ca o componentă a unui
sistem superior cum ar fi sistemul de subramură, sistemul de ramură etc.
La rândul său, privită cel puţin din perspectiva funcţiunilor manageriale ale
întreprinderii, orice organizaţie constituie un sistem format din subsisteme
corespunzătoare departamentelor aprovizionare, desfacere, financiar, contabilitate,
resurse umane, marketing etc. În direcţia eficientizării activităţii fiecărui subsistem
al organizaţiei socio-economice, conducerea are la dispoziţie cel mai performant
instrument existent astăzi pe piaţă – instrumentul informatic. În acest context,
rezolvarea unei probleme cu ajutorul calculatorului electronic este o activitate
complexă, care presupune o abordare sistematică, bazată pe o succesiune de
operaţii, pentru realizarea cărora se folosesc tehnici şi instrumente specifice.
În practica proiectării aplicaţiilor informatice se utilizează o serie de
concepte de bază:
Proiect informatic – denumire generică referitoare la realizarea sistemelor
informatice, a aplicaţiilor informatice sau a unor probleme independente.
Sistem informatic – ansamblu structurat de elemente intercorelate funcţional,
pentru automatizarea procesului de culegere şi prelucrare a datelor, în vederea
obţinerii informaţiilor pentru fundamentarea deciziilor. În general, sistemele
informatice reprezintă componente ale sistemelor informaţionale din organizaţiile
socio-economice.
Aplicaţie informatică – denumire generică pentru problemele de informatică
de dimensiuni relativ reduse, care vizează un domeniu de activitate strict delimitat.
Metodologie – în sens informatic, defineşte succesiunea etapelor de parcurs
pentru conceperea şi realizarea proiectelor informatice. O metodologie poate
cuprinde mai multe metode.
Metodă (tehnică) – o mulţime de paşi, aplicaţi într-o succesiune logică asupra
unei mulţimi de date de intrare, care conduce la obţinerea rezultatelor.
Aplicaţiile informatice acoperă o gamă largă de probleme1, ale căror
extreme pot fi caracterizate astfel:
a) existenţa unui volum relativ redus de date de intrare şi ieşire, dublată de
calcule laborioase (aplicaţii tehnico-inginereşti, care conduc la aplicaţii bazate pe
aproximări succesive, exprimate matematic prin ecuaţii algebrice şi transcendente,
sisteme de ecuaţii liniare, ecuaţii diferenţiale, integrale, adică într-o formulare
globală, aplicaţii bazate pe metode de calcul numeric).
b) existenţa unui volum mare de date de intrare şi ieşire, asociate uzual
unor calcule cu complexitate redusă (evidenţa materialelor, evidenţa personalului şi

1
Capitolul 4 – Etapele rezolvării problemelor cu calculatorul, în lucrarea Algoritmi în
programare, B. Ghilic-Micu (coord.), Ed. ASE, Bucureşti 2002, pg. 65
 Algoritmi în programare. Aplicaţii

calculul salariilor, evidenţa mijloacelor fixe, urmărirea realizării producţiei, a

contractelor de aprovizionare/desfacere etc., adică, în general, aplicaţii de gestiune
economică). Între aceste extreme există o diversitate de aplicaţii, dintre care unele
presupun atât volume mari de date cât şi modele economico-matematice bazate pe
calcule laborioase: gestiunea stocurilor, programarea producţiei, probleme de
transport, croire, alocare a resurselor etc.
Realizarea proiectelor informatice este un proces complex, structurat în
mai multe etape, cu obiective specifice. Modul de realizare a acestor etape,
resursele implicate şi durata lor totală depind de varianta de soluţie aleasă, pe de o
parte, şi de nivelul de abordare (aplicaţie, sistem informatic, problemă), pe de altă
parte. În funcţie de complexitatea problemelor abordate în vederea rezolvării cu
calculatorul, din perspectiva programelor care vor fi elaborate, soluţiile proprii pot
conduce la una din situaţiile: sisteme de programe realizate la nivelul unor aplicaţii
informatice, abordate independent sau ca parte a unor sisteme informatice; unul sau
mai multe programe, în cazul unor probleme de dimensiuni reduse.

9.1. Etapele de realizare a proiectelor informatice

Realizarea proiectelor informatice presupune parcurgerea următoarelor

etape: formularea cerinţelor, analiza, concepţia2 şi finalizarea3. Pentru realizarea
unui proiect informatic se recomandă constituirea unei echipe de analiză-
concepţie-programare. Numărul membrilor echipei va fi stabilit în funcţie de
dimensiunea şi complexitatea proiectului, precum şi de resursele disponibile. În
acest sens, există mai multe modele de organizare a activităţii de analiză-concepţie-
programare: organizare democratică (deschisă), echipa programatorului şef (CPT –
Chief Programmer’s Team), echipa chirurgicală etc.
Organizarea democratică este cel mai simplu model de conducere a
proiectelor, în care: întreaga echipă are ca scop unic reuşita proiectului şi nu
scopuri individuale, înlăturarea erorilor şi nu ascunderea lor; definirea soluţiei de
realizare a proiectului se face în colectiv; realizarea sarcinilor se distribuie între
membrii echipei iar rolul conducător poate fi jucat de orice membru al echipei, prin
rotaţie.
Echipa programatorului şef (CPT) presupune existenţa unui număr de
programatori dintre care unul este conducător, iar procesul de realizare a
proiectelor trebuie structurat precis, pe sarcini care se vor distribui membrilor
echipei. Programatorul şef este conducătorul tehnic al întregii echipe, realizând şi
legătura cu beneficiarii produsului. De asemenea, programatorul şef trebuie să fie
un bun manager şi un bun analist-programator. Avantajul principal al acestui model
de organizare este că activitatea poate fi riguros planificată şi urmărită, atât sub
aspectul sarcinilor de executat, cât şi al resurselor şi termenelor stabilite.
2
În literatura de specialitate, etapa de concepţie se regăseşte sub numele de proiectare şi
conţine două subetape: proiectarea de ansamblu (logică) şi proiectarea de detaliu (fizică).
3
Finalizarea, conform metodologiilor existente, cuprinde fazele de testare de ansamblu,
implementare şi evaluare a produsului informatic.
Aplicaţie informatică cu prelucrare de fişiere

Modelul echipei chirurgicale presupune o specializare mai accentuată a

membrilor echipei de analiză-concepţie-programare. Astfel, va exista un manager
care va fi ajutat de un administrator şi un secretar, iar ceilalţi membri ai echipei vor
fi repartizaţi pe diverse sarcini: formalizarea matematică, proiectarea algoritmilor,
stabilirea instrumentelor de programare, elaborarea documentaţiei, determinarea
necesarului de hardware şi software, codificarea şi implementarea, testarea şi
depanarea programelor, crearea interfaţelor om-calculator etc.
Indiferent de modelul ales pentru organizarea activităţii echipei de analiză-
concepţie-programare, acesta trebuie să asigure controlul proiectului în sensul
atingerii obiectivelor privind calitatea produselor software, utilizarea eficientă a
resurselor alocate, încadrarea în costurile alocate şi respectarea termenelor stabilite.
Principalele etape de realizare a proiectelor informatice sunt:

1. Formularea cerinţelor pentru proiect. Realizarea unui proiect

presupune, încă de la început, formularea clară, completă şi corectă a problemei, ca
o cerinţă importantă pentru desfăşurarea cu bune rezultate a activităţii de concepţie
şi finalizare a proiectelor. Cerinţele sunt formulate de beneficiarul proiectului.
După formularea cerinţelor se va stabili echipa de analiză-concepţie-programare,
pentru fiecare membru al echipei atribuindu-se responsabilităţi în procesul de
realizare a proiectului informatic, pornind de la un model de organizare.

2. Analiza. În această fază, plecând de la formularea cerinţelor

informaţionale exprimate concret în date de ieşire, echipa de analiză-proiectare va
identifica transformările şi prelucrările necesare pentru obţinerea acestora. În
funcţie de natura aplicaţiei, se vor stabili formulele matematice şi metodele
numerice corespunzătoare. Aparatul matematic folosit va fi argumentat teoretic în
documentaţia care trebuie să însoţească proiectul informatic în forma finală. Pe
baza exprimării matematice a prelucrărilor şi transformărilor identificate în proiect
se vor stabili datele de intrare4 necesare. De asemenea, se vor pune în evidenţă
condiţiile iniţiale şi restricţiile referitoare la soluţie. La finalul fazei, membrii
echipei vor angaja discuţii în urma cărora se poate reveni pentru eventuale corectări
şi detalieri, înainte de trecerea la faza următoare.

3. Concepţia proiectului (proiectarea aplicaţiei). Pe baza datelor de

intrare/ieşire şi prelucrărilor stabilite în cadrul analizei se proiectează formatele5 de
intrare, formatele de ieşire, codurile şi algoritmii, se definesc colecţiile de date şi

4
Determinarea datelor de intrare pornind de la transformările necesare pentru obţinerea
datelor de ieşire se realizează utilizând tehnica analizei concordanţei ieşiri-intrări (intrările
sunt condiţionate de ieşiri).
5
În acest context, prin format se înţelege modul în care vor fi reprezentate extern (pe ecran
sau pe hârtie) câmpurile pentru citirea datelor de intrare şi cele pentru afişarea rezultatelor.
De asemenea, formatele de intrare/ieşire sunt parte integrantă din interfaţa aplicaţiei
informatice cu utilizatorul, în proiectarea căreia trebuie să fie luate în calcul şi elemente de
estetică şi “ergonomie vizuală” (sarcina responsabilului cu proiectarea interfeţei).
 Algoritmi în programare. Aplicaţii

se stabilesc modulele proiectului care urmează să fie programate (structurarea

proiectului).
Formatele de intrare se vor constitui în ferestre individualizate de preluare
a datelor şi vor conţine câmpuri “dedicate”. Formatele de ieşire trebuie să fie
sugestive, să evidenţieze rezultatele (datele de ieşire) şi să ofere, eventual,
posibilităţi de imprimare. Formatele de intrare/ieşire trebuie să fie descrise şi în
documentaţia proiectului.
Proiectarea codurilor reprezintă o activitate cu implicaţii importante asupra
funcţionării produselor informatice. Codul reprezintă o combinaţie de simboluri
elementare (sau semnale), împreună cu o serie de reguli de combinare a lor,
atribuită univoc unei entităţi reale, pentru a o identifica fără nici un dubiu. Între cod
şi entitatea reală există o relaţie de asociere biunivocă. Simplificând, codurile pot fi
văzute ca “porecle unice” atribuite unor entităţi din cadrul proiectelor informatice.
Cel mai cunoscut exemplu este codul numeric personal, format din 13 caractere:
unul pentru sex, şase pentru data naşterii (an, lună, zi), cinci din registrul de
evidenţă a populaţiei şi o cifră de control. Codificarea este activitatea de stabilire a
codurilor.
Datele care stau la baza obţinerii rezultatelor (informaţiilor de ieşire) vor fi
grupate în colecţii, care vor concretiza sistemul de fişiere sau baza de date. Pot fi
identificate următoarele tipuri de colecţii de date: de bază, pentru tranzacţii,
intermediare, colecţii de date statistice, colecţii de date istorice.
Se identifică funcţiile de prelucrare, care vor fi grupate în entităţi numite
module. Pentru aceasta pot fi utilizate tehnicile de proiectare top-down şi
modularizată6. Etapa se finalizează cu elaborarea schemei de sistem, care ilustrează
modulele de prelucrare, colecţiile de date folosite şi legăturile dintre module şi
colecţii.
Proiectarea algoritmilor este o etapă complexă, care presupune analiza
riguroasă a problemei şi a formalizării ei matematice. Tehnicile top-down şi
modularizată pot fi adoptate şi în proiectarea algoritmilor. Etapa trebuie încheiată,
obligatoriu, cu testarea algoritmilor. Odată cu elaborarea algoritmilor se stabilesc
resursele de calcul necesare: echipamentele periferice, limbajele de programare
care vor fi utilizate, seturile de date care vor fi folosite la testare, necesarul de
memorie internă etc. Necesarul de resurse va trebui să fie trecut în formă explicită
în documentaţie, astfel încât să se poată realiza o exploatare ulterioară corectă a
produsului program.
Codificarea algoritmilor poate fi realizată după elaborarea algoritmilor sau
în paralel, când se lucrează în echipă. Scrierea programelor trebuie să se facă
respectând algoritmii (eventual se pot face modificări şi detalieri ale acestora)
urmărindu-se, în acelaşi timp, optimizarea utilizării resurselor calculatorului (timp
unitate centrală, memorie internă şi periferice) şi realizarea interfeţelor deja
conturate în etapele anterioare.

6
Paragraful 3.8 – Proiectarea algoritmilor, în lucrarea Algoritmi în programare, B. Ghilic-
Micu (coord.), Ed. ASE, Bucureşti 2002, pg. 60
Aplicaţie informatică cu prelucrare de fişiere

În documentaţia proiectului vor apărea în formă explicită detaliile legate de

limbajul de programare ales, de versiunea acestuia, de sistemul de operare sub care
poate rula produsul informatic.

4. Finalizarea proiectului. Odată realizat, proiectul este testat în ansamblu

pe baza unor seturi de date de control prestabilite. Produsele program se consideră
corecte dacă rezultatele obţinute sunt cele scontate (pentru datele de test,
programatorii trebuie să determine apriori rezultatele – valorile şi forma lor de
prezentare). Programele se testează atât independent, cât şi în corelaţie cu cele care
se execută în amonte sau în aval.
Implementarea aplicaţiei informatice presupune asigurarea exploatării sale
în condiţii reale la beneficiar, furnizorul livrând produsul “la cheie” (programe în
formă executabilă, care pot fi exploatate conform manualului de utilizare/
exploatare).

5. Evaluarea proiectelor. La baza elaborării proiectelor informatice stă

conceptul de eficienţă economică, respectiv compararea efectelor obţinute cu
cheltuielile necesare pentru funcţionarea sistemului/aplicaţiei în cauză. În acest
sens s-au formulat mai multe teorii şi concepte care privesc evaluarea eficienţei
proiectelor informatice, şi care se pot clasifica în trei grupe:
1. teorii şi metode bazate pe utilitatea proiectelor – eficienţa lor nu poate fi
pusă în discuţie cât timp acestea nu servesc cerinţelor informaţionale ale
utilizatorului final;
2. teorii şi concepte bazate pe valoarea informaţiilor furnizate prin proiectele
informatice realizate – eficienţa lor rezultă din impactul pe care îl au sistemele/
aplicaţiile respective asupra activităţii de conducere a organizaţiilor economico-
sociale;
3. teorii şi concepte pentru care eficienţa economică se poate evalua prin
contribuţia produselor informatice realizate la sporirea eficienţei activităţilor cu
caracter tehnic, de producţie, economic sau social, numărul indicatorilor utilizaţi
fiind limitat: coeficientul de satisfacere a cerinţelor informaţionale, coeficientul
timpului de răspuns, coeficientul timpului de recuperare, coeficientul economiei de
personal, coeficientul eficienţei economice, coeficientul tehnico-economic.

6. Exploatarea şi mentenanţa. După punerea la punct, produsele intră în

utilizare, fiind urmărite în vederea depistării unor erori care nu au putut fi sesizate
anterior. Această fază asigură menţinerea în funcţiune şi dezvoltarea produselor
informatice, proces care poate să continue pe tot parcursul utilizării lor şi care
poate conduce la dezvoltarea de noi versiuni, bazate pe informaţii despre
comportarea produsului la utilizatorul final.

7. Documentarea. Deşi nu este o etapă distinctă în procesul de realizare a

proiectelor informatice (documentarea se asigură în cadrul fiecărei etape parcurse),
pentru a-i sublinia importanţa şi pentru a crea reflexul întocmirii ei, o punctăm
 Algoritmi în programare. Aplicaţii

metodologic şi separat. Documentarea corectă a proiectului informatic face posibilă

exploatarea, dezvoltarea şi adaptarea produselor, mai ales dacă fac parte dintr-un
sistem informatic, precum şi comercializarea lor către diverşi utilizatori.
Documentaţia proiectului (manuale de prezentare şi utilizare/exploatare), cuprinde:
descrierea problemei (rezultatele, datele de intrare, procesul de prelucrare,
formalizarea matematică şi modelul matematic, precizia algoritmilor etc.);
descrierea resurselor necesare şi a restricţiilor de utilizare;
schema de sistem a proiectului (organigrama modulelor);
schema tehnologică a proiectului (modul de punere în funcţiune a
modulelor);
reprezentarea algoritmilor pentru fiecare modul (schemă logică, pseudocod
etc.);
modul de apel al procedurilor/funcţiilor şi structura datelor/parametrilor
care se transferă între apelator şi apelat;
instrucţiuni de utilizare (procedura de punere în lucru, lista şi forma
întrebărilor şi răspunsurilor în conversaţia cu utilizatorii etc.);
exemple de utilizare.
Documentaţia proiectului poate fi tehnoredactată folosind instrumente
informatice specifice: editoare de texte; editoare grafice; editoare de ecuaţii etc.
Trebuie menţionată, în special pentru dezvoltările ulterioare, utilitatea
autodocumentării proiectelor, realizată sub forma unor comentarii intercalate în
programe.

Evoluţia rapidă în domeniul tehnologiei informaţiei a condus la elaborarea

de noi metodologii pentru realizarea proiectelor informatice. În cazul unui proiect
real, de mari dimensiuni (sistem informatic/produs program) este bine ca echipa de
analiză-concepţie-programare să utilizeze o metodologie de proiectare (consacrată
sau proprie). Există o multitudine de metodologii de analiză-proiectare, începând
cu cele structurate şi continuând cu metodologiile orientate obiect.
În abordarea structurată, cele mai reprezentative metodologii sunt:
SSADM (Structured Systems Analysis and Design Method – elaborată în Marea
Britanie la începutul anilor ’80), MERISE (Franţa), Yourdon&Constantine,
Jackson, SA/SD (Structured Analysis/Structured Design), HIPO (Hierarchycal
Input Proces Output) etc.
Metodologiile de analiză şi proiectare a sistemelor informatice au cunoscut
o îmbunătăţire remarcabilă datorită dezvoltării programării orientate obiect.
Analiza şi proiectarea orientate obiect reprezintă un nou mod de abordare a
problemelor, bazat pe concepte din lumea reală. Modelele orientate obiect
constituie reprezentări abstracte ale sistemelor reale.
Dintre cele mai cunoscute metodologii de analiză-proiectare orientate
obiect fac parte: OOSE (Object Oriented Software Engineering – Ivar Jacobson),
OMT (Object Modelling Technique), OOSA (Object Oriented System Analysis -
Shlaer&Mellor), OOA (Object Oriented Analysis - Coad&Yourdon) etc.
Aplicaţie informatică cu prelucrare de fişiere

Pentru analiza şi proiectarea aplicaţiilor informatice există o serie de

instrumente software (medii integrate de dezvoltare software), care asistă echipa de
analiză-proiectare pe tot parcursul elaborării proiectelor. Astfel de instrumente sunt
produsele CASE (Computer Aided Software Engineering), care oferă posibilităţi
grafice şi de editare, generarea de cod în diferite limbaje de programare,
autodocumentarea proiectelor, conexiuni Internet etc.

Proiectele reale nu pot fi realizate fără un suport adecvat de baze de date

sau sisteme de fişiere, deoarece presupun memorarea stării iniţiale a sistemului şi
actualizarea lui în timp. Pentru exemplificare am ales o problemă a cărei rezolvare
utilizează un sistem de fişiere binare şi text, simulând metodele de organizare
relativă şi indexată.

Formularea cerinţelor pentru proiect

Să se realizeze un proiect de aplicaţie informatică utilizând limbajul Pascal
pentru gestiunea activităţii de închiriere a autoturismelor pentru o societate
comercială din domeniu. Aplicaţia va evidenţia aspectele legate de parcul auto, de
gestiunea clienţilor, contractelor de închiriere şi a facturilor emise. De asemenea,
principalele funcţiuni ale aplicaţiei se vor regăsi în următoarele operaţii, dintre care
unele situaţii se vor obţine la cerere: înregistrări/achiziţii auto; închirieri auto;
reeşalonarea tarifelor auto; radieri auto; emiterea automată a facturilor; plata
facturilor emise şi scadente; prezentarea ofertei auto pe tipuri de autoturisme;
calculul venitului societăţii pe fiecare maşină.

Analiza
Echipa de analiză-concepţie-programare a identificat, pe baza cerinţelor
formulate în proiect, datele de ieşire şi principalele prelucrări necesare pentru
obţinerea acestor date.
Datele de ieşire:
a) facturile emise ca urmare a scadenţei contractelor de închiriere auto;
b) oferta integrală a societăţii (prezentată pe tipuri de autoturisme);
c) venitul înregistrat pe fiecare maşină din parcul auto.
Prelucrări:
a) compararea datei curente din sistem cu data scadenţei contractelor
neonorate, calculul valorii facturii emise luând în calcul numărul de
kilometri parcurşi de client de la momentul închirierii auto; de asemenea,
la calculul valorii facturate se va ţine cont de fidelitatea clientului;
b) ordonarea alfabetică a datelor despre autoturismele din parcul auto în
funcţie de tipul acestora (problemă cu control după caracteristică);
c) calculul valorii închirierilor auto pentru fiecare maşină din parcul auto.
De asemenea, au fost stabilite condiţiile iniţiale şi restricţiile referitoare la
soluţie:
- o maşină nu poate fi închiriată dacă apare într-un contract neonorat;
 Algoritmi în programare. Aplicaţii

- unicitatea numerelor de înmatriculare auto;

- o maşină poate fi radiată dacă nu face obiectul unui contract de
închiriere neonorat;
- valoarea facturată este calculată cu o precizie de două zecimale;
- oferta auto a societăţii va fi afişată pe ecran şi va fi memorată într-un
fişier text.
Pe baza prelucrărilor, pentru obţinerea datelor de ieşire, au fost definite
următoarele date de intrare: informaţiile despre o maşină (număr auto, marca, anul
fabricaţiei, tariful la 100 km, starea, numărul de km la bord). Alte date de intrare,
care participă la obţinerea datelor de ieşire vor fi construite (introduse) interactiv şi
constau din informaţiile despre clienţi (cod, nume, adresa, număr de contracte
încheiate), contracte şi facturi.

Concepţia proiectului (proiectarea aplicaţiei)

Plecând de la analiza proiectului, în această etapă au fost definite formatele
de intrare/ieşire, s-au proiectat codurile, colecţiile de date şi modulele aplicaţiei,
precum şi algoritmii care vor fi programaţi. De asemenea, au fost elaborate schema
de sistem a proiectului şi schema tehnologică de punere în funcţiune a modulelor.
Formatele de intrare au fost proiectate pornindu-se de la datele de intrare
identificate. Pentru crearea fişierelor cu date despre parcul auto, clienţi, contracte şi
facturi, a fost realizat un program independent (creare), care realizează crearea
fără articole a fişierelor.
Pentru toate situaţiile formulate în problemă au fost proiectate formate de
ieşire care oferă posibilitatea obţinerii rezultatelor în fişiere text şi/sau pe ecran.
Fişierele rezultate vor avea nume sugestive, în funcţie de cerinţele solicitate de
utilizator, şi pot fi vizualizate în orice editor de texte. Conţinuturile fişierelor de
ieşire vor fi prezentate în documentaţia proiectului.
Corespunzător situaţiilor prezentate, au fost proiectate opt module
specializate, apelate din modulul principal al proiectului. Pe baza modulelor
proiectate, au fost definitivate schema de sistem a proiectului şi schema
tehnologică de punere în lucru a modulelor.
Activitatea de codificare vizează caracteristicile maşinilor din parcul auto,
informaţiile despre clienţi, atributele contractelor de închiriere şi informaţiile dintr-
o factură. Codificarea va ajuta şi la definirea colecţiilor de date.
Colecţiile de date externe alese sunt fişiere binare, câte unul pentru maşini,
clienţi, contracte şi facturi. Structura logică a articolelor din fiecare fişier este
descrisă în manualul de prezentare:
Algoritmii s-au realizat folosind metoda proiectării structurate, iar pentru
implementarea acestora s-a utilizat limbajul Pascal. În cadrul algoritmilor nu au
fost proiectate secvenţe de validare7. Descrierea detaliată a algoritmilor poate fi
studiată în documentaţia proiectului. De asemenea, primitivele folosite în lucrul cu

7
Pentru validare a se vedea capitolul 11 – Validarea datelor, din lucrarea Algoritmi în
programare, B. Ghilic-Micu (coord.), Ed. ASE, Bucureşti 2002, pg. 183
Aplicaţie informatică cu prelucrare de fişiere

fişiere relative (clienti.dat) şi fişiere indexate (auto.dat) sunt prezentate

detaliat în capitolele 7 şi 8 ale acestei lucrări).
Diferenţele faţă de unităţile relativ.tpu şi indexate.tpu constau în
structura articolelor (tabelul 9.1).

Tabelul 9.1. Diferenţe faţă de unităţile din capitolele 7 şi 8

UNIT Indexate;
INTERFACE
TYPE UNIT Relativ;
TipCheie= string[7]; INTERFACE
TipArt=RECORD TYPE
nrm:TipCheie; tipa=RECORD
is:BYTE;
marca:string[15]; nume:string[40];
an:word; adr:string[30];
tarif:real; nrc:byte;
stare:0..1; END;
nrkm:longint tipf=FILE of tipa;
end;
TipFis=FILE OF TipArt;

Finalizarea proiectului
Pentru această fază, proiectul a fost testat în ansamblu, verificându-se
astfel funcţionalitatea acestuia. Testarea s-a realizat utilizând date de test. După
testare, proiectul informatic este livrat beneficiarului, unde va fi implementat şi
pregătit pentru exploatare.

Exploatarea şi mentenanţa
Aplicaţia va fi exploatată la beneficiar, urmărindu-se comportamentul
acesteia pe parcursul utilizării.

Documentarea
Documentaţia proiectului cuprinde manualele de prezentare şi de
utilizare/exploatare. Pentru tehnoredactarea acestora a fost folosit editorul de texte
Microsoft Word 2002, editorul de ecuaţii Microsoft Equation 3.0 şi editorul grafic
Microsoft Word Picture 2002.
 Algoritmi în programare. Aplicaţii

9.2. Dosarul de prezentare a aplicaţiei

Aplicaţia realizată permite gestiunea activităţii de închiriere a

autoturismelor pentru o societate comercială din domeniu. Aplicaţia evidenţiază
aspectele legate de parcul auto, de gestiunea clienţilor, contractelor de închiriere şi
a facturilor emise. Principalele funcţiuni ale aplicaţiei sunt următoarele:
A. înregistrări/achiziţii auto;
B. închirieri auto;
C. actualizarea tarifelor auto;
D. radieri auto;
E. emiterea automată a facturilor;
F. plata facturilor emise şi scadente;
G. prezentarea ofertei auto pe tipuri de autoturisme;
H. calculul venitului societăţii pe fiecare maşină.
Aplicaţia simulare este scrisă în Limbajul Pascal, versiunea 6.0, fiind
structurată în opt module, câte unul pentru fiecare funcţiune. Punerea în execuţie a
modulelor aplicaţiei se realizează conform schemei de sistem (figura 9.1).

funcţia 1 A

funcţia 2 B

funcţia 3 C

M en iu
principal funcţia 4 D

funcţia 5 E

funcţia 6 F

G
funcţia 7

funcţia 8 H
Fig. 9.1. Schema de sistem a proiectului
Aplicaţie informatică cu prelucrare de fişiere

Prelucrările aplicaţiei folosesc patru colecţiile de date externe (fişiere

binare), câte unul pentru maşini, clienţi, contracte şi facturi. Structura logică a
articolelor din fiecare fişier este:
Fişierul auto.dat, organizat indexat după cheia primară nrauto:

numărul de număr de
tipul auto, anul de tariful la starea maşinii:
Semnificaţie înmatriculare auto km la
marca fabricaţie 100 km închiriată sau nu
(cheia primară) bord
Codificare nrm marca an tarif stare nrkm
Tip string[7] string[15] word real 0..1 longint

Fişierul clienti.dat, organizat relativ după cheia relativă codclient:

codul clientului indicatorul de numele şi număr de

adresa
Semnificaţie (cheia stare a prenumele contracte
clientului
relativă) articolului clientului încheiate
Codificare codc is nume adr nrc
Tip word byte string[40] string[30] byte

Fişierul contr.dat, organizat secvenţial:

numărul starea
data număr data
numărul codul auto al contractului:
Semnificaţie încheierii de km stingerii
contractului clientului maşinii în derulare
contractului parcurşi contractului
închiriate sau stins
Codificare nrc codc nrm dataem nrkm scadenta on
Tip word word string[7] data* longint data* 0..1
* a fost definit tipul data, de forma: an (word), luna (1..12), zi (1..31).

Fişierul facturi.dat, organizat secvenţial:

numărul starea
număr
numărul numărul numele auto al valoarea facturii:
Semnificaţie de km
facturii contractului clientului maşinii facturii achitată sau
parcurşi
închiriate nu
Codificare nrf nrc nume nrm nrkm val achitat
Tip word word string[40] string[7] longint real 0..1

Pentru memorarea datelor din fişierele aplicaţiei au fost definite, ca

structuri de date interne, următoarele tipuri de articole:

TipCheie= string[7];
TipArt=record
nrm:TipCheie;
marca:string[15];
an:word;
tarif:real;
stare:0..1;
nrkm:longint
end;
 Algoritmi în programare. Aplicaţii

tipa=record
is:BYTE;
nume:string[40];
adr:string[30];
nrc:byte;
end;
data=record
an:word;
luna:1..12;
zi:1..31
end;
contr=record
nrc:word;
codc:word;
nrm:tipcheie;
dataem:data;
nrkm:longint;
scadenta:data;
on:0..1
end;
facturi=record
nrf:word;
nrc:word;
nume:string[40];
nrm:tipcheie;
nrkm:longint;
val:real;
achitat:0..1
end;

Simultan cu crearea fişierului indexat (de date) auto.dat se creează

automat şi fişierul secvenţial auto.idx care va conţine tabela de indexuri
asociată. Structura articolului tabelei de indexuri este prezentată în capitolul 8.
Pentru fiecare modul au fost proiectate seturi de date de test, modulele
fiind testate atât individual, cât şi în inter-funcţionalitatea lor. Structura sistemului
de fişiere a fost proiectată astfel încât să simuleze funcţionarea unei baze de date
relaţionale (figura 9.2).
Pentru funcţiunea G a aplicaţiei se creează un fişier temporar de manevră
pe baza căruia se obţine oferta de maşini grupate după câmpul marca. Structura
logică a articolelor din fişierul de manevră este următoarea:

manevra=record
nrauto:string[7];
marca:string[15];
tarif:real;
nrkm:longint
end;
Aplicaţie informatică cu prelucrare de fişiere

OFERTA.TXT
MANEVRA.TMP

codc

AUTO.DAT CLIENTI.DAT

nume
MENIU PRINCIPAL
nrm

CONTR.DAT FACTURI.DAT
nrc

Fig. 9.2. Relaţiile dintre fişierele aplicaţiei

Descrierea algoritmilor pe funcţiuni

1. Modulul functia1 (funcţiunea A) este o operaţie de adăugare în acces

direct în fişierul indexat auto.dat. Se folosesc primitivele openold, start,
writekeyrec şi closefis din unitatea indexate. Dacă valoarea cheii primare
(nrm) introdusă de la tastatură este validă se realizează preluarea câmpurilor din
structura articolului, se setează starea pe valoarea 0 (neînchiriat) şi se scrie articolul
în fişier. Fişierul conducător este tastatura, iar în caz de cheie invalidă se
semnalează eroare.
2. Modulul functia2 (funcţiunea B) constă în mai multe operaţii:
- introducerea de la tastatură a tipului de maşină pe care doreşte să o închirieze
clientul (marca);
- căutare în acces secvenţial în fişierul indexat auto.dat utilizând primitiva
readseqrec din unitatea indexate; căutarea se face cu selecţie după două
criterii (marca şi starea);
- afişarea ofertei disponibile pentru marca căutată;
- alegerea maşinii care va face obiectul unui nou contract de închiriere (prin
introducerea de la tastatură a cheii primare corespunzătoare maşinii din oferta
afişată la pasul anterior);
- introducerea datelor despre client cu validarea cheii relative (codc) din
fişierul clienti.dat (se foloseşte primitiva writed din unitatea relativ);
- în cazul în care clientul există se realizează operaţia de modificare a
numărului de contracte de închiriere (sporul de fidelitate);
 Algoritmi în programare. Aplicaţii

- adăugare în acces secvenţial în fişierul contr.dat după ce sunt completate

celelalte câmpuri ale articolului şi starea contractului ia valoarea 0 (contract în
derulare).
3. Modulul functia3 (funcţiunea C) realizează reeşalonarea tarifelor prin
creşterea acestora cu 10% şi constă în operaţia de modificare în acces secvenţial a
articolelor din fişierul auto.dat, utilizând primitivele readseqrec şi
rewriterec din unitatea indexate.
4. Modulul functia4 (funcţiunea D) realizează ştergerea în acces direct a
articolelor din fişierul indexat auto.idx pentru cheile primare citite de la
tastatură. Radierea unei maşini se poate face doar dacă nu există contracte
neonorate pentru maşina respectivă. Această verificare se face comparând data
curentă din sistem (citită cu procedura getdate din unitatea DOS a mediului
Pascal) cu data de scadenţă a contractelor neonorate, folosindu-se o funcţie special
construită dme.
5. Modulul functia5 (funcţiunea E) realizează adăugarea în acces
secvenţial la sfârşitul fişierului facturi.dat. O factură este emisă automat dacă
în fişierul de contracte se găseşte o înregistrare care are ca dată de scadenţă data
curentă din sistem. În momentul emiterii facturii are loc calculul valorii acesteia pe
baza numărului de kilometri parcurşi de la momentul încheierii contractului de
închiriere. În cazul în care clientul este fidel (numărul de contracte încheiate este de
cel puţin cinci), aplicaţia permite acordarea unui discount de 10%. De asemenea,
odată cu emiterea facturii se modifică în acces direct şi starea maşinii din fişierul
auto.dat.
6. Modulul functia6 (funcţiunea F) cuprinde două operaţii de
modificare: modificarea stării facturii după achitare şi modificarea stării
contractului aferent (stingerea acestuia).
7. Modulul functia7 (funcţiunea G) constituie un model de problemă cu
control după caracteristică (marca). Astfel, pe baza fişierului indexat auto.dat
se creează un fişier temporar (manevra.tmp) care este şters fizic la ieşirea din
această funcţiune. Fişierul temporar este ordonat după caracteristica de grupare
marca, obţinându-se apoi pe ecran şi în lista oferta.txt oferta de maşini.
8. Modulul functia6 (funcţiunea H) este o operaţie de consultare în
acces secvenţial a fişierului facturi.dat, după o validare prealabilă a cheii
primare nrm (introdusă de la tastatură) în fişierul indexat auto.dat. În cazul când
cheia există se realizează totalul facturilor achitate în urma stingerii contractelor de
închiriere care au avut ca obiect maşina cu numărul auto corespunzător cheii.

Instalarea produsului informatic

La instalarea produsului, beneficiarul va lansa în execuţie programul

creare.exe, care realizează crearea fişierelor aplicaţiei fără articole. Utilizatorul
va trebui să furnizeze de la tastatură numele asociate fişierelor fizice pe disc.
Aplicaţie informatică cu prelucrare de fişiere

Urmează punerea în execuţie a aplicaţiei simulare, în urma căreia va fi

afişat meniul principal al aplicaţiei.

Utilizatorul poate alege una din cele opt opţiuni, iar pentru fiecare opţiune
se deschide un ecran special în care sunt preluate datele de intrare şi sunt afişate
rezultatele.
Dacă este aleasă opţiunea 2 şi clientul care urmează să închirieze maşina
este nou (nu există în fişierul clienti.dat), ecranul aplicaţiei va arăta astfel:

Dacă este aleasă opţiunea 5 şi există facturi scadente la momentul apelării

opţiunii, se emite automat o factură de următoarea formă:
 Algoritmi în programare. Aplicaţii

Pentru opţiunea 7 rezultatul este afişat pe ecran, dar va fi salvat şi într-un

fişier text numit oferta.txt.
Aplicaţie informatică cu prelucrare de fişiere

DOSAR DE PREZENTARE

Anexa A: fişierul sursă creare.pas

program creare;
uses crt, relativ, indexate;
type data=record
an:word;
luna:1..12;
zi:1..31
end;
contr=record
nrc:word;
codc:word;
nrm:tipcheie;
dataem:data;
nrkm:longint;
scadenta:data;
on:0..1
end;
facturi=record
nrf:word;
nrc:word;
nume:string[40];
nrm:tipcheie;
nrkm:longint;
val:real;
achitat:0..1
end;
var f:tipfis; g:tipf;
h1:file of contr; h2:file of facturi;
numef,numeg,numeh1,numeh2:string;
ivk:boolean;
begin
clrscr;
write('Numele fisierului de masini:');
readln(numef);
opennew(f,numef,ivk);
write('Numele fisierului de clienti:');
readln(numeg);
open(g,numeg,0,ivk);
write('Numele fisierului de contracte:');
readln(numeh1);
assign(h1,numeh1); rewrite(h1);
write('Numele fisierului de facturi:');
readln(numeh2);
assign(h2,numeh2); rewrite(h2);
end.
 Algoritmi în programare. Aplicaţii

DOSAR DE PREZENTARE

Anexa B: fişierul sursă simulare.pas

program simulare;
uses dos,crt,relativ,indexate;
type data=record
an:word;
luna:word;
zi:word
end;
contr=record
nrc:word;
codc:word;
nrm:tipcheie;
dataem:data;
nrkm:longint;
scadenta:data;
on:0..1
end;
facturi=record
nrf:word;
nrc:word;
nume:string[40];
nrm:tipcheie;
nrkm:longint;
val:real;
achitat:0..1
end;
manevra=record
nrauto:string[7];
marca:string[15];
tarif:real;
nrkm:longint
end;
const numef:string='auto.dat';
numeg:string='clienti.dat';
numeh1:string='contr.dat';
numeh2:string='facturi.dat';
var f:tipfis; g:tipf; h1:file of contr; h2:file of facturi;
m:file of manevra; l:text;
a:tipart; b:tipa; c:contr; d:facturi; t,z:manevra;
ivk,sf,vb:boolean; opt:0..8; i:byte;
datas:data; codc,sapt:word; nrm_t:tipcheie;
c1,marca_t:string[15]; r:char; n:longint; tot:real;
procedure meniu;
begin
reset(input); clrscr;
gotoxy(30,7); write('Aplicatie multifunctionala RENT A CAR');
gotoxy(26,9); write('1. Achizitie auto');
gotoxy(26,10); write('2. Inchiriere auto');
gotoxy(26,11); write('3. Cresterea pretului carburantului cu 10%');
gotoxy(26,12); write('4. Radiere auto');
gotoxy(26,13); write('5. Emitere automata factura');
Aplicaţie informatică cu prelucrare de fişiere

gotoxy(26,14); write('6. Plata factura');

gotoxy(26,15); write('7. Oferta auto pe tipuri de masini');
gotoxy(26,16); write('8. Valoarea inchirierilor pe masina');
gotoxy(20,18); write('Functia aleasa (sau 0):');
gotoxy(46,18); readln(opt);
end;
procedure functia1;
begin
clrscr; checkeof:=true; openold(f,numef,ivk);
if ivk then writeln('Fisier inexistent!')
else begin
gotoxy(20,2);
write('Nr. de inmatriculare (exp: B92BGM) sau ^Z:');
while not eof do
begin
gotoxy(20,42);
readln(nrm_t);
for i:=1 to length(nrm_t) do nrm_t[i]:=upcase(nrm_t[i]);
start(f,nrm_t,ivk);
if not ivk then begin
gotoxy(26,18);
writeln('Nr. deja existent!');
gotoxy(26,18); readln;
clreol
end
else begin
writeln;
a.nrm:=nrm_t;
write('Marca :'); readln(a.marca);
for i:=1 to length(a.marca) do
a.marca[i]:=upcase(a.marca[i]);
write('Anul fabricatiei :'); readln(a.an);
write('Tarif la 100 km :'); readln(a.tarif);
write('Nr. km la bord :'); readln(a.nrkm);
a.stare:=0;
writekeyrec(f,a,nrm_t,ivk)
end;
writeln;
write('Nr. de inmatriculare (exp: B92BGM) sau ^Z:')
end
end;
closefile(f)
end;
procedure functia2;
begin
clrscr; checkeof:=true;
assign(h1,numeh1); reset(h1); seek(h1,filesize(h1));
assign(g,numeg); reset(g);
write('Marca sau ^Z:');
while not eof do
begin
openold(f,numef,ivk);
readln(marca_t);
for i:=1 to length(marca_t) do
marca_t[i]:=upcase(marca_t[i]);
 Algoritmi în programare. Aplicaţii

sf:=false; vb:=false; i:=0;

readseqrec(f,a,sf);
while not sf do
begin
if (a.marca=marca_t) and (a.stare=0) then
begin
inc(i);
gotoxy(10,2+i);
write(a.nrm,' ',a.marca,
' ',a.nrkm:5,' km la bord');
vb:=true
end;
readseqrec(f,a,sf)
end;
readln;
if not vb then begin
gotoxy(26,18);
writeln('Marca de masina inexistenta sau alocata!');
gotoxy(26,18); readln;
clrscr
end
else
begin
writeln;
write('Nr. de inmatriculare din oferta:');
readln(nrm_t);
for i:=1 to length(nrm_t) do nrm_t[i]:=upcase(nrm_t[i]);
readkeyrec(f,a,nrm_t,ivk);
if ivk then writeln('Nr. de inmatriculare introdus gresit!')
else begin
a.stare:=1;
rewriterec(f,a,ivk);
closefile(f);
c.nrm:=a.nrm;
c.nrc:=filesize(h1)+1;
c.nrkm:=a.nrkm;
getdate(c.dataem.an,c.dataem.luna,c.dataem.zi,sapt);
write('Codul clientului:');
readln(codc);
readd(g,b,codc,ivk);
if ivk then begin
writeln('Client nou!');
write('Nume:'); readln(b.nume);
write('Adresa:'); readln(b.adr);
b.nrc:=1;
writed(g,b,codc,ivk)
end
else begin
b.nrc:=b.nrc+1;
writed(g,b,codc,ivk)
end;
writeln('Data scadentei contractului:');
write('Anul:'); readln(c.scadenta.an);
write('Luna:'); readln(c.scadenta.luna);
write('Ziua:'); readln(c.scadenta.zi);
Aplicaţie informatică cu prelucrare de fişiere

c.on:=0;
write(h1,c); clrscr
end
end;
write('Marca sau ^Z:')
end;
close(h1); close(g)
end;
procedure functia3;
begin
openold(f,numef,ivk);
clrscr; writeln('Tarifele la inchirieri auto vor creste cu 10%');
sf:=false;
readseqrec(f,a,sf);
while not sf do
begin
a.tarif:=a.tarif*1.1;
rewriterec(f,a,ivk);
readseqrec(f,a,sf)
end;
gotoxy(20,20); write('Sfarsit de operatie. Apasati ENTER'); readln;
closefile(f)
end;
function dme(var d1,d2:data):boolean;
begin
if d1.an>=d2.an then
if (d1.an=d2.an) and (d1.luna>=d2.luna) then
if (d1.an=d2.an) and (d1.luna=d2.luna) and (d1.zi>=d2.zi)
then dme:=true
else dme:=false
end;
procedure functia4;
begin
clrscr; checkeof:=true;
openold(f,numef,ivk);
write('Nr. de inmatriculare al masinii de radiat sau ^Z:');
while not eof do
begin
readln(nrm_t);
for i:=1 to length(nrm_t) do nrm_t[i]:=upcase(nrm_t[i]);
readkeyrec(f,a,nrm_t,ivk);
if ivk then begin
gotoxy(26,18);
writeln('Masina neinmatriculata sau radiata!');
gotoxy(26,18); readln; clrscr
end
else begin
if a.stare=1 then writeln('Pentru masina cu numarul ',
nrm_t,' exista contracte neonorate!')
else begin
writeln;
writeln('Nr. de inmatriculare: ',a.nrm);
writeln('Marca: ',a.marca);
writeln('Anul fabricatiei: ',a.an);
writeln('Tarif la 100 km: ',a.tarif:6:0,' USD');
 Algoritmi în programare. Aplicaţii

writeln;
write('Confirmati radierea (d/n)?');
readln(r);
if upcase(r)='D' then deletekeyrec(f,nrm_t,ivk)
end
end;
write('Nr. inmatriculare al masinii de radiat sau ^Z:')
end;
closefile(f)
end;
procedure functia5;
begin
clrscr;
assign(h2,numeh2); reset(h2); seek(h2,filesize(h2));
assign(h1,numeh1); reset(h1);
assign(g,numeg); reset(g);
openold(f,numef,ivk);
getdate(datas.an,datas.luna,datas.zi,sapt);
while not eof(h1) do
begin
vb:=false;
read(h1,c);
if (dme(datas,c.scadenta)) and (c.on=0) then
begin
vb:=true;
d.nrf:=filesize(h2)+1;
d.nrc:=c.nrc;
readd(g,b,c.codc,ivk);
d.nume:=b.nume;
d.nrm:=c.nrm;
writeln('Factura aferenta contractului nr. ',d.nrc,
' pentru masina ',d.nrm);
repeat
write('Nr. de km: '); readln(n);
if n<c.nrkm then writeln('Km mai putini decat la '
'inchiriere!')
until n>=c.nrkm;
d.nrkm:=n;
readkeyrec(f,a,c.nrm,ivk);
d.val:=(d.nrkm-c.nrkm)*a.tarif/100;
if b.nrc>=5 then d.val:=0.9*d.val;
d.achitat:=0;
write(h2,d);
readkeyrec(f,a,d.nrm,ivk);
a.stare:=0;
rewriterec(f,a,ivk);
clrscr;
gotoxy(20,2); write('FACTURA FISCALA nr. ',d.nrf:5);
gotoxy(15,4); write('S.C. RENT A CAR S.R.L. BUCURESTI');
gotoxy(12,7); write('Contravaloarea contractului nr. ',
d.nrc:6);
gotoxy(12,8); write('Numele clientului: ',d.nume);
gotoxy(12,9); write('Nr. masinii inchiriate: ',d.nrm);
gotoxy(12,11); write('Valoare factura: ',d.val:10:2,
' USD');
Aplicaţie informatică cu prelucrare de fişiere

gotoxy(20,15); write('Emitent');
gotoxy(50,15); write('Beneficiar');
readln;
clrscr
end
end;
if not vb then writeln('Nu sunt contracte scadente astazi!');
readln;
closefile(f);
close(g);
close(h1);
close(h2)
end;
procedure functia6;
begin
clrscr;
assign(h2,numeh2); reset(h2);
assign(h1,numeh1); reset(h1);
openold(f,numef,ivk);
while not eof(h2) do
begin
read(h2,d);
vb:=false;
if d.achitat=0 then begin
vb:=true;
writeln('Nr. factura: ',d.nrf);
writeln('Nr. contract: ',d.nrc);
writeln('Nr. auto: ',d.nrm);
writeln('Valoare: ',d.val:10:2,' USD');
writeln;
write('Platiti factura (d/n)?');
readln(r);
if upcase(r)='D' then begin
d.achitat:=1;
seek(h2,filepos(h2)-1);
write(h2,d);
reset(h1);
while not eof(h1) do begin
read(h1,c);
if c.nrc=d.nrc then begin
c.on:=1;
seek(h1,filepos(h1)-1);
write(h1,c)
end
end
end
end
end;
if not vb then writeln('Nu exista facturi de platit!');
readln;
closefile(f);
close(h1);
close(h2)
end;
 Algoritmi în programare. Aplicaţii

procedure functia7;
begin
openold(f,numef,ivk);
assign(m,'manevra.tmp');
rewrite(m);
readseqrec(f,a,sf);
while not sf do
begin
if a.stare=0 then
begin
t.nrauto:=a.nrm;
t.marca:=a.marca;
t.tarif:=a.tarif;
t.nrkm:=a.nrkm;
write(m,t)
end;
readseqrec(f,a,sf)
end;
closefile(f);
{sortarea dupa marca}
repeat
vb:=false;
for i:=1 to filesize(m)-1 do
begin
seek(m,i-1);
read(m,t,z);
if t.marca>z.marca then begin
seek(m,i-1);
write(m,z,t);
vb:=true
end
end
until not vb;
{obtinerea ofertei}
assign(l,'oferta.txt');
rewrite(l);
clrscr;
seek(m,0);
writeln(l,' Oferta de masini');
writeln(l,'_____________________________________');
writeln(l,'| Nr. auto | Tarif | Nr. km la bord |');
writeln(l,'_____________________________________');
writeln(' Oferta de masini');
writeln('_____________________________________');
writeln('| Nr. auto | Tarif | Nr. km la bord |');
writeln('_____________________________________');
sf:=false;
fillchar(t.nrauto,8,' ');
read(m,t);
while not sf do
begin
c1:=t.marca;
writeln(l,c1);
writeln(c1);
while (not sf) and (t.marca=c1) do
Aplicaţie informatică cu prelucrare de fişiere

begin
t.nrauto[0]:=#7;
writeln(l,'|',t.nrauto,' |',t.tarif:7:2,'|',
t.nrkm:16,'|');
writeln('|',t.nrauto,' |',t.tarif:7:2,'|',
t.nrkm:16,'|');
fillchar(t.nrauto,8,' ');
{$I-} read(m,t) {$I+};
if ioresult<>0 then sf:=true
end;
writeln(l,'_____________________________________');
writeln('_____________________________________')
end;
close(m);
erase(m);
close(l);
readln
end;
procedure functia8;
begin
clrscr;
checkeof:=true;
openold(f,numef,ivk);
assign(h2,numeh2);
reset(h2);
write('Nr. de inmatriculare al masinii sau ^Z:');
while not eof do
begin
readln(nrm_t);
for i:=1 to length(nrm_t) do nrm_t[i]:=upcase(nrm_t[i]);
start(f,nrm_t,ivk);
if ivk then begin
gotoxy(26,18);
writeln('Masina neinmatriculata sau radiata!');
gotoxy(26,18);
readln; clrscr
end
else begin
seek(h2,0);
tot:=0;
while not eof(h2) do
begin
read(h2,d);
if (d.nrm=nrm_t) and (d.achitat=1) then
tot:=tot+d.val
end;
writeln('Masina ',nrm_t:7,' a inregistrat o valoare a'+
' inchirierilor de ',tot:7:2,' USD');
readln
end;
write('Nr. de inmatriculare sau ^Z:')
end;
closefile(f);
close(h2)
end;
 Algoritmi în programare. Aplicaţii

{programul principal}
begin
meniu;
while opt<>0 do begin
case opt of
1: functia1;
2: functia2;
3: functia3;
4: functia4;
5: functia5;
6: functia6;
7: functia7;
8: functia8
end;
meniu
end
end.

9.3. Dosarul de utilizare/exploatare a aplicaţiei

Pentru exploatarea corectă a produsului informatic proiectat, beneficiarul

trebuie să asigure un minim de resurse hardware şi software, care constă în:
- calculator IBM-PC sau compatibil;
- microprocesor 80386, frecvenţa de 166 MHz;
- memorie RAM 16 Mb;
- monitor VGA;
- sistem de operare MS-DOS, versiunea 6.2;
- limbajul de programare Pascal, versiunea 6.0;
- un editor de texte.

Etape în utilizarea produsului simulare:

1. Lansarea în execuţie a aplicaţiei creare.exe, pentru crearea, fără

articole, a fişierelor referitoare la parcul auto (auto.dat şi auto.idx), la clienţi
(clienti.dat), la contracte (contr.dat) şi la facturi (facturi.dat).
2. Lansarea în execuţie a aplicaţiei simulare.exe, care execută următorii
paşi:
2.1. afişează meniul principal;
2.2. execută funcţiunile din meniul principal dacă pasul 1 s-a
realizat corect (în soluţia adoptată, numele fişierelor sunt stabilite în aplicaţia
simulare în secţiunea const).
3. Utilizatorul va solicita execuţia uneia din opţiunile meniului.
4. După execuţia fiecărei opţiuni, simulare revine în meniul principal.
5. Terminarea execuţiei se poate realiza prin alegerea opţiunii 0 din meniu.