Curs Programarea Calc ID

UNIVERSITATEA „CONSTANTIN BRANCUŞI” DIN TÂRGU JIU
FACULTATEA DE ŞTIINŢE ECONOMICE ŞI GESTIUNEA AFACERILOR

DEPARTAMENTUL PENTRU ÎNVĂŢĂMÂNT LA DISTANŢĂ
Lector univ. dr. CARINA-ELENA STEGĂROIU
PROGRAMAREA CALCULATOARELOR
pentru uzul studenţilor ID
Editura Academica Brâncuşi

Târgu Jiu, 2011
1
Referenţi ştiinţifici:
Prof. univ. dr. BABUCEA GABRIELA
Prof. univ. dr. BONCEA AMELIA
2
Cuprins
INTRODUCERE..........................................................................................................................6
MODULUL 1................................................................................................................................8
UNITATEA 1 – INTRODUCERE ÎN PROGRAMARE...............................................................9
U1.1. Scopul şi obiectivele unităţii................................................................................................9
U1.2. Introducere în programare...................................................................................................9
U1.3. Noţiuni de programare.......................................................................................................10
U1.4. Mediu de programare.........................................................................................................14
U1.5. Test de autoevaluare nr. 1...................................................................................................17
U1.6. Rezumat.............................................................................................................................17
Bibliografie minimală..................................................................................................................17
Răspunsuri şi comentarii la testul de autoevaluare nr. 1..............................................................17
UNITATEA 2 – TIPURI DE LIMBAJE DE PROGRAMARE..................................................18

U2.1. Scopul şi obiectivele unităţii..............................................................................................18
U2.2. Noţiuni introductive...........................................................................................................18
U2.3. Limbajele de nivel scăzut - de nivel înalt..........................................................................19
U2.4. Limbaje procedurale / neprocedurale................................................................................21
U2.5. Limbaje orientat.................................................................................................................23
U2.6. Limbaje concurente...........................................................................................................24
U2.8. Rezumat.............................................................................................................................24
UNITATEA 3 – LIMBAJE DE PROGRAMARE.......................................................................26

U3.2. Abordări conceptuale.........................................................................................................26
U3.3. Limbaje de nivel înalt neorientate.....................................................................................28
3.3.1. Basic..............................................................................................................................28
3.3.2. Fortran...........................................................................................................................29
3.3.3. Pascal............................................................................................................................30
3.3.4. Pascal for Windows......................................................................................................32
3.3.5. Limbajul C....................................................................................................................33
3.3.6. ADA..............................................................................................................................34
U3.5. Rezumat.............................................................................................................................36
UNITATEA 4 – LIMBAJE ORIENTATE PE GESTIUNEA BAZELOR DE DATE...............37

U4.2. Limbaje orientate de gestiunea bazelor de date.................................................................37
U4.3. Caracteristici definitorii S.G.B.D.-uri clasice....................................................................39
U4.4. Tipuri de SGBD: DBASE, PARADOX, FOX...................................................................41
U4.6. Rezumat.............................................................................................................................43
MODULUL 2..............................................................................................................................44
UNITATEA 5 – REZOLVAREA PROBLEMELOR ECONOMICE CU AJUTORUL
PROGRAMELOR PE CALCULATOR..........................................................45
U5.2. Programare.........................................................................................................................45
3
U5.3. Noţiuni de bază specifice procesului de prelucrare automată a datelor.............................46
U5.5. Rezumat.............................................................................................................................49
UNITATEA 6 – NOŢIUNI DE BAZĂ REFERITOARE LA PROGRAMARE.......................51

U6.2. Noţiuni de bază referitoare la programare.........................................................................51
U6.3. Problematica generală a limbajelor de programare...........................................................57
U6.4. Rezumat.............................................................................................................................60
UNITATEA 7 – ELEMENTELE DE BAZĂ ALE PROGRAMĂRII ORIENTATE PE

OBIECTE............................................................................................................61
U7.2. Abordare conceptuală........................................................................................................61
U7.4. Rezumat.............................................................................................................................65
MODULUL 3..............................................................................................................................67
UNITATEA 8 – LIMBAJUL DE PROGRAMARE VISUAL BASIC........................................68
U8.2. Caractersticile generale ale mediului integrat de dezvoltare Visual Basic.......................68
U8.3. Componentele de bază ale mediului integrat de dezvoltare Visual Basic.........................70
U8.5. Rezumat.............................................................................................................................73
UNITATEA 9 – PROIECTAREA APLICAŢIILOR ÎN LIMBAJUL VISUAL BASIC...........75

U9.2. Proiectarea aplicaţiilor în limbajul Visual Basic................................................................75
9.2.1. Fişierul proiect..............................................................................................................76
9.2.2. Crearea interfeţei aplicaţiei...........................................................................................78
9.2.3. Precizarea proprietăţilor................................................................................................84
9.2.4. Scrierea codului............................................................................................................86
9.2.5. Execuţia aplicaţiei informatice în Visual Basic............................................................89
U9.3. Elementele limbajului de programare Visual Basic...........................................................89
9.3.1. Unele reguli de scriere..................................................................................................89
9.3.2. Tipuri de date................................................................................................................91
9.3.3. Variabile şi constante....................................................................................................92
9.3.4. Constante simbolice utilizate în Visual Basic...............................................................94
U9.5. Rezumat.............................................................................................................................94
MODULUL 4..............................................................................................................................96
UNITATEA 10 – FOXPRO............................................................................................................97
U10.1. Scopul şi obiectivele unităţii............................................................................................97
U10.2. Prezentare generală FOXPRO.........................................................................................98
U10.3. Intrarea şi ieşirea din FoxProW. Mediul FoxProW. Elemente de interfaţă....................103
U10.4. Tipul logic......................................................................................................................104
4
U10.5. Tipul numeric.................................................................................................................105
U10.6. Tipul şir de caractere......................................................................................................109
U10.7. Tipul memo....................................................................................................................112
U10.8. Tipul dată calendaristică................................................................................................112
U10.9. Baze de date...................................................................................................................116
10.9.1. Crearea unei baze de date. Structura unei baze de date............................................117
10.9.2. Deschiderea şi închiderea unei baze de date.............................................................118
10.9.3. Manipularea structurii unei baze de date..................................................................118
10.9.4. Manipularea câmpurilor unei baze de date...............................................................118
10.9.5. Vizualizarea conţinutului unei baze de date..............................................................119
U10.10. Câmpurile memo.........................................................................................................121
U10.11. Meniuri.........................................................................................................................122
10.11.1. Comenzi pentru lucrul cu meniuri..........................................................................123
10.11.2. Funcţii referitoare la meniuri..................................................................................137
U10.12. Programe. Execuţia programelor.................................................................................138
10.12.1. Proceduri şi funcţii definite de utilizator................................................................140
10.12.2. Variabile globale şi variabile locale........................................................................142
10.12.3. Transferul de parametri la şi de la module de program..........................................143
10.12.4. Compilarea..............................................................................................................145
10.12.5. Depanarea programelor şi tratarea erorilor.............................................................146
U10.13. Programarea structurată...............................................................................................149
U10.14. Lucrul cu fişiere...........................................................................................................154
U10.15. Test de autoevaluare nr. 10...........................................................................................157
U10.16. Rezumat.......................................................................................................................157
Bibliografie minimală................................................................................................................157
Răspunsuri şi comentarii la testul de autoevaluare nr. 10..........................................................158
UNITATEA 11 – TURBO PASCAL............................................................................................159

U11.1. Scopul şi obiectivele unităţii..........................................................................................159
U11.2. Noţiuni introductive.......................................................................................................159
U11.3. Elemente de bază ale limbajului Turbo Pascal..............................................................161
U11.4. Mediul de programare Turbo Pascal..............................................................................162
11.4.1. Începerea sesiunii de lucru Turbo Pascal..................................................................163
11.4.2. Principalele elemente ale ferestrei de editare............................................................164
11.4.3. Salvarea pe disc a programului sursă........................................................................164
11.4.4. Editarea unui program sursă Pascal..........................................................................164
11.4.5. Compilarea programului editat.................................................................................166
11.4.6. Corectarea erorilor sintactice....................................................................................167
11.4.7. Execuţia programului................................................................................................167
11.4.8. Trecerea la editarea unui alt program........................................................................168
11.4.9. Crearea unei variante a unui program existent..........................................................169
11.4.10. Obţinerea informaţiilor ajutătoare...........................................................................169
11.4.11. Încheierea sesiunii de lucru.....................................................................................170
11.4.12. Unităţile lexicale ale limbajului PASCAL..............................................................170
U11.5. Test de autoevaluare nr. 11.............................................................................................173
U11.6. Rezumat.........................................................................................................................173
Bibliografie minimală................................................................................................................174
Răspunsuri şi comentarii la testul de autoevaluare nr. 11..........................................................174
5
INTRODUCERE
Scopul cursului:
În mai puţin de o generaţie, revoluţia informaţiei şi introducerea
calculatoarelor în fiecare dimensiune a societăţii, a schimbat lumea. Predicţiile unor
futurişti ca Marshall McLuhan şi Alvin Toffler se adeveresc şi lumea se transformă
într-un “sat global”, unde nu mai există graniţe pentru afaceri, comunicaţii sau
comerţ.
Putem considera că un nou tip de economie şi-a marcat prezenţa la nivel
planetar. Ea poate fi catalogată, atât ca o economie informaţională, o economie
bazată însă pe cunoştinţe, cât şi ca una globală. Este informaţională deoarece
productivitatea şi competitivitatea agenţilor economici depind în mod esenţial de
capacitatea lor de generare, tratare şi aplicare a unei informaţii eficace bazate pe
cunoaştere. Este şi globală deoarece activităţile cheie, de producţie, consum şi
distribuţie, precum şi componentele lor (capitalul, forţa de muncă, materiile
prime, informaţiile, tehnologiile, pieţele) sunt organizate la scară planetară.
Informaţională şi globală, în acelaşi timp, întrucât în noile condiţii istorice,
productivitatea ea naştere şi concurenţa se exprimă într-o reţea globală de
fenomene ce interacţionează.
Emergenţa unei noi paradigme tehnologice organizate în jurul noilor
tehnologii ale informaţiei, mult mai puternice şi mai “suple”, permit chiar
informaţiei să devină produs al procesului de producţie. Astfel a apărut aşa
numita economie în reţea, profund independentă, care devine din ce în ce mai
capabilă de a aplica progresele tehnologiei sale, cunoaşterii şi gestiunii sale.
Peter Drucker descrie curentul actual, pe care-l consideră apărut în anii
60 şi continuat până în 2020: “Intrăm într-o societate a cunoaşterii, în care
resursa economică principală nu mai este capitalul sau munca, ci cunoaşterea şi
în care lucrătorii inteligenţi vor juca un rol central”. Dacă în ultimii ani se
vorbea despre tipul de societate postindustrială, în care se remarca trecerea în
special de la industrie către servicii, pentru secolul XXI lucrurile sunt relativ
simple: se va trece de la activităţi bazate pe informaţii, la activităţi bazate pe
cunoştinţe şi putem aprecia că dacă secolul XX a fost unul al tehnicii, secolul XXI
va fi cu siguranţă al cunoaşterii.
Volumul de faţă se adresează cu precădere studenţilor de la forma de
învăţământ la distanţă ai Facultăţii de Ştiinţe Economice şi Gestiunea Afacerilor
din cadrul Universităţii „Constantin Brâncuşi” Târgu Jiu, dar poate fi deosebit
de util oricărui student indiferent de forma de învăţământ pe care o urmează
având în vedere că în această lucrare sunt tratate noţiunile de bază ale biroticii
cu cea mai largă aplicabilitate în aşa manieră încât studentul parcurgând
materialul să-şi poată însuşi obiectul şi metoda acestei discipline cu o deosebită
aplicabilitate în viaţa economică şi socială.
Modul în care a fost gândit şi pus în practică face din acest volum un
suport metodologic pentru disciplina Programarea Calculatoarelor, dar şi un
instrument de lucru necesar atât în înţelegerea şi însuşirea acestei discipline prin
prezentarea concisă a noţiunilor urmată de exemple practice, dar şi pentru
consolidarea acestora prin testele de autocontrol propuse.
Conţinutul lucrării a fost structurat pe 4 module divizate în 14 unităţi de
studiu care cuprind obiectivele învăţării, sinteze de noţiuni teoretice şi exemple
ilustrative, rezumate, concluzii şi teste de autoevaluare.
6
O unitate de învăţare, acoperind în medie 2-3 ore de studiu individual, se
constituie practic ca o succesiune de sarcini de învăţare, în care un rol determinat
revine autoevaluării dorind astfel să dezvoltăm capacitatea de studiu individual şi
să dăm posibilitatea studentului ID ca, deşi lipsit de explicaţiile profesorului, să
dobândească cunoştinţe şi competenţe de aceeaşi calitate şi în aceeaşi cantitate
cu cele ale studenţilor de la forma de învăţământ zi.
Parcurgând prezentul material ne dorim să dobândiţi capacităţi privind
explicarea şi interpretarea la un nivel elementar a tehnicilor, conceptelor şi
sistemelor pentru prelucrarea automată a informaţiei sub forma unor sisteme
raţional argumentate, interpretarea contextuală, la un nivel elementar, a
rezultatelor obţinute în urma unui proces de analiză informatică a fenomenelor
economice.
Testele de autoevaluare care sunt incluse pe parcursul fiecărei unităţi de
studiu au rolul de a vă testa atingerea obiectivele propuse. Aceste exerciţii de
autotestare împreună cu răspunsurile/rezolvările/indicaţiile incluse la sfârşitul
unităţii respective încearcă să vă ajute în activitatea de autotestare, activitate
prin care vă puteţi da seama dacă aţi atins obiectivele propuse la începutul
unităţii de studiu, sau nu.
În speranţa că vom parcurge împreună un drum plăcut, interesant, dar
mai ales util, autorul acestui curs vă doreşte succes în acumularea corectă şi
rapidă a cunoştinţelor necesare utilizării unui calculator personal.
Obiectivele cursului:
Cursul intitulat Programarea Calculatoarelor are ca obiectiv principal
familiarizarea studentului cu noţiunile de bază ale programării, precum şi studiul
componentelor sistemelor de calcul automat şi prelucrarea automată a datelor care
preia treptat toate sarcinile tehnologiei informaţiei dintr-un sistem economico-
social privind elaborarea de metode, tehnici, concepte şi sisteme pentru
prelucrarea automată a informaţiei. În acest sens, la sfârşitul acestui curs, veţi fi
capabili să:
 explicaţi şi să interpretaţi la un nivel elementar conceptele, abordările
limbajelor de programare aplicate în economie;
 realizaţi la nivel acceptabil anumite programe care să redea o parte din
activitatea economică a unui agent economic;
 utilizaţi concepte, teorii, modele şi metode elementare specifice programării
calculatoarelor, pentru rezolvarea de probleme practice ale domeniului de
studiu;
 modelaţi fenomene economice cu un grad de complexitate scăzut;
 interpretaţi contextual, la un nivel elementar, rezultatele obţinute în urma
unui proces de prelucrare a datelor economice.
Timpul alocat:
Durata medie de studiu individual a conţinutul cursului - 22 ore(ŞI)
Activităţi de laborator – 11 ore (AA)
Evaluarea:
Temele de control vor avea o pondere de 30% în nota finală, restul reprezintă 60%
nota la testul de verificare a cunoştinţelor de la examenul programat în sesiunea de
examene şi 10% accesarea platformei e-learning.
7
MODULUL 1
UNITATEA 1: Introducere în programare
UNITATEA 2: Tipuri de limbaje de programare
UNITATEA 3: Limbaje de programare
UNITATEA 4: Limbaje orientate pe gestiunea bazelor de

date
8
UNITATEA 1
INTRODUCERE ÎN PROGRAMARE
Durata medie de studiu individual - 2 ore
Cuprins: pag.
U1.1. Scopul şi obiectivele unităţii ............................................................. 9
U1.2. Introducere în programare .............................................................. 9
U1.3. Noţiuni de programare ..................................................................... 10
U1.4. Mediu de programare ....................................................................... 14
U1.5. Test de autoevaluare ......................................................................... 17
U1.6. Rezumat ............................................................................................. 17
Bibliografie minimală ................................................................................. 17
Răspunsuri şi comentarii la testul de autoevaluare ................................. 17
U1.1. Scopul şi obiectivele unităţii
În această temă vei învăţa următoarele concepte fundamentale:

 scrierea programului (într-un anumit limbaj de programe);
 compilarea programului;
 editarea de legături (link-editarea);
 execuţia programului;
 eventuala depanare a sa, reluând procedeul de la etapa a);
 îmbunătăţirea performanţelor programului.
U1.2. Introducere în programare
Fără intenţia de a leza temerarii angajaţi în acest domeniu trebuie să

constatăm că varietatea soft-ului pentru PC-uri este imensă, iar performanţele
atinse sunt incredibile. Menţinerea în această cursă necesită echipe de specialişti
pregătiţi temeinic şi eforturi deosebite - întinse pe perioade de luni sau chiar ani
de zile. Deci, nu vă aşteptaţi ca după parcurgerea acestui capitol să puteţi aborda
realizarea unui program (pachet de programe) care să rivalizeze cu cele deja
prezentate. Posibilităţile unui singur programator sau a unei echipe restrânse sunt
mult mai modeste.
Dacă aşa stau lucrurile, este oare nevoie să programăm? Sau trebuie să
apelăm întotdeauna la firme specializate?
9
În practică intervin frecvent cazuri în care este necesară construirea unui
program deoarece oricât de generoasă ar fi familia aplicaţiilor deja disponibile
este imposibil a acoperi infinitatea situaţiilor concrete. Aceste situaţii inedite nu se
referă la noi tipuri de probleme sau la „revoluţionarea” modului de lucru, ci în
general, la modeste adaptări. Iată câteva situaţii în care efortul de programare îşi
dovedeşte pe deplin utilitatea;
-adaptarea unui program (editor de texte) la specificul naţional (caracterele
româneşti: ă, â, î, ş, ţ);
-prelucrări sumare ale datelor (conversii, prelucrare efectivă);
-extinderea unei aplicaţii cu module proprii;
-construirea unei aplicaţii cu înalt grad de particularitate etc.
Un programator va putea rezolva o situaţie “neplăcută” de acest gen
nefiind restrâns la gama de operaţii oferite într-un pachet. În general, însă, nu pot
fi abordate proiecte ample, ci doar operaţii punctuale.
Iar pentru ducerea la bun sfârşit a unui astfel de proiect restrâns sunt
necesare cunoştinţe tehnice şi studiu mult mei aprofundat decât cel a unui simplu
utilizator.
Dacă totuşi trebuie să programăm, atunci să programăm bine şi eficient. Să
nu ne apucăm să reinventăm gramafonul când acum muzica se ascultă pe compact
- discuri. Deci mai întâi trebuie trecut în revistă soft-ul deja existent şi doar în
cazul în care acesta nu este suficient să ne construim propriile programe. Iar
atunci când abordăm o aplicaţie să alegem cea mai performantă dintre uneltele
disponibile.
U1.3. Noţiuni de programare
Prezentarea amănunţită a acestor noţiuni se face pe baza schemei

principiale de realizare a unui program. Invariabil, etapele necesare de parcurs
sunt următoarele:
 scrierea programului (într-un anumit limbaj de programe);
 compilarea programului;
 editarea de legături (link-editarea);
 execuţia programului;
 eventuala depanare a sa, reluând procedeul de la etapa a);
10
 îmbunătăţirea performanţelor programului.
a) Scrierea programului presupune editarea unui fişier ce conţine textul
programului. Acest fişier se cheamă fişier-sursă şi este - după cum am menţionat-
un fişier cu text în format ASCII. În interiorul său el conţine instrucţiuni ale
limbajului în care se face programarea.
Un limbaj de programare este foarte asemănător limbajului obişnuit
(natural); el reprezintă un sistem de convenţii pe baza căruia se efectuează o
comunicare. Deci limbajul de programare este un sistem de cuvinte (cheie),
semne, construcţii cu cuvinte şi semne care ne asigură de faptul că transmitem
calculatorului ceea ce dorim să realizeze.
b) “Propoziţiile” şi “frazele” unui limbaj de programare nu sunt direct
înţelese de calculator. Ele sunt traduse din această formă uşor manevrabilă în
instrucţiuni maşină (singurele recunoscute de microprocesor) de către un program
ce se cheamă compilator. Acest program recunoaşte noţiunile din fişierul-sursă şi
le converteşte în echivalenţele lor în limbaj maşină pe care le depune într-un fişier
de ieşire numit fişier-obiect.
c) Fişierul-obiect produs de un compilator nu este, încă, gata de a fi
executat necesitând o prelucrare suplimentară a cărei raţiune va fi prezentată în
continuare.
Dacă fişierele-sursă ar fi traduse ca atare ele ar putea conţine multă
informaţie redundantă. Spre exemplu, să considerăm un program care printre
altele scrie mesaje pe monitorul calculatorului.
Dacă fiecare instrucţiune din fişierul-sursă ar produce instrucţiuni care
realizează scrierea unui mesaj această porţiune de cod s-ar găsi repetată (cu mici
modificări) în mai multe locuri din program. Pentru înlăturarea unui astfel de
lucru nedorit, operaţiile cel mai des folosite sunt “izolate” într-o colecţie de rutine
de unde pot fi apelate oricând este nevoie.
Deci, după compilare, fişierul-obiect produs nu va conţine întotdeauna
instrucţiunile necesare unei operaţii ci eventuale referiri la rutina de bibliotecă ce
execută operaţia în cauză.
11
Figura 1. „Compilarea” unui program
Figura 2. Compilarea şi link-editarea corectă
Editarea de legături (link-editarea) va rezolva aceste referiri stabilind

conexiunile dintre referiri şi punctele referite. Ea va conecta referinţele
nerezolvate de compilator cu modulele de bibliotecă ce le corespund.
Din colecţia de rutine (denumită bibliotecă) vor fi extrase numai aceste
rutine (module) referite care împreună cu instrucţiunile din fişierul-obiect vor
constitui un program coerent. adică un fişier-executabil.
d) Execuţia programului este scopul final al etapelor anterioare şi
presupune lansarea fişierului-executabil astfel obţinut. Pentru această operaţie sunt
eventual necesare:
-îndeplinirea unor cerinţe din partea sistemului;
-specificarea de parametri corespunzători pentru program.
e) În cazul unui program mai amplu sau în cazul unui debut în programare
va fi întotdeauna necesară depanarea programului obţinut deoarece (fără greş)
acesta nu va funcţiona din prima. Pentru depistarea eventualelor erori stau la
dispoziţie pachete de programe numite depanatoare.
12
f) După ce programul a fost convins să funcţioneze corect, abia atunci este
cazul a încerca îmbunătăţirea performanţelor sale (viteză de execuţie, resurse
sistem mai reduse, protejare la erori). Pentru acest reglaj „fin” stau la dispoziţie
programe de tip “profiler” care detectează zonele de programe ce consumă cele
mai mari cantităţi de timp, punctele în care trebuie să se concentreze atenţia
programatorului.
De regulă se obişnuieşte a se lansa o versiune de test (versiunea „beta”) a
aplicaţiei care este exploatată efectiv pentru a se constata eventualele erori de
funcţionare.
În concluzie schema de dezvoltare a unei aplicaţii este următoarea:
Figura 3. Etapele realizării unui program
Etapele de compilare şi link-editare sunt necesare pentru realizarea unui

program compilat. Se pot „executa” aplicaţii şi fără producerea fişierelor obiect şi
executabil. Metoda folosită este cea a unui interpretor.
Un interpretor, compilează, link-editează şi execută un program „linie-cu-
linie”. Pe măsură ce sunt citite linii din fişierul-sursă ele sunt transformate în
instrucţiuni maşină şi executate imediat. Pentru un program dat, un interpretor nu
mai produce fişierele-obiect şi executabil, operând numai cu fişierul-sursă.
Care din metode este mai bună, cea a unui compilator sau cea a unui
interpretor?
Pentru interpretor pledează un singur avantaj şi anume reducerea timpului
de punere la punct a unei aplicaţii (prin “eliminarea” etapelor intermediare), dar
acest avantaj este infim, deoarece în momentul de faţă, mediile de programare de
tip compilator, sunt extrem de rapide (sute de linii de text-sursă pe secundă) şi
13
realizează automat link-editarea şi execuţia, astfel încât întârzierile provocate de
etapele “suplimentare” sunt neglijabile.
În schimb, avantajele unui program compilat faţă de un program
interpretat sunt zdrobitoare:
- viteză de execuţie de câteva ori (chiar zeci de ori) mai marc;
- posibilitatea de a rula de sine stătător; odată compilat, compilatorul nu
este necesar în execuţia programului, pe când un program interpretat nu se poate
“executa” decât dacă interpretorul se află în memoria calculatorului;
- programul compilat dispune de resursele sistemului în întregime, pe când
cel interpretat le împarte cu interpretorul (mai ales memoria, care este de multe ori
critică);
- flexibilitate sporită în realizarea programelor compilate (adăugarea de noi
biblioteci, redefinirea unei rutine deja existente etc).
Toate aceste consideraţii au determinat ca interpretoarele să fie pe cale de
dispariţie la ora de faţă sau oricum, să fie dublate de un compilator. Spre exemplu
limbajul BASIC ce beneficia iniţial numai de interpretor posedă în prezent şi
compilatoare care încearcă să-l menţină în atenţia programatorilor.
Noţiunile de mai sus descriu etapele principale ale realizării unui program,
în plus faţă de aceste elemente fundamentale ce asigură o viziune de ansamblu
asupra procesului este necesar să amintim şi câteva noţiuni de detaliu ce intervin
frecvent în practică.
U1.4. Mediu de programare
Un pachet de programe ce asigură toate operaţiile de mai înainte poartă

numele de mediu de programare.
Deci cu ajutorul său:
- se editează un program;
- se compilează şi eventual link-editează automat;
- se lansează în execuţie;
- se depanează un program;
- se poate “regla” execuţia unui program (cu un profiler).
14
Mediile de programare disponibile în prezent sunt deosebit de performante
şi oferă utilizatorului toată gama de servicii necesare (help, exemple gata-
construite etc.), prin intermediul unor programe puternic interactive. Ele
transformă munca laborioasă a programatorului într-un succes aproape sigur.
Interfaţă de programare
Nici un program nu este construit de la zero. Spre exemplu, programele ce
lucrează sub MS-DOS se bazează pe interfaţa DOS, folosind rutinele elementare
ale acesteia (scriere caracter la consolă, citire caracter de la tastatură etc). Interfaţa
de programare reprezintă suportul pe care se construieşte un program. Desigur, cu
cât acest suport este mai elaborat şi programul în cauză va fi mai elaborat şi va fi
mai uşor de atins un nivel ridicat al complexităţii operaţiilor realizate. Un program
realizat pentru a rula sub Windows (deci bazat pe interfaţa Windows) are la
dispoziţie facilităţi de multitasking, nu mai trebuie să gestioneze diversele driver-e
(de ecran, imprimantă, tastatură etc), toate acestea fiind deja rezolvate de
Windows.
Biblioteci de programare
După cum aţi constatat din prezentarea anterioară‚ operaţia de link-editare
înseamnă conectarea unui fişier-obiect la rutinele corespunzătoare. Aceste rutine
pot exista într-un fişier pe disc şi link-editarea se realizează static, obţinându-se un
fişier-executabil.
Există, însă, şi biblioteci ce se încarcă în memorie şi sunt gestionate de un
program (de ex. Windows). in momentul lansării în execuţie a unei aplicaţii,
aceasta se află pe disc ne-link-editată. Ea va fi încărcată în memorie şi link-editată
dinamic cu modulele existente în memorie. Astfel, aplicaţia va fi rulată fără ca să
fie produs fişierul-executabil în forma sa completă.
Overlay-uri (acoperiri)
În momentul în care un program este prea mare pentru a încape în
memoria calculatorului se recurge la fragmentarea sa. Se păstrează din program o
parte principală (numită rădăcină) care se va afla în memorie şi de asemenea se
rezervă în memorie spaţiul necesar pentru încărcarea pe rând, a celorlalte părţi ale
programului în funcţie de necesităţi.
15
Figura 4. Program cu „acoperiri”
Desigur această tehnică de overlay presupune ca segmentul principal de

program să conţină, în plus faţă de modulele propriu-zise, şi module ce vor
gestiona încărcarea de pe disc a “acoperirii” (overlay-ului) necesar la un moment
dat.
Un mediu de programare “inteligent” nu trebuie decât să fie informat că se
doreşte lucrul cu overlay-uri şi va genera automat instrucţiunile necesare acestei
tehnici.
Memorie virtuală
Deoarece memoria internă pune de multe ori probleme realizatorilor de
programe, a fost introdus un concept ce ajută imens programatorii, şi anume:
memoria virtuală. Această memorie este privită de program ca memorie internă,
dar ea se poate afla fizic în orice tip de memorie (expandată, extinsă, pe disc).
Pentru implementarea memoriei virtuale există concepute module (rutine)
speciale ce funcţionează asemănător tehnicii de overlay.
Spre exemplu un program necesită 20 Mb de memorie internă dar sistemul
dispune de 1 Mb memorie RAM şi 40 Mb memorie pe disc. Atunci se poate
declara o memorie virtuală de 20 Mb / l Mb RAM+19 Mb pe disc. Când
programul va face un apel la memoria virtuală ce se află mapată pe disc,
gestionarul de memorie virtuală va încărca acea informaţie în memoria internă şi
va permite programului să lucreze cu ea (modalitate de lucru facilitată de modul
de adresare virtuală a procesorului 80386).
16
U1.5. Test de autoevaluare nr. 1
1. Care este scopul şi obiectivele unităţii? (1,5 pct.)
2. Care sunt etapele necesare realizării unui program? (1,5 pct.)
Timp de lucru : 40 min 3. Ce este mediul de programare? (1,5 pct.)
Punctaj 6p
4. În ce situaţii efortul de programare îşi dovedeşte pe deplin utilitatea? (1,5
pct.)
Total puncte: 6 Puncte obţinute………
U1.6. Rezumat
Dacă totuşi trebuie să programăm, atunci să programăm bine şi eficient. Să

nu ne apucăm să reinventăm gramafonul când acum muzica se ascultă pe compact
- discuri. Deci mai întâi trebuie trecut în revistă soft-ul deja existent şi doar în
cazul în care acesta nu este suficient să ne construim propriile programe. Iar
atunci când abordăm o aplicaţie să alegem cea mai performantă dintre uneltele
disponibile.
Bibliografie minimală
1. Tamaş şi alţii – Bazele tehnologiei informaţiei şi comunicaţiilor, Editura
InfoMega, Bucureşti, 2004;
2. Airinei, D., Depozite de date, Editura Polirom, Iaşi, 2002
3. Dospinescu, O., Dezvoltarea aplicaţiilor în Visual Basic.NET, Editura
Polirom, Iaşi, 2004;
4. Date, C.J., Baze de date, Ediţia a opta, Pearson Addison Wesley, Editura
Plus, Bucureşti, 2004.
5. Kris Jamsa, Visual Basic. Net: Sfaturi şi tehnici, Ed. All, Bucureşti, 2003;
6. John Conell, Microsoft Visual Basic.Net. Ed. Teora, Bucureşti, 2003;
7. Davidescu, D.N., Proiectarea sistemelor informatice prin limbajul Unified
Modeling Language (PSI 2), Editura All Beck, Bucureşti, 2003.
Răspunsuri şi comentarii la testul de autoevaluare nr. 1
17
UNITATEA 2
TIPURI DE LIMBAJE DE PROGRAMARE
Cuprins: pag.
U2.2. Noţiuni introdictive .......................................................................... 18
U2.3. Limbajele de nivel scăzut – de nivel înalt ....................................... 19
U2.4. Limbaje procedurale / neprocedurale ............................................. 21
U2.5. Limbaje orientat ................................................................................ 23
U2.6. Limbaje concurente .......................................................................... 24
U2.8. Rezumat ............................................................................................. 24

 Limbajele de programare;
 Limbajele de nivel scăzut – de nivel înalt;
 Limbajele procedurale/neprocedurale;
 Limbaje orientat;
 Limbaje concurente.
U2.2. Noţiuni introductive
Un limbaj de programare este un sistem de convenţii adoptate pentru

realizarea unei comunicări - între programator şi calculator. Limbajele folosite
pentru programarea unui calculator sunt extrem de asemănătoare limbajelor
naturale. Ele sunt compuse din:
- cuvinte (rezervate);
- punctuaţie;
- propoziţii şi fraze;
18
- reguli sintactice etc.
Iată spre exemplu, cum arată un program scris în limbaj PASCAL, afişează
pe ecran mesajul: Ce mai faci?
Figura 5. Program în limbaj PASCAL
Aşa cum pentru însuşirea unei limbi străine trebuie învăţate cuvintele
acesteia şi regulile cu care pot fi manevrate tot aşa pentru însuşirea unui limbaj de
programare trebuie studiate cuvintele şi semnele care îl compun împreună ca
reguli de manevrare a lor.
După metoda cu care este conceput ansamblu comunicării, limbajele pot fi
clasificate în mai multe moduri.
În continuare vom enumera cele mai importante clase de limbaje, descriere
ce acoperă totalitatea limbajelor existente.
U2.3. Limbajele de nivel scăzut - de nivel înalt
“Nivelul” unui limbaj este apreciat prin poziţia pe care o ocupă pe scara
constituită de limbajul recunoscut de microprocesor (limbaj maşină) şi limbajul
natural al programatorului (limba română, limba engleză ...).
Un limbaj de nivel scăzut este foarte apropiat de maşină, el manipulează
cu elemente de nivel hardware, fizic, cum ar fi: registru-micro-procesor, locaţie de
memorie, port de intrare/ieşire etc.
Un limbaj de nivel înalt sau foarte înalt manipulează cu concepte apropiate
de limbajul natural, concepte de nivel logic, cum ar fi: colecţie de date, nume de
operaţie (sort = sortare, writeln = scrie linie, open = deschidere fişier etc),
variabile, constante (asemănătoare ca înţeles cu cele din matematică) etc..
19
Figura 6. Tipuri de limbaje de programare
Cu ajutorul unui limbaj de nivel înalt programatorul se face mai uşor

înţeles de către calculator. Uneori o singură linie de program scrisă cu un astfel de
limbaj poate echivala cu sute de linii de program scrise în limbaj maşină. Deci,
din punct de vedere al reducerii timpului de realizare a unui program şi al
siguranţei în funcţionare (absenţa erorilor de programare) este de preferat un
limbaj de nivel cât mai ridicat (înalt sau foarte înalt). În schimb, pe măsură ce
limbajul are un nivel mai ridicat execuţia programului conceput cu ajutorul său va
fi mai lentă, decât a unui program ce realizează aceleaşi operaţii dar este scris în
limbaj de asamblare. Motivele acestei diminuări de viteză sunt multe; amintim
câteva dintre ele:
- fiind apropiat de maşină, limbajul de asamblare exploatează la maxim
posibilităţile acesteia;
- limbajul de nivel înalt este un cadru general, deci automat posedă cod
(instrucţiuni) ce decide asupra specificităţii operaţiei cerute şi după identificarea ei
pune în execuţie codul propriu-zis care realizează operaţia;
- limbajul de nivel înalt poate conţine cod ineficient sau inutil pentru o
anumită operaţie deoarece acest cod trebuie să funcţioneze şi pentru alte operaţii
din aceeaşi clasă.
În prezent acest dezavantaj al limbajelor de nivel înalt nu mai este
considerat esenţial. El este compensat de sporirea resurselor hard.
Modalitatea modernă de abordare a problemelor poate fi sintetizată astfel:
“De ce să programez luni de zile sau ani de zile în plus, când pot cumpăra
un calculator mai rapid?!”
20
Ideal ar fi ca cele două tipuri de limbaje să fie folosite combinat.
Programul se realizează cu un limbaj de nivel înalt, apoi se lansează un profiler şi
se detectează instrucţiunile în care se consumă cel mai mult timp sau timp inutil.
În aceste puncte se rescriu instrucţiunile respective folosind limbajul de
asamblare. Aşadar randament sporit de un mai bun raport efort/performanţe.
În unele cazuri necesitatea folosirii limbajului de asamblare este de
neînlăturat. Aceste situaţii apar în cazul unor operaţii nestandard, ce nu sunt puse
la dispoziţie de limbaje de nivel înalt (de ex: manipularea unui modem, a unui
cititor de cod de bare etc.) Pentru aceste cazuri limbajul de asamblare este singura
soluţie, deoarece este singurul care poate exploata toate posibilităţile sistemului.
O altă diferenţă esenţială între cele două tipuri de limbaje o reprezintă
posibilitatea, adică posibilitatea transferării programelor pe un alt tip de maşină
decât cea pe care au fost construite. Din acest punct de vedere limbajul de
asamblare este neportabil deoarece el este specific microprocesorului. Programele
realizate pe un tip de maşină trebuie rescrise integral pentru noul tip de maşină,
folosind un nou set de instrucţiuni - care de obicei diferă foarte mult. De asemenea
programul scris în limbaj de asamblare este legat direct de interfaţa de programare
pe baza căreia a fost construit. Schimbarea acesteia va impune rescrierea
programului. Deci, un program scris pentru un IBM-PC dotat cu sistem de operare
MS-DOS nu va putea fi utilizat pe un IBM-PC dotat cu sistem de operare UNIX.
Lucrurile stau altfel cu programele concepute cu ajutorul unui limbaj de
nivel înalt, deoarece acestea sunt detaşate de maşină. Intre un astfel de program şi
calculator se interpune compilatorul (sau interpretorul) care rezolvă corect
transformarea fişierului-sursă în fişier-executabil.
În prezent limbajul maşină este extrem de rar folosit de programatori, el
este rezervat constructorilor de calculatoare.
U2.4. Limbaje procedurale / neprocedurale
Cele două tipuri de limbaje, procedurale şi neprocedurale, se diferenţiază

prin nivelul de organizare (structurare) a unui program, limbajele neprocedurale
sunt concepute pentru a gândi un program la nivel de instrucţiune, pe când cele
procedurale, obligă programatorul să conceapă programe la nivel de bloc.
Desigur, într-un limbaj procedural (numit şi limbaj structurat) programele
sunt scrise instrucţiune cu instrucţiune, dar ele sunt organizate logic în blocuri
21
(grupuri de instrucţiuni) ce realizează o acţiune bine determinată. În figura
următoare sunt prezentate - vădit exagerat - modurile în care „se desfăşoară”
atenţia programatorului pentru a realiza (sau depana) un program.
Figura 7. Limbaje procedurale / neprocedurale
Avantajul esenţial al programării structurate îl constituie conceptul de bloc

de program. Un astfel de bloc reprezintă un set de instrucţiuni ce realizează o
operaţie bine determinată. În general un bloc are un punct de intrare şi un punct de
ieşire - nu mai multe.
Deci un program structurat este mult mai lizibil decât unul nestructurat.
În al doilea rând programarea structurată permite lucrul la un nivel logic
mai înalt. Odată definite blocurile ce realizează operaţii elementare (intrări, ieşiri,
prelucrări), programatorul va gândi programul în aceşti termeni, nu la nivel de
instrucţiune, deci la un nivel de înţelegere superior.
În al treilea rând, şi nu cel din urmă, programarea structurată disciplinează
gândirea unui programator. Această modalitate de lucru obligă programatorul să-şi
organizeze aplicaţiile coerent şi limpede, pe când un limbaj nestructurat
favorizează improvizaţiile de moment şi deseori labile.
În concluzie, un limbaj procedural oferă posibilitatea utilizării unui nivel
ridicat de concepere a unui program şi duce la realizarea de programe coerente şi
protejate la erori. Prin contrast, limbajele neprocedurale nu favorizează
programatorul în a se desprinde de nivelul “instrucţiune” şi duc deseori la
programe greu de controlat -mai ales în cazul programelor de dimensiuni mari.
Limbajele neprocedurale (BASIC, dBASE) sunt încă preferate de unii
utilizatori datorită timpului foarte scurt cât decurge învăţarea şi utilizarea lor:
câteva zile faţă de câteva săptămâni în cazul limbajelor procedurale - desigur ne
referim la elementele principale ale limbajelor în cauză şi la realizarea unei
aplicaţii simple. Însă, această “grabă” este de cele mai multe ori nejustificată
22
ducând inevitabil la dificultăţi artificiale datorate alegerii din start a unui drum
greşit.
Tendinţa actuală este de a transforma limbajele neprocedurale în limbaje
procedurale (versiunea- Turbo Basic implementează un Basic structurat, iar
dBASE IV permite definirea de proceduri). Modalitatea de lucru neprocedurală a
unui limbaj de tip algoritmic rămâne pentru uzul amatorilor.
U2.5. Limbaje orientate
Clasificarea operată în secţiunea de faţă se referă la domeniul de

aplicabilitate al unui limbaj. Din acest punct de vedere limbajele pot fi orientate
pe o anumită problemă sau concepute pentru soluţionarea oricărui tip de problemă
- limbaje de uz general sau altfel spus, neorientate pe o problemă.
Limbajele orientate prezintă un grad înalt de specificitate. Limbajele
neorientate reprezintă un cadru general ce permite introducerea de către utilizator
a conceptelor şi prelucrărilor dorite. Se poate crea şi întreţine o bază de date cu
ajutorul unui limbaj neorientat, dar în loc de a efectua, să zicem o sortare printr-o
simplă instrucţiune va fi nevoie de zeci (chiar sute) de instrucţiuni care să
realizeze acelaşi lucru.
Deci, diferenţa esenţială dintre cele două tipuri de limbaje o constituie
nivelul conceptual definit. Cele specializate posedă deja integral suportul necesar
şi permit programatorului să se concentreze la ansamblul problemei, pe când cele
nespecializate lasă în sarcina programatorului manevrarea nivelelor inferioare ale
problemei.
Deci, trebuie analizat cu grijă limbajul ce va fi abordat deoarece facilităţile
sale pot duce la diminuarea calităţii programelor obţinute.
Cele mai importante domenii pentru care există disponibile limbaje
specializate sunt următoarele:
1. gestiune baze de date;
2. calcul tabelar;
3. inteligenţă artificială;
4. calcul matematic.
23
U2.6. Limbaje concurente
O altă posibilă clasificare a limbajelor se poate face după „fluxul” de

execuţie a programelor realizate.
Un limbaj concurent permite definirea de procese (prelucrări) paralele,
execuţia sa fiind ramificată la un anumit moment de timp. Prin contrast limbajele
neconcurente (cazul majorităţii limbajelor) au o desfăşurare liniară, fiind activ un
singur proces la un moment dat.
Procesele concurente presupun în mod obligatoriu un sistem multi-tasking
ce poate gestiona mai multe „sarcini” la un moment dat. Din acest motiv pentru
IBM-PC există puţine implementări de limbaje concurente.
Totuşi, e bine de ştiut că specialiştii în domeniu prevăd acestor limbaje un
viitor strălucit.

1. Care este scopul şi obiectivele unităţii? (1,5 pct.)
2. Care sunt limbajele de nivel scăzut şi care sunt cele de nivel înalt? (1,5
Timp de lucru : 40 min pct.)
Punctaj 7,5p
3. Ce este limbajul orientat şi ce este cel concurent? (2 pct.)
4. Care este diferenţa dintre limbajul concurent şi cel orientat? (2,5 pct.)
Total puncte: 7,5 Puncte obţinute………
U2.8. Rezumat
Clasificarea operată în secţiunea de faţă se referă la domeniul de

aplicabilitate al unui limbaj. Din acest punct de vedere limbajele pot fi orientate
pe o anumită problemă sau concepute pentru soluţionarea oricărui tip de problemă
- limbaje de uz general sau altfel spus, neorientate pe o problemă.
Limbajele orientate prezintă un grad înalt de specificitate. Limbajele
neorientate reprezintă un cadru general ce permite introducerea de către utilizator
a conceptelor şi prelucrărilor dorite. Se poate crea şi întreţine o bază de date cu
24
ajutorul unui limbaj neorientat, dar în loc de a efectua, să zicem o sortare printr-o
simplă instrucţiune va fi nevoie de zeci (chiar sute) de instrucţiuni care să
realizeze acelaşi lucru.
Deci, diferenţa esenţială dintre cele două tipuri de limbaje o constituie
nivelul conceptual definit. Cele specializate posedă deja integral suportul necesar
şi permit programatorului să se concentreze la ansamblul problemei, pe când cele
nespecializate lasă în sarcina programatorului manevrarea nivelelor inferioare ale
problemei.
Deci, trebuie analizat cu grijă limbajul ce va fi abordat deoarece facilităţile
sale pot duce la diminuarea calităţii programelor obţinute.
25
UNITATEA 3
LIMBAJE DE PROGRAMARE
Cuprins: pag.
U3.2. Abordări conceptuale ........................................................................ 26
U3.3. Limbaje de nivel înalt neorientate ................................................... 28
U3.5. Rezumat ............................................................................................. 36
În această temă veţi învăţa următoarele concepte fundamentale:

 Principalele clase de limbaje de programe;
 Basic;
 Fortran;
 Pascal;
 Limbajul C;
 ADA.
U3.2. Abordări conceptuale
Cu aceste noi elemente la dispoziţie putem aborda prezentarea limbajului

de programare, în cunoştinţă de cauză este de menţionat faptul că optarea pentru
un limbaj sau altul nu depinde numai de caracteristicile sale conceptuale, ci în
mare măsură poate fi influenţată de performanţele mediului de programare
disponibil. O implementare performantă a unui limbaj, dublată de “unelte”
puternice (editor, compilator, link-editor, depanator, profiler) poate fi un element
hotărâtor în alegerea dumneavoastră. Acest aspect nu va fi neglijat în prezentarea
care urmează.
26
Prezentarea va cuprinde principalele clase de limbaje de programe,
descrise mai întâi din perspectiva caracteristicilor definitorii, iar apoi detaliate
diferenţiat pentru fiecare din limbajele ce o compun o astfel de clasă.
Limbaje de nivel scăzut - această categorie de limbaje are un reprezentant
autoritar şi anume: limbajul de asamblare.
Diferenţierile care se pot face pentru limbajele de nivel scăzut sunt
următoarele:
a) după tipul de maşină;
b) după mediul de programare oferit.
a) Limbajul de asamblare este strâns legat de tipul de hardware disponibil,
iar un IBM-PC poate fi realizat cu diverse procesoare, din familia Intel 80x86
(8086, 80286, 80386, 80486, 80586, 80686, etc). Aşadar există tot atâtea limbaje
de asamblare - câte unul pentru fiecare procesor în parte.
Regulile respectate de versiunile limbajului de asamblare sunt, evident,
uşor de intuit:
- o nouă versiune o include complet pe cea anterioară;
- versiunea nouă oferă funcţii suplimentare şi le realizează pe cele vechi
mai rapid.
b) Aspectul unui limbaj (nu conţinutul său) poate fi schimbat radical de
mediul de programare oferit.
Pentru limbajul de asamblare există mai multe implementări disponibile,
începând cu pachete ce operează în mod linie (editare, compilare, link-editare
realizate cu câte un utilitar specializat) şi culminând cu medii integrate în care
toate operaţiile se pot declanşa de la un acelaşi pupitru de comandă (utilitar
interactiv pe bază de meniuri).
Nu sunt de luat în considerare decât aceste medii integrate (denumite
generic medii Turbo), dintre care se detaşează Turbo Asamblorul firmei Borland
TASM. El se livrează la un preţ ridicol de scăzut faţă de totalitatea serviciilor
oferite (interactivitate, viteză mare de lucru, implementare evoluată a limbajului -
directive de control al compilării, macroinstrucţiuni deja definite sau definibile de
utilizator etc).
Cu toate aceste calităţi produsul este foarte rar întrebuinţat datorită
dezavantajelor constructive ale unui limbaj de nivel scăzut cum este cel pe care îl
implementează. Dacă ţinem seama şi de faptul că limbajele de nivel înalt
27
performante (PASCAL,C) acceptă instrucţiuni în limbaj de asamblare, ne putem
explica de ce sunt foarte rar întâlnite situaţiile în care se apelează la TASM.
U3.3. Limbaje de nivel înalt neorientate
3.3.1. Basic
Creat în anul 1964 la Darmooth College (S.U.A) limbajul BASIC a

cunoscut succesul maxim în anii ‘80.
Denumirea sa provine de la iniţialele cuvintelor Beginner’s Allpurpose
Symbolic Instruction Code (Cod de instrucţiuni simbolice, de uz general, destinat
începătorilor) şi spune deja multe despre acest limbaj.
Iată caracteristicile sale fundamentale:
- simplu de învăţat; instrucţiunile sale sunt cuvinte din limba engleză sau
prescurtări ale acestora;
- neorientat pe un anumit tip de problemă; permite construirea de aplicaţii,
teoretic în orice domeniu;
- este un limbaj nestructurat, ceea ce îi permite să fie uşor învăţat; din acest
motiv aplicaţiile rezultate se citesc şi modifică foarte greu, fiind favorizată
proiectarea anarhică, „de moment”.
Speculând faptul că limbajul a cunoscut o largă răspândire, au fost
implementate noi versiuni de BASIC, diferite de cel standard, care introduc
elemente de structurare în limbaj, încercând (nu cu mare succes) să menţină
limbajul în atenţia programatorilor.
Aşadar mediile de programare, cu diversele implementări de BASIC sunt
următoarele:
- GW-BASIC Versiune nestructurată a limbajului. Mediu de programare
primitiv şi neperformant în principal din cauza faptului că sunt interpretoare şi nu
compilatoare. Poate fi folosit de amatori pentru a simula senzaţia de programare.
- Ouick Basic Versiune structurată de Basic produsă de Microsoft.
Datorită faptului că este compilator, îmbunătăţeşte cu mult performanţele
aplicaţiilor. De asemenea un plus calitativ este dat de interactivitatea sporită a
acestui mediu.
- Turbo Basic Versiune puternic structurată de BASIC produsă de firma
Borland. Compilatorul este performant şi limbajul implementat nu mai are prea
28
multe legături cu Basic-ul standard fiind mai degrabă o specie de PASCAL.
Mediul de programare este tipic “turbo” deci interactiv, performant, dublat de
toate accesoriile necesare (editor, compilator, link-editor, depanator).
- Basic for Windows (Visual Basic) Versiune structurată de Basic.
Avantajul esenţial al acestei implementări îl reprezintă faptul că aplicaţiile create
sunt aplicaţii ce rulează sub Windows, deci suportă disciplinarea funcţionării
multi-tasking. Între această versiune şi GW-BASIC singura asemănare o
reprezintă numele.
În concluzie, constatăm că BASIC-ul a fost popular datorită simplităţii
sale şi din cauza faptului că în perioada succesului său cerinţele pentru o aplicaţie
erau foarte reduse. Pe măsură ce aceste standarde au crescut, BASIC-ul s-a
dovedit depăşit şi ineficient, iar atunci când a încercat să menţină ritmul a încetat
să mai fie BASIC ...
3.3.2. Fortran
Limbajul Fortran este în mod cert decanul de vârstă al limbajelor de largă

folosinţă. A apărut în anul 1956 şi îşi datorează numele prescurtării cuvintelor:
FORmula TRANslation (Traducere de formule).
După cum arată numele său, iniţial reprezenta un limbaj orientat pe calcule
ştiinţifice având definite concepte precum: matrice, funcţii trigonometrice, numere
reale în dublă precizie. Versiunile ulterioare de Fortran (Fortran IV şi Fortran 77)
care au cunoscut o mare popularitate au extins posibilităţile limbajului (manipulări
de fişiere, conversii de date, programare pseudo-structurată) transformându-l într-
un limbaj eficient, de uz general.
În prezent există pentru IBM-PC două implementări mai importante ale
limbajului:
- Microsoft Fortran Compilator ce defineşte un limbaj cu performanţe
acceptabile, chiar foarte bune în cazul calculelor ştiinţifice. Dezavantaj principal:
metoda arhaică de punere la punct a programelor (utilitare în mod linie) şi absenţa
uneltelor de depanare şi control al performanţelor.;
- Fortran for Windows. Versiune complet structurată de Fortran.
Avantajul principal (şi foarte important) este că se pot crea rapid aplicaţii
acceptabile ce rulează sub Windows, în comparaţie cu PASCAL for Windows,
unde efortul de programare este mult mai mare.
29
Limbajul Fortran a constituit mulţi ani la rând principala unealtă a
programatorilor, de unde şi o oarecare nostalgie a acestora. Deşi nu poate fi
considerat “depăşit” din punct de vedere conceptual (este un limbaj algoritmic -
structurat) este neindicată folosirea lui datorită absenţei unor medii de programare
performante şi pentru că tendinţa actuală îi este defavorabilă.
Singura sa utilizare justificată o poate constitui versiunea Windows a
compilatorului.
3.3.3. Pascal
Conceptualizat în anul 1970 de către Niklaus Wirth, limbajul PASCAL

poartă numele matematicianului şi filozofului Blaise Pascal, în semn de
recunoaştere a meritelor sale în teoretizarea maşinilor de calcul moderne.
Creat după acumularea de cunoştinţe temeinice în ştiinţa limbajelor
formale, din confruntarea cu problemele concrete ale programării, limbajul
PASCAL a constituit la vremea respectivă un limbaj modern, menţinându-se ca
atare şi în prezent, datorită faptului că posedă o solidă bază conceptuală.
Limbajul PASCAL a introdus în versiunea sa iniţială noţiunea de
programare structurată şi ulterior noţiunile de date (structuri) dinamice, date
(structuri) definite de utilizator.
În prezent standardul implementărilor PASCAL cuprinde următoarele
elemente:
- programare structurată de tip algoritmic, deci:
- blocuri de instrucţiuni executate liniar;
- blocuri de decizie ce permit executarea alternativă a unui set sau altul de
instrucţiuni in funcţie de rezultatul unui test;
- blocuri de ciclare pentru executarea repetată (cu număr de paşi cunoscut
anterior sau până la îndeplinirea unei condiţii) a unui set de instrucţiuni;
- posibilitatea definirii unei instrucţiuni compuse (formată dintr-un set de
instrucţiuni simple) ce este tratată ca o singură instrucţiune elementară în analiza
sintactică;
- definirea de noi funcţii sau proceduri;
- tipuri de date definibile de către utilizator (structuri de date);
- structuri de date dinamice (alocate de program în memorie în momentul
execuţiei, nu în etapa de compilare);
30
- adresări indirecte ale datelor (variabile pointer ce conţin nu valoarea unei
variabile, ci adresa de memorie la care se află aceasta);
- recursivitate (posibilitatea unei proceduri de a se apela pe ea însăşi,
asigurând astfel transcrierea extrem de simplă a algoritmilor ce presupun paşi de
recursivitate
- şiruri convergente, căutări in arbori etc;
- rutine complete de intrare/ieşire (deschidere, citire, scriere, modificare,
adăugare în fişiere ce pot conţine text, sau date de orice tip);
- funcţii de conversie a datelor din ASCII în format intern şi invers;
- set complet de funcţii matematice (radical, sin, cos, exponenţială,
logaritm etc);
- funcţii elementare de grafică 2D;
- posibilitatea inserării direct în sursă a instrucţiunilor în limbaj de
asamblare;
- posibilitatea definirii de overlay-uri pentru program.
Deci, un limbaj puternic, care în ciuda complexităţii sale nu este dificil de
învăţat şi stăpânit datorită clarităţii ireproşabile care îl fundamentează conceptual.
Versiunile standard ale implementărilor PASCAL sunt cele oferite de
Microsoft şi Borland, cu avantaj pentru cele din urmă (Turbo Pascal 5.0, Turbo
Pascal 5.5) datorită mediului de lucru performant. Combinaţia PASCAL + Turbo a
reprezentat un succes imens în rândul programatorilor având ca singur rival
cealaltă combinaţie: C + Turbo.
Versiunile recente ale PASCAL-ului constituie o mică revoluţie în
programare.
Turbo Pascal 6.0 introduce (altfel decât versiunea 5.5) noţiunea de
„obiect”. Pentru Pascal 6.0, obiect înseamnă o colecţie de date şi metode
(procedee de prelucrare, manevrare a datelor) ce se comportă unitar. Există mai
multe tipuri de obiecte, organizate într-o ierarhie bine definită. Definirea unui
obiect nou în acest arbore permite moştenirea comportamentului „părintelui” şi
eventual adăugarea unor noi comportamente.
Concret, gândiţi-vă la un meniu pe ecran. Acest meniu este un obiect
descendent din obiectul predefinit de tip view. El este un grup de obiecte şi conţine
rubrici, butoane de tip radio, butoane de acţiune etc, taste obiecte descendente din
view. Fiecare obiect se comportă aşa cum a fost definit (implicit ca “părintele”
său, ori într-un mod propriu dacă a fost redefinit sau extins comportamentul
31
“părintelui”. Obiectele funcţionează cooperant pentru definirea unui meniu, a
liniei de stare a unei căsuţe de dialog etc.
Având la îndemână acest instrumentar se pot crea aplicaţii ireproşabile din
punct de vedere al nivelului de prezentare şi al interactivităţii cu utilizatorul.
Acest modul orientat pe obiect implementat în Turbo Pascal 6.0 poartă
numele de Turbo Vision. Cu Vision se poate crea o aplicaţie ce se prezintă ca în
figura următoare:
Figura 8. Aplicaţie creată cu Turbo Vision
Aplicaţia e complet concepută pe bază de meniuri, posedă suport de

mouse, help senzitiv la context, linie de stare senzitivă la context, scurtături pentru
operaţiile considerate mai importante ş.a.m.d. Toate acestea cu numai 300 de linii
de program (deci 5 pagini).
De acord, aceste 300 de linii presupun numai partea de prezentare a
aplicaţiei fără nici un fel de prelucrare efectivă. Operaţiile concrete vor fi realizate
în PASCAL-standard, Turbo Vision oferind funcţii numai pentru definirea
aspectului pe ecran al aplicaţiei.
Modulul Turbo Vision nu este dificil de înţeles la nivel teoretic, dar
presupune ceva studiu din partea programatorului, neputând fi utilizat din mers,
fără parcurgerea documentaţiei.
Dezavantajul principal pentru Turbo Vision îl constituie faptul că nu pot fi
create aplicaţii grafice, ci numai aplicaţii ce funcţionează în mod caracter.
3.3.4. Pascal for Windows
Această implementare de PASCAL, asigură crearea de programe ce vor

rula ca aplicaţii Windows.
32
Programarea este mai laborioasă (faţă de Fortran for Windows), deoarece
poate fi gestionată totalitatea serviciilor Windows (nu numai o gamă restrânsă a
acestora).
3.3.5. Limbajul C
Acest limbaj de programare, cu cel mai scurt nume posibil, a fost creat în
1971 de către Dennis Ritchie şi Brian Kernigham pentru dezvoltarea sistemului de
operare UNIX. Istoria sa merită menţionată deoarece este relevantă pentru
caracterizarea limbajului.
Aşadar se punea problema conceperii unui sistem de operare universal,
care să poată funcţiona, teoretic, pe orice tip de maşină -sistemul UNIX. Pentru
aceasta era nevoie de un limbaj care să exploateze toate posibilităţile unei maşini,
dar care nu putea fi limbajul de asamblare, deoarece el este specific maşinii - o
nouă implementare presupunea rescrierea integrală a sistemului. Din această
dilemă s-a putut ieşi construind un limbaj de nivel înalt (iniţial limbajul B, ulterior
C) care introducea şi concepte de nivel scăzut, hardware (registru, adresă, locaţie
de memorie absolută etc).
Mai bine de 90% din sursele primului sistem de operare UNIX
(implementat pe o maşină PDP-7) au fost scrise utilizând limbajul C, iar pentru
restul modulelor s-a apelat la limbajul de asamblare. sistemul astfel obţinut a rost
distribuit cu programele În format sursă şi cu descrierea noului limbaj folosit, cu
intenţia vădită de a-l transforma într-un sistem de operare universal.
Succesul nu a sosit imediat, dar era asigurat de noua metodă de lucru.
Programatorii au fost incitaţi să dezvolte acest sistem, extinzându-l cu noi module
şi să îl implanteze pe alte maşini prin rescrierea acelei minime părţi sub 10% în
limbaj de asamblare... “C” devenea un limbaj de referinţă.
După acest scurt preambul iată care sunt principalele caracteristici ale
limbajului:
- limbaj structurat de nivel înalt;
- posedă concepte de nivel scăzut, ceea ce permite exploatarea portabilă a
caracteristicilor intime unei maşini.
Spre exemplu, o variabilă foarte des utilizată, poate fi declarată “register”
(registru) şi atunci ea va fi memorată într-un registru al microprocesorului, nu într-
o locaţie din memoria internă, mărind (uneori considerabil) viteza de execuţie;
33
- rutine de conversie a datelor foarte evoluate (conversii implicite, intrări,
ieşiri, conversii în memorie);
- tipuri de date definibile de către utilizator;
- gestionarea elaborată a datelor de tip dinamic;
- definirea de noi funcţii;
- adresări indirecte ale variabilelor (pointer-i);
- recursivitate;
- set complet de funcţii matematice etc;
- funcţii pentru realizarea de grafică elementară 2D;
- funcţii de apel servicii DOS;
- posibilitatea definirii de overlay-uri pentru un program;
- şi nu în ultimul rând: concizie deosebită a limbajului (set de operatori şi
instrucţiuni foarte concise).
Aşadar un limbaj care suplimentează PASCAL-ul şi poate pretinde pe
drept cuvânt supremaţia în rândul limbajelor structurate de uz general.
Pentru versiunile standard ale implementărilor limbajului C există medii
de programare de tip «turbo» ce aparţin după cum ne-am obişnuit, firmelor:
Microsoft -produsul Ouick C - şi firmei Borland -produsele Turbo C.
3.3.6. ADA
Limbajul ADA a fost creat special pentru a gestiona totalitatea aplicaţiilor

dezvoltate şi utilizate de N.A.S.A. Conceptualizarea limbajului a fost rodul unui
concurs internaţional în care au fost angajaţi mii de cercetători. Rezultatul nu
putea fi decât remarcabil.
Noutatea limbajului (de tip structurat, algoritmic etc) o constituie
concurenţa, deci posibilitatea lansării de procese paralele (sincronizate interactiv
în finalul execuţiei lor etc). Saltul calitativ este evident şi deschide un nou
domeniu în programare dar, nu pentru IBM-PC. Versiunile implementărilor
limbajului ADA pe IBM-PC nu posedă tocmai această parte de concurenţă’ deci
reduc limbajul la un banal limbaj structurat de uz general, iar în lupta pentru
supremaţie primează tocmai facilităţile suplimentare oferite peste acest minim
necesar.
Aşadar, ADA este un limbaj ultramodern din punct de vedere teoretic dar
ineficient din punct de vedere practic pentru IBM-PC-uri.
34
În finalul acestei prezentări a limbajelor de uz general este deosebit de
utilă o recapitulare comparativă a celor doi candidaţi rămaşi în cursa pentru
supremaţie: PASCAL şi C.
Avantaje Pascal:
- regulile sintactice ale limbajului sunt mai stricte, de unde rezultă
programe mai sigure şi mai uşor de depanat; în limbajul C se acordă o mai mare
libertate programatorului, dar inevitabil şi o responsabilitate sporită (pentru a ţine
sub control un program C de mare întindere trebuie studiu şi mai ales experienţă);
- la noi în ţară - literatură de specialitate mai bogată (nu e de neglijat acest
factor).
Avantaje C:
- cod mai eficient pentru. operaţiile de intrare/ieşire pe disc;
- modulul Vision conţine mai puţine erori de fabricaţie decât cel al
PASCAL-ului;
- este de menţionat că în general 99% din presupusele erori. se datorează
programatorului şi numai 1% sunt erori reale. O metodă sigură de a depista cine
se înşeală este de a intra cu un depanator în
- executabilul produs şi de a analiza codul la nivel de limbaj de asamblare;
- libertatea de exprimare sporită, siguranţă de funcţionare diminuată;
- concizie seducătoare a exprimării;
- conversii de date şi gestionare a memoriei uşor mai performante
(modulul Vision al lui Pascal 6.0 înlătură această diferenţă);
- programele sursă circulă de regulă în limbaj C.
Informaţiile de mai sus nu pot înclina decisiv balanţa în favoarea unuia
dintre candidaţii la supremaţie. Dar se poate constata o evoluţie a limbajului
PASCAL către C şi putem presupune că disputa se va încheia în momentul în care
cele două limbaje vor fi complet similare. Oricum există un translator (PAS2C) ce
asigură traducerea fişierelor-sursă PASCAL în C şi un alt program (C2PAS) ce
efectuează operaţia în sens invers. Deci, problema deciziei „PASCAL sau C?”
poate fi considerată mai mult de domeniul livrescului.
Timp de lucru : 40 min 35

Punctaj 7p
1. Care sunt principalele clase de limbaje de programare (1,5 pct.)
2. Care sunt diferenţierile ce se pot face pentru limbajele de nivel scăzut
(1,5 pct.)
3. Care sunt caracteristicile fundamentale ale limbajului BASIC (1 pct.)
4. Ce elemente cuprinde în prezent standardul implementărilor PASCAL
(0,5 pct.)
5. Care sunt principalele caracteristici ale limbajului „C”(0,5 pct.)
6. Care este noutatea limbajului ADA? (1,5 pct.)
7. Care sunt avantajele C şi care sunt cele PASCAL? (0,5 pct.)
Total puncte: 7 Puncte obţinute………
U3.5. Rezumat
Deci, se poate constata o evoluţie a limbajului PASCAL către C şi putem

presupune că disputa se va încheia în momentul în care cele două limbaje vor fi
complet similare. Oricum există un translator (PAS2C) ce asigură traducerea
fişierelor-sursă PASCAL în C şi un alt program (C2PAS) ce efectuează operaţia în
sens invers.
36
UNITATEA 4
LIMBAJE ORIENTATE PE GESTIUNEA
BAZELOR DE DATE
Cuprins: pag.
U4.2. Limbaje orientate pe gestiunea bazelor de date ............................. 37
U4.3. Caracteristici definitorii S.G.B.D.-uri clasice ................................. 39
U4.4. Tipuri de SGBD: DBASE, PARADOX, FOX ................................. 41
U4.6. Rezumat ............................................................................................. 43

 Limbaje orientate pe gestiunea bazelor de date;
 Caracteristicile definitorii ale S.G.B.D.-uri clasice;
 Tipuri de SGBD: DBASE, PARADOX, FOX.
U4.2. Limbaje orientate de gestiunea bazelor de date
Datorită implicării tot mai accentuate a calculatoarelor în multe domenii de

activitate, sfera problemelor rezolvate cu ajutorul calculatorului s-a extins foarte
mult. A apărut astfel a specializare a programelor (pachetelor de programe),
orientate spre rezolvarea diverselor tipuri de probleme: matematice, tehnice,
economice, de proiectare etc. Sistemele de Gestiune a Bazelor de Date (pe scurt
S.G.B.D. - prescurtare foarte des întâlnită în literatura de specialitate) sunt sisteme
informatice (soft) specializate în stocarea şi prelucrarea unui volum mare de date,
volumul de prelucrări implicat fiind relativ mic (spre deosebire de programele
orientate spre rezolvarea problemelor matematice, de exemplu, care necesită un
volum mare de prelucrări asupra unui volum relativ mic de date). Termenul de
bază de date se va referă la datele de prelucrat, la modul de organizare a acestora
37
pe suportul fizic de memorare, iar termenul de „gestiune” va semnifica totalitatea
operaţiilor ce se vor aplica asupra datelor din bazele de date.
Baza de date reprezintă structura logică în care este memorată o cantitate
de informaţii pe un suport fizic de memorare pentru a putea avea acces cât mai
rapid la toate informaţiile depozitate într-o bază de date, aceasta are o anumită
organizare, asemănătoare unui tabel, folosindu-se următoarea terminologie:
- câmp - coloană în tabel
- înregistrare - linie în tabel
- structura bazei de date - antetul tabelului
Pentru a determina în mod univoc structura bazei de date (antetul
tabelului) trebuie specificate câmpurile care compun tabelul , împreună cu
caracteristicile acestora. Fiecărui câmp îi sunt caracteristice:
- numele - identifică câmpul printre celelalte elemente
- tipul - stabileşte prelucrările ce se pot aplica datelor memorate în câmpul
respectiv
- lungimea - numărul de octeţi ocupaţi de câmp
- zecimale - pentru câmpurile numerice stabileşte poziţia punctului zecimal
în cadrul câmpului respectiv
Un S.G.B.D. trebuie să asigure următoarele funcţiuni elementare relativ la
bazele de date:
- definirea, crearea bazei de date;
- introducerea datelor în bazele de date (adăugare);
- modificarea unor date deja existente în bazele de date;
- ştergerea datelor din bazele de date;
- consultarea bazelor de date (interogarea, extragerea informaţiilor).
Alături de acestea, S.G.B.D-urile mai pot fumiza şi alte servicii, cum ar fi:
- suport pentru limbaj de programare;
- interfaţă cât mai atractivă şi performantă, pentru comunicarea cu
utilizatorul;
- diferite tehnici avansate de memorare, organizare, accesare a datelor din
bazele de date;
- utilitare încorporate: sistem de gestiune a fişierelor, liste şi tabele etc;
- help pentru „ajutarea” utilizatorului în lucrul cu bazele de date etc.
Necesităţile actuale în practica utilizării calculatoarelor se îndreaptă cu
precădere spre gestionarea bazelor de date de mari dimensiuni. O explicaţie
38
posibilă a acestei orientări e dată de faptul că o bază de date reprezintă informaţie,
iar cel care deţine informaţii complete şi rapide într-o anumită problemă este
indiscutabil cu un pas înaintea celorlalţi. Concurenţa din. domeniul economic
poate fi numită pe bună dreptate o bătălie informaţională.
Desigur, nu este nevoie să detaliem pentru cititor importanţa sistemelor de
gestiune a bazelor de date (S.G.B.D.). O experienţă minimă în domeniul
informatic este suficientă pentru a constata că la tot pasul apar necesităţi de
utilizare a unui S.G.B.D.
Pentru a putea studia diversele opţiuni posibile vom prezenta mai întâi
termenii care definesc un S.G.B.D., deci cadrul teoretic ce va constitui baza
consideraţiilor ulterioare.
U4.3. Caracteristici definitorii S.G.B.D.-uri clasice
Un sistem de gestionare a bazelor de date de tip clasic operează cu

următorii termeni fundamentali:
- câmp = o locaţie în care se poate memora o informaţie bine determinată;
- înregistrare = mai multe câmpuri alcătuiesc împreună o înregistrare;
- baza de date = colecţie de înregistrări.
După cum se observă, datele sunt gestionate prin intermediul unei
structuri, organizată ierarhic, deci la un nivel de organizare logică.
Pentru a exploata o bază de date se defineşte mai întâi structura ei
(câmpurile ce alcătuiesc o înregistrare). Această structură reprezintă “sertarele”
goale în care vor fi depuse date. Se operează cu două tipuri fundamentale de
câmpuri:
- câmpuri numerice (informaţie numerică);
- câmpuri alfanumerice (orice caracter tipăribil).
După operaţia iniţială de definire a bazei de date urmează exploatarea sa
efectivă. Se pot diferenţia două tipuri importante de operaţii:
- întreţinere bază de date, ce presupune următoarele:
- introducere înregistrare în baza de date (inserare);
- regăsire a unei înregistrări deja introduse;
- modificare a unei înregistrări existente;
- ştergere completă din baza de date a unei înregistrări;
- adăugare înregistrare la sfârşitul bazei de date;
39
- prelucrare elementară a bazei de date, ce presupune în principal sortarea
(indexarea) înregistrărilor dintr-o bază de date;
- generarea de rapoarte pe baza datelor disponibile într-o bază de date.
Datorită importanţei deosebite a operaţiei de sortare, vom detalia acest
subiect.
Este evident pentru oricine că o carte de telefon în care numele persoanelor
nu sunt ordonate alfabetic este, din punct de vedere practic, ca şi inexistentă.
Datele există în forma completă, din punct de vedere cantitativ, însă esenţială este
metode calitativă de organizare a lor.
Operaţia elementară de sortare a unei baze de date presupune ordonarea
înregistrărilor acesteia, după o ordine prestabilită (de ex.: ordinea alfabetică pentru
valorile alfanumerice sau ordinea crescătoare/descrescătoare pentru valorile
numerice).
Ordonarea bazei de date se poate face:
- fizic; înregistrările din baza de date schimbă între ele poziţia ocupată
astfel încât să fie dispuse în ordinea corectă.
- logic înregistrările nu îşi schimbă ordinea în baza de date, dar sunt privite
altfel prin intermediul unui index ce specifică ordinea lor logică..
Desigur, indexarea este o operaţie mult mai rapidă pentru bazele de date
mari, dar presupune o scurtă întârziere în regăsirea informaţiilor faţă de metoda
sortării lor fizice.
Pentru un S.G.B.D. de tip clasic toate cerinţele descrise până în acest punct
sunt minimale şi cu greu se mai poate opta pentru un mediu restrâns la aceste
operaţii.
Facilităţile suplimentare puse la dispoziţie sunt în general următoarele:
- manipulări grupe de înregistrări (copieri dintr-o bază de date într-o alta,
ştergeri etc);
- import/export date; bazele de date gestionate intern de către S.G.B.D. pot
fi puse la dispoziţie şi în formate ce sunt recunoscute de alte programe.
Import = încărcare date dintr-un format diferi de cel intern al S.G.B.D.-
ului.
Export = furnizare date convertite de la formatul intern la un alt format
extern S.G.B.D.-ului în cauză.
Formatul extern recunoscut de majoritatea S.G.B.D.-urilor clasice este
formatul ASCII.
40
- posibilităţi avansate de regăsire a înregistrărilor;
În mod clasic, regăsirea unei înregistrări se face după numărul ei în baza
de date sau după valoarea unui câmp. Aceste metode presupun un lucru greu
acceptabil: trebuie ştiut dinainte ceea ce trebuie aflat.
Caracteristicile principale ale unui mediu de tip S.G.B.D. sunt calitatea
serviciilor de exploatare oferite şi gradul de elaborare al limbajului de programare
definit.
Pentru prima cerinţă întâlnim aceleaşi criterii de evaluare ca în cazul
oricărei alte aplicaţii:
- interactibilitatea cu utilizatorul;
- viteză de lucru;
- protecţii la erori (accidente).
Cea de-a doua componentă (mediul de programare) reprezintă
implementarea unui limbaj orientat pe gestiunea bazelor de date. Pentru
caracterizarea sa vom ţine seama de criteriile uzuale:
- interactivitate mediu de programare;
- compilator / interpretor (viteza de lucru a aplicaţiilor obţinute);
- calitatea conceptuală a serviciilor şi funcţiilor oferite de limbaj;
- protecţia la erori a programelor obţinute, siguranţa în funcţionare;
- uneltele suplimentare de lucru (depanator, profiler).
Optarea pentru un anumit produs trebuie făcută după analizarea cu atenţie
a acestor caracteristici.
U4.4. Tipuri de SGBD: DBASE, PARADOX, FOX
Pentru a lansa în execuţie produsul FoxPro se lansează FOX.EXE. După

executarea acestei comenzi va apărea pe ecran o fereastră numită COMMAND şi
un meniu bară alcătuit din: SYSTEM, FILE, EDIT, DATABASE, … etc.
Activarea meniului se face prin apăsarea tastei F10.
Funcţiile care se pot aplica unei baze de date se împart în două mari
categorii, care asigură funcţionarea tuturor funcţiunilor unui SGBD:
- Funcţia de descriere a datelor: - S.G.B.D. trebuie să permită descrierea
structurii datelor, a legăturilor dintre entităţi, a condiţiilor de validare şi acces.
Pentru aceasta S.G.B.D.-urile dispun de un limbaj specializat: LIMBAJUL DE
DESCRIERE A BAZEI DE DATE (LDD).
41
- Funcţia de manipulare: - permite crearea, actualizarea datelor, căutarea
rapidă, sortarea. Pentru acestea se foloseşte LIMBAJUL DE MODIFICARE A
BAZEI DE DATE (LMD).
Limbajul de descriere a bazei de date (LDD).
Setul de caractere: - este format din literele mari si mici ale alfabetului,
cifrele sistemului zecimal si caracterele: ., #, @, &,…etc.
Identificatorii:- sunt folosiţi pentru desemnarea variabilelor, fişierelor,
programelor, numelor de câmp. În funcţie de utilizare, aceştia pot avea maxim 10
caractere, dintre care prima este literă.
Cuvinte cheie: desemnează comenzile, funcţiile standard ale limbajului
neputând fi folosite în alt context şi pot fi prescurtate la primele patru caractere.
Tipuri de date:
- tipul numeric - este specificat prin litera N sau F.
- tipul şir - mulţime ordonată de caractere ASCII, fiind specificate prin
litera C.
- tipul dată calendaristică - este specificată prin litera D.
- tipul logic - mulţimea formată din două valori T sau F (litera L- logical).
- tipul memo - folosit numai în baze de date şi este asemănător cu tipul şir,
dar are o lungime variabilă (litera M)
Constante - sunt date ale căror valori constituite chiar din caracterele
utilizate în scrierea lor:
- numerice
- caracter
- logic
- dată calendaristică
Variabile - zone de memorie identificate printr-un nume-utilizator ce
primesc la un moment dat o valoare şi un tip.
Operatorii limbajului:
- aritmetici: +, -, /, *, **
- relaţionali: <, >, <=, >=
- logici: .not., .or., .and.
Expresiile: numerice; relaţionale; logice; şir; dată calendaristică.
Limbajul de manipulare al bazei de date (LMD) este alcătuit din comenzi
şi clase de comenzi (funcţii) realizate de SGBD.
42
1. Care sunt limbajele orientate pe gestiunea bazelor de date? (3,5 pct.)

2. Care sunt caracteristicile definitorii S.G.B.D.-urilor clasice? (1,5 pct.)
Timp de lucru : 40 min
Punctaj 6,5p 3. Ce tipuri de S.G.B.D.-uri cunoaşteţi? ? (1,5 pct.)
Total puncte: 6,5 Puncte obţinute
U4.6. Rezumat
Datorită implicării tot mai accentuate a calculatoarelor în multe domenii de

activitate, sfera problemelor rezolvate cu ajutorul calculatorului s-a extins foarte
mult. A apărut astfel a specializare a programelor (pachetelor de programe),
orientate spre rezolvarea diverselor tipuri de probleme: matematice, tehnice,
economice, de proiectare etc. Sistemele de Gestiune a Bazelor de Date (pe scurt
S.G.B.D. - prescurtare foarte des întâlnită în literatura de specialitate) sunt sisteme
informatice (soft) specializate în stocarea şi prelucrarea unui volum mare de date,
volumul de prelucrări implicat fiind relativ mic (spre deosebire de programele
orientate spre rezolvarea problemelor matematice, de exemplu, care necesită un
volum mare de prelucrări asupra unui volum relativ mic de date). Termenul de
bază de date se va referă la datele de prelucrat, la modul de organizare a acestora
pe suportul fizic de memorare, iar termenul de „gestiune” va semnifica totalitatea
operaţiilor ce se vor aplica asupra datelor din bazele de date.
43
MODULUL 2
UNITATEA 5: Rezolvarea problemelor economice cu

ajutorul programelor pe calculator
UNITATEA 6: Noţiuni de bază referitoare la programare
UNITATEA 7: Elementele de bază ale programării orientate

pe obiecte
44
UNITATEA 5
REZOLVAREA PROBLEMELOR ECONOMICE CU
AJUTORUL PROGRAMELOR PE CALCULATOR
Cuprins: pag.
U5.2. Programare ........................................................................................ 45
U5.3. Noţiuni de bază specifice procesului de prelucrare automată a
datelor ................................................................................................. 46
U5.5. Rezumat ............................................................................................. 49

 Rezolvarea problemelor economice cu ajutorul programelor pe
calculator;
 Informatica de gestiune;
 Gestiunea;
 Datele ce sunt prelucrate pe un sistem de calcul;
U5.2. Programare
Rezolvarea problemelor, în general, şi a problemelor economice în

particular, cu ajutorul programelor pe calculator necesită cunoaşterea şi însuşirea
noţiunilor fundamentale referitoare la programare. Problemele economice
prezintă o serie de particularităţi legate de caracterul proceselor şi fenomenelor
economice din care fac parte: existenţa unor modele (inclusiv bazate pe relaţii
matematice), volumul mare de date stocate în baze de date şi în depozite de date,
operaţii relativ puţine şi de complexitate redusă (în comparaţie, de exemplu, cu
45
calculele tehnico-inginereşti), prelucrări şi reprezentări statistice etc. Toate aceste
particularităţi sunt luate în considerare la rezolvarea problemelor economice, în
special a celor de gestiune. Informatica de gestiune reprezintă în esenţă
informatica aplicată în domeniul prelucrării automate a datelor asupra evidenţei şi
controlului activităţilor şi bunurilor unei organizaţii economice.
Gestiunea unei organizaţii economice constă în totalitatea activităţilor
desfăşurate pentru evidenţa resurselor acesteia (umane, materiale, financiare şi
informaţionale), încredinţate, spre administrare, factorilor de decizie, pentru
realizarea scopurilor specifice domeniului său de activitate.
În prezent, dar mai cu seamă în viitor, nu există şi nu va exista nici un loc
de muncă fără calculator conectat în reţea, în special în domeniile contabilitate şi
financiar-bancar. Viitorul economist trebuie să cunoască principiile şi elementele
de bază ale programării şi să câştige deprinderi adecvate, cel puţin din
următoarele două motive:
• economistul este un creator, şi nu un simplu operator pe calculator;
complexitatea şi diversitatea proceselor şi fenomenelor economice presupun o
permanentă deschidere spre schimbarea şi perfecţionarea aplicaţiilor informatice
economice ce pot fi realizate nemijlocit de către economist;
• economistul poartă un dialog permanent cu specialistul informatician în
ceea ce priveşte perfecţionarea sistemelor şi instrumentelor informatice complexe
dedicate rezolvării problemelor economice.
Este inutil să se insiste mai mult, la capitolul motivaţie, asupra importanţei
programării şi bazelor de date pentru viitorul economist cu specializarea
contabilitate şi informatică de gestiune, în care sintagma informatică de gestiune
reprezintă a doua jumătate a întregului. Acest fapt îi conferă viitorului economist
dreptul de a profesa şi în categoria profesioniştilor în informatică, dar, în acelaşi
timp, generează şi obligaţia de a-şi însuşi în mod corespunzător fundamentele
programării şi ale bazelor de date.
U5.3. Noţiuni de bază specifice procesului de prelucrare automată

a datelor
Orice sistem de calcul (adică acel sistem tehnic care asigură execuţia
procesului de prelucrare automată a datelor) are în compunere, în esenţă, partea de
hardware şi partea de software. Bill Gates, patronul Microsoft, spunea în anul
46
2002 că, din totalul costurilor unui sistem de calcul, partea de hardware reprezintă
5%, în timp ce partea de software reprezintă 95%. Problema costurilor unui
sistem de calcul devine din ce în ce mai importantă în condiţiile cerute de
societatea informaţională – societatea cunoaşterii şi în conformitate cu prevederile
legale referitoare la respectarea legii drepturilor de autor în domeniul software.
Partea de software a unui sistem de calcul cuprinde, la rândul ei, software-
ul de bază (sistemul de operare sau sistemul de programe de bază) şi software-ul
de aplicaţie (sau sistemul de programe aplicative). În continuare sunt prezentate
noţiunile de bază specifice procesului de prelucrare automată a datelor.
Sistem informatic conţine unul sau mai multe sisteme de calcul (hard şi
soft), cărora li se adaugă restul bazei tehnico-materiale, baza ştiinţifico-
metodologică, baza informaţională, resursele umane şi cadrul organizatoric. Baza
tehnico-materială conţine echipamentele de culegere, verificare şi transmitere
date, echipamentele de teleprelucrare, suporturile de stocare a datelor şi
calculatorul propriu-zis.
Baza ştiinţifico-metodologică cuprinde modelele matematice ale
proceselor şi fenomenelor economice şi metodologii de realizare a sistemelor
informatice. Baza informaţională se referă la date, fluxuri şi circuite
informaţionale, cataloage şi dicţionare de date etc.
Un sistem informatic are funcţia de prelucrare automată a datelor pentru
obţinerea informaţiilor necesare procesului de conducere sau de informare.
Din cele arătate mai sus, rezultă că procesul de prelucrare automată a
datelor presupune existenţa simultană a următoarelor elemente: sistemul de
echipamente (hardware), sistemul de programe de bază, sistemul de programe
aplicative, datele de intrare ce sunt supuse proceselor de prelucrare automată şi
datele de ieşire sau rezultatele prelucrărilor. În esenţă, acest proces de prelucrare
automată a datelor este format din trei etape: introducerea (citirea) datelor de
intrare, prelucrarea datelor (efectuarea calculelor) şi extragerea (scrierea)
rezultatelor. Este de reţinut că datele de intrare sunt introduse printr-o operaţie de
citire - read, iar datele ce reprezintă rezultate sunt obţinute printr-o operaţie de
scriere –write sau de tipărire- print a rezultatelor.
Sistemul de operare este realizat cu preponderenţă în limbajul de
programare C, este livrat cu licenţă, de regulă, de compania producătoare a părţii
hardware a calculatorului şi este specific unui anumit tip de platformă de
calcul (Windows, Unix, OS/2 etc). Programele aplicative sunt realizate prin
47
utilizarea limbajelor de programare acceptate de către sistemul de calcul şi de
sistemul de operare al acestuia.
Datele ce sunt prelucrate pe un sistem de calcul sunt organizate într-o
formă avantajoasă pentru aplicaţia informatică şi sunt reprezentate într-o structură
accesibilă calculatorului. Datele sunt organizate în colecţii de date în funcţie de
condiţiile specifice impuse de sistemul informaţional existent şi de dorinţele
utilizatorilor finali din procesul de decizie.
Procesul de prelucrare automată a datelor are loc într-o succesiune
controlată de operator, adică, în accepţiunea clasică, de acel utilizator final
specializat în operarea pe sistemul de calcul. Etapele procesului de prelucrare a
datelor pe calculator sunt materializate în următoarele operaţii:
 pregătirea datelor iniţiale, de regulă manual, în vederea introducerii lor
în procesul de prelucrare automată (citire), ce presupune verificarea, sortarea şi
codificarea acestor date în funcţie de documentele primare existente;
 verificarea datelor presupune confirmarea concordanţei între valorile
prezente în documentele primare şi valorile care trebuie să existe în conformitate
cu aplicaţia informatică concretă sau problema economică cu urmează a fi
rezolvată;
 sortarea datelor semnifică acel tip de prelucrare prin care datele sunt
dispuse într-o anumită ordine, în conformitate cu un anumit sistem sau cu anumite
precizări ale utilizatorului;
 codificarea datelor înseamnă operaţia de atribuire de semne numerice,
alfabetice sau alfanumerice unor date cu scopul de a optimiza numărul de semne
cu care se scriu şi se prelucrează, de exemplu, elementele specifice sistemului
informaţional financiar-contabil;
 noţiunea de document primar (de evidenţă primară) este cea definită în
contabilitate, ca primă etapă a funcţiei contabile, adică acel document în care se
consemnează pentru prima dată o operaţie economico-financiară (facturi, chitanţe,
cecuri etc). Fiecare eveniment ce prezintă un efect economic se înscrie într-un
document primar în momentul şi în locaţia în care s-a produs;
 introducerea datelor iniţiale în calculator, adică în memoria internă sau
memoria externă a sistemului de calcul; introducerea datelor iniţiale poate fi
făcută direct de la tastatură (în regim conversaţional) sau de pe un suport tehnic
accesibil calculatorului;
 prelucrarea propriu-zisă a datelor, ceea ce înseamnă execuţia automată
48
de către calculator a tuturor operaţiilor prestabilite prin program (validări de date,
sortări, interclasări, comparări şi testări);
 validarea de date este tipul de prelucrare ce constă în verificarea datelor
de intrare dacă sunt corecte în raport cu un set de reguli prestabilite (dacă sunt
reale, coerente, corelate, corect testate, corect transferate dintr-un mediu într-
altul);
 interclasarea datelor reprezintă tipul de prelucrare prin care se obţine un
şir (vector) de date ce conţine toate elementele unor vectori iniţiali ordonaţi;
 compararea datelor este tipul de prelucrare prin care se verifică
existenţa unor relaţii de ordine între două date;
 relaţia de ordine a fost definită la cursul de matematică şi este o relaţie
binară pe o mulţime de date ce stabileşte ordinea de parcurgere a elementelor
mulţimii;
 testarea datelor este tipul de prelucrare prin care se verifică un ansamblu
de date ce sunt pregătite pentru buna funcţionare a unui program;
 prezentarea rezultatelor prelucrării, adică afişarea pe ecranul
monitorului sau imprimarea pe hârtie; când rezultatele sunt folosite în prelucrări
ulterioare, ele sunt stocate pe suporţi magnetici.
Etapele şi operaţiile prezentate mai sus se încadrează în ”triada de aur”
specifică oricărui sistem de calcul: stocare – prelucrare– prezentare date.
1.Cum rezolvăm problemele economice cu ajutorul programelor pe

calculator (2,5 pct.)
Timp de lucru : 40 min
Punctaj 5p 2.Care sunt noţiunile de bază specifice procesului de prelucrare automată a
datelor? (2,5 pct.)
Total puncte: 5 Puncte obţinute: .....
U5.5. Rezumat
Procesul de prelucrare automată a datelor are loc într-o succesiune

controlată de operator, adică, în accepţiunea clasică, de acel utilizator final
49
specializat în operarea pe sistemul de calcul şi se încadrează în „triada de aur”
specifică oricărui sistem de calcul: stocare – prelucrare– prezentare date.
50
UNITATEA 6
NOŢIUNI DE BAZĂ REFERITOARE LA
PROGRAMARE
Cuprins: pag.
U6.2. Noţiuni de bază referitoare la programare ..................................... 51
U6.3. Problematica generală a limbajelor de programare ...................... 57
U6.4. Rezumat ............................................................................................. 60

 noţiuni de bază referitoare la programare;
 problematica generală a limbajelor de programare.
U6.2. Noţiuni de bază referitoare la programare
Rezolvarea unei probleme reprezintă procesul de concepere şi de

implementare a unei strategii de găsire a unei soluţii sau de conversie la
normalitate a unor stări generate de condiţii nedorite sau neaşteptate.
În activitatea de concepere a programelor destinate calculatoarelor
electronice, problema de rezolvat este definită, detaliată şi transformată într-un
proiect pe baza căruia se poate realiza un program ce poate fi rulat pe un sistem
de calcul.
Înainte de a se scrie efectiv programul, se efectuează analiza problemei de
rezolvat şi se realizează algoritmul de calcul.
Programul pe calculator este un set de instrucţiuni (comenzi) ce se
51
execută de sistemul de calcul cu scopul de a efectua o succesiune de acţiuni sau un
tip prestabilit de activitate.
Instrucţiunea sau comanda semnifică un enunţ ce specifică o acţiune într-
un limbaj de programare.
Programul pe calculator (sau, mai simplu, programul) are în compunere,
de regulă, două tipuri de enunţuri: declaraţii şi instrucţiuni. Declaraţia este
asocierea dintre un identificator şi anumite informaţii. Această asociere este
formală la realizarea programului şi devine efectivă în timpul compilării sau în
timpul execuţiei programului. Declaraţia priveşte modul de organizare a datelor de
intrare, pe timpul prelucrării, precum şi a datelor de ieşire (rezultatelor).
Identificatorul reprezintă orice şir de caractere alfanumerice ce se foloseşte
în calitate de:
 nume de variabilă sau constantă într-un program;
 etichetă de regăsire a unui punct din program;
 nume de procedură sau de funcţie;
 nume ataşat unei unităţi logice de memorie externă (hard disc, dischetă,
compact disc, memorie flash etc.).
Dintr-o altă perspectivă, orice program pe calculator reprezintă un
ansamblu format din date (structuri de date) şi algoritmi prezentate într-un
limbaj de programare. Noţiunea de algoritm nu are o definiţie riguroasă.
Algoritmul este o metodă, un procedeu, o reţetă, o soluţionare a unei probleme,
fără însă a realiza echivalenţa cu aceşti termeni.
Dicţionarele de informatică definesc algoritmul ca:
 descriere a schemei de realizare a unui eveniment cu ajutorul unei
mulţimi finite de acţiuni elementare predenumite, realizabile a priori şi având o
durată limitată în timp;
 un concept folosit pentru a desemna o mulţime finită de operaţii
cunoscute care, executate într-o ordine bine stabilită, pornind de la o mulţime de
valori (date) de intrare conduc la obţinerea în timp finit a unei alte mulţimi de
valori, valori (date) de ieşire;
 secvenţă finită de paşi prin care se rezolvă o problemă logică sau
matematică.
În realizarea unui algoritm este necesară satisfacerea următoarelor patru
condiţii (proprietăţi):
 claritatea, ceea ce înseamnă ca algoritmul să fie bine definit (cu
52
specificaţii riguroase şi fără ambiguităţi);
 exactitatea (determinismul), adică în fiecare moment al execuţiei
algoritmului, se cunosc cu exactitate următoarea operaţie, precum şi modul de
execuţie a fiecărei operaţii; descrierea cu exactitate asigură execuţia algoritmului
pe un sistem de calcul;
 universalitatea, ceea ce semnifică faptul că orice algoritm, fiind cât mai
universal cu putinţă, asigură rezolvarea unei clase largi de probleme;
 finitudinea, ce constă în faptul că algoritmul este finit în spaţiu (ca
descriere) şi asigură obţinerea rezultatului într-un timp determinat de execuţie,
adică după un anumit număr finit de paşi.
După gândirea algoritmului, acesta se poate reprezenta sub mai multe
forme; dintre aceste forme, cele mai uzuale sunt reprezentarea în limbaj
pseudocod şi schema logică.
Limbajul pseudocod asigură descrierea algoritmilor prin intermediul a
două enunţuri: standard şi nestandard; enunţurile nestandard sunt fraze în limbajul
natural ce se folosesc, de regulă, în programare pentru reprezentarea formei
iniţiale a algoritmilor; enunţurile standard exprimă operaţii ce dispun de
corespondenţe directe în instrucţiunile limbajului de programare.
Schema logică asigură reprezentarea sub formă grafică a algoritmilor.
Schema logică de program se deosebeşte de schema logică de sistem.
Schema logică de sistem descrie operaţiile de prelucrare a datelor pe
sistemul de calcul, cu focalizare pe sursele de date, documentele primare ce le
conţin, activităţile ce se execută asupra lor, modul de stocare şi de prezentare a
rezultatelor prelucrării.
Schema logică de sistem este utilizată pentru a oferi o imagine de
ansamblu a fluxurilor de date din sistemul de calcul, în timp ce schemele logice de
program sunt folosite pentru detalierea anumitor procese reprezentate în schema
logică de sistem.
Schemele logice de program sunt independente de limbajul de programare
utilizat.
Pentru realizarea unui program sunt necesare trei tipuri de structuri de
control, caracterizate prin aceea că au o singură intrare şi o singură ieşire. Această
posibilitate se bazează pe teorema lui Boehm şi Jacopini care arată că orice
algoritm poate fi reprezentat ca o combinaţie a celor trei structuri de control
fundamentale: secvenţială, alternative şi repetitive.
53
 Structura de control secvenţială (liniară) cuprinde o succesiune de
blocuri care se execută unul după altul;
 Structurile de control alternative (cu ramificaţii) corespund unui bloc de
prelucrare care se execută în functie de satisfacerea unei condiţii.
Aceste structuri de control prezintă următoarele forme:
 structura de control alternativă cu două ramificaţii (If…Then…Else);
 structura de control alternativă cu mai multe ramificaţii (imbricată);
 structura de control alternativă generalizată (Case-Of).
Structurile de control repetitive (de ciclare) asigură repetarea prelucrării
unor secvenţe de program. Formele structurilor de control repetitive sunt:
 structura repetitivă fără contor condiţionată anterior (While Do);
 structura repetitivă fără contor condiţionată posterior (Repeat …Until);
 structura repetitivă cu contor condiţionată anterior (Do…For);
 structura repetitivă cu contor condiţionată posterior (Do…For).
Din punct de vedere structural, un program poate avea în compunere mai
multe subprograme sau module. Pot constitui subprograme, componentele
programului de tipul procedurilor şi/sau al funcţiilor. Mai multe programe
alcătuiesc împreună o aplicaţie informatică. Clasic, aplicaţia informatică are o
structură statică arborescentă, adică este formată dintr-un program principal care
apelează subprograme. Subprogramele sunt independente în conformitate cu
principiile programării structurate (programe constituite din subprograme sau
module şi folosirea structurilor de control fundamentale).
Aplicaţia informatică este dedicată unui anumit domeniu de activitate
economică (de exemplu, aplicaţie informatică de contabilitate, aplicaţie
informatică pentru managementul resurselor umane, aplicaţie informatică pentru
gestiunea creditelor bancare etc.). Noţiunea de aplicaţie informatică nu este
similară cu aceea de sistem informatic.
Limbajul de programare este un limbaj artificial ce se foloseşte pentru
definirea unui şir de instrucţiuni care pot fi prelucrate şi executate pe un
calculator.
Problematica generală a limbajelor de programare este tratată în finalul
acestui paragraf.
Procedura (procedure) este o parte componentă, cu nume, a unui
program, căreia îi sunt associate constante, tipuri de date şi variabile şi care
54
execută, de regulă, un task unic. Task-ul este un subprogram sau aplicaţie
autonomă rulată ca o entitate independentă.
Funcţia (function) este un subprogram sau rutină care returnează o singură

valoare prin însăşi numele funcţiei. Spre deosebire de funcţie, procedura poate
returna mai multe valori atunci când este rulată.
Variabila este, în programare, o locaţie de memorie în care se stochează
date de un anumit tip şi care pot fi modificate pe timpul execuţiei programului.
Constanta desemnează o entitate cu nume ce reprezintă o valoare care nu
se modifică pe timpul execuţiei unui program.
Structura de date este o schemă de organizare a datelor cu scopul de a
simplifica operaţiile de prelucrare sau de a uşura interpretarea lor.
Există mai multe tipuri de structuri de date: vector, înregistrare, mulţime
etc. Instrucţiunea este formată din două elemente distincte: codul operatorului şi
operanzii (datele supuse operaţiei elementare reprezentate prin cod). În funcţie de
tipul prelucrării pe care o execută, instrucţiunile se clasifică în:
 instrucţiuni de prelucrare propriu-zisă;
 instrucţiuni de organizare (structurare), care realizează concordanţa
logică între algoritm şi succesiunea internă a secvenţelor de program.
Instrucţiunile de prelucrare propriu-zisă se grupează în:
 instrucţiuni de intrare-ieşire, care stabilesc sensul fluxului de date în
sistemul de calcul, fişierul de date asupra căruia se efectuează operaţia şi
echipamentul periferic pe care se găseşte acest fişier de date; fişierul de date este
o colecţie de date stocată pe un suport tehnic într-o succesiune de înregistrări;
 instrucţiunile de calcul, ce precizează natura operaţiei, adresele
operanzilor care participă la calcul şi a operaţiei aritmetice;
 instrucţiunile de transfer (atribuire), ce realizează transferul datelor,
precizând sensul transferului şi adresele operanzilor.
Instrucţiunile de organizare sunt următoarele:
 instrucţiunile de comparare (decizie logică), care asigură compararea a
doi sau mai mulţi operanzi, rezultatul fiind categorisit ca „adevărat” (True) sau
„fals” (False);
 instrucţiunile de salt, ce realizează trecerea de la secvenţa de instrucţiuni
curentă din program la o secvenţă de instrucţiuni situată în alt punct al
programului.
55
Indiferent de limbajul de programare folosit pentru rezolvarea problemei,
realizarea unui program presupune parcurgerea următoarelor etape:
1. Analiza problemei de rezolvat şi realizarea algoritmului, etapă ce

presupune elaborarea unui enunţ complet al problemei, stabilirea modalităţilor de
organizare şi de reprezentare a datelor de intrare şi de ieşire, elaborarea schemei
logice de sistem care defineşte echipamentele din configuraţia calculatorului ce
participă la procesul de prelucrare a datelor, realizarea algoritmului ce presupune
elaborarea şi reprezentarea acestuia în limbaj pseudocod sau sub forma schemei
logice de program.
2. Scrierea (introducerea) programului, ce are drept scop codificarea
algoritmului, adică conversia acestuia în conformitate cu instrucţiunile unui limbaj
de programare; pentru această codificare, se foloseşte un editor de texte; acest
editor poate fi independent sau poate face parte din mediul integrat de dezvoltare
(IDE); se obţine astfel programul-sursă (codul-sursă al programului), care este
scris într-un limbaj similar cu limbajul natural, dar încă inaccesibil sistemului de
calcul;
3. Compilarea programului, ce realizează traducerea programului-sursă
scris într-un limbaj de programare de nivel înalt în program-obiect, exprimat în
instrucţiuni cod-maşină. Această operaţie de traducere se obţine, în mod automat,
prin folosirea unei componente a sistemului de operare, numită compilator. După
compilare, eventualele erori de codificare existente în program (numite erori de
sintaxă ce apar datorită nerespectării sintaxei generale a unei instrucţiuni) sunt
depistate şi afişate. Erorile de sintaxă sunt eliminate prin corecţii aduse
programului-sursă, după care operaţia de compilare este reluată. Este important de
menţionat faptul că în etapa de compilare nu se depistează erorile logice din
program; erorile logice sunt greşeli produse la realizarea algoritmului de calcul.
4. Editarea de legături (linkeditarea), ce asigură includerea codului obiect
al programului (programul-obiect) într-un ansamblu executabil (programul
executabil), care cuprinde şi module specifice sistemului de operare, funcţii de
bibliotecă etc. cu ajutorul componentei denumită editor de legături (linkeditor).
Eventualele erori ce apar conduc la corecţii în programul-sursă.
5. Testarea logică a programului, care realizează verificarea finală a
programului pe baza unui set de date de test ce acoperă domeniul real de valori ale
datelor de intrare ce se vor folosi în timpul exploatării programului.
56
U6.3. Problematica generală a limbajelor de programare
Limbajul de programare reprezintă un limbaj artificial ce se foloseşte

pentru definirea unui şir de instrucţiuni care pot fi prelucrate şi executate pe un
sistem de calcul.
Spre deosebire de limbajele naturale (umane), limbajele artificiale au fost
create cu scopuri precise: limbaje de programare, limbaje de specificare a
programelor, limbaje de descriere a documentelor structurate, limbaje de schimb
de date electronice, EDI (Electronic Data Interchange) etc.
Limbajele de programare se definesc formal prin alfabet, vocabular şi
gramatici (fapt ce permite compilarea sau interpretarea lor). Alfabetul reprezintă
mulţimea simbolurilor utilizate pentru scriere în limbajul de programare respectiv.
Vocabularul este compus din mulţimea cuvintelor întrebuinţate în limbaj.
Gramatica limbajului de programare este reprezentată de ansamblul
regulilor de scriere, cu preponderenţă sub aspect sintactic (mulţimea regulilor de
formare a instrucţiunilor), cu luarea în consideraţie a regulilor de punctuaţie şi a
semanticii (semnificaţiilor conferite cuvintelor) şi extrem de puţin sub aspect
morfologic (ansamblul regulilor de modificare a formei cuvintelor, în contextul
utilizării lor).
Operaţia de interpretare asigură execuţia instrucţiune cu instrucţiune (la
comanda pas cu pas a operatorului) a unui program.
Limbajele de programare au evoluat istoric în concordanţă cu dezvoltarea
şi progresele părţii de hard a sistemelor de calcul. În anul 1944, când firma IBM şi
Universitatea Harvard au realizat primul calculator electronic denumit MARK 1,
programarea s-a efectuat în limbaj cod-maşină (generaţia zero, 0 GL), sub forma
unei succesiuni de instrucţiuni în cod binar. Primul limbaj de programare
(generaţia 1, 1 GL) este definit după anul 1950, pentru calculatorul electronic
UNIVAC 1, sub denumirea de program asamblor, care automatizează
programarea calculatoarelor prin simbolizarea instrucţiunilor, operanzilor şi
adreselor de memorie sub formă de mnemonice şi prin translatarea programelor
din forma scrisă cu mnemonice în limbaj cod-maşină. După anul 1960, sunt puse
la punct primele limbaje de nivel înalt sau evoluate (Cobol, ALGOL, FORTRAN).
57
Limbajele de nivel înalt sau evoluate sunt concepute în funcţie de
domeniul de aplicaţii informatice căruia îi este destinat (limbaje specializate,
pentru aplicaţii economice – limbajul Cobol, pentru aplicaţii tehnico-inginereşti,
limbajul FORTRAN, pentru aplicaţii de inteligenţă artificială, limbajele Lisp şi
Prolog) sau sunt universale (de exemplu, limbajele de programare PL/1 şi Ada).
Tendinţa de „ieşire” a limbajelor de programare din laboratoarele firmelor de
calculatoare şi de facilitare a însuşirii acestora de cercuri diverse de utilizatori s-a
materializat în dezvoltarea unor limbaje de programare „didactice”, cum sunt
Pascal şi Basic.
Dintre limbajele de programare de nivel înalt utilizate în prezent pentru
realizarea de software profesional de către firmele specializate se menţionează
limbajele C (cu variantele sale ulterioare C++, C#), Java, Ada.
Dintre limbajele de nivel jos (apropiate de cod-maşină) se menţionează
limbajele de macroasamblare (MASM, TASM), ce aparţin generaţiei 2 (2 GL), la
care se realizează gruparea unor secvenţe de instrucţiuni realizatoare ale unor
operaţii repetitive, de rutină, într-o macroinstrucţiune (instrucţiune a limbajului de
macroasamblare). Macroinstrucţiunile sunt standard (specifice limbajului de
programare) sau sunt definite de utilizator. Fiecare tip de microprocesor, ce
defineşte sistemul de calcul, dispune de propriile său limbaj cod-maşină şi limbaj
de asamblare.
Limbajele de programare pot fi procedurale şi neprocedurale.
Limbajul procedural sau imperativ,ce defineşte generaţia 3 (3 GL), este
limbajul de programare în care elementul esenţial al programării este procedura
(exemple: Basic, C, Pascal, Cobol, Fortran, Ada etc.). Limbajul procedural
necesită o detaliere atentă a ansamblului de instrucţiuni ce urmează a fi executate
în scopul realizării unei sarcini (task) precizate şi este independent de sistemul de
calcul.
Limbajele neprocedurale sunt limbaje de nivel foarte înalt, din generaţia 4
(4 GL), situate deasupra limbajelor de nivel înalt, specializate pe tipuri de aplicaţii
informatice. Aceste limbaje se caracterizează prin faptul că necesită precizarea
problemei de rezolvat, a metodei de rezolvare (şi nu a algoritmului de rezolvare),
a referirilor asociative de date (şi nu a adreselor specifice datelor) şi a operatorilor
generali necesari operaţiilor cu structuri de date. Limbajele neprocedurale sunt
foarte apropiate de limbajele naturale (umane). O ierarhie a limbajelor de
programare este prezentată în figura de mai jos.
58
LIMBAJE DE NIVEL FOARTE ÎNALT (4 GL)
LIMBAJE DE NIVEL ÎNALT (3 GL)
LIMBAJE DE MACROASAMBLARE (2 GL)
LIMBAJ DE ASAMBLARE (1 GL)
LIMBAJ COD-MAŞINĂ (0 GL)
HARDWARE
Un mare grad de utilizare îl prezintă sistemele de gestiune a bazelor de

date (SGBD) ce sunt fundamentate pe limbaje de descriere a structurii bazei de
date şi pe limbaje de manipulare şi interogare a bazei de date. SGBD-urile
lucrează cu date organizate în baze de date şi programele sunt independente în
raport cu descrierea datelor. Se dau ca exemple SGBD-urile FoxPro (cu o largă
răspândire în România în deceniul 9 al secolului trecut), Informix, Oracle, Sybase,
Microsoft Access.
Din categoria limbajelor de programare specializate fac parte limbajele
inteligenţei artificiale. Se dau ca exemple limbajele Lisp şi Prolog.
Limbajele de programare orientate pe obiecte sunt dezvoltate în
conformitate cu conceptul de programare orientată pe obiecte, OOP (Object-
Oriented Programming). Programarea orientată pe obiecte semnifică
programarea bazată pe obiecte la care se adaugă moştenirea şi polimorfismul.
Programarea bazată pe obiecte, OBP (Object-Based Programming)
utilizează conceptele de clasă şi obiect. Dintre limbajele de programare OOP se
menţionează Pascal, C++, C#, SmallTalk, Simula, Java etc.
1. Definiţi care sunt noţiunile de bază referitoare la programare (3,5 pct.)

2. Care este problematica generală a limbajelor de programare (4 pct.)
Timp de lucru: 40 min
Punctaj 7,5p
Total puncte: 7,5 Puncte obţinute ....
59
U6.4. Rezumat
Rezolvarea unei probleme reprezintă procesul de concepere şi de

implementare a unei strategii de găsire a unei soluţii sau de conversie la
normalitate a unor stări generate de condiţii nedorite sau neaşteptate.
În activitatea de concepere a programelor destinate calculatoarelor
electronice, problema de rezolvat este definită, detaliată şi transformată într-un
proiect pe baza căruia se poate realiza un program ce poate fi rulat pe un sistem
de calcul.
60
UNITATEA 7
ELEMENTELE DE BAZĂ ALE PROGRAMĂRII
ORIENTATE PE OBIECTE
Cuprins: pag.
U7.2. Abordare conceptuală ....................................................................... 61
U7.4. Rezumat ............................................................................................. 65

 Programarea orientată pe obiecte, OOP (Object-Oriented
Programming);
 Programarea bazată pe obiecte, OBP (Object-Based Programming).
U7.2. Abordare conceptuală
Programarea orientată pe obiecte, OOP (Object-Oriented Programming).

Specifică limbajelor de programare orientate pe obiecte, înseamnă programarea
bazată pe obiecte, la care se adaugă moştenirea şi polimorfismul. Programarea
bazată pe obiecte, OBP (Object-Based Programming) utilizează conceptele de
obiect şi clasă.
Obiectul este o entitate dinamică (este creat, utilizat şi apoi distrus)
constituită din oricare unitate programabilă şi caracterizată prin identitate, metode
de comportament şi stare. Identitatea individualizează un obiect în comparaţie cu
alte obiecte.
Metodele de comportament ale obiectului reprezintă elementele
61
comportamentale ale acestuia în momentul accesării. Prin comportament, obiectul
îşi pune în evidenţă apartenenţa la clasă, precum şi individualitatea sa.
Starea obiectului este caracterizată cu ajutorul atributelor lui. Orice atribut
dispune de nume şi valoare sau realizare ce este asociată ca variabilă de instanţă
(ce defineşte proprietăţile obiectului la un anumit moment). Elementele ce aparţin
colecţiei de obiecte descrise într-o clasă reprezintă instanţe de clasă. Obiectul este
definit de un identificator intern unic, independent de valoarea sau adresa de
memorie a obiectului. Acest identificator nu este controlat de utilizator şi nu se
confundă cu diferitele nume utilizate de utilizator cu scopul de a-l numi. Ca
entităţi complexe, obiectele sunt constituite din alte obiecte şi din valori.
Distincţia între obiecte şi valori se realizează prin intermediul stării obiectului:
obiectele dispun de o stare internă care se poate schimba; valoarea nu se schimbă
niciodată. Obiectele sunt create de utilizatori, prin derivare din tipuri de obiecte
create anterior sau printr-o operaţie de creare (new).
Clasa reprezintă o implementare a unui tip abstract de date ce
încapsulează două tipuri de atribute: câmpuri sau proprietăţi şi metode sau
operaţii ale tipului respectiv.
Câmpurile sunt private adică sunt ascunse în reprezentarea obiectului.
Metodele sunt publice adică accesibile utilizatorului. Altfel exprimat, clasa
defineşte o categorie de obiecte cu proprietăţi şi metode ce se moştenesc într-o
subclasă.
Subclasa sau clasa derivată defineşte comportamentul obiectului derivat
dintr-o clasă considerată de bază. Clasa este un model de realizare a obiectelor de
acelaşi tip şi se defineşte cu ajutorul unui limbaj declarativ sau pe cale grafică.
Clasa are un nume, prezintă operaţii externe sau metode, are o reprezentare
internă (ca expresie a valorilor diverselor stări ale instanţelor de clasă) şi
foloseşte cod ce implementează atât operaţiile externe, cât şi descrierile
reprezentării interne a obiectelor. Clasa există conceptual chiar şi atunci când nu
conţine obiecte şi este un şablon pentru generarea şi manipularea obiectelor şi este
accesată de utilizator cu ajutorul interfeţei specifice clasei. Specificarea metodei
se numeşte semnătură, iar modul de implementare constituie corpul metodei.
Noţiunea de clasă este asociată în special cu faza de execuţie şi presupune:
generarea de obiecte (new) şi memorarea mulţimii de obiectecare reprezintă
instanţele claselor. O clasă descrie obiectele, crearea unui obiect realizându-se
prin luarea în consideraţie a unei expresii de tip.
62
Tipul reprezintă o descriere abstractă a unui grup de entităţi asemănătoare.
Obiectul prezintă valorile lui proprii, lista atributelor şi metodelor fiind

gestionate de clasă. Pentru majoritatea limbajelor OOP, ansamblul instanţelor unei
clase reprezintă o colecţie care are acelaşi nume cu clasa şi care se numeşte
extensie a clasei.
Obiectele reprezintă instanţe (manifestări) ale claselor din care fac parte.
Tipul de dată este folosit pentru descrierea unei mulţimi de obiecte care au
aceeaşi reprezentare. Fiecărui tip de dată i se asociază anumite operaţii cum ar fi
de exemplu: operaţii aritmetice pentru date numerice, concatenări pentru şirurile
de caractere, modificări pentru anumite articole.
Tipul abstract de dată este un tip de dată care este definit prin accentuarea
elementelor de precizare a comportamentului şi de specificare a metodelor ce se
pot efectua asupra variabilelor de tipul de dată respectiv (se specifică atât
structura obiectului, cât şi mesajele aplicabile lui). Tipul abstract de dată ascunde
modul în care sunt implementate metodele asociate obiectului, reprezentarea
internă a obiectelor şi protejează algoritmii interni care implementează cererile din
exterior.
Acest tip abstract de dată are două componente: interfaţa (listă de
metode) şi implementarea (descrierea structurii interne a datelor obiectului şi
realizarea procedurilor de implementare a metodelor interfeţei). Structura aleasă
pentru memorarea tipului abstract de dată este ascunsă pentru utilizator; ca
urmare, algoritmul de reprezentare este încapsulat. Există o interfaţă publică, la
care au acces utilizatorii, şi o interfaţă privată, ce ascunde reprezentarea şi
implementarea.
Diferenţa dintre tipul de dată şi clasă este următoarea: tipul de dată este
destinat pentru definirea de declaraţii utilizate pentru controlul static al expresiilor
de limbaj, în timp ce clasele sunt şabloane destinate generării şi manipulării
obiectelor care prezintă proprietăţi şi comportament comun.
Între clase şi obiecte se stabilesc relaţii astfel: asociaţii binare între două
clase, asociaţii n-are între mai multe clase, relaţii între obiect şi clasa din care face
parte, relaţii între obiectele aceleiaşi clase.
Există mai multe paradigme ale modelului folosit de OOP: moştenirea,
încapsularea, polimorfismul, abstractizarea datelor, persistenţa, evenimentul.
Paradigma este un ansamblu ce detaliază conceptele specifice unui anumit
63
termen utilizat ca model. Paradigma se referă la forme de manifestare ale
termenului respectiv.
Moştenirea asigură transferarea de proprietăţi şi metode de la clasa-
părinte către un obiect nou. Prin moştenire sunt generate tipuri noi de obiecte şi
clase într-o ierarhie. Prin moştenire, în OOP se elimină rescrierea şi recodificarea
programelor, asigurându-se reutilizarea codului. Un obiect nou moşteneşte
operaţii sau metode, variabile de instanţă, atribute. În cazul metodelor, este
vorba de partajarea codului, iar în cazul variabilelor, de partajarea structurii între
datele obiectelor.
Proiectarea unei aplicaţii prin intermediul OOP constă în gruparea
informaţiilor generale în clase care sunt apoi specializate pas cu pas în subclase cu
comportament particular.
Aşa cum s-a arătat deja, metodele reprezintă operaţii ce pot regăsi sau
actualiza starea unui obiect. Această stare a obiectului este memorată în
variabilele instanţelor sale. Într-o ierarhie de moşteniri, o metodă definită pentru o
clasă este moştenită de subclasele sale. Moştenirea este implementată static sau
dinamic.
 Moştenirea statică înseamnă adăugarea câmpurilor moştenite, situaţie în
care redefinirea unei clase obligă la actualizarea tuturor subclaselor.
 Moştenirea dinamică se realizează fără a se copia câmpurile moştenite şi
obligă la parcurgerea legăturilor de moştenire. În cazul moştenirii dinamice,
actualizarea se efectuează mai rapid, în timp ce execuţia este mai puţin eficientă.
Moştenirea poate fi simplă sau multiplă.
 Moştenirea simplă se produce atunci când o subclasă moşteneşte
proprietăţi şi metode ale unei singure clase-părinte.
 Moştenirea multiplă se realizează când o subclasă posedă mai multe
clase-părinte.
Încapsularea reprezintă proprietatea ce defineşte posibilitatea de a ascunde
prin mascare atributele proprii unui obiect şi modul în care se execută metodele.
Astfel, sunt protejate obiectele în situaţia efectuării greşite a unor
manipulări exterioare. Un obiect poate fi accesat numai prin metodele asociate la
crearea sa.
Polimorfismul defineşte caracteristica unei metode de a se comporta în
mod diferit în funcţie de clasa de obiecte căreia îi aparţine. Polimorfismul asigură
invocarea pentru obiectele de diferite tipuri a metodelor cu acelaşi nume, dar
64
semantică şi implementare diferită. O metodă se comportă diferit în funcţie de
clasa de obiecte căreia îi aparţine.
Abstractizarea datelor se realizează prin faptul că înseşi clasele sunt
expresia unei abstracţii. Obiectele dintr-o clasă prelucrează datele modelului
clasei căreia îi aparţin. Utilizatorul obţine comunicarea cu obiectele prin mesaje ce
se transmit prin interfaţa ce specifică metodele posibile.
Persistenţa este o proprietate a obiectelor care implică existenţa acestora şi
după încetarea procesului ce le-a creat. Starea obiectului şi codul corespunzător
metodelor sunt memorate în baza de date. Tipurile obiectelor pot fi declarate
persistente prin folosirea cuvântului cheie persistent la momentul declarării,
variabila fiind şi ea constrânsă la un tip persistent.
Evenimentul reprezintă o acţiune efectuată de sistemul de calcul în cazul în
care utilizatorul solicită executarea unei comenzi, este aplicat un mesaj al
sistemului sau există o solicitare din partea altei aplicaţii informatice. Ca urmare,
evenimentele se pot produce în mod interactiv sau programat.
Într-o aplicaţie informatică dirijată prin evenimente, codul nu urmăreşte o
cale prestabilită, ci secvenţe de program executate ca răspuns la apariţia
evenimentelor. Succesiunea în care se produc aceste evenimente determină
secvenţa după care se execută codul, ceea ce înseamnă că, la fiecare rulare a
programului, el va parcurge o cale diferită.
1. Prin ce se caracterizează abordarea conceptuală? (5,5 pct.)

Punctaj 5,5p Total puncte: 5,5 Puncte obţinute……..
U7.4. Rezumat
Proiectarea unei aplicaţii prin intermediul OOP constă în gruparea

informaţiilor generale în clase care sunt apoi specializate pas cu pas în subclase cu
comportament particular.
Aşa cum s-a arătat deja, metodele reprezintă operaţii ce pot regăsi sau
actualiza starea unui obiect. Această stare a obiectului este memorată în
variabilele instanţelor sale. Într-o ierarhie de moşteniri, o metodă definită pentru o
65
clasă este moştenită de subclasele sale. Moştenirea este implementată static sau
dinamic.
66
MODULUL 3
UNITATEA 8: Limbajul de programare Visual Basic
UNITATEA 9: Proiectarea aplicaţiilor în limbajul Visual

Basic
67
UNITATEA 8
LIMBAJUL DE PROGRAMARE VISUAL BASIC
Cuprins: pag.
U8.2. Caractersticile generale ale mediului integrat de dezvoltare Visual
Basic .................................................................................................... 68
U8.3. Componentele de bază ale mediului integrat de dezvoltare
Visual Basic ........................................................................................ 70
U8.5. Rezumat ............................................................................................. 73

 Visual Basic (VB);
 mediu integrat de dezvoltare, IDE (Integrated Development
Environment);
 OLE (Object Linking and Embedding);
 COM (Component Object Model);
 ActiveX – tehnologie soft Microsoft ce reuneşte componente OLE şi
COM;
 DDE (Dynamic Data Exchange);
 ODBC (Open DataBase Connectivity);
 Crystal Report sau Data Report;
 Microsoft Jet Database Engine.
U8.2. Caractersticile generale ale mediului integrat de dezvoltare

Visual Basic
68
Visual Basic (VB) reprezintă un mediu integrat de dezvoltare, IDE
(Integrated Development Environment), în mod interactiv, pentru aplicaţii
informatice sub sistemul de operare Microsoft Windows. În general, un mediu de
programare este un sistem de programare care asistă utilizatorul în proiectarea şi
codificarea algoritmilor şi a datelor, respectiv în editarea şi depanarea
programelor.
Când acest mediu de programare asistă utilizatorul (programatorul) în
toate etapele de realizare a unui program, el se numeşte mediu de dezvoltare. Când
toate componentele de asistare a utilizatorului (programatorului) sunt integrate în
cadrul aceluiaşi mediu de dezvoltare, el se numeşte mediu integrat de dezvoltare.
Termenul visual din denumirea IDE Visual Basic semnifică faptul că
aplicaţiile informatice dezvoltate în VB dispun de interfeţe grafice ce sunt
proiectate vizual de către utilizator. Pentru aceasta, utilizatorul are la dispoziţie un
set de elemente vizuale standard ce pot fi folosite la proiectarea unei interfeţe
grafice, denumite elemente de control, sau, pe scurt, controale (Controls). Aceste
controale sunt dispuse în ferestrele aplicaţiei, ferestre denumite formulare
(Forms), concomitent cu stabilirea proprietăţilor acestora (în fereastra Properties)
la dorinţa utilizatorului şi în conformitate cu necesităţile aplicaţiei
Termenul Basic din compunerea IDE Visual Basic arată tipul limbajului de
programare utilizat pentru realizarea programelor (secvenţelor de cod)
corespunzătoare evenimentelor generate de acţionarea controalelor dispuse în
formularul specific aplicaţiei. Limbajul de programare Basic (acronim provenit
din denumirea în limba engleză – Beginner’s All-purpose Symbolic Instruction
Code), definit la începutul anilor ’60 ai secolului XX, a cunoscut numeroase
versiuni şi dezvoltări ulterioare.
În anul 1991, firma Microsoft a realizat produsul Visual Basic, care,
ulterior, a cunoscut mai multe versiuni, în concordanţă cu dezvoltarea sistemului
de operare Windows. Versiunea Visual Basic 6.0 face parte din pachetul Microsoft
Visual Studio 6.0, iar versiunea Visual Basic.NET este parte componentă a
pachetului Microsoft Visual Studio.NET.
Visual Basic prezintă caracteristici specifice programării structurate
(programării bazate pe obiecte), programării dirijate de evenimente, orientării
spre prelucrarea bazelor de date (manipulare şi interogare).
Aplicaţiile informatice realizate cu VB pot interacţiona cu alte aplicaţii
Windows prin intermediul unor interfeţe specializate: OLE (Object Linking and
69
Embedding) – legarea şi încapsularea obiectelor, ce asigură afişarea datelor din
alte aplicaţii şi modificarea acestor date din interiorul aplicaţiei care le-a generat;
COM (Component Object Model) – model de legare şi comunicare între obiecte
distribuite Windows; ActiveX – tehnologie soft Microsoft ce reuneşte componente
OLE şi COM; DDE (Dynamic Data Exchange) – schimb dinamic de date
(conversaţie) între aplicaţii Windows; ODBC (Open DataBase Connectivity) –
conectivitatea bazelor de date deschise, adică posibilitatea conectării aplicaţiilor
client la multiple servere de fişiere sau de baze de date; Crystal Report sau Data
Report – proiectarea vizuală a rapoartelor unei aplicaţii VB; Microsoft Jet
Database Engine – motorul sistemului de gestiune a bazelor de date Microsoft
Access ce asigură acelaşi limbaj de manipulare a datelor între VB şi Access.
Visual Basic face parte din clasa de medii de dezvoltare rapidă a
aplicaţiilor, RAD (Rapid Application Development), alături de Microsoft Visual
C++, Power Builder, Borland Delphi ş.a. ce prezintă următoarele caracteristici:
realizare rapidă a aplicaţiilor informatice, necesităţi acceptabile de resurse
informatice la execuţie, separarea proiectării prelucrărilor de proiectarea interfeţei,
integrează proiectarea interfeţei, scrierea codului, testarea şi depanarea.
În cadrul pachetului de birotică Microsoft Office, a fost inclus ca limbaj de
dezvoltare un subset al Visual Basic, denumit Visual Basic for Application – VBA.
U8.3. Componentele de bază ale mediului integrat de dezvoltare

Visual Basic
Lansarea în execuţie a VB 6.0 din mediul Windows se execută astfel:

a) Se apasă butonul Start de pe bara de task-uri;
b) Se parcurge succesiunea Programs (All Programs în sistemul de operare
Windows XP) - Microsoft Visual Studio 6.0 - Microsoft Visual Basic 6.0;
c) La apariţia ferestrei de creare a unui nou proiect - New Project, se apasă
butonul Open.
După aceste acţiuni, apar simultan fereastra principală a mediului integrat
de dezvoltare VB (1), cutia cu instrumente Toolbox (2), fereastra de proiectare a
formularului Form Design (3), fereastra de editare a codului Code Editor (4),
fereastra Project Explorer (5), fereastra de stabilire a proprietăţilor Properties (6),
fereastra Form Layout (7), fereastra Immediate (8), fereastra Locals (9), fereastra
Watch (10), utilitarul Object Browser (11).
70
Ferestrele care nu apar la pornirea VB şi sunt necesare pentru lucru pot fi
activate prin următoarea succesiune de comenzi: bara cu meniuri – View –
poziţionare pe denumirea ferestrei – click. Fereastra principală a mediului
integrat de dezvoltare VB are patru componente: bara de meniuri (1), bara cu
instrumente (2) şi două zone care afişează poziţia (3) şi dimensiunea (4) obiectului
ce a fost selectat (obiectul curent).
Butoanele de pe bara cu instrumente (Toolbar) dublează cele mai utilizate
comenzi din bara de meniuri.
Meniurile contextuale cuprind comenzi rapide pentru acţiunile efectuate în
mod frecvent. Pentru deschiderea unui meniu contextual se poziţionează vârful
mouse-ului pe obiectul care trebuie folosit, se apasă butonul din dreapta mouse-
ului, se selectează comanda dorită concomitent cu click executat cu butonul din
stânga mouse-ului.
Cutia cu instrumente, Toolbox asigură instrumentele predefinite folosite în
timpul proiectării formularului pentru a introduce controale pe acesta. Utilizatorul
poate crea propriile controale, imagini sau grafică prin selecţia opţiunii AddTab
din meniul contextual.
Fereastra de proiectare a formularului, Form Design este fereastra pentru
realizarea interfeţei dintre utilizator şi secvenţele de program.
Fereastra de editare a codului, Code Editor este folosită ca editor de texte
71
pentru a introduce codul aplicaţiei informatice. Fiecare formular sau modul de cod
din cadrul aplicaţiei informatice dispune de propria fereastră de editare a codului.
Fereastra Project Explorer serveşte numai la proiectarea aplicaţiei pentru
afişarea colecţiei de fişiere ce conţin formularele şi modulele din cadrul
proiectului aflat în lucru (curent). Unele fişiere sunt încărcate în mod automat de
către sistem, iar alte fişiere sunt realizate de către utilizator (programator).
Fişierele care se găsesc în fereastră (proiect) se pot grupa pe categorii cu ajutorul
butonului ToggleFolders. Butonul View Object serveşte pentru vizualizarea
obiectului selectat (current), iar butonul View Code este folosit pentru vizualizarea
codului.
Fereastra de stabilire a proprietăţilor, Properties asigură afişarea valorilor
proprietăţilor pentru formularul sau controlul selectat. O proprietate reprezintă o
caracteristică a unui obiect (titlu, dimensiuni, poziţie, culoare etc.).
Fereastra Form Layout este folosită pentru vizualizarea aspectului
formularului.
Fereastra Immediate este o fereastră suplimentară utilizată în procesul de
depanare a aplicaţiilor informatice rulate din interiorul mediului IDE. Mediul VB
6.0 permite funcţionarea în trei moduri de lucru:
 proiectare (design mode),
 rulare normală (run mode) şi
 execuţie cu întrerupere (break mode).
Execuţia cu întrerupere (pas cu pas) se utilizează la depanarea aplicaţiei pe
baza punctelor de întrerupere (breakpoints) stabilite în prealabil.
Fereastra Immediate permite introducerea de secvenţe de cod care se
execută imediat sau afişarea valorilor unor expresii.
Fereastra Locals este destinată, la depanarea programelor VB, pentru
afişarea valorilor unor expresii din program.
Fereastra Watch de asemenea, o fereastră suplimentară utilizată în procesul
de depanare a programelor VB, pentru gestiunea variabilelor şi expresiilor
watch,adică a valorilor unor variabile şi expresii din program existente în
momentul acţiunii (curente). Utilizarea ferestrei Watch este posibilă prin
intermediul meniului contextual.
Utilitarul Object Browser realizează afişarea obiectelor disponibile în IDE
ce pot fi utilizate de proiect.
Utilitarul serveşte, de asemenea, pentru a examina obiecte din VB şi din
72
alte aplicaţii, pentru a constata ce metode şi proprietăţi sunt disponibile în cazul
acestor obiecte şi pentru a prelua coduri de program în propria aplicaţie
informatică.
Editorul de meniu (Menu Editor) permite proiectarea meniurilor asociate
formularelor. Pentru afişarea ferestrei corespunzătoare se apasă butonul cu acelaşi
nume de pe bara cu instrumente sau prin opţiunea Menu Editor din meniul Tools.
Fiecare meniu are nume, proprietăţi şi mod de accesare asociat
1. Care sunt caracteristicile generale ale mediului integrat de dezvoltare

VB? (2,5 pct.)
Punctaj 4,5p 2. Care sunt componentele de bază ale mediului integrat VB? (2 pct.)
Total puncte: 4,5 Puncte obţinute……..
U8.5. Rezumat
Aplicaţiile informatice realizate cu VB pot interacţiona cu alte aplicaţii

Windows prin intermediul unor interfeţe specializate: OLE (Object Linking and
Embedding) – legarea şi încapsularea obiectelor, ce asigură afişarea datelor din
alte aplicaţii şi modificarea acestor date din interiorul aplicaţiei care le-a generat.
73
74
UNITATEA 9
PROIECTAREA APLICAŢIILOR ÎN LIMBAJUL
VISUAL BASIC
Cuprins: pag.
U9.2. Proiectarea aplicaţiilor în limbajul Visual Basic ........................... 75
U9.3. Elementele limbajului de programare Visual Basic ...................... 89
U9.5. Rezumat ............................................................................................. 94

 proiectarea aplicaţiilor în limbajul VB;
 crearea interfeţei;
 precizarea proprietăţilor;
 scrierea codului;
 elementele limbajului VB.
U9.2. Proiectarea aplicaţiilor în limbajul Visual Basic
Pentru a proiecta o aplicaţie informatică în limbajul Visual Basic, este

necesară parcurgerea următoarelor trei etape:
1. Crearea interfeţei.
2. Precizarea proprietăţilor.
3. Scrierea codului.
Crearea interfeţei se efectuează cu ajutorul formularelor (Forms). Acestea
servesc pentru a genera ferestre şi casete de dialog, în calitate de containere pentru
elemente care se găsesc în partea ascunsă a aplicaţiei. Precizarea proprietăţilor se
75
realizează prin intermediul ferestrei Properties, după selecţia prealabilă a
obiectului. Scrierea codului se execută folosind fereastra de editare a codului,
CodeEditor. Crearea aplicaţiilor în VB se face în modul de proiectare Design
Mode, iar execuţia acestora se efectuează în modul de rulare normală, Run Mode.
Înainte de prezentarea în detaliu a celor trei etape de proiectare a unei aplicaţii în
VB, se tratează fişierul proiect.
9.2.1. Fişierul proiect
Termenul de proiect în VB este similar cu aplicaţia informatică, astfel că

el cuprinde o listă a fişierelor care intră în compunerea aplicaţiei. Fişierul proiect
este un fişier text cu extensia .VBP. Mediul de dezvoltare VB 6.0 asigură
posibilitatea lucrului cu mai multe proiecte concomitent, proiecte ce sunt reunite
într-un grup deproiecte (fişierul grup de proiecte are extensia .VBG). În lista de
fişiere a unui proiect pot fi incluse următoarele tipuri de fişiere:
 fişier pentru formular (.FRM);
 fişier pentru formular care cuprinde controale cu proprietăţi care prezintă
ca valori date binare (.FRX);
 fişier pentru clasă de module (.CLS);
 fişier pentru modul standard (.BAS);
 fişier pentru control utilizator (.VBX – DDL-uri pentru controale pe 16
biţi şi .OCX - DDL-uri pentru controale pe 32 de biţi).
Din punctul de vedere al utilizatorului, proiectul are în compunere module
existente în mediul integrat de dezvoltare (IDE) Visual Basic, în format binar, şi
module realizate de utilizator (formular, cod, clasă). Modulul reprezintă un termen
76
generic care desemnează entitatea de structurare a unui program. Modulele sunt
reutilizabile, ceea ce înseamnă că un modul folosit într-un program, poate fi
utilizat ulterior şi în alte programe.
Modulul defineşte reguli de vizibilitate adică elementele declarate în
interiorul lui pot fi sau nu pot fi vizibile în exteriorul acestui modul. Orice proiect
trebuie să includă cel puţin un modul (modul de formular sau modul de cod).
Atunci când au fost definite toate componentele unui proiect, acesta poate
fi transformat direct într-un fişier executabil (.EXE), astfel:
1) din meniul File se selectează opţiunea Make … EXE …;
2) se introduce numele fişierului executabil în caseta File Name şi se apasă
butonul OK
Meniul File
Crearea, deschiderea şi salvarea unui proiect se efectuează prin intermediul

comenzilor disponibile în meniul File, astfel:
 New Project (1) serveşte pentru crearea unui proiect nou, adăugând un
nou formular şi, eventual, module, referinţe şi obiecte utilizator cuprinse în
fişierul Auto32ld.VBP;
 Open Project (2) deschide un proiect existent, cu formularele, modulele
şi obiectele utilizator listate în fişierul proiect;
 Save Project As…(5) asigură prima salvare a proiectului în lucru sau
schimbarea numelui unui proiect existent pentru conservarea stadiului la care s-a
ajuns şi continuarea lucrului cu un alt nume de proiect;
 Save Project actualizează, prin salvare pe disc, fişierul proiect al
aplicaţiei existente împreună cu toate formularele, clasele de module şi modulele
standard.
77
Aşa cum se deduce din descrierea opţiunilor de salvare a proiectului de
mai sus, realizarea aplicaţiei este terminată atunci când se selectează comanda
Save Project As…(5) din meniul File sau când se selectează butonul Save Project
din linia de butoane. Mediul Visual Basic solicită salvarea, pe rând, a formularului
şi apoi a proiectului prin introducerea numelui, dar şi a unităţii logice de memorie,
precum şi a căii unde se doreşte a avea loc salvarea. În mod implicit, mediul
Visual Basic asigură salvarea în locaţia C:\Program Files\Microsoft Visual
Studio\VB98 (Save In). Pentru salvarea unui proiect, se recomandă particularizarea
numelui proiectului şi folosirea unei unităţi logice de memorare şi a unei căi
personalizate a utilizatorului pentru fiecare proiect, ca, de exemplu:
Homes(D:)\Student\Facultatea\Grupa\Nume_prenume_student\Numeproiect
Când se lucrează cu mai multe proiecte, la un anume moment un singur

proiect este activ. Între aceste proiecte cu care se lucrează simultan, se pot partaja
fişiere. Un fişier, cum este, de exemplu, un formular, poate aparţine mai multor
proiecte. Crearea unor formulare, module şi controale noi se efectuează cu
comenzile din meniul Project.
Meniul Project
9.2.2. Crearea interfeţei aplicaţiei
Crearea interfeţei unei aplicaţii se realizează cu ajutorul unui obiect

denumit formular (Form). În multe lucrări destinate VB, echivalentul românesc
78
pentru Form este formă. În lucrarea de faţă s-a preferat denumirea de formular,
deşi cea de formă este mai apropiată de termenul în limba engleză (crearea
formularului înseamnă de fapt „turnarea” controalelor într-o formă adecvată
interfeţei aplicaţiei).
Motivul preferinţei pentru „formular” este asigurarea lizibilităţii apariţiei
denumirii acestui obiect în explicaţiile din cuprinsul lucrării, deşi, în dicţionarele
limbii române, formularul, în general, este definit ca un imprimat cu mai multe
spaţii albe ce se completează în vederea întocmirii unui tabel.
Formularul este un container de controale care facilitează dialogul dintre
utilizator şi aplicaţie. Controalele nu pot funcţiona în afara formularului. Ele sunt
obiecte care eliberează programul de sarcinile legate de intrările şi ieşirile
generate de acţiunile utilizatorului, concentrând eforturile pe operaţiile de
prelucrare a datelor. Avantajul controalelor din VB este că ele se aseamănă foarte
mult cu controalele standard ce apar în sistemul de operare Windows (meniuri,
butoane, casete). Controalele uşurează munca de programare în sensul că sunt
eliminate instrucţiunile care să ghideze utilizatorul asupra acţiunilor pe care acesta
trebuie să le întreprindă. La proiectarea interfeţei aplicaţiei (Design Mode),
fereastra de proiectare a formularului serveşte pentru dispunerea controalelor
necesare proiectului.
La rularea programului (Run Mode), formularul îndeplineşte rolul de
fereastră principală a proiectului sau de fereastră de dialog.
La pornirea mediului VB, fereastra de proiectare a formularului cu
numele implicit (default) Form1 este dispusă în centrul ecranului. În interiorul
acestei ferestre se găsesc linii punctate cu rolul de a asigura orientarea
utilizatorului, iar la marginea ferestrei sunt dispuse mânerele de redimensionare a
formularului. Este bine ca, încă de la crearea formularului, să se opteze pentru o
dimensiune potrivită a formularului în raport cu numărul de controale introduse şi
de dimensiunile acestora; nu este estetic şi nici practic să rămână zone mari
nefolosite pe suprafaţa formularului.
Un formular include descrierea grafică a acestuia, controalele sale,
proprietăţile, constantele, variabilele şi procedurile externe, subrutinele de tratare
a evenimentelor, procedurile generale. Fiecărui formular îi corespunde un modul
de formular (Form Module).
Clasa de module (Class Module) este asemănătoare formularului, dar nu
dispune de interfaţă utilizator vizibilă. Clasa de module poate fi folosită pentru
79
crearea obiectelor utilizator, cuprinzând secvenţe de cod pentru metodele şi
proprietăţile obiectelor definite. Obiectele care aparţin aceleaşi clase nu sunt
înzestrate cu evenimente proprii.
Mediul VB asigură interfaţă pentru un singur document (SDI) sau interfaţa
multidocument (MDI). În cazul SDI, toate ferestrele mediului VB pot fi deplasate
pe ecran, iar în cazul MDI, toate ferestrele mediului integrat de dezvoltare VB
(numite fii) sunt incluse într-o fereastră unică (numită părinte) ce poate fi
redimensionată. Pentru a obţine comutarea între modurile de lucru SDI şi MDI se
realizează următoarea succesiune de acţiuni:
 se selectează Options (opţiuni) din meniul Tools; efectul este apariţia
casetei de dialog Options;
 se selectează Advanced;
 se validează sau se invalidează caseta SDI Developement Environement.
În figura de mai jos sunt prezentate controalele implicite incluse în caseta
cu instrumente (Toolbox). Controalele standard sunt butoanele de comandă
(nr.14, Command Button), casetele cu text (nr.13, TextBox), etichetele (nr.2,
Label), casetele de validare (nr.4, Check Box), butoanele de opţiuni (nr.15, Option
Button), casetele cu listă (nr.16, ListBox), casetele cu imagine (nr.12, PictureBox),
barele de defilare (nr.6 şi nr.17, ScrollBar) orizontale şi verticale, casetele
combinate (ComboBox).
Caseta cu instrumente (ToolBox)
Se face menţiunea că această casetă cu instrumente (Toolbox) este

configurabilă. Adăugarea sau scoaterea de controale din caseta cu instrumente
80
(Toolbox) se obţine din meniul Project, opţiunea Components.
Modul de adăugare a unui control la cutia cu instrumente (Toolbox)
Introducerea unui control din cutia cu instrumente (Toolbox) pe suprafaţa

formularului se obţine prin parcurgerea etapelor următoare:
 se deplasează cursorul mouse-ului în cutia cu instrumente (Toolbox), pe
pictograma care reprezintă controlul ce urmează a fi introdus în formular şi se
acţionează butonul din stânga al mouse-lui;
 se mută cursorul mouse-ului pe suprafaţa formularului, în poziţia în care
va fi colţul stâng al controlului;
 se efectuează succesiunea de operaţii de tipul Drug and Drop până se
dimensionează după dorinţă controlul selectat;
 se eliberează butonul stâng al mouse-ului.
O altă modalitate de introducere a controlului selectat pe suprafaţa
formularului este reprezentată de dublu-click-ul mouse-ului pe pictograma (icon-
ul) controlului din cutia cu instrumente (Toolbox). Se generează astfel un control
cu dimensiunile implicite, dispus în centrul formularului.
Dispunerea controalelor pe suprafaţa formularului se face după o anumită
logică legată de succesiunea operaţiilor importante de introducere date, prelucrare
şi afişare rezultate. Fiecare control este caracterizat de un ansamblu de proprietăţi
ce se referă la descrierea comportamentului sau aspectului unui control. Lăţimea
sau înălţimea unui control se măsoară în twip (un twip reprezentând cel mai mic
81
punct adresabil de pe ecran, cu dimensiunea de 1/1440 inch). Aşa cum se va arăta
în paragraful următor, fereastra Properties permite modificarea între limite
prestabilite a valorilor diferitelor proprietăţi ale controalelor.
Focalizarea reprezintă operaţiunea de punere în evidenţă a unui control la
un moment dat; mai precis, acel control devine activ prin focalizare. Acel control
activ se mai numeşte şi focar (focus). Acest lucru se pune în evidenţă printr-o linie
punctată în jurul controlului sau printr-un titlu îngroşat. Mutarea focarului de la un
control la altul se efectuează prin intermediul tastelor Tab sau Shift+Tab. Apăsarea
tastei Enter va determina acţiunea controlului focar sau focalizat.
Ordinea de parcurgere a controalelor în formular reprezintă ordinea în care
controalele sunt puse în evidenţă prin focalizare, o dată cu apăsarea succesivă a
tastei Tab. În momentul activării formularului, este stabilit primul control care este
focalizat. Proprietăţile comune tuturor controalelor din formular care stabilesc
ordinea de parcurgere a controalelor sunt TabIndex (poziţia) şi TabStop (oprirea).
Ordinea de parcurgere a controalelor este circulară şi în ambele sensuri –
înainte (Tab) şi înapoi (Shift+Tab).
Un control poate include o tastă „fierbinte” (Hot Key) ce este evidenţiată
printr-o literă subliniată. Prin acţiunea Alt+litera subliniată, se provoacă acţiunea
controlului respectiv. Litera subliniată se introduce cu ajutorul proprietăţii Caption
prin precedare de un ampersand (&).
Redimensionarea unui control introdus deja pe suprafaţa formularului se
obţine astfel:
1) se selectează controlul de redimensionat prin click executat cu mouse-ul
în interiorul suprafeţei acestui control. Pe marginile controlului apar mânerele de
redimensionare;
2) se fixează cursorul mouse-ului în dreptul unui mâner de redimensionare
şi se mişcă ţinând apăsat butonul stâng al mouse-ului, până se obţine dimensiunea
dorită. Mânerele situate în colţurile suprafeţei controlului redimensionează
controalele atât pe verticală, cât şi pe orizontală, iar mânerele dispunse pe laturi
redimensionează controlul numai într-o singură direcţie;
3) se eliberează butonul stâng al mouse-ului.
Mutarea unui control pe suprafaţa formularului se realizează cu mouse-ul
prin tehnica Drug and Drop.
82
După finalizarea proiectării formularului, blocarea tuturor controalelor pe
suprafaţa formularului se obţine din meniul Format cu opţiunea Lock Controls sau
cu butonul Lock Controls Toggle de pe bara cu instrumente Form Editor.
Formularele sau controalele VB au asociate, în cadrul proiectului,
proceduri eveniment vide care sunt personalizate în momentul execuţiei aplicaţiei.
Pentru exemplificarea etapei de creare a interfeţei aplicaţiei, în continuare
se propune să se introducă controalele pentru un formular care să constituie
interfaţa pentru următoarea aplicaţie informatică:
Să se realizeze un program în limbajul Visual Basic care să calculeze
valoarea totală a unei facturi de materiale. Deocamdată, factura conţine un singur
material la o rulare a programului. Datele de intrare sunt: număr factură (Nrf),
data facturii (Df), codul materialului (Codmat), denumirea materialului (Denmat),
cantitate (Cant) şi preţul unitar al materialului (Pu). TVA este de 19%. Datele de
intrare vor fi introduse cu ajutorul casetelor text (Text Box) cu etichete pentru
fiecare dintre ele.
Rezultatele rulării programului se vor afişa în casete text separate pentru
valoare material fără TVA (Vmftva), valoare material cu TVA (Vmctva), valoare
factură fără TVA (Vfftva) şi valoare factură cu TVA (Vfctva).
Se vor prevedea butoane de comandă (Command Button) pentru calculul
şi afişarea unui material (fără TVA şi cu TVA) – butonul CALCULEAZA şi pentru
calculul valorii facturii (fără TVA şi cu TVA) – butonul AFISEAZA.
Pentru afişarea denumirilor pentru datele de intrare (Nrf, Df, Codmat,
Denmat, Cant şi Pu), a datelor intermediare (Vmftva şi Vmctva) şi a datelor de
ieşire sau rezultatelor (Vfftva şi Vfctva), se folosesc controale de tip etichetă
(Label). Aceste controale de tip etichetă se găsesc în caseta cu intrumente
(Toolbox) cu simbolul grafic. Controalele se introduc în formular prin tehnica
Drug and Drop şi se dimensionează cu ajutorul mânerelor de dimensionare
(Label1 … Label10). În mod similar se procedează cu casetele text (Text Box) cu
simbolul grafic casete care servesc, în cazul formulat în enunţul aplicaţiei
informatice (un singur material pe factură), pentru introducerea datelor de intrare
şi afişarea datelor intermediare şi de ieşire (Text1…Text2), precum şi cu butoanele
de comandă (Command Button) ce se vor folosi pentru declanşarea procedurilor
de calcul (Command1), de afişare a valorii facturii (Command2) şi de ieşire din
program (Command3).
83
Crearea formularului pentru aplicaţia informatică cu factura de materiale
9.2.3. Precizarea proprietăţilor
Precizarea proprietăţilor în etapa de proiectare (Design Mode) a

formularului sau a altui obiect vizual se realizează cu ajutorul ferestrei Properties.
Fereastra Properties este formată din caseta cu obiecte, Objects (afişează
numele şi tipul obiectului selectat, adică obiectul curent) şi caseta Settings –
setări (afişează alfabetic sau pe categorii lista proprietăţilor – stânga şi lista cu
valorile sau setările proprietăţilor – dreapta).
84
Fereastra Properties
Activarea ferestrei Properties se poate obţine prin succesiunea de comenzi
meniu principal – View – Properties Window sau cu ajutorul tastei funcţionale F4.
Precizarea proprietăţilor se obţine prin parcurgerea următoarele etape:
1) dacă nu este afişată, se activează fereastra Properties; se selectează
obiectul căruia urmează să i se precizeze proprietăţile; în acest moment, se
afişează automat proprietăţile cu valorile implicite pentru obiectul selectat;
2) din lista alfabetică sau lista pe categorii a proprietăţilor se selectează
denumirea proprietăţii la care se vor modifica valorile sau setările existente;
3) în coloana valorilor sau setărilor din dreapta se tastează sau se
selectează valorile dorite pentru proprietate.
Pentru a asocia o pictogramă unui formular se atribuie o valoare
proprietăţii icon pentru acel formular.
Pentru exemplificarea etapei de precizare a proprietăţilor,se continuă
aplicaţia cu factura materiale din paragraful 9.2.2, precizându-se proprietăţile de
bază – Name şi Caption pentru formular şi controalele introduse de tipul Label,
TextBox (numai Name) şi Command Button prin selectarea succesivă a acestora.
Personalizarea numelui pentru formular se obţine prin introducerea în
fereastra Properties a numelui (Name) frmMat şi a etichetei (Caption) FACTURA
MATERIALE.
Personalizarea numelui pentru controalele de tip etichetă (Label) se obţine
prin introducerea în fereastra Properties a numelui (Name) lblNrf şi a etichetei
(Caption) Numar factura, respectiv:
• lblDf (Name), Data factura (Caption);
85
• lblCodmat (Name), Cod material (Caption);
• lblDenmat (Name), Denumire material (Caption);
• lblCant (Name), Cantitate (Caption);
• lblPu (Name), Pret unitar (Caption);
• lblVmftva (Name), Valoare material fara TVA (Caption);
• lblVmctva (Name), Valoare material cu TVA (Caption);
• lblVfftva (Name), Valoare factura fara TVA (Caption);
• lblVfctva (Name), Valoare factura cu TVA (Caption).
Personalizarea numelui pentru controalele de tip caseta cu text (TextBoxl)
se obţine prin introducerea în fereastra Properties a:
• txtNrf (Name) pentru Numar factura;
• txtDf (Name) pentru Data factura;
• txtCodmat (Name) pentru Cod material;
• txtDenmat (Name) pentru Denumire material;
• txtCant (Name) pentru Cantitate;
• txtPu (Name) pentru Pret unitar;
• txtVmftva (Name) pentru Valoare material fara TVA;
• txtVmctva (Name) pentru Valoare material cu TVA;
• txtVfftva (Name) pentru Valoare factura fara TVA;
• txtVfctva (Name) pentru Valoare factura cu TV.
Personalizarea numelui pentru controalele de tip butoane de comandă
(Command Button) se obţine prin introducerea în fereastra Properties a:
• cmdCalcul (Name), CALCULEAZA (Caption);
• cmdAfisare (Name), AFISARE VALOARE FACTURA (Caption);
• cmdExit (Name), IESIRE (Caption).
Aspectul formularului obţinut prin precizarea proprietăţilor formularului şi
controalelor incluse este prezentat în figura de mai jos.
86
Introducerea proprietăţilor formularului şi controalelor incluse pentru
aplicaţia informatică cu factura de materiale
9.2.4. Scrierea codului
După proiectarea formularului şi precizarea proprietăţilor, urmează

scrierea codului care constă în asocierea unor secvenţe de cod pentru toate
controalele din formular, adică moduri de acţiune la diverse evenimente. Codul
conţine constante, declaraţii de variabile şi instrucţiuni scrise în limbajul de
programare Visual Basic, în conformitate cu algoritmul de calcul.
Legarea efectivă de control sau fereastră a secvenţelor de cod se obţine de
către utilizator (programator) în mod conversaţional.
Pentru scrierea codului se deschide fereastra de editare a codului (Code
Editor), prin dublu-click executat cu butonul stâng al mouse-ului poziţionat pe
obiectul selectat.
Fereastra de editare a codului (Code Editor) este formată din fereastra
principală ce reprezintă zona pentru scrierea codului şi două casete de tip listă din
care se selectează controlul pentru care se scrie codul (Object) şi, respectiv, din
care se alege evenimentul la care se reacţionează prin codul scris pentru procedură
în fereastra principală (Procedure).
Codul din proiectele realizate în VB se divide în blocuri de dimensiuni mai
mici numite proceduri. Codul care corespunde unui eveniment se numeşte
procedură eveniment.
87
Procedura-eveniment asociată unui control are numele alcătuit din numele
controlului (stabilit în proprietatea Name), o liniuţă de subliniere (_) şi numele
evenimentului.
Fereastra editare a codului, Code Editor
Atunci când se deschide fereastra de cod şi se selectează evenimentul

pentru care se scrie codul, se generează automat prima şi ultima linie a procedurii
(Private Sub Form_Load () şi End Sub) ce constituie un şablon de lucru.
Pentru crearea unei proceduri-eveniment se execută următoarea succesiune
de acţiuni: caseta Object → se specifică numele obiectului din formularul curent
(adică cel care este focalizat) pentru care se scrie codul → caseta cu listă
Procedure → selecţie nume eveniment asociat obiectului selectat (de exemplu,
procedura Click implicită pentru controlul buton de comandă, Command Button)
→ şablon pentru procedura-eveniment → între declaraţiile Private Sub şi End
Sub, se introduce de la tastatură codul în conformitate cu algoritmul de calcul.
Se poate opta pentru afişarea tuturor procedurilor în aceeaşi fereastră de
cod sau pentru afişarea unei singure proceduri la un moment dat.
Pentru afişarea tuturor procedurilor în cadrul aceleiaşi fereastre de cod, se
execută clic pe butonul de vizualizare a întregului modul, Full Module View, în
colţul din stânga-jos al ferestrei de editare a codului, Code Editor sau se execută
următoarea succesiune de acţiuni: meniul Tools → caseta de dialog Options →
secţiunea Editor (1) → grupul de setări pentru fereastră, Window Settings (2), bifă
în caseta de validare din stânga lui Default to Full Module View (3). În acelaşi
grup de setări pentru fereastră, caseta de validare din stânga lui Procedure
88
Separator (4) serveşte la adăugarea sau eliminarea unei linii de separaţie între
proceduri.
Fereastra de opţiuni, Options a meniului de instrumente, Tools
Pentru afişarea unei singure proceduri la un moment dat, se execută click

pe butonul de vizualizare a procedurii, Procedure View, în colţul din stânga-jos al
ferestrei de editare a codului, Code Editor sau se execută următoarea succesiune
de acţiuni: meniul Tools → caseta de dialog Options →secţiunea Editor (1) → în
grupul de setări pentru fereastră, Window Settings (2), se şterge bifa din caseta de
validare din stânga lui Default to Full Module View (3).
Pentru exemplificarea etapei de scriere a codului unei aplicaţii informatice
în Visual Basic, se continuă aplicaţia cu factura de materiale din paragrafele 9.2.2
şi 9.2.3. Codul aferent se introduce în fereastra de editare a codului (Code Editor).
9.2.5. Execuţia aplicaţiei informatice în Visual Basic
După parcurgerea etapelor de creare a interfeţei (proiectarea formularului),

de precizare a proprietăţilor şi de scriere a codului, toate fişierele aplicaţiei sunt
salvate şi se trece de la modul de proiectare (Design Mode) la modul de rulare
(execuţie) a proiectului (Run Mode).
Pentru a lansa în execuţie aplicaţia, se alege opţiunea Start din meniul Run
sau se acţionează tasta funcţională F5 sau se execută cu butonul stâng al mouse-
ului click pe butonul Start de pe bara cu instrumente.
89
Terminarea rulării proiectului se efectuează cu opţiunea End din meniul
Run sau prin apăsarea butonului de închidere (Close) a ferestrei aplicaţiei (colţul
din dreapta sus al ferestrei) sau prin apăsarea butonului End de la bara cu
instrumente.
După terminarea execuţiei aplicaţiei, mediul VB revine în modul de
proiectare (Design Mode).
Prin rularea proiectului, se obţine fişierul executabil. Aşa cum s-a arătat în
paragraful 9.2.1, fişierul executabil se poate obţine direct din meniul File cu
opţiunea Make …EXE.
Reluând aplicaţia cu factura de materiale din paragrafele 9.2.2, 9.2.3 şi
9.2.4, această aplicaţie se rulează cu seturile de date de intrare (se consideră
materiale consumabile pentru tehnica de calcul).
U9.3. Elementele limbajului de programare Visual Basic
9.3.1. Unele reguli de scriere
O proprietate esenţială a unui obiect în Visual Basic este numele (Name).

Numele este folosit pentru a referi un obiect particular în cadrul codului.
Numele obiectului trebuie să fie sugestiv şi să arate, în cazul controalelor, grupul
de controale căruia îi aparţine. Ca urmare, s-a adoptat convenţia conform căreia
un nume trebuie să fie format dintr-un prefix din trei litere (dat de notaţia ungară)
şi numele propriu-zis cu semnificaţie pentru utilizarea obiectului. Prefixul
numelui indică, în mod unic, grupul de controale din care face parte.
Numele obiectelor pot avea maxim 40 de caractere, trebuie să înceapă cu o
literă şi pot conţine numai litere, numere şi underscore ( _ ). În cadrul mai larg al
întregului limbaj Visual Basic, cu setul de caractere ASCII extins ce formează
alfabetul acestui limbaj, se construiesc literalii şi identificatorii. Literalii sunt
compuşi din şiruri de caractere. Literalii pot fi de tipul literali şiruri de caractere şi
sunt scrişi între ghilimele, şi de tipul literali numerici – zecimali (în baza 10),
octali (în baza 8), hexazecimali (în baza 16).
Identificatorii pot fi predefiniţi (cuvinte rezervate şi cuvinte-cheie ce
desemnează instrucţiuni, funcţii, operatori, metode) sau pot fi definiţi de utilizator
(ce desemnează obiecte, variabile, tipuri de date, constante, etichete, proceduri).
90
Instrucţiunile specifice limbajului Visual Basic se obţin prin combinarea
literalilor, identificatorilor şi cuvintelor rezervate. Pentru lizibilitatea codului,
fiecare instrucţiune se scrie pe o linie separată. Dacă o instrucţiune nu încape pe o
linie, se poate continua pe linia următoare prin caracterul underscore (_). Se pot
folosi 20 astfel de linii de continuare a unei instrucţiuni. Numele sunt folosite la
setarea proprietăţilor la momentul execuţiei şi în stabilirea numelor procedurilor
pentru evenimentele obiectelor. Setarea proprietăţilor la momentul execuţiei se
obţine prin scrierea unui cod. Formatul acestui cod se scrie prin notarea cu punct
şi este: Nume obiect. proprietate = noua valoare (Object Name. Property = New
value).
În Visual Basic, numele obiectelor sunt utilizate în setarea unui cadru de
lucru (framework) corespunzător procedurilor eveniment, pentru scrierea codului.
Formatul fiecărei subrutine (în Visual Basic nu există program principal; toate
procedurile obiectelor sunt subrutine) este: Private Sub Object Name_Event
(Optional Arguments) … End Sub.
Formularului i se ataşează un obiect. Visual Basic construieşte automat un
cadru de lucru (framework) pentru fiecare dintre procedurile eveniment.
Utilizatorul care construieşte aplicaţia trebuie să scrie codul procedurilor
eveniment la care corespunde aplicaţia.
9.3.2. Tipuri de date
Tipurile de date reprezintă natura datelor în cadrul unui limbaj de

programare. În limbajul Visual Basic, tipurile de date sunt predefinite (standard)
sau definite de utilizator.
Tipurile de date definte de utilizator se obţin prin combinarea mai multor
tipuri de date existente în structuri de date.
Declararea tipurilor de date definite de utilizator se efectuează în secţiunea
Declaration (din modulul standard) cu Type…End Type care are sintaxa generală:
[Private/Public] Type nume_tip_data_utilizator
Nume_1 As tip_data_1
Nume_2 As tip_data_2
91
…
Nume_n As tip_data_n
End Type
Tipurile de date definite de utilizator se declară la nivelul modulelor
standard, de clasă sau formular (numai Private). Aceste tipuri de date nu pot fi
declarate la nivelul unei proceduri.
De exemplu, tipul de date definite de utilizator Client are următoarea
structură:
Type Client
Nume_client As String *20
Prenume_client As String *20
Adresa_client As Adresa
CNP_client As String *13
End Type
unde tipul de date definit de utilizator Adresa are structura:
Type Adresa
Localitate As String *20
Strada As String *20
Numar As Integer
Judet As String *20
End Type
9.3.3. Variabile şi constante
Variabilele care se folosesc într-un program desemnează locaţii de

memorie în care se stochează valori ce se modifică pe timpul execuţiei
programului. O variabilă în limbajul Visual Basic are un nume (identificator)
format astfel:
 maxim 40 de caractere;
 numele include: litere, numere, underscore (–):
 primul caracter trebuie să fie o literă;
 nu se pot folosi ca nume de variabile, cuvintele rezervate, care fac parte
din setul de cuvinte cheie al limbajului.
92
Corespunzător variabilei care se doreşte a fi creată şi utilizată, utilizatorul
poate să stabilească tipul de dată asociat prin folosirea unui sufix de natura tip de
dată care va putea fi stocat sau prelucrat prin intermediul respectivei variabile.
Există trei moduri de declarare a unei variabile:
 Prin lipsă (din oficiu). Dacă variabila nu este definită în nici un mod, ea
este presupusă Variant, adică un tip de dată Visual Basic care poate conţine: valori
numerice, şiruri de caractere sau dată calendaristică.
 Implicit. Declararea implicită este dată prin folosirea sufixului
corespunzător. De exemplu, o variabilă de tip String (şir de caractere) poate fi
declarată implicit astfel:
Material$ = ”Cherestea”
iar o variabilă de tip Integer se poate declara implicit astfel:
Cantitatea% = 273
 Explicit. Acest mod de declarare a unei variabile prezintă mai multe
avantaje: asigură efectuarea unui calcul corect prin intermediul instrucţiunilor care
utilizează variabilele respective şi permite identificarea, gestionarea corectă a
apariţiei literelor mari sau a literelor mici în numele variabilelor. Datorită acestor
avantaje, se preferă lucrul cu tipurile de variabile explicite.
Pentru a putea lucra cu variabile declarate explicit trebuie să fie cunoscut
domeniul de valabilitate şi anume:
1) domeniul procedurilor;
2) domeniul procedurilor în care variabilele se declară static;
3) domeniul formularelor şi modulelor;
4) domeniul nivelului global.
De exemplu, pentru domeniul procedurilor, variabilele sunt declarate
folosind cuvântul cheie Dim:
Dim Denumire_material As String
Dim Cantitate As Integer
Dim Pret_unitar As Single.
Variabilele declarate la nivelul procedurilor îşi vor păstra valorile numai pe
timpul rulării procedurilor respective. Din acest motiv se mai numesc şi variabile
locale.
Pentru ca variabilele să-şi păstreze valorile şi după terminarea procedurii,
se foloseşte domeniul procedurilor în care variabilele se declară static, cuvântul-
cheie Dim fiind înlocuit cu Static.
93
De exemplu:
Static Denumire_material As String.
Static Cantitate As Integer.
Static Pret_unitar As Single.
Pentru domeniul domeniul formularelor şi modulelor, variabilele îşi
menţin valorile la nivelul formularului (modulului), relativ la toate procedurile
prin declararea variabilelor cu Dim, dar în partea de declaraţii a obiectului general,
în fereastra de cod a formularului.
Pentru domeniul domeniul nivelului global, o variabilă este disponibilă
tuturor procedurilor prezentate în aplicaţie, prin declararea în partea de declaraţii a
obiectului general din fereastra de cod a unui modul cu ajutorul cuvântului cheie
Global. De exemplu:
Global Nr_factura As Long
Global Data_factura As Date.
În cazul mai multor variabile cu acelaşi nume, variabilele locale au
valabilitate numai în cadrul procedurilor. La părăsirea acestor proceduri se
folosesc variabilele cu acelaşi nume, dar definite la nivel superior.
Procedura de introducere a acestor variabile globale este următoarea:
 se execută dublu-click oriunde în fereastra formularului pentru a
deschide fereastra de editare a codului (sau se selectează opţiunea View Code din
fereastra Project);
 se declară variabilele din formular astfel:
Option Explicit (forţează declararea variabilelor)
Global Nr_factura As Long
Global Data_factura As Date.
9.3.4. Constante simbolice utilizate în Visual Basic
În cele mai multe situaţii, funcţiile şi obiectele limbajului Visual Basic

necesită argumente pentru efectuarea operaţiilor specifice, argumente care
reprezintă constante numerice. Acestea sunt greu de interpretat din punct de
vedere al utilizatorului. Pentru a le face inteligibile, limbajul Visual Basic asigură
nume celor mai utilizate valori şi acestea se numesc constante simbolice.
De exemplu, pentru setarea fondului formularului frmMat pe culoarea
albastră se poate scrie:
94
frmMat. Back Color = 0XFF0000 sau, folosind constanta simbolică pentru
albastru:
frmMat. Back Color = VBBlue
Utilizatorul îşi poate defini propriile constante ca de exemplu: const TVA
= 0.24.
Constantele de utilizator se scriu cu litere mari, pentru a le distinge de
variabile. Domeniul de valabilitate al unei constante este similar cu cel al
variabilelor.
1. Ce este fişierul proiect? (1,5 pct.)

2. Cum se creează o interfaţă a aplicaţiei? (1,5 pct.)
Punctaj 4,5p 3. Enumeraţi elementele limbajului de programare VB (1,5 pct.)
U9.5. Rezumat
În cele mai multe situaţii, funcţiile şi obiectele limbajului Visual Basic

necesită argumente pentru efectuarea operaţiilor specifice, argumente care
reprezintă constante numerice. Acestea sunt greu de interpretat din punct de
vedere al utilizatorului. Pentru a le face inteligibile, limbajul Visual Basic asigură
nume celor mai utilizate valori şi acestea se numesc constante simbolice.
95
96
MODULUL 4
UNITATEA 10: FOXPRO – I
UNITATEA 11: FOXPRO – II
UNITATEA 10
FOXPRO
Cuprins: pag.
U10.1. Scopul şi obiectivele unităţii ........................................................... 97
U10.2. Prezentare generală FOXPRO ...................................................... 98
U10.3. Intrarea şi ieşirea din FoxProW. Mediul FoxProW. Elemente
de interfaţă ...................................................................................... 103
U10.4. Tipul logic ........................................................................................ 104
97
U10.5. Tipul numeric .................................................................................. 105
U10.6. Tipul şir de caractere ..................................................................... 109
U10.7. Tipul memo ..................................................................................... 112
U10.8. Tipul dată calendaristică ................................................................ 112
U10.9. Baze de date ..................................................................................... 116
U10.10. Câmpurile memo .......................................................................... 121
U10.11. Meniuri .......................................................................................... 122
U10.12. Programe. Execuţia programelor ............................................... 138
U10.13. Programarea structurată ............................................................. 149
U10.14. Lucrul cu fişiere ............................................................................ 154
U10.15. Test de autoevaluare ..................................................................... 157
U10.16. Rezumat ......................................................................................... 157

 FoxPro – prezentare generală;
 mediul FoxPro;
 elemente de interfaţă ale FoxPro;
 Tipuri;
 baze de date FoxPro;
 câmpurile memo şi meniuri;
 execuţia programelor;
 programarea structurată;
 lucrul cu fişiere.
U10.2. Prezentare generală FOXPRO
Fereastra COMMAND - orice comandă scrisă în această fereastră se

execută imediat.
Meniul bară FILE
Opţiunea NEW - permite crearea unei noi baze de date, program, fişier,
raport, etichetă, ecran, meniu, querry, proiect.
Opţiunea OPEN - deschide o fereastră de navigare, de unde ne putem
alege aplicaţia, baza, etc., pe care dorim să le deschidem.
98
Opţiunea CLOSE - închide aplicaţia la care lucrăm fără a ieşi din mediul
Fox.
Opţiunea SAVE şi SAVE AS - execută salvarea bazei, a aplicaţiei, etc.
Opţiunea PRINTER SETUP - permite setarea imprimantei.
Opţiunea PRINT - tipărirea unui document.
Opţiunea QUIT - părăsirea mediului Fox.
Crearea unei baze de date
Forma generală a comenzii:
CREATE [<fişier>]
Dacă pentru acest fişier nu se specifică nici o extensie, atunci Fox-ul
asociază implicit: .dbf.
Va apare pe ecran o fereastră în care va fi creată structura bazei de date.
Avem opţiunile:
name - pentru numele unui câmp.
type - tipul câmpului (ce fel de date se memorează în acesta).
width - numărul de octeţi asociat câmpului.
dec - numărul de zecimale (pentru câmpuri numerice).
INSERT si DELETE se folosesc pentru inserarea sau ştergerea unui câmp
în şi respectiv din structura creată.
Comanda LIST este utilizată pentru listarea conţinutului unei baze de date.
Meniul EDIT
- conţine câteva comenzi obişnuite în lucrul cu fişierele.
Opţiunea CUT - duce textul selectat într-o zonă specială de memorie
numită clipboard.
Opţiunea COPY - face o copie după textul selectat în zona de clipboard.
Opţiune PASTE - se foloseşte pentru a aduce din zona clipboard porţiunea
ce a fost copiată.
Obs. Opţiunea PASTE se foloseşte după opţiunea COPY.
Opţiunea CLEAR - şterge textul selectat.
Opţiunea SELECT ALL - selectează întreaga fereastră activă.
Opţiunea GOTO LINE - se foloseşte pentru a ne poziţiona pe o anumită
linie din fereastra activă.
Opţiunea FIND - se foloseşte pentru a căuta o anumită informaţie (de tip
numeric, sir de caractere, etc.).
99
Opţiunea FIND AGAIN - găseşte următoarea informaţie, ce se aseamănă
cu cea căutată de utilizator.
Opţiunea REPLACE AND FIND AGAIN - se foloseşte atunci când dorim
înlocuirea unei anumite informaţii cu o alta, aleasă de noi.
Opţiunea REPLACE ALL - se foloseşte atunci când dorim înlocuirea unei
anumite informaţii din textul nostru, ori de câte ori apare, cu o altă informaţie
aleasă de noi.
Meniul WINDOW
Acest meniu permite manipularea ferestrelor active de pe ecran.
Toate ferestrele ce se folosesc în FoxPro, au câteva elemente comune. Vom
exemplifica aceste elemente folosindu-ne de cea mai importantă fereastră din
FoxPro şi anume fereastra de comenzi:
Opţiunea HIDE - ascunde sau închide fereastra activă. Reapariţia ferestrei
de comenzi pe ecran se face folosind opţiunea COMMAND din acest meniu, sau
combinaţia de taste CTRL+F2.
Opţiunea CLEAR - se foloseşte pentru a şterge de pe ecran toate
informaţiile afişate la un moment dat.
Obs.: Acelaşi lucru se poate face dacă se scrie în fereastra de comenzi -
comanda CLEAR.
Opţiunile MOVE, SIZE, ZOOM , ZOOM se folosesc pentru mutarea
ferestrei active dintr-o zonă în alta a ecranului (MOVE); pentru redimensionarea
ferestrei (SIZE); pentru mărirea pe tot ecranul (ZOOM ) sau pentru micşorarea
ferestrei la nivel de bară de stare (ZOOM ).
Comenzi pentru descrierea structurii unei baze de date
Comanda CREATE (prezentată anterior).
Comanda MODIFY STRUCTURE - realizează modificarea structurii unei
baze de date existente. Baza de date, înainte de modificarea structurii, trebuie
activată. Forma comenzii este:
MODIFY STRUCTURE <Enter>
Efectul acestei comenzi este apariţia pe ecran a unei ferestre asemănătoare
ca structură, cu cea de la comanda CREATE, în care se afişează date despre
structura bazei de date respective şi anume:
- numele câmpurilor bazei de date (NAME)
- tipul de informaţie din câmpul respectiv (TYPE)
- dimensiunea câmpului (WIDTH)
100
- partea fracţională a dimensiunii (DEC)
Modificările câmpurilor deja existente în baza de date se pot face prin trei
operaţii:
- inserare;
- ştergere;
- adăugare.
Pentru inserare, se plasează cursorul pe câmpul următor şi se acţionează
tastele INSERT din submeniul FIELD.
Pentru ştergere, se plasează cursorul pe câmpul respectiv şi se acţionează
tasta DELETE din acelaşi submeniu.
Pentru adăugare, se plasează cursorul după ultimul câmp.
După ce am efectuat toate modificările în structura bazei de date
respective, apăsăm butonul OK şi programul ne va întreba dacă dorim să păstrăm
aceste modificări sau nu.
Comanda DISPLAY STRUCTURE - afişează structura bazei de date
active. Forma comenzii este:
DISPLAY STRUCTURE <Enter>
În plus mai furnizează: numele bazei de date, numărul înregistrărilor, data
ultimei actualizări.
Comanda LIST STRUCTURE - are acelaşi efect ca şi comanda anterioară,
cu deosebirea că afişează toată structura bazei de date, chiar dacă numărul de
câmpuri este mai mare de 16.
Comenzi de utilizare a bazei de date şi de introducere de date (informaţii)
într-o bază de date.
Comanda USE - deschide o bază de date în vederea utilizării sale. Forma
comenzii este: USE <nume bază de date>
Efectul acestei comenzi nu este de ordin vizual adică, pe ecran nu va
apărea nici o informaţie sau fereastră nouă, faţă de cele existente anterior execuţiei
acestei comenzi. Dar această bază de date devine activă şi astfel utilizatorul o
poate folosi pentru prelucrările dorite.
Comanda de închidere a unei baze de date este: USE <Enter>
Comanda LIST - afişează pe ecran toate înregistrările din baza de date
activă.
101
Comanda BROWSE - este una din cele mai folosite comenzi FoxPro şi se
utilizează la introducerea de noi informaţii în baza de date activă şi la modificarea
informaţiilor existente. Forma comenzii este: BROWSE [<clauze>]
<clauzele> sunt opţionale şi se folosesc numai de utilizatorii avansaţi.
Obs.: Comanda BROWSE mai poate fi activată şi din meniul
DATABASE.
Efectul acestei comenzi este apariţia pe ecran a unei ferestre cu numele
bazei de date active, fereastră în care se pot face modificări asupra înregistrărilor
existente şi în plus se pot adăuga noi înregistrări folosind combinaţia de taste
CTRL+N.
Comanda APPEND - este asemănătoare cu BROWSE, doar că utilizează
modul de lucru ecran pentru introducerea datelor.
Forma comenzii este: APPEND <Enter>
Obs.: Comanda APPEND poate fi activată şi din meniul RECORD.
Adăugarea unei înregistrări noi se poate face utilizând combinaţia de taste
CTRL+Y.
Se recomandă folosirea comenzii BROWSE atunci când dorim
modificarea înregistrărilor dintr-o bază de date dată, deoarece fereastra BROWSE
oferă accesul mai rapid la orice câmp şi orice înregistrare din baza de date
respectivă.
Crearea structurii unei baze de date CREATE
O dată creată structura bazei de date, ea nu se mai creează niciodată; se
poate doar modifica cu MODIFY STRUCTURE - prin crearea bazei de date se
distruge conţinutul ei de până atunci.
Comanda SET STATUS ON face să apară linia stare în care avem:
- numele bazei curente
- poziţia cursorului
- starea tastelor INSERT , NUMCAPS.
Pentru a lucra cu o bază de date, ea trebuie mai întâi deschisă.
Comanda:
USE <nume>
Comenzi care afişează înregistrări.
DISPLAY - afişează înregistrări din baza de date (se opreşte după
umplerea unui ecran)
LIST - afişează înregistrări din baza de date
102
DISPLAY [FIELDS] listă câmpuri [scope] FOR [expL1] WHILE [expL2]
OFF.
Sistemele software prin intermediul cărora se creează, se actualizează şi se
consultă bazele de date se numeşte Sistem de Gestiune a Bazelor de Date
(S.G.B.D.-uri). Fox Pro este un astfel de sistem. Pentru manipularea unei baze de
date Fox Pro foloseşte o zonă de memorie în care memorează unele informaţii
referitoare la starea bazei de date numită zonă de lucru. Acest SGBD poate lucra
simultan cu mai multe baze de date, deci va avea mai multe zone de lucru (25 la
număr).
Modul de lucru cu o bază de date este următorul:
- se deschide baza de date ( acesteia i se atribuie o zonă de lucru)
- se execută operaţiile dorite asupra bazei de date respective (adăugări,
ştergeri etc)
- la terminarea lucrului cu baza de date aceasta se închide.
Aliasul unei baze de date este numele atribuit acesteia pentru a fi
identificată.. Aliasul poate fi furnizat de utilizator sau poate fi atribuit automat de
către Fox Pro.
Un concept mai nou în domeniul bazelor de date este relaţia. O bază de
date relaţională nu mai este văzută ca un simplu tabel, ci ca o mulţime de tabele,
aflate în relaţie unul cu altul. Se stabileşte o relaţie de subordonare între cele două
sau mai multe tabele, primul numit părinte iar cel de-al doilea copil.
U10.3. Intrarea şi ieşirea din FoxProW. Mediul FoxProW.

Elemente de interfaţă
Pentru a porni FoxPro-ul sub Windows este necesar ca anterior se fi fost

instalat atât sistemul Windows cât şi FoxProW-ul sub acest sistem. Presupunând
că aceste operaţi s-au executat, pornirea FoxProW-ul se realizează prin
următoarele etape:
- se porneşte Windows-ul prin introducerea la prompt-ul sistemului do
operare a comenzii: C: \>win
103
- dată pornită această platformă grafică, urmează deschiderea ferestrei
grupului care conţine icoana corespunzătoare FoxPro-ului sub Windows (grup
implicit numit FoxPro for Windows), printr-un clic dublu pe icoana acestui grup;
- din fereastra deschise se alege icoana corespunzătoare FoxProW-ului,
implicit numite Microsoft FoxPro, printr-un clic dublu pe aceasta; sistemul
FoxProW este acum pornit.
Iniţial, fereastra asociată FoxPro-ului arată ca în figura de mai jos:
La partea superioară a acesteia, imediat sub titlu, se aflã meniul sistem al

FoxProW-ului, prin care utilizatorul poate introduce comenzile sale în mod
interactiv. Comenzile pentru lucrul cu acest meniu pot fi de două feluri: fie cele
specifice platformei grafice Windows, fie cele specifice variantei sub DOS a
FoxPro-ului. La instalare, utilizatorul este întrebat asupra setului de taste şi
combinaţii de taste folosit pentru comunicarea cu FoxProW-ul.
Un alt element al mediului FoxProW este fereastra de comenzi (aflatã în
colţul din dreapta-jos în figura de mai sus). Aceasta permite utilizatorului să
introduce comenzi FoxProW în vederea execuţiei imediate. Alături de meniul
sistem, fereastra de comenzi pune la dispoziţia utilizatorului un alt mod de a
transmite comenzile sale FoxProW-ului. Fereastra de comenzi poate fi manipulată
ca orice alte fereastrã Windows.
Ecranul FoxProW, care este de fapt zona utilizator a ferestrei Microsoft
FoxPro, reprezintă zona de afişare a informaţiilor de către sistemul FoxProW, ca
rezultat al comenzilor transmise de utilizator. Spre deosebire de varianta sub DOS,
care folosea ca ecran de lucru tot ecranul fizic al monitorului, FoxProW foloseşte
doar interiorul ferestrei Microsoft FoxPro ca ecran de lucru, dimensiunile lui
depinzând de dimensiunile acestei ferestre. Iniţial, pe ecran este afişată sigla
FoxPro-ului sub Windows (vulpea).
Pentru a putea vedea întregul conţinut al ecranului FoxProW, inclusiv
porţiunea de sub fereastra de comenzi, se poate ascunde această fereastră, se poate
104
transforma într-o icoană sau se poate închide, reafişarea sa realizându-se prin
alegerea opţiunii Command de pe submeniul Window.
Alături de aceste trei elemente ale interfeţei FoxProW-ului, care sunt
vizibile pe ecran imediat după pornirea acestui S.G.B.D., comunicarea dintre
utilizator şi sistem mai implică şi alte elemente cum ar fi ferestrele sistem şi
obiectele de control.
Ferestrele sistem sunt deschise de FoxProW ca urmare a unor comenzi ale
utilizatorului, în vederea realizării comunicării dintre cei doi, utilizator şi
S.G.B.D.. ferestrele sistem pot conţine mesaje, obiecte de control şi chiar meniuri
asociate şi sunt manipulate ca oricare altă fereastră Windows
În limbajul FoxPro vom avea următoarele tipuri de date :
- tipul logic
- tipul numeric
- tipul şir de caractere
- tipul dată calendaristică
- tipul memo
U10.4. Tipul logic
Acest tip este caracteristic datelor ce nu pot lua decât două valori, adevărat
(true) sau fals (false). Pentru a specifica valoarea adevărat a unei expresii de tip
logic se foloseşte construcţia T (de la True), iar pentru valoarea fals se foloseşte F
(de la False).
Operatorii logici în ordinea priorităţii de evaluare sunt sintetizaţi în tabelul
următor:
Operator Semnificaţie
() grupează expresii logice
!,NOT negaţie logică
AND şi logic
OR sau logic
De asemenea rezultatul unei expresii care conţine operatori relaţionali
(<,>,=) este tot de tip logic.
U10.5. Tipul numeric
105
O mare parte a datelor prelucrate de calculator o reprezintă numerele,
pentru a căror descriere se foloseşte tipul numeric. Cu toate că limbajul FoxPro
este orientat pe lucrul cu baze de date şi nu unul orientat pe calcule matematice,
ştiinţifice (cum este Fortran-ul, Pascal-ul etc.) tipul numeric este implementat
astfel încât să realizeze majoritatea operaţiilor matematice întâlnite în practică.
Operatorii care se aplică unor operanzi numerici sunt sintetizaţi în tabelul
următor în ordinea priorităţii de evaluare:
Operator Semnificaţie
() paranteze ptr. gruparea expresiilor
**,^ ridicare la putere
*,/,% înmulţire ,împărţire, modulo (restul împărţirii)
+,- adunarea şi scăderea
Între două expresii numerice se pot aplica operatori relaţionali, obţinându-
se astfel expresii logice. Aceşti operatori sunt prezentaţi în tabelul următor:
<operator> relaţie
< mai mic decât
> mai mare decât
= egal cu
<>,#,!= diferit de
<= mai mic sau egal cu
>= mai mare sau egal cu
Afişarea numerelor este controlată de comanda SET DECIMALS care are
sintaxa: SET DECIMALS TO [<expN]
Această comandă determină numărul minim de cifre zecimale ce sunt
afişate dacă nu se specifică un format explicit de afişare. Implicit acest număr este
de 2 zecimale.
Ex. ?2?3
0.67
SET DECIMALS TO 4
?2/3
0.6667
Funcţii referitoare la semnul datelor numerice
Pentru aflarea valorii absolut a unui număr se foloseşte funcţia ABS() cu
sintaxa ABS(<expN>)
Ex. ?ABS(-400)
400
Funcţia SIGN() este folosită pentru a afla semnul numărului transmis ca
argument astfel: SIGN(<expN>) returnează:
+1 dacă <expN> este pozitivă
106
1 nulă
-1 negativă
Ex. ?SIGN(-33)
-1
Funcţii de aproximare a datelor numerice
Partea întreagă a unei expresii numerice este returnată de funcţia INT() cu
sintaxa:
INT(<expN>)
Ex. ?int(14.34)
14
?INT(-2.42)
-2
Partea fracţionară a unui număr se obţine folosind tot funcţia INT(), astfel:
a = 14.34
?a-INT(a)
0.34
Alte moduri de a obţine o aproximaţie întreagă a unui număr sunt date de
funcţiile CEILING() şi FLOOR() cu sintaxele:
CEILING(<expN>)
FLOOR(<expN>)
Funcţia CEILING() returnează cel mai apropiat întreg mai mare sau egal
cu <expN>, iar FLOOR() se foloseşte pentru a afla cel mai apropiat întreg mai
mic sau egal cu <expN>
Ex. ?CEILING(8.32)
9
?ceiling(-4.23)
-4
?FLOOR(8.32)
8
?FLOOR(-4.32)
-5
Funcţia ROUND() realizează de asemenea o aproximare. a unui număr dar
nu neapărat la un întreg, ci la un număr real cu un număr dat de zecimale
Sintaxa comenzii: ROUND (<expN1>,<expN2>)
107
unde: <expN1> reprezintă expresia de rotunjit iar <expN2> este numărul
de zecimale ce se vor păstra în valoarea returnată de funcţie. Numărul de zecimale
exprimat prin SET DECI va fi ignorat.
Funcţii matematice elementare
Din categoria acestor funcţii fac parte exponenţiala(e x), logaritmul natural
(ln x), logaritmul zecimal (log x), radicalul ( )
Aceste funcţii au formatul general:
EXP(<expN>)
LOG(<expN>)
LOG 10(<expN>)
SQRT(<expN>)
Funcţii trigonometrice
Conversia din grade în radiani este implementată prin funcţia DTOR() iar
conversia inversă prin RTOD(). Aceste două funcţii au sintaxele :
DTOR(<expN>)
RTOD(<expN>)
Pentru funcţia DTOR() (<expN>) reprezintă unghiul exprimat în grade a
cărui conversie o dorim iar pentru. RTOD() reprezintă unghiul exprimat în radiani
ce se va transforma în grade.
Ex. ?DTOR(90) =PI()/2
.T.
?RTOD(PI()/4)
45.00
Funcţiile trigonometrice sinus, cosinus, tangentă au următoarele sintaxe :
SIN(<expN>)
COS(<expN>)
TAN(<expN>)
unde < expN> este argumentul funcţiei reprezentând unghiul a cărei funcţie se
calculează, exprimat în radiani. Rezultatele sunt de tip numeric.
Ex.? SIN(PI()/2)
1.00
? COS(PI())
-1
Funcţiile trigonometrice inverse ASIN() ;ACOS();ATAN() cu sintaxele:
ASIN(<expN>),ACOS(<expN>),ATAN(<expN>)
108
expN - numărul a cărui funcţie se calculează
Funcţii referitoare la calcule financiare
În această categorie intră trei funcţii şi anume: PAYMENT(),PV(),FV()
şi au sintaxele:
PAYMENT(<EXPn1,EXPn2,EXPn3>)
PV(<EXPn1,EXPn2,EXPn3>)
FV(<EXPn1,EXPn2,EXPn3>)
unde cele trei expresii numerice au semnificaţii diferite pentru fiecare funcţie în
parte.
Pentru o mai bună înţelegere vom explicita cele trei funcţii prin exemple.
Să presupunem că avem de returnat un împrumut de 500.000 u.m., suma
pe care o avem depusă într-o bancă ce practică o dobândă de 1% lunar adică la
sfârşitul fiecărei luni la suma de bani pe care o avem momentan în bancă se
adaugă 1% din această sumă ca dobândă. Să presupunem că împrumutul trebuie
returnat în rate lunare în 24 luni. Ne interesează ce sumă trebuie să achităm lunar
pentru a returna împrumutul în perioada precizată. Această problemă se rezolvă cu
funcţia PAYMENT() având următoarele corespondenţe:
<expN1> reprezintă valoarea împrumutului (500.000)
<expN2> rata dobânzii (0.01)
<expN3> număr de rate pentru achitarea împrumutului (24)
Valoarea returnată de funcţie reprezintă valoarea ce trebuie achitată lunar
pentru a acoperi împrumutul.
N1=500.000
N2=0.01
N3=24
?PAYM(N1,N2,N3)
23536.74
Folosirea funcţiei FV() în calcule financiare. Presupunem că am deschis un
cont la o bancă ce practică o dobândă de 1% lunar , iniţial contul este gol , dar ne
propunem să depunem lunar o sumă de 3.000 u.m. . Ne interesează ce sumă vom
avea în cont după 36 luni de la deschiderea contului . Valoarea aceasta este
returnată de funcţia FV() folosind ca parametrii:
<expN1> suma ce se va depune lunar în cont
<expN2> rata dobânzii practicate de bancă
109
<expN3> număr de depuneri după care se calculează suma din cont(egal
cu număr de luni în cazul când se face o singură depunere pe lună)
Ex. N1=3000
N2=0.01
N3=36
? FV (N1,N2,N3)
Presupunem că avem un cont la o bancă ce practică o rată a dobânzii de
1% lunar. Propunându-se ca în curs de 48 luni plătind lunar din cont câte 4.000
u.m. ne interesează ce sumă am putea acoperi din acest cont presupunând că după
achitarea sumei contul este gol. Această valoare este returnată de funcţia PV() care
necesită parametrii:
<expN1> suma ce se scoate lunar din cont
<expN2> rata dobânzii practicate de bancă
<expN3> nr. de luni în care se scot banii din bancă
Ex. N1=4.000
N2=0.01
N3=48
? PV(N1,N2,N3)
151895.84
U10.6. Tipul şir de caractere
Un şir de caractere reprezintă o mulţime ordonată de caractere care se

tratează ca un tot unitar. Într-un şir de caractere ,ordinea acestora fiind esenţială ,
fiecăruia i se va putea asocia un număr reprezentând poziţia caracterului în cadrul
şirului (primul caracter va avea poz.1 al doilea poz.2 ş.a.m.d.
Numărul caracterelor dintr-un şir reprezintă lungimea şirului. Un subşir al
şirului dat reprezintă o porţiune din şir începând de la o poziţie specificată şi de
lungime dată.
Constantele de tip şir de caractere specifică prin mulţimea caracterelor care
îl compun încadrată de apostrofuri simple sau duble (la ambele capete având
acelaşi tip de apostrof). Dacă lungimea şirului de caractere este 1 acesta se
reduce la un caracter ex. “A”,”1”,
110
‘ ‘. Dacă lungimea şirului este 0 obţinem şirul nul sau vid, care se specifică
prin două apostrofuri consecutive fără spaţii sau alte caractere între ele, adică ““
sau ‘’
Funcţii referitoare la subşirurile de caractere
Extragerea unui subşir dintr-un şir de caractere se realizează cu funcţia
SUBSTR() care are următoarea sintaxă:
SUBSTR (<expC,expN1[,<expN2>])
unde <expC> reprezintă expresia din care se extrage subşirul. Specificarea
subşirului se face prin intermediul celor două expresii numerice transmise ca
parametrii funcţiei.
<expN1> precizează poziţia de unde începe subşirul de extras (se extrage
inclusiv caracterul de pe această poziţie)
<expN2> reprezintă nr. de caractere ce se extrag, adică lungimea
subşirului. Dacă <expN2> lipseşte subşirul se întinde până la sfârşitul şirului de
bază.
În anumite situaţii se pot folosi alte două variante ale acestei funcţii,
acestea sunt LEFT() şi RIGHT() care returnează un subşir al unui şir poziţionat la
stânga, respectiv la dreapta.
Sintaxele celor două funcţii sunt:
LEFT(<expC>,<expN>)
RIGHT(<expC>,<expN>)
unde <expC> reprezintă şirul de caractere din care se extrage subşirul, iar <expN>
reprezintă lungimea subşirului extras.
Ambele funcţii au ca rezultat un şir de caractere.
Ex. ?LEFT(‘LA MULTI ANI!’, 2)
LA
? RIGHT(‘POFTĂ BUNĂ !’,6)
BUNĂ !
Funcţia REPLICATE() cu sintaxa: REPLICATE (<expC>,<expN>),
returnează un şir de caractere obţinut prin repetarea şirului <expC> de <expN>
ori.
Ex. ?REPLICATE (‘a’,5)
aaaaa
Funcţiile PADC() , PADL() , PADR() cu sintaxa de forma:
PADC (<expr>,,expN>[,<expC>])
111
PADL (<expr>,,expN>[,<expC>])
PADR (<expr>,,expN>[,<expC>])
Aceste funcţii adaugă la expresia <expr> şirul de caractere <expC>, la
dreapta pentru PADR(), la stânga pentru PADL() şi la ambele capete pentru
PADC() până se obţine o lungime a şirului de <expN> caractere.
Se observă că <expr> poate fi de tip şir de caractere, de tip numeric sau de
tip dată calendaristică, în cazul ultimelor două realizându-se mai întâi conversia la
tipul şir de caractere.
Ex.?PADL (‘Pagina1’,40.’-‘)
Funcţii privind transformări ale şirurilor de caractere
Diferenţierea dintre caracterele alfabetice mici şi mari a dus la necesitatea
transformării caracterelor mici în majuscule şi invers. Aceste operaţii sunt
realizate de funcţiile LOWER(), UPPER(() şi PROPER(), care au ca efect
prelucrarea unui şir de caractere primit ca parametru, astfel:
LOWER() transformă toate majusculele în litere mici, restul caracterelor
rămânând neschimbate.
UPPER() transformă toate caracterele mici în majuscule corespunzătoare ,
restul caracterelor din şir rămânând neschimbate.
PROPER() transformă primul caracter dintr-un cuvânt în majusculă (dacă
este alfabetic), iar următoarele în litere mici. Sintaxele celor trei funcţii sunt:
LOWER(<expC>)
UPPER(<expC>)
PROPER(<expC>)
Ex.
a=’ALFA’
b=’alfa’
?UPPER(a)==UPPER(b)
.T
U10.7. Tipul memo
Acest tip de date reprezintă o facilitate puternică a FoxPro dând

programatorului posibilitatea controlului, la nivel inferior, a diverselor date
(drivere de imprimantă, de ecran, diverse texte cu lungime variabilă etc.).
Tipul memo este asemănător tipului şir de caractere.
112
U10.8. Tipul dată calendaristică
Expresiile de tip dată calendaristică pot conţine:

- câmpuri de acest tip ale unei baze de date
- funcţii ce returnează valori de tip dată calendaristică
- variabile de tip dată calendaristică
- constante de tip dată calendaristică
O constantă de tip dată calendaristică se specifică prin luna, ziua şi anul
corespunzător, separate prin caracterul ”/”şi încadrate între caracterul acolade.
Ordinea de specificare a zilei, lunii şi anului, modul de scriere a anului (cu
două sau patru cifre) cât şi separatorul dintre cele trei componente ale datei sunt
controlate de comenzi ce urmează să fie prezentate mai jos.
Implicit anul se specifică prin două cifre, ordinea implicită este lună/zi/an,
iar separatorul implicit este /, adică format american.
Ex. STORE {11/24/91} TO data c
?data c
11/24/91- răspuns pe ecran
Data calendaristică vidă se specifică prin blancuri în poziţia zilei, lunii şi
anului sau printr-un blanc încadrat între paranteze acolade.
Ex. data_v ={ / / }
data_v={ }
Observaţie: FoxPro tratează datele invalide (care nu există) ca date
calendaristice vide.
Ex. ? {02/330/92} ={ }
.T.
Constantele de acest tip sunt reprezentate în calculator prin numere
reprezentând zile, deci se poate scădea sau aduna o valoare numerică la o dată
fixată.
Ex. ? {02/29/92} +1
03/01/92
Observăm că adunarea unei zile la o dată calendaristică nu are ca efect
creşterea cu 1 (unu ) a numărului de zile ci avansarea datei cu o zi în ordine
calendaristică.
113
Operatorii raţionali se pot aplica şi asupra datelor calendaristice. O dată
calendaristică este mai mare decât o alta atunci când prima dintre acestea urmează
calendaristic celei de-a doua.
Formatul de specificare a datelor calendaristice este controlat de comanda
SET DATE care are următoarea sintaxă:
SET DATE TO |AMERICAN | BRITISH | FRENCH | GERMAN | ...
Următoarea tabelă sintetizează acţiunea comenzii SET DATE
Tipul datei FORMATUL
American LL/ZZ/AA
British ZZ/LL/AA
German ZZ.LL.AA
Italian ZZ-LL-AA
Japan AA/LL/ZZ
Formatul implicit pentru data calendaristică este cel AMERICAN.

În specificarea anului se pot folosi două cifre, sau prin 4 cifre cînd anul
este specificat complet. Alegerea între aceste două variante se face cu comanda
SET CENTURY care are sintaxa:
SET CENTURY ON | OFF
unde cazul ON indică 4 cifre pentru an iar OFF stabileşte formatul de 2 cifre
pentru an.
De asemenea delimitatorii care separă ziua, luna şi anul din expresia unei
constante de tip dată calendaristică se pot modifica prin comanda SET MARK TO
cu sintaxa:
SET MARK TO [<expC>]
Expresia <expC> trebuie să reprezinte un singur caracter care va deveni
delimitatorul în reprezentarea externă a datelor calendaristice. Separatorul implicit
folosit pînă la execuţia unei comenzi SET MARK TO este caracterul “/” .
Data curentă a sistemului se obţine folosind funcţia DATE() care are
sintaxa :ss
DATE ()
Rezultatul funcţiei este de tip dată calendaristică.
Ex. ?DATE ( )
11/03/99
SET CENTURY ON
SET MARK TO ‘.’
? DATE ( )
114
11.03.1999
Având o expresie de tip dată calendaristică putem afla în ce zi din cadrul
cade această dată. Acest lucru se realizează cu funcţiile DOW ( ) şi CDOW ( )
care au sintaxele: DOW(<expD>) CDOW (<expD>)
Ambele funcţii primesc ca parametru expresia de tip dată calendaristică
returnând ziua din cadrul săptămânii în care cade această dată, astfel:
- ca şir de caractere reprezentând numele zilei din cadrul săptămânii
(Sunday, Monday, etc.) pentru CDOW( )
- ca număr reprezentând a câta zi din săptămână (1 pentru Luni, 2 pentru
Marţi, etc.) pentru DOW( )
Ex. ? CDOW(DATE())
Wednesday
?DOW(DATE())
3
Ziua în cadrul lunii este returnată de funcţia DAY () cu următoarea sintaxă:
DAY (<expD>)
Ex. ? DAY({03/14/90})
14
Luna corespunzătoare unei expresii de tip dată calendaristică este returnată
de funcţiile MONTH () şi CMONTH (), cu sintaxele:
MONTH (<expD>)
CMONTH (<expD>)
Ca şi în cazul celor două funcţii anterioare şi la acestea deosebirea provine
de la valoarea returnată de ele şi anume :
- un şir de caractere reprezentînd denumirea lunii corespunzătoare date
(Ianuary, February,etc.) pentru funcţia CMONTH()
- un număr reprezentînd a câta lună în cadrul anului (1 ptr. ianuarie, 2 ptr.
februarie, etc.) pentru funcţia MONTH().
Ex. ? MONTH (DATE())
11
?CMONTH(DATE())
NOVEMBER
CONTROLUL TIMPULUI ÎN FOXPRO
Ora exactă a sistemului se obţine cu funcţia TIME () care are sintaxa:
TIME ([<expN>])
115
Valoarea returnată de această funcţie este un şir de caractere de lungime 8,
formatul HH:MM:SS, unde:
- HH reprezintă două cifre ptr. oră (de la 0 la 23)
- MM reprezintă două cifre pentru minute (de la 0 la 59)
- SS reprezintă două cifre pentru secunde ( de la 0 la 59)
Dacă în apelul funcţiei se specifică şi <expN>, valoarea returnată va
include şi sutimi de secundă; şirul returnat va avea lungimea de 11 caractere,
ultimile două poziţii reprezentînd sutimile de secundă.
Ex. ? TIME ()
04 :30:40
? TIME(0)
04:30:40. 80
Există două funcţii care măsoară intervalul de timp ce s-a scurs de la
miezul nopţii, adică de la ora 0 (zero), pînă în prezent. Funcţia SYS (2) returnează
numărul de secunde ce a trecut de la ora zero, rezultatul fiind de tip numeric.
Ex. ? TIME ()
02:40:34
? SYS (2)
9648
Acelaşi efect cu al funcţiei SYS (2) îl obţinem cu funcţia SECONDS (),
diferenţa dintre cele două funcţii fiind rezoluţia.
Sintaxa funcţiei este: SECONDS(), iar rezultatul este numeric cu trei cifre
după virgulă, reprezentînd numărul de milisecunde.
Ex. ? TIME()
-----------
? SYS (2)
9672
? SECONDS ()
9683.482
Ora exactă dată de sistem, poate fi menţinută tot timpul pe ecran, folosind
comanda SET CLOCK, cu sintaxa:
(1) SET CLOCK ON | OFF
(2) SET CLOCK TO [<rând>, <coloană>]
ON face ca ceasul să rămînă tot timpul vizibil pe ecran
OFF face ca ceasul să dispară de pe ecran
116
Formula a doua (2) se foloseşte pentru a specifica poziţia pe ecran unde va
apărea ceasul. Această poziţie se specifică prin <rând> reprezentând rândul pe
ecran şi <coloana> reprezentând coloana primei cifre a orei. Poziţia implicită a
orei este (0,60), în colţul din dreapta sus.
U10.9. Baze de date
Datorită asemănării dintre modul de organizare a unei baze de date şi cel al

unui tabel vom folosi analogia dintre aceste două elemente în descrierea bazelor
de date.
Corespunzător acestui tabel vom avea o bază de date, în care:
- capului de tabel îi va corespunde “structura”
- coloanele vor fi numite “câmpuri”
- liniile se vor numi “înregistrări”
La crearea unei baze de date trebuie specificată structura acesteia. Pentru a
specifica în mod univoc structura unei baze de date, trebuie indicate câmpurile
care o compun printr-un nume asociat fiecărui câmp cât şi caracteristicile acestora
(tipul de date ce se memorează în acel câmp, lungimea).
Pentru a specifica o anumită înregistrare din baza de date se foloseşte
“indicatorul de înregistrări”, care reprezintă o zonă de memorie ce conţine
numărul înregistrării curente. Indicatorul de înregistrări poate fi modificat prin
comenzi FoxPro, acest lucru fiind realizat cu ajutorul tastelor direcţionale în sus
şi în jos a indicatorului de înregistrări de-a lungul bazei de date. Pentru a folosi o
bază de date aceasta trebuie mai întâi deschisă. Deschiderea bazei de date se face
într-o zonă din memoria calculatorului care poartă numele de zonă de lucru ( în
engleză „work area”) şi sunt 25 la număr în varianta FoxPro 2.0 şi 225 în varianta
2.6. Pentru identificarea zonelor de lucru se folosesc două metode :
- primele 10 zone de lucru se identifică prin litere de la A la J adică primele
10 litere din alfabet
- pentru toate cele 25 baze de date putem folosi pentru identificare
numerele de la 1 la 25.
La deschiderea unei baze de date într-o zonă de lucru acesteia i se atribuie
un nume pe care îl vom numi “alias”. Deci baza de date deschisă va putea fi
identificată şi prin aliasul respectiv. La un moment dat, din cele 25 de zone de
lucru una singură va fi curentă. La pornirea FoxPro zona de lucru curentă va fi
117
zona A, sau 1. Aceasta se poate schimba folosind comanda SELECT, cu sintaxa:
SELECT<expN> <expC>, unde: <expN> reprezintă numărul zonei de lucru ce va
fi activată, adică va deveni zonă de lucru curentă <expC> reprezintă aliasul bazei
de date deschisă în acea zonă de lucru.
Pentru a afla care este zona de lucru curentă se foloseşte funcţia
SELECT().
10.9.1. Crearea unei baze de date. Structura unei baze de date
Pentru crearea unei baze de date se foloseşte comanda CREATE cu

sintaxa:
CREATE [<fişier>] unde <fişier> reprezintă numele fişierului de bază de
date ce va fi creat. Dacă pentru acest fişier nu se specifică nici o extensie, FoxPro
asociază automat extensia .DBF. Dacă nu se specifică numele fişierului pe ecran
va apare o fereastră, unde se va introduce numele bazei de date ce se va crea, în
câmpul de editare din partea de jos în locul cuvântului “untitled”. După
specificarea numelui bazei de date se activează declanşatorul implicit <<Create>>
după care se va intra în fereastra de specificare a structurii. După introducerea
structurii bazei de date se selectează declanşatorul <OK> semnalizând terminarea
editării structurii bazei de date. După terminarea editării structurii FoxPro afişează
un mesaj întrebând daca dorim să introducem date şi în funcţie de opţiunea aleasă
se va trece fie într-o fereastră de introducere a datelor fie se revine în fereastra de
comenzi.
Cea de-a doua metodă de creare a unei baze de date este reprezentată de
comanda CREATE TABLE, care are sintaxa:
CREATE TABLE DBF<nume.dbf> (<nume_câmp 1> <tip>[(<precizie>
[,<scala>) [,<nume_câmp 2...]])
în care:
- <nume.dbf> reprezintă numele bazei de date de creat
- <nume_câmp 1> , <nume_câmp 2>,... reprezintă numele câmpurilor
structurii bazei de date
- <tip> reprezintă tipul câmpului aceasta fiind o literă, astfel: C (caracter),
N(numeric) D(data calendaristică), L(logic) , M(memo)
- lăţimea câmpului este specificată prin <precizie>
118
- <scala> reprezintă numărul de zecimale în cazul câmpurilor numeric sau
float
10.9.2. Deschiderea şi închiderea unei baze de date
Pentru deschiderea unei baze de date se foloseşte comanda USE cu

sintaxa:
USE [<fişier>?], unde:
- <fişier> reprezintă numele bazei de date sau aliasul acesteia
- dacă în locul acestui fişier se specifică ? fişierul bazei de date ce va fi
deschis va fi selectat interactiv printr-o fereastră de dialog.
Închiderea bazelor de date se realizează cu comanda CLOSE ALL , care
închide toate fişierele din toate zonele de lucru şi selectează zona de lucru 1.
10.9.3. Manipularea structurii unei baze de date
Modificarea structurii unei baze de date se realizează cu comanda

MODIFY STRUCTURE cu aceeaşi sintaxă şi realizează modificarea structurii
bazei de date prin deschiderea unei ferestre de dialog aceeaşi ca la crearea bazei
de date, unde se vor realiza modificările. Dacă în zona de lucru curentă este
deschisă o bază de date atunci comanda se referă la aceasta. În caz contrar, apare o
fereastră de dialog, de unde se va selecta baza de date a cărei structură se va
modifica.
Vizualizarea structurii unei baze de date se face cu comenzile DISPLAY
STRUCTURE sau LIST STRUCTURE.
10.9.4. Manipularea câmpurilor unei baze de date
Accesul la câmpurile unei baze de date este controlat de comanda SET

FIELDS, care are următoarea sintaxă:
SET FIELDS ON OFF
SET FIELDS TO [[<câmp1>[<câmp 2>...]] ALL]
unde:
119
- <câmp 1>,<câmp 2>,... reprezintă lista câmpurilor ce pot fi accesate în
cazul SET FIELDS ON. SET FIELDS TO ALL permite accesul la toate
câmpurile, chiar dacă starea lui SET FIELDS este ON.
Comanda se referă la baza de date curentă.
Funcţia FIELDS() returnează numele unui câmp dintr-o bază de date
identificat prin numărul câmpului în cadrul structurii bazei şi are sintaxa:
FIELDS (<expN1>[,<expN2> <expC>])
în care <expN1> specifică numărul de ordine al câmpului (primul câmp are nr. de
ordine 1 ş.a.m.d.) iar <expN 2> sau <expC> identifică baza de date la care se
referă funcţia prin zona de lucru în cazul lui <expN> şi prin <expC> aliasul
acesteia.
Numărul câmpurilor dintr-o bază de date este returnat de funcţia
FCOUNT() ce are sintaxa: FCOUNT ([<expN> <expC>])
<expN> reprezintă zona de lucru în care este deschisă baza la care se
referă funcţia
<expC> reprezintă aliasul bazei respective.
10.9.5. Vizualizarea conţinutului unei baze de date
După crearea unei baze de date şi încărcarea acesteia cu informaţii, apare

necesitatea vizualizării datelor stocate, adică a conţinutului bazei de date.
Afişarea acestor informaţii se poate face pe ecran, la imprimantă sau într-
un fişier de pe disc folosind comenzile LIST şi DISPLAY. Comanda DISPLAY
afişează conţinutul bazei de date din zona de lucru curentă, având sintaxa :
DISPLAY [FIELDS] <lista câmpuri>
[<domeniu>] [FOR <expL 1> ][WHILE <expL2 >]
[OFF]
[TO PRINTER TO FILE<fişier>]
[NOCONSOLE]
Ex. Afişaţi doar la imprimantă conţinutul bazei de date Personal.dbf fără
numărul înregistrării.
USE PERSONAL
DISP ALL OFF NOCONSOLE TO PRINTER
Pentru a obţine conţinutul bazei de date Personal atât în fişierul Listare .txt
cât şi pe ecran se foloseşte:
120
DISP ALL TO FILE Listare.txt
Indicatorul de înregistrări conţine numărul înregistrării curente într-o
bază de date, având la un moment dat o singură înregistrare curentă.
Există o mulţime de comenzi şi funcţii care se referă la anumite înregistrări
din baza de date. Astfel comanda:
DISPLAY NEXT 2, afişează următoarele două înregistrări din baza de date
curentă începând de la înregistrarea curentă inclusiv.
Domeniul înregistrărilor se specifică prin patru clauze: ALL, RECORD,
NEXT, REST dintre care ultimele două au ca punct de referinţă înregistrarea
curentă.
Aflarea înregistrării curente dintr-o bază de date se face cu funcţia
RECNO() cu sintaxa:
RECNO([<expN> <expC>]) unde:
<expN> -zona de lucru în care este deschisă b.d.
<expC>-aliasul bazei de date
Dacă ambele lipsesc funcţia se referă la baza de date activă. Următoarele
două comenzi sunt echivalente: DISP NEXT 1 şi DISP RECORD RECNO()
Schimbarea înregistrării curente se realizează prin intermediul unor
comenzi Fox Pro cum ar fi GOTO, SKIP etc.
Comanda GO sau GOTO poziţionează indicatorul de înregistrări pe o
anumită înregistrare dintr-o bază de date cele două comenzi fiind echivalente şi au
sintaxa:
GO GOTO [RECORD]<expN1>[IN <expN2> <expC>]
GO GOTO TOP BOTTOM [<expN1>[IN <expN2> <expC>]
Prima formă are ca efect poziţionarea indicatorului de înregistrări din baza
de date. <expC> sau din zona de lucru <expN2> pe înregistrarea cu nr.<expN1>.
Absenţa clauzei IN determină referirea la baza de date curentă.
Forma a doua este folosită pentru poziţionarea indicatorului de înregistrări
pe înregistrările extreme ale bază de date.
Un alt tip de deplasare cu indic. de înregistrări de-a lungul bază de date
este realizat cu comanda SKIP. Aceasta mută indicatorul peste un număr de
înregistrări relativ la înregistrarea curentă.
Sintaxa comenzii:
SKIP [expN1> // <expN2> // <expC>]
unde: <expN 1> nr. înregistrărilor peste care se sare
121
<expN2>- zona de lucru în care este baza de date
<expC> - aliasul bazei de date
Comanda SKIP este echivalentă cu SKIP 1.
U10.10. Câmpurile memo
În memorarea informaţiilor într-o bază de date apar situaţii când, cantitatea

de informaţii ce trebuie stocată într-un anumit câmp diferă foarte mult de la o
informaţie la alta. Pentru a elimina acest neajuns s-a introdus câmpul de tip memo
care permite memorarea informaţiilor de acest fel mult mai eficient. O bază de
date care conţine cel puţin un câmp memo are asociat un fişier suplimentar în
care sunt depuse informaţiile conţinute în acel câmp.
Încărcarea unor date într-un câmp memo se poate face fie de către
utilizator introducându-se caracter cu caracter într-o fereastră de editare, fie prin
citirea acestora dintr-un fişier sau din memoria calculatorului.
Prima metodă se realizează în felul următor:
- se deschide o fereastră de editare pentru modificarea conţinutului bazei
de date. sau pentru adăugarea de noi înregistrări folosind comenzile CHANGE,
EDIT, BROWSE, APPEND etc.;
- se poziţionează cursorul în câmpul memo respectiv al înregistrării dorite
după care se apasă combinaţia de taste CTRL + PgDn. Dacă se foloseşte mouse-ul
se poziţionează cursorul deasupra câmpului respectiv şi se apasă butonul stâng de
două ori la intervale scurte de timp;
- ca efect al acestei acţiuni pe ecran apare o fereastră de editare în care se
introduce conţinutul câmpului respectiv;
- după terminarea editării se iese din fereastră cu CTRL+W, combinaţie
care salvează modificările efectuate, sau cu ESC care nu salvează modificările
aduse câmpului memo.
Pentru a edita un câmp memo fără a mai trece prin fereastra de editare
CHANGE se foloseşte comanda MODIFY MEMO care deschide direct o fereastră
de editare pentru câmpul memo specificat al înregistrării curente din baza de date
activă.
Sintaxa: MODI MEMO <câmp memo 1> [<câmp memo 2>...]
O altă modalitate de a încărca un câmp memo dintr-o bază de date este
dată de APPEND MEMO.
122
Această comandă încarcă conţinutul unui fişier într-un câmp memo
specificat. Comanda are următoarea sintaxă:
APPEND MEMO <câmp memo> FROM <fişier>[OVERWRITE]
Conţinutul întregului fişier, cu numele fişier se adaugă la sfârşitul
câmpului memo <câmp memo>. Dacă se include opţiunea OVERWRITE
conţinutul fişierului va fi copiat peste acesta vechiul conţinut al câmpului
pierzându-se.
Operaţia inversă de copiere a conţinutului unui câmp memo dintr-o bază
de date într-un fişier se face cu comanda COPY MEMO <câmp memo> TO
<fişier> [ADDITIVE].
U10.11. Meniuri
Meniul reprezintă un element FoxPro prin care se oferă utilizatorului

posibilitatea selectării unei opţiuni, dintr-o mulţime finită de opţiuni posibile,
afişată pe ecran total sau parţial, urmând ca în funcţie de selectarea făcută să se
declanşeze anumite acţiuni corespunzătoare opţiunii alese.
Un meniu este format dintr-o “bară a meniului” şi mai multe “submeniuri”.
Bara meniului conţine la rândul ei mai multe opţiuni numite “opţiuni bară”
fiecăreia dintre acestea putându-i-se ataşa un submeniu. Fiecare submeniu este
format la rândul lui din “opţiuni”.
Modul de lucru cu submeniurile definite de utilizator este următorul:
Se defineşte meniul respectiv astfel:
- Definirea barei meniului;
- Definirea opţiunilor bară;
- Definirea submeniurilor;
- Definirea opţiunilor;
- Definirea acţiunilor ce se execută la alegerea unei opţiuni sau a unei
opţiuni bară a meniului;
- Se activează meniul urmând a se selecta opţiunea dorită;
- Se efectuează diferite operaţii specifice meniului (afişare, ascundere
etc.);
- Se elimină meniul din memorie însemnând sfârşitul lucrului cu acest
element.
123
10.11.1. Comenzi pentru lucrul cu meniuri
Definirea barei unui meniu se face prin intermediul comenzii DEFINE

MENU, cu sintaxa:
DEFINE MENU <nume meniu>
[BAR[AT LINE<expN 1>]]
[KEY<eticheta tasta>]
[MARK <expC 1>]
[MESSAGE <expC 2]
[NOMARGIN]
[COLOR <lista culori>]
Barei meniului i se atribuie un nume, <nume meniu> urmând ca acest
element să fie identificat prin numele atribuit.
Clauza BAR se foloseşte cu scopul de a prelua caracteristicile noii bare de
meniu de la cea a meniului sistem FoxPro.
Următoarele aspecte sunt caracteristice meniului sistem:
- După alegerea unei opţiuni bară de meniu se dezactivează;
- Bara de meniu va acoperi o singura linie a ecranului sau a ferestrei in
care este plasata de la un capăt la altul;
- Poziţia submeniurilor va fi stabilită de FoxPro in mod automat;
- Dacă bara va avea dimensiuni mai mari decât ecranul sau fereastra în
care s-a introdus se va folosi metoda defilării pentru accesarea opţiunilor bară.
Clauza AT LINE determină afişarea barei meniului pe linia cu nr.<expN 1>
a ecranului sau a ferestrei respective.
Clauzele IN WINDOW si IN SCREEN sunt folosite pentru a specifica
locul unde bara meniu va fi plasată:
- în fereastră <nume fereastra>, dacă în comandă se include clauza IN
WINDOW;
- în ecran dacă se precizează clauza IN SCREEN sau nu se specifică nici
una din cele două clauze, iar ieşirea curentă este direcţionată spre ecran.
Activarea meniului se poate face prin activarea unei taste sau a unei
combinaţii de taste, care va fi determinată de etichetă <eticheta tasta> a clauzei
KEY.
Unele dintre opţiunile bară ale meniului pot fi însemnate, marcate,
indicând că acestea respectă o anumită condiţie. Caracterul folosit pentru
124
marcarea opţiunilor bară este ‘ ‘, dar acesta poate fi schimbat prin clauza MARK,
urmată de un şir de caractere. Primul caracter din şir se va folosi pentru marcarea
opţiunilor bară ale meniului respectiv. Clauza este influenţată de comanda SET
MARK OF.
Clauza MESSAGE determină afişarea şirului de caractere <expC 2> pe
ultima linie a ecranului în centrul acesteia. Clauza este influenţată de SET
MESSAGE.
Opţiunile bară ale meniului vor fi afişate una după alta, pe bara meniului,
fiind separate prin blancuri. Eliminarea acestora se face introducând clauza NO
MARGIN în comanda DEFI MENU respectivă.
Clauza COLOR controlează culorile folosite pentru afişarea meniului.
După definirea unei bare a meniului se vor defini opţiunile bară care vor
aparţine barei respective, aceasta realizându-se cu comanda DEFINE PAD, cu
sintaxa:
DEFINE PAD <opţiune bara 1> OF <nume meniu> PROMPT <expC 1>
[AT <linie>,<coloana>]
[BEFORE<opţiune bara 2>/AFTER <opţiune bara2>]
[KEY <eticheta tasta>[,expC 2>]]
[MARK <expC 3>]
[SKIP[FOR <expL>]]
[MESSAGE<expC 4>]
[COLOR <pereche culori>]
Numele opţiunii bară va fi <opţiune bara>, iar bara de meniu de care
aceasta va aparţine va fi <nume meniu>. Textul care va fi afişat pe bara meniului
va fi cel dat de clauza PROMPT, adică şirul de caractere <expC 1>. Stabilirea
unei taste directe de selectare a opţiunii bară respective se realizează prin plasarea
combinaţiei ‘|<’înaintea caracterului ce va desemna tasta directă în textul clauzei
PROMPT.
Ex…PROMPT ‘|<Ştergere’…va defini un text al opţiunii bara numit
‘Ştergere’ în care tasta directă de selectare va fi ‘S’. Dacă în textul clauzei
PROMPT caracterul selectat ce va prezenta tasta directă nu este primul de acest
tip, atunci ca tastă directă de selectare va fi aleasă prima apariţie a caracterului
respectiv.
125
Ex. …PROMPT ‘Alb|<astru’…în acest caz va avea textul ‘Albastru’ în
care ‘A’ va reprezintă tasta directă de selectare (de fapt selectarea se poate face
atât cu’a’ cât şi cu’A’).
Clauza AT nu se poate folosi pentru o bară a meniului definită cu clauza
BAR (acestea sunt totdeauna orizontale , iar poziţia opţiunilor bară este controlată
automat de FoxPro).
Ordinea de apariţie, selectarea opţiunilor bară ale unui meniu este dată de
ordinea definirii acestora prin comanda DEFI PAD corespunzătoare. Dacă după
definirea unui număr de opţiuni se doreşte inserarea uneia noi între cele definite
anterior se foloseşte una din clauzele BEFORE sau AFTER.
Clauza BEFORE determină inserarea lui <opţiune bară1> imediat înainte
de <opţiune bară 2>, iar clauza AFTER determină inserarea lui <opţiune bară 1>
imediat după <opţiune bară 2>.
Ex. DEFI MENU test
DEFI PAD opt 1 OF test PROMPT ‘opt\<1’
DEFI PAD opt 2 OF test PROMPT ‘opt\< 2’
DEFI PAD opt 3 OF test PROMPT ‘opt\<3’
Acelaşi lucru realizându-se cu secvenţa următoare:
DEFI MENU test
DEFI PAD opt 1 OF test PROMPT’opt\<1’
DEFI PAD opt 3 OF test PROMPT’opt\<3’
DEFI PAD opt 2 OF test PROMPT’opt\<2’ BEFORE opt 3
Clauza KEY se foloseşte pentru definirea unei căi directe de selectarea
unei opţiuni bară.
Calea de selectare directă reprezintă o combinaţie de taste care, acţionate
la un moment dat, determină selectarea opţiunii respective. Combinaţia de taste va
fi desemnată de o etichetă <eticheta tasta>.
O opţiune bară care se prevede cu o cale directă de selectare va fi afişată
având la dreapta ei eticheta respectiva. Dacă se doreşte inhibarea acestei afişări ,
sau afişarea unui alt text în locul etichetei, se va folosi şirul de caractere <expC>
care poate conţine:
- Textul de afişat în dreapta opţiunii bară
- Fişierul vid când nu se doreşte afişarea căii directe alături de opţiunea
bară.
Ex. DEFI PAD opt 1 OF test PROMPT’opt\< 1’ KEY CTRL+H,”^ H”
126
Clauza MARK se foloseşte pentru a specifica caracterul folosit la marcarea
opţiunii barei respective, acesta fiind primul caracter al şirului <expC3>.
Marcatorul implicit este ‘ ‘, iar condiţia de marcare este dată de SET MARK OF.
Dacă se specifică câte un marcator şi prin comanda DEFI MENU şi prin DEFI
PAD (la ambele folosind clauza MARK) pentru marcarea opţiunii bară se va
folosi cel dat de clauza DEFI PAD.
Clauza MESSAGE determină afişarea textului din şirul <expC 4> cât timp
opţiunea bară respectivă este selectată. Afişarea mesajului este controlată de
comanda SET MESSAGE .
Pentru stabilirea condiţiilor de accesare a unei opţiuni bară se foloseşte
clauza SKIP.
Dacă această clauză se foloseşte fără FOR opţiunea bară respectivă nu va
putea fi accesată, ea este dezactivată. De asemenea dezactivarea unei opţiuni bară
se poate face prin plasarea caracterului ‘\’ înaintea textului din comanda
PROMPT.
Ex. Comenzile următoare sunt echivalente:
DEFI PAD opt OF test PROMPT’\Ales’
DEFI PAD opt OF test PROMPT’Ales’ SKIP
Clauza COLOR specifică culorile folosite pentru afişarea opţiunii bară.
Ex. Să se definească bara meniu ACŢIUNE din figura următoare:
Modificare Ştergere * Adăugare ^N Listare Vizualizare
Ieşire ^X
Literele subliniate reprezintă taste directe de selectare, iar ^N,^X
reprezintă căi directe de selectare, iar ‘*’ reprezintă marcajul.
DEFI MENU ACTIUNE
DEFI PAD STERGERE OF ACTIUNE PROMPT ‘\<Ştergere’
DEFI PAD MODIFICARE OF ACTIUNE PROMPT ’\<Modificare’
BEFORE;
Ştergere
DEFI PAD ADAUGARE OF ACTIUNE PROMPT ‘\<Adăugare’ MARK
‘*’;
KEY CTRL+N ,”^ N”
DEFI PAD LISTARE OF ACTIUNE PROMPT ‘\<Listare’ AFTER
Adăugare
DEFI PAD VIZUALIZARE OF ACTIUNE PROMPT ‘\<Vizualizare’
127
DEFI PAD IESIRE OF ACTIUNE PROMPT ‘\<Ieşire’ KEY CTRL+X, “^
X”
Submeniurile se definesc prin comanda DEFINE POPUP care are sintaxa:
DEFI POPUP <nume submeniu>
[FROM <linie 1>,<coloana 1>][TO <linie 2>, coloana 2>]
[IN [WINDOW] <nume fereastră>|IN SCREEN]
[FOOTER <expC 1>][TITLE ,expC 2>]
[KEY <eticheta tasta>]
[MARGIN]
[MARK <expC 3>]
[MESSAGE <expC 4>]
[MOVER]
[MULTI]
[PROMPT FIELD <expr>| PROMPT FILES[LIKE <masca>|PROMPT
STRUCTURE]
[RELATIVE]
[SCROLL]
[SHADOW]
[COLOR <lista perechi culori>]
Un submeniu reprezintă o listă de opţiuni care pot fi de următoarele tipuri:
- opţiuni definite de utilizator(prin comenzi DEFI BAR)
- înregistrări dintr-o bază de date ( PROMPT STRUCTURE)
- o listă de fişiere de pe disc (PROMPT FILES)
Numele submeniului va fi <nume submeniu>. Poziţia acestuia pe ecran sau
într-o fereastră va fi dată de clauza FROM în care <linia 1>, <coloana 1> indică
poziţia colţului stânga sus al submeniului.
Dacă această clauză lipseşte, submeniul va fi plasat în colţul din stânga sus
al ecranului la poziţia 0,0.
Clauza TO este folosită pentru a indica poziţia colţului din dreapta jos a
submeniului prin coordonatele <linie 2>,<coloana 2> aceasta determinând si
dimensiunile submeniului.
Pentru ca submeniul să fie într-o fereastră, numele acesteia, <nume
fereastra>, va fi inclus în clauza IN WINDOW. Dacă această clauză lipseşte
submeniul va putea fi introdus într-o fereastră în cazul în care ieşirea este
128
direcţionată către o fereastra (fereastra curentă) şi în comanda DEFINE POPUP
nu s-a inclus clauza IN SCREEN.
Submeniul va fi plasat pe ecran dacă este prezentă clauza IN SCREEN şi
ieşirea este direcţionată spre ecran.
Clauza TITLE se foloseşte pentru afişarea textului dat de şirul <expC2> în
centrul laturii superioare a chenarului submeniului, iar clauza FOOTER permite
afişarea textului din şirul <expC1> la mijlocul laturii inferioare a chenarului
submeniului.
Clauza KEY se foloseşte în scopul de a specifica o cale directă pentru
activarea submeniului, cale dată de <eticheta tast>a.
Stabilirea caracterului folosit pentru marcarea opţiunilor unui submeniu se
face cu clauza MARK urmată de caracterul respectiv<expC3>. Clauza este
influenţată de comanda SET MARK OFF.
Cât timp submeniul este activat se poate afişa un text explicativ, un mesaj,
pe ultima linie a ecranului sau a ferestrei respective. Mesajul este dat prin
<expC4>, expresie de tip şir de caractere inclusă în clauza MESSAGE. Această
clauză este controlată de comanda SET MESSAGE.
Clauza MARGIN se include în comanda pentru ca opţiunile să fie separate
de chenar printr-un spaţiu suplimentar, la dreapta şi la stânga acestora. În acest
spaţiu în stânga vor fi afişate marcajele, iar la dreapta acestora se va afişa, când
este cazul, o săgeată indicând ieşirea în alt submeniu.
MOVER este o clauză care permite rearanjarea opţiunilor într-un
submeniu, când acesta este activat. Pentru mutarea unei opţiuni în altă poziţie a
submeniului se procedează astfel:
- se selectează opţiunea prin deplasarea cursorului deasupra acesteia şi cu
ajutorul tastelor Ctrl+| sau Ctrl+| se deplasează opţiunea respectivă în noua
poziţie.
- cu ajutorul mouse-ului, se poziţionează cursorul acestuia deasupra
caracterului „|” corespunzător opţiunii de mutat, după care se apasă butonul stâng
şi cu acesta apăsat se mută opţiunea odată cu cursorul în noua poziţie.
Pentru aflarea opţiunii dintr-o anumită poziţie a submeniului se va folosi
funcţia GETBAR().
O altă facilitate a submeniului este cea a selecţiilor multiple. Selectarea
mai multor opţiuni se face în modul următor:
129
- folosind tastatura se acţionează tasta Shift şi împreună tastele Enter sau
Space când cursorul se afla pe o opţiune ce se va selecta. Ţinerea tastei Shift
apăsată şi deplasarea cursorului deasupra mai multor opţiuni determină selectarea
opţiunilor peste care cursorul trece;
- folosind mouse-ul, se apasă butonul stâng al acestuia în timp ce cursorul
sau se afla deasupra unei opţiuni de selectat şi în timp ce tasta Shift este apăsată.
De asemenea deplasarea cursorului mouse-ului deasupra mai multor opţiuni când
tasta Shift este apăsată, determină selectarea opţiunilor respective.
Clauza MULTI nu poate fi folosită în acelaşi timp cu clauza PROMPT.
Funcţia MRKBAR() se va folosi pentru detectarea opţiunilor selectate prin
metodele de mai sus.
Tipul de submeniu este determinat de clauza PROMPT. Dacă această
clauză lipseşte, opţiunile submeniului urmează a fi definite cu comenzi BAR.
În cazul clauzei PROMPT FIELD opţiunile submeniului vor fi preluate
dintr-o bază de date deschisă într-o zonă de lucru, pentru fiecare înregistrare
corespunzând câte o opţiune. La activarea submeniului se va selecta automat zona
de lucru respectivă.
Expresia <expr> va determina modul de obţinere a unei opţiuni din
înregistrarea corespunzătoare. Această expresie poate conţine câmpuri ale bazei de
date curente sau ale unei baze de date din altă zonă de lucru între care se poate
aplica operatorul de concatenare.
Numărul maxim de opţiuni ale unui submeniu creat dintr-o bază de date
este de 32767 în versiunea standard a FoxPro, numărul de opţiuni fiind nelimitat
în versiunea extinsă a Fox Pro.
Pentru ca opţiunile submeniului să reprezinte fişiere de pe un disc, dintr-un
anumit director, se foloseşte clauza PROMPT FILES.
Această clauză, folosită fără LIKE determină afişarea unor opţiuni ale
submeniului, a tuturor fişierelor de pe discul curent, din directorul curent. În cazul
în care se doreşte să reprezinte numai anumite opţiuni ale submeniului se va folosi
<masca> din clauza LIKE. <Masca> respectă regulile DOS de specificare a mai
multor fişiere, folosind simbolurile * şi ? (exemplu: .DBF, A.PRG,*.?11).
O ultimă variantă a clauzei PROMPT este cea care se referă la structura
unei baze de date, adică PROMPT STRUCTURE. În acest caz opţiunile
submeniului vor fi câmpurile bazei de date active. Şi în acest caz activarea
130
submeniului va determina selectarea zonei de lucru conţinând baza de date
respectivă.
În cazul submeniurilor ale căror opţiuni sunt definite prin comenzi
DEFINE BAR ordinea acestor opţiuni este controlată de clauza RELATIVE. În
prezenţa acestei clauze opţiunile vor apare în submeniu în ordinea definirii lor,
deci nu vor mai apare spaţii între opţiunile submeniului. De asemenea, această
clauză permite folosirea clauzelor BEFORE şi AFTER în comanda DEFINE
BAR.
Clauza SCROLL are ca efect afişarea unei bare de defilare verticale, pe
latura dreapta a chenarului submeniului, când nu toate opţiunile pot fi afişate
simultan pe ecran, în interiorul submeniului.
SHADOW este clauza referitoare la efectul de umbră, prezenţa acestuia
permiţând afişarea umbrei submeniului. Starea umbrei este controlată de comanda
SET SHADOW.
Pentru definirea opţiunilor unui submeniu, ce a fost definit anterior cu o
comanda DEFINE POUP, vom folosi comanda DEFINE BAR, cu sintaxa :
DEFINE BAR <expN1>/<nume opţiune sistem.
OF <nume submeniu>PROMPT<expC1>
BEFORE<expN2>/AFTER<expN2>
KEY<eticheta tasta> , <expC2>
MARK<expC3>
MESSAGE<expC4>
SKIP FOR<expL>
COLOR<LISTA PERECHI CULORI>/ COLOR SCHEME<expN>
Comenzile DEFINE BAR şi DEFINE PAD sunt asemănătoare întrucât
definirea opţiunilor într-un submeniu se face asemănător cu definirea opţiunilor
bară într-o bară a unui meniu.
Afişarea şi activarea unei bare de meniu se face cu comanda ACIVATE
MENU, cu sintaxa:
ACTIVATE MENU<nume meniu>
NOWAIT
PAD<nume opţiune bară>
Clauza NOWAIT determină continuarea execuţiei programului după
afişarea şi activarea barei de meniu. Bara de meniu va rămâne activată,
131
utilizatorului dându-i-se posibilitatea selectării unei opţiuni bara ori de câte ori
programul aşteaptă introducerea unor date de la tastatură.
Analog afişării şi activării barei de meniu se face şi afişarea şi activarea
submeniului, în acest caz folosindu-se comanda ACTIVATE POPUP, cu sintaxa :
ACTIVATE POPUP<nume submeniu>
AT<LINIE>, <coloana>
BAR<expN>
NOWAIT
REST
Această comandă - REST- va afişa şi activa submeniul <nume submeniu>
la coordonatele specificate în clauza AT <linie> şi <coloană> în ecran sau
fereastra curentă, selectând iniţial opţiunea <expN>.
Afişarea pe ecran sau în fereastra curentă a barelor de meniu şi a
submeniurilor, fără activarea acestora se realizează cu comenzile SHOW MENU
şi SHOW POPUP.
Comanda SHOW MENU realizează afişarea barelor de meniu enumerate
în lista ce urmează comenzii, sau a tuturor barelor de meniu, dacă se foloseşte
ALL în locul listei.
Pentru afişarea unei opţiuni bara ca fiind selectată, aceasta se specifică prin
clauza PAD.
Pentru reţinerea imaginii pe ecran fără activarea acestora, se va folosi
clauza SAVE în comanda SHOW MENU. Această imagine va putea fi ştearsă prin
comanda CLEAR.
Eliminarea de pe ecran sau din fereastra curentă a barelor de meniu şi a
submeniurilor fără înlăturarea acestora din memorie, se realizează cu comenzile
HIDE MENU şi HIDE POPUP.
Comanda HIDE MENU ascunde barele de meniu specificate în listă sau
toate barele de meniu definite, dacă se foloseşte clauza ALL, dar nu le elimină pe
acestea din memorie.
Clauza SAVE se foloseşte pentru a păstra o imagine a barei de meniu, pe
ecran sau în fereastra curentă, şi după ascunderea acesteia, ştergerea făcându-se cu
CLEAR.
Comanda HIDE POPUP ascunde submeniurile specificate în lista sau toate
submeniurile definite (ALL) adică le elimină de pe ecran fără a le înlătura şi din
memorie.
132
Legătura dintre barele de meniu şi submeniuri este de o importanţă
deosebită pentru realizarea de meniuri complexe.
O primă modalitate de a lega o bară de meniu de un submeniu sau o altă
bară de meniu este dată de comanda ON PAD.
Pentru activarea unui submeniu se foloseşte clauza ACTIVATE POPUP
urmată de numele submeniului, iar pentru activarea unei alte bare de meniu se
foloseşte clauza ACTIVATE MENU, după care se include numele barei
respective.
Pentru ca la alegerea unei opţiuni bară sau a unei opţiuni a unui submeniu,
să se execute operaţii mai complexe ( nu numai activarea unui submeniu sau a
unei bare de meniu) vom folosi grupul de comenzi ON SELECTION format din
următoarele patru comenzi:
1. ON SELECTION MENU
2. ON SELECTION PAD
3. ON SELECTION POPUP
4. ON SELECTION BAR
Aceste comenzi determină executarea unei singure comenzi la alegerea
unei opţiuni bară sau a unei opţiuni.
Comanda ON SELECTION MENU are sintaxa :
ON SELECTION MENU<nume meniu>/ ALL <instrucţiune>
Instrucţiunea <instrucţiune> va fi executată la alegerea oricărei opţiuni
bară a barei de meniu <nume meniu> sau a oricărei bare de meniu definită când
se foloseşte clauza ALL. Comanda ON SELECION MENU trebuie plasată între
DEFINE MENU şi ACTIVATE MENU. Dacă instrucţiunea lipseşte, opţiunile
bara respective sunt eliberate, adică nu se va mai executa nici o instrucţiune la
alegerea lor.
O utilizare asemănătoare o are comanda ON SELECTION PAD cu
sintaxa:
ON SELECTION PAD <nume opţiune bara>OF<nume meniu>
<instrucţiune>
cu deosebirea că <instrucţiune> se va executa numai la alegerea opţiunii bara
<nume opţiune bara> a barei de meniu, ca la comanda anterioară.
Comanda ON SELECTION POPUP determină executarea instrucţiunii
<instrucţiune> la fiecare alegere a unei opţiune din submeniul definit, când
foloseşte clauza ALL.
133
În lipsa lui <instrucţiune>, opţiunile respective sunt eliberate de acesta,
deci nu se va mai executa nici o instrucţiune la alegerea unei opţiuni a
submeniului. Aceasta comandă trebuie plasată între DEFINE POPUP şi
ACTIVATE POPUP.
Comanda MOVE POPUP mută submeniul în poziţia specificată de clauza
TO sau peste linii şi coloane, relativ la poziţia curentă, dacă se foloseşte clauza
BY.
Modificarea dimensiunilor unui submeniu, după definirea acestuia se
realizează cu comanda SIZE POPUP dată de sintaxa:
SIZE POPUP<nume submeniu>TO<expN1>,<expN2>/
BY<expN3>, <exp.N4>.
Un alt grup de comenzi referitoare la lucrul cu bare de meniu şi cu
submeniuri sunt cele referitoare la depozitarea acestora în memorie într-o anumită
zonă organizată sub forma de stivă (ultimul intrat, primul ieşit).
Salvarea unei bare de meniu în stiva meniurilor se face cu comanda PUSH
MENU iar refacerea acestuia, adică aducerea sa din stivă, se realizează prin
comanda POP MENU.
Comanda PUSH MENU depune în stivă bara de meniu<nume meniu> iar
comanda POP MENU scoate din stiva bara <nume meniu>, depusă anterior printr-
o comandă PUSH MENU.
Clauza TO MASTER folosită în comanda POP MENU determină
extragerea din stiva primei bare de meniu depusă în aceasta (cea de la bază), după
care stiva se goleşte.
Comanda PUSH POPUP depune în stiva submeniul <nume submeniu>
care va fi scos cu comanda POP POPUP.
Dezactivarea unei bare de meniu sau a unui submeniu se realizează prin
comenzile DEACTIVATE MENU şi DEACTIVATE POPUP, cu sintaxele
DEACTIVATE MENU
DEACTIVATE POPUP
Aceste comenzi nu înlătură meniul din memorie pentru reactivarea sa,
folosind ACTIVATE MENU sau ACTIVATE POPUP, nu este necesară redefinirea
acestuia.
Comanda DEACTIVATE MENU dezactivează bara de meniu curentă iar
comanda DEAFTIVATE POPUP realizează aceeaşi sarcină pentru submeniul
curent.
134
Eliminarea din memorie a barelor de meniuri şi a submeniurilor (deci
eliminarea definitivă a acestora) se realizează cu grupul de comenzi RELEASE
care cuprinde RELEASE MENUS, RELEASE PAD, RELEASE POPUS şi
RELEASE BAR.
Comanda RELEASE MENUS elimina barele de meniuri din <lista
meniuri> din memorie şi de pe ecran sau fereastra curentă. Bara de meniu activă
trebuie dezactivată înainte de eliminarea sa din memorie.
Clauza EXTENDED se foloseşte pentru înlăturarea, pe lângă bara de
meniu respectivă, şi a elementelor subordonate : opţiuni bara, submeniuri, opţiuni,
comenzi introduse cu ON.
RELEASE PAD va înlătura opţiunea bara <nume opţiune bară> sau toate
opţiunile bara, când se foloseşte clauza ALL din bara de meniu <nume meniu>.
RELEASE POPUS înlătură din memorie şi de pe ecran sau fereastra
curentă submeniurile din lista asociată comenzii, sau toate submeniurile definite
dacă această listă este vidă. Submeniul activ trebuie mai întâi dezactivat pentru a
fi eliminat cu comanda RELEASE POPUPS.
RELEASE BAR se foloseşte pentru eliminarea opţiunilor dintr-un
submeniu. Comanda va elimina opţiunea <expN> sau toate opţiunile în cazul
prezentei clauzei ALL, submeniul <nume submeniu>.
Toate barele de meniu vor fi eliminate din memorie şi de pe ecran sau
ferestre prin comanda CLEAR MENUS iar îndepărtarea se va face prin comanda
CLEAR POPUS. De asemenea, barele de meniu şi submeniurile vor fi mai
îndepărtate din memorie şi ecran şi la execuţia comenzii CLEAR ALL.
Pentru schimbarea modelului ecranului, adică a caracterelor folosite pentru
afişarea acestuia, vom folosi comanda SET BORDER.
Controlul accesului la meniul sistem al FoxPro este realizat de comanda
SET SYSMENU având sintaxa:
SET SYSMENU ON / OFF / AUTOMATIC
/TO <listă submeniuri sistem/listă opţiuni bară>
/TO DEFAULT
Pentru ca meniul sistem să fie accesibil în timpul rulării programului, la
executarea unor comenzi de citire de la tastatură (READ, BROWSE etc) se
include comanda SET SYSMENU clauza ON, aceasta fiind şi opţiunea implicită.
Opusă clauzei ON este clauza OFF care nu permite accesul la meniul
sistem în timpul executării unui program.
135
Clauza AUTOMATIC determină afişarea pe ecran a meniului sistem în
timpul rulării unui program.
Clauza TO se foloseşte pentru a elimina unele submeniuri ale meniului
sistem. Vor putea fi accesate numai acele submeniuri prezente în lista <lista
submeniuri> sistem sau care corespund opţiunilor bară din lista <lista opţiuni
bară>. Elementele listei sunt separate prin virgulă.
Folosirea clauzei DEFAULT în comanda SET SYSMENU determină
revenirea la configuraţia implicită a meniului sistem
Funcţia SYS(2013) cu sintaxa:
SYS (2013)
returnează un şir de caractere conţinând denumirile elementelor meniului sistem al
FoxPro adică a barei meniului, a opţiunilor bara, a submeniurilor şi a opţiunilor
submeniurilor.
O opţiune bară a unei bare de meniu sau o opţiune a unui submeniu poate
fi marcată, în funcţie de condiţie, stabilită de utilizator. Caracterul folosit pentru
marcare cât şi condiţia de marcare, adică dacă o opţiune este marcată sau nu, se
stabileşte prin grupul de comenzi SET MARK OF compus din patru comenzi
SET MARK OF MENU, SET MARK OF PAD,
SET MARK OF POPUP şi SET MARK OF BAR.
Comanda SET MARK OF MENU determină folosirea caracterului
<expC> pentru marcarea opţiunilor bara ale barei de meniu <nume de meniu> în
cazul când se introduce în comanda un caracter.
Dacă această comandă va fi urmată de o expresie logică, SET MARK OF
MENU va determina marcarea tuturor opţiunilor bara ale barei de meniu în cazul
valorii T, a expresiei logice şi demarcarea acestora când expresia este evaluată la
valoarea F.
Comanda SET MARK OF PAD se referă la o opţiune bară <nume opţiune
bară> a barei <nume meniu>, această comandă având întâietate faţă de comanda
SET MARK OF MENU.
Comanda SET MARK OF POPUP se referă la toate opţiunile submeniului
<nume submeniu>.
Comanda SET MARK OF BAR se referă doar la opţiunea <expN> a
submeniului <nume submeniu>, această comandă având întâietate faţă de
comanda SET MARK OF POPUP pentru submeniul ce conţine opţiunea
respectivă.
136
Două funcţii, referitoare la marcarea opţiunilor, se pot folosi împreună cu
această comandă MRKPAD() care determină dacă o opţiune bară a unei bare de
meniu este marcată sau nu, şi la funcţia MRKBAR() ce testează marcarea unei
opţiuni a unui submeniu.
Funcţia MRKPAD()are sintaxa:
MRKPAD(<expC1>,< expC2>)
iar funcţia MRKBAR() are sintaxa:
MRKBAR(<expC>, <expN>)
Alegerea opţiunii Marcare determină marcarea tuturor opţiunilor bară ale
barei de meniu, iar alegerea opţiunii bară Demarcare are ca efect demarcarea
acestora. La alegerea opţiunii bară inversare se va inversa starea de marcare a
opţiunilor bară ale barei de meniu.
Grupul de comenzi SET SKIP OF se referă la posibilitatea de accesare a
barelor de meniuri, opţiunilor bară, submeniurilor sau opţiunilor şi conţine
comenzile: SET SKIP OF MENU, SET SKIP OF PAD, SET SKIP OF POPUP şi
SET SKIP OF BAR.
Diferenţa dintre comenzi este dată de elementul la care se referă fiecare,
dar modul de funcţionare este asemănător.
Comanda SET SKIP OF MENU se referă la accesarea barei de meniu
<nume meniu> iar comanda SET SKIP OF PAD acţionează numai asupra opţiunii
bară <nume opţiune bară> a barei de meniu <nume meniu>.
În mod analog, comanda SET SKIP OF POPUP acţionează asupra
submeniului <nume submeniu> iar comanda SET SKIP OF BAR se referă numai
la opţiunea <expN> sau opţiunea sistem <nume opţiune sistem> a submeniului
<nume submeniu>.
În combinaţia cu această comandă se pot folosi două funcţii referitoare, de
asemenea, la posibilitatea de accesare a unei opţiuni sau a unei opţiuni bară.
Acestea sunt SKPPAD() şi SKPBAR() şi au sintaxele:
SKPPAD(<expC1>, <expC2>)
SKPBAR(<expC>, <expN>)
Funcţia SKPPAD() testează opţiunea bară dată de şirul de caractere
<expC2> a barei de meniu specificată prin şirul <expC1>.
Funcţia SKPBAR va testa opţiunea <expN> a submeniului specificat prin
şirul de caractere <expC>
137
10.11.2. Funcţii referitoare la meniuri
Cu ajutorul funcţiilor pentru lucru cu meniuri se pot obţine informaţii

despre:
- opţiunea bară aleasă dintr-o bară de meniu sau opţiunea aleasă dintr-un
submeniu;
- submeniul activ;
- numărul de opţiuni bară a unei bare de meniu sau numărul de opţiuni
dintr-un submeniu;
- textul asociat unei opţiuni bară sau unei opţiuni.
Ultima opţiune bară aleasă dintr-o bară de meniu activă va fi dată, într-un
şir de caractere, de funcţia PAD(). Numele opţiunii respective va fi trecut cu
majuscule, în şirul returnat de funcţie. În cazul când nu există o bară de meniu
activă, funcţia va returna şirul nul.
Pentru submeniuri, funcţia cu care vom afla ultima opţiune aleasă este
funcţia BAR(). Valoarea returnată de funcţie va fi de tip numeric, reprezentând
numărul ultimei opţiuni alese din submeniul activ. În cazul în care nu există nici
un submeniu activ sau s-a ieşit din submeniu cu tasta Escape, funcţia va returna
valoarea 0.
Evaluarea funcţiei MENU() are ca rezultat un şir de caractere conţinând
numerele barei de meniu active, trecut cu majuscule. Şirul vid va fi returnat de
funcţie dacă nu există o bară de meniu activă.
Funcţia POPUP() returnează un şir de caractere reprezentând numele
submeniului activ. Acest şir va fi vid dacă nu este activat nici un submeniu.
Fiecare opţiune bară şi fiecare opţiune are asociat câte un text care este
afişat pe ecran în locul opţiunii respective şi este definit prin clauza PROMPT a
comenzilor DEFINE PAD şi DEFINE BAR.
Funcţia PROMPT() returnează un şir de caractere conţinând textul ultimei
opţiuni bară aleasă dintr-o bară de meniu sau ultimei opţiuni aleasă dintr-un
submeniu. Funcţia va returna şirul vid dacă nu există nici o bară de meniu şi nici
un submeniu activ sau dacă s-a folosit tasta Escape.
Funcţiile PRMPAD() şi PRMBAR() sunt folosite cu scopul de a afla
textul unei opţiuni bară de meniu, şi respectiv, a unei opţiuni de meniu.
Funcţia PRMPAD() returnează o valoare de tip şir de caractere
reprezentând textul asociat opţiunii bară <expC2> a barei de meniu <expC1>.
138
Funcţia PIMBAR() va avea ca rezultat tot o valoare de tip şir de caractere,
reprezentând textul asociat opţiunii cu numărul <expN> a submeniului dat, prin
<expC>.
Numărul de opţiuni bară asociate unei bare de meniu este returnat de
funcţia CNTPAD(), funcţie ce returnează o valoare numerică reprezentând
numărul de opţiuni bară a barei de meniu.
Funcţia CNTBAR() returnează, de asemenea, o valoare numerică
reprezentând numărul de opţiuni ale submeniului <expC>.
Funcţia MENU() returnează numele meniului. La evaluarea construcţiei
CNTPAD(MENU() ) vom obţine numărul de opţiuni bară ale meniului, iar
evaluarea lui CNTBAR(POPUP() )va duce la returnarea numărului de opţiuni ale
submeniului.
Construcţia GETPAD (MENU (), i) va da numele celei de-a „i”-a opţiune
a meniului, iar prin GETBAR(POPUP(), i) vom obţine numele opţiunii „i”-a a
submeniului.
Funcţiile PRMPAD() şi PRMBAR() sunt folosite pentru a trece de la unele
opţiuni (bară şi respectiv simplă) la textul asociat acesteia prin construcţiile :
PRMPAD(MENU(), GETPAD(MENU(), i)
PRMBAR(POPUP), GETBAR(POPUP) i).
U10.12. Programe. Execuţia programelor
Un program reprezintă o succesiune de instrucţiuni, realizată în

conformitate cu regulile limbajului de programare folosit, care rezolvă o anumită
problemă, îndeplineşte o anumită sarcină, printr-un anumit algoritm.
Un program FoxPro este depus pe disc într-un fişier. Când se doreşte
execuţia instrucţiunilor programului, fişierul este transformat într-o formă
intermediară (compilare) care interpretată de FoxPro.
Execuţia unui program se realizează prin comanda DO, având sintaxa:
DO<fişier>
[WITH<listă parametri>]
[IN<fişier>]
Această comandă execută programul conţinut în fişierul <fişier>. Dacă
fişierul nu are prevăzută extensia, atunci se vor căuta pe disc următoarele fişiere,
în această ordine:
139
<fişier>EXE - program executabil
<fişier>APP - aplicaţie
<fişier>FXP forma compilată a programului
<fişier >PRG- programul sursă.
<Fişier>PRG reprezintă fişierul sursă în care a fost depus programul,
conţinutul acestuia fiind transmis de utilizator la scrierea programului. Execuţia
unui program sursă presupune mai întâi compilarea sa, după această fază
obţinându-se forma compilată a programului, care va fi interpretată de FoxPro.
Această formă compilată reprezintă tot un fişier pe disc, obţinut automat ca
rezultat al compilării şi care poartă numele <fişier>FXP.
Un program poate conţine mai multe comenzi DO, obţinându-se astfel Do-
uri îmbrăcate, pe mai multe nivele, limita maximă pentru aceste nivele fiind 32.
Execuţia programului se va opri în una din următoarele situaţii:
- la execuţia unei comenzi RETURN, CANCEL, QUIT;
- când se întâlneşte sfârşitul fişierului;
- când se întâlneşte o altă comandă DO.
Comanda RETURN având sintaxa:
RETURN[<EXPR>/TO MASTER/TO<nume rogram>]
termină execuţia programului returnând controlul la programul apelant de cel mai
înalt nivel sau la un alt program (specificat prin clauza TO).
<expr> reprezintă valoarea transmisă de programul a cărui execuţie se
încheie către programul căruia i se predă controlul. Dacă <expr>lipseşte se va
returna valoarea logică T.
<nume program> reprezintă numele unui program care va prelua controlul
de la cel care se încheie cu comanda RETURN.
Comanda CANCEL determină terminarea execuţiei programului curent şi
predarea controlului în fereastra de comenzi.
Suspendarea execuţiei unui program (cu posibilitatea de reluare) se
realizează prin comanda SUSPEND cu sintaxa SUSPEND continuarea rulării unui
program suspendat făcându-se prin comanda RESUME, cu sintaxa RESUME. De
asemenea execuţia unui program se va încheia la întâlnirea comenzii QUIT, cu
sintaxa QUIT care determină şi ieşirea din mediul FoxPro.
Numele unui program este obţinut prin funcţia PROGRAM() având
următoarea sintaxă: PROGRAM ([<expN>]).
140
Dacă apelul funcţiei se face fără nici un parametru, aceasta va returna un
şir de caractere conţinând numele programului în execuţie sau numele ultimului
program executat când a apărut o eroare.
O funcţie asemănătoare este SYS(16) aceasta returnând într-un şir de
caractere numele programului, cu tot cu calea completă unde acesta se află.
Dacă în cele două funcţii se include <expN>, aceasta va desemna nivelul
programului curent executat ce fa fi returnat de funcţii.
10.12.1. Proceduri şi funcţii definite de utilizator
Execuţia unu program din interiorul altui program, folosind comanda DO,
reprezintă un pas important în structurarea aplicaţiilor de dimensiuni mari.
Pe măsură ce creşte dimensiunea unei aplicaţii (creşte numărul liniilor de
program ale aplicaţiei), testarea şi depanarea acestuia devine din ce în ce mai
dificilă datorită numărului mare de variabile.
Astfel, s-a trecut la gruparea unor instrucţiuni în module separate, aceste
module fiind independente între ele.
Modulele de acest tip pot fi create şi în interiorul fişierului ce conţine
programul formând aşa-numitele proceduri şi funcţii definite de utilizator (UDF
-User Defined Functions).
Datorită independenţei unui modul faţă de celelalte module, acesta poate fi
executat de mai multe ori în cadrul unui program prin câte o instrucţiune de
apelare a modulului în fiecare poziţie dorită.
Se introduce astfel o modalitate de execuţie a unui grup de instrucţiuni în
mai multe zone ale unui program, fără a rescrie aceste instrucţiuni la fiecare
folosire.
O funcţie reprezintă un grup independent de instrucţiuni care primeşte un
set de parametrii de la programul apelant şi returnează acestuia o valoare ca
rezultat al prelucrărilor asupra parametrilor transmişi.
O funcţie definită de utilizator poate intra în componenţa unei expresii ca
operand, analog funcţiilor standard din FoxPro.
O procedură reprezintă de asemenea un grup de instrucţiuni ce primeşte de
la programul apelant un grup de parametrii, realizează anumite prelucrări, după
care se revine la programul apelant.
141
O procedură definită de utilizator nu poate intra în alcătuirea unei expresii
ca operand, fiind analoagă comenzilor standard din FoxPro.
La definirea unei funcţii sau proceduri se stabilesc prelucrărilor ce au loc
în interiorul ei, parametrii care se primesc spre prelucrare şi rezultatele ce se vor
transmite după prelucrare.
La apelul unei funcţii sau proceduri apare doar numele care identifică
respectiva funcţie sau procedură însoţit eventual de lista parametrilor ce se vor
transmite.
Termenul de independent din definiţiile funcţiilor şi procedurilor are o
importanţă deosebită: variabilele definite în interiorul funcţiilor şi procedurilor
sunt cunoscute doar în acest domeniu, în sensul că pentru programul ce apelează
funcţia sau procedura, aceste variabile nu există.
Definirea unei funcţii se face prin intermediul comenzii FUNCTION care
are sintaxa FUNCTION <nume funcţie> unde <nume funcţie> reprezintă numele
care se atribuie funcţiei nou definite şi care va fi folosit la fiecare apel al acesteia
pentru identificarea printre celelalte funcţii a celei dorite.
Definirea procedurilor se realizează prin comanda PROCEDURE cu
sintaxa: PROCEDURE <nume procedură>.
Instrucţiunile unei rutine vor începe imediat după comanda FUNCTION
sau PROCEDURE şi se vor întinde până la întâlnirea unei noi comenzi
FUNCTION sau PROCEDURE, sau până la întâlnirea sfârşitului de fişier.
Apelul unei funcţii se face prin numele acesteia, urmat, între paranteze
rotunde, de lista parametrilor prin care se comunică funcţia. La executare, în locul
acestei construcţii se va introduce valoarea returnată de funcţie, ca rezultat al
prelucrărilor din interiorul acesteia.
O procedură se execută prin comanda DO urmată de numele procedurii (pe
poziţia lui <fişier>, iar parametrii prin care programul comunică cu aceasta se
introduc în lista clauzei WITH a acestei comenzi.
Terminarea execuţiei unei rutine se face fie după execuţia ultimei
instrucţiuni a acesteia, fie la întâlnirea unei dintre comenzile RETURN,
CANCEL, SUSPEND, QUIT.
Procedurile şi funcţiile unui program se introduc de regulă, după ultima
instrucţiune a programului, în acelaşi fişier cu acesta. Dar acestea se pot introduce
în fişiere separate care vor fi asociate programului apelant prin comanda SET
PROCEDURE.
142
Această comandă asociază programului, în execuţie, fişierul <fişier> (cu
extensia implicită PRG), unde se vor căuta procedurile care nu se găsesc în
fişierul programului apelant.
Comanda SET PROCEDUTE TO, fără alţi parametrii, determină
închiderea fişierului de proceduri curent asociat programului în execuţie.
Comanda CLOSE PROCEDURE, de asemenea închide fişierul de
proceduri curent.
La execuţia unei proceduri, folosind comanda DO, căutarea acestuia se
face în următoarea ordine:
- mai întâi se caută în fişierul care conţine comanda DO de apelare a
procedurii;
- dacă nu se găseşte, se caută apoi în fişierul de proceduri deschis cu
comanda SET PROCEDURE,
- şi în ultima instanţă se caută pe rând în programele în curs de execuţie pe
diferite nivele, până la programul de nivel 1.
Abia după aceste etape s-au încheiat fără succes, se va căuta fişierul cu
numele identic cu al procedurii, considerând comanda ca determinând execuţia
unui program.
Pentru ca o căutare a unei proceduri să se facă numai într-un anumit fişier,
acesta se va include în clauza IN a comenzii DO:IN <fişier>.
10.12.2. Variabile globale şi variabile locale
Variabilele folosite într-un program sunt prin diferite comenzi FoxPro

(STORE, GET, DEFAULT...) şi ele există în memorie atâta timp cât programul
este în curs de rulare la terminarea acestuia fiind eliminate automat.
Două tipuri de variabile pot fi referite într-un modul : variabile globale şi
variabile locale.
Variabilele globale (publice) pot fi accesate şi modificate în orice modul în
curs de execuţie de pe un nivel inferior, egal sau superior nivelului modulului
curent.
Variabilele locale (private) nu pot fi accesate decât în modulul curent şi în
cele subordonate acestuia, deci în modulele de pe nivelele mai mari sau egale cal
modulului curent.
143
Pentru ca într-un modul să se declare un set de variabile private, acestea se
includ în comanda PRIVATE, cu sintaxele:
PRIVATE<lista variabile>
PRIVATE ALL[LIKE<masca>/EXCEPT<masca>]
Prin această comandă se declară ca fiind private (dar nu se creează)
variabilele din< listă variabile>, toate variabilele care se potrivesc cu <masca>
(când se foloseşte clauza LIKE) sau toate variabilele cu excepţia celor care se
potrivesc cu <masca> ( la folosirea clauzei EXCEPT).
Variabilele globale se definesc prin comanda PUBLIC, cu sintaxele:
PUBLIC<listă variabile>
PUBLIC [ARRAY]<masiv1>(expN1>[, <expN2>])
[,<masiv2>(<expN3>[, (<expN4>])]...
Spre deosebire de PRIVATE care nu creează variabilele la care se referă,
comanda PUBLIC, odată cu declararea variabilelor respective le şi creează pe
acestea.
Un tip special de variabile este tipul regional, asemănător cu cel privat.
Acest tip se foloseşte pentru a folosi variabile cu acelaşi nume în „regiuni” diferite
ale programului.
Acest tip se declară prin comanda REGIONAL cu două forme ale sintaxei:
# REGION<număr>
REGIONAL<listă variabile>
Pentru a folosi două variabile în acelaşi program, acestea trebuie definite
în listele de variabile ale comenzilor REGIONAL, în două regiuni separate ale
programului.
Regiunile se definesc prin prima formă a comenzii # REGION,
identificarea fiecărei regiuni făcându-se printr-un număr de la 0 la 31.
O regiune se întinde de la comanda # REGION care desemnează începutul
unei regiuni până la prima comandă #REGION care urmează acesteia, sau până la
sfârşitul fişierului.
10.12.3. Transferul de parametri la şi de la module de program
În FoxPro sunt implementate două metode de transmitere a parametrilor la

rutine, programe:
144
- prin referinţă, în care variabila transmisă este afectată de eventualele
modificări aduse în subprogram;
- prin valoare, când o eventuală modificare a variabilei în subprogram nu
afectează valoarea acesteia în programul apelant.
Transmisia parametrilor la un subprogram se desfăşoară astfel:
- se stabilesc variabilele care se vor transmite ca parametrii, într-o ordine
stabilită de programator la conceperea programului;
- se stabileşte un set de variabile locale subprogramului care vor prelua
valorile variabilelor transmise ca parametrii de la programul apelant;
- corespondenţa între variabilele transmise din programul apelant şi cele
locale ale subprogramului se face prin poziţia în două liste şi anume: listă cu
parametrii de apel a subprogramului, şi respectiv lista variabilelor locale,
specificată prin comanda PARAMETERS;
- în modulul apelant se lucrează cu variabilele locale respective;
- dacă tipul transmisiei este de referinţă, la sfârşitul executării
subprogramului, conţinutul variabilelor este trecut în variabilele corespunzătoare
transmise ca parametrii;
- dacă avem o transmise prin valoare, această ultimă copiere nu mai are
loc, deci variabilele de apelare nu vor mai fi actualizate cu noile valori ale
variabilelor locale corespunzătoare.
Lista variabilelor transmise ca parametrii este stabilită fie prin clauza
WITH a comenzii DO, în cazul apelului unui subprogram sau a unei proceduri, fie
prin lista dintre parantezele rotunde ce urmează numelui funcţiei, când avem un
apel în funcţie.
Pentru a stabili în ce variabile locale se încarcă parametrii transmişi se
foloseşte comanda PARAMETERS, cu sintaxa:
PARAMETERS <listă variabile locale>
Această comandă, care trebuie să fie prima comandă a uni modul (în cazul
când acesta există) defineşte lista de variabile locale care vor prelua parametrii
transmişi de la programul apelant.
Lista variabilelor locale trebuie să aibă totdeauna mai multe elemente (sau
cel mult egal) decât lista parametrilor transmişi, pentru ca fiecare parametru să
aibă un corespondent în subprogram.
Numărul de parametrii transmişi programului, procedurii sau funcţiei
curente este returnat de funcţia PARAMETERS ().
145
În ceea ce priveşte metoda folosită la transmisia parametrilor există
următoarele reguli:
- la programe parametrii se transmit implicit prin referinţă;
- la proceduri şi funcţii se foloseşte metoda transmiterii parametrilor prin
valoare.
Pentru a schimba metoda implicită de transmitere a parametrilor la
proceduri şi funcţii se poate folosi comanda SET SDFPARMS (User Defined
Parameters), cu sintaxa:
SET UDFPARMS TO VALUE | REFERENCE
SET UDFPARMS TO VALUE determină transmiterea prin valoare a
parametrilor, ca metodă implicită, iar SET UDFPARMS TO REFERENCE face ca
transmisia parametrilor să se facă implicit prin referinţă.
Pentru a forţa transmiterea unui parametru prin valoare la apelul unei
funcţii, acesta se include între paranteze rotunde, iar pentru forţarea transmiterii
unui parametru prin referinţă, acesta va fi precedat de caracterul „ „.
10.12.4. Compilarea
Un fişier sursă pentru a fi executat, mai întâi trebuie transformat într-o

formă intermediară, compilat. Această operaţie se face automat de FoxPro la
execuţia unei comenzi DO când programul de executat nu a fost compilat anterior
şi poate fi realizată explicit de utilizator prin intermediul comenzii COMPILE:
COMPILE <fişier> |<masca>[ENCRYPT][NODEBUG]
Se va compila fie prin fişierul <fişier>, fie mai multe fişiere, a căror
denumire se potriveşte cu <masca>.
În funcţie de tipul caracterului sursă, fişierul obiect (forma compilată a
programului) va avea o extensie specifică, având următoarele corespondenţe:
EXTENSIE
TIP FIŞIER EXTENSIE SURSĂ DESTINAŢIE
COMPILATĂ
Program .PRG .FXP
Cod de ecran .SPR .SPX
Cod de meniu .MPR .MPX
Fişier de filtru .QPR .QPX
Fişier format .FMT .PRX
Orice alt fişier .FXP
Clauza ENCRYPT determină blocarea posibilităţii de refacere a fişierului
sursă original din forma compilată (fişierul obiect).
146
Clauza NODEBUG determină compilarea programului fără informaţiile de
depanare reducând astfel mărimea fişierului obiect, dar eliminând posibilitatea
depanării respectivului program.
Comanda CLEAR PROGRAM goleşte bufferul de compilare al FoxPro şi
este folosită doar pentru compatibilitatea cu versiunile anterioare.
SET LOGERRORS cu sintaxa:
SET LOGERRORS ON | OFF
determină (ON) sau inhibă (OFF) crearea, la compilare, a unui fişier în care se
scriu toate mesajele de eroare apărute în timpul acestui proces. Fişierul creat va
purta acelaşi nume cu al programului sursă şi va avea extensia .ERR.
10.12.5. Depanarea programelor şi tratarea erorilor
În scrierea unui program deseori apar erori datorate fie neatenţiei, fie unei
cunoaşteri insuficiente a limbajului de programare, fie neluării în seamă a unor
cazuri particulare ale evoluţiei programului.
Două mari clase de erori pot apare la execuţia unui program:
- erori de sintaxă, când programul este incorect scris, ducând fie la
întreruperea rulării, fie la executarea unor rutine pentru tratarea erorilor;
- erori de rulare, când programul este corect scris, dar el nu funcţionează
cum dorim, rezultatele obţinute nefiind cele aşteptate.
Primul tip de erori sunt mai uşor de detectat şi de corectat, pe când cele din
cea de-a doua categorie necesită mai mult timp.
La rularea unui program, apariţia unei erori de sintaxă determină de obicei,
întreruperea procesului de execuţie şi afişarea unei mesaj de eroare, indicând tipul
erorii apărute şi cerând utilizatorului luarea unei decizii astfel:
- întreruperea programului, acţionând declanşatorul <Cancel>;
- suspendarea execuţiei programului, obţinută prin acţionarea
declanşatorului <Suspended>;
- continuarea execuţiei, ignorând eroarea apărută, prin alegerea
declanşatorului <Ignore>.
Detectarea erorilor de rulare presupune tehnici de lucru mai avansate, cum
ar fi rularea pas cu pas, folosirea punctelor de întrerupere, vizualizarea
conţinutului unor variabile în paralel cu executarea programelor etc.
147
Rularea pas cu pas a unui program reprezintă o tehnică specială constând
în executarea unei singure instrucţiuni a programului la o comandă a utilizatorului
(acţionarea unei taste). În intervalul de timp dintre execuţia a două instrucţiuni
consecutive, programatorul poate observa eventualele funcţionări incorecte ale
programului, detectând astfel cauzele ce au dus la erorile de rulare respective.
Punctele de întrerupere reprezintă poziţii fixe în cadrul programului de
depanat, la care execuţia programului respectiv se opreşte, utilizatorul având astfel
posibilitatea de a verifica starea de moment a variabilelor din program, modul
cum decurge execuţia programului, în vederea detectării eventualelor surse de
eroare.
Aceste două tehnici prezentate mai sus sunt disponibile prin intermediul
ferestrei Trace, care se deschide prin selectarea opţiunii Trace din cadrul
submeniului Window.
Fereastra Trace, are la partea superioară propriul său meniu care va fi
explicitat odată cu prezentarea modului de depanare a unui program.
Pentru ca un program să fie depanat prin fereastra Trace, acesta trebuie
mai întâi deschis în această fereastră, acest lucru realizându-se prin opţiunea
Open, de pe submeniul Program. Ca urmare a alegerii acestei opţiuni, pe ecran va
apare o fereastră de dialog, în care utilizatorul va specifica programul de depanat.
După deschiderea programului se poate trece la execuţia acestuia, aceasta
putându-se realiza în mai multe rânduri:
- pas cu pas, câte o instrucţiune la fiecare comandă a utilizatorului;
- până la un punct de întrerupere care va determina suspendarea
programului;
- executare continuă, al viteza maximă;
- executarea continuă, cu viteza controlată, când după executarea fiecărei
instrucţiuni se face o pauză, după care se continuă rularea.
Rularea pas cu pas a unui program deschis cu fereastra Trace decurge
astfel: pentru execuţia fiecărei instrucţiuni a programului utilizatorul va alege
opţiunea Over sau Step din meniul ferestrei Trace, acestea determinând execuţia
instrucţiunii curente după care se aşteaptă o nouă comandă de executare de la
utilizator.
Diferenţa dintre cele două opţiuni este dată de modul de tratare a
comenzilor de apel al unei rutine:
148
- Step determină executarea unei instrucţiuni a programului, iar în cazul
când aceasta este un apel al unei rutine, se va trece în interiorul rutinei, pentru
executarea instrucţiunilor acesteia;
- Over execută tot o instrucţiune, dar când aceasta este un apel al unei
rutine (program, procedură, funcţie) aceasta este executată în întregime, într-un
singur pas, fără a trece la executarea pas cu pas a instrucţiunilor respectivei rutine.
Instrucţiunea curentă care va fi executată prin intermediul opţiunilor Step
sau Over va apare pe ecran supraluminată, indicând această stare a liniei
respective.
În combinaţie cu operaţiunea Step se foloseşte şi opţiunea bară Out, care
determină executarea continuă a restului de instrucţiuni din programul curent,
urmând ca după revenirea în programul, rutina apelantă, execuţia să fie suspendată
pe prima instrucţiune care urmează instrucţiunii de apel a rutinei.
La modalitatea de rulare a unui program prin puncte de întrerupere, pentru
stabilirea acestora, în care execuţia programului va fi suspendată, se va deplasa
cursorul pe linia respectivă, după care se va tasta Space sau Enter. Linia va fi
marcată astfel ca reprezentând un punct de întrerupere a programului. O nouă
acţionare a tastei Space sau Enter, când cursorul se află pe o linie care conţine un
punct de întrerupere, va determina anularea punctului de întrerupere respectiv,
linia revenind la starea iniţială.
Ştergerea, anularea tuturor punctelor de întrerupere se poate face prin
alegerea opţiunii Clear Breakpointes de pe submeniul Program.
Un punct de întrerupere nu determină terminarea execuţiei programului, ci
numai suspendarea acesteia, până la o nouă comandă a utilizatorului cu privire la
continuarea rulării.
Opţiunea bară Resume a meniului ferestrei Trace determină continuarea
execuţiei continue până la un nou punct de întrerupere, până la sfârşitul
programului sau până la acţionarea tastei Escape.
O modalitate specială de rulare a programului este obţinută prin alegerea
opţiunii Throttle de pe submeniul Program, constând în executarea continuă a
programului, instrucţiune cu instrucţiune, după executarea fiecărei instrucţiuni
făcându-se o pauză, stabilită de utilizator.
Oprirea execuţiei programului se poate face în orice moment, selectând
opţiunea Cancel a submeniului Program.
149
În paralel cu executarea unui program în fereastra Trace se poate vizualiza
conţinutul unor variabile folosite în program, sau chiar rezultatul evaluării unor
expresii folosind aceste variabile, pin intermediul ferestrei Debug.
Se recomandă ca ferestrele Trace şi Debug să fie deschise şi vizibile
simultan pe ecran, urmărindu-se astfel efectul fiecărei instrucţiuni executate în
fereastra Trace asupra variabilelor in fereastra Debug.
Fereastra Debug este formată din două părţi, astfel : în partea dreaptă se
introduc variabilele şi expresiile care se doresc vizualizate în timpul executării
programului, în partea stângă apărând valorile de moment al variabilelor sau
expresiilor respective.
De asemenea în fereastra Debug se pot specifica puncte de întrerupere a
programului dependente de valorile variabilelor sau expresiilor din fereastra
respectivă, spre deosebire de punctele de întrerupere stabilite în fereastra Trace,
care reprezintă puncte fixe ale programului, independente de valorile variabilelor.
Pentru a poziţiona un astfel de punct de întrerupere, în dreptul variabilei
sau expresiei dorite, pe bara se separă cele două părţi ale ferestrei se va poziţiona
un marcaj. Acest lucru se va realiza fie cu mouse-ul, poziţionând cursorul acestuia
în poziţia dorită şi acţionând butonul stâng, fie prin intermediul tastaturii,
deplasându-ne pe bara separatoare folosind tasta Tab, poziţionându-ne în dreptul
variabilei sau expresiei dorite, cu ajutorul săgeţilor direcţionate şi acţionând tasta
Space, pentru marcare.
Execuţia programului se va suspenda ori de câte ori valoarea variabilei sau
expresiei corespunzătoare unui astfel de punct de întrerupere se va modifica.
U10.13. Programarea structurată
În FoxPro au fost implementate principalele comenzi şi funcţii ale

programării structurate, care permit:
- executarea unui grup de instrucţiuni de mai multe ori;
- executarea condiţionată a unor instrucţiuni, în funcţie de rezultatul
evaluării unei expresii logice.
Primul tip de comenzi care determină executarea repetată a uneia sau a mai
multor instrucţiuni, alcătuiesc aşa numitele „bucle” şi este reprezentat de
comenzile FOR, ENDFOR, DO WHILE..., ENDDO şi SCAN.....ENDSCAN.
150
Al doilea tip, condiţionând executarea unor instrucţiuni de rezultatele
evaluării unor expresii logice, este reprezentat de instrucţiunile condiţionate de
decizie, având în componenţă: IF..., ENDIF, IIF (), DO CASE.....ENDCASE.
Comanda IF .... ENDIF are două forme care vor permite executarea unor
instrucţiuni numai dacă este respectată o condiţie dată şi executarea fie a unui
grup de instrucţiuni, fie a altui grup de instrucţiuni, în funcţie de rezultatul
evaluării unei expresii logice.
Comanda are sintaxa:
IF <expL>
<instrucţiuni1>
[ELSE]
<instrucţiuni2>
ENDIF
La începutul execuţiei comenzii se va evalua expresia logică <expL> şi , în
funcţie de rezultatul evaluării, vom avea:
- dacă <expL> este .T se va executa grupul de instrucţiuni <instrucţiuni1>,
după care execuţia se va termina;
- în cazul valorii .F a expresiei logice apar două cazuri:
a) dacă există clauza ELSE în comandă, se vor executa instrucţiunile din
grupul <instrucţiuni2>, după care execuţia se termină;
b) în absenţa clauzei ELSE nu se execută nici o instrucţiune terminându-se
imediat.
Un efect asemănător de selecţie se face prin comanda IIF(), având sintaxa:
IIF(<expL>, <expr1>, <expr2>)
Această funcţie evaluează expresia logică <expL> şi în funcţie de
rezultatul obţinut, returnează valoarea uneia din expresiile <expr1> şi <expr2>:
- returnează valoarea obţinută prin evaluarea expresiei <expr1> dacă
<expL> este evaluată la .T;
- returnează rezultatul evaluării expresiei <expr2> când <expL> se
evaluează la .F.
Cele două expresii nu trebuie să aibă neapărat acelaşi tip, acestea putând fi
de tip şir de caractere, dată calendaristică, logic sau numeric.
Mai multe comenzi IF....ENDIF pot fi imbricate, incluse una în alta,
obţinându-se condiţionarea unui grup de instrucţiuni prin mai multe expresii
logice, sau obţinându-se selecţii diverse între mai multe grupuri de instrucţiuni.
151
Un tip de selecţie între mai multe grupuri de instrucţiuni este dat de
comanda DO CASE...ENDCASE, având sintaxa:
DO CASE
CASE <expL1>
<instrucţiuni>
[CASE<expL2>
<instrucţiuni2>
......................
CASE <expLN>
<instrucţiuniN>]
[ORHERWISE
<instrucţiuni>
ENDCASE
Comanda va determina execuţia grupului de instrucţiuni pentru care
expresia logică corespunzătoare are valoarea .T. Execuţia comenzii va decurge în
modul următor: se evaluează prin expresie logică <expL1> şi, dacă valoarea
obţinută este .T, se execută grupul de instrucţiuni <instrucţiuni1>. Dacă expresia
logică <expl1> are valoare .F, se trece evaluarea următoarei expresii logice.
După găsirea primei expresii logice cu valoarea .T şi executarea grupului
de instrucţiuni corespunzător, execuţia comenzii se încheie continuând cu prima
comandă de după ENDCASE.
Dacă nici una din expresiile, expL1>, <expL2>, ...<expLN> nu are
valoarea .T, apar două cazuri:
- când nu există clauza OTHER WISE, execuţia comenzii se încheie;
- în prezenţa clauzei OTHERWISE, se va executa grupul de instrucţiuni
<instrucţiuni>, după care se trece se trece la prima comandă de după ENDCASE.
Executarea repetată a unui grup de instrucţiuni reprezintă unul din
principalele avantaje ale elaborării de programe, fără de care multe din probleme
nu ar putea fi rezolvate, sau s-ar rezolva foarte greu.
Comenzile FoxPro care realizează „buclele” din teoria programării sunt
FOR....ENDFOR, DO WHILE.....ENDDO, şi SCAN.....ENDSCAN, acestea
împărţindu-se la rândul lor în două grupe:
- comenzi pentru bucle cu un număr dat de paşi, în care un grup de
instrucţiuni se execută de un număr dat de ori: FOR, SCAN;
152
- comenzi folosite pentru bucle cu un număr nedefinit de paşi, în care
numărul de executări a grupului de instrucţiuni este variabil, fiind dependent de o
condiţie asociată comenzii: DO WHILE.
Comanda FOR.....ENDFOR determină executarea repetată a grupului de
instrucţiuni <instrucţiuni>, contorizarea acestor paşi fiind făcută printr-o variabilă
<var>.
Valoarea iniţială a variabilei contor va fi dată de evaluarea expresiei
<expN1>. După fiecare execuţie a grupului de instrucţiuni <instrucţiuni>,
variabila va fi incrementată sau decrementată, cu o valoare constantă, dată de
evaluarea expresiei <expN3>, dacă este prezentă clauza STEP sau 1 când STEP
lipseşte (absenţa clauzei STEP este echivalentă cu construcţia STEP1).
Deci la prima execuţie a grupului de instrucţiuni, <var> va avea valoarea
<expN1>, la a doua execuţie <expN1>+<expN3>, la a treia execuţie <expN1>+
<expN3>+<expM3> şi aşa mai departe.
Când valoarea variabilei <var> creşte peste valoarea expresiei <expN2>
(strict mai mare), în cazul unei valori pozitive a lui <expN3>, sau scade valoarea
<expN2> (strict mai mică), pentru o valoare negativă a expresiei <expN3>, se va
ieşi din buclă, programul continuând următoarea comandă după ENDFOR.
EXIT determină ieşirea forţată din buclă şi continuarea execuţiei
programului cu prima comandă care urmează după ENDFOR, indiferent de
valoarea variabilei contor.
LOOP care determină saltul peste următoarele instrucţiuni ale buclei
(dintre LOOP şi ENDFOR), incrementarea sau decrementarea contorului de
instrucţiuni, dacă se respectă condiţia de rămânere în buclă.
Exemplu:
sumă = 0
FORi =TO 10
sumă = sumă +1
IF i = 5
EXIT
ENDIF
ENDFOR
Programul funcţionează astfel: se execută comanda sumă= sumă +1 de
cinci ori, pentru i = 1,2,3,4 şi 5. La i =5 este respectată condiţia IF şi deci va fi
153
executată comanda EXIT care determină saltul la ultima instrucţiune a
programului (care afişează rezultatul).
Un tip special de buclă, foarte asemănătoare cu FOR ...ENDFOR, dar
specializată în lucrul pe o bază de date, este reprezentată de comanda SCAN...
ENDSCAN, cu sintaxa de forma:
SCAN[NOOPTIMIZE]
[<domeniu> ][FOR<expL1>][WHILE<expL2>]
[<instrucţiuni>
[LOOP]
[EXIT]
ENDSCAN
Această comandă realizează parcurgerea bazei de date curente şi
executarea grupului de instrucţiuni <instrucţiuni>, pentru fiecare înregistrare care
aparţine domeniului specificat prin <domeniu>, FOR sau WHILE.
Clauzele LOOP şi EXIT au acelaşi efect în cazul comenzii FOR....
ENDFOR, iar clauza NOOPTIMIZE inhibă optimizarea RUSHMORE.
Exemplu:
SCAN
<instrucţiuni>
ENDSCAN
are acelaşi efect cu
FOR i = to RECCOUNT ()
GOTO i
<instrucţiuni>
ENDFOR
iar comanda
SCAN;
NEXT 10 FOR MOD(RECNO(),2) =0
<instrucţiuni>
ENDSCAN
va fi echivalentă cu
FOR i=RECNO() TO RECNO () + 9
IF MOD (RECNO(), 2) =0
<instrucţiuni>
ENDIF
154
ENDFOR
Expresia MOD (RECNO(),2)=0 are valoarea .T dacă înregistrarea curentă
are un număr par şi valoarea .F, în caz contrar.
Cel de-al doilea tip de buclă, cu un număr nedefinit de paşi, este
implementat în FoxPro prin comanda DO WHILW....ENDDO, având sintaxa:
DO WHILW <expL>
<instrucţiuni>
[LOOP]
[EXIT]
ENDDO
Această comandă determină execuţia repetată a grupului de instrucţiuni
<instrucţiuni>, atâta timp cât valoarea expresiei logice este .T.
Execuţia comenzii se va desfăşura astfel se evaluează expresia <expL> şi,
dacă aceasta are valoarea .F, execuţia comenzii se încheie. Dacă valoarea acesteia
este .T, se vor executa instrucţiunile din <instrucţiuni>. La întâlnirea lui ENDDO
se încheie, programul continuând cu prima instrucţiune de după ENDDO.
Comenzile LOOP şi EXIT au aceeaşi semnificaţie ca şi la comanda FOR,
prima determinând ignorarea restului de comenzi şi reevaluarea lui <expL>, iar
cea de-a doua determinând ieşirea forţată din buclă, indiferent de valoarea
expresiei logice <expL>.
U10.14. Lucrul cu fişiere
Există două moduri de lucru cu fişierele:

- lucrul la nivel înalt, când operaţiile elementare sunt executate de FoxPro
în mod automat, eliberând astfel programatorul de grija evidenţei tuturor
acţiunilor de rutină, de amănunt;
- lucrul la nivel coborât, când programatorului i se oferă posibilitatea de a
controla toate operaţiile referitoare la lucrul cu fişiere.
Copierea unui fişier se realizează prin comanda COPY FILE, cu sintaxa:
COPY FILE <fişier1>TO<fişier2>
în care <fişier1> este fişierul de copiat, iar <fişier2> reprezintă copia nou creată
prin execuţia comenzii.
Redenumirea unui fişier, este de asemenea o operaţie importantă în lucrul
cu fişiere, care se realizează prin intermediul comenzii RENAME:
155
RENAME <fişier1>TO<fişier2>
<fişier 1>reprezintă fişierul care se va redenumi, noul nume fiind <fişier2>.
Comanda TYPE, cu sintaxa:
TYPE <fişier1>
[AUTO]
[WRAP]
[TOPRINTER|TO FILE <fişier2>] [NUMBER]
afişează conţinutul fişierului <fişier1> pe ecran sau în fereastra activă şi la
imprimantă (dacă se specifică clauza TO PRINTER) sau într-un alt fişier <fişier2>
(desemnat de clauza TO FILE).
Clauza NUMBER determină plasarea numărului liniei la începutul fiecărei
linii a fişierului.
Clauza AUTO şi WRAP controlează modul de afişarea a textului din fişier,
AUTO referindu-se la alinierea liniilor, paragrafelor în formatul de afişare, iar
WRAP determinând afişarea pe rândul următor a unui cuvânt care nu mai încape
în rândul curent.
Modificarea conţinutului unui fişier se face prin intermediul comenzilor
MODIFY COMMAND sau MODIFY FILE care deschide ferestre de editare în
care încarcă fişierul de modificat (conţinutul acestuia).
MODIFY COMMAND <fişier> | MODIFY FILE [<fişier>]
[NOEDIT]
[NOWAIT]
[RANGE <expN1>,<expN2>]
[[WINDOW<nume fereastră> ]
[IN [WINDOW] <nume fereastră2> | SCREEN]]
[SAVE]
ERASE <fişieri>| ?
Fişierul modificat este <fişieri> la comanda MODIFY COMMAND acesta
având extensia implicită .PRG. Clauza NOEDIT se foloseşte pentru a împiedica
utilizatorul a modifica conţinutul fişierului, iar clauza NOWAIT determină
continuarea execuţiei programului după deschiderea ferestrei de editare, fără a mai
aştepta modificările utilizatorului.
RANGE permite editarea caracterelor dintre poziţiile <expN1> inclusiv şi
<expN2> exclusiv din cadrul fişierului respectiv. Clauza SAVE păstrează fereastra
de editare pe ecran şi după terminarea comenzii respective.
156
Ştergerea fişierelor se face prin două comenzi: DELETE FILE şi ERASE.
Ambele comenzi şterg fişierul <fişier> de pe disc, din directorul curent
sau din alt director, care se specifică împreună cu <fişier>.
Selectarea fişierului de şters se poate face într-o fereastră de dialog, dacă în
comandă se specifică ?
În funcţie de starea lui SET SAFETY ON|OFF vom fi (ON) sau nu (OFF)
avertizaţi înainte de ştergerea fişierului sau de o eventuală scriere peste conţinutul
unui fişier existent pe disc.
Afişarea unei liste dintr-un director de pe un anumit disc se poate face prin
comanda DIR sau DIRECTORY, cu sintaxa:
DIR | DIRECTORY [[ON]<disc:>]
[[LIKE][<cale>][<masca>]]
[TO PRINTER | TO FILE <fişier>]
Vor fi afişate fişierele de pe discul <disc:> din directorul dat de <cale>,
care se potrivesc cu <masca>. Afişarea se va face pe ecran imprimantă (TO
PRINTER) sau în fişierul <fişier> (TO FILE).
O comandă asemănătoare este DISPLAY FILES.
DISPLAY FILES
[ON <disc |director>]
[LIKE <masca>]
[TO PRINTER |TO FILE <fişier>]
clauzele şi utilizarea lor fiind aceleaşi cu cele ale comenzii anterioare.
Există, în FoxPro, posibilitatea ca, în paralel cu afişarea pe ecran a unor
informaţii, acestea să fie scrise şi într-un fişier. Această operaţie este controlată de
comanda SET ALTERNATE care are două forme:
SET ALTERNATE ON |OFF
SET ALTERNATE TO [<fişier> [ADDITIVE]].
Fişierul în care se va scrie este desemnat prin <fişier> în forma a doua a
comenzii. Această comandă va determina fie iniţializarea fişierului înainte de
scriere, când clauza ADDITIVE lipseşte, fie adăugarea la fişierul existent anterior,
în prezenţa acestei clauze.
Validarea ieşirii în fişierul ALTERNATE este dată prin comanda SET
ALTERNATE ON, iar oprirea ieşirii la acest fişier se realizează prin SET
ALTERNATE OFF.
157
Închiderea fişierului ALTERNATE se face prin comanda CLOSE
ALTERNATE, cu sintaxa simplă CLOSE ALTERNATE.
1. Care sunt comenzile pentru descrierea structurii unei baze de date (1

pct.).
Punctaj 5,5p 2. Cum se crează structura unei baze de date CREATE? (1,5 pct.)
3. Ce este tipul logic şi ce ceste tipul numeric? (1,5 pct.)
4. Care este structura unei baze de date? (1,5 pct.)
U10.16. Rezumat
La crearea unei baze de date trebuie specificată structura acesteia. Pentru a

specifica în mod univoc structura unei baze de date, trebuie indicate câmpurile
care o compun printr-un nume asociat fiecărui câmp cât şi caracteristicile acestora
(tipul de date ce se memorează în acel câmp, lungimea).
Pentru a specifica o anumită înregistrare din baza de date se foloseşte “indicatorul
de înregistrări”, care reprezintă o zonă de memorie ce conţine numărul
înregistrării curente. Indicatorul de înregistrări poate fi modificat prin comenzi
FoxPro, acest lucru fiind realizat cu ajutorul tastelor direcţionale în sus şi în jos a
indicatorului de înregistrări de-a lungul bazei de date. Pentru a folosi o bază de
date aceasta trebuie mai întâi deschisă. Deschiderea bazei de date se face într-o
zonă din memoria calculatorului care poartă numele de zonă de lucru ( în engleză
„work area”) şi sunt 25 la număr în varianta FoxPro 2.0 şi 225 în varianta 2.6.
158
159
UNITATEA 11
TURBO PASCAL
Cuprins: pag.
U11.1. Scopul şi obiectivele unităţii ........................................................... 159
U11.2. Noţiuni introductive ....................................................................... 159
U11.3. Elemente de bază ale limbajului Turbo Pascal ............................ 161
U11.4. Mediul de programare Turbo Pascal ............................................ 162
U11.5. Test de autoevaluare ....................................................................... 173
U11.6. Rezumat ........................................................................................... 173

 noţiuni introductive despre Turbo Pascal;
 elementele de bază ale limbajului Turbo Pascal;
 mediul de programare Turbo Pascal.
U11.2. Noţiuni introductive
Un sistem de calcul este o maşină capabilă să execute operaţii relativ

simple, dar cu viteză extrem de mare. Sistemul de calcul nu are iniţiative, ci
aşteaptă ca după pornire utilizatorul să îi dea toate instrucţiunile referitoare la
operaţiile pe care trebuie să le execute.
Instrucţiunile pentru rezolvarea unei anumite probleme sunt grupate într-
un program, scris de un programator sau de o echipă de programatori. Cea de-a
doua situaţie se întâlneşte în special în cazul programelor ,,de firmă” de
complexitate ridicată, care sunt livrate odată cu sistemul de calcul (sistemul de
operare şi diverse programe utilitare) sau se achiziţionează ulterior (jocuri,
160
compilatoare, programe pentru realizarea aplicaţiilor specifice unui anumit
domeniu etc.).
Pentru scrierea unui program se utilizează un limbaj de programare, cu
sintaxă şi semantică riguros definite. În cazul de faţă programele sunt scrise în
limbajul Pascal.
Forma în care programatorul îşi scrie programul este numită program
sursă. Pentru a fi prelucrat de sistemul de calcul programul sursă trebuie
înregistrat într-un fişier sursă. Acesta este creat cu ajutorul unui program utilitar
numit editor de texte. Editorul permite atât dactilografierea şi modificarea textului
programelor sursă, cât şi salvarea acestora în fişiere pe suport magnetic (de obicei
disc fix sau disc flexibil).
Programul sursă nu poate fi ,,înţeles şi executat direct de către sistemul de
calcul, dar poate fi ,,tradus” într-o formă direct executabilă, numită program
executabil. Generarea programului executabil are sens numai dacă programul
sursă respectă sintaxa limbajului de programare în care este scris. Analiza
sintactică a programului sursă este realizată de către un program specializat, numit
compilator, specific limbajului în care este scris programul sursă şi sistemului de
calcul pe care va fi executat programul. Dacă programul sursă are erori sintactice,
compilatorul le semnalează prin mesaje care arată cauza probabilă a fiecărei erori.
Corectarea programului sursă se realizează cu ajutorul editorului de texte. După
corectare programul sursă trebuie compilat din nou. Acest proces se repetă până la
eliminarea tuturor erorilor sintactice. În cazul unui program sursă fără erori,
compilatorul generează fie programul executabil corespunzător, fie o formă
intermediară, pe care un alt program specializat o va transforma în program
executabil. În cele ce urmează vom considera numai cazul compilatoarelor care
generează programe direct executabile.
Corectitudinea sintactică nu dă certitudinea rezolvării corecte a problemei,
deoarece programul sursă poate să aibă erori de concepţie. Pentru a verifica dacă
programul executabil funcţionează corespunzător acesta trebuie testat pentru mai
multe seturi de date. Seturile de date trebuie alese astfel încât să se poată valida
rezultatele furnizate de program (prin confruntarea cu rezultatele aşteptate, care
trebuie să fie cunoscute apriori sau să fie uşor de determinat). De asemenea,
trebuie testate nu numai situaţiile tipice de utilizare a programului, ci şi cazurile
limită.
161
Dacă la execuţie apar erori sau se constată că rezultatele obţinute nu sunt
cele aşteptate, atunci trebuie determinată cauza erorilor şi efectuate corecţiile
necesare. După corectare programul sursă trebuie recompilat şi testat, până la
obţinerea unui program executabil care funcţionează conform aşteptărilor.
Pentru a reduce posibilitatea apariţiei erorilor de concepţie este important
să se formuleze cât mai clar enunţul problemei propuse spre rezolvare, cu
specificarea datelor iniţiale şi a rezultatelor dorite (inclusiv a formei de prezentare
a acestora). De asemenea, dacă problema propusă spre rezolvare este ceva mai
complicată, scrierea programului sursă trebuie precedată de elaborarea unei schiţe
a rezolvării problemei.
Programele folosite pentru obţinerea unui program executabil (cel puţin un
editor de texte şi un compilator specific limbajului de programare utilizat) pot fi
independente sau pot fi integrate într-un ansamblu de programe utilitare, numit
mediu de programare. De obicei un mediu de programare este destinat dezvoltării
programelor scrise într-un anumit limbaj de programare. De aceea se foloseşte şi
termenul de mediu integrat de dezvoltare a programelor (Integrated Development
Environment)].
Într-o sesiune de lucru (reprezentată de totalitatea prelucrărilor efectuate de
la începerea şi până la terminarea lucrului cu mediul de programare) pot fi
realizate mai multe programe. Acestea pot rezolva probleme complet diferite sau
pot reprezenta variante de rezolvare a aceleiaşi probleme.
U11.3. Elemente de bază ale limbajului Turbo Pascal
Limbajul de programare PASCAL şi compilatorul asociat au fost elaborate

în 1970 de către elveţianul Niklaus Wirth. Autorul a intenţionat să pună la
dispoziţia utilizatorilor un limbaj de nivel înalt, eficient şi performant, care să
permită învăţarea programării ca disciplină sistematică, bazată pe anumite
concepte fundamentale, evidenţiate de către limbaj în mod logic şi clar.
Elementele de bază ale limbajului PASCAL au fost preluate din ALGOL
60, la acestea adăugându-se importante extensii referitoare în primul rând la
structuri de date şi mai recent la programarea orientată pe obiect, care au lărgit
considerabil domeniul de aplicabilitate al limbajului PASCAL. Datorită calităţilor
sale, limbajul PASCAL s-a răspândit foarte repede fiind astăzi unul din cele mai
162
utilizate limbaje de programare de nivel înalt. Este un limbaj structurat, neorientat,
fiind studiat ca prim limbaj de programare în toate universităţile din lume.
Majoritatea implementărilor PASCAL au la bază standardul ISO
(International Standards Organization) cunoscut sub numele de PASCAL
STANDARD, prezentând în general diferite extensii faţă de acesta. Printre cele
mai răspândite versiuni ale limbajului PASCAL se numără Microsoft PASCAL
(MS-PASCAL) versiune elaborată de firma americană BORLAND.
În cele ce urmează va fi prezentată implementarea TURBO PASCAL, care
prin cuplarea editorului de texte, compilatorului şi depanatorului într-un singur
sistem gestionat prin meniuri sugestive, reprezintă un mediu de programare
deosebit de performant cu multiple facilităţi în ceea ce priveşte crearea, depanarea
şi exploatarea programelor. În definiţiile sintactice se vor face referiri la PASCAL
STANDARD, care stă la baza tuturor versiunilor PASCAL, în particular vor fi
prezentate elemente din versiunea TURBO PASCAL 6.0 apărută în 1990, fără a
prezenta o descriere exhaustivă a ei, care ar depăşi cu mult volumul limitat al
acestui manual.
U11.4. Mediul de programare Turbo Pascal
Mediul de programare Turbo Pascal este dedicat dezvoltării programelor

scrise în limbajul Pascal. Dintre componentele sale menţionăm:
• editorul de programe - acesta este un editor de texte specializat, conceput
astfel încât să uşureze dactilografierea şi modificarea programelor sursă Pascal;
• componenta de gestiune a fişierelor, care asigură, în principal, salvarea în
fişiere pe disc a programelor editate şi încărcarea programelor sursă de pe disc;
• compilatorul, care analizează corectitudinea sintactică a programului
editat şi generează forma sa executabilă;
• componenta ce controlează execuţia programului, cu revenire a editorul
de programe în momentul terminării normale a programului sau la producerea
unei erori,
• sistemul de informaţii ajutătoare (HELP), care asigură obţinerea de
informaţii referitoare la utilizarea mediului de programare Turbo Pascal şi,
respectiv, la elementele limbajului Pascal.
163
11.4.1. Începerea sesiunii de lucru Turbo Pascal
O sesiune de lucru Turbo Pascal este declanşată de comanda turbo. Aceasta

se introduce ca răspuns la cererea sistemului de operare MS-DOS de a specifica ce
operaţie trebuie executată. Această cerere (denumită în engleză prompt) are forma:
mesaj >
De cele mai multe ori mesaj-ul precizează catalogul curent, din care se
citesc şi în care se scriu, implicit, diferite fişiere (în cazul de faţă fişierele sursă
Pascal, care au extensia implicită pas).
Ca efect al comenzii turbo (care, ca orice altă comandă, trebuie încheiată
prin apăsarea tastei ENTER), pe ecran se afişează fereastra principală, peste care
se suprapune o fereastră de editare.
În partea superioară a ferestrei principale se află meniul principal, care
permite accesul la sistemul de meniuri al mediului de programare Turbo Pascal.
Deoarece comenzile şi opţiunile Turbo Pascal sunt foarte numeroase, ele sunt
grupate în funcţie de semnificaţie. Comenzile dintr-un grup sunt prezentate în
cadrul unui meniu specific şi pot fi selectate atunci când meniul corespunzător
este afişat pe ecran şi comanda respectivă are sens (de exemplu nu se poate
solicita execuţia operaţiei „salvare fişier” atunci când nu există un fişier în curs
de prelucrare).
Anumite comenzi pot fi însă transmise direct, prin acţionarea unei taste sau
a unei combinaţii de taste de activare (hot keys). Din această categorie fac parte şi
cele câteva menţionate în ultima linie din fereastra principală (numită linie de
informare), care au următoarele semnificaţii:
F1 Help - acces la sistemul de informaţii ajutătoare;
F2 Save - salvarea programului din fereastra de editare într-un fişier pe
disc;
F3 Open - deschiderea unei ferestre de editare în care se încarcă conţinutul
unui fişier sursă;
Alt+F9 Compile - compilarea programului din fereastra de editare;
F9 Make - generarea formei executabile a programului;
F10 Local Meniu - acces la meniul principal, pentru a opera cu sistemul de
meniuri Turbo Pascal.
164
11.4.2. Principalele elemente ale ferestrei de editare
Principalele elemente ale ferestrei de editare sunt:

• numele fişierului sursă în care se salvează textul programului editat; dacă
nu a fost ales încă un nume pentru fişierul sursă, atunci numele afişat este
NONAME00.PAS;
• numărul de ordine al ferestrei de editare curente (mediul Turbo Pascal
poate opera cu mai multe ferestre de editare dar, pentru simplitate, în cele ce
urmează vom trata numai cazul utilizării unei singure ferestre de editare);
• poziţia curentă în cadrul textului sursă, specificată în partea de jos a
ferestrei, sub forma indice-linie: indice-coloană;
• zona rezervată afişării conţinutului fişierului sursă, situată în interiorul
cadrului ferestrei.
11.4.3. Salvarea pe disc a programului sursă
Deşi nu este obligatoriu, recomandăm ca în cazul editării unui nou

program să se fixeze numele fişierului sursă corespunzător chiar de a începutul
editării. Aceasta se realizează prin intermediul comenzii de salvare (Save),
transmisă direct mediului Turbo Pascal prin apăsarea tastei F2. În acest caz se
afişează fereastra care permite programatorului să specifice numele fişierului
sursă. Dacă se introduce numele test, mediul de programare îi adaugă automat
extensia .pas, deci identificatorul complet al fişierului sursă va fi test.pas.
După introducerea numelui fişierului, la apăsarea tastei ENTER, se revine
la fereastra de editare şi se poate trece la editarea textului programului.
Recomandăm ca, pe parcursul editării textului programului, acesta să fie
salvat din când în când, pentru a evita situaţiile neplăcute, de genul ,,cădere de
tensiune” sau ,,blocare sistem”, în urma cărora textul editat se pierde şi este
necesară reintroducerea sa.
11.4.4. Editarea unui program sursă Pascal
Introducerea textului unui program se face caracter cu caracter. Poziţia

următorului caracter introdus este pusă în evidenţă printr-un marcaj clipitor, numit
cursor.
165
Pentru a termina o linie şi a trece la linia următoare se apasă tasta ENTER.
Editorul Turbo Pascal indentează automat liniile introduse, plasând cursorul sub
primul caracter diferit de blanc din linia terminată (spre deosebire de alte
editoare, care îl plasează la marginea din stânga a ecranului). Indentarea textului
unui program este foarte importantă, deoarece uşurează urmărirea structurii sale
şi, deci, corectarea sau modificarea ulterioară.
Să considerăm următorul program sursă:
program test;
begin
writeln (“salut prieteni!”)
end.
La introducerea primelor două linii nu apar probleme deosebite. Deoarece
a treia linie începe cu 3 spaţii, trebuie apăsată de trei ori tasta BLANC (tasta cea
mai lungă de pe tastatură), continuând apoi cu introducerea textului propriu-zis.
După apăsarea tastei ENTER cursorul se poziţionează sub caracterul w. Pentru
poziţionarea la capătul din stânga al liniei trebuie apăsată tasta HOME. Aceasta
face parte din grupul tastelor care comandă deplasarea rapidă în cadrul textului
editat, după cum urmează:
CTRL+A - salt la începutul cuvântului anterior;
CTRL+F- salt la începutul cuvântului următor;
CTRL+ Q,E- salt la prima linie de pe ecran;
CTRL+Q,X- salt la ultima linie de pe ecran;
HOME - salt la începutul liniei curente;
END - salt la sfârşitul liniei curente;
PAGE UP- salt la pagina următoare;
PAGE DOWN -salt la pagina următoare.
Deplasările pas cu pas se realizează apăsând tastele direcţionale, marcate
cu săgeţi.
Pe parcursul editării programului sursă este posibil să se greşească şi să fie
necesară ştergerea unuia sau a mai multor caractere. În acest scop pot fi utilizate
următoarele comenzi:
DELETE- şterge caracterul pe care este poziţionat cursorul;
BACKSP - această tastă, situată de obicei deasupra tastei ENTER şi
marcată cu o săgeată orientată spre stânga, se utilizează în mod obişnuit pentru
ştergerea caracterului din stânga cursorului; efectul este diferit dacă la stânga
166
cursorului există numai blancuri, caz în care ştergerea se efectuează până la
nivelul de indentare anterior;
CTRL+T - şterge un cuvânt sau finalul acestuia, începând de la caracterul
pe care este poziţionat cursorul;
CTRL+Q,Y- şterge toate caracterele de la dreapta cursorului;
CTRL+Y - şterge linia pe care este poziţionat cursorul.
De exemplu, pentru a înlocui cuvântul salut cu SALUT, se poate proceda
astfel:
• se poziţionează cursorul la începutul cuvântului;
• se şterge cuvântul utilizând CTRL+T;
• se introduce noua formă a cuvântului.
Modul obişnuit de lucru al editorului de programe este modul ,,inserare”.
Aceasta înseamnă că în cazurile în care cursorul se află în interiorul unei linii,
apăsarea unei taste determină inserarea caracterului corespunzător (caracterele de
la dreapta cursorului deplasându-se corespunzător).
Modul de lucru al editorului poate fi comutat de la ,,inserare” la
,,substituţie”, apăsând tasta INSERT. În modul ,,substituţie”, la apăsarea unei
taste, caracterul indicat de cursor este înlocuit de cel introdus. Schimbarea
modului de lucru al editorului este semnalată prin schimbarea formei cursorului.
De exemplu, o altă variantă pentru a înlocui cuvântul salut prin SALUT
este următoarea:
• se poziţionează cursorul la începutul cuvântului;
• se apasă tasta INSERT, trecând astfel în modul ,,substituţie”;
• se introduce cuvântul SALUT, caracterele introduse înlocuindu-le pe cele
existente anterior;
• se apasă din nou tasta INSERT, pentru a reveni la modul „inserare”.
11.4.5. Compilarea programului editat
Comanda prin care se solicită compilarea programului sursă şi generarea

celui executabil este F9 (Make). În cazul programelor sursă fără erori sintactice se
afişează o fereastră care furnizează informaţii despre rezultatul compilării.
Dacă programul are erori, atunci compilatorul se opreşte la prima eroare
întâlnită, redând controlul editorului. În acest caz cursorul este poziţionat în locul
167
în care a fost detectată eroarea şi se afişează un mesaj referitor la cauza probabilă
a erorii.
În cazul programelor de dimensiuni mai mari se pot face compilări chiar
înainte de editarea completă a textului programului sursă, pentru a verifica dacă
porţiunea introdusă a fost corect dactilografiată.
11.4.6. Corectarea erorilor sintactice
Chiar dacă revenirea în etapa de editare se face cu poziţionarea cursorului

în locul detectării erorii, cauza acesteia trebuie căutată cu atenţie, deoarece
elementul greşit se poate afla într-o linie anterioară celei pe care este poziţionat
cursorul.
Printre erorile cel mai des întâlnite sunt cele de tipul „Unknown identifier”
(identificator necunoscut, adică nedefinit). De cele mai multe ori ele apar datorită
dactilografierii incorecte a textului programului, dar pot fi determinate şi de
absenţa unei declaraţii corespunzătoare pentru identificatorul (numele) semnalat
ca necunoscut.
După găsirea cauzei erorii şi modificarea programului este necesară o nouă
compilare, procesul repetându-se până în momentul obţinerii unei program fără
erori sintactice.
11.4.7. Execuţia programului
Cea mai simplă comandă de lansare în execuţie a programului editat este

CTRL+F9. Ca rezultat, este afişată fereastra utilizator (în care se afişează
mesajele scrise prin program şi ecoul datelor introduse de utilizator), iar apoi se dă
controlul programului respectiv.
La încheierea execuţiei programului controlul este redat mediului Turbo
Pascal, care reafişează fereastra de editare.
Astfel, în cazul execuţiei programului test, deoarece aceasta este practic
instantanee, se remarcă numai o scurtă clipire a ecranului. Pentru a vedea ce
anume s-a întâmplat, este necesară afişarea ferestrei utilizator. În acest scop se
utilizează comanda ALT+F5. Pentru a reveni la fereastra TP se poate apăsa orice
tastă.
168
În cazul exemplului considerat, o singură execuţie a programului este
suficientă pentru a constata dacă acesta funcţionează corect. De cele mai multe ori
sunt însă necesare mai multe execuţii succesive, pentru diferite seturi de date. În
procesul de testare a programului este posibil să fie detectate erori. În cazul unei
erori detectate de mediul de programare, execuţia se termină cu afişarea unui
mesaj de eroare corespunzător. Alte erori sunt cele observate de utilizator, atunci
când compară rezultatele afişate de program cu cele pe care le aştepta.
Corectarea erorilor impune modificări ale textului programului sursă,
urmate de compilare şi execuţie.
11.4.8. Trecerea la editarea unui alt program
După obţinerea unui program care funcţionează conform aşteptărilor, se

poate trece la editarea unui alt program. În acest scop se închide fereastra de
editare curentă, prin comanda ALT+F3. Dacă varianta curentă a programului
editat nu a fost deja salvată, atunci se afişează fereastra din figura 13. Aceasta
conţine trei butoane de comandă, dintre care poate fi selectat doar unul.
Un buton de comandă poate fi selectat în două moduri:
• prin poziţionarea pe buton folosind tasta TAB, urmată de apăsarea tastei
ENTER;
• apăsând tasta corespunzătoare, dacă în textul înscris pe butonul respectiv
este pusă în evidenţă o anumită literă.
Efectul selectării fiecărui buton este descris în cele ce urmează:
Yes - se memorează (salvează) versiunea curentă (cea mai recentă) a
programului editat;
No - se păstrează versiunea salvată anterior, iar versiunea curentă se
pierde;
Cancel - se revine la etapa de editare a programului.
Dacă este selectat butonul Yes sau butonul No, atunci fereastra de editare
este închisă şi pe ecran rămâne numai fereastra principală.
Pentru a trece efectiv la editarea unui alt program, se utilizează comanda
F3 (Open). În acest moment se poate introduce un nume de fişier nou (care nu
apare în lista afişată) sau se poate alege unul dintre fişierele existente, pentru a
modifica sau reexecuta programul sursă pe care îl conţine.
Alegerea unui fişier existent se poate face în două moduri:
169
• prin introducerea numelui fişierului;
• apăsând mai întâi tasta TAB, după care banda luminoasă de selecţie
trebuie poziţionată, folosind tastele direcţionale, pe numele fişierului dorit.
Selecţia devine efectivă în momentul apăsării tastei ENTER, moment în
care se deschide o fereastră de editare în care apare conţinutul fişierului selectat.
11.4.9. Crearea unei variante a unui program existent
Dacă se doreşte crearea unei variante a unui program, cu păstrarea

versiunii existente, se poate proceda în mai multe feluri. În cele ce urmează
prezentăm o singură soluţie, destul de simplă:
• se trece a editarea unui nou fişier, în care se va păstra noua variantă a
programului;
• se copiază varianta curentă a programului, folosind comanda
CTRL+K,R; ca efect al acestei comenzi se permite selectarea fişierului din care se
copiază, la fel ca în cazul încărcării unui fişier sursă existent;
• textul copiat din fişierul selectat este pus în evidenţă prin modul de
afişare; pentru a trece la afişarea normală se utilizează comanda CTRL+K,H;
• se modifică programul sursă copiat şi se salvează în noul fişier.
11.4.10. Obţinerea informaţiilor ajutătoare
Informaţiile ajutătoare sunt grupate în ecrane de informare cu conţinut fix.

Conţinutul ecranului de informare corespunzător contextului curent se afişează
într-o fereastră-help. În funcţie de dimensiunile ecranului şi ale ferestrei, afişarea
este integrală sau parţială. Pentru a aduce în cadrul ferestrei acele porţiuni din
ecranul de informare care nu sunt vizibile, utilizatorul poate folosi tastele
direcţionale (cele marcate cu săgeţi, precum şi PAGE UP şi PAGE DOWN).
În majoritatea ecranelor de informare apar casete care conţin titlurile altor
ecrane. Aceste casete pot fi selectate în mai multe moduri: utilizând tastele
direcţionale, respectiv TAB şi SHIFT+TAB, sau introducând litera (literele) cu
care începe textul din casetă. Odată selectată caseta dorită, apăsarea tastei ENTER
determină afişarea ferestrei de informare corespunzătoare.
O sesiune de informare este lansată printr-una din următoarele comenzi:
170
- ALT+H sau F10,H -determină afişarea meniului Help, din care pot fi
selectate diferite ecrane de informare;
- F1 - are ca efect afişarea ecranului corespunzător contextului curent;
- CTRL+F1 - se utilizează în cazul în care pe parcursul editării este
necesară obţinerea de informaţii ajutătoare cu privire la un element al limbajului.
În astfel de cazuri este suficient să se deplaseze cursorul până la elementul
respectiv (de exemplu un cuvânt cheie sau un operator) şi să se dea comanda
CTRL+F1;
- SHIFT+Fl - determină afişarea ecranului de informare Index;
- ALT+F1 - în urma acestei comenzi se revine la fereastra de informare
activată anterior, sau se afişează o primă fereastră.
Sesiunea de informare se încheie la apăsarea tastei ESC.
11.4.11. Încheierea sesiunii de lucru
Pentru a încheia sesiunea de lucru Turbo Pascal se utilizează comanda

ALT+X. În cazul în care programul sursă nu a fost salvat sau a suferit modificări
după ultima salvare, se afişează fereastra din figura 5. Utilizatorul este cel care
decide dacă forma curentă a programului sursă trebuie salvată sau nu.
11.4.12. Unităţile lexicale ale limbajului PASCAL
Un program PASCAL fiind un text ce specifică acţiunile ce vor fi

executate de calculator, este format din caractere grupate în unităţi lexicale.
Acestea sunt:
- caracterele;
- cuvintele rezervate;
- identificatorii (inclusiv identificatorii Standard);
- numerele;
- şirurile de caractere;
- delimitatorii;
- comentariile.
Setul de caractere
Este un subset al setului de caractere utilizat de sistemele de calcul (ASCII
sau EBCDIC). El conţine următoarele grupe de caractere:
171
a) literele alfabetului latin: a, b, c, …, z.
A, B, C, …, Z.
b) cifrele arabe: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9;
c) caractere speciale: +,-,/,*, ^, < >; ( ), [ ], { }, ., :, ;, ’, #, $, @, .. =; la
care se adaugă simbolurile formate din două caractere:
- operatorul de atribuire: =
- operatorii relaţionali <=, >=, = şi < > (diferit)
- delimitatorii de comentarii (* *) echivalenţi cu { }.
Cuvintele rezervate
Sunt cuvinte cu semnificaţie prestabilită de compilator şi nu pot fi folosite
de utilizator într-un alt context decât cel specificat în definirea limbajului
PASCAL. În particular cuvintele rezervate nu pot fi folosite ca identificatori. În
TURBO PASCAL 6.0. există următoarele cuvinte rezervate:
ABSOLUTE EXTERNAL MOD SHR
AND FILE NIL STRING
ARRY FOR NOT THEN
BEGIN FORWARD OBJECT TO
CASE FUNCTION OF TYPE
CONST GOTO OR UNIT
CONSTRUCTOR IF PACKED UNTIL
DESTRUCTOR IMPLEMENTATION PROCEDURE USES
DIV IN PROGRAM VAR
DO INLINE RECORD VIRTUAL
DOWNTO INTERFACE REPEAT WHILE
ELSE INTERRUPT SET WITH
END LABEL SHL XOR
Identificatorii
Sunt nume care desemnează constante, variabile, proceduri, funcţii şi alte
elemente ale unui program PASCAL. Un identificator este o combinaţie de
caractere alfanumerice (litere şi cifre), primul caracter fiind obligatoriu alfabetic.
Singurul caracter special permis la constituirea identificatorilor este liniuţa
de subliniere „__” (underscore). Compilatorul TURBO PASCAL nu face distincţie
între majuscule şi minuscule. Pot fi definiţi identificatori din mai multe cuvinte
legate prin liniuţa de subliniere (__). Exemplu: Matrice __ de __ numere.
172
În principiu, lungimea identificatorilor nu este limitată dar compilatorul
TURBO PASCAL 6.0 ia în consideraţie numai primele 63 de caractere.
Exemple de identificatori ilegali: 2XY, Var, nivel. 4x-y. (2XY începe cu
cifră, VAR este cuvânt rezervat iar ultimul identificator conţine caractere
nepermise în identificatori: punct, minus).
Anumiţi identificatori, numiţi identificatori standard sunt predefiniţi şi se
recomandă folosirea lor sub forma stabilită: sin, cos, arctan, ln, exp, ord, pred,
sqrt, sqr, aud, not, or etc. Se recomandă deci utilizarea identificatorilor standard
drept cuvinte rezervate.
Identificatorii definiţi de utilizator pentru constante, tipuri de date,
variabile, funcţii, proceduri, se numesc identificatori utilizator. Se utilizează
denumiri sugestive care să faciliteze urmărirea programului, dar nu se recomandă
folosirea de identificatori foarte lungi care sunt greu de manevrat în expresii.
Numere
Se reprezintă în notaţia zecimală (baza 10). Un număr întreg se reprezintă
ca un şir de cifre precedat sau nu de un semn (+, -).
Numerele reale se reprezintă în două moduri:
a) fără exponent, caz în care numărul se reprezintă prin parte întreagă,
punct zecimal, parte fracţionară: parte întreagă poate fi precedată de un semn.
Exemple: 1.59 +92.51 477.89911 -0.225
b) (cu exponent sau factor de scară), caz în care numărul se reprezintă prin:
parte întreagă cu sau fără semn, punct zecimal, partea fracţionară, litera E şi un
întreg cu semn de două cifre, aceasta din urmă reprezentând exponentul lui 10.
Exemple:
0.15E + 03 = 0.15 x 1000 = 150
8.007E - 02 = 8.007 x 0.01 = 0.08007
dacă un număr conţine punct zecimal, aceasta din urmă trebuie precedat şi urmat
de cel puţin o cifră. În interiorul unui număr nu poate apare virgula (,).
Şiruri de caractere
Un şir de caractere este o succesiune de caractere încadrate între semnele
apostrof.
Un şir de caractere trebuie să apară pe o singură linie a textului
programului. Spre deosebire de cuvintele rezervate şi de identificatori, în
interiorul şirurilor de caractere se face deosebire între literele majuscule şi
minuscule.
173
Comentarii
Pentru creşterea clarităţii programelor este recomandabil ca în textul lor să
fie incluse anumite explicaţii sau comentarii. În PASCAL un comentariu este o
succesiune de caractere incluse între delimitatorii {şi} sau (* şi *). Exemplu:
{Programul calculează dobânzile în procente}
La compilare, comentariile nu sunt luate în consideraţie, şi nu modifică
efectul programului. Comentariile pot fi inserate oriunde în textul programului.
Delimitatori şi separatori
Delimitatorii sunt semne de punctuaţie sau operatori. De asemenea
cuvintele rezervate pot fi incluse în categoria delimitatorilor. Ei se utilizează
pentru a delimita spaţiul ocupat de unităţile lexicale:
+ - / . : ; = > < < => = < >,: ( ) ‘ [] {} ^.
Separatorii în PASCAL sunt: spaţiul (blank), sfârşitul de linie şi
comentariul. Între două cuvinte rezervate, identificatorii sau numere trebuie
intercalat cel puţin un separator însă nu este permisă intercalarea de separatori în
interiorul cuvintelor rezervate, identificatorilor, numerelor şi simbolurilor
speciale. În rest poate să apară un număr arbitrar de separatori între oricare două
simboluri consecutive.
Pentru separarea instrucţiunilor se utilizează “ ; ”
1. Specificaţi elementele de bază ale limbajului Turbo Pascal (1,5 pct.).

2. Care sunt principalele elemente ale ferestrei de editare? (1,5 pct.)
Punctaj 5,5p 3. Ce presupune corectarea erorilor sintactice? (2,5 pct.)
U11.6. Rezumat
Instrucţiunile pentru rezolvarea unei anumite probleme sunt grupate într-

un program, scris de un programator sau de o echipă de programatori. Cea de-a
doua situaţie se întâlneşte în special în cazul programelor ,,de firmă” de
complexitate ridicată, care sunt livrate odată cu sistemul de calcul (sistemul de
operare şi diverse programe utilitare) sau se achiziţionează ulterior (jocuri,
174
compilatoare, programe pentru realizarea aplicaţiilor specifice unui anumit
domeniu etc.).
175

Curs Programarea Calc ID

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Curs Programarea Calc ID

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSITATEA „CONSTANTIN BRANCUŞI” DIN TÂRGU JIU

FACULTATEA DE ŞTIINŢE ECONOMICE ŞI GESTIUNEA AFACERILOR

Lector univ. dr. CARINA-ELENA STEGĂROIU

pentru uzul studenţilor ID

Editura Academica Brâncuşi

UNITATEA 2 – TIPURI DE LIMBAJE DE PROGRAMARE..................................................18

UNITATEA 3 – LIMBAJE DE PROGRAMARE.......................................................................26

UNITATEA 4 – LIMBAJE ORIENTATE PE GESTIUNEA BAZELOR DE DATE...............37

UNITATEA 6 – NOŢIUNI DE BAZĂ REFERITOARE LA PROGRAMARE.......................51

UNITATEA 7 – ELEMENTELE DE BAZĂ ALE PROGRAMĂRII ORIENTATE PE

UNITATEA 9 – PROIECTAREA APLICAŢIILOR ÎN LIMBAJUL VISUAL BASIC...........75

UNITATEA 11 – TURBO PASCAL............................................................................................159

UNITATEA 1: Introducere în programare

UNITATEA 2: Tipuri de limbaje de programare

UNITATEA 3: Limbaje de programare

UNITATEA 4: Limbaje orientate pe gestiunea bazelor de

Durata medie de studiu individual - 2 ore

U1.1. Scopul şi obiectivele unităţii

În această temă vei învăţa următoarele concepte fundamentale:

U1.2. Introducere în programare

Fără intenţia de a leza temerarii angajaţi în acest domeniu trebuie să

U1.3. Noţiuni de programare

Prezentarea amănunţită a acestor noţiuni se face pe baza schemei

Figura 2. Compilarea şi link-editarea corectă

Editarea de legături (link-editarea) va rezolva aceste referiri stabilind

Figura 3. Etapele realizării unui program

Etapele de compilare şi link-editare sunt necesare pentru realizarea unui

U1.4. Mediu de programare

Un pachet de programe ce asigură toate operaţiile de mai înainte poartă

Desigur această tehnică de overlay presupune ca segmentul principal de

Total puncte: 6 Puncte obţinute………

Dacă totuşi trebuie să programăm, atunci să programăm bine şi eficient. Să

Răspunsuri şi comentarii la testul de autoevaluare nr. 1

Durata medie de studiu individual - 2 ore

U2.1. Scopul şi obiectivele unităţii

În această temă vei învăţa următoarele concepte fundamentale:

U2.2. Noţiuni introductive

Un limbaj de programare este un sistem de convenţii adoptate pentru

Figura 5. Program în limbaj PASCAL

U2.3. Limbajele de nivel scăzut - de nivel înalt

Cu ajutorul unui limbaj de nivel înalt programatorul se face mai uşor

U2.4. Limbaje procedurale / neprocedurale

Cele două tipuri de limbaje, procedurale şi neprocedurale, se diferenţiază

Figura 7. Limbaje procedurale / neprocedurale

Avantajul esenţial al programării structurate îl constituie conceptul de bloc

U2.5. Limbaje orientate

Clasificarea operată în secţiunea de faţă se referă la domeniul de

O altă posibilă clasificare a limbajelor se poate face după „fluxul” de

U2.7. Test de autoevaluare nr. 2

Total puncte: 7,5 Puncte obţinute………

Clasificarea operată în secţiunea de faţă se referă la domeniul de

Răspunsuri şi comentarii la testul de autoevaluare nr. 2

Durata medie de studiu individual - 2 ore

U3.1. Scopul şi obiectivele unităţii

În această temă veţi învăţa următoarele concepte fundamentale:

U3.2. Abordări conceptuale

Cu aceste noi elemente la dispoziţie putem aborda prezentarea limbajului

U3.3. Limbaje de nivel înalt neorientate

Creat în anul 1964 la Darmooth College (S.U.A) limbajul BASIC a

Limbajul Fortran este în mod cert decanul de vârstă al limbajelor de largă

Conceptualizat în anul 1970 de către Niklaus Wirth, limbajul PASCAL

Figura 8. Aplicaţie creată cu Turbo Vision

Aplicaţia e complet concepută pe bază de meniuri, posedă suport de