Turbo Pascal Algoritmi Si Limbaje de Programare

lr!
formatica pentru clasale IX""'XU
Manual pentru clasa a IX-a
Teora
Conceput in conformitate cu programa colara

in vigoare, pentru disciplinele Algoritmi
i limbaje de programare i Aplicatii
practice
de laborator - clasa a IX-a, profil informatica
- manualul este rezultatul indelungatei
experiente didactice a autorului.
Fiecare capitol este insotit de un set
de probleme propuse, prezentate
in functie de complexitatea lor. Elevilor li se
'
ofera acum posibilitatea de a acoperi dintr-o

singura sursa, atat programa cat i aplicatii
din afara ei, pentru care exista un interes
dovedit: unitati de program, programare pe
'
obiecte, crearea meni urilor, format area

ecranelor, validarea datelor de intrare,
reprezentari grafice de functii i suprafete,
salvarea imaginilor etc.
Tudor Sorin
TU BO PfiSCfiL
Algoritmi i limbajv dv programarcz
Manual pvntru clasa a IX-a
Teora
Acopera programa cursurilor de algoritmi, limbaje de programare i lucrari

practice de laborator.
Nu a facut obiectul unei avizari a Ministerului lnvatamantului i tiintei
Teora
CP 79-30, cod 72450 Bucure ti, Romania
Tel.: 619.30.04
Fax: 210.38.28
Distributie
8-dul AI. I. Cuza nr. 39
Tel.: 222.45.33
Fax: 222.45.33
Teora - Cartea prin po ta

CP 79-30, cod 72450 Bucure ti, Romania
Tel.: 635.14.41
Copyright 1995 Teora
Prima editie 1995
Retiparita: octombrie 1995
Reproducerea integrala sau partiala a textului sau a ilustratiilor din aceasta
carte este posibila numai cu acordul prealabil scris al editurii Teora.
Coperta: Valentin Tanase
ISBN: 973-601-212-3.
Tipar executat Ia ROMFEL S.R.L.
Bucure ti, str. Lizeanu nr. 35 A, sect. 2
Tlparlt Ia ROMFE:L S.R.L
Str. Llzeanu nr. 35A, sector 2
Cuprins
1. Notiunea de algoritm, caracteristici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
1.1. Obiectele cu care lucreaza algoritmii: date, variabile, expresii,
operatii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. 11
1.1.1. Date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
1.1.2. Variabile
. . . . .. . . . . . . . . . . . . . . . . . .. . . . . . . . .
11
1.1.3. Expresii .................................. 12
1.1.3.1. Expresii intregi . . . . . . . . . . . . . . . . . . . . . . .
12
1.1.3.2. Expresii reale ........................ 12
1.1.3.3. Expresii logice
...................... 13
1.1.3.4. Expresii de tip !?ir de caractere . . . . . . . . . . . . 13
1.1.4. Operatii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
1.1.4.1. Operatii de intrare-ie!?ire . . . . . . . . . . . . . . . . 13
1.1.4.2. Operatii de decizie . . . . . . . . . . . . . . . . . . . . 14
1.1.4.3. Operatii de atribuire ................... 14
2. Principiile programarii structurate
. . . . . . . . . . . . . . . . . . . . .. . . . . . . . .
15
2.1. Structuri de baza. Descrierea acestora cu ajutorul schemelor logice
15
2.1.1. Operatii de intrare-ie!?ire . . . . . . . . . . . . . . . . . . . . . . .
15
2.1.2. Operatii de atribuire .......................... 16
2.1.3. Operatii de decizie ........................... 16
2.1.4. Reguli de detaliere a unei operatii complexe . . . . . . . . . . 18
2.1.5. Structura alternativa ......................... 18
2.1.6. Structura repetitiva .......................... 19
2.2. Structuri de baza. Descrierea acestora cu ajutorul unui limbaj de tip
pseudocod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
2.2.1. Prezentarea lirtlbajului ......................... 22
2.2.1.1. Variabile ........................... 22
2.2.1.2. lnstructiuni ......................... 23
2.3. Aplicatii ......................................... 27
3. Elemente de baza ale limbajului Pascal ........................... 46

3.1. Notiuni introductive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.1.1. Evolutia limbajelor de programare ................. 46
3.1.2. Structura programelor Pascal .................... 47
3.1.3. Descrierea sintaxei cu ajutorul diagramelor de sintaxa ... 48
3.2. Vocabularul limbajului . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.2.1. Setul de caractere ........................... 50
3.2.2. ldentificatori ............................... 50
3.2.3. Separatori l;ii comentarii ....................... 51
3.3. Constanta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
3.3.1. Constanta intregi ............................ 51
3.3.2. Constanta reale ... .......................... 52
3.3.3. Constanta !?ir de caractere ..................... 52

3.3.4. Constanta simbolice .......................... 53
3.4. Notiunea de tip de data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.4.1. Tipuri simple standard . . . . . . . . . . . . . . . . . . . . . . . .
54
3.4.1.1. Tipul boolean ........................ 54
3.4.1.2. Tipul char .......................... 54
3.4.1.3. Tipuri intregi ........................ 54
3.4.1.4. Tipuri reale . . . . . . . . . . . . . . . . . . . . . . . . .
56
3..5.
3.6.
3.7.
3.8.
3.4.2. Tipuri ordinale definite de utilizator ................ 57

3.4.2.1.Tipul enumerat ....................... 57
3.4.2.2. Tipul subdomeniu ..................... 58
3.4.3. Definirea tipurilor ........................... 58
Declararea variabilelor .......................... ..... 58
Definirea constantelor ............................... 60
Expresii ......................................... 60
Citirea i scrierea datelor ............................. 60
3.8.1. Citirea datelor .............................. 61
3.8.2. Scrierea datelor ............................. 61
4. lnstructiunile limbajului Turbo Pascal ............................ 62

4.1. lnstructiunea de atribuire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.2. lnstruqiunea IF .................................... 64
4.2.1. IF THEN ELSE .............................. 64
4.2.2. Forma IF THEN ............................. 65
4.3. lnstruqiunea compusa ............................... 66
4.4. lnstructiunea vida .................................. 67
4.5. lnstructiunea CASE ................................. 67
4.6. lnstructiunea WHILE ................................ 68
4.7. lnstructiunea REPEAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.8. lnstructiunea FOR .................................. 71
4.9. Aplicatii Ia capitolele 3 i 4 ............................ 76
5. Tipuri structurate de date .................................... 81
5.1. Tipul tablou . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.1.1. Tipul ARRAY .................. : ........... 81
5.1.2. Tipul. STRING .............................. 90
5.1.2.1. Functia COPY ....................... 94
5.1.2.2. Funqia POS ........................ 95
5.1.2.3. Procedura DELETE .................... 96
5.1.2.4. Procedura INSERT .................... 96
5.1.2.5. Procedura STR ...................... 97
5.1.2.6. Procedura VAL ...................... 98
5.2. Tipullnregistrare (RECORD) ........................... 98
5.2.1. Tipullnregistrare fixa ......................... 98
5.2.2. Tipullnregistrare cu variante ................... 104
5.3. Tipul de date multime .............................. 106
5.3.1. Constructori de tip multime .................... 107
5.3.2. Operatori ......\ .......................... 108
5.3.3. Constante .......... : . .................... 108
5.3.4. Constante de tip multime ..................... 110
5.4. Aplicatii Ia capitolul 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
5.4.1. Tipul ARRAY
............................. 111
5.4.2. Tipul STRING ............................. 118
5.4.3. Tipul RECORD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
5.4.4. Tipul multime . . . . . . . . . . . . . . .. . . . . . . . . . . . . . .
119
6. Subprograme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6. 1. Conceptul de subprogram . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2. Domeniul de vizibilitate a identificatorilor .................
6.3. Proceduri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
123
6.3.1. Declarare i apel ...........................
6.3.2. Parametri formali, parametri efectivi
.............
6.3.2.1. Transmiterea parametrilor prin referinta . . . . .
6.3.2.2. Transmiterea parametrilor prin valoare . . . . . .
1 22
122
122
.
123
129
130
130
6.4. Functii (declarare !?i apel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

6.4.1. Tipul funqiei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
6.5. Dezvoltare ascendenta, dezvoltare descendenta . . . . . . . . . . . . . 135
6.5. 1. Dezvoltarea ascendenta . . . . . . . . . . . . . . . . . . . . . . 135
6.5.2. Dezvoltarea descendenta . . . . . . . . . . . . . . . . . . . . . 136
6.6. Unitati de program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
6.6.1. Forma generala !?i constructia unei unitati de program . . 136
6. 7. Proceduri !?i functii predefinite . . . . . . . . . . . . . . . . . . . . . . . . 139
6.8. Parametri formali de tip procedura sau functie . . . . . . . . . . . . . 140
6.8.1. Tipul de date procedural . . . . . . . . . . . . . . . . . . . . . . 140
6.9. Programarea pe obiecte .............................. 143
6.9.1. Logica !?i mecanismul programarii pe obiecte . . . . . . . . 143
6.9.2. Mecanismul de realizare a programarii pe obiecte . . . . . 144
6.9.2.1. Sintaxa tipului obiect !?i incapsularea . . . . . . . 144
6.9.2.2. Mo tenirea . . . . . . . . . . . . . . . . . . . . . . . . 147
6.9.2.3. Atribuirea in cazul variabilelor obiect ....... 148
6.9.2.4. Proceduri cu parametri formali de tip obiect . . 149
6.9.2.5. Polimorfism . . . . . . . . . . . . . . . . . . . . . . . . 150
6.1 0. Aplicatii Ia capitolul 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 54
6.1 0.1. Proceduri, funqii, unitati de program, obiecte . . . . . . 154
7. Unitatea de program CRT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
7.1. Memoria video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
7.2. Ferestre .......................... '" ............ 161
7.3. Alte proceduri !?i functii specifice unitatii CRT . . . . . . . . . . . . . . 164
7.4. Aplicatii ........................... . . . . . . . . . . . . . 16 7
7 .4.1. Unitatea de program UTIL . . . . . . . . . . . . . . . . . . . . . 167
7.4.1.1. Procedura DESCHID F ................ 167
7.4.1.2. Procedura SCRIU F-.................. 167
7.4.1.3. Procedura A D SARA . . . . . . . . . . . . . . . . . 168
7.4.1.4. Procedura P[IMS SARA V ............. 169
7.4.1.5. Procedura PLIMS-SARA-0 ............. 170
7.4.1.6. Procedura CURSOR .. -:- ............... 170
7.4.2. Fereastra obiect . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
7.4.2.1. Metoda DESCHID ................... 174
7.4.2.2. Metoda SALVEZ .................... 175
7.4.2.3. Metoda RESTAUREZ ................. 175
7.4.3. Meniul obiect ............................. 177
7 .5. Aplicatii Ia capitolul 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
7 .5.1. ,Aplicatii ale unitatii de program CRT . . . . . . . . . . . . . . 182
8. Fi!?iere Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

8.1. Fi iere text .................. \ . . . . . . . . . . . . . . . . . .
187
8.1.1. Crearea !?i exploatarea fi!?ierelor text . . . . . . . . . . . . . . 188
8.1.2. Citirea variabilelor de tip char .................. 191
8.1.3. Citirea variabilelor de tip string . . . . . . . . . . . . . . . . . 192
8. 1.4. Citirea variabilelor de tip numeric . . . . . . . . . . . . . . . . 192
8.1. 5. Scrierea cu format implicit . . . . . . . . . . . . . . . . . . . . 193
8.1.6. Scrierea cu format explicit . . . . . . . . . . . . . . . . . . . . 193
8.1.6.1. Scrierea datelor de tip intreg . . . . . . . . . . . . 193
8.1.6.2. Scrierea datelor de tip real . . . . . . . . . . . . . . 194
8.1.6.3. Scrierea datelor de tip caracter . . . . . . . . . . 194
8.1.6.4. Scrierea datelor de tip string . . . . . . . . . . . . 194
8.1.6.5. Scrierea datelor de tip boolean . . . . . . . . . . . 194
8.1.7. Alte proceduri !?i functii care lucreaza cu fi!?iere text . . . 195
8.1.7.1. Procedura APPEND .................. 195
8.2.
8.3.
8.4.
8.5.
8.6.
8. 1. 7.1. Functia EOLN . . . . . . . . . . . . . . . . . . . . . .

8.1.8. Fi iere text standard . . . . . . . . . . . . . . . . . . . . . . . .
8.1.8.1. Fi ierele INPUT !?i OUTPUT . . . . . . . . . . . . .
8.1.8.2. Fi!?ierul PAN . . . . . . . . . . . . . . . . . . . . . . .
Validarea operatiilor de intrare I ie!?ire . . . . . . . . . . . . . . . . . . . .
8.2.1. Alte tipuri de validari . . . . . . . . . . . . . . . . . . . . . . . .
8.2.1.1. Validarea naturii datelor . . . . . . . . . . . . . . .
8.2.1.2. Testarea naturii numerice a datelor ........
8.2.1.3. Testarea naturii alfabetice a datelor
. . . . . . .
Fi!?iere cu tip ..................................... 200
8.3.1. Crearea fi!?ierelor cu tip ....................... 201
8.3.2. Procedura SEEK !?i functia FILESIZE .............. 204
8.3.3. Adaugarea de articole ........................ 205
Un exemplu de lucru cu un fi!?ier ....................... 210
Fi!?iere fara tip .................................... 223
Aplicatii Ia capitolul 8 .............................. 225
8.6.1. Aplicatii ale fi!?ierelor ........................ 225
8.6.1.1. Fi!?iere text . . . . . . . . . . . . . . . . . . . . . . . .
225
8.6.1.2. Fi!?iere cu tip ....................... 226
8.6.1.3. Fi!?iere fara tip ...................... 228
9. Unitatea de program DOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

9.1. Prelucrarea datei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9.2. Cautarea unui fi!?ier ................................
9.3. Executia unui program . . . . . . . . . . . . . . . . . . . . . . . . . . . .
231
9.4. Probleme propuse ........................ ........
. 230
. 230
231
. .
234
10. Grafica pe calculator ..................................... 235

10.1. lntroducere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
235
10.2. lnitializarea modului grafic .......................... 235
10.3. Culori ........................................ 237
10.4. Coordonate ecran !?i reprezentarea punctelor .............. 242
10.5. Punct curent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
243
10.6. Trasarea segmentelor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
243
10.7. Raportul aspect .................................. 244
10.8. Desenarea obiectelor grafice . . . . . . . . . . . . . . . . . . . . . . . . .
245
10.8.1. Desenarea unei linii frante .................... 245
10.8.2: Desenarea cercurilor, arcelor de cere !?ide elipsa .... 246
10.8.3. Desenarea unor obiecte ha!?urate ............... 247
10.9. Afi!?area textelor ................. : ............... 250
1O.lO. Tehnici de animatie .............................. 254
10.11. Fi!?iere imagine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
260
10.12. Ferestre grafice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
262
10.13. Elemente de grafica 20 ........................... 265
10.13.1. Desenarea graficului unei functii . . . . . . . . . . . . . . 265
10.13.2. Desenarea curbelor plane ................... 271
10.13.3. Rotatii ....... : ................ . . . . . . . . 275
10.13.4. Curbe BSPLINE .......................... 277
10.14. Elemente de grafica 3D . . . . . . . . . . . . . . . . . . . . . . . . . . .
278
10.14.1. Rotatia unei figuri In spatiu . . . . . . . . . . . . . . . . . . 285

10.14.2. Reprezentarea unei suprafete in spatiu .......... 287
10.14.3. Coordonatele sferice !?i aplicatiile lor ............ 291
10.14.4. Prezentarea integrala a unitatii UTILG . . . . . . . . . . . 295
10.15. Probleme propuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
ANEXA
Utilizarea meniurilor In limbajul TURBO PASCAL
. . . . . . . . . . 299
Capitolul 1
Notiunea de algoritm, caracteristici

Sa presupunem ca dispunem de un 'calculator electronic de buzunar, fara
program. Se cere sa se calculeze vaiorile funqiei de rnai jos, definita pe rnul!i
mea numerelor reale, pentru 10 valori date ale lui x (-3.1, 7, 0, 2.23, .a.m.d.).
I X *X-2, X<O
f(x)
-l
3, x=O
X
+2, X>0
Ce avem de facut? Consideram prima valoare a lui x, i anume -3.1. Obser

vam ca aceasta valoare este mai midi dedit 0. Avem de calculat X*X-3. Pen
tru a face acest calculll introducem pe x, II ridicam ia puterea a cioua (am pre
supus ca acest calculator poate efectua direct ridicarea Ia puterea a doua), din
rezultat scadem 2 !?i obtinem rezultatul dorit. Repetam caiculul pentru urmatoa
rele 9 valori. Sa nu uitam faptui ca pentru fiecare valoare a !ui x, noi trebuie sa
decidem care din cele trei variante de calcul va fi aleasa. Sa recunoa!?tem ca
o astfel de modalitate de lucru este plicticoasa i cere mult timp. Trebu!e gasit
un mod de lucru eficient. Care este acesta? Raspunsul Ia lntrebare constituie
subiectul actualului capitol.
Presupunem ca dispunem de un calculator programabil. Trebuie sa respec
tam urmatoarele etape de lucru:
elaborarea unui algoritrn d9 rezo:vae a problernei;
transpunerea flCestuia lntr-un lirnbaj de programa;e,:
rularea programului i ob!inerea rezuitatelor.
Ce este un algoritm i cum se elaboreaza?
In primul rand, trebu1e sa ne fie toart8 clar de !a ce pornim i ce avem de
facut. Cunoa!?tem funqia i 10 valori ale lui x. Trebuie calcuiata valoarea
func!iei pentru fiecare din cele 10 valori. Sarcina noastra poate fi sistematizata
astfel:
1
- se parcurg urmatoarele etape, de zece ori :
se cite te valoarea lui x;
Tn functie de valoarea propriu-zisa a lui x, se procedeaza astfel:
daca este negativa, se calculeaza f=x*x-2;
daca este 0, valoarea tunctiei este 3;
daca este pozitiva, se caiculeaza f = x + 2;
se scrie valoarea calculata pentru f.
Aceasta sinteza a ceea ce avem de facut se r,ume;;te algoritmul de rezoivare
a problemei propuse.
Notiuhea de algoritm este primara, nu se define te, intocmai ca i no iunea

de multime.Tn matematica. Cu toate acestea, ca i multimea, algoritmul poate
fi descris. In esen a, este vorba de o succesiune de etape care se pot aplica
mecanic pentru rezolvarea unei clase de probleme (pornind de Ia datele ini iale
sa conduca Ia solutie).
fn exemplul ante.rior, algoritmul poate fi aplicat pentru oricare 10 valori ale
lui x i nu numai pentru cele 10 date ini ial. Daca vom considera ca pentru
fiecare 10 valori avem o problema, Tnseamna ca algoritmul nostru este capabil
sa rezolve o infinita.te de probleme.
Pentru redactarea algoritmi!or se folosesc schemele logice i limbajele de
tip pseudocod. Despre acestea vom discuta In capitolul urmator.
Un algoritm bun trebuie sa satisfaca urmatoare!e cerinte: claritate, generali
tate 9i finititudine.
Claritatea este acea proprietate a algoritmului prin care procesul de calcul
este descris precis, tara ambiguita i.
Generalitatea este proprietatea algoritmului de a rezolva o lntreaga clasa de
probleme.
Revenind Ia problema prezentata Ia Tnceputul acestui capitol, se observa ca
algoritmul poate fi u9or modificat pentru a calcula valoarea func iei lntr-un
numar oarecare de puncte 9i nu numai In cele 1 0 presupuse initial. Mai general,
se poate obtine un algoritm care sa primeasca drept date de intrare atat nu'lla
rul de puncte cu valorile lor, cat 9i functia ale carei valori trebuie calculate.
Finititudinea este proprietatea algoritmilor de a furniza rezultate Tntr-un timp finit.
Referitor Ia aceasta ultima proprietate, se impun anumite precizari. Exista
probleme pentru care nu se cunosc algoritmi de rezolvare rapizi. Pentru anumite
seturi de date de intrare, este necesar un timp de calcul de ordinul sutelor sau
chiar miilor de ani i aceasta pe calculatoare ultramoderne. Din acest motiv, In
practica se considera ca pentru aceste probleme nu exista algoritmi de rezolvare,
chiar daca timpul de lucru este finit.
Observatii:
1. Nu exista un algoritm cu ajutorul caruia sa putem elabora oricare alt
algoritm. Acest fapt ne arata ca activitatea de e!aborare a algoritmilor nu este
u9oara. Ea presupune multa munca i fantezie.
2.
0 problema poate avea mai multi algoritmi de rezolvare. Unii dintre ei
conduc mai rapid Ia rezultat. Este sarcina noastra sa cautam un algoritm care
sa rezolve rapid problema. Aceasta lnseamna ca, atunci cand avem de elaborat
un algoritm, nu ne vom opri Ia prima solutie gasita.
Odata scris, un algoritm este codificat Tntr-un limbaj de programare co.nvena
bil ales i astfel se obtine programul. Acesta se ruleaza ori de cate ori este
necesar. Exista multe limbaje de programare, ca de exemplu FORTRAN,
COBOL, C, PASCAL.
in acest manual vom studia limbajul PASCAL.
1.1. Obiectele cu care lucreaza algoritmli: date, variabile,

expresiL op;::ra ii
1.1.1. Date
A9a cum am vazut, orice aigoritm porne9te.de Ia anurnite date de intrare, ie
prelucreaza, iar In final obtine date de ie9ire. In exemplu! prezentat, datele de
intrare sunt reprezentate de cele 10 valori ale lui x, iar date!e de ie ire sunt cele
10 valori ale lui f(x).
Datele pot fi clasificate dupa tipul lor:

lntregi;
reale;
logice;
9ir de caractere.
Datele din primele doua tipuri poarta nume!e de date numerice.
Datele intregi sunt n mere apar1inand mul!irr.ii numereior In tragi.
Dupa cum 9tim din matematica, mu!timea numerelor reale este o reuniune Tntre
multimea numerelor rationale i mul imea numere!or ira1ionale. Nici un calculator
din lume nu poate retine un numar irational, Tntrucat acesta are o infinitate de
zecimale. Din acest motiv, In informatica, printr-o data rea!a Tntelegem un numar
cu zecimale. La o astfel de data, In loc de virgula se fo!ose te punctul.
Exemplu: In loc de 3,25 se scrie 3.25.

0 data logica poate avea numai doua vaiori: TRUE (adevarat) sau FALSE (fals).
Dupa cum indica 9i nume!e, o dati:i de tip ir de caractere !nseamna un ir de
caractere cuprinse lntre doua semne apostrof.
Exemplu: 'un text'.

Aici este momentul sa vorlJim de o categorie aparte de date 9i anume
constantele. Acestea pot fi date de oricare dintre tipurile precizate. Eie se
caracterizeaza prin faptul ca sunt con inute In algoritm, fara a fi citite sau
obtinute din calcule.
Se folosesc Tn calculele care se fac sau sunt mesaje care trebuie sa apara Ia
fiecare rulare a programului rezultat In urma algoritmu!ui.
1.1.2. Variabile
In problema analizata avt3am de citit 10 valori de intrare. fn maternatica acestea
ar fi fost notate x 1, x2,...,x 1 0. fn prelucrare, pentru orice data de intrare de
acest tip se fac aceiea9i operatii. Este lipsit de sens sa explicam ce facem cu x'l
pentru
ca apoi sa explicam ce facem cu x2 etc. Din aces1 motiv, In algoritm se explica
ce se face cu un snume x, oricare ar fi el dintre cele -, 0. De asemenea, nu are rost
sa precizam ca se tipare9te f(x1) a poi f(x2) $.a.m.d. Se noteaza pur $i simplu ca
se tipare te f. Pentru algoritmul nostru, x if sunt variabile. Orice aigoritm lucreaza

cu varia bile. Cu toate ca o variabila ai e un nume unic, con inutui ei poate fi diferit
de Ia un moment Ia aitt.il Lh ,:: rcursul executiei programului. De aici provine i
denumirea de variabiUL D2daci'L l:l mod abstract, este posibil sa notam o intrare
cu x i o ie ire cu f, curn este posibil sa folosim aceasta abstractizare in momentul
in care algoritmul este transpus lntr-un limbaj de programare obtinandu-se un
program ce urmeaza a fi rulat pe calculator? Practic, in memoria calculatorului se
rezerva
pentru
variabila
diteXun
spatiu
de spatiu
memorie.
Aceasta
inseamna
am
rezervat
un fiecare
singur spariu
pentru
i un
singur
oentru
f. Tntr-un
astfel de
spatiu se poate retine Ia un moment de timp o singura valoare. Tipurile de variabile
coincid cu tipurile de date. Estf! normal sa fie aa intrucat intr-o variabila se poate
re ine numai un anurnit tip de date. In concluzie, printro variabiia intelegem un
ansamblu de patru elemente:
numele variabilei;
tipul ei;
valoarea ei Ia un moment dat;
locul in memoria ca!culatorului unde poate fi gasita variabila (adresa ei).
ca
1.1.3. Expresii
Cu ajutorui constantelor, variabilelor i operatorilor se pot construi diverse
xpresii. Acestea se scriu dupa reguli precis determinate, dar (in general)
,:ceste reguli sunt preluate din matematica. In scrierea expresiilor este permisa
fo!osirea para ntezeior.
Ca i variabilele, expresiile sunt Je mai multe tipuri:

intregi;
reale;
logice;
de tip ir de caractere.
1.1.3.1. Expresii lntregi
,/
Folosesc operatorii +, -, ' (pentru inmul ire), DIV (pentru catul Tmpartirii
intre"i), MOD (pentru restrlllnrar irii intregi) .a.
Rezultatul evaluarii !or este un n'-lrnar intreg.
Exemp!e:
3 x + 7, unde x este o vari:Jbiia htreaga;
a .. (b +c), unde a,b,c sunt var,abi!e 1ntreg1.
1.1.3.2. Expresii reale

Operanzii care le a!ci:lt ,iesc slmt constante $i variabiie Tntregi sau reale. Pe
lana operatorii utilizai In c2drul expresiilor Tntregi putem utiliza i altii ca ar fi
de exemplu I (pentru lmpar irea cu zecimale). Rezultatu1 evaiuarii lor este
lntotdeauna un numar rea!.
1.1.3.3. Expresii logice

Rezultatul lor poate avea numai doua valori: TRUE sau FALSE.
Operatorii sunt cei din logica matematica: OR, AND, NOT. De asemenea este
permis sa folosim i operatorii <, >, >= (mai mare sau egal), <= (mai mic sau
egal), <> (diferit).
Exemple:
a OR b, unde a l?i b sunt variabile logice;
(a> =b)AND(c<d).
Pentru folos-irea corecta a expresiilor logice trebuie sa avem cuno tinte de
logica matematica.
1.1.3.4. Expresii de tip ir de caractere
Se folosesc constante l?i variabile de tip ir de caractere. Singurul operator
permis este operatorul + avand semnificatia de concatenare (scrierea a celor
doua iruri unul dupa altul).
Exemplu: a+ ' text', unde a este o variabila de tip

continutul 'acest' are ca rezultat l?irul 'acest text'.
ir de caractere avand
1.1.4. Operatii
Tn linii mari, operatiile care se fac intr-un algoritm se pot clasifica Tn trei categorii:
operatii de intrare-ie ire;
operatii de atribuire;
operatii de decizie.
1.1.4.1. Operatii de intrare-ie ire
Am aratat ca orice algoritm lucreaza cu date de intrare i de ie ire.
Acestea pot fi citite sau scrise.
Prin operatia de intrare (de citire) se Tntelege preluarea unei date de Ia un
dispozitiv de intrare catre memoria interna a calculatorului, Tn spa iul rezervat pen
tru aceasta (spatiul rezervat pentru variabila care prime te ca valoare acea daHi).
Dispozitivele de intrare pot fi urmatoarele:
tastatura (eel mai des utilizata);
unitatea de discheta;
unitatea de disc.
Prin operatia de ie ire (scriere) se in elege trecerea unei date din memoria
interna catre un dispozitiv de ie!?ire.
Dispozitivele de iel?ire pot fi urmatoarele:
monitorul;
unitatea de discheta;
unitatea de disc.
1.1.4.2. Opera1ii de decizie

in cadrul unui algoritm, Tn funqie de datele de intrare se pot realiza anurnite
operatii. Tn exemplul nostru, se face un anumit calcul atunci cand data de
intrare corespunzi:Hoare variabilei x este negativa l?i altul in cazul ca aceasta
este pozitiva.
In functie de valoarea datei de intrare, se ia o decizie sau alta. Tn genera1, in
functie de.anumite condi1ii, trebuie facute anumite operatii sau altele. Operatia
prin care testam acele conditii se nume!?te opera1ie de decizie. In functie de
rezultatul testului, algoritmul executa anumite operatii.
1.1.4.3. Opera1ii de atribuire
Am vazut ce este o variabila. Tn algoritm aceasta poate lua diferite valori ca
urmare a operatiilor de intrare sau a opera11ilor de atribuire. Acest din urma caz
ne intereseaza a cum.
Sa presupunem ca un algoritm folose!?te o variabila notata arbitrar z !?i o alta no
tata y. Dorim ca z sa ia o anumita valoare (de exemplu 1). Spunem ca am atribuit
variabilei z valoarea 1 l?i pentru moment \rom nota acest lucru astfel: z: = 1. Atat
timp cat asupra variabilei z nu efectuam nici o alta operatie de atribuire l?i nu efec
tuam nici o operatie de citire, aceasta il?i pastreaza valoarea 1. Presupunem ca scri
em valoarea variabilei z pe monitor. Dupa scriere variabila z va avea In continuare
valoarea 1. Presupunem ca atribuim variabilei y valoarea variabilei z (y: = z). in urma
atribuirii, valoarea variabilei y va fi 1 si valoarea variabilei z ramane 1. Acest lucru
este mai greu de lnteles Ia inceput. in'imaginatia noastra, daca y a luat valoarea lui
z ar trebui ca y sa aiba valoarea 1 l?i z sa nu mai aiba nici o valoare, ca 9i cand citra
1 s-a mutat efectiv in variabila y 9i ea nu se poate gasi simultan in doua locuri.
Atribuim lui y valoarea z + 2 (y: = z + 2). Prin aceasta intelegem ca s-a
efectuat z + 2 (1 + 2) l?i y a luat valoarea 3. Valoarea continuta de variabila y
inainte de aceasta atribuire ( 1) se pierde iar y va avea valoarea 3. Atribuim
variabilei x valoarea 1. Atribuim variabilei x valoarea x+x+3 (x:=x+x+3). Tn
acest caz x va lua valoarea 5 (1 + 1 + 3). Vechea valoare 1 (a variabilei x) se
pierde. Daca repetam aceasta atribure (x:=x+x+3), x va lua valoarea 13
(5+5+3).
In concluzie, operatia de atribuire se efectueaza astfel:
se evalueaza expresia din partea dreapta a operatiei de atribuire;
valoarea care se obtine astfel este preluata de variabila din partea stanga,
iar valoarea avuta de aceasta se pierde.
fntrebari recapitulative:
1. Dorim sa calculam suma 99 + 1. Concepem un procedeu de calcul astfel:
se pune 1 pe prima pozitie;
se pun doua cifre 0.
Este acesta un algoritm?
2. Exista un algoritm capabil sa calculeze toate zecimalele numarului pi?
3. Care va fi valoarea variabilei x dupa secventa de atribuiri care urmeaz<P
x: = 3; -Af: = 1;
x: = x+x; y: =x+y;
x: =y.
Capitolul 2
Principiile programarii structurate

Programarea structurata a aparut Ia lnceputul anilor 70. Este un concept cu
o importanta fundamentala In scrierea algoritmilor. Cine lnvaa sa redacteze
structurat algoritmii dispune de mari avantaje, cum ar fi:
o mai mare u urinta de scriere a algoritmilor;
., odata scris, un algoritm se lntelege mult mai u or (lnainte de apan 1a
programarii structurate, dupa o perioada, nici eel care redactase algoritmui nu
II mai Tntelegea.
. In principaJ, eel care redacteaza un algoritm utilizand programarea structu
rata respe'cta structurile care vor fi prezentate ulterior. In acest manual vom
lnvata sa redactam algoritmii direct structurat, varianta nestructurata inand
deja de istoria informaticii.
2.1. Structuri de baza. Descrierea acestora cu ajutorul

schemelor logice
Pentru reprezentarea algoritmilor pot fi foJosite schemele logice. Aceasta
reprezentare este utila In special In perioada de ini iere. Grice schema logica
Tncepe cu un bloc de START i se termina cu unul de STOP. Aceste doua
blocuri sunt unice. Ele se reprezinta aa cum se vede mai jos.
(......._s_T_A_R_T_ .,)
Figura 2.1.1.
( _S_TO_P
..)
Figura 2.1.2.
Am aratat caIn orice algoritm se executa trei tipuri de opera ii: de intrare-ie
:;;ire, de atribuire :;;i de decizie. Toate aceste operatii se pot reprezenta cu
ajutorul unor simboluri speciale.
2.1.1. Operatii de intrare-iel?ire

Aceste operatii se reprezinta grafic cu ajutorul unor paralelograme cum sunt
cele de mai jos:
Cite te A, B
Figura 2.1.3.
Serle C
Figura 2.1.4.
2.1.2. Operatii de atribuire

Pentru reprezentarea unei astfel de operatii se folosel?te dreptunghiul:
C :=A+ B
Figura 2.1.5.
2.1.3. Operatii de decizie

Grafic, acestea se reprezinta utilizand rombul, a9a cum
urmi:\toare:
rezulta din
fiyura
DA
NU
Figura 2.1.6.
In cazul algoritmilor cu un grad mai mare de complexitate, este dificil sa

scriem de Ia inceput o schema logica completa :;;i corecta. Din acest motiv,
pentru aqiuniinca nedetaliate folosim un bloc special, cum este eel de mai jos, caruia
ii ata:;;am un nume.
II
PREL
II
Figura 2.1.7.
Pana acum, am aratat cum se reprezinta operatiile pe care le executa un

algoritm. Trebuie aratata l?i succesiunea in care se executa aceste operatii.
Blocurile prezentate sunt unite intre ele prin linii pe care se marcheaza sensul
de. parcurgere (arce). in situatia Tn care sensul de parcurgere este de sus Tn jos,
marcarea nu mai este necesara.
Cum se reprezintc':i algoritmii cu ajutorul schemelor logice? Grice schema
logic a contine obligatoriu cele doua blocuri START i STOP, Tntre care sunt
reprezentate toate operatiile necesare prelucrarii propriu-zise.
Figura 2.1.8.
lnterpretarea acestei scheme este urmatoarea:

se porne te de Ia blocul de START i se cauta un drum catre blocul de
STOP;
acest drum trece prin blocul ACTIUNE (specific oricarui algoritm) care
sintetizeaza ce trebuie sa facem Tn algoritmul respectiv.
Urmeaza detalierea blocului ACTIUNE. intr-o prima faza, se evidentiaza una
dupa alta operatiile algoritmului care pot fi citiri, scrieri, atribuiri, decizii sau
alte operatii complexe Tnca neprecizate in amanunt.
Exemplu: Sa se citeasca un numar intreg (citirea se va face intr-o variabila
a) Ai sa se tipareasca.
In acest caz, blocul ACTIUNE poate fi detaliat astfel:
citirea numarului;
scrierea lui.
Schema logica corespunzatoare acestui algoritm este cea din figura
urmatoare:
Figura 2.1.9.
Observa.tii:
structurile din figurile 2.1.8 i 2.1.9 sunt structuri secventiale;
forma generala a unei structuri secventiale este cea din figura 2.1. 10.
Figura 2.1.10.
2.1.4. Reguli de detaliere a unei operatii complexe

Fiecare bloc ce desemneaza o operatie complexa (inca neprecizata In
amanunt) se detaliaza respectand urmatoarele structuri:
structura secventiala (a fost prezentata);
structura alternativa (cu cele doua forme ale sale);
structura repetitiva (cu cele doua forme ale sale).
2.1.5. Structura alternativa

Cum intervin deciziile Tn schema logica? Modul de reprezentare grafica a unei
decizii a fost deja aratat. Sa presupunem un bloc ce reprezinta o operatie
complexa care consta din:
evaluarea unei expresii logice;
Tn cazul Tn care expresia ia valoarea TRUE, se executa o o.peratie A 1;
Tn caz contrar (valoarea FALSE), se executa aqiunea A2.
Operatiile A 1 i A2Apot fi operatii de citire-scriere, atribuire sau alte operatii
ce necesita detaliere. In schemele logice, acestea se reprezinta printr-o structu
ra ca aceea din figura 2.1.11., numita structura alternativa sau (pentru ca
deocamdata nu a fost studiata) IF THEN ELSE.
in anumite cazuri, dupa evaluarea expresiei logice, trebuie efectuate anumite
opera1ii numai daca expresia ia valoarea TRUE. Se obtine astfel o structura
alternativa de tip IF THEN.
Exemplu de structura IF THEN ELSE: Se citesc doua numere a 9i b. Sa se
tipareasca eel mai mare dintre ele.
Analizam ce avem de facut:
citim primul numar;
citim al doilea numar;
Figura 2.1.11.
Figura 2.1.12.
vedem care este mai mare i il tiparim.

Ultima operatie (complexa) trebuie transcrisa Tntr-o structura alternativa. Tn
mod practic, se procedeaza astfel:
se verifica daca a este mai mare decat b;
daca acest lucru este adevarat, se tipare:;;te a;
in caz contrar se tipare!?te b.
Figura 2.1.13.
2.1.6. Structura repetitiva

De multe ori, este necesara repetarea unor operatii. Din acest motiv, in
cadrul schemelor logice putem folosi structura repetitiva. Aceasta are doua
forme:
structura repetitiva conditionata anterior;
structura repetitiva conditionata posterior.
Structura repetitiva conditionata anterior se mai nume9te 9i structura de tip

WHILE DO. Aceasta este folosita In cazul in care:
avem de evaluat o expresie logica;
daca in urma evaluarii obtinem valoarea FALSE, se trece mai departe;
daca in urma evalua.rii obtinem valoarea TRUE, se executa o operatie (care poate fi 9i complexa), dupa care totul se reia. Reprezentarea grafica a
acestei structuri se poate observa in figura urmatoare:
NU
DA
Figura 2.1.14.
Exemplu: Sa presupunem ca avem de calculat suma primelor n numere naturale.
Mai jos este prezentata schema logica completa pentru aceasta problema.
STOP
Figura 2.1.15.
Cum a fost alcatuita l?i cum se cite!?te aceasta schema?
Trebuie sa rezolvam urmatoarele probleme:
citirea lui n;
ini ializarea variabilei s, in care vom calcuia suma (prin initializare se

intelege ca variabila capata valoarea 0, in caz contrar este posibil ca
variabila sa aiba o alta valoare reziduala, deCi rezultatul va fi grel?it);
sa adunam pe rand numerele 1 ,2, ...,n Ia
s;
Pentru a realiza aceasta ultima operatie procedam astfel:
o consideram o variabila i care va lua pe rand valorile 1 ,2, ...,n (initial iva
lua valoarea 1 );
o de n ori il insumam pe i Ia s, de n ori il marim pe i cu 1 (controlul asupra
faptului ca facem aceasta operatie de n ori se realizeaza comparand pe i cu
n).
Sa probam functionarea algoritmului pe schema logica:
se pornel?te de Ia blocul START;
se cite te n (pentru exemplificare presupunem valoarea 3);
i va lua valoarea 1 iar s va lua valoarea
0;
i este mai mic decat n (3), deci s va lua valoarea 0 + 1 = 1 iar i va lua
valoarea 2;
i este mai mic decat n, deci s va lua valoarea 1 + 2 = 3 iar i va lua valoarea 3;
i este egaI cu n, dec( s va lua valoarea 3 + 3 = 6 iar i va lua valoarea

4;
i nu este mai mic sau egal cu n, deci se tipare!?te s (6) i algoritmul se oprel?
te.
Schema repetitiva conditionata posterior se mai nume te i schema de tip
REPEAT UNTIL. Se folose te in cazul in care:
avem de executat o anumita opera ie;
evaluam o expresie logica;
o in cazul in care expresia ia valoarea TRUE, se trece mai departe;
o in caz contrar, se reia totul.
Grafic, aceasta se reprezinta astfel:
Figura 2.1.16.
Tema : Refaceti algoritmul anterior utilizand aceasta structura.

Observa,tie : Aa cum reiese i din cele doua desene, pozitia blocului de
decizie este diferita fata de cea a blocului de calcul. Astfel, in primul caz este
posibil sa nu se ajunga Ia blocul de calcul, in timp ce, in cazul al doilea se
trece eel pu in o data prin acesta.
2.2. Structuri de baza. Descrierea acestora cu ajutorul

unui limbaj de tip pseudocod
Practica a demonstrat ca utilizarea schemelor logice in programare este
anevoioasa din urmatoarele motive:
spatiul mare ocupat de acestea, fapt ce conduce Ia urmarirea dificila a
algoritmului;
posibilitati mici de inserare a comentariilor;
neplaceri legate de reprezentarea grafica.
Toate acestea au determinat marea majoritate a programatorilor profesioni9ti
sa renunte Ia ele. Trebuia gasit ceva care sa le inlocuiasca cu succes. Astfel,
au aparut limbajele de tip pseudocod. Ce sunt ele? in primul rand sunt limbaje
pentru descrierea algoritmilor. Ele contin condensat, sub forma de instructiuni,
subschemele clasice ale programarii structurate. Cu ajutorullor se pot descrie
cu u9urinta algoritmii. Exista o mare asemanare intre ele 9i limbajele de progra
mare. Acest fapt permite ca, odata descris un algoritm Jntr-un limbaj de tip
pseudocod, conversia intr-un limbaj de programare sa se faca aproape in mod
mecanic. Din acest motiv, mai toate cursurile referitoare Ia algoritmi care apar
in strainatate l?i in tara folosesc pentru descrierea lor aceste limbaje. Se pune
intrebarea urmatoare: daca aceste limbaje de tip pseudocod sunt atat de
asemanatoare limbajelor de programare, care este motivul pentru care algoritrnii
nu se descriu direct intr-un limbaj de programare? lata numai doua din motivele
care au condus Ia aceasta situatie:
limbajele de tip pseudocod au o sintaxa mai Iibera decat orice limbaj de
programare;
un algoritm scris intr-un limbaj de tip pseudocod este inteles de to!i
programatorii, In timp ce unul scris lntr-un anumit limbaj de programare va
fi inteles numai de cunoscatorii limbajului respectiv.
Exista o mare diversitate de limbaje de tip pseudocod. Practic, oricine T i
poate concepe propriullimbaj. Totul?i, in practica, s-a impus eel prezentat aici,
datorita faptului cain strainatate au aparut multe lucrari privind algoritmii in
care ace9tia sunt descri9i tocmai in acest limbaj.
inaintea prezentarii limbajului trebuie sa intelegem notiunea de ,cuvant
cheie" care intervine in studiul acestuia. lntr-un limbaj exista anumite cuvinte
care au un inteles strict. Ele nu pot fi folosite in nici un alt context.
2.2.1. Prezentarea limbajului
2.2.1.1. Variabile
Variabilele pot fi clasificate dupa tipul lor.
1.
Variabile intregi
Au capacitatea de a retine numere intregi. Pentru recunoa$terea :or se
folose9te cuvantul cheie INTEGER.
Exemp/u: INTEGER a,b.
Am declarat doua variabile Tntregi a 9i b.
2.
Variabile reale
Cu ajutorul lor se retin numere cu virgula (ra ionale). Pentru recunoa!?terea
lor folosim cuvantul cheie REAL.
Exemplu : REAL c, d, e.
Am declarat trei variabile reale numite c, d 9i e.
3.
Variabile logice (boolene)

,
Au capacitatea de a retine numai doua valori 9i anume TRUE (adevarat) i
FALSE (fals).
Exemplu: BOOLEAN
h; Am declarat o variabila numita h, de tip boolean.
2.2.1.2. lnstructiuni
In capitolul anterior am aratat faptul ca un algoritm executa trei tipuri de
operatii !?i anume: de intrare-ie!?ire, de atribuire !?i de decizie. Fiecarei operatii,
in limbaj ii corespunde o instructiune.
1.
a.
lnstructiuni de intrare-ie ire

lnstructiunea READ
Preia o informatie din exterior in memoria principala. Pentru simplitate

consideram ca informatia este preluata de Ia tastatura.
Exemp/u:
INTEGER a
REAL b
READ a,b
Se citesc doua numere, unul intreg, altul real. Dupa citire cele.doua numere
se gasesc in va'riabilele a i b.
b.
lnstructiunea WRITE
Preia o informatie din memorie (din cadrul unei variabile) si o scrie in exterior.
Pentru simplitate,consideram faptul ca informatia este sc.risa pe monitor.
Exemp/u:
INTEGER a
READ
WRITE a.
I
Se cite te de Ia tastatura un numar intreg in cadrul variabilei a (pe scurt

putem spune ca citim un numar a). Acest numar e tipare te pe monitor.
2.
lnstructiunea de atribuire
Este de forma v: =e.

Semnificatia este urmatoarea:
v - nume de variabila;
e - o expresie.
in acest caz trebuie ca tipul expresiei sa coincida cu tipul variabilei.
Exemp/e:
INTEGER a;
a:
=2
a: =a+3.
in urma executiei acestei secvente a va contine numarul intreg 5.

INTEGER a,b
BOOLEAN c;
a:=3 b:
=4
c:=a>b.
in urma executiei acestei secvente, c va avea valoarea FALSE.

3.
lnstructiunea STOP
Are rolul de a marca sfarl;iitul unui program.

4.
lnstructiuni de decizie
Aceste instructiuni se Impart Tn doua categorii:

instructiuni de ramificare;
instructiuni repetitive.
a.
lnstructiunea de ramificare
Corespunde structurii alternative de Ia scheme

urmatoarea:
IF conditie
logice. Forma ei aste
THEN sl
[ELSE s2]
END IF
Aici, s 1, s2 reprezinta secvente de alte instructiuni.

Ceea ce este Tncadrat Tntre paranteze drepte este optional.
Principiul de funqionare al acestei instruqiuni (Tn cazul formei complete)
este urmatorul:
se evalueaza conditia;
o daca aceasta este Tndeplinita se executa secventa s 1;
o Tn caz contrar se executa secventa s2.
se trece Ia instructiunea urmatoare.
in cazul Tn care clauza ELSE lipse!?te, principiul de funqionare este:
se evalueaza conditia;
,.
daca aceasta este Tndeplinita, se executa secventa de instruqiuni s 1;
Tn caz contrar, se trece mai departe.
Exemplu de program:
Se citesc doua variabile Tntregi. Sa se tipareasca cea mai mare dintre ele.
INTEGER a,b;
READ a, b
IF a>b THEN WRITE a
ELSE WRITE b
END IF
STOP.
b.
lnstructiunea repetitiva (WHILE)

Forma generala este:
WHILE expresie logica
s
REPEAT.
s reprezinta o secvena de instruc iuni.

Principiul de func ionare este urmatorul:
se evalueaza expresia logica;
daca aceasta are valoarea FALSE se trece Ia instruc iunea urmatoare;
daca valoarea ei este TRUE, se executa secvena s dupa care se pornel?te
din nou cu evaluarea expresiei logice.
Procedeul continua pana cand, Ia evaluare, expresia logica are valoarea
FALSE. Aceasta instruqiune corespunde Tn limbajul schemelor logice structurii
repetitive condi ionate anterior.
Sa se scrie un program care calculeaza suma primelor n numere naturale
(se presupune ca nu se cunoal?te formula directa).
INTEGER n,i,s;
READ n
s:=o
i:=l
WHILE i<=n
s:=s+i
i:=i+l
REPEAT
WRITE s.
Sa analizam funqionarea pentru n = 3:

se cite te n (citesc 3);
s ia valoarea 0 iar i ia valoarea 1;
i este mai mic decat n (1 este mai mic decat 3) deci s va lua valoarea
0 + 1 = 1 iar i va lua valoarea 2;
i este mai mic decat trei deci s va lua valoarea 1 + 2 iar i va lua valoarea 3;
i este egal cu n ( deci este Tndeplinita condi ia) caz Tn care s va lua valoarea
3 + 3 = 6 iar i va lua valoarea 4;
i este mai mare decat n, deci se trece Ia instruqiunea urmatoare;
se tipare te 6.
lnstructlunile prezerltate pana aici sunt suficiente pentru descrierea unui
algoritm. In practica se folosesc :;;i alte doua instructiuni repetitive care
determina ca programul sa fie mult mai U.!?or de citit.
5.
lnstructiunea repetitiva DO
Corespunde structurii
urmatoarea:
DO
repetitive conditionate posterior. Forma
UNTIL expresie logica.
Principiul de functionare este urmatorul:
ei
este
se executa secvena s;
daca in urma evaluarii expresiei se ob ine valoarea TRUE, se trece ia
urmatoarea instructiune;
in cazul in care expresia ia valoarea FALSE, se reia executia secventei s
.a.m.d. Secvena s este executata pana cand expresia logica ia valoarea
TRUE.
Pentru exemplificare, reluam problema anterioara:
INTEGER n,i,s;
READ n
i:=l
s:=o
DO
s:=s+i
i:=i+l
UNTIL i>n
WRITE s
STOP
I
Sa vedem cum decurge algoritmul dupa citirea lui n (citim 3):

i ia valoarea 1 iar s ia valoarea 0;
s ia valoarea 0 + 1 = 1 iar i ia vaJoarea 2;
i nu este mai mare decat 2, deci s va lua valoarea 1 + 2 = 3 iar i va lua
valoarea 3;
i nu este mai mare ca 3 deci s va lua valoarea 3 + 3 = 6 iar i va lua
valoarea
4;
i este mai mare decat n deci se trece Ia instruqiunea urmatoare unde se
tipare:;;te valoarea 6.
I
6.
lnstructiunea repetitiva FOR
Forma gener?la a as;estei instruc iuni este urmatoarea:

FOR variabila de ciclare:= valoare ini iala, valoare finala
REPEAT
Variabila de ciclare trebuie sa fie de tipuiiNTEGER. Valoare ini iala, valoare

finala sunt expresii aritmetice de tipul INTEGER.
Principiul de funqionare este urmatorul:
variabilei de ciclare i se atribuie valoarea initiala;
se executa secvena s;
variabilei de ciclare i se adauga 1;
daca 'nu s-a depal?it valoarea finala se executa secvena s;
procedeul continua pana cand variabila de ciclare depa:;;e:;;te valoarea finala.
In situatia in care, de Ia bun ir)t:eput valoarea initiala depal?e te valoarea
finala, se trece Ia instructiunea urmatoare.
Reluam problema referitoare Ia calculul sumei primelor n numere naturale:.
)
!NTEGER n,s,i;
READ n
s:=o
FOR i:=l,n
s:=s+i
REPEAT
WRITE s
STOP.
Algoritmul decurge astfel:

se cite9te n ( presupunem n =
3);
s ia valoarea 0, iar i valoarea 1;
se calculeaza s = 0 + 1 =
1;
i ia valoarea 2;
3;
i ia valoarea 3;
6;
i ia valoarea 4 l?i Tn acest fel se depa:;;el?te valoarea lui n;
se trece Ia instruc iunea urmatoare unde se tipare:;;te valoarea 6.
2.3. Aplicatii
in acest paragraf se prezinta cateva probleme rezolvate. Algoritmul propus
pentru ele este prezentat atat sub forma de schema logica cat :;;i 'fn limbaj
pseudocod.
Problema 1
Se citesc doua variabile de tip intreg, A :;;i B. Sa se interschimbe con inutul

celor doua variabile :;;i sa se tipareasca.
La prima vedere, am fi tentati sa scriem secventa urmatoare:
INTEGER a,b;
READ a,b
a: =b
b: =a
WRITE a,b
STOP.
Aceasta secventa este gre:;;ita. Atunci cand variabilei a i se atribuie valoarea

variabilei b, con inutul variabilei a se pierde. Sa presupunem ca am citit a= 3
l?i b=4.
Prin atribuirea a:= b, con inutul lui a va fi 4 iar al lui b va fi tot 4: Prin
atribuirea b: =a continutul celor doua variabile va fi acela:;;i. Din acest motiv,
in urma executiei acestui algoritm se va tipari 4 :;;i 4. Pentru a Iuera corect,
trebuie considerata o variabila intermediara c de acelal?i tip ca a :;;i b. Secventa
corecta este urmatoarea:
c:=a
a: =b
b: =c
in acest mod, continutul variabilei a se salveaza 'fn c (deci nu se pierde Ia a
doua atribuire). Pentru valorile 3l?i 4 presupuse ca citite pentru a :;;i b vom avea
In ordine:
lui c i se atribuie valoarea 3;
lui a i se atribuie valoarea 4;

lui b i se atribuie valoarea 3.
Prezentam mai jos algoritmul sub forma de schema logica l?i pseudocod.
Figura 2.3.1.
INTEGER a,b,c;
READ a,b
c:=a
a: =b
b: =c
WRITE a,b
STOP.
in anumite cazuri se poate evita folosirea unei variabile intermediare. Sa con

sideram algoritmul urmator realizat Tn pseudocod. Acesta rezolva aceea i
problema.
INTEGER a,b;
READ a,b
a: =a+b
b: =a-b a:
=a-b WRITE
a,b
STOP.
Pentru valorile citite ale lui a l?i b algoritmul functioneaza astfel:

lui a i se atribuie valoarea 3 + 4 = 7;
lui b i se atribuie valoarea 7-4 = 3;
lui a i se atribuie valoarea 7-3 = 4;
se tipare te a= 4 l?i b = 3 (rezultat corect).
Problema 2
Sa se elaboreze algoritmul pentru rezolvarea unei ecuatii de gradul 1 .
Forma generala a ecuatiei de gr_?dul 1 este a* x + b = 0. In matematica

se presupune ca a este diferit de 0. In programare acest lucru nu este
posibil intrucat, din gre:;;eala, eel care il introduce pea ii poate da acestuia
valoarea 0. Din acest motiv se va lua in discutie si acest caz. Din analiza
problemei rezulta ca a poate avea valoarea 0 sau vaiori.diferite de 0. In cazul in
care a este diferit de 0 se calculeaza solutia x: = -b/a. Daca a este 0, trebuie
sa vedem cum este b: Daca i b este 0, inseamna ca orice numar real
verifica ecuatia, in caz contrar ecuatia nu are solutie.
Trebuie sa citim variabilele a :;;i b, sa le prelucram dand solutia sau mesajele
corespunzatoare. 0 prima schema logica ar arata astfel:
Figura 2.3.2.
Analizam ce avem de facut in operatia PREL. Vom proceda in mod diferit
pentru cazurile a = 0 i pentru a diferit de 0. Daca a este diferit de 0, putem
calcula x i sa-l tiparim. Cazul in care a= 0 nu-l analizam pe moment. Schema
devine:
Figura 2.3.3.
Analizam PREL1. Acum 9tim ca a este 0. Procedam diferit 'in funqie de

valorile lui b. Daca b este 0, avem o infinitate de solutii, in caz contrar nu avem
nici una. Rezulta schema finala:
Figura 2.3.4.
in pseudocod, algoritmul arata astfel:
REAL a,b,x;
READ a,b
IF a<>O THEN
x: =-b/a
WRITE x
ELSE
IF b=O
THEN WRITE 'infinitate de solutii'
ELSE WRITE nu avem solutii
ENDIF
ENDIF
STOP.
Problema 3
Se dau trei numere reale a, b, c.
Sa se calculeze valoarea expresiei:
Ia b, daca
e
c>O
1ab, daca C=O

a-b, daca c<O
Dupa ce citim a, b, c vedem daca c este mai mare decat 0. In caz afi::,na iv,
calculam a+ b. Tn caz contrar se efectueaza operatia PREL, pe care o vom deta
lia ulterior. 0 prima forma a schemei logice se gase!?te mai jos.
Figura 2.3.5.
Daca c nu este mai mare decat 0, inseamna ca este mai mic sau ega! cu 0.
Testam daca el nu este 0. in caz afirmativ calculam produsul a*b, in caz con
trar calculam a-b. Acum putem scrie schema logica finala.
Figura 2.3.6.
in pseudocod algoritmul arata astfel:
REAL a,b,c,e;
READ a,b,c
IF c>O THEN
e:=a+b
ELSE
IF c=O
ENDIF
ENDIF
WRITE e
STOP.
THEN e:=a*b
ELSE e: =a-b
Problema 4
Se citesc trei numere intregi a, b, c. Sa se tipareasca in ordine crescatoare.
ldeea de lucru este urmatoarea:
se compara primele doua (a !?i b);
dupa ce se cunoaste ordinea intre acestea, se incearca plasarea lui c fata de ele.
in prima forma, schema logica arata astfel:
.
STOP
Figura 2.3.7.
Daca a este mai mic decat b trebuie vazut unde il plasam pe c. El poate fi
mai mic decat a, deci ordinea ar fi c, a, b, sau mai mare sau egal cu a. In acest
din urma caz, c trebuie comparat cu b. Daca el este mai mic decat b, ordinea
este a, c, b, in caz contrar - este a, b, c. Tot asa se rationeaza In situatia in
care a nu este mai mic decat b (este mai mare. sau egal). Tn final se obtine
schema logica din figura 2.3.8. Tn pseudocod, algoritmul arata astfel:
INTEGER a,b,c;
READ a,b,c
IF a<b THEN
IF c<a THEN WRITE c,a,b
ELSE .IF c<b THEN WRITE a,c,b
ELSE WRITE a,b,c
ENDIF
ENDIF
ELSE
IF c<b THEN WRITE c,b,a
ELSE
IF c<a THEN WRITE b,c,a
ELSE WRITE b,a,c
ENDIF
ENDIF
ENDIF
STOP.
DA
Figura 2.3.8.
0 alta modalitate (mai generala) de rezolvare a acestei probleme va fi
descrisa in continuare. Consideram trei numere oarecare, spre exemplu 7, 4,
1. Avem dreptul de a inversa pozitiile a doua numere alaturate. Dorim ca, In
final, numerele sa fie scrise in ordine crescatoare.
lata cum procedam:
7 este mai mare decat 4, deci se inverseaza cele doua numere, obtinand 4 7 1;
7 este mai mare decat 1, deci se inverseaza cele doua numere 4 1 7;
4 este mai mare decat 1, deci obtinem 1 4 7.
Acest exemplu numeric ne sugereaza posibilitatea de a rezolva altfel
problema anterioara:
In locul numerelor consideram variabilele a, b, c;
,
comparam pe rand a cu b, b cu c !?i din nou a cu b, iar daca este cazul
interschimbam continutul acestor variabile.
in pseudocod, algoritmul propus arata astfel:
NOT 1167
Figura 2.3.9.
INTEGER a,b,c;
READ a,b,c
IF a>b THEN
m:=a
a:=b
b: =m
ENDIF
IF b>c THEN
m:=b
b: =c
c:=m
ENDIF
IF a>b THEN
m:=a
a: =b
b: =m
ENDIF
WRITE a,b,c
STOP.
Problema 5
Pentru n citit (n natural mai mare sau egal cu 1) sa se calculeze suma
5=1 +1*2+1*2*3+ ... +1*2* ... *n.
Pentru rezolvare, observam ca putem adauga Ia o suma s (care are initial
valoarea 0) pe rand valorile calculate 1, 1 *2,...,1 *2* ...*n (adica n valori).
Aceasta nu inseamna ca trebuie calculata de fiecare data valoarea 1 *2* ...*i.
Daca am
calculat 1 * 2 * ... * i, valoarea urm1:itoare care trebuie adaugata este 1 * 2 * ... * i* (i
+ 1)
i se poate obtine inmultind valoarea calculata cu i + 1. Pentru calcuiul acestor
valori se utilizeaza variabila p. Din cele aratate rezulta schema logica de mai jos:
DA
STOP
Figura 2.3.10.
35
in pseudocod, algoritmul propus arata astfel:

INTEGER n,i,s,p;
READ n
s:=O
p: =1
FOR i:=l,n
s:=s+p
REPEAT
WRITE s
STOP.
Problema 6
Se citel;ite un numar natural n. Sa se calculeze suma cifrelor sale.

Exemplu: pentru n = 213, se va tipari 6 (2 + 1 + 3).
Pentru calculul acestei sume, trebuie sa gasim o modalitate de a separa

cifrele unui numik intre operatorii care se pot aplica numerelor naturale sunt
doi care ne folosesc In acest caz. Acel;itia sunt operatorii DIV i MOD. Aplicand
operatorul DIV pentru doua numere naturale a l;ii b sub forma a DIV b ob inem
catul intreg al impartirii lui a Ia b.
Exemp/u: 24 DIV 5 = 4.
Prin aplicarea operatorului MOD Ia doua numere naturale a i b (a MOD b)

obtinem restul impartirii lui a Ia b.
Exemp/u: 24 MOD 7 = 3.
Daca vom considera un numar natural n, n MOD 10 va da restul impartirii Ia

10 a numarului, deci ultima cifra a sa, iar n DIV 10 va avea ca rezultat c Hul
Tmpartirii Ia 1 0 a numarului (acesta nu este altceva decat numarul format prin
suprimarea ultimei cifre a numarului n).
Presupunem ca am citit numarul 425. Procedam astfel:
initializam suma (s = 0);
calculam ultima cifra a numarului 425 MOD 10 = 5 !?i o adunam Ia s (s = 5);
retinem numarul fara ultima cifra (425 DIV 10 = 42);
pentru numarul nou format retinem ultima cifra l;ii o adunam Ia s (42 MOD
10=2, s:=5+2=7);
retinem numarul far a ultima cifra (42 DIV 10 = 4);
pentru numarul nou format retinem ultima cifra !?i o adunam Ia s (4 MOD
10=4, s:=7+4= 11);
retinem numarul fara ultima cifra (4 DIV 10 = 0).
intrucat numarul a devenit 0, algoritmul se incheie prin tiparirea luis (s =
11). Alaturam algoritmul scris Tn pseudocod:
INTEGER n,s;
READ n
s:=O;
WHILE n<>O
41
Figura 2.3.11.
s:=s+n MOD 10
n:=n DIV 10
REPEAT
WRITE s;
STOP.
Problema 7
Se citel?te n numar natural. Sa se tipareasca numarul obtinut prin inversarea

cifrelor lui n.
Exemp/u: n = 412. Se va tipiki 214.
in problema anterioara am vazut cum putem izola cifrele unui numar. De

mentionat ca algoritmul propus anterior izola cifrele numarului in ordine inversa.
Exemp/u: pentru numarul 162 se izolau pe rand cifrele 2, 6 !?i 1.
Pe de alta parte, daca cunoa!?tem cifrele unui numar putem calcula numarul
respectiv.
Exemplu: din cifrele 2, 6 i 1 putem obtine numarul 261. Aici nu este vorba
de alaturarea cifrelor, cum am fi tentati sa credem, ci de calculul numarului sub
forma:
2
1
2 * 10 + 6 * 10 + 1 * 101
aa cum cunoa tem din teoria bazelor de numeratie. Cum procedam pentru
rezolvarea acestei probleme? Consideram o variabila (notata ninv, care initial
va avea valoarea 0). Pentru fiecare cifra noua valoare a lui ninv va fi vechea
valoare 'fnmuiJita cu 10 Ia care se adauga cifra:
ninv: =0* 10+2 = 2;
ninv: = 2* 10+6= 26;
ninv:=26*10+1 =261.
Figura 2.3.12.
in concluzie, izolam pe rand cifrele In ordine inversa (a!?a cum am ar<Hat In

problema anterioara) si cu fiecare noua cifra construim numarul cerut.
in pseudocod, algo;itmul arata astfel:
INTEGER n,ninv;
READ n
ninv:=0;
WHILE n<>O
ninv:=ninvlO+n
n:=n DIV 10
REPEAT
WRITE ninv
STOP.
MOD 10;
Problema 8
Se cite:;;te n numar natural. Sa se precizeze daca este pdm sau nu.
Pentru rezolvare, o prima idee de lucru consta In a considera toti divizorii
posibili ai numarului n. Daca nici unul din ace!?tia nu-l divide, lnseamna ca
numarul este prim. Dar care sunt ace!?ti divizori posibili?
o prima posibilitate ar fi sa-i consideram cuprin!?i lntre 2 :;;i n-1;
o a doua posibilitate este de a-i considera cuprin:;;i lntre 2 l?i jum<'Hatea lui n
(n DIV 2) solutie mult mai avantajoasa decat prima lntrucat consideram mai
putini divizori !?i implicit se calculeaza mai putin;
o a treia posibilitate consta 'fn a considera toti divizorii cuprin!?i lntre 2 !?i
parte lntreaga din radical din n (presupunand cunoscuta teorema care afirma
ca, daca un numar nu are nici un astfel de divizor, el este prim).
Ultima varianta este cea mai buna. Spre exemplificare, vom considera
numarul 999; in prima varianta trebuie verificati 997 de divizori, in a doua 447
iar 'fn a treia numai 29 de divizori. Corespunzator acestei ultime variante
redactam, in figura 2.3.13, algoritmul.
NU
Figura 2.3.13.
Acelal?i algoritm II redactam In pseudocod:

INTEGER n,i
BOOLEAN prim;
READ n
prim:=true
FOR i: = 2 , y'ii
IF n MOD i=O THEN prim:=FALSE
ENDIF
REPEAT
IF prim THEN WRITE numarul este prim'
ELSE WRITE numarul nu este prim
ENDIF
STOP.
Algoritmul prezentat are un neajuns. Sa presupunem ca dorim sa verifici:im

daca numarul 1000 este prim. Primul divizor posibil (2) divide acest numar. Cu
toate acestea, In loc sa se afi:;;eze rezultatul imediat, se verifica :;;i ceilalti
divizori posibili. Trebuie gasita o modalitate prin care, Ia gasirea unui divizor,
sa se tipareasca faptul ca numarul nu este prim.
Prezentam acest nou algoritm in figura 2.3.14.
Figura 2.3.14.
lata algoritmul redactat In pseudocod:

INTEGER n,i;
READ n
i:=2
WHILE (i<n) AND (n MOD i<>O)
i:=i+l
REPEAT
IF i=n THEN WRITE numarul este prim'
ELSE WRITE numarul nu este prim'
ENDIF
STOP.
Acest algoritm are dezavantajul ca, atunci cand numarul este prim, se
45
lncearca toi divizorii posibili cuprini lntre 2 i n-1 . Un ait dezavantaj este
acela ca pentru n = 1 se tipare!?te mesajul corespunzator pentru numar naprim.
Puteti gasi un algoritm care sa elimine aceste dezavantaje?
Problema 9
Sa se scrie un algoritm care tipare!?te primele nr numere prime (nr se cite te).
In problema anterioara, am vazut cum putem stabili daca un numar este
prim. Acum, se pune problema sa asiguram un cantor In care sa se caute
numerele prime printre numerele 1, 2, !?.a.m.d., pana se tiparesc cele nr cerute
(figura 2.3.15.).
In pseudocod, algoritmul arata astfel:
INTEGER n,i,j,nr
BOOLEAN prim;
READ nr
n:=l;
j: =0;
DO
prim:=true
FOR i: =2, [/ri]
IF n MOD i =0 THEN prim:=false
ENDIF
REPEAT
IF prim THEN
WRITE n
j : =j+1
ENDIF
n: =n+l
UNTIL j=nr
STOP.
Problema 10
Se citel?te n, numar natural. Sa se descompuna In factori primi.
Algoritmul consta In urmatoarele:
se cite te n;
se initializeaza primul divizor (i = 2);
secventa urmatoare se repeta pana cand n = 1:
) se initializeaza fm cu 0 (factor de multiplicitate, arata puterea ia care se
gase te factorul prim);
r_o atat timp cat i II divide pe n, se executa urmatoarele:
se mare te cu 1 factorul de multiplicare;
se lmparte n Ia i;
> daca fm este diferit de 0 (deci i a fost gasit divizor allui n) se tiparesc i $i fm;
:) se aduna 1 Ia i (se incrementeaza).
o
Sa presupunem ca am citit n = 12. Algoritmul dec urge astfel:

se initializeaza i cu 2;
se initializeaza fm cu 0;
lntrucat 2 divide pe 1 2, fm va lua valoarea 1 iar n valoarea 6;
lntrucat 2 divide pe 6, fm va lua valoarea 2 i n valoarea 3;
NU
NU
NU
Figura 2.3.15.
2 nu divide pe trei, deci se trece mai departe;

fm este diferit de 0, se tipare te 2 'Ia puterea' 2;
se mare te i cu 1;
n nu este 1, deci secventa se reia;
fm va lua valoarea 0;
3 divide pe 3 (i divide pe n) deci fm va lua valoarea' 1 i n va deveni 1;
3 nu divide pe 1, deci se trece mai departe;
fm este diferit de 0, deci se tiparel?te 3 'Ia puterea' 1;
i devine 4;
n este 1 i algoritmul se incheie.
in continuare se prezinta schema logica i algoritmul realizat in pseudocod.
Figura 2.3.16.
INTEGER n,i,fm;
READ n
i:=2;
DO
fm:=O;
WHILE
MOD i =0
fm:=fm+l;
n:=n div i
REPEAT
IF fm<>O THEN
WRITE i, la puterea fm
ENDIF
i:=i+l
UNTIL n=l
STOP.
Problema 11
Sa se tipareasca toate numerele naturale mai mici sau egale cu 10000 care
se pot descompune in doua moduri diferite ca suma de cuburi.
Adevarata problema consta in a afla daca un numar natural se poate
sau3 nu
3
descompune
3
3 in doua feluri ca suma de cuburi (de exemplu, 1729 = 1 + 12 =
= 9 + 10 si este eel mai mic numar natural care admite o astfel de descom
punere). intr-o structura repetitiva de tip FOR se incearca, pe rand, sa se
descompuna numerele intre 1 l?i 10000.
.Se considera n, numar natural. Presupunand ca acest numar se descompune
in i + j, apare ca evident faptul ca i !?i j nu pot lua valori mai mari decat radical in
dice 3 din n. Pe de alta parte, pentru a nu gasi o pereche (i,j) de doua ori (de
exemplu 3,5 9i 5,3), iva lua valori intre 1 l?i limita maxima, iar j va lua valori intre
i !?i limita maxima. 0 variabila (nr in exemplul nostru) va re ine numarul de perechi
(i,j) gasite.
Prezentam in continuare algoritmui in pseudocod l?i schema logica.
INTEGER n,nr,max,i,j,il,jl,i2,j2;
FOR n:=l,lOOOO
max:= l3/n1
nr:=O;
FOR i:=l,max
FOR j:=i,max
IF i*i*i+j*j*j=n THEN
IF nr=O THEN
il:=i
j1: =j
ELSE
i2:=i
j2:=j
ENDIF
nr:=nr+l;
ENDIF
REPEAT
REPEAT
IF nr>l THEN
WRITE n,il,jl,i2,j2
ENDIF
REPEAT
STOP.
DA
Figura 2.3.17.
Capitolul 3
Elemente de baza ale limbajului Pascal

3.1. Notiuni introductive
3.1.1.
Evolutia limbajelor de prOgramare
Evolu ia limbajelor de programare cunoa!?te trei perioade distincte de timp

!?i anume: anii 1950-1959, 1960-1969, dupa 1970.
Anii '50 reprezinta etapa de pionierat in domeniul programarii calculatoarelor.
Tn aceasta perioada s-a cristalizat no iunea de program. Initial, programela erau
scrise in cod ma incl (instructiunile, datele de intrare-ie9ire erau formate din
succesiuni de 0 :;;i 1, a:;;a cum de fapt le prelucreaza orice calculator din lume).
Datorita acestui fapt, scrierea programelor, introducerea datelor erau activitati
deosebit de migaloase !?i pu in productive. Un pas important in evolutie este dat
de apari ia limbajelor de asamblare. Acestea folosesc pentru fiecare instructiune
In cod ma!?ina o abreviere din limba engleza ce sintetizeaza efectul instruc iunii
respective. De!?i mult U!?Urata, activitatea de programare intr-un limbaj de
asamblare ramane dificila. Cu toate acestea, :;;i astazi limbajele de asamblare sunt
utilizate cu succes datorita unor avantaje cum ar fi: posibilitatea scrierii unor
programe specifice calculatorului pe care se ruleaza un anumit program (deci cu
mare viteza de executie), posibilitatea scrierii unor secvente de program care nu
se eot scrie lntr-un limbaj evoluat (din lipsa unor instructiuni specifce) etc.
In aceasta perioada apar !?i limbajele de nivelinalt (FORTRAN, COBOL). De
aceasta data, scrierea programelor se face cu ajutorul unor expresii din limba
engleza (de:;;i extrem de restrictive). De asemenea, formulele_ prin care se
solicita calculul unor expresii sunt asemanatoare formulelor matematice. Un
mare avantaj al limbajelor de nivellnalt Tl constituie portabilitatea programelor
scrise cu ajutorul lor (posibilitatea ca un program scris sa poata fi rulat pe
diverse tipuri de calculatoare).
Tn anii '60 se dezvolta cu precadere aparatul matematic necesar crearii 9i
utilizarii limbajelor de programare. Astfel, regulile de scriere a programelor In
limbajele respective sunt formalizate matematic. De asemenea, apare
cor.ceptui
de recursivitate in programare (acest concept era utilizat de mult timp in mate
matica). Pentru prima data apare no iunea de alocare dinamica a n:er. ori&i (a!o
carea spatiului de memorie pentru diverse variabile se face in timpul execu iei
programului, atunci cand este cazul, l?i tot in acest timp se poate !?terge l.in
spatiu alocat, cand nu mai este necesar). Toate acestea a par pentru prima data
Ia limbajui.ALGOL. Acest limbaj, mai pu in utilizat de practicanti, a avut un ro!
fundamental in dezvoltarea ulterioara a informaticii. Tot in aceasta perioada au a
parut :;;i alte limbaje de programare evoluate care s-au raspandit in intreaga !ume.
La lnceputul anilor '70 a aparut programarea structurata (initiatorii ei fiind

E. W. Dijkstra l?i C. A. Hoare). Pentru prima data apar metode standardizate de
elaborare a programelor, activitatea de programare depa9ind stadiul artizanal.
Redactarea oricarui program se poate face utilizand cateva structuri simple
(secventiala, alternativa, repetitiva). 0 problema complexa se descompune In
subprobleme, care Ia randul lor se descompun din nou, pana cand sunt sufi
cient de simple pentru a fi transpuse In programe (programare descendenta).
La sfarl?itul anilor '80 apare un nou concept !?i anume programarea pe
obiecte (in care datele l?i rutinele pentru ele sunt unificate in 'obiecte' care se
pot utiliza ca a tare sau dezvolta ulterior far a a finevoie de a lua munca de Ia
capat sau de a le cunoa!?te In mecanismul lor intim). Timpul va decide daca
acestea vor deveni sau nu indispensabile in activitatea de programare.
limbajul Pascal a aparut Ia inceputul anilor '70 !?i a fost elaborat de mate
maticianul N. Wirth. Initial, limbajul a fost conceput pentru predarea sistema
tica a disciplinei de programare a calculatoarelor (structurile clasice din progra
marea structurata au fost transformate in instruqiuni). Cu timpul, limbajul a
lnceput sa fie folosit 9i in activitatea practica de programare a calculatoarelor.
Un rol fundamental pentru aceasta 1-a avut firma americana Borland, care a
implementat o varianta numita Turbo Pascal, care pe langa instructiunile clasice
ale limbajului contine l?i multe altele. Un mare avantaj al acestui limbaj este
acela ca utilizatorul are posibilitatea sa-!?i declare propriile tipuri de date.
Ultimele versiuni ale limbajului permit l?i realizarea programarii pe obiecte.
3.1.2. Structura programelor Pascal

Sa consideram eel mai simplu program Pascal:
program fara_actiune;
begin
end.
Acesta este un program care se poate rula. Efectul sau este nul. Nu cite9te,
nu scrie, nu efectueaza nici un calcul. Totu!?i, din analiza acestuia rezulta
urmatoarele:
orice program lncepe printr-un cuvant numit PROGRAM care este urmat de
numele propriu-zis al programului (nume ales de utilizator) !?i de semnul ';' ;
orice program contine eel putin o data cuvintele cu un inteles special BEGIN
i
END;
orice program se termina prin punct.
Observa.tii:
orice cuvant al programului poate fi scris cu litere mari sau mici (nu are
importanta);
in versiunea Turbo, prima linie a programului poate lipsi (dei nu este
recomandabil acest lucru, din ratiuni de ordine);
plasarea cuvintelor pe linie i numarul de spatii dintre ele sunt Ia alegerea
programatorului (putem scrie intreg programul pe o singura linie, insa este
bine ca programul sa fie scris in aa fel incat sa fie u or de inteles).
Un program scris in Pascal (oricat de complex ar fi) are structura urmatoare:
PROGRAM nume;
definitii de constante;
definitii de tipuri;
declaratii de variabile;
declaratii de proceduri i funqii;
BEGIN
instruqiuni
END.
Nu este obligatoriu ca intr-un program sa figureze toate acestea, dar dac2

ele figureaza, trebuie sa apara In aceasta ordine.
3.1.3. Descrierea sintaxei cu ajutorul diagramelor de sintaxa

Orice limbaj de programare se caracterizeaza prin sintaxa i semantica.
Sintaxa limbajului este data de totalitatea regulilor de scriere corecta (In sertsul
acceptarii sale de programul traducator (compilator) care are rolul de a converti
programulln cod ma ina pentru a fi executat). Dar un program corect din punct
de vedere sintactic nu este automat un program bun. Corectitudinea sintactica
este numai o cerinta a programelor, tot al?a cum pentru a fi campion mondial
Ia alergari este necesar sa nu ai picioarele amputate. Cel mai greu este ca
programul sa execute lntocmai ce i-a propus eel care 1-a realizat. Prin
semantica unui limbaj se intelege ce anume realizeaza fiecare instruqiune a sa.
Sintaxa este formalizata perfect din punct de vedere matematic dar nu acela i
lucru se intampla cu semantica. Sintaxa poate fi descrisa cu ajutorul diagramelor
de sintaxa. Acestea nu reprezinta singura forma de descriere a sintaxei unui limbaj
(mai exista de exemplu forma BNF), dar se remarca prin faptul ca sunt sugestive.
in ce consta o descriere cu ajutorul diagramelor de sintaxa?
Sa presupunem ca dorim sa descriem riguros cum arata scris un numar in
baza 16. Daca folosim o descriere de genul: un numar in baza 16 are in
componenta sa cifre l?i litere, cifrele pot fi de Ia 0 Ia 9 iar literele a, b, c, d, e,
f, A, 8, C, D, E, F i dam cateva exemple, nu suntem suficient de riguro i.
lmediat pot aparea intrebari de genul: A reprezinta un numar In baza 16? Mai
mult, daca dorim sa facem un program care sa recunoasca daca un numar citit
este sau nu in baza 16, situatia se complica. Reluam descrierea unui numar in
baza 16, cu ajutorul diagramelor de sintaxa.
+ 4.. .
Definim o citra dupa cum se vede mai jos:

-CIFRA
Figura 3.1.3.1.
..
Se observa ca o astfel de schema are un nume (In cazul nostru cifra).

Pentru a putea obrine o cifra trebuie sa urmez un drum prin acest desen (in
matematica se numel?te graf orientat), de Ia intrare (din dreptul numelui) pana
Ia iel?ire, urmand sensul sagetilor. Problema se poate pune ;;i invers: fiind dat
un caracter oarecare sa se precizeze daca este sau nu cifra. Caracterul dat este
cifra daca in diagrama prezentata exista un drum care trece printr-un cerculet
ce prezinta caracterul.
Acum am definit riguros cifra. Putem defini riguros cifra hexa:
CIFRA
HEXAZECIMALA
Figura 3.1.3.2.
In noua diagrama apare un dreptunghi in care este scris cuvantul CIFRA.

Dreptunghiul se folose te atunci cand se folose!?te o no iune ce a fost definita
printr-o alta diagrama de sintaxa. Orice drum folosim in acest desen (de Ia
intrare Ia ie ire) obtinem sau o cifra sau una din literele care pot face parte din
structura unui numar in hexa.
Acum se poate defini un numar hexa:
:=r
-HEMZNEUMCAJRMAL
_
"' CIFRA HEXAZECIMALA
Figura 3.1.3.3.
in acest ultim desen observam ca este permisa de mai multe ori trecerea
prin acelai loc.
in esenta, intr-o diagrama de sintaxa putem lntalni urmatoarele simboluri
grafice:
cercuri - lncadreaza anumite simboluri speciale;

elipse - incadreaza cuvinte rezervate (nu pot fi folosite in alt context);
dreptunghiuri -lncadreaza elemente definite prin alte diagrame de sintaxa:
Ne-am putea lntreba care este motivul unei descrieri atilt de riguroase? Un
program scris intr-un limbaj de programare trebuie tradus de catre programul
numit compilator in cod ma ina. in primul rand programul trebuie sa fie corect
din punct de vedere sintactic (altfel nu poate fi tradus). A verifica corectitudi
nea nu este un lucru simplu (pot fi foarte multe forme de programe). Din acest
motiv, verificarea se face dupa reguli care trebuie descrise foarte clar iar
aceasta descriere este realizata de diagramele de sintaxa.
3.2. Vocabularul limbajului
Vocabularul oricarui limbaj este format din:

setul de caractere;
identificatori;
separatori;
comentarii;
3.2.1. Setul de caractere

Reprezinta ansamblul caracterelor cu ajutorul carora se poate realiza un
program Pascal.
Acesta este alcatuit din:
literele mari i mici ale alfabetului englez (A-Z, a-z);
cifrele sistemului de numeratie in baza 10 (0-9);
caractere speciale: +, -, *, ';, =, ", <, >, (, ), [, ], {, }, ., , :, ;, #, $,
@,
_, i blanc (spatiu).
3.2.2. ldentificatori
Prin identificator intelegem o succesiune de litere sau cifre sau caracterul
special ' ' din care prima trebuie sa fie Tn mod obligatoriu litera. Cu ajutorul
identificatorilor se asociaza nume constantelor, variabilelor, procedurilor etc.
Exemp/e de identificatori: a 1, tasta, un_numar.
Contraexemple: 1ar, mt& (primul incepe cu o litera, al doilea contine un
caracter special).
Diagrama de sintaxa a unui identificator este urmatoarea:
--IDENTIFICATORt LI A
CIFRA
Figura 3.2.2.1.
. 0 categorie speciala de identificatori este data de cuvintele cheie ale
limbajului (au un inteles bine definit i nu pot fi folosite in alt context). Acestea
sunt: and, array, begin, case, const, div, do, downto, else, end, file, for,
function, goto, if, in, label, mod, nill, not, procedure, program, record, repeat,
set, of, or, origin, otherWise, packed, then, to, type, until, var, while, with.
3.2.3. Separatori i comentarii

Cele mai simple elemente alcatuite din caractere cu semnificatilingvistica
poarta denumirea de unitai lexicale. Acestea se separa intre ele, dupa caz, prin
blanc, sfan?it de linie sau caracterul ';'.
Pentru ca un program sa fie u9or de inteles se folosesc comentariile. Aces
tease plaseaza oriunde in program. Un comentariu poate fi scris in doua feluri:
intre acolade, exemplu: {un comentariu};
intre paranteze rotunde urmate de *, exemplu: (* un comentariu *).
3.3. Constante
Constantele Pascal reprezinta valori care pot fi continute de un program scris
in acest limbaj (nu sunt citite de program). Ele folosesc in calculul diverselor
expresii (numerice, logice, siruri de caractere) sau pentru scrierea unor mesaje.
Exemplu: in program tr.ebuie realizata atribuirea y: = 2 * x + 1. in acest caz,
2 l?i 1 sunt constante.
Constantele limbajului Pascal se impart in 4 categorii:
constante intregi;
constante reale;
constante l?ir de caractere;
constante simbolice.
Prezentarea notiunii de constanta prin utilizarea unei diagrame de sintaxa
arata astfel:
CONSTANTAiNTREAGA
-CONSTANTA
CONSTANTA REALA
!?IR CARACTERE
CONSTANTA SIMBOLICA
Figura 3.3.1.
3.3.1. Constante intregi

Sunt alcatuite dintr-o submultime a numerelor intregi care pot fi reprezen
tate in memoria calculatorului.
Observa_tie: Nu se pot reprezenta in calculator numere oricat de mari sau
oricat de mici (orice numar ocupa un spatiu in memoria interna a calculatoru
lui). Prin utilizarea limbajului Turbo Pascal se pot reprezenta numere intregi
cuprinse in intervalul [-2.147.483.648, 2.147.683.647].
Numerele se pot reprezenta in baza 10 sau baza 16 (mai rar utilizata).

Pentru baza 16, numarul este precedat de caracterul special '$'.
Exemple: 32, -164,
+ 31,
$a1, -a1.
Pentru eliminarea oricaror ambiguitati, utilizam diagrama de sintaxa pentru

a defini un astfel de numar.
CIFRA
CIFRA HEXAZECIMALA
Figura 3.3.1.1.
3.3.2. Constante reale

Sunt alcatuite dintr-o submultime a numerelor reale (mai precis a numerelor
rationale) care pot fi reorezentate in calculator. Numerele se gasesc in
intervalul [3:41o-4352, 1,1 1o4932J.
in locul virgulei se folose te P,unctul.
Exemple: 2.34, -45.26, 512E
+ 23,
-45.1 E-3.
Ultimele doua numere folosesc o scriere neintalnita In matematica. Ele

23
3
reprezinta numerele 52110 i -45,11 o- .
Figura 3.3.2.1.
3.3.3. Constante ir de caractere

Dupa cum reiese i din denumire, cu ajutorul lor se reprezinta l?iruri de
car ctere. $irurile de caractere se pot reprezenta In doua forme.
In prima forma se scrie l?irul cuprins intre apostrofuri.
Exemp/u: 'acesta este un text'.
in forma a doua se scrie irulln cod ASCII (fiecarui caracter i se ata eaza
un cod cuprins intre 0 l?i 255 i este precedat de caracterul'#'.
Exemp/u: #1#2sau, echivalent (in baza 16), #$1#$2.
57
SIR
-CARACTERE
CARACTER
CONSTANTAiNTREAGA
Figura 3.3.3.1.
3.3.4. Constante simbolice

Acestea sunt constante care au in program un
anumit nume. Numele dat acestor constante poate fi
cunoscut de limbaj (de exemplu: false, true, maxint)
sau dat
de utilizator atunci cand
definel?te
constantele. Acest din urma aspect il vom analiza in
paragraful 3.6.
3.4. Notiunea de tip de

data
Tn procesul de calcul intervin diverse date (intregi,
reale etc.) Prin tip de data vom intelege o multime
de valori. Pe tipurile de date se introduc anumite
operatii.
Exemplu de tip: integer.
Multimea valorilor acestui tip este o submultime a
numerelor intregi. Cu aceste valori se pot efectua o
serie de operatii cum ar fi: adunarea, scaderea etc.
Avem trei categorii de tipuri:
simple;
structurate;
reper.
Tipurile simple de date (nu necesita structurare)
se pot clasifica din doua puncte de vedere.
Un tip ordinal reprezinta o multime finita de valori

intre care exista o relatie de ordine.
Conform acestui criteriu, tipurile simple se
clasifica in:
tipuri ordinale;
tipuri reale (chiar daca se ia o submultime a
numerelor reale situata intr-un anumit interval,
acesta nu are un numar finit de elemente).
Din
punct
de
vedere al modului de
definire
a
tipului,
tipurile
simple
se
clasifica in:
tipuri standard
(este cunoscut,
nu este necesar
sa fie definit de
programator);
tipuri definite de
utilizator.
53
3.4.1. Tipuri simple standard
Acestea se clasifica in:

tip boolean;
tip char;
tipuri lntregi;
tipuri real.
Dintre acestea, primele trei sunt tipuri ordinale.
3.4.1.1. Tipul boolean
Are numai doua valori: true si false. Operatorii care lucreaza cu acest tip
sunt: AND, OR, NOT. Tn versiunea Turbo a limbajului s-a introdus i operatoiul
XOR. Fiind date doua valori oarecare ale acestui tip, a i b, avem a XOR b
=true daca :;;i numai daca ele sunt diferite.
3.4.1.2. Tipul char
Multimea valorilor a cestui tip este fermata de toate caracterele reprezentate
in codul ASCII extins. Fiecare din aceste caractere se reprezinta pe un octet.
Relatia de ordine intre aceste caractere este data de relatia de ordine dintre
codurile prin care se reprezinta aceste caractere (cuprinse intre 0 i 255).
Limbajul contine anumite funqii care se pot aplica tipului char. Acestea sunt:
SUCC(caracter) - returneaza caracterul care are codul ASCII cu o unitate
mai mare (succ('c') = 'd');
PRED(caracter)- returneaza caracterul care are codul ASCII cu o unitate mai
mica (PRED('d') = 'c');
ORD(caracter) - returneaza codul ASCII al caracterului;
CHR(cod) - returneaza caracterul care are codul specificat.
3.4.1.3. Tipuri intregi
Tn funqie de submultimea considerata a numerelorintregi, avem urmatoarea
clasificare:
tipul SHORTINT, numere din intervalul [-128, 127] care se reprezinta in
memoria interna pe un octet;
tipul INTEGER, numere in intervalul [-32768, 32767], se reprezinta pe 2
octeti;
tipul LONGINT, numere din intervalul [-2.147.483.648,2.147.483.647},
se reprezinta pe 4 octeti;
tipul BYTE, numere din intervalul [0, 255], se reprezinta pe un octet;
tipul WORD, numere din intervalul [0, 65535], se reprezinta pe 2 octeti.
Variabilelor de tip intreg li se pot aplica urmatorii operatori aritmetici: +
(adunare, operator binar), - (scadere, operator binar), * (inmultire, operator
bin;!r), DIV l?i MOD (operatori binari). Ace:;;ti ultimi doi operatori merita analizati.
In cazul a doua valori naturale (deci intregi pozitive), operatorii MOD !?i DIV
60
furnizeaza catul i restul impartirii intregi.

Exemplu: 14 DIV 5 = 2;
14MOD5 =4.
Daca eel putin un operand este negativ, lucrurile se complica.
Exemp/u: -13 DIV 4=-3
-13MOD4=-1.
$tim din matematica faptul ca restul impartirii a doua numere Tntregi este
pozitiv. In acest caz, cei doi operanzi nu furnizeaza rezultatul corect.
Pentru operandul DIV rezultatul se obtine astfel:
se impart cele doua numere in valoare absoluta (pentru exemplul dat, catul
este 3);
semnul catului se stabile!?te dupa regula semnelor ( + cu + rezultat +, cu + rezultat -, etc.).
Pentru MOD rezultatul se obtine din scaderea din delmpaqit a produsului
dintre impartitor i cat (pentru exemplificare se calculeaza -13-4* 3 =
-1.
Operanzilor de tip intreg lise pot aplica i operatorii pe biti (lucreaza asupra
bitilor din reprezentarea interna a numarului). Ace!?tia vor fi prezenta1i In
continuare.
Operatorul NOT (operator unar)
Bitii care au valoarea 0 vor avea valoarea
!?i invers.
Exemplu: NOT 7 = -8.
Presupunem numarul 7 reprezentat pe un octet. El va arata astfel:

00000111. Aplicand operatorul NOT obtinem: 11111000. Acesta reprezinta
un numar negativ. Dupa cum tim, pentru a obtine valoarea lui, se transforma
bitii cu 1 in biti cu 0 i se adauga 1. Rezulta: 00000111 + 1 = 00001OOO.Uiti
mul rezultat este numarul 8, iar daca tinem seama ca era negativ, obtinem -8.
Operatorul AND (operator binar)
,
Fie continutul a doi biti, b 1 i b2. Definim operatia de conjunctie a
supra continutului lor, astfel:
?aca.b1=1b2=1
b 1 AND b 2
1n once alt caz
J
Ia
Cu ajutorul lui AND se face conjunqia bit cu bit a celor doi operanzi.
Exemplu: 3 AND 7=3.
3 se reprezinta astfel: 00000011;
7 se reprezinta astfel: 00000111;
'fn final, rezulta: 00000011,adiea numarul 3.
Operatorul OR
Fie b 1 !?i b2 continutul a doi biti. Definim disjunqia astfel:
b 1 OR b2 =
o ?aca. b1 =0b2=0
1 1n once alt caz
Operatorul OR face disjunctia bit cubit asupra reprezentarii celor doua numere.
1
Exemplu: 3 OR 7 = 7.
Operatorul XOR (operator binar)

Fie b1,b2 continutul a doi bi!i.
con!inutului celor doi biti astfel:
Definim operaria sau exclusiv asupra
= 1. ?aca b1=1 i b2=0 sau b1=0 i b2=1

1 0,
1n caz contrar
Prin aplicarea operatorului XOR se face operatia sau exclusiv bit de bit
asupra reprezentarii binare a celor doua numere.
b
XOR b
Exemplu: 3 XOR 7 = 4.
reprezentam numarul 3:
reprezentam numarul 7:
rezulta:
00000011;
00000111;
00000100,adica 4.
Operatorul SHL (operator binar)

Deplaseaza Ia stanga toti bitii primului operand, cu un m.:mar de biti ega! cu a!
doilea operand. Continutul primilor biti se pierde, iar continutul ultimilor biti deJine 0.
Exemp/u: 11 SHL 2 = 44.
11 se reprezinta 00001 011;
prin deplasarea cu doua pozitii Ia stanga se obtine: 00101100, adica
numarul 44.
Observa.tie: Prin deplasarea Ia stanga cu o pozitie (daca primul bit al
numarului nu este 1) numarul se lnmulte9te cu 2.
Operatorul SHR
Deplaseaza tori bi!ii primului operand Ia dreapta cu un numar de pozitii egal
cu al doilea operand, ultimii biti ai primului operand se pierd, iar pe primele
pozi!ii se pune 0.
Exemplu : 44 SHR 2 = 11. Aratati cum s-a obtinut acest rezultat.
Observa.tie: Deplasarea Ia dreapta cu o pozitie este echivalenta cu impaqirea
lntreaga Ia doi.
Tipurile lntregi sunt tipuri ordinale deci lise pot aplica functiile SUCC, PRED,
ORO 9i operatorii relationali.
FUNCTIA ABS(nr)- furnizeaza modulul numarului (abs(-12) = 12);
3.4.1.4. Tipuri reale
Tntr-o data de tip real se pot retine numere rationale. Numerele reale,
cunoscute de noi din matematica, cuprind l?i numere irationale. Acestea din
urma au o infinitate de zecimale, deci nu pot fi retinute in calculator. Totu9i, ele
pot fi suficient de bine aproximate prin numere rationale. Operatiile cu numere
reale au rezultate aproximative (nu se pot retine oricat de multe zecimale).
Limbajul TURBO PASCAL are urmatoarele tipuri reale:
tipul REAL - numerele se reprezinta pe 6 octeti 9i pot avea maxim 11, 1 2
cifre;
tipul SINGLE - numerele se reprezinta 'fn memorie pe 4 octeti l?i pot avea
maxim 7, 8 cifre;
DOUBLE, numerele se reprezinta pe 8 octeti 9i pot avea maxim 15, 16 cifre;

EXTENDED, numerele se reprezinta pe 10 octeti i pot avea 19, 20 de cifre;
COMP se retin numai numere pozitive pe 8 octeti 9i numerele pot avea
pana in 19, 20 de cifre.
Datelor de tip real li se pot aplica urmlHorii operatori:
pentru adunare;
- pentru scadere;
* pentru inmultire;
I pentru impartire.
Datelor de tip realli se pot aplica operatorii relationali 9i urmatoarele functii:

ABS(x) - are ca rezultat modulul numarului x;
SQR(x) - x Ia patrat;
SQRT(x) - radical din x;
SIN(x) -sinus din x (x este exprimat In radiani);
COS(x) - cosinus din x;
ARCTAN(x)- arctangent din x;
LN(x) - logaritm natural din x;
EXP(x) - e Ia puterea x ( e are valoarea aproximativa 2.71);
INT(x) - partea intreaga din x;
FRAC(x) - partea fractionara a lui x;
pi -numarul " ( aproximativ 3.14).
0 data de tip real nu este de tip ordinal.
3.4.2. Tipuri ordinale definite de utilizator
'
Utilizatorul are posibilitatea sa declare doua tipuri de date ordinale:

tipul enumerat;
tipul subdomeniu.
3.4.2.1.Tipul enumerat
Avand in vedere faptul ca acest limbaj a fost creat In scopuri pur didactice,
s-a avut In vedere posibilitatea scrierii unor programe care sa fie inteles cu
Ul?urinta. Din acest motiv a aparut tipul de date enumerat.
Exemple de astfel de tipuri:
(luni, marti, miercuri, joi, vineri, sambata, duminica);
(ieri, azi, maine).
Prin diagrame de sintaxa acest tip se reprezinta astfel:
TIP
-ENUMERAT
(
IDENTIFICATOR
'--- G)
Figura 3.4.2.1.
Datele de acest tip nu pot fi scrise sau citite. Ele se reprezinta Tn memorie
prin numarullor de ordine (ORD(Iuni) = 0, ORD(marli) = 1 etc. Acestor date lise
pot aplica func iile PRED, SUCC precum 9i operatorii relationali (avem, referitor
Ia exemplul dat, marti < miercuri)).
3.4.2.2. Tipul subdomeniu
Se ob ine dintr-un tip ordinal definit anterior sau predefinit (numit tip de
baza) din care se extrage un numar de valori consecutive (precizand prima l?i
ultima valoare). Cu acest tip se pot face acelea9i opera ii care se pot face l?i cu
tipul de baza).
Exemple:
2..20- o variabila de acest tip ia valori Tntregi cuprinse Tntre 2 9i 20, tipul
de baza fiind tipul integer;
luni..vineri - o variabila de acest tip poate lua toate valorile dintre luni l?i
vineri ale tipului de baza enumerat, definit anterior.
Prezentam acest tip prin intermediul diagramelor de sintaxa:
--SUBDOTMIPENIU-------..1,
I1---.tllt .. 1-----.t..J,
CONSTANTA 1
..---
...
CONSTANTA 2
Figura 3.4.2.2.
3.4.3. Definirea tipurilor

Dupa ce am vazut principalele tipuri de date ale limbajului, trebuie sa
cunoal?tem 9i modulln care se fac declaratiile de tipuri.
Pentru declararea unui tip se folose9te declara ia TYPE.
Exemple: TYPE zile = (luni, mar i, miercuri, joi, viner1, sambata, duminica);
an_na9tere = 1900..1994;
litere ='A'..'Z';
Observa_tii:
Tntr-un program putem defini mai multe tipuri de date prin utilizarea unui singur
cuvant TYPE (toate declara iile de mai sus pot fi facute lntr-un singur program);
atunci cand declaram un tip, declaram de fapt o mul ime de valori posibile
pe care le-ar putea lua variabilele programului.
Declaratia tipurilor cu ajutorul diagramelor de sintaxo prezentam mai jos.
3.5. Declararea variabilelor

Notiunea de variabila a fost prezentata 'fn primul capitol. Aici se prezinta
modul Tn care se declara o variabila de un anumit tip. Pentru declarare se
folose9te cuvantul cheie VAR.
DE TIPURI-------.,
_DEFINITIE
.f TYPE
IDENTIFICATOR
I
BOOLEAN
CHAR
TIP SIMPLU
TIP STRUCTURAT
TIP
-SIMPLU
iNTREG
REAL
TIP REPER
ENUMERAT
SUBDOMENIU
SHORTINT
INTEGER
TIP
-iNTREG
LONGINT
TABLOU
TIP
-STRUCTURAT
STRING
MULTIME
BYTE
ARTICOL
WORD
FI!;>IER
REAL
SINGLE
TIP
-REAL
DOUBLE
EXTENDED
COMP
Figura 3.4.3.1.
Exemple: TYPE zile = (luni, marti, miercuri, joi, vineri, sambata, duminica);
an nastere = 1900..1994;
litere,;'A'..'Z';
Var a: integer;
zi: zile;
an1, an2: an nastere;
ch: litere;
-
Prezentam declararea variabilelor cu ajutorul diagramelor de sintaxa:
DECLARATIA
-- VARIABILA
IDENTIFICATOR
Figura 3.5.1.
3.6. Definirea constantelor

Se face prin utilizarea cuvantului cheie CONST.
Const nota max= 10;
Exemple:
r = 3:-25.
Exista posibilitatea de a defini o constanta prin precizarea tipului ei (care
poate fi !?i un tip structurat). in acest manual se vor da astfel de exemple de
cate ori va fi cazul.
3.7. Expresii
Regulile de formare a expresiilor sunt acelea!?i din matematica.
0 mare importanra in evaluarea expresiilor o are prioritatea operatorilor.

Aceasta este urmiHoarea:
prioritatea 1 (maxima): NOT, +, - (operatori unari);
prioritatea 2: AND, *, /, DIV; (operatori multiplicativi);
prioritatea 3: OR, XOR, +, - (operatori aditivi);
prioritatea 4; > , > =,<, < =, =, IN (operatori relarionali).
in mod normal, expresia se evalueaza de Ia stanga Ia dreapta, tinand cont
de prioritatile operatorilor (putem schimba prioritatile prin utilizarea parantezelor
rotunde).
Gre$eli posibi/e:
1. 1/2*a se calculeaza a de impartit Ia 2 !?i nu 1 de impartit Ia 2*a, daca se
dore!?te aceasta se pune 1 /(2 *a);
2. expresia (a> b) AND (b <c) nu este echivalenta cu expresia:
a> b AND b < c (aceasta din urma nici nu are sens deoarece se efectueaza
inirial b AND b, dupa care expresia l!?i pierde sensul).
3.8. Citirea i scrierea datelor

Acestea se realizeaza
WRITE, WRITELN.
utilizand procedurile standard READ, READLN,
3.8. 1. Citirea datelor

Se face cu ajutorul procedurilor READ !?i READLN.
in acest
paragraf se prezinta aceste proceduri lntr-o forma
simplificata. Pentru amanunte, vezi fi!?iere text.
mult
Procedura READ are forma READ(var), unde var are semnificaria de variabila
(variabilele de tip boolean !?i enumerare nu se citesc). Se cite te de Ia tastatura
o data care se depune in variabila var. Procedura READLN se folose te exact
ca READ, cu deosebirea ca, dupa citire, cursorul sare pe linia urmatoare a
ecranului.
3.8.2. Scrierea datelor

Se face cu ajutorul procedurilor WRITE !?i WRITELN.
in ambele cazuri se scrie lncepand cu pozitia curenta a cursorului pe ecran.
Diferenta lntre WRITE !?i WRITELN este aceea ca, dupa scriere, prin utilizarea
procedurii WRITE cursorul ramane dupa ultimul caracter scris, iar prin utilizarea
procedurii WRITELN el sare pe prima pozitie a randului urmator.
Exemp/e:
WRITE (a), unde a este o variabila intreaga care contine numarul 3 - scrie
3 incepand din pozitia curenta a cursorului.
WRITE (a,b), unde a !?i b sunt variabile lntregi care au continutul 2 respectiv
3- va avea ca efect scrierea numarului 2 urmat de numarul 3 (apare 23).
WRITE(' a= ',a)- areca rezultat scrierea !?irului de caractere 'a=' urmat
de data retinuta de variabila lntreaga a.
Presupunem ca b este o variabila reala care contine numarul 3.25.
WRITELN (b:4:2) va determina aparitia pe monitor a numarului 3.25. Ci-Fra
4 are semnificaria de numar total de pozitii pe care sa se scrie numarui real,
iar citra 2 numarul de pozitii pe care se va scrie partea zecimala (in absenta
acestor parametri, data reala se va scrie intr-o forma greu inteligibila). In
situatia In care partea intreaga a datei reale nu incape in formatul
prestabilit, nu se mai tine cont de acest format.
Capitolul 4
lnstructiunile limbajului Turbo Pascal

Tnainte de a incepe prezentarea instructiunilor acestui limbaj, amintim
conditiile In care acesta a fost elaborat.
1.
Limbajul a fost conceput special pentru scrierea de programe structurate.

Din acest motiv, instruqiunile reproduc structurile fundamentaie ale
programarii structurate. Exista !?i o exceptie 9i anume instructiunea GO TO (salt
Ia o anumita eticheta). Motivul includerii acesteia in setul de instructiuni ale
limbi=iiu.lui este a_cela de a permite programatorilor, obil?nuiti sa lucreze
nestructurat, folosirea acestui limbaj (o gluma care circula Ia aparitia limbajului
spune ca aceasta instructiune a fost in!rodusa spre a permite programatorilor
sa scrie programe BASIC in PASCAL). lntrucat elevilor nu le este permis sao
foloseasca, nu va fi prezentata in acest manual.
DE
ATRIBUIRE IF
COMPUSA
VIDA
CASE
-INSTRUCTIUNE
WHILE
REPEAT
FOR
WITH
PROCEDURALA
Figura 4.1.
2.
Din fericire, autorul limbajului este de formatie matematician, fapt ce i-a
permis sa realizeze urmatoarele:
definirea riguroasa (matematica) a sintaxei limbajului;
mari posibilitati de extindere a tipurilor de date;
introducerea instruqiunii vide, cu mari consecinte asupra programelor.
3.
Limbajul a fost conceput sa fie unul didactic (introducerea in programare
se face cu ajutorul lui, in multe universitati).
Din acest motiv, el este extrem de apropiat de un limbaj de tip pseudocod,
fapt care permite programatorilor cu anumita experienta sa redacteze algoritmii
direct in Pascal. Ulterior, datorita marilor sale calitc':iti, limbajul a fost extins Ia
varianta Turbo Pascal, varianta ce este folosita cu succes de profesioni9ti.
Conceptul de instruqiune rezulta din diagrama de sintaxa din figura 4.1.
4.1. lnstruc1iunea de atribuire

Este de forma:
v: = expresie, unde v este numele unei variabile.
Principiul de executie este urmatorul:

se evalueaza expresia;
variabila via aceasta valoare.
Regula fundamentala este urmatoarea: tipul expresiei trebuie sa coincida cu
tipul variabilei.
Exemple:
1.
x: =3;
x: = x + 2 unde x este o variabila de tip integer sau real.

in urma executiei acestei secvente, variabila x va contine valoarea 5.
2.
a:= i <j unde a este o variabila de tip boolean, i 9i j sunt variabile de
tip real;
Se evalueaza expresia i < j . Daca valoarea lui i este mai mica decat
valoarea lui j, a va lua valoarea TRUE, Tn caz contrar a va lua valoarea
FALSE.
Contraexemple:
1.
2.
i: = i +a unde i este o variabila de tip integer, iar a de tip real. in acest caz
expresia este de tip real iar variabila i este de tip integer. La compilare
apare un mesaj de eroare ('type mismatch');
i: = i/2, unde i este de tip integer. Cu toate ca rezultatul ar putea fi de tip
integer (daca i este par), forma nu este permisa pentru ca expresia este
de tipul real. Corect, ar fi trebuit scris i: = i div 2.
in diagrama de sintaxa prezentata in figura 4.2., apare 9i identificatorul de

funqie. Astfel de atribuiri vor fi prezentate in capitolul care trateaza subprogra
mele Pascal.
Programul p1 interschimba continutul a doua variabile care au fast citite. La
sfar9it, se tipare!?te noul continut al variabilelor.
program pl;
var a,b,c:integer;
begin
write(a=);
readln(a);
IDENTIFICATOR
(VARIABILA)
INSTRUCTIUNE
ATRIBUIRE
EXPRESIE
ID
w
r
i
t
e
(
'
b
=
)
;
r
e
a
d
l
n
(
b
)
;
c
:
=
a
;
a
:
=
b
;
72
b
:
=
c
;
w
r
i
t
e
l
n
(
a
=
'
e
p
e
r
,
a
)
;
w
r
i
t
e
l
n
(
'
b
=
f
e
c
lnstruqiunea
se scrie astfel:
IF expresie
logica
THEN
instructiune 1
EL
E
in
uq
ne
s
t
r
u
c
,
b
)
;
end.
t
u
r
i
4.2
.
lnst
ruc
tiun
ea
IF
i
a
l
t
e
r
Acea
sta
instr
uctiu
ne
core
spun
Principiul de
executie este
urmatorul:
se evalueaza
expresia logica;
daca aceasta
ia valoarea
TRUE, se
executa
instructiunea
plasata dupa
THEN, in caz
contrar se
executa
instruc iunea
plasata dupa
ELSE.
Aten_tie! Atat
dupa THEN cat
9i dupa ELSE
avem voie sa
punem o
singura
instruqiune.
Exemplu:
Programul care
urmeaza
calculeaza
maximul dintre
doua numere
73
citite:
program max;
var a,b:integer;
be
g
i
n
w
r
i
t
e
(
'
a
=
)
;
r
e
a
d
l
n
(
a
)
;
w
r
i
t
e
(
'
b
=
'
)
;
r
e
a
d
l
n
(
b
)
74
if
a>b
then
writeln
(a)
end.
else writeln(b)
Se citesc trei variabile reale a, b, :;;i c. Se cere sa se calculeze

l
a
+
b
,
c
>
O
9='8*b,C=0
a
b
,
c
<
O
Programul p3, care rezolva aceasta problema, exemplifica
folosirea unei instructiuni IF, plasata in corpul altei instructiuni
IF.
program p3;
var a,b,c,e:real;
begin
wr
it
e
('
a=
)
;
re
ad
l
n
(
a
)
;
if c>O
then e:=a+b
else if c=O
t
h
e
n
w
r
i
t
e
e
:
=
a
(
'
b
=
)
;
r
e
a
d
l
n
(
b
)
;
w
r
i
t
e
(
'
c
=
)
;
r
e
a
d
l
n
e
l
s
e
writeln('e=,e:3:2)
end.
e
:
=
a
b
;
4.2.2.
Forma IF
THEN
Aceasta instructiune se
scrie sub forma: IF expresie
logica THEN instructiune.
In situatia In care aceasta.ia valoarea TRUE, se executa
instructiunea aflata
dupa THEN, in caz contrar se trece Ia instructiunea urmatoare.
lata :;;i diagrama de sintaxa care prezinta instructiunea IF:
INSTRUCTIUNEA
IF.
INSTRUCTIUNE
I
N
S
T
R
U
C
T
I
U
N
E
4.3. lnstructiunea compusa

Se pune urmatoarea problema: cum procedam In situa ia in care Ia utilizarea
instruc iunii IF dupa THEN urmeaza sa scriem mai multe instruc iuni (aceea i
problema apare daca dorim sa scriem mai multe instruqiuni dupa ELSE). Pentru
a putea scrie mai multe instruqiuni care sa fie interpretate de compilator ca una
singura se folose te instruc iunea compusa.
lnstructiunea compusa are forma urmatoare:
begin
il;
i2;
in
end.
Aici, i1,..., in reprezinta instruc iunile care se gasesc In corpul instruc iunii
compuse. Acestea sunt separate prin virgula.
Exemplu: Sa se scrie un program care rezolva ecuatia de gradul 1
(a* x + b = 0). Modul de rezolvare a acestei ecuatii a fost discutat pe larg atunci
cand am exemplificat elaborarea algoritmilor prin utilizarea schemelor logice i
a limbajului de tip pseudocod. Aici prezentam programul Pascal care rezolva
aceasta problema. Se observa folosirea unei instruqiuni compuse Ia calculul
radacinii l?i tiparirea ei.
program p2;
var a,b,x:real;
begin
write( 1 a= 1 );
readln(a);
write( 1 b= 1
);
readln(b);
if a<>O then
begin
x:=-b/a;
writeln(1 x= 1 , x: 3:2);
end
else if b=O then writeln( 1 infinitate de solutii 1 )
else writeln( 1 nu avem solutii 1 )
end.
Observatie: orice program PASCAL are eel putin o instructiune compusa

(lncepe cu BEGIN !?i se termina cu END).
Prezentam diagrama de sintaxa a acestei instruc iuni:
INSTRUCTIUNE
COMPUSA
END
Figura 4.4.
4.4. lnstructiunea vida

lnstruqiunea vida nu se trece in program. Totul?i, prin faptul ca este admisa
ca instruqiune, apar multe avantaje cum ar fi:
In cadrul instruqiunii compuse, intre ultima instructiune i blocul END,
sintaxa cere sa nu se puna separatorul ';'. De multe ori, din obi!?nuinta,
programatorii pun chiar
i in acest caz semnul ';'. Compilatorul nu
semnaleaza acest fapt ca eroare, intrucat se presupune ca intre separator i
END se gase te instruqiunea vida;
se poate utiliza instructiunea IF sub forma:
IF expresie logica
THEN
ELSE instructiune;
(dupa THEN urmeaza de fapt instruqiunea vida).
4.5. lnstructiunea CASE

Am aratat faptul ca structurii alternative licorespunde in limbaj instructiunea
IF. Cum procedam in situatia in care in urma unui test avem mai multe variante
de executie? Desigur, putem folosi instructiunea IF (practic dupa THEN sau
dupa ELSE se tree alte instruqiuni IF). Aceasta modalitate de lucru se
dovedel?te de multe ori ineficienta. Acesta este motivul includerii in setul de
instruqiuni al limbajului a instruqiunii CASE.
Forma generala a acesteia este:
CASE expresie ordinala do
c1,[c2,...,cn1]: instructiune 1;
p1,[p2,...,pn2]: instruqiune 2;
z1,[z2,...,znp]: instructiune p
[ ELSE instructiune]
end.
Aici, c 1,...,en1,...,znp reprezinta constante de acelal?i tip ca !?i expresia
ordinala.
se evalueaza expresia ordinala;
se executa acea instructiune care are In fata constanta obtinuta in
evaluarea expresiei;
In situa ia In care nici una din instruc iunile 1...p nu esteprecedata de

acea constanta, se executa instruc iunea plasata dupa ELSE;
daca !?i clauza ELSE este absenta, se trece Ia instructiunea urmatdare.
Observatii:
constantele trebuie sa fie distincte;
pot exista eel mult 255 constante;
Exemplu: Programul care urmeaza probeaza instruc iunea CASE.
program c1;
var i:integer;
begin
write('i=');
readln (i);
case i of
1:
writeln('am citit 1');
2,3:
writeln('am citit 2 sau 3');
else
writeln ('am citit altceva')
end;
end.
Formal, instruc iunea CASE se prezinta astfel:

INSTRUCTIUNEA
CASE
EXPRESIE
ORDINALA
ALTERNATIVA
(CASE)
INSTRUCTIUNE
ALTERNATIVA
(CASE)
CONSTANTA
INSTRUCTIUNE
CONSTANTA
Figura 4.5.
4.6. lnstructiunea WHILE

Aceasta instructiune reproduce structura de tip WHILE DO.
WHILE expresie log1ca DO instruc iune.

se evalueaza expresia logica !?iin caz ca aceasta ia valoarea TRUE se
executa instructiunea, se evalueaza din nou expresia, daca aceasta ia
valoarea TRUE, se executa din nou instructiunea; procedeul se repeta pana
candIa evaluarea expresiei se obtine FALSE.
in situatia in care se dore te sa se ruleze mai multe instructiuni cand
expresia a luat valoarea TRUE, se folose!Jte instructiunea compusa.
Pentru urmatoarele exemple, algoritmii de rezolvare au fost prezentati in
capitolul 2.
Exemp/u/1:
Se cite:;;te n, numar natural. Sa se calculeze suma cifrelor sale (pe:ltru
n=213, se va tipari 6).
program p6;
var n,s:integer;
begin
write(1 n= 1 ) ;
readln{n);
s:=O;
while n<>O
do begin
s:=s+n mod 10;
n:=n div
10 end;
writeln{1 s= 1 , s)
end.
Exemp/u/2:
Se cite!?te n, numar natural. Sa se tipareasdinumarul obtinut rin
inversarea cifrelor sale (pentru n = 41 2, se va tipari 214).
program p7;
var n,ninv:integer;
begin
write {1 n= 1 );
readln{n);
ninv:=0;
while n<>O
do begin
ninv:=ninv10+n mod 10;
n:=n div 10
end;
writeln (1 numarul inversat =
end.
1 ,
ninv);
lnstructiunea WHILE se prezinta prin diagrama de sintaxa astfel:
81
EXPRESIE
LOGICA
INSTRUCTIUNEA
WHILE
INSTRUCTIUNE
Figura 4.6.
4.7. lnstructiunea REPEAT

Aceasta instructiune reproduce structura REPEAT
UNTIL. Forma generaIa a acestei instruqiuni este
urmatoarea:
re
p
e
a
t
i
1
;
i
2
;
i
3
;
in
until expresia logica.
Aici, i1,...,in
reprezinta
instructiuni.
Principiul de
executie este
urmatorul:
se efectueaza secventa de instructiuni i1,...,in
pana cand, Ia evaluare,
expresia logica ia valoarea TRUE.
Observatie: Secventa se executa eel putin o
data, dupa care se pune problema daca sa se repete
sau nu (prin
evaluarea
expresiei !ogice).
Exemp/ul 1:
Se cite te un
numar natural n,
mai mare sau egal
cu 1. Sa se
calculeze suma
primelor n numere
naturale.
program swna;
var
n,s,i:integer;
begin
write( 1 n=
);
readln(n);
i
:
=
l
;
s
:
=
o
;
r
e
p
e
a
t
s
:
=
s
+
i
;
i
:
=
i
+
l
until i>n;
writeln( 1 s=
1 , s)
end.
Exemplu/ 2:
Se cite te n, numar natural. Sa se descompuna In factori primi.
program plO;
var n,i,fm:integer;
begin
write('n=');
readln(n);
i:=2;
repeat
fm:=O;
while n mod i =0 do
begin
fm:=fm+l;
n: =n div i
end;
if fm <>o then writeln
i:=i+l
until n=l
end.
(i, ' la puterea ',fm);
lata cum arata instruqiunea REPEAT prezentata cu ajutorul diagramei de

sintaxa:
_INST: ;J! NEA-c REPEAT
)aoj INSTRUCTIUNE
., I. .---{G) ---'-
Figura 4.7.
4.8. lnstructiunea FOR

De multe ori trebuie repetata o anumita secventa de un numar cunoscut de
ori. Tn acest caz se recomanda folosirea instructiun(i FOR. lnstruqiunea FOR are
doua forme.
Forma 1:
FOR variabila : = expresie 1 TO expresie 2 DO instruqiune.
Cuvantul variabila semnifica variabila de ciclare i ea poate fi de orice tip
ordinal. Expresie 1, expresie 2 sunt expresii care au acelai tip ca 9i variabila de
ciclare.
se evalueaza cele doua expresii;
daca expresia 1 are un ordin mai mare decat expresia 2 se trece mai departe,
iar variabila de ciclare are valoarea expresiei 1;
daca cele doua expresii au aceeai valoare, se executa o singura d 1a
84
instructiunea, variabila de ciclare ia valoarea comuna celor doua expresii;

daca expresia 1 are un ordin mai mic decat eel al expresiei 2 se procedeaza
astfel:
o variabila de ciclare ia valoarea expresiei 1 i se executa instructiunea;
o variabila de ciclare ia valoarea succ (din vechea valoare a variabilei de
ciclare) l?i se executa instructiunea;
o procedeul continua,repetitiv,pana cand se executa instructiunea !?i pentru
variabila de ciclare egala cu valoarea expresiei 2 (In acest caz, dupa ie!?irea
din ciclu variabila de ciclare va avea valoarea expresiei 2).
Forma 2:
FOR variabila ciclare: = expresie 1 DOWNTO expresie 2 DO instructiune.
Diferenta fata de forma 1 este ca Ia fiecare pas variabila de ciclare va lua ca
valoare pred (vechea valoare).
Exemp/u/1:
Sa se calculeze suma primelor n numere naturale utilizand instructiunea FOR.

Se prezinta doua programe care calculeaza aceasta suma (se utilizeaza cele
doua forme ale instructiunii FOR).
program f1;
var n,s,i:integer;
begin
write( 1 n= 1 );
readln(n);
s:=O;
for i:=1 ton do s:=s+i;
writeln(1 s= 1 , s)
end.
program 2;
var n,s,i:integer;
begin
write(1 n= 1 ) ;
readln(n);
s:=O;
for i:=n downto 1 do s:=s+i;
writeln(1 s= 1, s)
end.
Exemp/u/2:
Sa se listeze alfabetul. Se prezinta doua variante de listare in ordine normala

!?i inversa.
program 3;
var i:char;
begin
for i:=
a 1 to
z 1 do write(i);
end.
program f4;
var i:char;
begin
for i:='z' downto a do write(i);
end.
Exemplul 3:
Este unul tara efect deosebit, dar demonstreaza varietatea tipurilor de date
care pot fi folosite de FOR. in acest exemplu se listeaza primele trei luni ale
anului In ordine naturala !?i in ordine inversa.
program fS;
var i:(ianuarie,februarie,martie);
begin
for i:=ianuarie to martie do
case i of
ianuarie: writeln('ianuarie);
februarie: writeln('februarie);
martie: writeln(martie')
end
end.
program f6;
var i:(ianuarie,februarie,martie);
begin
for i:=martie downto ianuarie do
case i of
ianuarie: writeln('ianuarie);
februarie: writeln('februarie');
martie: writeln('martie')
end
end.
Pentru exemplele care urmeaza, algoritmii au fost prezentati in capitolul 2.

Exemp/u/ 4:
Pentru n citit (n natural mai mare sau egal cu 1) sa se calculeze suma

S= 1 + 1 *2 + 1 *2*3+ ... + 1 *2* ...
*n.
program pS;
var n,i,s,p:integer;
begin
write('n=');
readln(n);
s:=O;
p:=l;
for i:=l ton do
begin
p:=pi;
s:=s+p
end;
writeln('s=,s)
end.
Exemp/u/5:
Se citel?te n numar natural. Sa se precizeze daca este prim sau nu.
Se prezinta doua variante de program care rezolva aceasta problema.
program p8;
var n,i:integer;
prim:boolean;
begin
write('n=');
readln(n);
prim: =true;
for i:=2 to trunc(sqrt(n)) do
if n modi =o then prim:=false;
if prim then writeln(numarul este prim')
else writeln('numarul nu este prim')
end.
program p8;
var n,i:integer;
prim:boolean;
begin
write('n=');
readln(n);
prim:=true;
if n modi =0 then prim:=false;
if prim then writeln(numarul este prim')
else writeln('numarul nu este prim')
end.
Exemplul 6:
Sa se scrie un program care tipare te primele nr numere prime (nr se cite te).
program p9;
var n,i,j,nr:integer;
prim:boolean;
begin
n: =1;
j: =0;
write(nr= );
readln(nr);
repeat
prim:=true;
74

if n mod i=o then prim:=false;
if prim then
begin
writeln(n);
j: =j+1
end;
n:=n+1
until j=nr
end.
Exemplu/ 7:
Sa se tipareasca toate numerele naturale mai mici sau egale cu 10000 care
se pot descompune in doua moduri diferite ca suma de cuburi.
program p11;
var n,nr,max,i,j,i1,j1,i2,j2:integer;
begin
for n:=1 to 10000 do
begin
max:=trunc(exp(1/3ln(n)));
nr:=O;
for i:=1 to max do
for j:=i to max do
if i*i*i+j*j*j=n then
begin
if nr=O then,
begin
i1:=i;
j 1:=j
end
else
begin
i2:=i;
j2: =j
end;
nr:=nr+1;
end;
if nr>1 then writeln(n,' ',i1,' ,j1,' ,i2,' ,j2)
end
end.
Prezentam instructiunea FOR cu ajutorul diagramelor de sintaxa.

INSTRUCTIUNE
FOR.
IDENTIFICATOR
EXPRESIE
Figura 4.8.
88
EXPRESIE
INSTRUCTIUNE
4.9. Aplicatii Ia capitolele 3
'i
Algoritmi simpli
Pentru aplica1iile de mai jos, algoritmii se vor redacta utilizilnd schemele
logice, un limbaj de tip pseudocod i programe PASCAL.
1. Se cite:;;te o valoare intreaga. Sa se precizeze daca ese pozitiva sau nu.
2. Se citesc 3 valori reale a, b, c. Sa se precizeze daca ele pot fi laturile
unui triunghi.
3. Sa se scrie un program care rezolva o ecua1ie de gradul 2.
4. Se citesc 4 numere intregi. Sa se tipareasca in ordine descrescatoare.
5. Sa se calculeze valoarea func1iei F, definita pe mu11imea numerelor reale,

pentru un x citit:
F
IX *X-3,
X<5
1I
5 s X s 25
X *X-5 *X +6,
X>25
= \ X+
6. Se citesc 4 valori reale a, b, c, d. Sa se evalueze expresia:
a
E=
b.
c +d>O
a-b, c +d=O
a *b, c +d<O
7. Se citesc a, b, c, coeficientii unei ecua1ii de gradul 2. Fara a rezolva

ecuatia, sa se precizeze natura radacinilor (reale sau nu, pozitive, negHive,
semnul radacinilor (daca sunt reale).
8. Se citesc n numere reale. sa se tipareasca valoarea minima citita.
9. Se cite!Jte un ir de numere intregi pana Ia intillnirea numarului 0. Si:i se
calculeze media aritmetica a numerelor din ir.
10. Citim un !Jir de numere intregi, Ia fel ca Ia problema precedenta. Sa se
calculeze suma dintre primul numar, al treilea, al cincilea,... :;;i produsul dintre
al doilea, al patrulea,... etc.
11. Se citesc 3 numere naturale n, p, k si un sir den numere naturale. Gate
dintre acestea, imparlite Ia p dau restul ki
12. Sa se calculeze expresiile de mai jos (programe separate):
1
1
1
E = 1 +- + -- +,.. + --
22
E2= 1
-+
23
32
n2
---- + ... +
34
(n+1)(n+2)
n!=123... n
1
1
E3 =
+ ... +
1
1
+- +-,
1! 2!
n!
13. Sa se calculeze produsul a doua numere naturale prin
adunari repetate.
14. Efectua!iimpartirea intreaga a doua numere citite, far a a
utiliza operatorii
MOD !?i DIV.
15. Se cite!?te o succesiune de cifre 1 l?i 0 in care prima este
1. Aceasta are semnificatia unui numar In baza 2. Sa se
tipareasca numarulln baza 10.
16. Se cite!?te o succesiune de caractere ('fntr-o variabila de tip
char) '0', '1 ',
..., '9', 'a', 'b', ..., 'f' In care primul caracter citit nu este 0.
Aceasta are
semnificatia unui numar 'fn baza 16. Sa se tipareasca numarulln
baza 10.
17. Se considera !?irul definit astfel (FIBONACCI):
1, daca
n=1 sau n=2 u(n)
= { u(n-1) +u(n2), altfel
Se cite!?te o valoare naturala a. Sa se calculeze u(a).
18. Se considera !?irul definit Ia problema anterioara. Sa
se tipareasca numarul lui de termeni care sunt strict mai mici
decat o valoare citita.
19. Se citesc doua numere naturale m i n; Sa se calculeze
eel mai mare divizor comun al lor:
a) prin utilizarea algoritmului lui EUCLID;
b) prin utilizarea relatiei de mai jos:
cmmdc{a
-b,b), cmmdc(a,b) =
cmmdc{a,b-a),
_
d
a
c
a
a
>
b
;
d
a
c
a
a
<
b
;
d
a
c
a
a
=
b
.
20. Se
cite!?te
un numar
natural.
Cate cifre
contine?
21.
Calculati
suma !?i
produsul
divizorilor
primi ai
unui
numar
citit.
22. Se
citesc, pe
rand, cifrele unui numar (lncepand cu cifra cea mai

semnificativa). Sa se formeze numarul, lntr-o variabila de tip
integer.
23. Se cite!?te un numar cu 5 cifre. Tipariti numarul format
dupa eliminarea cifrei din mijloc.
24. Se cite!?te un numar cu 8 zecimale (partea lntreaga a

acestuia este 0).
Sa se tipareasca numarul rezultat prin eliminarea primelor doua l?i ultimelor

doua zecimale. Exemplu: 0.12345678, se va tipari 0.3456.
25. In practica, un rol fundamental il joaca numerele aleatoare (lntampla
toare). Exista mulri algoritmi G_are permit generarea lor, insa ace tia implica
ni te cunol?tinte de matematica ce depa!?esc cu mult programa de liceu. Aici
vom prezenta pe eel mai modest dintre ei, dar i eel mai simplu. Se considera
un numar cu 8 zecimale si se inlatura 4 dintre acestea, lntocmai ca Ia problema
anterioara. Numarul obtinut se ridica Ia patrat. In acest fel obtinem un nou
numar cu 8 zecimale, cu care se procedeaza in mod identic. Cititi un numar cu
8 zecimale i tipariti prtmele n numere obtinute prin procedeul indicat.
Observatie: pentru un !?ir astfel obtinut, Ia un moment dat valorile se repeta
(se spune ca l?irul este periodic). in acest sens, pentru ca l?irul sa se repete
dupa un numar cat mai mare de valori, nu este indiferent numarul de Ia care se
pleaca. incercati programul stabilit, pentru mai multe numere de pornire,
inclusiv pentru eel definit in problema 24.
26. Pornind de Ia problema anterioara, gasiti un procedeu de generare a
numerelor aleatoare intregi.
27. Gasiti un procedeu de generare a unor numere aleatoare lntregi care sa
se gaseasca intre doua valori intregi citite.
28. Cititi un numar natural n i unul real R < 1; generati n perechi de
numere aleatoare de forma (x,y). cu x i y valori pozitive, cuprinse In
intervalul [O,R). Cate perechi dintre acestea verifica relatia X*X+Y*V<R*R?
Daca reprezentam In plan un punct de coordonate (x,y), unde x l?i y verifica
relatia de mai sus, acesta se va gasi in interiorul unei figuri determinate de axa
OX (in sens pozitiv), axa OY (in sens pozitiv) !?i cercul de raza R, cu centrul in
origine. Aria acestei figuri este "*R*R/4.1ndiferent daca perechea (x,y) verifica
sau nu relatia de mai sus, punctul se va gasi in interiorul unui patrat de la ura
R (aria R*R). in cazul in care punctele se distribuie proportional in interiorul unei
figuri, aria fi_!;lurii este proportionala cu numarul punctelor care se gasesc in
interiorul ei. In concluzie, raportul celor doua arii considerate este aproximativ
ega! cu raportul dintre numarul punctelor care se gasesc In interiorul figurii mai
sus precizate i numarul total de puncte (care sunt oricum in interiorul
patratului). Raportul celor doua arii este "/4.
Calculati catul dintre numarul de puncte care se gasesc in interioru! cercului
!?i numarui total de puncte, inmultiti rezultatul cu 4. in acest fel, se obtine o
valoare aproximativa pentru numarul " incercati algoritmul cu diferite numere
de pornire (pentru generare) i cu un numar variabil de puncte care vor fi
reprezentate.
29. Se considera un triunghi echilateral inscris intr-un cere de raza R. Care
este lungimea laturii triunghiului echilateral in functie de raza cercului? Unim
mijlocul M al unei laturi a triunghiului cu centrul cercului 0 i prelungim seg
mentul OM pana intersecteaza cercul intr-un punct P. Se traseaza segmentele
care unesc extremiti:itile laturii cu punctul P. Procedand in mod asemanator cu
fiecare latura, se obtine un hexagon regulat (de ce ?) . Cu acelai procedeu,
acestuia i se dubleaza numarul de laturi .a.m.d.
acestuia i se dubleaza numarul de laturi .a.m.d.

Considerand In lungimea laturii unui poligon regulat, inscris intr-un cere de
raza R, sa se calculeze 12n, lungimea laturii poligonului regulat cu un numar
dublu de laturi, inscris in acelai cere i care a fost obtinut aa cum s-a aratat
mai sus (se va calcula 12n Tn func ie de In i R, fara a utiliza func1ii trigono
metrice).
in cazul in care se porne!?te de Ia triunghiul echilateral, se dubleaza
numarul de laturi, iar se dubleaza (de n ori) i se obtine un poligon regulat
al carui perimetru se cere.
Dupa un numar de astfel de dublari ale laturilor, perimetrul poligonului regulat
care se ob ine aproximeaza destul de bine lungimea cercului (2*"*R). in
concluzie, daca se imparte perimetrul Ia 2 * R, se obtine o valoare aproximativa
a numarului "
Scrieti un program care sa calculeze astfel numarul " Programul va avea ca
data de intrare numarul natural n (de cate ori dublam laturile triunghiului
echilateral).
Testati programul pentru diverse valori ale lui n. Veti observa ca, pentru
valori mai mari ale lui n, vom ob ine pentru "valoarea 0 (absurd). Explicai care
este cauza.
30. Un numar este perfect daca este egal cu suma divizorilor sai
(excluzandu-1 pe el). Exemplu: 6 = 1 + 2 + 3. Tiparii toate numerele perfecte
pana Ia un Tntreg citit.
31. Pana Ia un intreg citit, tipariti toate numerele naturale care sunt egale cu
suma patratelor cifrelor lor.
32. Determinati numarul de zile trecute intre doua date calendaristice citite
(anii bisecti sunt cei divizibili cu 4).
33. Afi ati primele n perechi de numere prime care sunt consecutive in
multimea numerelor impare. Exemplu: (3,5), (5,7).
34. Se cite!?te un numar natural par. Sa se descompuna in suma de numere
prime (conjectura GOLDBACH).
35. Se citesc doua numere naturale formate din cate 4 cifre distincte. Care
este numarul cifrelor comune celor doua numere (nu coincid obligatoriu !?i ca
pozitie)?
36. Se citesc 2 numere naturale n i m. Calculai n Ia puterea m efectuand,
pe cat posibil, mai putin de m-1 inmultiri.
37. Se citesc n numere naturale. Sa se tipareasca eel mai mare divizor
comun al lor.
38. Se citesc a, b, c coeficien ii unei ecua ii de gradul 2 i un numar natural

n. Fara a rezolva ecuatia sa se calculeze expresia:
Indicatie:
ax, + bx, + c = 0
x1 radaeina - A
lnmultln m relatl - ax n +2 + b n 1 +cx n = 0.

x1
a cu x
1
1
1
n2
n1
n
Analog, ax 2 +bx2
+cx2 = 0.
.
n2 n+2
n+1 n+1
n
n
Pnn adunare - a(x 1 +x2 ) +b(x1 +x2 ) +C(x1 +x2 ) = 0
b
2
2
2
b c
- aSn+2+bSn+1 +cSn=O, dar S,=--,
S2=x,
+X2=(X,tX2)
-2X1X2=--2--.
a
ProgramaJi
relaJie
recurenJa.
o
de
a2
a
39. Rezolvati in multimea numerelor

intregi ecuatia: X*X- Y*Y = k (k
natural);
I
n
d
i
c
a
t
i
e
:
Putem scrie: (x- y)
* (x + y) = k.
Notam: x - y
x
a;
+ y = b;
Rezulta: x = (a + b) I 2;
y = (b - a) I 2.
Pe alta parte, a i b trebuie sa fie divizori ai lui k. De asemenea
se tine cont de faptul ca, daca ecuatia admite solutia (x,y)
admite i solutiile (-x, -y), (-x, y), (X, -y).
40. Se citesc pe rand n numere naturale !Ji un numar p.
Se cere sa se gaseasca k maxim, astfel incat p Ia puterea k
divide produsul celor n numere naturale. Se va evita
efectuarea produsului celor n numere naturale.
94
Capitolul 5
Tipuri structurate de date

5.1. Tipul tablou
5.1.1. Tipul ARRAY
Pentru explicarea necesitatii tipului ARRAY vom porni de Ia o aplicatie
practica. Se citesc 100 de numere naturale. Sa se precizeze daca acestea sunt
distincte sau nu. Pentru rezolvare, In program ar trebui sa retinem o suta de
variabile de tip lntreg. Pe langa acest dezavantaj major, imaginati-va cum ar
arata secventa de program care testeaza daca numerele continute de cele 100
de variabile sunt distincte sau nu. Dar daca ar trebui sa rezolvam aceasta
problema pentru 1000 de numere? $irul de exemple care sa justifice utilizarea
tipului ARRAY ar putea continua Ia nesfar!?it.
Cum se declara variabilele de acest tip?
Programul urmator (care de altfel nu realizeaza nimic) exemplifica astfel de
declara1ii.
program a1;
type vector=array [1..100] of integer;
vector1=array [-10..10] of real;
var a:vector;
b,c:vector1;
d:array[1..21] of char;
begin
end.
0 variabila de tip vector va contine 100 de componente. Fiecare

componenta va retine un numar intreg. 0 variabila de tip vector1 contine 21
de componente. Fiecare din ele retine un numar real. Variabila d are 21 de
componente care memoreaza cate un caracter.
Observatii:
Nu putem sa declaram un tip array cu un numar variabil de componente (a!?a

cum este permis In limbajul BASIC, de exemplu: citim n !?i declaram o
variabila care are n componente).
Nu este obligatoriu ca indicele componentelor sa fie cuprins intre 1 !?i n (tipui
vector1 are !?i componente de indice negativ). Prin indicele unei componente
intelegem valoarea prin care putem adresa components.
Se pot declara variabile de un tip anonim (tipul variabilei d a fost precizat Ia
declararea variabilei).
Tn memoria calculatorului componentele unei variabile de tip array se retin

una dupa alta (fara a exista spatiu lntre ele).
Cum se adreseaza componentele unei variabile de tip array?
Pentru adresarea unei componente, se folose9te numele variabilei urmat de
indicele ei. lndicele este trecut in mod obligatoriu intre paranteze drepte.
Prograll]ul care urmeaza cite!?te !?i tipare!?te componentele unei variabile de
tip array. In final, se tipare9te din nou continutul componentei a doua.
program a2;
var a:vector;
n,i:integer;
begin
writ'e( 1 n= 1 );
readln(n);
for i:=1 ton do begin
write(1 a[1 , i, 1 ] = 1 ) ;
readln(a[i])
end;
for i:=1 ton do writeln( 1 a[ 1 ,i, 1 ]= 1 ,a(i]);
writeln(a[2])
end.
Observatii:
Este indicat ca Ia citirea unei componente sa se tipareasca !?i numarul ei de
ordine (pentru ca acela care introduce datele sa !?tie de fiecare data ce
componenta introduce);
Nu este obligatoriu ca indicele sa fie continut intr-o variabila. El poate fi
trecut printr-o valoare (am procedat astfel cand am tiparit componenta doi).
Teoretizand, tipul array se declara dupa diagrama de sintaxa de mai jos:
TIP
-TABLOU
Figura 5.1.1.
Dupa cum rezulta din diagrama, indicele poate fi de un tip ordinal (cu un
numar finit de elemente). Nu poate fi indice un tip INTEGER dar este admis
pentru indici un subdomeniu al tipului INTEGER a!?a cum de altfel am folosit In
toate exemplele de pana acum.
Tn diagrama, prin TIP se intelege tipul de baza al tabloului, adica tipul
componentelor acestuia.
Sa exemplificam cele prezentate in diagrama, aratand astfel !?i extraordinara
diversitate a tipurilor de date ale limbajului. Programul care urmeaza cite!?te !?i
tipare!?te o variabila cu componente de tip intreg, dar indicele componentelor
este tipul char (care este un tip ordinal).
program a3;
type vector=array
var a:vector;
i:char;
[char] of integer;
begin
for i:= 1 a 1 to 1 C 1
do begin
write(1 a[1 ,i, 1 ] = 1 ) ;
readln(a[i])
end;
for i:= 1 a 1 to 1 C 1 do writeln( 1 a[ 1 ,i, 1 ]= 1 ,a[i]);
end.
Programul a4 cite te o variabila de tip array cu componente reale i indice

de tip enumerare.
program a4;
type
zile=(luni,marti,miercuri,joi);
vector=array [zile] of real;
var a:vector;
i:zile;
begin
for i:=luni to joi do readln(a[i]);
for i:=lur.i to joi do writeln(a[i]:5:2);
end.
Componentele unei variabile de tip array pot fi Ia randul lor variabi!e de tip
array.
Tn programul urmator tipul matrice are trei componente de tip vector.
Programul cite te i tipare te o variabila de tip matrice. Observati modul de
adresare a componentelor.
program as;
type vector=array[l..2] of integer;
matrice=array[l..3] of vector;
var i,j: ipteger;
a:matrice;
begin
for i:=l to 3 do
for j:=l to 2 do
readln(a(i]
[j]);
for i:=l to 3 do
for j:=l to 2 do
writeln(a[i][j])
end.
Modul de adresare este departat de eel folosit in matematica. Astfel, Tn

matematica o matrice este un tablou cu un numar de linii.i coloane. intr-o anu
mita linie l?i coloana se gasel?te un element de un anumit tip (intreg, real !?.a).
0 matrice arata al?a cum se vede mai jos:
Elementul din linia i i coloana j se simbolizeaza prin a(i,j), unde a reprezinta

matricea. Pentru a putea scrie cu u urinta programe care lucreaza cu matrice,
limbajul Pascal permite l?i o altfel de adresare P'entru componentele de acest
tip. Pentru un astfel de tip se folosesc doi indici de adresare. Fiecare din ei
trebuie sa respecte regulile prezentate pentru un singur indice. Programul care
urmeaza prezinta citirea l?i scrierea unei matrice cu trei linii l?i doua coloane (de
acelai tip cu cea folosita in programul anterior).
program as;
type matrice=array[l.. 3,1..2] of integer;
var i, j:integer;
a:matrice;
begin
for i:=l to 3 do
for j:=l to 2 do
readln(a[i,j]);
for i:=l to 3 do
for j:=l to 2 do
writeln(a[i,j])
end.
Este momentul sa clarificam anumite probleme care apar atunci cand se

lucreaza cu tipul array. Daca un astfel de tip are componente care nu sunt de
tip array spunem ca lucram cu vectori.
in situatia in care componentele sunt de tip array i Ia randul lor au compo
nente care nu sunt de tip array spunem ca lucram cu matrice. Vectorii au o
singura dimensiune, iar matricele au doua dimensiuni (linie, coloana). Evident
i matricele se pot generaliza in sensul ca acestea au componente de tip
vector. Pentru a identifica un elemental unui astfel de tip avem nevoie de trei
indici, motiv pentru care spunem ca astfel de structuri au trei dimensiuni. in
general, putem Iuera cu structuri n dimensionale.
Aplicatii:
Problema 1
Se cite te un vector cu n componente (numere naturale). Se cere sa se

tipareasca valoarea maxima dintre numerele citite.
Algoritmul de rezolvare este urmatorul:
variabilei max i se atribuie valoarea primei componente;
pe rand, se compara valoarea variabilei max cu valorile existente in
componenta 2, 3, n i de cate ori valoarea retinuta intr-o componenta
este mai mare decat valoarea retinuta Tn max, variabilei max i se atribuie
valoarea acelei componente.

Acest algoritm efectueaza n-1 comparatii.
program m;
var v:vector;
i,max,n:integer;
begin
write( 1 n= 1 );
readln(n);
for i:=1 to n do
begin
write( 1 v[ ,i,']= 1 );
readln(v[i])
end;
max:=v[1];
for i:=2 ton do
if v[i]>max then max:=v[i];
writeln(1 max= 1 , max)
end.
Exercitiu: Scrieti programul care calculeaza minimul dintre componentele

citite ale unui vector.
Problema 2
Se cite!?te un vector avand n componente numere intregi. Se cere sa se
decida daca numerele citite sunt distincte sau nu.
Principiul de rezolvare a acestei probleme este urmatorul:
se compara valoarea primei componente cu valorile componentelor 2, 3,..., n;
se compara valoarea componentei doi cu valorile componentelor 3, 4,..., n;
se compara valoarea componentei n-1 cu valoarea componentei n.
in cazul in care in toate aceste comparatii nu se gase9te nici o egalitate,
rezulta ca numerele citite sunt distincte. La prima egalitate gasita rezulta ca
numerele nu sunt distincte !?i programul se termina cu mesajul corespunzator.
Analizati modul in care a fost scris programul astfellncH Ia prima egalitate
gasita sa se opreasca.
program dist;
var a:vector;
gasit:boolean;
n,i,j:integer;
begin
write( 1 n= 1 );
readln(-.);
for i:=l to n do
begin
write(1 a[1 , i, 1 ] = );
readln(a[i])
end;
gasit:=false;
i:=1;
while not gasit and(i<=n) do
begin
j:=i+1;
while (j<=n) and not gasit do
begin
if a[i]=a[j] then gasit:=true;
j: =j+1
end;
i:=i+1
end;
if gasit then writeln( 1 elementele nu sunt distincte
else writeln( 1 elementele sunt distincte 1 )
end.
Daca .numerele retinute de un vector sunt distincte, rezulta ca ele pot alcatui
o multime. Din acest motiv, un astfel de test se mai numel?te !?i test de mul
time.
Problema 3
Se citesc doi vectori a !?i b cu componente numere naturale distincte (datele

introduse de operator se presupun a fi distincte). Cei doi vectori au n, respectiv
m componente !?i au semnificatia de multimi. Se cere sa se construiasca
vectorul c care reprezinta reuniunea celor doua multimi.
Algoritmul de rezolvare este urmatorul:
se copiaza componentele vectorului a In vectorul c (reuniunea include oricare
din multimile din care rezulta);
se adauga vectorului c acele componente ale vectorului b care nu se
regasesc In vectorul a;
se tipare!?te continutul vectorului c.
Observatii:
Variabila k arata componenta vectorului c in care urmeaza sa se scrie acea
componenta a vectorului b care nu este egala cu nici o componenta a
vectorului a. Care este motivul pentru care, in final, se listeaza primele k-1
componente ale vectorului c?
Se presupune ca vectorul c nu va avea mai mult de 9 componente (vezi
declararea tipului vector).
program reun;
var a,b,c:vector;
n,m,i,j,k:integer;
gasit:boolean;
begin
wr,iteln( 1 multimea A');
write( 1 n= 1 );
readln(n);
for i:=1 ton do
begin
write(1 a[1 , i, 1 ] = 1 )
;
readln(a[i])
end;
writeln(multimea B');
write('m=');
readln(m);
for i:=1 tom do
begin
Write (Ib [I 1 i 1 I ] I ) i
readln(b[i])
end;
for i:=1 ton do c[i]:=a[i];
k:=i+1;
for i:=1 tom do
begin
gasit:=false;
j:=1;
while not gasit and (j<=n) do
begin
if a[j]=b[i] then gasit:=true;
j:=j+1
end;
if not gasit then
begin
c[k]:=b[i];
k:=k+1
end end;
writeln('reuniunea);
for i:=1 to k-1 do writeln(c[i]);
end.
Problema 4
Se citesc doi vectori, a !?i b, cu n 9i m componente numere naturale, avand

semnificatia de multimi. Se cere sa se construiasca l?i tipareasca vectorul c,
care reprezinta interseqia celor doua multimi.
Pornind de Ia faptul ca intersectia a doua multimi este formata din elementele
comune celor doua multimi, vectorul c se construiel?te din acele elemente. ale
vectorului a care sunt si elemente ale lui b.
Care este motivul pentru care cautarea unui element al multimii a In
multimea b nu se face utilizand instructiunea for?
program inters;
var alb,c:vector;
n1m1i1 j1 k:integer;
gasit:boolean;
begin
writeln('multimea A');
write('n=);
readln(n);
for i:=1 ton do
begin
Write( Ia (I 1 i 1 I ] :I ) i
readln(a[i])
end;
writeln(multimea B');
write('m=);
readln(m);
for i:=1 to m do
begin
write( b[',i, ]= );
readln(b[i])
end;
k:=O;
for i: =1 to n do
begin
gasit:=false;
j : =1;
while not gasit and (j<=m) do
begin
if a[i]=b[j] then gasit:=true;
j : =j+1
end;
if gasit then
begin
k:=k+1;
c[k]:=a[i]
end
end;
writeln ('intersectia ');
for i:=1 to k do writeln(c[i])
end.
Pro.blema 5
Se cite te un vector cu n componente numere naturale. Se cere sa se

sorteze componentele acestui vector In ordine descrescatoare.
Exista foarte multi algoritmi de sortare. Aici vom considera algoritmul eel mai
simplu, acela Ia care s-ar gandi cineva care este pus pentru prima data in fata
acestei probleme. Aceasta nu inseamna ca acest algoritm este l?i eficient,
dimpotriva.
in ce consta acesta? Se calculeaza maximul dintre elementele vectorului.
Acesta este trecut pe prima pozitie a unui alt vector numit vs !?i care va contine
componentele sortate. Dintre componentele ramase se calculeaza din 'lOU
maximul care este trecut pe pozitia 2 a vectorului vs. Procedeul continua pal}a
cand sunt trecute toate componentele vectorului care se sorteaza in vs. In
final, se listeaza vs. Pentru a calcula mereu maximul dintre componentele
ramase, se considera un vector suplimentar, numit s, care are tot n
componente. Atat timp cat componenta i a vectorului v nu a fost gasita
maxima !?i deci selectata, s(i) are valoarea 1, In caz contrar are valoarea 0.
program sort1;
type vector=array[1..9] of integer;
var v,vs,s:vector;
n,i,j,k,max;poz:integer;
begin
write( 1 n= 1 );
readln(n);
for i:=1 to n do
begin
Write (IV [I IiI I ] =I ) ;
readln(v[iJ)
end;
for i:=1 ton do s[i]:=1;
for i:=1 to n .do
begin
j: =1;
while s[j]=O do j:=j+1;
if j<=n then
begin
max: =v[j];
poz:=j;
for k:=j+1 ton do
if s[k]=1 then
if v[k]>max then
begin
max:=v(k];
po:i:: =k
end;
s[poz]:=0;
vs[i]:=max
end;
end;
for i:=1 ton do writeln(vs[i]);
end.
Problema 6
Se cite!?te un vector cu n componente numere intregi. Sa se sorteze

crescator.
Desigur, se poate folosi algoritmul din problema precedenta cu deosebirea
ca aici se va calcula de fiecare data minimul. Vom folosi o alta metoda, numita
metoda bulelor. Tn ce consta ea? Se parcurge vectorul de mai multe ori !?i se
inverseaza de fiecare data elementele alaturate care nu respecta relatia de
ordine considerata. Procedeul continua pana candIa o parcurgere a vectorului
nu am facut nici o inversare.
Exemplu: Sa presupunem ca am citit 4, 1, 3, 2.
se parcurge pentru prima data vectorul:
o se inverseaza 4 cu 1 l?i se obtine 1, 4, 3, 2;
o se inverseaza 4 cu 3 !?i se obtine 1, 3, 4, 2;
o se inverseaza 4 cu 2 !?i se obtine 1, 3, 2, 4;
intrucat Ia aceasta parcurgere am avut inversari, reparcurgem vectorul:
o se inverseaza 3 cu 2 !?i ob!inem 1, 2, 3, 4;
intrucat am avut inversari, se reparcurge vectorul:
o nu se face nici o inversare;
in acest moment vectorul este sortat, iar algoritmul se opre!?te.
Observati ca ideea de sortare este mai greu de gasit, dar algoritmul acesta
este mult mai simplu decat eel anterior.
Care este modificarea ce trebuie facuta astfel Tncat vectorul sa fie sortat
descrescator?
program sort2;
type vector=array[l..10]
var n,i,m:integer;
v:vector;
inversari:boolean;
begin
write( 1 n= 1 );
readln(n);
for i:=1 ton do
begin
Write (IV [I 1 i 1 I
)
of integer;
] :I
readln(v[i])
end;
repeat
inversari:=false;
for i:=1 to n-1 do
if v[i]>v[i+l] then
begin
m:=v(i];
v[ij :=v[i+1];
v[i+1]:
=m;
inversari:=true
end;
until not inversari;
writeln('vectorul sortat ');
for i:=1 ton do writeln(v[i])
end.
5. 1.2. Tipul STRING

Se propune urmatoarea problema: sa se citeasca i sa se tipareasca cuvantul
'calculator'. Pentru aceasta, trebuie sa procedam astfel:
retinem un vector cu eel putin 10 componente de tip char;
citim cuvantul, caracter cu caracter;
Tl tiparim (paradoxa!, tiparirea se poate face in ansamblu).
Programul urmator realizeaza toate acestea:
program st1;
var a:array[1..10]
i:integer;
of char;
begin
for i:=1 to 10 do read(a[i]);
writeln;
writeln(a);
end.
Sa recunoal?tem ca o astfel de modalitate de lucru este deosebit de greoaie.

Dar daca citim un cuvant cu patru litere? S-ar putea scrie o secventa care sa
citeasca cuvantul pana Ia intalnirea caracterului ENTER, lnsa !?i aceasta
modalitate este dificila.
Limbajul Turbo Pascal contine un tip de date, numit STRING, care permite
sa se lucreze cu mare u9urinta In aceste cazuri. lata cum arata programul care
rezolva problema pusa Ia inceputul acestui paragraf:
program st2;
var a:string;
begin
readln(a);
writeln(a);
end.
0 astfel de rezolvare a problemei propuse prezinta 9i un alt avantaj l?i anume,

se poate citi un cuvant (sau mai multe cuvinte separate prin blancuri) fara a l?ti
de Ia inceput numarul de caractere ce vor fi citite (totu9i acest numar trebuie
sa fie mai mic sau egal cu 255).
0 variabila de tip STRING poate retine maximum 255 de caractere !?i pentru
ea se rezerva in memorie 256 de octeti (in primul octet se retine lungimea
efectiva a cuvantului citit).
Mai mult, nu suntem obligati sa declaram variabile de acest tip care sa
contina 256 de octeti. Exista posibilitatea sa declaram variabile de tip STRING
cu un numar mai mic de octeti. De exemplu, daca Ia problema propusa !?tim de
Ia inceput ca lungimea cuvantului citit nu depa9e9te 20 de caractere, putem
proceda ca in programul urmator:
program st3;
var a:string[20];
begin
readln(a);
writeln(a);
end.
De aceasta data, pentru variabila a s-au retinut 21 de octeti.

Ca 9i Ia tipul array, exista posibilitatea de a adresa un anumit caracter pentru
cuvantul citit. De exemplu, daca variabila a contine cuvantul 'text', a[2] va fi
'e'. Avem posibilitatea de a cunoa9te lungimea efectiva a cuvantului prin
numarul continut in octetul a[O] (pentru exemplul nostru, acesta va contine
numarul 4).
program st4;
var a:string;
begin
readln(a);
writeln(a);
writeln(a[2]);
writeln('cuvantul
end.
citit,are
,ord(a[O]),
litere')
Variabilele de tip STRING pot face obiectul instruqiunii de atribuire.

Consideram instruqiunea a:= b, unde a i b sunt variabile de tip string. in
principiu, In urma executiei acestei instructiuni variabila b are acelai continut
ca i variabila a.
Distingem, totul?i mai multe situatii.
Daca variabila a are rezervati mai putini octeti decat continutul efectiv al va
riabilei b, l?irul de caractere ce va fi continut de a va avea un numar de carac
tere egaI cu numarul caracterelor pe care le poate retine a i anume primele po
ziti de Ia stanga Ia dreapta ale irului continut In b (nu se semnaleaza eroare).
In situatia in care variabila a are rezervati mai putini octeti decat variabila b, dar
l?irul continut de b are un numar de caractere mai mic sau egal cu numarul
octetilor rezervati pentru a, atribuirea se face normal (a va avea continutullui b).
Testati acestea, folosind programul urmator:
program sts;
var a:string[lO];
b:string[4];
c:string;
begin
readln(b);
a:=b;
writeln(a);
readln(a);
b: =a;
writeln(b);
a:=text ';
b: = baza;
c:=a+b;
writeln(c)
end.
Programul prezentat contine i atribuirea c:=a+ b. in cazul variabilelor de

acest tip operatia + are semnificatia de concatenare. Variabila c va avea drept
continut sirul de caractere ce rezulta din sirul continut de a, urmat de sirul
continut de b. in program, c va avea continutul 'text baza'.
Variabilelor de tip STRING li se pot aplica operatori relationali. Ace tia sunt:
= (egal), < >'(diferit), < (mai mic), <= (mai mic sau egal), > (mai mare),>=
(mai mare sau egal).

Care este mecanismul prin care se realizeaza comparatia? Cum este posibil
ca un cuvant sa fie (de exemplu) mai mare decat altul? Sa nu uitam ca fiecare
caracter are un anumit cod (un numar care se retine pe un octet). Codurile nu
au fost alese intamplator, cia fost respectata ordinea alfabetica a caracterelor
(de exemplu caracterul bare un cod mai mare decat caracterul a). Comparatia
se realizeaza, de fapt, prin codurile caracterelor. Sa presupunem case compara
doua iruri, primul cu m caractere, al doilea cu n caractere (m < = n).
Se procedeaza astfel:
se compara codul primului caracter al primului l?ir c'u codul primului caracter
al celui de-al doilea !?ir, In urma comparatiei se poate ajunge intr-una din
situatiile urmatoare:
primul cod este mai mare, caz In care se considera primul !?ir mai mare decat
celalalt;
primul cod este mai mic, astfel ca primul !?ir este mai mic;
cele doua coduri sunt egale (avem acela!?i caracter), se trece Ia comparatiile de
cod pentru al doilea caracter al primului !?ir cu al doilea caracter pentru 9irul al
doilea !?i in urma comparatiei se procedeaza Ia fel ca pentru primul caracter.
Presupunem cain urma comparatiei primelor m caractere ale celor doua l?iruri
am avut tot timpul egalitate. Daca m = n, rezulta ca cele doua l?irurisunt egale,
iar daci:i m < n rezulta ca primul !?ir este mai mic decat al doilea.
Programul st6 tipare!?te de doua ori TRUE.
program st6;
var a: string[lO];
b: string[3];
begin
a:= act';
b:=act;
writeln(a=b);
a:=ma;
b:= mal';
writeln(a<b);
end.
Faptul ca doua l?iruri pot fi comparate reprezinta un avantaj enorm in

practica. Astfel, putem sorta altabetic un !?ir de cuvinte. Programul st7 sorteaza
alfabetic componentele unui vector cu elemente de tip string (deci fiecare
element va contine un cuvant).
program st7;
var man:string[lO];
inv:boolean;
n,i:integer;
v:vector;
of string[lO];
begin
write('n=');
readln(n);
for i:=l ton do
beg;.n
Write (IV [I i 1 I ]: I ) j
readln(v[i])
end;
repeat
inv:=false;
for i:=l to n-1 do
if v[i]>v[i+l] then
1
107
begin
man: =v[i];
v[i]: =v[i+l];
v[i+l]:=man;
inv:
=true end
until not inv;
for i:=l ton do
writeln(v[i])
end.
Exista mai multe proceduri !?i functii care pot Iuera cu variabile de tip string.
Pana In acest moment, noi nu am studiat nici procedurile, nici funqiile.
Acestea se vor studia ulterior. Pentru moment,lntelegem ca acestea reprezinta
secvente de program, scrise de altii, care efectueaza anumite calcule !?i
returneaza anumite rezultate. Rezultatele funqiilor le regasim prin numele lor
(Ia fel cum continutul unei variabile se obtine referind variabila prin numele ei)
iar rezultatele procedurilor le regasim continute in anumite variabile pe care le
transmitem atunci cand apelam procedurile. La apel, atat pentru proceduri cat
!?i pentru functii, se transmit (de cele mai multe ori) ca parametri variabile ale
programului nostru. Lucrurile vor fi mai bine lamurite, prin exemple, iar in acest
an vom lnvata pe larg despre proceduri !?i funqii.
5.1.2.1. Functia COPY
Se presupune urmatoarea problema, care apare de multe ori In practica. A
vern o variabila de tip string ce contine un !?ir cum caractere. Se cere sa se ga
seasca sub!?irul care incepe In pozitia i < = m !?i care are n caractere. De exem
plu, variabila a contine !?irul 'calculator' !?i se dore9te sa extragem sub!?irul care
lncepe de Ia pozitia 3 !?i are 4 caractere. Aceasta problema se poate rezolva In
felul urmator:
program st8;
var a,b:string;
i:integer;
begin
a:=calculator;
b:=";
for i:=3 to 6 do b:=b+a[i];
writeln(b)
end.
in program, apare atribuirea b: = ". Aceasta inseamna ca variabilei b i se

atribuie !?irul vid. in continuare variabilei b i se adauga pe rand caracterele
cuprinse intre 3 !?i 6. Se va tipari cuvantul 'Icui'.
Acela!?i rezult ;t se obtine !?i prin apelarea funqiei COPY, cum se vede mai jos:
program st9
var a,b: st ing;
begin
a:= 1 calculator 1 ;
b:=copy(a,3,4);
writeln(b)
end.
Functia COPY extrage un sub ir dintr-un !?ir dat. La apel, funqia COPY are
trei parametri care trebuie scrii in ordinea de prezentare:
!?irul din care se face extragerea;
pozitia primului caracter al 9irului extras;
numarul de caractere care se extrag.
Observa,tii:
Este mult mai bine sa lucram utilizand aceasta functie datorita faptului ca,
prin parametri convenabil ale9i, se poate extrage sub!?irul dorit din orice
pozitie pe orice lungime.
In exemplu am folosit valori efective pentru pozitie !?i numar de caractere,
dar se pot folosi 9i variabile (acest lucru este adevarat in general pentru orice
procedura 9i functie). Daca avem m = 3, n = 4 (m, n variabile de tip
integer) putem pune COPY(a,m,n).
In situatia in care lungimea sub!?irului cerut este mai mare decat numarul de
caractere existente in ir incepand din pozitia solicitaHi, se extrag numai
caracterele din pozitia curenta pana Ia sfar9it. Exemplu: variabila a contine
cuvantul 'tasta'. Funqia Copy(a,3,5) returneaza 9irul 'sta'.
5.1.2.2. Functia POS

Se considera doua variabile a 9i b (de tip string) 9i fiecare din ele contine un
ir de caractere. Se cere sa se precizeze daca 9irul continut de variabila b este
sau nu sub!?ir al variabilei a, iar in cazul unui raspuns afirmativ sa se precizeze
pozitia de inceput a sub9irului continut In b, in 9irul con inut in a.
Exemp/e:
a contine 'calculator' iar b cuvantul'lat' . Raspunsul este afirmativ iar pozitia
de inceput este 6.
a contine 'calculator' iar b cuvantul 'lar'. Raspunsul este negativ.
Programul st10 cauta sub9irul continut in b in cadrul irului continut in a.
Daca este gasit, se tipare9te pozitia de inceput a sub9in lui, in caz contrar se
tipare te 0.
program stliJ;
var a,b:str_ _ng;
i:integf<r;
begin
a:= 1 calcu. 1tor1 ;
b:= 1 lat 1 ;
i:=l;
while (i< length(a)-length(b)+l) and
(b< copy(a,i,length(b))) do i:=i+l;
if i>length(a)-length(b)+l
writeln(i)
end.
then i:=O;
Acela:;;i lucru, dar mai general i mai simplu se realizeaza prin utilizarea
functiei POS. Aceasta are doi parametri: subl?irul cautat i l?irul unde se cauta.
Rezultatul este de tip byte. Daca rezultatul este 0, lnseamna ca subl?irul nu a
fost gasit iar daca rezultatul este < > 0, sub irul a fost gasit l?i s-a returnat
numarul octetului de lnceput al sub irului in cadrul irului.
program stll;
var a,b:string;
i:integer;
begin
a:=calculator;
b:='lat;
i:=pos(b,a);
writeln(i)
end.
Procedurile care urmeaza se prezinta fara sa realizam programe echivalente

in care acestea sa lipseasca.
5.1.2.3. Procedura DELETE

Aceasta procedura are rolul de a l?terge un sub ir din cadrul unui l?ir dat.
Parametrii procedurii sunt urmatorii:
variabila de tip string care contine sub9irul din care se face l?tergerea;
pozitia de inceput a sub9irului in cadrul 9irului din care se face l?tergerea;
numarul de octeti ce vor fi terl?i.
in exemplul urmator variabila a contine 9irul 'calculator'. Dupa executia
procedurii DELETE, variabila a va contine 9irul 'calator'.
program st12;
var a:string;
begin
a:=calculator;
delete(a,4,3);
writeln(a)
end.
5.1.2.4. Procedura INSERT

Rolul acestei proceduri este de a insera un 9ir In cadrul unui alt !?ir.
Pentru executie, sunt necesari urmatorii parametri:
9irul care urmeaza a fi inserat sau v<u4abila ce contine acest 9ir;
variabila ce contine !?irul in care urmeaza sa se faca inserarea;

pozitia primului octet din care se va face inserarea.
in programul st13 variabila a contine !?irul 'mama!?i variabila b contine !?irul
'riti'. Dupa e.xecutia procedurii INSERT variabila a va .contine !?irul 'maritima'.
program stll;
var a,b:string;
begin.
a:=mama;
b:=riti;
insert{b,a,J);
writeln{a)
end.
Dupa cum se !?tie, variabilele numerice au un mod propriu de reprezentare
in memoria calculatorului (cod compl mentar pentru variabile de tip intreg !?i
virgula mobila pentru cele de tip real). In cadrul variabilelor de tip string, fie are
cifra a unui numar se retine in cadrul unui octet prin codul ei (ASCII).
Se pune problema de a converti continutul unei variabile de tip numeric
intr-un ir de tip string !?i invers. in capitolele urmatoare vom vedea care este
motivul pentru care sunt necesare aceste conversii.
5.1.2.5. Procedura STR
Are rolul de a converti continutul unei variabile de tip numeric intr-un !?ir de
tip string.
Pentru apelul acestei proceduri se folosesc doi parametri:
variabila numerica ce contine numarul ce urmeaza a fi convertit;
variabila de tip string care va contine numarul convert t.
Dupa tipul variabilei ce contine valoarea numerit:a ce va fi convertita
(intreaga sau reala) se disting doua forme de apel pentru procedura STR.
a. Variabila este de tip real.
in acest caz, Ia apel, variabila reala se trece sub forma v:m:n unde v este
numele variabilei, m numarul total de caractere pe care le va avea !?irul
convertit, iar n reprezinta numarul de zecimale pe care le va contine numarul
convertit.
b. Variabila este de tip intreg.
La apel, aceasta va fi trecuta sub forma v:m, unde m reprezinta numarul
total de caractere pe care il va avea rezultatul.
Programul st14 exemplifica convertirea continutului unor variabile de tip real
i intreg in iruri de caractere.
program stl4;
var a:string;
b:real;
c:integer;
begin
b:=-23.25;
str(b:6:2,a);
writeln(a); c:=127;
str(c: 3,a);
writeln(a)
end.
5.1.2.6. Procedura VAL

Aceasta procedura are rolul de a converti un 9ir lntr-o valoare numenca.
lntrucat nu orice 9ir poate fi convertit (de exemplu in cazul in care contine o
litera) procedura VALva avea Ia ape! un parametru in plus 9i anume o variabila
de tip intreg ce va contine dupa ape! un numar. Daca acest numar este diferit
de 0, inseamna ca operatia de conversie nu a reu9it.
in concluzie, procedura va utiliza Ia ape! trei parametri:
9irul (sau variabila de tip string ce contine 9irul) care urmeaza a fi convertit;
variabila de tip intreg sau real ce va contine rezultatul conversiei;
o variabila de tip intreg ce va contine, dupa executia procedurii, numarul
care ne spune daca conversia a reu9it sau nu.
in programul urmator se convertesc doua variabile (una de tip intreg 9i alta
de tip real) in l?iruri de caractere.
program st15;
var a:string;
b:real;
c,c_er:integer;
begin
a:='-12.25'; val(a,b,c
er); writeln(b:6:2,'
,c_er); a:='123';
val(a,c,c er);
writeln(c ,c_er);
a:='1a3'; val(a,c,c
er); writeln(c '
,c er)
end.
/
5.2. Tipul inregistrare (RECORD)

5.2.1. Tipul inregistrare fixa
Tn prezentarea acestui tip, vom porni de Ia un exemplu practic. 0 firma
productiva i9i pastreaza materialele, care Lrmeaza sa intre in prelucrare, in n
magazii. Se cere sa tinem o evidenta pe calculator a acestor materiale.
lnformatiile ce trebuie retinute pentru fiecare material sunt urmatoarele:

codul materialului (numar intreg);
magazia in care se gasel?te (numar intreg cuprins lntre 1 l?i n);
denumirea materialului (30 de octeti, deci STRING[30]);
unitatea de masura (bucati, kilograme, litri, STRING[3] );
cantitatea (numar real);
pret unitar (numar real).
Daca un material se gase9te in mai multe magazii, se inregistreaza de mai
multe ori.
Observam ca informatiile care apar perntru fiecare material se retin in
variabile de natura diferita (STRING, INTEGER, REAL). Se pune problema ca
toate aceste informatii sa se regaseasca intr-o singura variabila de un anumit
tip. Tipul de variabila care poate strange toate aceste informatii Ia un loc este
tipul inregistrare. lnformatiile asupra unui material existent intr-o magazie
constituie o inregistrare. Aceasta este alcatuita din mai multe campuri (pentru
exemplul nostru, acestea sunt codul materialului, denumirea lui etc.).
Sa analizam programul de mai jos care cite9te l?i afi9eaza
referitoare Ia un material.
informatiile
program reel;
type material=record
cod,mag:integer;
den:string(30];
wn:string[3];
cant,pu:real
end;
var m:material;
begin
write ('cod'); readln(m.cod);
write ('magazie '); readln(m.mag);
write ('denumire '); readln(m.den);
write ('unitate masura' ); readln(m.wn);
write ('cantitate '); readln(m.cant);
write ('pret unitar '); readln(m.pu);
writeln ('informatiile citite ');
writeln ('cod ',m. cod);
writeln(magazie ',m.mag);
writeln('denumire ',m.den);
writeln('unitate de masura ,m.wn);
writeln(cantitate ,m.cant:5:2);
writeln(pret unitar ,m.pu:5:2)
end.
Tipul material este un tip inregistrare. Descrierea unui astfel ddt1p incepe
prin cuvantul cheie RECORD $i se termina prin END. intre aceste doofi cuvinte
cheie sunt trecu te toate campurile continute cu tipurile lor. Partea cuprinsa
intre RECORD
END se nume9te parte fixa. Figurile de mai jos prezinta
descrierea unui "tip inregistrare cu ajutorul diagramelor de sintaxa.
Variabila m este de tip MATERIAL (deci retine toate informatiile referitoare Ia un
TIP
-INREGISTRARE FIXA
RECORD
DESCRIERE
PARTE FIXA
Figura 5.2.1.1.
DESCRIERE
-PARTE FlxA
TIP
F
ig
u
ra
5
.
2
.
1
.
2
.
material). Adresarea unui camp
al acestei variabile se face prin
numele ei, urmat de punct l?i
numele campului. Astfel, pentru
a adresa campul dense scrie
m.den..
Acest mod de adresare
deranjeaza prin faptul ca se
pierde timp Ia scrierea
programelor (de fiecare data
scriem numele variabilei).
Limbajul pune Ia
dispozitie o instructiune
numita WITH care are rolul
de a U!?Ura adresarea
campurilor. Rescriem
programul anterior utilizand
aceasta instructiune.
program rec2;
cod,mag
:intege
e
n
d
;
var m:material;
begin
with m do
begin
w
r
i
t
e
(
'
c
o
d
'
)
;
r
e
a
d
l
n
(
c
o
d
)
;
w
r
i
t
e
(
'
m
a
g
r;
den:
stri
ng[J
O];
um:s
trin
g[J]
;
cant
,pu:
real
a
z
i
e
'
)
;
r
e
a
d
l
n
(
m
a
g
)
;
w
r
i
t
e
(
'
d
e
n
u
m
i
r
e
'
)
;
r
e
a
d
l
n
(
d
e
n
)
;
write
('uni
tate
masu
ra'
);
readl
n(um);
w
r
i
t
e
(
'
c
a
n
t
i
t
a
t
e
'
)
;
r
e
a
d
l
n
(
c
a
n
t
)
;
w
r
i
t
e
(
'
p
r
e
t
u
n
i
t
a
r
'
)
;
r
e
a
d
l
n
(
p
u
)
;
w
r
i
t
e
l
n
(
'
i
n
f
o
r
m
a
t
i
i
l
e
c
i
t
i
t
e
'
)
;
w iteln ('cod
,cod);
writeln('magazie
',mag);
.
writeln('denumire
',den);
writeln('unitate
de masura ,um);
writeln(cantitate
,cant:5:2);
writeln('pret
unitar ,pu:5:2)
end
end.
Forma
generala a
instructiun
ii WITH
este:
WITH nume variabila de tip inregistrare DO instructiune.

Rolul ei este de a permite (in cadrul instructiunii subordonate ei) adresarea unui
camp fara a preciza numele variabilei. Evident, de cele mai multe ori instructiu
nea subordonata instructiunii WITH este o instructiune compusa.
in figura de mai jos se prezinta forma generalaa instructiunii cu ajutocul
diagramelor de sintaxa.
INSTRUCTIUNE
INSTRUCTIUNEA
WITH
Figura 5.2.1.3.
Aplicatia propusa Ia inceputul acestui paragraf presupune lucrul cu rnamulte
inregistrari, dar programele prezentate pana aici lucreaza cu una singura. In cele
ce urmeaza, se prezinta o modalitate de lucru cu mai multe inregistrari.
Se cere sa se scrie un program care sa citeasca n inregistrari de tip material
!Ji sa calculeze valorile totale pe magazii. De asemenea se va tipari valoarea
tuturor materialelor det.inute de fir.ma.
0 posibilitate de a retine cele n inregistrari este data de declararea unui
vector (structura de tip ARRAY) ale carui componente sunt inregistrari.
Declaratia acestui tip este:
type vector= array[ 1..100] of material.
Cum putem adresa un camp al unei componente? Pentru aceasta, se
precizeaza componenta urmata de punct, urmata de numele campului.
Exemplu: campul den al componentei 3 se adreseaza prin v[3].den, unde v este
o variabila de tip vector. $i in acest caz se poate folosi instructiunea WITH sub
forma WITH v[i] do instructiune, evitand astfel o adresare greoaie. in program
folosim aceasta instructiune atunci cand scriem secventa citirii celor n Tnregistrari.
Pentru calculul totalurilor pe magazii, s-a retinut un alt vector, cu componente
reale, numit vectot. Acest vector are un numar de componente egal cu numarul
de magazii pe care le detine firma (numar pe care programul il cite!?te). Pentru
fiecare inregistrare de tip material se calculeaza valoarea materialului ca produs
intre cantitate !?i pret unitar. Aceasta valoare se adaugtotalului pe magazia careia
iiapartine materialul (campul mag al unei inregistrari). In final, se calculeaza valoa
rea totala a materialelor retinute de firma prin insumarea totalurilor pe magazii.
program reel;
cod,mag:integer;
den:string[JO];
um:string[J];
cant,pu:real
end;
vector=array[1..100] of material;
vectot=array[1..10] of real;
var v:vector;
n,i,nr_mag:integer;
tot:vectot;
total:real;
begin
write(n=');
readln(n);
write('numar de magazii=');
readln(nr mag);
for i:=l to nr mag do tot[i]:=0;
for i: =1 to n
do with v[i] do
begin
writeln(inregistrarea ',i);
write ('cod'); readln(cod);
write (magazie '); readln(mag);
write ('denumire '); readln(den);
write ('unitate masura' ); readln(um);
write ('cantitate '); readln(cant);
write ('pret unitar '); readln(pu);
end;
for i:=l ton do
tot[ [i].mag]:=tot[v[i].mag]+v[i].cantv[i].pu;
total:=o;
for i:=l to nr mag do
begin
writeln(total magazia ,i, ' ,tot[i]:4:2);
total:=total+tot[i]
end;
writeln('total general ,total:5:2)
end.
Observatii:
Programul prezentat este unul didactic, motiv pentru care secvenla de citire
se face separat (pentru a a rata cum se cite!?te un vector de Tnregistrari). Se
putea evita retinerea unui vector pentru aceasta problema. Rescrieliprogra
mul tinand cont de aceasta observatie. De asemenea, multe informatii sunt
inutile in program (de exemplu denumirea fiecarui material se cite!?te pentru
fie care Tnregistrare).
in practica, pentru astfel de aplicatii se folose!?te un alt tip de Tnregistrare numit
FISlER care permite memorarea informatiilor pe suport magnetic. Ce ne facem
daca Ia fiecare prelucrare de materiale trebuie sa le introducem pe toate? Dar
in constructia tipului fi9ier se folose!?te tipul Tnregistrare prezentat aici.
Programul care urmeaza utilizeaza din plin structura de tip vector de Tnregistrari. Se citesc n Tnregistrari de tip material. Acestea se sorteaza alfabetic. in
final, Tnregistrarile sortate sunt tiparite (pentru fiecare Tnregistrare se tipare!?te
denumirea materialului !?i cantitatea). Metoda de sortare a fost prezentata pe
cazul unui vector cu numere Tntregi (se nume!?te metoda bulelor).
program rec4;
cod,mag:integer;
den:string[30];
um:string[3];
cant,pu:real
end;
vector=array[1..100] of material;
var v:vector;
n,i:integer;
inversari:boolean;
m:material;
begin
write('n=); readln(n);
for i:=1 fo n do
with v [i] do
begin
writeln('Inregistrarea ,i);
write (cod '); readln(cod);
write ('magazie '); readln(mag);
write (denumire '); readln(den);
write ('unitate masura' ); readln(um);
end;
repeat
inversari:=false;
for i:=1 to n-1 do
if v(i].den>v[i+1].den then
begin
m:=v[i];
v(i]:=v[i+1];
v(i+1]:
=m;
inversari:=true
end
for i:=1 ton do
with v [i] do
begin
writeln('Inregistrarea' i); writeln(den);
writeln(cant:4:2);
end
end.
Sunt situatii in care unul din campurile unei structuri de tip inregistrare este tot
de tip inregistrare. De exemplu,in aplicatia noastra, pentru fiecare materiC!I trebuie
sa se retina !?i data fabricatiei. Aceasta este compusa din zi, luna i an deci are o
structura de tip inregistrare.
Limbajul permite ca o structura de tip RECORD sa cantina o alta structura de
tip RECORD.
Analizati programul urmator care cite!?te o singura inregistrare din noul tip de
structura. Pentru a adresa campul an al inregistrarii m ar trebui sa folosim
adresarea m.dataf.an, adresare extrem de greoaie. Din acest motiv, in program,
se folose te de doua ori instructiunea WITH.
program recs;
cod,mag:integer;
den:string[JO];
um:string[J];
cant,pu:real;
dataf:record
zi:l..31;
luna:l..12;
an:integer
end
end;
var m:material;
begin
with m do
begin
write ('cod'); readln(cod);
write ('magazie '); readln(mag);
write (denumire '); readln(den);
write ('unitate masura ); readln(um);
with data do
begin
write('ziua fabricatiei '); readln(zi);
write('luna fabricatiei 'l; readln(luna);
write('anul fabricatiei '); readln(an)
end
end
end.
5.2.2. Tipul inregistrare cu variante

Nu toate inregistrarile au o structura fixa (acela!?i numar de campuri) a!?a cum
au fost cele prezentate ca exemplu In paragraful anterior. Sunt cazuri cand un
tip inregistrare are o parte fixa urmata de o parte variabiliL
Sa presupunem ca ne intereseaza o situatie referitoare Ia studiile unei
p.ersoane. 0 astfel de inregistrare are o parte fixa data de campurile care retin
numele, varsta !?i tipul de studii. 0 persoana poate sa nu aiba studii, caz in care
nu mai este necesar sa avem alte informatii, poate sa fi facut cateva clase de
!?COala generala (ne-ar putea interesa cate clase), sa fi terminat liceul (caz In
care dorim sa !?tim anul terminarii !?i ora!?ul) sau sa aiba studii superioare (!?i
atunci ne intereseaza numele facultatii si numarul de ani de studiu In cadrul
facultatii respective). in concluzie, infunctie de tipul de studii, inregistrarea
arata altfel.
Limbajul permite ca lnregistrarile sa aiba o structura variabila. Cum se realizeaza
aceasta?
in primul rand trebuie retinut ca partea variabila este plasata In cadrul

lnregistrarii dupa partea
fixa.
0 parte
variabila se dezvolta in
cadrullnregistrarii dupa valorile pe care le ia un camp situat in cadrul partii
fixe.
in programul
variabila) selec
campul STUDII.
C ampul dupa
care urmeaza (ce exemplifica descrierea unui tip de inregistrare

ia partii variabile se face In functie de valorile pe care le ia
Pentru selectare, se folose!?te o clauza speciala numita CASE.
care se face selectia apare descris in aceasta
clauza.
Campul selector trebuie sa fie de tip ordinal cu un numar finit de elemente
(tipul INTEGER nu este permis). in functie de valorile pe care le poate lua
campul selector se va dezvolta partea v riabila. in esenta, se scriu pe rand
valorile posibile ale campului selector. in dreptul fiecarei valori se trece partea
pe care trebuie sa o con ina inregistrarea in acest caz. Aceasta se incadreaza
intre paranteze rotunde !?i poate fi chiar vida. CampJrile prezente intre
paranteze rotunde se scriu separate prin ';'.
Analizati programul urmator (care cite!?te o singura inregistrare):
program rec6;
type persoana=record
nume:string[JO];
varsta:byte;
case studii:char of
If
I : ();
g 1 : (nr cl:integer);
1 11 : (an-t:integer;
oras:string);
1
s 1 : (fac:record
nume f:string[20];
an s7byte
end)1
\
end;
var p:persoana;
begin
write( 1 nume 1 ); readln(p.nume);
write( 1 varsta); readln(p.varsta);
write( 1 studii '); readln(p.studii);
case p.studii of
'g1 : begin
write( 1 numar clase 1 );
readln(p.nr_cl)
end;
1: begin
write( 1 anul terminarii liceului 1 );
readln(p.an t);
write( 1 orasul 1 );
readln(p.oras)
end;
s1 : begin
write( 1 numele facultatii 1 );
readln(p.fac.nume f);
writeln( 1 ani studii facultate 1 );
readln(p.fac.an s)
end
end {case}
end.
10!i
Observatii:
Este preferabil ca citirea unei variabile de acest tip sa se faca prin utilizarea
instruqiunii CASE.
Pentru fiecare inregistrare de acest tip compilatorul rezerva un numar de
octeti necesar inregistrarii celei mai lungi posibile.
Toate celelalte operatii cu inregistrari de un tip variabil sunt similare cu cele
prezentate pentru inregistrari de tip fix.
Cu ajutorul diagramelor de sintaxa tipul inregistrare cu variante se descrie
astfel:
TIP iNREGISTRARE
CU VARIANTE
RECORD
DESCRIERE
PARTE FIXA
IDENTIFICATOR
DESCRIERE
PARTE
VARIANTE
CONSTANTA
DESCRIERE
PARTE FIXA
DESCRIERE
PARTE
VARIANTE
Figura 5.2.2.1.
5.3. Tipul de date multime

Sa presupunem ca se cite!?te o variabila de tip char. Se cere sa se precizeze
daca a fost citita o litera mica a alfabetului. Cum am putea rezolva aceasta pro
blema?
0 posibilitate de rezolvare consta in a testa daca am citit 'a' sau 'b' sau ...
'z'. Nu credeti ca un astfel de test este cam lung? Altfel cum am putea
proceda? Sa retinem toate literele mici ale alfabetului intr-un vector de
caractere, pentru ca apoi caracterul citit sa fie comparat, pe rand, cu fiecare
componenta a vectorului. Nici aceasta solutie nu straluce!?te prin simplitate.
Limbajul Turbo Pascal ofera posibilitatea de a rezolva eficient astfel de
probleme utilizand tipul de date multime.
Evident, o variabila de un tip multime poate retine o multime de elemente. De
Ia bun inceput precizam ca multimea nu poate avea mai mult de 256 de elemente.
Oricum, este un numar suficient de mare pentru a putea rezolva cu succes o clasa
larga de probleme. Ce natura au elementele care constituie multimile?
Aceste elemente trebuie sa apartina unui tip ordinal standard (char,boolean)
123
sau unui tip definit de utilizator. Tipul ordinal caruia li apaqin elementele ce
constituie multimile nu trebuie sa cantina mai mult de 256 de caractere i se
nume te tip de baza. Ordinul elementelor ce alcatuiesc tipul de baza trebuie sa
fie cuprins intre 0 !?i 255. Tipul integer nu poate fi tip de baza dar pot fi
folosite subdomenii ale acestuia care au elemente lntre 0 i 255.
Sa analizam programul de mai jos:
program mul;
const a:set of char=( 1 a 1 1 i 1 , 1 m 1 ];
type zile=(luni,marti,miercuri,joi);
cifre=O ..9;
cifre mari=10..200;
var v1:set of char;
v2:set of zile;
v3:set of cifre;
v4:set of cifre_mari;
begin
V 1:
I 11
= ( Ia I
, , I
d1
IU I
, , I
zI
v1:=a; v2: =
(] ;
v2:=(1uni];
v3: = ( o, 1, 7 .. 9] ;
v4: = ( 9 o .. 1o o] ;
end.
Variabila v1 retine o multime de caractere. Variabila v2 retine o multime de

elemente apartinand tipului enumerare mai sus definit. Analizati singuri natura
elementelor multimilor ce pot fi retinute in variabilele v3 i v4.
Declararea tipului multime se face aa cuni arata diagrama de sintaxa de mai
jos:
TIP
TIP ORDINAL
-MULTIME
Figura 5.3.1.
Singura operatie permisa asupra variabilelor de tip multime este operatia de
atribuire in care variabila capata valoarea unei expresii de tip multime.
0 expresie de tip multime poate contine:
variabile de tip multime;
constructori de tip multime;
operatori;
constante de tip multime.
5.3.1. Constructori de tip multime

Ace!?tia definesc valori de tip multime. Orice constructor incepe prinT !?i se
termina prin ']'. Tn esenFi, intre paranteze drepte se trece valoarea multime
definita de constructor. Elementele multimii sunt date prin enumerare.
Sa analizam constructorii prezenti In programul de mai sus:

[] reprezinta muiJimea vida;
[luni] reprezinta multimea formata dintr-un singur element i anume
elementul luni;
[0,1,7..9] reprezinta multimea formata din elementele 0, 1, 7, 8 i 9.
5.3.2. Operatori
Variabilelor de tip multime li se pot aplica urmatorii operatori:
+ pentru reuniune (reuniunea a doua multimi A i B este o multime formata din
elementele multimii A Ia care se adauga elementele multimii B care nu
apartin multimii A);
* pentru intersectie (intersectia a doua multimi A i B, reprezinta multimea
formata din elementele comune celor doua multimi);
- pentru diferenta (prin diferenta dintre multimile A i B se intelege multimea
formata din elementele muiJimii A care nu sunt i elemente ale multimii 8_).
Mai avem Ia dispozitie i operatori relationali:
pentru apartenenta;
< > pentru a testa daca doua multimi sunt diferite (nu contin aceleai elemente);
<= peritru a testa daca o multime este inclusa in alta;
>= pentru a testa daca o multime include alta muiJime.
in
5.3.3. Constante
in primul program al acestui paragraf se define te o constanta de tip
multime. Aceasta se declara prin definirea tipului multime, urmat de semnul
'= ', dupa care se trece valoarea multime sub forma de constructor.
Elementele unei multimi nu pot fi scrise i nici citite In mod direct. Pentru a
putea realiza aceste operatii se recurge Ia mici artificii.
Cum citim o variabila multime?
Pentru a realiza acest lucru se procedeaza astfel:
variabila multime se initializeaza (acesteia i se atribuie multimea vida);
se cite te un element (intr-o variabila avand acelai tip ca tipul de baza al
multimii);
elementul citit este privit ca multime cu un singur element, iar aceasta
multime se reune te cu multimea care se cite te;
se cite te un alt element cu care se procedeaza Ia fel, pana cand au fost
citite toate elementele.
Pentru a realiza tiparirea, element cu element, a unei multimi se procedeaza
astfel:
se considera o variabila de acelai tip cu tipul de baza al multimii;
aceasta variablla este folosita (ca variabila de ciclare) in constructia unui
ciclu FOR care are ca valoare initiala prima valoare posibila a multimii i ca
valoare finala, ultima valoare posibila a multimii.
.
Ia fiecare pas se testeaza daca valoarea de ciclare apartine : au nu multimii
(in caz afirmativ aceasta se tipare te).
Programul care urmeaza cite!?te doua multimi A !?i B dupa care tipare!?te
reuniunea, intersectia si diferenta celor doua multimi. Elementele celor doua
muiJimi sunt numere naturale cuprinse lntre 0 !?i i55.
program mull;
type m int=set of o ..255;
var a,b,c:m int;
m,n,i,nr:integer;
begin
write(card(a)=');
readln(m);
a:=[];
for i:=l to m do
begin
write('elementul ',i, ');
readln(nr);
a:=a+[nr]
end;
writeln(multimea A');
for i:=O to 255 do
if i in a then writeln(i);
readln;
write(card(b)=');
readln(n);
b:
= [] ;
for i:=l ton do

begin
write('elementul i,' ');
readln(nr);
b:=b+[nr];
end;
writeln('multimea B');
for i:=l to 255 do
if i in b then writeln(i);
readln;
c:=a+b;
writeln ('multimea reuniune);
for i:=l to 255 do
if i inc then writeln(i);
readln;
c:=ab;
writeln('multimea intersectie');
for i:=l to 255 do
readln;
c: =a-b;
writeln('A-B');
for i:=l to 255 do
readln
end.
Observatii:
Nu orice tip de baza al unei multimi poate fi citit sau tiparit (exemplu: tipul
enumerare). Pentru cazuri in care avem de citit sau scris multimi cu ace.ste
tipuri de baza se recurge Ia urmatoarele artificii:
Citirea. Se cite!?te, de exemplu, o variabila de tip string !?i in functie de
valoarea citita se reune!?te multimea care trebuie citita cu elementul
corespunzator cuvantului citit.
Scrierea. Se tipare!?te un cuvant corespunzator elementului care trebuie tiparit.
De Ia matematica, stim ca o multime are elemente distincte. Orice variabila
de tip multime va avea numai elemente distincte. De fapt, nici nu poa::e fi
altfel. 0 multime se construie!?te utilizand numai operatii cu multimi care au
ca rezultat multimi. Sa presupunem ca atunci cand se ruleaza programul
MUL1, Ia citirea mul"timii A se introduce de doua ori elementul 2. La fiecare
introducere, multimea A este reunita cu acel element, deci se va reuni multi
mea A de doua ori cu elementul 2. Rezulta ca multimea nu va contine decat
o singura data elementul 2 (In caz contrar nu se efectueaza corect operatia
de reuniune). Acest fapt nu este lipsit de importanta. Sa presupunem ca
dorim sa !?tim cate litere distincte are un cuvant. Este suficient sa construim
multimea literelor lui. Cum o litera nu poate figura de doua ori intr-o multime
de litere, numarul de elemente al multimii va fi egal cu numarul de litere
distincte ale cuvantului.
5.3.4. Constante de tip multime

in primul program propus in acest paragraf am definit o constanta de tip
multime. Declararea unei constante se face prin declararea tipului ei, urmat de
semnul egal, dupa care se scrie constructorul multime.
De!?i tipul multime este folosit rar In scrierea programelor, sunt cazuri cand
este de maxim folos. De exemplu, daca dorim sa !?tim daca o variabila de tip
string contine numai litere (test alfabetic), se verifica apartenenta fiecarui
caracter Ia multimea literelor. Ganditi-va cum ar arata un program C!are face un
astfel de test tara a utiliza tipul multime.
Programul MUL2 numara vocalele dintr-un text citit.
program mul2;
const v:set of char=['a','e','i','o','u','A','E','I','O','U'];
var a:string;
i,s:integer;
begin
write(' Dati textul ');
readln(a);
s:=o;
for i:=l to length(a) do
if a[i] in v then s:=s+l;
writeln('avem ,s, vocale' );
end.
5.4. Aplicatii Ia capitolul 5

Aplicatii asupra tipurilor de date structurate
5.4.1. Tipul ARRAY
1. Sa se citeasca 9i sa se tipareasca un vector cu componente de tip CHAR.
2. Sa se citeasca 9i sa se tipareasca o matrice cu componente de tip REAL.
3. Se cite!?te un numar natural N. Sa facem conversia acestui numar in baza
2. Cifrele de 1 sau 0 se vor retine intr-un vector. Sa se tipareasca vectorul
(atentie, nu se vor tipari cifrele zero nesemnificative).
4. Aceea!?i problema ca precedenta pentru conversia in baza 16.
5. Se cite!?te un numar intreg N (atentie, poate fi !?i negativ). Sa se
converteasca in cod complementar pe 16 pozitii binare. Cifrele de 1 sau 0 se
vor retine intr-un vector. Sa se tipareasca rezultatul.
6. Se cite!?te un numar natural N (citirea se va face Tntr-o variabila de tip
INTEGER). Sa se scrie acest numar Tntr-un vector.
Exemplu: Citim 1231. Vom avea V[1] = 1, V[2] = 2, V[3] = 3, V[4) = 1.
7. Se cite!?te un vector 'Cu n componente numere naturale. Sa se tipareasca

eel mai mare divizor comun al celor n numere.
8. Se cite!?te un vector cu componente numere naturale. Sa se tipareasca
numarul cifrelor de 0 cu care se termina numarul format din produsul celor n
componente.
9. Sa se calculeze 2 Ia puterea 100;

10.Un numar natural se retine intr-un vector astfel inc at fiecare componenta
a vectorului contine o citra a numarului. Exemplu: daca vectorul V are 5
componente iar numarul este 128, V[1]=0, V[2)=0, V[3]=1, V[4]=2,
V[5] = 8. Sa se Tnmulteasca numarul cu un alt numar natural format dintr-o
singura citra.
11. Aceea!?i problema ca precedenta, insa deinmultitul are mai multe cifre
!?i este reprezentat Tntr-un vector. 12. Se citesc intr-un vector n numere naturale: a 1, a2, ..., an. Sa se
calculeze:
S 1 =a 1 + a2 + ... +an;
52= a 1 *a2 + ... +a 1 *an+ a2 *a3 + ... + a2 *an+ ... + an-1 *an
Sn=a1 *a2* ...*an.
13. Se cite!?te un vector cu n componente numere naturale distincte.
Acestea alcatuiesc o multime de numere naturale. Se cere sa se tipareasca
toate submultimile acestei multimi.

14. Se citesc doi vectori cu componente numere naturale. Fiecare vector are
elementele sortate crescator. Se cere sa se construiasca un al treilea vector
care contine componentele celor doi In ordine crescatoare. Aceasta este
problema interclasarii !?i are o mare importanta practica.
15. Se considera un vector cu componente numere naturale distincte i
sortate crescator. Se cite!?te un numar natural M. Se cere sa se precizeze daca
numarul citit se gase te sau nu lntre componentele vectorului considerat, iar
In caz afirmativ sa se tipareasca indicele componentei care 11 contine (cautare
binara).
16. Se considera F un polinom de gradul n, unde cei n + 1 coeficienti sunt
retinuti lntr-un vector. Se cite te o valoare reala a. Sa se tipareasca F(a).
17. Se dau doua polinoame ai caror coeficienti sunt retinuti In doi vectori.
Sa se calculeze coeficientii produsului celor doua polinoame.
18. Se considera un vector care contine n numere naturale. Sa se tipareasca
o submultime a acestora a carei suma se divide cu n.
19. Tipariti suma elementelor aflate deasupra diagonalei principale a unei
matrice patratice.
20. Tipariti suma elementelor aflate sub diagonala principala a unei matrice
patratice.
21. Tipariti suma elementelor aflate sub diagonala secundara a unei matrice
patratice.
22. lnterschimbati coloanele unei matrice cu m linii i n coloane astfel lncat

in linia k elementele sa fie in ordine strict crescatoare.
23. lnterschimbati linii !?i coloane ale unei matrice cu n linii !?i n coloane
astfel incat elementele de pe diagonala principala sa fie sortate crescator.
24. Determinati elementele !?a ale unei matrice cu n linii !?i m coloane
(elemente minime pe linie !?i maxime pe coloana sau maxime pe linie !?i minime
pe coloana).
25.Tipariti sumele elementelor aflate pe patrate concentrice ale unei matrice
patratice.
/ndicatii:
8. Nu putem efectua produsul celor n numere pentru ca, apoi, sa vedem cu
cate cifre de 0 se termina, pentru ca lntr-un astfel de caz numarul obtinut poate
fi foarte mare (nu poate fi retinut lntr-o variabila de tip integer sau longint).
Solutia este urmatoarea:
se determina k 1, exponentul maxim al cifrei 2 astfel Inc at 2 Ia puterea k
1 divide pe V[1];
se determina kn, exponentul maxim al cifrei 2, astfel lncat 2 Ia puterea kn

divide V[n];
se calculeaza a= k 1 + k2 + ... + kn (am determinat puterea maxima a lui
doi
astfellncat 2 Ia puterea a divide produsul considerat);

se determina p1, exponentul maximal cifrei 5, astfel incat 5 Ia puterea kn
divide pe v[1];
se determina pn, exponentul maximal cifrei 5, astfel incat 5 Ia puterea pn
divide V[n];
se calculeaza b = p1 + p2 + ... + pn puterea maxima a lui 5 astfel incat 5
Ia puterea b divide produsul considerat.
Numarul de cifre 0 cu care se termina produsul va fi minimul intre a !?i b (de ce ?)
.
9. Daca am calcula produsul pe cai clasice, numarul oblinut este atat de

mare !neat nu se poate reprezenta in memorie nici chiar prin utilzarea tipului
longint. Pentru aceasta, suntem nevoili sa simulam inmultirea cu 2 retinand
cifrele numarului intr-un vector.
Astfel, se porne te de Ia un vector ale carui componente au valorile:
0 0 0 0 0... 0 0 0 1 (numarul 1);
se inmulte:;;te fiecare componenta a vectorului cu 2:
0 0 0 0 0... 0 0 0 2;
se inmulte!?te fiecare componenta cu 2
0 0 0 0 0... 0 0 0 4
0 0 0 0 0... 0 0 0 8
0 0 0 0 0... 0 0 0 16;
dupa fiecare inmultire cu 2 se parcurge vectorul in sens invers !?i pentru
fiecare componenta (n) cu un continut mai mare decat 9 se scade 10 !?i se
aduna 1 Ia componenta n-1:
0 0 0 0 0... 0 0 0 1 6
se va obtine In continuare:
0 0 0 0 0... 0 0 0 2 12
0 0 0 0 0... 0 0 0 3 2
0 0 0 0 0... 0 0 0 6 4
Estimati numarul de cifre pe care il va avea numarul 2 Ia puterea 100 astfel
incat sa retinem tipul vector cu atatea componente cate sunt necesare.
12. Sumele considerate sunt coeficienlii polinomului:
P= (x + a 1)(x + a 2 ) ...(x +an).
Astfel:
(x+a 1)(x+a2 )=x2 +(a 1 +a2 )x+a 1a 2
(x + a 1)(x + a 2 )(x + a3) = x3 + (a 1 + a 2 3)x2 + (a1a 2 + a 1a 3+ a2 a3)x + a1a 2 a 3
+a
(x + a 1)(x + a 2 )(x + a 3) ... (x+ an)=
=Xn + ( a 1 + ... +an)x;n-1 + ( a 1a 2 + ... +an_ 1an) xn-2 + ... +a 1a 2 ...an
x + a 1 este un polinom ai carui coeficienli se retin intr-un vector In felul
urmator: 0 0 0 0 0 0...1 a1;
se scrie o secventa care inmulte!?te un polinom cu x +a;
ceasta secventa se folose te de n-1 ori (pentru a= a2 , a= a 3, ...,a =an.
In final, se tiparesc coeficientii lui x Ia puterea n-1 (S 1), x Ia puterea n-2
(S2), x Ia puterea 0 (Sn).
13. Exista mai multi algoritmi care rezolva problema considerata. Aici, vom
studia unul de o mare simplitate.
Fie vectorul considerat:
a1 a2 a3 a4 ... an.
Acestuia i se ata!?eaza un vector ale carui componente pot lua numai valori 0
sau 1 (pentru inceput 0). Un astfel de vector se nume!?te vector caracteristic.
Astfel avem:
0 0 0 0 ... 0.
Pentru ca acest vector sa reprezinte o submultime, facem urmatoarea
conventie: elementul continut in componenta k a primului vector apartine sau
nu submultimii considerate dupa cum componenta k a vectorului caracteristic
are valoarea 1 sau 0. Astfel, a genera toate submultimile multimii considerate
se reduce Ia generarea in cadrul vectorului caracteristic a tuturor combinatiilor
posibile de 0 sau 1. Cum rezolvam aceasta ultima problema? Simplu,
consideram ca vectorul caracteristic retine un numar in baza 2 (initial 0,
corespunzator submuJtimii vide). La fiecare pas se aduna 1 acestui numar (se
simuleaza adunarea cu 1 a numarului continut in vectorul caracteristic) !?i se
tipare!?te submultimea obtinuta (se tiparesc acele componente ale primului
vector carora le corespunde 1 Tn cadrul vectorului caracteristic). Astfel avem:
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
............ 0 (submultimea vida);

............ 1 {an};
...... 0 1 0 {an-1 };
...... 0 1 1 {an-1,an};
... 0 1 0 0 {an-2};
... 0 1 0 1 {an-2,an};
1 1 1 1 1 1 ... 1 1 1 1 {a 1,a2,...an}.
Daca tinem seama de faptul ca eel mai mare numar care se poate scrie in baza
2 prin utilizarea a n componente care retin 0 sau 1 este doi Ia puterea n-1,
regasim faptul ca o multime cu n elemente are doi Ia puterea n submultimi
(inclusiv cea vida), rezultat bine cunoscut de Ia matematica.
14. lnterclasare. Sa presupunem ca se citesc 2 vectori A !?i B, primul cu m
componente, al doilea cu n componente. Cei doi vectori se introduc deja
sortati. 0 prima posibilitate de lucru r fi sa-i trecem pe amandoi in cadrul
vectorului C, pe care apoi sa-l sortain. In acest fel nu beneficiem in nici un fel
de faptul ca cei doi vectori sunt deja sortati (se consuma mult timp inutil).
Prezentarea algoritmului se va face pe un exemplu:
A 1 3 4 58 (m = 5);
8 24567910(n=7);
Variabila i va retine indicele componentei Ia care s-a ajuns in vectorul A.
Variabila j retine indicele Ia care s-a ajuns in parcurgerea vectorului B. Variabila
k retine indicele elementului care urmeaza a fi scris in cadrul vectorului C.
Initial avem i = 1, j = 1, k = 1.
Se compara A[1] cu 8[1]. Este mai mic A[1], deci C[1] va fi 1, iva fi 2,
k=2.
Se compara A[2] cu 8[1]. Este mai mic 8[1], deci C[2]=2, k=3, j=2.
Se compara A[2] cu 8[2], este mai mic A[2], C[3] = 3, k = 4, i =
3.
Procedeul se repeta atat timp cat !?i i este mai mic sau egal cu m !?i j este mai
mic sau egal cu n. Este clar ca, Ia un moment dat, unul din vectori a fost
analizat complet (componentele sale au fost trecute in vectorul
C).
Compon.entele ramase din celalalt vector se copiaza !?i ele in vectorul C.
p ogram interclas;
type vector=array[1..100]
var a,b,c:vector;
i,j 1k1m 1n:integer;
of integer;
begin
1
write( 1
m=
);
readln(m); write( 1 n= 1 );
readln(n); for i:=1 tom
do
begin
Write (I a [I 1 i1 I ] :I) j
readln(a[i]);
end;
for j:=l ton do
begin
Write (I b [I I jI I:I) j
readln(b[j])
end;
i:=1; j:=1; k:=1;
while(i<=m) and (j<=n) do
begin
if a[i]<b[j] then
begin
c [k] :=a (i] ;
i:=i+1
end
else
begin
c [k] : =b [j] ;
j:=j+1
end;
k:=k+1
end;
if i<=m then
for j:=i tom do
begin
c [k] : =a [j1 ;
k:=k+l
end
else
for i:=j to n do
begin
c[k]:=b[i];
k:=k+1
end;
fori :=1 to k-1 do writeln(c[i]);
end.
15. Cautare binara. Tn cazulln care vectorul nu era sortat, valoarea m ar fi

fost cautata prin compara!ie cu continutul celorlalte componente, incepand cu
prima, pana cand era gasita (caz in care se tiparea indicele), sau pana cand am
fi parcurs in lntregime vectorul fara sa o gasim. Faptul ca vectorul este deja
sortat ne ajuta sa rezolvam problema mai rapid. Care este principiul de cautare?
in esenta, acesta consta in urmatoarele:
avem doua limite in care facem cautarea: limita inferioara (li) !?i limita
superioara (Is);
initial li = 1 !?i Is=
n;
se compara valoarea lui m cu valoarea componentei din mijloc (mai corect,
de indice (li +Is) DIV 2) !?i apar trei posibilitati:
o egalitate, caz in care se tipare!?te indicele !?i algoritmul se termina;
o componenta din mijloc este mai mica decat valoarea cautata (aceasta
inseamna ca avem !?anse sa gasim valoarea cautata de Ia componenta cu
indicele imediat superior componentei care a fost comparata !?i cea de
indice Is), caz in care li va lua ca valoare indicele componentei care a fost
comparadi, Ia care se aduna 1, iar limita superioara ramane nemodificata;
o componenta din mijloc este mai mare decat valoarea cautata !?i, din
motive asemanatoare celor expuse anterior, limita superioara devine
in<Jicele componentei care a fost comparata, din care se scade 1, iar limita
interioara ramane nemodificata;
in ultimele doua cazuri algoritmul se reia pana cand limita inferioara
devine mai mare decat limita superioara, sau pana cand componenta a
fost gasita.
Observatie. Dupa efectuarea unei comparatii, numarul valorilor in care

cautam se reduce Ia jumatate. Ca!?tigul de timp este foarte mare. Sa ne
imaginam ca avem 1000 de componente. Cu eel mult 10 comparatii am
rezolvat problema (2 Ia puterea 10 este 1024), altfel ar fi trebuit efectuate (in
cazul eel mai nefavorabil) 1 000 de comparatii.
program cbin;
type vector=array[1..100] of integer;
var v:vector;
li,ls,lm,i,n,m:integer;
gasit:boolean;
f
begin
write( 1 n:1 ); readln(n);
for i:=1 to n do
begin
Write (IV [I 1 i 1 I ] :I) j
readln(v[i])
'end;
1
);
write( 1
m=
readln(m);
li:=1;
ls:=n;
gasit:=false;
while (li<=ls) and not gasit do
begin
lm:=(li+ls) div 2;
if v[1m]<m
end.
end
then li:=lin+l
else if v[1m]=m
then
begin
writeln(1m);
gasit:=true
end
else ls:=lm-1
16. Problema nu este dificila. Totul este de a nu calcula Ia fiecare pas a Ia

puterea k =a*a*a* ...*a (de k ori). Nu uitati ca Ia pasul anterior am calculat a
Ia puterea k-1.
program polinom;
type coef=array[O..20] of real;
var c:coef;
n i:integer;
a,flp:real;
1
begin
write (1 n= 1 ); readln(n);
for i:=O to n
do begin 1
write(1 a , i, 1 .. 1 ) ;
readln(c[i])
end;
p: 1;
write( 1 a= 1 ); readln(a);
f: =c [n] ;
for i:=n-1 downto o do
begin
p:=pa;
f:=f+c[i]p
end;
Writeln(If(I a:3:21
f:3:2)
I)I:
end.
1
18. Oricat ar parea de curios, exista intotdeauna o secventa de numere

consecutive a caror suma se divide Ia n. Sa demonstram acest fapt. Calculam
sumele: S1=a1;
S2=a1 +a2;
Sn=a1 +a2+ ... +an.
Daca suma Sk se divide cu n problema este rezolvata (se tiparesc a 1, a2,
...,ak). Sa presupunem ca nici o suma nu se divide cu n. $tim de Ia matematica
faptul ca restul impartirii Ia n poate fi {0,1,...,n-1 }. Cazul restului 0 a fost
!ratat anterior. Rezulta ca n:.J putem avea decat un rest cuprins intre 1 !?i r,-1.
lntrucat avem n sume !?i n-1 posibilitati de rest, rezulta ca exista doua sume
care dau acelai rest Ia impartirea Ia n. Fie acestea Si !?i Sj (i <j).
Si =a 1 + a2 + ... + ai;
Sj =a 1 + a2 + ... + ai + (ai + 1) + ... +
aj; Sj-Si = (ai+ 1) + ... + aj.
Se tiparesc ai + 1, ai+ 2,...,aj (diferenta a doua numere care dau acela!?i
rest prin impartirea cu n se divide Ian). Utilizand cele prezentate, scrieti un
program corespunzato .
19-21. Pentru identificarea elementelor care intra in calculul sumei nu trebuie
parcursa in intregime matricea. Gasiti o relatie, intre indicii acestor elemente,
care sa permita o identificare directa a lor.
23. Sortarea se realizeaza prir compara ia !?i eventual inversarea elementelor

de forma A[i,i] !?i A[i + 1 ,i+ 1 ]. Daca este cazul, inversarea se realizeaza
prin interschimbarea liniilor i !?i i + 1 !?i interschimbarea coloanelor i !?i i + 1.
24. Atentie! Maximele sau minimele pe linii sau coloane pot sa nu fie unice.
Daca vom considera numai o valoare dintre acestea, s-ar putea sa pierdem
solutii.
5.4.2. Tipul STRING

1. Scriei o secvena care preia de Ia tastatura o variabila numerica, In felul
urmator:
se cite!?te o variabila de tip STRING;
continutul acesteia se converte!?te intr-o variabila de tip real;
In cazul in care conversia nu reu!?e!?te (de exemplu am introdus o litera),
procedeul se reia.
2. Se cite!?te lntr-o variabila de tip string un text. Cuvintele se considera

separate prin virgula, spatiu sau punct. Cate cuvinte are textul citit?
3. Se cite!?te intr-o variabila de tip string un text !?i in alta o succesiune de
caractere. De cate ori intalnim aceasta succesiune in cadrul textului?
4. Se citesc n cuvinte !?i se cere ca acestea sa fie sortate alfabetic.
5. Se cite!?te intr-o variabila de tip string un text. Doua cuvinte pot fi
separate printr-unul sau mai multe spa ii. Se cere sa se elimine spatiile inutile.
5.4.3. Tipul RECORD

1. Cititi o variabila de tip inregistrare care are urmatoarea structura:
nume elev: string[30]
data na!?terii :record
zi
:string[2];
luna :string[2];
an :string[4];
nota matematica, nota informatica, media celor doua note: real (media se
calculeaza, nu se cite!?te).
Testai daca datele au fost introduse corect. Citirea se va verifica prin tiparirea
rezultatului. Programul va utiliza instruqiunea (mai corect, directiva de compila
re) WITH.
2. Citii n inregistrari de
alfabetica.
tipul
celei de mai sus !?i afi!?ati-le in ordinea
3. Aceea!?i problema numai ca afi!?area se va face in ordinea descrescatoare

a mediilor.
4. Presupunand ca inregistrarile se refera Ia un examen de admitere, sa se
tipareasca in ordinea descrescatoare a mediilor in limita unui numar de locuri
sau pana cand se epuizeaza toate inregistrarile elevilor cu medii mai mari sau
egale cu 5. In cazul in care pe ultimul loc avem mai muli elevi cu aceea!?i
medie, toti ace!?tia sunt considerati admi!?i. Programul va afi!?a numarul de
locuri necesare in plus.
5. Un serviciu de evidenta a populatiei retine pentru fiecare persoana
urmatoarele:
nume: string[30];
varsta: byte;
apartenenta politic a ( 1 daca persoana este inscrisa intr-un partid, 0 In caz
contrar). in ituatia apartenentei persoanei Ia un partid politic se retine !?i
numele partidului (string [20]).
Scrieti un program care sa citeasca informatii despre n astfel de persoan !?i sa
tipareasca structura persoanelor pe optiuni politice.
5.4.4. Tipul multime

1. se cite!?te numele unei persoane intr-o variabila de tip string. Se cere sa
se testeze natura alfabetica a acestuia (sa nu contina cifre).
2. Se citesc n multimi de numere naturale mai mici sau egale cu 255. Se
cere sa se tipareasca daca aceste mul imi sunt disjuncte sau nu. (Doua multimi
sunt disjuncte daca nu au elemente comune.)
3. Problema partitiei. Se considera o multime finita A. Multimile A 1,
A2,...,Am alcatuiesc o partitie a multimii A daca indeplinesc simultan trei
conditii:
toate multimile sunt incluse in A;
sunt disjuncte (oricum am intersecta doua dintre ele, intersectia este vida);
reuniunea tuturor acestor multimi este mul imea A.
Se citesc m, cele m multimi A 1, A2,...,Am (de numere lntre 0 !?i 255) !?i o
mul ime A. Se cere sa se raspunda Ia intrebarea daca multimile citite
alcatuiesc sau nu o partitie a multimii A.
4. Partitia determinatii de o relatie de echivalentii. Se considera o multime
A. 0 relatie oarecare R intre elementele acestei multimi este o relatie de
echivalenta daca respecta urmatoarele trei conditii:
oricare ;;tr fi x apartinand mul imii A, x R x (x este echivalent cu x),
proprietate numita reflexivitate;
oricare ar fi x !?i y apartinand multimii A, din x R y rezulta y R x, proprietate
numita simetrie;
oricare ar fi x, y, z, apartinand multimii A, din x R y !?i y R z, rezulta x R z,
proprietate numita tranzitivitate.
Exemp/u. in multimea _triunghiurilor consideram relatia de asemanare.
Aceasta este o relatie de echivalenta deoarece:
orice triunghi este asemenea cu el ;
daca un triunghi este asemenea cu un al doilea, atunci !?i acesta este
asemenea cu el;
daca un triunghi este asemenea cu un altul !?i acesta este asemenea cu un
al treilea, atunci primul triunghi este asemenea cu al treilea.
Observatie. Nu toate relatiile intre elementele unei multimi sunt relatii de

echivalenta. Exemplu: in multimea numerelor naturale relatia de divizibilitate nu
este simetrica (a divide b nu implica b divide a).
0 relatie de echivalenta determina o partitie a unei multimi (fiecare
subniultime a partitiei contine elementele echivalente intre ele). Cum orice
element este eel putin echivalent cu el insu!?i rezulta ca acesta apartine unei
multimi a partitiei. Daca doua submultimi ar avea eel putin un element comun
rezulta ca toate elementele din prima submultime !?i toate elementele din cea
de-a doua submultime sunt echivalente intre ele (tranzitivitatea prin utilizarea
elementului comun), deci cele doua multimi coincid.
Se cite!?te o multime de numere intre 0 !?i 255 prin citirea a n perechi (x y)

de numere de acest tip. Printr-o astfel de pereche se intelege ca x este
echivalent cu y. Se cere sa se determine partitia generata de relatia de
echivalenta considerata pe multime.
Exemplu:
citim
1 2
45
23
67
7 1
Se obtine partitia: {1, 2, 3, 6, 7} {4, 5} a multimii {1, 2,...,7}.
Vom prezenta un algoritm neperformant din punct de vedere al timpului de
calcul, insa accesibil in acest moment. in ce consta acest algoritm?
Toate elementele multimii considerate sunt citite sub forma (x,y). Printr-o
astfel de relatie se intelege ca x este echivalent cu y. Numarul de perechi care
se citesc este cunoscut de Ia inceput (n). 0 variabila (m) retine multimile care
se formeaza (este un vector de multimi). 0 alta variabila (nr m) retine indicele
maximal multimilor create (initial a;e valoarea 0). La citirea-unei perechi (x,y)
se ajunge intr-una din cele trei situatii care vor fi analizate in continuare.
Nici x, ci y nu apartin unei muliimi a partitiei. in acest caz se creeaza o
noua multime care va include cele doua elemente considerate (nr m cre!?te
cu o unitate).
Numai x sau numai y se gase!?te intr-una din multimile partitiei. in acest caz,
celalalt element este adaugat acelei multimi (de fapt multimea in care a fost
gasit un element se reune te cu multimea formata din cele doua elemef\te
!?i dupa regulile incluziunii elementul deja continut nu se mi adauga).
Elementul x se gase!?te intr-o multime !?i elementul yin alta. In acest caz cele
doua multimi se reunesc in cadrul multimii care are eel mai mic indice in vector.
in cazul in care cealalta rnultime era cu indicele eel mai mare nr m scade cu o
unitate, in caz contrar acea ta multime capata ca valoare multimea vida.
Pentru a testa apartenenta elementelor x !?i y multimilor considerate, se folosesc doua variabile GASIT !?i INDICE M. De cate ori este gasit un element in
tr-o multime, continutul variabilei GASIT cre!?te cu o unitate. in final, aceasta
poate avea trei valori: 0, 1 sau 2. Variabila INDICE M (vector cu componente
!ie tip byte) retine de fiecare data indicele multimiiincare se gase!?te x sau y.
In cazul in care GASIT are valoarea 0 continutul variabilei INDICE_M nu
intereseaza, daca GASIT are valoarea 1 intereseaza numai continutul primei
componente a variablei INDICE_M, iar daca GASIT are vaharea 2 ambele
componente prezinta interes (retin indicii celor doua mult mi).

La sfar!?it listam multimile partitiei obtinute.
program echiv;
type multime=set of byte;
vector multimi=array[1..SO] of multime;
var n,i,j,x,y,nr m:byte;
gasit:o.. 2; m:vector multimi;
indice_m7array[1..2] of byte;
begin
write(n=); readln(n);
nr m:=0;
for i:=1 ton do
begin
write('(x,y)=); readln(x,y);
gasit:=o;
for j:=1 to nr m do
if (x in m[jJ) or (yin m[j]) then
begin
gasit:=gasit+1;
indice m[gasit]:=j;
end;
case gasit of
0: begin
nr m:=nr m+1;
m (iir mJ :-;[x, y] ;
end; 1: m[indice m[1]]:=m[indice m[1]]+[x,y];

2: begin
m[indice m[1]]:=m[indice m[1]]+m(indice m(2]];
if indice m[2]=nr m thenr m:=nr m-1
- else m[Indice=m(2]]:=[]
end;
end {case}
end;
writeln (' Partitia obtinuta '); writeln;
for i:=1 to nr m do
if m[i]<>(] then
begin
writeln ('multime ');
for j:=O to 255 do
if j in m[i] then write (j, ');
writeln
end;
end.
Capitolul 6
Subprograme
6.1. Conceptul de subprogram
Blocul este unitatea de baza a oricarui program Pascal. El este format din
doua par!i:
o parte de declara!ii (constante, tipuri, variabile, proceduri !?i functii), optionala;
o instructiune compusa, obligatorie.
Din cele spuse rezulta ca orice program Pascal este un bloc.

in practica programarii, apar urmatoarele situatii care necesita o rezolvare:
o anumita secventa dintr-un program se repeta;
exista multe programe care au nevoie de un anumit calcul (fie el oricat de
complex).
Apare ideea ca acea se venta (calculul) sa fie scrisa o data !?i sa fie folosita
de cate ori este necesar. In acest mod, am ajuns Ia notiunea de subprogram.
Subprogramul reprezinta o pa'rte dintr-un program, identificabila prin nume,

care se poate lansa In executie ori de cate ori este cazul.
Exemplu: Multe programe (din domeniile cele mai diverse), pentru a putea
ajunge Ia rezultat, trebuie sa rezolve un sistem de ecua ii liniare. in acest caz,
se va scrie un subprogram care rezolva un astfel de sistem.
Care trebuie sa fie structura unui astfel de subprogram?

Pentru a raspunde Ia aceasta lntrebare, trebuie sa ne gandim ce trebuie sa
contina el. in primul rand, este necesara o secventa de calcui propriu-zis (care
poate fi efectuata lntr-o instructiune compusa).
Pentru a fi general, subprogramul nostru trebuie sa lucreze cu variabile
proprii !?i pentru acestea trebuie declarat tipul. Este posibil ca !?i acest
subprogram sa necesite Ia randul lui alte subprograme !?i acestea sa fie
declarate Ia randul lor.
Pe scurt, un subprogram trebuie sa fie Ia randul lui un bloc.
in Pascal, subprogramele sunt de doua tipuri: proceduri !?i functii.
6.2. Domeniul de vizibilitate al identificatorilor

in paragraful anterior s-a aratat ca un program (care este un bloc) poate
apela unul sau mai multe subprograme care Ia randul lor sunt blocuri. Orice
subprogram poate utiliza alte subprograme !?.a.m.d. in practica, aceste
descompuneri sunt de o mare diversitate.

Sa presupunem ca Ia nivelul unui bloc am declarat o variabila.
Exemplu a: integer. Se pune urmatoarea intrebare: in care din blocurile intregului
program este recunoscuta variabila a ? Prin faptul ca ea este recunoscuta,
intelegem ca ne putem referi Ia ea (de exemplu, sa efectuam atribuirea a:= a+ 1)
tara sa apara mesajul de identificator necunoscut. Raspunsul.la aceasta intrebare
este urmatorul: variabila este recunoscuta in blocul in care am declarat-o si in
toate blocurile care au fost definite in acesta. intr-un bloc care include blocul in
care am declarat aceasta variabila, ea nu este recunoscuta. Pentru blocul Tn care
am definit-o, variabila este locala, pentru blocurile care au fost declarate in acesta,
variabila este globala, iar pentru blocurile care includ blocul in care a fost
declarata ea este necunoscuta. 0 exceptie de Ia acest principiu apare atunci cand
redeclaram o variabila. Cintelegem prin asta? La nivelul unui bloc am declarat
variabila a de tip intreg. lntr-un bloc subordonat acestuia (declarat in cadrul lui)
declar din nou variabila a ca fiind de tip real. Daca in acest bloc actionez asupra
acestei variabile, ea este vazuta ca una de tip real. Pentru a explica acest meca
nism, am prezentat domeniul de vizibilitate al unei variabile. in realitate, mecanis
mul este acelal?i !?i pentru identificatorii de constante, tipuri, proceduri !?i funqii.
in concluzie, retinem urmatoarele: domeniul de vizibilitate al unui identifica

tor este blocul in care acesta a fost definit !?i toate blocurile definite in cadrul
ac stuia, exceptie facand cazul unei redefiniri.
In paragraful urmator vor fi date multe exemple in acest sens.
6.3. Proceduri
6.3.1. Declarare i apel
Procedura este un subprogram care se caracterizeaza prin faptul ca
rezultatele prelucrarii (exceptie facand operatiile de ie!?ire) se gasesc depuse
exclusiv in anumite variabile.
Unii autori diferentiaza procedura de functie, prin aceea ca procedura poate
returna mai multe rezultate.
DeclaratiaAprocedurii (procedurilor) se face in blocul apelant dupa declaratia
variabilelor. In acest paragraf vom considera numai proceduri fara parametri.
ln acest caz, o declaratie consta in a scrie cuvantul cheie PROCEDURE u'rmat
de numele procedurii.
Cu exceptia declaratiei, structura unei proceduri este aceea!?i cu structura
unui program, deci aceea de bloc.
Apelul unei proceduri se face prin numele ei. Atunci cand in blocul apelant
a fost intalnit un astfel de apel (se mai nume!?te !?i instructiune de apel), se
intrerupe secventa .Tn curs, se preda controlul procedurii !?i dupa executla
acesteia se revine Ia instructiunea imediat urmatoare celei de apel. In
continuare, se prezinta cateva exemple de apel proceduri, exemple de un

interes exclusiv didactic.
Exemp/ul 1
program prl;
var a,b,c:integer;
procedure suma;
begin
c:=a+b
end;
begin
write(1 a= 1 );
readln{a);
write( 1 b= 1 );
readln(b);
swna;
write( 1 C= 1 ,c)
end.
Programul pr1 cite!?te doua numere a i b !?i calculeaza suma lor. Calculul
sumei se face in procedura 'suma'.
Programul ruleaza astfel:
se citesc variabilele a !?i b;
se preda controlul procedurii care atribuie variabilei c suma dintre a !;>i b;
se revine in programul apelant, unde se tipare!?te valoarea variabilei c.
Din studiul acestui exemplu mai observam ca:
variabilele a, b,c sunt variabile ale blocului apelant;
ele sunt recunoscute in procedura (dadi am fi declarat o variabila in
procedura, ea nu ar fi fost recunoscuta in programul apelant).
Exemp/u/2
program pr2;
var a,b,c,d:integer;
procedure adun;
begin
d:=a+b
end;
procedure scad;
begin
d:=d-e
end;
begin
write(1 a= 1 ) ;
readln(a);
write( 1 b= 1 );
readln(b);
write( 1 c=);
readln(c);
adun;
scad;
writeln{1 d=
end.
d)
in acest exemplu programul calculeaza expresia a+ b-e, prin apelui a

doua proceduri 'adun' !?i 'scad'. Observam ca:
procedurile au fost declarate una dupa alta;
variabilele globale ale programului sunt recunoscute de ambele proceduri.
Exemplul 3
program pr3;
var a:integer;
procedure ad;
var b:integer;
begin
write{ 1 b= 1
);
readln{b);
a:=a+b
end;
begin
write{1 a= 1 ) ;
readln{a);
ad;
write{ 1 a= 1 ,a)
end.
Acest program calculeaza suma a doua numere a !?i b. Rularea sa decurge

in felul urmator:
in programul principal, se cite!?te variabila a;
se preda controlul procedurii 'ad' care efectueaza urmatoarele:
o cite!?te variabila b;
o face suma dintre a !?i b !?i atribuie rezultatul variabilei a;
e revine in blocul apelant unde se tipare!?te a.
In acest exemplu observam urmatoarele:
in cadrul procedurii am declarat variabila b (locala procedurii dar necunoscuta
blocului apelant);
in cadrul procedurii sunt recunoscute ambele variabile.
Exemp/u/4
program pr4;
var a:integer;
procedure ad;
var b:integer;
procedure sd;
var c:integer;
begin
write{ 1 C= 1 );
readln(c);
b: =be end;
begin
write( 1 b= 1 );
readln(b);
sd;
a: =a+b
end;
begin
write( 1 a= 1 );
readln(a);
ad;
writeln(1 a= 1 I a)
end.
Programul prezentat calculeaza expresia a+ b-e. Pentru aceasta, programul

principal apeleaza o procedura declarata In cadrul lui, iar aceasta Ia randul ei
apeleaza o alta procedura pe care o contine.
Rularea decurge in felul urmator:
se citel?te a;
se preda controlul procedurii 'ad';
o aceasta II cite!?te pe b !?i preda controlul procedurii 'sd';
aceasta il cite!?te pe c, calculeaza b-e !?i atribuie rezultatul variabilei b;
o se revine in procedura 'ad' care calculeaza a+ b !?i atribuie aceasta
valoare variabilei a;
se revine in programul principal, care tipare!?te continutul variabilei a.
Exemplul 5
program prS;
var a:integer;
procedure pl;
procedure p2;
begin
a:
=a+l
end;
begin
a:=a+l;
p2
end;
begin
write( 1 a= 1 );
readln(a);
pl;
writeln(1 a= 1 a)
I
145
in acest exemplu se cite!?te o variabila !?i se aduna cu 2.

Rularea decurge astfel:
se cite!?te variabila a !?i se apeleaza procedura 'p 1 ';
aceasta aduna 1 Ia variabila a !?i apeleaza procedura p2 (pe care o contine);
procedura p2 aduna 1 Ia variabila a;
se revine in p1;
se revine in programul principal care tipare!?te continutul variabilei a.
Este interesant de observat faptul ca variabila a este recunoscuta in 'p2' chiar
daca nu a fost definita in blocul in care s-a facut declaratia acestei proceduri.
Exemplu/ 6
in acest exemplu se demonstreaza cum se redefine!?te o variabila. Valoarea
tiparita de program va fi 0. Variabila a este declarata de doua ori: in programul
principal !?i in procedura 'b'. in acest caz, compilatorul rezerva doua spatii In
memorie: unul pentru variabila a declarata in programul principal, altul pentru
variabila a declarata in procedura. Procedura lucreaza asupra
variabilei
declara te in cadrul
ei. Tn acest
caz,
variabila globala
a nu este
recunoscuta in procedura.
program pr6;
var a:integer;
procedure b;
var a: integer;
begin
a: =1
end;
begin
a: =o;
b;
writeln(a)
end.
Contraexemplu:
program pr7;
procedure a;
procedure b;
begin
writeln('merge');
end;
begin
end;
begin
end.
Acest program da eroare de sintaxa. S-a lncercat din programul principal

apelul unei proceduri ('b') care a fost definita In cadrul procedurii 'a'. Nu ne
ajut Uaptul ca am apelat o procedura definita In cadrul unui bloc declarat acolo
unde am facut apelul.
in continuare, se presupun doua sau mai multe proceduri declarate In cadrul
aceluiai bloc. Se pune lntrebarea daca este posibil sa apelam o astfel de
procedura dintr-una declarata Ia acela!?i nivel. Raspunsul comporta o nuantare.
Daca procedura apelata este declarata lnaintea celei care o apeleaza, acest
lucru este posibil. Programul urmator demonstreaza acest lucru.
program pre;
var a:integer;
procedure pl;
begin
a: =a+l
end;
procedure p2;
begin
pl
end;
begin
write( 1 a= 1
);
readln(a);
p2;
writeln(1 a=
end.
a)
in situatia In care procedura care este apelata se afla plasata dupa procedura
care o apeleaza !?i daca nu se iau masuri suplimentare, acest lucru nu este
posibil. Programul urmator da eroare de sintaxa.
program pr9;
var a:integer;
procedure pl;
begin
p2
end;
procedure p2;
begin
a:=a+l
end;
begin
write(a=');
readln(a);
pl;
writeln(1 a=' 1 a)
Pentru a putea realiza, din cadrul unei proceduri, apelul unei proceduri
plasate dupa procedura apelanta, antetul procedurii care este apelata se declara
Ia inceput, urmat de clauza FORWARD iar descrierea ei poate fi pusa dupa
procedura apelanta. Programul urmator demonstreaza acest fapt.
program pr9;
var a:integer;
procedure p2; forward;
procedure pl;
begin
p2
end;
procedure p2;
begin
a: =a+l
end;
begin
write( 1 a= 1 );
readln(a);
pl;
writeln(1 a= 1 , a)
end.
6.3.2. Parametri formali, parametri efectivi

A fost aratat faptul ca un subprogram poate fi utilizat de mai multe programe.
Evident, acesta va Iuera cu variabile proprii (de unde solicita datele de intrare,
depune rezultatele, face diverse calcule). Ar fi dificil ca toi utilizatorii acestor
subprograme sa cunoasca toate amanuntele (de exemplu ca datele de intrare in
subprogram se depun in doua variabile, una numita d de tipul real, alta b de tip
boolean etc.). Apare necesitatea existen ei in limbaj a unui mecanism de interfat.3
intre subprogram si blocul apelant. Acesta este reprezentat de parametrii prin care
subprogramul set mba informatii cu blocul apelant. Ei sunt prezenti atat in antetul
subprogramului r .it !?i in instructiunea de apel prezenta in blocul apelant.
Parametrii sit ati in antetul subprogramului se numesc parametri formali !?i
sunt alcatuiti c
nume de variabile, valori sau alte subprograme. Numele de
formali provine t-In faptul cain momentul declaratiei nu sunt cunoscuti efectiv
(ca valoare). Purametrii situati in instructiunea de apel sunt numiti parametri
efectivi (in momentul apelului valorile acestora sunt cunoscute).
Sa analizam urmatorul exemplu:
program prl ;
var s,sl,n:integer;
procedure ;uma(var s:integer;n:intege
var i:inte rer;
);
begin
s:=O;
for i:=l ton do s:=s+i
end;
begin
write( 1 n= 1 );
readln(n);
suma(s,n);
writeln(1 suma = 1 , s);
suma(s,lO);
writeln(suma primelor 10 numere = 1 ,s);
swna(s1,4);
writeln( 1 suma primelor 4 numere= 1 , sl)
end.
Procedura 'suma' calculeaza suma primelor n numere naturale. Tn programul

principal ea este apelata de trei ori, in diverse moduri.
Analizam antetul procedurii. Tntre paranteze sunt trecui parametrii formali.
Ace!?tia sunt: var s:integer !?i n:integer, deci avem doi parametri formali. Ei sunt
separati prin semnul ';'. De aici tragem o prima concluzie: parametriiformali sunt
separai prin semnul ';'. Daca urmarim oricare din cele trei apeluri 3le acestei
proceduri observam ca intre paranteze sunt trecuti parametrii efectivi. Avem de
fiecare data cate doi parametri efectivi. Observam existenta egalitatii intre numarul
parametrilor formali !?i numarul parametrilor efectivi. De aici tragem concluzia
urmatoare: numarul parametrilor formali coincide cu numarul parametrilor efectivi.
De asemenea observam ca parametrii efectivi sunt separari prin virgula.
Pentru cele trei apeluri ale procedurii analizam parametrii efectivi. La primuJ
ape! avem s !?i n, Ia al doilea - s !?i 10, Ia al treilea - s 1 $i 4. Nu este
QQ!igatoriu ca numele parametrilor formali sa coincida cu numele parametrilor
efectivi (aceste nume coincid numai Ia primul apel). Totu!?i exista o alta
corespondena $i anume de tip. Primul parametru, fie ca este formal, fie ca este
efectiv este de tipul INTEGER, iar al doilea fie ca se nume9te n, fie ca este un
numar este, de asemenea, de tipul INTEGER.
in concluzie, se pot spune urmatoarele: intre parametrii formali !?i cei efectivi
exista o corespondenta de numar !?i tip.
Analizam din nou parametrii formali. Amandoi sunt de tipul INTEGER. Cu
toate acestea, unul a fost declarat cu ajutorul cuvantului VAR, altul fara acest
cuvant. Care este motivul pentru care s-a procedat astfel?
Limbajul Pascal admite doua forme de transmitere a parametrilor: prin
referinta !?i prin valoare.
6.3.2.1. Transmiterea parametrilor prin referinta

Tn acest caz, un astfel de parametru (formal) este
Tn exemplul nostru este cazul primului parametru.
ca atat subprogramul cat !?i programul apelant
variabile (chiar daca numele ei este altull. Sa fim
precedat de cuvantui VAR.

Prin aceasta se precizeaza
lucreaza asupra aceleia!?i
mai expliciti. Consideram
149
apelul suma(s,n). in subprogram, nu se face alocarea de spaiiu Tn memoria

calculatorului pentru variabila s. El lucreaza Tn acelai spatiu alocat pentru s Tn
blocul apelant. Aceasta explica faptul ca Tn blocul apelant regasim rezultatul
final (valoarea luis) pe care o tiparim. Analizam apelul suma (s 1,4). Cu toate
ca nu exista corespondenta de nume (parametrul formal este s iar eel efectiv
este s 1, a tat subprogramul cat i blocul apelant lucreaza In spatiul de memorie
alocat variabilei s 1. Folosim transmiterea parametrilor prin referinta, atunci
cand ne intereseaza sa Tntoarcem blocului apelant un rezultat.
6.3.2.2. Transmiterea parametrilor prin valoare
in acest caz parametrul formal nu este precedat de cuvantul VAR. Sa anali
zam exemplul nostru. Este cazul celui de-al doilea parametru. La o astfel de
transmisie, subprogramul rezerva un spatiu Tn memorie pentru aceasta valoare
(deci pentru n). Acest fapt ne permite sa transmitem ca parametru efectiv chiar
o valoare (nu neaparat o varibila din care, de fapt, este folosit numai continutul
ei). Spre a ne lamuri asupra acestui mecanism consideram un nou exemplu:
program pr13;
var n:integer;
procedure a(n:integer);
begin
n:=n+l;
writeln(n)
end;
begin
n: =1;
a (n);
writeln(n)
end.
Avem un singur parametru transmis prin valoare. Programul decurge astfel:

variabilei n i se atribuie valoarea 1;
este apelata procedura a;
n se incrementeaza cu 1 i se tipare te (se va tipari 2);
se revine in blocul apelant i se tipare te valoarea lui n( 1).
Acest program demonstreaza ca pentru n s-a alocat in subprogram un alt

spatiu Tn memorie. in procedura, valoarea finala pentru n este 2, iar Tn
programul principal este 1 (nu am putut Tntoarce rezultatul).
Observa,tie: Nu este permis ca variabila ce este trimisa ca parametru sa fie
de un tip anonim. Exemp/u: v:array[1 ..9] of integer nu poate fi trimisa ca
parametru. Toate variabilele transmise ca parametru trebuie sa aiba declarat
tipul utilizand TYPE, ca in exemplul urmator:
program pr14;
var v:vector;
n,i,s:integer;
of integer;
procedure suma(n:integer;v:vector;var
begin
s:=o;
for i:=l ton do s:=s+v[i]
end;
begin
write( 1 n= 1 );
readln(n);
for i: =1 to n do
begin
Write( IV [ I 1 i 1 I ] =
readln(v[i])
end;
suma(n,v,s);
writeln( 1 S= 1 ,s);
end.
I )
s:integer);
Pentru rigurozitate prezentam procedurile utilizand diagrame de sintaxa:
DECLARATIE
-DE PROCEDURA
ANTET PROCEDURA
BLOC
Figura 6.3.2.1.
ANTET
PROCEDURE
IDENTIFICATOR
LISTA
PARAMETRI
-PROCEDURA
j
f)>
Figura 6.3.2.2.
INSTRUCTIUNE
--PROCEDlJRALA
IDENTIFICATOR
Figura 6.3.2.3.
LISTA
--PARAMETRI
FORMALl
LISTA
--PARAMETRI
EFECTIVI
IDENTIFICATOR TIP
IDENTIFICATOR
151
6.4. Func1ii (declarare i apel)

Nu o data, 'fn matematica intervin expresii de genul: 3*sin(x), 4- cln(x) + 1
etc. in Pascal este permis ca aceste expresii sa fie transcrise direct In limbaj.
Pentru a putea face astfel de calcule (sin, In) se apeleaza ni te subprograme
numite functii, care intorc un singur rezultat (astfel de calcule se realizeaza prin
dezvol tari In serie, pe care le vom lnvata mult mai tarziu). Ne putem pune
probiPma daca nu este posibil sa scriem i noi astfel de subprograme (care sa
nu depa easca cuno tintele noastre de matematica). Raspunsul este afirmativ.
Pentru studiul lor pornim de Ia un exemplu.
program prlS;
var s,i:integer;
function inv(n:integer):integer;
var ninv:integer;
begin
ninv:=o;
while n<>o do
begin
ninv:=ninv*lO+n modlo;
n: =n div
10 end;
inv:=ninv
end;
begin
writeln(inv(l25));
s:=o;
for i:=lS to 20 do s:=s+inv(i);

writeln(s=',s)
end.
Acest program contine o functie care are ca parametru de intrare un numar

:;;i returneaza o valoare lntreaga ce reprezinta numarul inversat. Analizand
functia collstatam urmatoarele: antetul unei functii cuprinde cuvantul cheie
FUNCTION urmat de numele ei, in continuare se pun parametrii formali (pot
lipsi), semnul ':' i tipul functiei (In cazul nostru INTEGER).
Mecanismul de transmitere a parametrilor este acelai cu eel de Ia proceduri
deci nu il vom comenta In acest paragraf.
Tipul functiei da natura rezultatului. in exemplul nostru, inversul unui numar
lntreg pozitiv este un intreg oozitiv :;;i de aici rezulta tipul INTEGER.
in afara antetului, numele unei functii se poate gasi in doua locuri: in
procedura standard de scriere sau In cadrul unor instruqiuni de atribuire.
Atunci cnd numele figureaza in cadrul unei instruqiuni de scriere el figureaza
cu parametru (de exemplu, writeln(inv(125)). in acest caz se apeleaza func !a
cu parametri dati, iar rezultatul este tiparit. Atunci cand numele unei functii se
gase te 'fn cadrul unei instructiuni de atribuire se disting doua cazuri: numele
se gase te in partea stnga a instructiunii sau in partea. dreapta a acesteia.
in cazul cand numele se gase te In partea dreapta (in exemplul nostru
(inv: = ninv) funqia se comporta ca o variabila, Tn sensul ca rezuitatul ei capi:l"ta

valoarea expresiei din partea stanga (dupa ce am calculat inversul unui numii
Tn cadrul variabilei inv, functia ia aceasta valoare).
in situatia Tn care numele 'se gase$te In partea stanga a unei instruq;'-.ln; cje
atribuire, el trebuie urmat de parametri i atunci funqia se apeieaza rar
rezultatul ei intra Tn calculul expresiei (In exempiul dat s: = s + inv(i)}. frr astfe!
de cazuri se grel?e te de multe ori In scrierea unei funqii.
Contraexemplu: Rescriem funqia dupa cum se vede mai jos:
function inv(n:integer):integer;
begin
inv:=0;
while n<>O do
begin
inv:=inv*10+n mod 10;
n:=n div 10
end;
end;
Pare mai simplu, nu-i a a? Gre eala Tn aceasta secvena se gase:?te ia linia
inv: = inv* 10 + n mod 10. Numele funqiei figureaza i In dreapta instruqiu:1ii
de atribuire. Deci se Tncearca apelul ei. Dar pentru apel functiei li sunt necesari
parametri pe care nu-i are preciza1i. in concluzie, compi!atorui va gener:1 o
eroare de sintaxa.
6.4.1. Tipul funcJiei

Poate fi de trei feluri:
orice tip simplu (exemplul anterior);
de tip reper (vom studia cu alta ocazie acest tip);
de tip string (exemp!ul care urmeaza).
program pr16;
function concat(a,b:string):string;
begin
concat:=a+b
end;
begin
writeln
end.
(concat(1 studiul
functiilor'))
in continuare prezentam sintaxa func iilor utilizand diagramele de sintaxa

DECLARATIE
DE FUNCTIE
BLOC
ANTET FUNCTIE
r---,
------ t-+( )-+

FORWARD
,/
_rJ
153
r---------,
I """
'"""
LISTA
NRAMETRI
:!._
FORMA...;
L - - - - -
,_
)_j-;o:
- - -
,... - - - - - -- - - ---'
IDENTIFICA
DETIP_J
tp
Figura 6.4.1.2.
APEL
IDENTIFICATOR
FUNCTIE
-FUNCTIE
.J .
1-usrA.I
"'
PARAMETRI 1-+! )
EFECTIVI
Figura 6.4.1.3.
6.5. Dezvoltare ascendenta, dezvoltare descendenta

Din cele aratate privind apelul procedurilor i functiilor, rezulta doua moda!:tati de
dezvoltare a prograrnelor: dezvoltare ascendenta, dezvoltare descei'denta.
6.5.1. Dezvoltarea ascendenta

Programul principal apeleaza n proceduri. Acestea sunt plasate, una dupa alta,
Tn partea de dec!ara ii (proceduri, functii) a programului principal. Structura generala
este urmatoarea:
program.....
procedure
procedure
I
procedure
begin
);
);
01
)
end.
Procedurile se pot apela i una pe alta, daca este Tndeplinita una din conditiile:
procedura care apeleaza se gase te plasata dupa procedura apelata;
nu este Tndeplinita conditia anterioara, dar s-a utilizat clauza FORWARD.
Denumirea provine de Ia faptul ca programul principal rezuita. Tn esenta, c:'
apelul acestor proceduri.
6.5.2. Dezvoltarea descendenta

Programul principal apeleaza o procedura sau funqie, aceasta Ia randul ei are
declarata o alta procedura sau functie pe care o apeleaza, .a.m.d. Denumirea
provine din faptul ca se gfmdel?te intregul, dupa care se vede de ce anume este
nevoie pentru realizarea lui (ce procedura sau functie) apoi acest proces se reia.
Schema generala este urmatoarea:
program..... .
procedure
...(
);
procedure...(
);
begin
end;
begin
end;
begin
end.
Aceste modalitati de dezvoltare a programelor au un caracter mai mult

teoretic, deoarece in practica se folose te o metoda mixta.
6.6. Unitati de program

in activitatea practica se fac aplicatii cu un mare numar de programe care
de multe ori sunt
de mari dimensiuni. 0 preocupare constanta a
informaticienilor este de a pune Ia dispozitia programatorilor instrumente
eficiente de pro gramare. in acest sens, limbajul TURBO PASCAL ofera
posibilitatea lucru!ui cu unitati de program (unit-uri).
6.6.1. Forma generala !?i constructia unei unitati de program

Prin unitate de program intelegem un ansamblu de date, proceduri !?i functii,
plasate !?i compilate impreuna care pot fi u or. utilizate in scrierea c.::!tor
programe, tara a se cunoa!?te amanunte necesare realizarii lor.
Forma generala a unei unitati de program este urmihoarea:
UNIT < nume unitate >;
INTERFACE
[USES < numele altor unitati de program pe care le utilizeaza > ;]
[tipuri de date !?i variabile globale in programul care utilizeaza unitatea]
antete de proceduri !?i functii
155
IMPLEMENTATION
ltipuri de date i variabile locale (valabile numai pentru unitatea de program)]
procedurile !?i functiile utilizate de unitatea de program
[BEGIN o eventuala secventa de
program care se executa
in momentul declararii
unitatii de program in
programul care o utilizeaza.
END.]
Se observa ca o unitate de program are in mod obligatoriu doua parti 9i

optional o a treia.
Prima parte obligatorie este precedata de clauza INTERFACE. Aici se gasesc de
claratiile tipurilor de date, variabi.lelor, !?i sunt enumerate procedurile !?i funqiile ce
pot fi utilizate din programul principal. Pentru orice tip de variabila declarat aici, se
pot declara variabile de acest tip atat in cadrul unitatii cat !?i in cadrul
programului care folose!?te unitatea. Orice variabila declarata aici poate fi folosita
tara nici o alta declaratie atat in cadrul unitatii cat !?i in programul care folose!?te
unitatea (unde are rolul de variabila globala). Toate procedurile !?i functiile care
aici sunt numai enumerate pot fi folosite de orice program care folose!?te
unitatea.
_
A doua parte, obligatorie, se gase!?te plasata sub clauza IMPLEMENTATION. In
aceasta parte se pot declara tipurile !?i variabilele valabile numai pentru unitatea
data. Tot aici se scriu in clar toate procedurile !?i functiile care in prima parte au
fost numai declarate, precum !?i altele ce pot fi folosite numai in cadrul unitatii.
Partea optionala a fost prezentata in cadrul formei generale a unitatii.
Tn continuare, vom da un exemplu pur didactic de unitate de program,

numita OPERATII. Aceasta contine patru proceduri de adunare, scadere,
inmultire !?i impartire de variabile reale. Variabilele a !?i b sunt globale pentru
programul care utilizeaza aceasta unitate, iar variabila c poate fi utilizata numai
in cadrul unitatii. in secventa de initializare se citesc valorile variabilelor a !?i b.
unit operatii;
interface
var a,b:real;
procedure adun(a,b:real);
procedure scad(a,b:real);
procedure produs(a,b:real);
procedure impart(a,b:real);
implementation
var c:real;
procedure adun(a,b:real);
begin
c:=a+b;
writeln
end;
(c:3:2)
procedure scad(a,b:real);
begin
c: =a-b;
writeln(c:3:2)
end;
procedure produs(a,b:real);
begin
c:=a*b;
writeln (c:3:2)
end;
procedure
begin
if b=O
end;
impart(a,b:real);
then writeln ('Impartirea nu se poate face ')
else begin
c: =a/b;
writeln(c:3:2)
end
begin
write('a=');
write(b=');
end.
readln(a);
readln(b);
0 unitate de program trebuie sa se gaseasca compilata pe disc avand

extensia TPU. Pentru aceasta se procedeaza In felul urmiHor:
pe tasteaza F1 0 !?i se deplaseaza cursorul catre optiunile de compilare
(sau direct ALT +C)
se alege optiunea DESTINATION MEMORY;
indata ce suntem pozi ionai pe aceasta optiune tastam D, precizand astfel
ca rezultatul compilarii sa se gaseasca pe disc;
pentru declan!?area compilarii se tasteaza F9.
Programul urmator utilizeaza aceasta unitate. Faptul ca acest program utilizeaza
o unitate se precizeaza utilizand clauza USES. Rularea sa decurge in felul urmator:
se cer valorile variabilelor a !?i b (declarate in unitate);
se apeleaza procedurile de adunare, scadere, inmultire !?i impartire iar
rezultatele se tiparesc;
se apeleaza aceleai proceduri utilizand pentru apel doud variabile globale a!e
programului (c i d).
program test;
uses operatii;
var c,d:real;
begin
adun(a,b);
scad(a,b);
produs(a,b);
impart(a,b);
write(c='); readln(c);
write(d='); readln(d);
adun(c,d);
scad(c,d);
produs(c,d);
impart(c,d);
end.
Dupa ce am vazut modul de alcatuire i construc ie al unei unita1i de

program, trebuie sa precizam faptul ca limbajul Turbo Pascal este livrat cu
cateva unita!i de program standard (produse de firma BORLAND). Amintim
cateva: SYSTEM, CRT, DOS, GRAPH. Procedurile i funqiile puse Ia dispozi!ie
de limbaj le gasim In aceste unita1i.
6.7. Proceduri i functii predefinite

In unitatea de program SYSTEM se gasesc
func iilor prezentate In capitolele anterioare.
majoritatea procedurilor
Exemple de func_tii: sin, cos, In, ord, succ etc.

Exemple de proceduri: delete, insert, read, readln etc.
in acest paragraf prezentam o procedura i o functie pentru generarea
numerelor aleatoare (intampiatoare). Acestea sunt extrem de utile atunci cand
scriem programe pentru diverse jocuri. Mi carea unei figuri 'i'ntr-o parte sau In
alta este consecin1a generarii unui numar aleator.
Procedura RANDOMIZE ini1ializeaza variabila de pornire a generatorului de
numere aleatoare. Aceasta variabila se nume te RANDSEED i este declarata
in unit-ul SYSTEM.
Funqia RANDOM(n) genereaza un numar aleator cuprins lntre 0 i n-1.
Fara parametru, funqia genereaza un numar aleator cuprins In intervalul
[0,1).
Programul urmator realizeaza un joe. Calculatorul genereaza un numar aleCJtor
format din 4 cifre distincte, cuprinse intre 0 i 9. Prima cifra trebuie sa fie di
ferita de 0. Acest numar nu este tiparit. Operatorul va introduce i el un numar
care respecta aceleai condi!ii. Cifrele celor doua numere sunt comparate de
calculator, care scrie cate din ele coincid ca pozi ie i valoare i cate coincid
numai ca valoare (centrate i necentrate).
Exemplu: calculatorul ,a ascuns" numarul 3172. Operatorul tasteaza 4129.
Raspunsul este una centrata (este vorba despre citra 1, i una necentrata (citra 2).
Procedeul se repeta pana cand numarul a fost ghicit (4 centrate). Rulati acest
program !?i Tncerca1i sa ghiciti numarul ascuns din cat mai putine incercari.
program centrate;
type numar=array[l..4] of integer;
var nr ascuns,nr citit:numar;
c,n,i,nr:integer;
function nr corect(nr:numar):boolean;
var i,j:integer;
begin
nr_corect:=true;
for i:=1 to 3 do
for j:=i+1 to 4 do
if nr[i]=nr[j] then nr corect:=false;
if nr[1]=o then nr_corect: false;
end;
procedure c n(nr1,nr2:numar;var c,n:integer);
var i,j:integer;
begin
c:=o;
n: =0;
for i:=1 to 4 do
if nr1[i]=nr2[i] then c:=c+1;
for j:=1 to 4 do
if (nr1[i]=nr2[j])and(i<>j) then n:=n+1
end;
procedure ascund(var nr:numar);
var i:integer;
begin
for i:=1 to 4 do nr[i]:=random(10)
end;
begin
randomize;
repeat
ascund(nr ascuns);
until nr_corect(nr_ascuns);
repeat
repeat
readln(nr);
i:=4;
while nr<>o do
begin
nr citit[i]:=nr mod 10;
nr:=nr div 10;
i:=i-1
end
until nr corect(nr citit);
c n(nr ascuns,nr citit,c,n);
writeln(centrate=,c, necentrate=,n)
until c=4
end.
6.8.
Parametri formali de tip procedura sau functie

6.8.1. Tipul de date procedural
Printr-un tip procedural se descrie totalitatea procedurilor sau functiilor cu

aceia!?i parametri formali.
0 variabila de un anume tip procedural poate primi ca valoare o procedura
sau functie. Pentru ca programul sa poata Iuera cu tipul procedural avem doua
posibilitati:
Sa fie prezenta optiunea de compilare FORCE FAR CALLS din submeniul

COMPILER al meniului OPTIONS.
c se tasteaza ALT + 0;
c se deplaseaza bara de meniu cu ajutorul sagetilor pe op iunea COMPILER:
o se tasteaza RETURN (s-a facut selectia);
o Ia optiunea FORCE FOR CALLS se tasteaza spatiu (se selecteaza aceasta
optiune).
Procedurile sau functiile care fac obiectul atribuirii vor f! cuprinse Tntre { $f +}
i {$f-}.
in programul care urmeaza se exemplifica modul de lucru cu tipul procedural.
program prol;
type a=procedure(x:integer);
var p:a;
procedure adun (i:integer);
begin
i:=i+l;
writeln(i)
end;
begin
p: =adun;
p ( 3)
end.
Tipul a este un tip procedural. El reprezinta totalitatea procedurilor cu un

singur parametru formal de tip INTEGER.
Variabila p este de tipul procedural. Valorile ei sunt procedurile specificate
de tipul a. in program, se efectueaza o instructiune de atribuire asupra variabilei
p. in urma acestei atribuiri ea capata ca va(oare procedura adun. Procedura
este lansata Tn executie cu parametrul efectiv 3.
Programul urmator exemplifica modul de lucru cu tipul procedural care
admite ca valori functii cu un singur parametru real de tipul INTEGER.
program pro2;
type a=function(x:integer):integer;
var p:a;
function adun (i:inteaer):integer;
begin
adun:=i+l;
end;
begin p:=adun;
writeln(p(J))
end.
Procedurile !?i functiilf

procedural.
admit
ca parametri formali variabile de un tip
in exemplul urmator, procedura tipar are ca parametru formal de intrare

variabila p care poate lua ca valori funqii de tip INTEGER cu un parameuu
formal de tip INTEGER. Procedura este apelata pentru doua funqii diferite
(adun i scad) i, Tn mod evident, rezultatele celor doua executii sunt diferite.
program pro3;
var p: a;
function adun (i:integer):integer;
begin
adun:=i+l;
end;
function scad (i:integer):integer;
begin
scad: =i-1;
end;
procedure tipar(p:a);
begin
writeln(p(9))
end;
begin
p:=adun;
tipar(p);
p: =scad;
tipar(p)
end.
Se poate pune fireasca Tntrebare, cum este posibil ca o variabila, fie ea si de

un tip procedural, sa ia valoarea unei proceduri sau tunqii? In realitate, o astfel
de variabila ia ca valoare o adresa catre procedura sau funqia specificata.
Atunci cand se face apelul procedurii (func iei), prin intermediul adresei se face
transferul catre aceasta.
in cadrul unita!ilor de program s-a realizat pentru prima data unitatea Tntre
proceduri i date Tn cadrul unei unice structuri sintactice. Se pune Tntrebarea
daca aceasta legatura este posibila i Tn cadrul unei alte structuri sintactice i
anume tipul RECORD. Raspunsul Ia aceasta Tntrebare este afirmativ. Tipu!
RECORD aduna In cadrul unei lnregistrari date de diverse tipuri printre care si
cele de tip procedural (deci i proceduri sau funqii). In programul care urme
za, o Tnregistrare de tip OBIECT con ine un numar Tntreg i o func ie lntreaga
de parametru formallntreg. Se fac atribuiri pentru doua variabile de tip OBIECT
:?i se lanseaza procedurile con inute de fiecare Tn parte.
program prol;
obiect=record
nr:integer;
functie:a
end;
var inr,inrl:obiect;
function adun (i:integer):integer;

begin
adun:=i+l;
end;
function scad (i:integer):integer;
begin
scad:=i-1;
end;
begin
inr.functie:=adun;
inr.nr:=S;
inrl.functie:=scad;
inrl.nr:=3;
writeln(inr.functie(inr.nr));
writeln(inrl.functie(inrl.nr))
end.
Acest exemplu ne conduce Ia urmatoarele concluzii:

datele si procedurile pot fi reunite In cadrul unei structuri de date de tipul
lnregist are (aceasta unificare se nume te iNCAPSULARE);
Tntrucat avem posibilitatea sa construim o alta structura de tip lnregistrare
cu una deja construita, noua structura preia toate datele i procedurile vechii
structuri (fenomen ce se numeste MOSTENIRE). Aceste doua ca racteristici
stau Ia baza programarii pe obiecte.
6.9. Programarea pe obiecte

6.9.1. Logica !?i mecanismul programarii pe obiecte
in scopul declarat ca activitatea de programare sa fie accesibila oricui

dore te sa o practice, s-a cautat sa se puna Tn coresponden a obiectele
realitatii Tnconjuratoare cu mecanismele existente Tn cadrul limbajeior de
programare, lndeplinindu-se astfel i un deziderat mai vechi al programatori:or
Exemplu ce justifica necesitatea programarii pe obiecte.
Sa consideram un obiect din viata reala i anume un telefon care se

caracterizeaza prin:
1)
tip (public sau nu);
2)
modul de transmitere a numarului (disc sau tastatura);
3)
provenienta (tara Tn care a fost fabricat);
4)
pret;
5)
algoritmul de utilizare.
Un program care gestioneaza un stoc de astfel de telefoane utiiizand tipu!
RECORD, poate retine fara probleme, pentru un telefon, primele patru
informatii. Pentru a re1ine algoritmul de utilizare a talefonului avem urmatoare!e
14::1
posibilitati:
In functie de tipul telefonului l?i modul de transmitere a numarului, In cadrul
lnregistrarii sa se memoreze un text care sa descrie acest algoritm, solutie
extrem de ineficienta;
programul sa contina o procedura care analizand lnregistrarea pentru un
telefon sa furnizeze algoritmul sau de funqionare (In ac st caz legatura lntre
procedura !?i date nu se realizeaza In cadrul unei constructii sintactice unice,
iar In cele ce urmeaza se vor evidentia !?i alte dezavantaje).
Aceste neajunsuri lncearca sa le rezolve programarea pe obiecte.
Pentru aceasta, limbajul TURBO PASCAL 6.0 dispune de un mecanism
specific. Astfel, apare un nou tip !?i anume tipul obiect.
Prin obiect se lntelege o constructie sintactica unica In care se pun Ia un loc
datele !?i procedurile care lucreaza cu aceste date !?i care este recunoscut de
compilator prin cuvantul cheie OBJECT.
Procedurile sau functiile existente lntr-un obiect se numesc ,METODE".
Rezulta ca, pentru exemplul nostru, avem nevoie de o variabila obiect pe
care o putem numi TELEFON !?i care sa contina toate informatiile 1)...4) precum
!?i !!letoda (procedura care descrie algoritmul de folosire a acestuia).
In ultimii ani au aparut telefoane moderne cu facilitati suplimentare (memorie,
robot etc.). Este evident faptul ca algoritmul de utilizare a unui astfel de telefon
contine In plus !?i alte elemente cum ar fi memorarea unui numar de telefon,
efectuarea unui apel dupa un numar deja memorat, lansarea unui mesaj pe
robot etc. Aceasta lnseamna ca algoritmul de folosire a telefonului se complica
deci avem nevoie de noi metode pe langa cele vechi. Rezulta ca este absurd
sa rescriem aceste proceduri lntr-un alt tip de obiect TELEFON M. Tn cadrul
limbajului exista posibilitatea de a construi un nou obiect (In -cazul nostru
TELEFON_M) pornind de Ia unul vechi, preluand toate datele !?i metodele
acestuia Ia care se pot adauga date !?i/sau metode noi. Revenind Ia ipoteza In
care nu folosim programarea pe obiecte !?i avem o procedura din exterior care
furnizeaza algoritmul, aceasta ar trebui modificata, fapt ce presupune un efort
suplimentar de programare.
6.9.2. Mecanismul de realizare a programarii pe obiecte

6.9.2.1.
Sintaxa
incapsularea
tipului
obiect
Sintactic, structura tip obiect se poate prezenta In doua feluri:

1.
OBJECT
metoda 1;
{metoda_2};
{metoda_n}
PRIVATE
164
lista 1 campuri :tip;

{lista_ 2 campuri :tip;
{lista_p campuri :tip}
end
2.
object
lista 1 campuri :tip;
{lista 2 campuri :tip;}
{lista_p campuri :tip:}
metoda 1;
{metoda_2};
{metoda_n}
end
in cazul formei 1. cuvantul PRIVATE specifica faptul ca ceea ce urmeaza

intre el i END nu este accesibil decat metodelor asociate tipului obiect care!!
con ine. Precizam de asemenea ca din punct de vedere allimbaju!ui, putem sa
nu folosim acest cuvant i deci sa avem acces Ia datele unei variabiie obiect
i din cadrul programului, insa acest lucru nu este permis din punctul de vedere
al programarii pe obiecte (accesul Ia date se face numai prin intermediul
metodelor). Tot astfellimbajul permite utilizarea lui GO TO insa acest lucru este
nepermis din punctul de vedere al programarii structurate.
Forma 2. este utila in situatia in care se folose te un obiect spre a declara
un alt obiect care il mo tene te pe acesta i poseda metode noi, care au acces
in campurile de date ale vechiului obiect. Tn acest caz, sarcina programatorilor
este sa nu acceseze datele obiectului din programul care il folose te pe acesta.
Sa consideram un obiect care apare in multe programe i anume un vector
de numere intregi. Acesta se caracterizeaza prin urmatoarele:
numarul de componente (sa numim acest numar lungimea vectorului);
vectorul propriu-zis;
o procedura care permite citirea lungimii i a vectorului de Ia tastatura (cit);
o procedura ce permite tiparirea pe monitor a vectorului (tip).
Toate acestea se re in in variabila obiect VECTOR. Variabila obiect lmpreuna
cu procedurile aferente se retin intr-o unitate de program care, in exemplul
nostru, se nume te OBIECT1.
Precizam urmatoarele reguli:
variabila obiect se re!ine in partea de interfata a unita ii de program (in cazul
nostru se nume9te VECTOR);
descrierea in clar a procedurilor existente (metodelor) intr-o variabila obiect
se realizeaza in partea de implementare a unitatii de program;
s in partea de implementare, numele fiecarei proceduri men!ionat in cadrul
variabilei obiect se formeaza din numele variabilei obiect urmat de punct i
numele procedurii existent in cadrul variabilei obiect (exemplu: procedura
numita cit in cadrul variabilei obiect se nume te aici vector .cit).
Tn continuare prezentam unitatea de program care are descrisa variabila

obiect VECTOR.
unit obiectl;
interface
type vector=object
procedure cit;
procedure tip;
private
lung:integer;
vec:array[l..20]
end;
of integer;
implementation
procedure vector.cit;
var i:integer;
begin
write(lung=');
readln(lung);
for i:=l to lung do
begin
write('elem[' I i 1 ' l =');
readln(vec[i])
end
end;
procedure vector.tip;
var i:integer;
begin
for i:=l to lung do
begin
write('elem[' 1 i,']=' 1 vee[i]);
writeln
end
end;
end.
Primul exemplu prezentat arata modul Tn care un prograrn utiiizeaza un

obiect. Programul cite te un vector ;;;i Tl tipare te. Regullie care stau Ia t"'3za
alcatuirii unui astfel de program sunt urmatoarele:
se precizeaza numele unita ii de program ce con1ine obiectul utilizand clauza
USES;
se declara variabilele care sunt utilizate Tn program (Tn cazul nostru utilizam
o singura variabila i anume a);
apelul unei metode asociate variabilei se face prin numele variabilei urmat
de punct i numele metodei (exemplu: pentru variabila a procedura cit se
apeleaza prin a.cit).
program exemplul;
uses obiectl;
var a:vector;
begin
a.cit;
a. tip;
end.
Pana aici, am aratat modul in care se realizeaza ,iNCAPSULAREA ".

Prin ,iNCAPSULARE" in elegem inglobarea in cadrul
unei structuri
sintactice unice
atilt a datelor cat :;;i
a procedurilor (metodelor) ce
prelucreaza aceste date. ldeea de incapsulare nu apare prima data in cazul
programarii pe obiecte, ea a fost intalnita in cadrul unita ilor de program 9i in
cadrul tipurilor RECORD ce contin pe langa date 9i tipuri procedurale.
Variabila a de tip vector cuprinde lungimea vectorului, vectorul propriu-zis
precum !?i doua proceduri de scriere 9i citire a acestui vector.
6.9.2.2. Mo9tenirea
in cele ce urmeaza exemplificam mecanisul de ,MO$TENIRE". Sa
presupunem ca ne intereseaza o situatie privind notele obtin!;Jte de elevii unui
liceu Ia un examen (notele sunt considerate numere intregi). In acest exemplu
avem o noua variabila obiect (ELEV) care trebuie sa contina :
numele elevului;
o procedura de citire a acestui nume;
notele elevului 9i procedura de citire a acestora.
Notele obtinute de elev Ia examen constituie un vector. Pentru acesta avem
deja un obiect (VECTOR) ce include !?i metoda de citire a componentelor
vectorului (a notelor obtinute de elev). Rezulta ca obiectul VECTOR ne este de
mare folos In construirea noului obiect ELEV. Limbajul permite acest lur:ru.
Analizand unitatea de program in care construim acest nou obiect se desprind
urmatoarele :
noua unitate de program OBIECT2 utilizeaza unitatea OBIECT1, acest lucru
se specifica utilizand clauza USES.
noul obiect il utilizeaza pe eel vechi 9i acest lucru se specifica plasand
numele obiectului utilizat, a9ezat intre paranteze, dupa cuvantul cheie
OBJECT (in acest mod, noul obiect preia toate datele 9i metodele vechiului
obiect);
datele 9i metodele care apar pentru prima data aici se descriu in clar in
noul tip dupa regulile deja specificate.
unit obiect2;
interface
uses obiectl;
type elev=object(vector)
procedure cit_nume;
private
nume:string[20];
end;
implementation
procedure elev.cit nume;

begin
write('nume elev=');
readln(nume)
end;
end.
In exemplul care urmeaza se utilizeaza o variabila obiect de tip ELEV. Pentru

un elev se citesc numele, numarul de note 9i notele. Se observa ca procedura
cit a fost mo!?tenita de Ia tipul vector.
program exemplu2;
uses obiect2;
var a:elev;
begin
a.cit nume;
a.citend.
Prin ,MO$TENIRE" se ln elege acea proprietate a obiectelor prin care un

obiect nou construit preia datele !?i metodele unui alt obiect.
Observa_tie foarte important:
Sa urmarim o consecina a fenomenului de ,MO$TENIRE". Am construit tipul
vector. Cu ajutorul lui am construit tipul elev. in programare vectorii sunt mult
utilizati. Cu tipul vector se poate construi un alt obiect cum este acela care re ine
o multime de numere intregi (m_int care, spre deosebire de vector, are !?i o metoda
de verificare a elementelor distincte). Cu acest din urma obiect se pot construi alte
obiecte. Toate acestea preiau rutinele pentru vector. in acest mod ob!inem
reutilizarea softului deja realizat iar un program (care se scrie relativ U!;iOr dar preia
soft prin ,MO$TENIRE") poate avea efecte spectaculoase.
6.9.2.3. Atribuirea in cazul variabilelor obiect

lnstructiunea de atribuire funqioneaza !?i cu variabile obiect. De exemplu
daca A 9i B sunt doua variabile de tip VECTOR se poate folosi instruqiunea
A:= B.
Observa_tie foarte important:
Putem atribui unei variabile obiect, de un tip ce a fost folosit in construc ia
altui tip, valoarea unei variabile din noul tip. De exemplu, unei variabile de tip
vector i se poate atribui valoarea unei variabile de tip elev.
Programul care urmeaza exemplifica acest lucru. Se citesc numele !?i notele
unui elev In variabila b de tip elev. Variabilei a de tip vector i se atribuie
valoarea variabilei b de tip elev (deci a va avea ca valori notele elevului). Faptul
ca opera ia de atribuire a reu!;iit se probeaza in program prin tiparirea vectorului.
program exemplu3;
uses obiect2,obiectl;
var a: vector;
b:elev;
begin
b.cit;
b.cit nume;
a:=b; a.tip
end.
Observafie: Atribuirea unei variabile obiect de un tip descendent a valorii
unei variabile de un tip stramo!ji nu este posibila. De exemplu, unei variabile de
tip elev nu i se poate atribui valoarea unei variabile de tip vector. Care este
ra Junea acestui fapt?
In ipoteza ca aceasta atribuire este posibila, raman campuri necompletate in
variabila de un tip descendent. Ce semnifica ie logica poate avea con inutul
unei varia bile de tip elev care con ine un elev tara nume dar cu note?
6.9.2.4. Proceduri cu parametri formali de tip obiect

Variabilele de tip obiect pot fi parametri pentru proceduri Ia fel ca i celelalte
variabile. De asemenea, daca in fraza PROCEDURE apare un parametru de un
tip stramos al acestuia, acestei proceduri i se poate transmite o variabila de un
tip descendent din acesta. in exemplul care urmeaza procedurilor test1, test2
lise pot trimite ca parametri variabile de tip vector !?i variabile de tip elev. Ca
!jii in cazul atribuirii, invers nu este posibil (unui parametru de un tip descendent
nu i se poate atribui o variabila de un tip stramo!ji).
Aceasta proprietate are consecinte practice deosebite. Sa presupunem ca
am construit o procedura ce lucreaza cu ni!jite variabile obiect. Construim
alte obiecte descendente din obiectul care da tipul variabilelor cu care
lucre.aza aceasta procedura. Procedura va putea Iuera !jii cu variabile din tipul
obiectelor descendente. lata cum o procedura poate Iuera !?i cu variabile de alt
tip dec at acelea pentru care a fost conceputa.
program exemplu4;
uses obiectl,obiect2;
var a:vector;
b:elev;
procedure testl(var m:vector);
begin
m.cit
end;
procedure
begin
m.tip
end;
test2(m:vector);
begin
testl(a);
test2(a);
testl(b);
test2(b)
end.
6.9.2.5. Polimorfism
in biologie, prin polimorfism se. intelege fenomenul prin care indivizi
apartinand aceleiai specii apar sub forme diferite.
Prin analogie, In programarea pe obiecte, prin polimorfism se inte!ege ca o
procedura, recunoscuta printr-un nume, poate sa apar2 sub mai mu!te forme
(mai multe proceduri cu acelai nume).
in procesul de ,MO$TENIRE" poate aparea problema redefinirii unor r11etode
(pentru un obiect descendent dorim 7nlocuirea :.mei metode a unui obiect
stramo!ji cu o metoda noua). Pentru aceasta, Tn noui obiect se scrie o metoda
cu acelasi nume ca acela al metodei ce se lnlocuieste.
in exe plul urmiHor vom construi doua obiecte numar i numar 1 . Pentru
obiectul numar1 am redefinit procedura tip (modificand mesajul Ia afi are).
unit obpoll;
interface
type numar=object
nr:integer;
procedure cit;
procedure tip;
end;
implementation
procedure numar.cit;
begin
write( 1 numar= 1 );readln(nr)
end;
procedure numar.tip;
begin
writeln(1 numar= 1, nr)
end;
end.
unit obpol2;
interface
uses obpoll;
type numarl=object(numar)
procedure tip;
end;
implementation
procedure numarl.tip;
begin
writeln( 1 numarl= 1 ,nr);
end;
end.
Programul care urmeaza lucreaza cu cele doua obiecte. Atunci cand se

apeleaza metoda tip se selecteaza automat cea specifica obiectului. Cand se
apeleaza metoda pentru un obiect, numele ei este cautat Tn cadrul obiectului.
Daca este gasita se apeleaza (cazul nostru), Tn caz contrar se cauta metoda
Tntr-un obiect ascendent pana este gasita.
Pentru programul nostru, daca se cite te 20 se tipare te "numar= 20" i
apoi, daca se cite te 23, se tipare te "numar1 =23".
program tpol;
uses obpoll,obpol2;
var a:numar;
b:numarl;
begin
a.cit;
a.tip;
b.cit;
b.tip
end.
in continuare, se construiesc din nou doua obiecte numite tot numar i

numar1. Deosebirea consta Tn faptul ca obiectul numar contine o noua metoda
adun. Aceasta aduna 1 Ia campul nr al obiectului, dupa care se apeleaza
procedura tip.
unit obpolll;
interface
type numar=object
nr:integer;
procedure cit;
procedure tip;
procedure adun;
end;
implementation
begin
write('numar=');readln(nr)
end;
begin
writeln('numar=,nr)
end;
procedure numar.adun;
begin
nr:=nr+l;
tip
end;
end.
unit obpol21;
interface
uses obpolll;
procedure tip;
end;
implementation
begin
writeln( 1 numar1= 1 , nr);
end;
end.
in programul care urmeaza se declara o variabila de tip numar1. Dupa citirea

campului nr al obiectului se observa ca tiparirea se face dupa metoda tip a
obiectului numar. Este firesc sa fie a!?a deoarece metoda adun care apeleaza
tip se gase!?te in cadrul obiectului numar deci se apeleaza metoda tip din cadrul
obiectului de unde se face apelul.
De exemplu, daca se cite!?te 3, se tipare!?te "numar = 4".
program tpol;
uses obpol21;
var b:numarl;
begin
b.cit;
b.adun
end.
Se pot pune doua intrebari:

1. Care este motivul pentru care in cazul metodelor redefinite se apeleaza
acea metoda care se gase!?te in obiectul din care s-a facut apelul sau intr-un
obiect ascendent?
2. Cum este posibil ca in aceasta situatie sa putem noi selecta care din
variantele redefinite sa fie apelata ?
Raspu12sul pentrprima intrebare consta In afirmatia ca, aici, s-a folosit o
,METODA STATICA" de apel. La momentul compilarii unitatilor de program nu
se !?tia care metoda se va apela, a!?a ca s-a apelat acea metoda care se
gase!?te in obiectul de unde s-a facut apelul iar daca metoda nu se gase!?te
acolo, se cauta in primul ascendent !?.a.m.d.
in continuare raspundem Ia a doua intrebare.
Exista !?i o ,METODA DINAMICA sau VIRTUALA'' de apel care permite ca
selectia unei metode sau a alteia din cele redefinite sa se faca in momentul
apeluiui !?i nu Ia compilare. Pentru a realiza aceasta trebuie sa procedam astfel:
cand se declara, in cadrul obiectului stramol?, o metoda ce va fi
redefinita, se adauga dupa declaratie cuvantul VIRTUAL;
orice redefinire a metodei, in cadrul obiectelor ascendente, se va face
utilizand acelasi cuvant cheie VIRTUAL;
e fiecare obiect Ce COntine 0 metoda redefinita va avea 0 metoda
specifica
numita CONSTRUCTOR.
Metoda CONSTRUCTOR este prima care se va apela din cadrul obiectului i

are un dublu rol:
dupa apelul ei, relativ Ia un obiect, o metoda care apare redefinita este
apelata din cadrul obiectului pentru care s-a facut apelul constructorului i
nu din cadrul obiectului din care s-a Hicut apelul;
In cadrul metodei CONSTRUCTOR se pot face oplional $i alte operatii cum
ar fi initializari etc., motiv pentru care in antetul unui constructor se pot pune
parametri ca Ia orice alta metoda.
Observatii:
metodele CONSTRUCTOR nu pot fi redefinite;

datele din cadrul obiectelor nu pot fi redefinite.
in continuare se prezinta cele doua obiecte numar $i numar1 realizate dupa
cele spuse mai sus.
unit obpollll;
interface
type numar=object
nr:integer;
constructor init;
procedure cit;
procedure tip;virtual;
procedure adun;
end;
implementation
constructor numar.init;
begin
end;
begin
write('numar= );
readln(nr)
end;
begin
writeln('numar=,nr)
end;
procedure numar.adun;
begin
nr:=nr+l;
tip
end;
end.
unit obpol211;
interface
uses obpollll;
constructor init;
procedure tip;virtual;
end;
implementation
constructor numarl.init;
begin
end;
begin
writeln('numarl=',nr);
end;
end.
in programul care urmeaza se verifica cele prezentate. Metoda a dun

apeleaza metoda cit a obiectului numar1.
program tpol2;
uses obpol211;
var a:numarl;
begin
a.init;
a.cit;
a.adun
end.
Programul urmator verifica faptul ca dupa apelul unui alt constructor se

anuleaza efectul primului apel de constructor !?i se selecteaza metoda redefinita
corespunzatoare obiectului pentru care s-a facut ultimul apel.
program tpoll;
uses obpollll,obpol211;
var a:numar;
b:numarl;
begin
a.init;
a.cit;
a.adun;
b.init;
b.cit;
b.adun
end.

6.10. 1. Proceduri, functii, unitali de program, obiecte
Pentru toate problemele In care se solicita scrierea unei proceduri sau func ii
se va da i un exemplu de apel al acestora din cadrul programului principal.
1. Sa se scrie o procedura care aduna doua numere reale.

2. Sa se scrie o functie de tip intreg care inmulte!?te doua numere intregi.
3. Sa se scrie o procedura care aduna doi vectori cu acelai numar de

elemente i intoarce rezultatul intr-un vector.
4. Sa se scrie o functie care returneaza maximul dintr-un vector de numere
reale.
5. Sa se scrie o procedura care sorteaza crescator elementele de pe
diagonala principala a unei matrice patratice.
6. Sa se scrie o functie booleana care returneaza TRUE daca un element citit
se gase!?te intr-un vector sortat crescator.
7. Sa se citeasca doua matrice i sa se faca suma lor. Programul se va

realiza astfel:
se scrie o procedura de citire a unei matrice cu m linii i n coloane;
se scrie o procedura de tiparire a unei matrice cu m linii i n coloane;
se scrie o procedura care aduna doua matrice;
programul principal rezulta din apelul acestor proceduri.
8. Sa se calculeze coeficientii polinomului P(x) = (x + a)n. Programul va
utiliza o procedura care inmultel?te un polinom oarecare
de grad
k
(coeficientii dati intr-un vector) cu polinomul x+a.
9. Se citesc m i n intregi. Sa se tipareasca fraqia ireductibila m/n.
Programul va utiliza o functie de tip INTEGER care returneaza c.m.m.d.c. a
doua numere.
10. Sa se tipareasca toate numerele prime af!ate intre doi intregi cititi.
Programul va folosi o functie booleana care returneaza daca un numar este
prim sau nu.
11. Scrieti un program care tipare te numerele intregi gasite intre doua vi'llori
citite care se divid cu suma cifrelor lor. Programul va utiliza o functie care
returneaza suma cifrelor unui numar intreg primit ca parametru.
12. Sa se scrie o procedura care permuta doua linii ale unei matrice
patratice.
13. Sa se scrie o procedura care permuta doua coloane ale unei matrice
patratice.
14. Sa se scrie un program care sorteaza descresciHor elementele situate pe
diagonala secundara a unei matrice patratice prin permutari de linii !?i coloane.
Programul va utiliza procedurile de Ia problemele 1 2 i 1 3.
15. Scriei o procedura care sorteaza descrescator un vector.

Problemele 1 6-1 9 vor fi rezolvate exclusiv prin folosirea de proceduri !?i
funqii. Mai clar, problema se descompune in subprobleme. Fiecare subproble
ma va fi rezolvata de o procedura sau func ie. Programul principal va rezulta
din apelul acestor proceduri i funqii. Exemplu problema 16.
16. Se citesc doua polinoame de grade m i n (coeficientii fiecarui polinom
se citesc intr-un vector). S3 se afi eze coeficien ii polinomului suma.
Pentru a realiza programul sunt necesare urmatoarele proceduri:
procedura de citire a unui polinom de parametri n (gradul polinomului) i p
(vectorul In care se citesc coeficientii);

procedura de adunare a doua polinoame (de fapt se aduna coeficientii) cu
parametri formali m !?i n (gradele celor doua polinoame), p, q, r, trei vectori
cu semnificatia de polinoame (r polinomul rezultat);
procedura de tiparire a unui polinom.
Programul principal realizeaza urmatoarele:
cite!?te gradul primului polinom !?i apeleaza procedura de citire a polinor.1ului;
cite!?te gradul celui de-al doilea polinom !?i apeleaza procedura de citire a
polinomului;
apeleaza procedura de adunare a doua polinoame;
apeleaza procedura de tiparire a rezultatului.
Observatie. Este bine sa ne obi!?nuim sa
prezentat. Problema pe care o avem
subprobleme care se rezolva cu ajutorul
subproblema este dificila se descompune
metoda se nume!?te TOP DOWN.
rezolvam problemele ca In exerr.plul

de rezolvat se descompune In
procedurilor sau functiilor. Daca o
!?i ea In alte subprobleme. Aceasta
17. Cititi doua polinoame de grade m !?i n !?i calculati polinomul produs.
18. Cititi un polinom F de gradul n !?i m valori reale a 1, a2, ..., am. Calculati
valoarea polinomului pentru cele m valori citite.
19. Se citesc 3 valori a, b, n (a !?i b reale, n lntreg). Se cere sa se calculeze

valoarea unei functii F (definita pe intervalul [a,b]) In cele n + 1 puncte rezultate
din lmpartirea intervalului [a,b] In n parti egale. Functia F va fi data sub forma
unui subprogram de tip funqie.
20. Sa se creeze o unitate de program care contine 3 subprograme de tip
funqie. Fiecare din aceste subprograme calculeaza valoarea urmatoarelor
funqii (definite pe R) lntr-un punct :
x 1 1 , daca x :5 - 3 ;
1
a) F(x)='j 3*X. daca -3<X<=100;
1
5, daca x > 100

b) G(x)
= sin(x) +
c) H(x)
= 10
cos(X)*COs(2*x);
* {x} (am notat prin {x} partea fractionara a lui x).
21. Sa se scrie o procedura care calculeaza valorile uneia din cele trei funqii
din problema 20 In cele n + 1 puncte rezultate din lmpaqirea intervalului [a,b]
In n paqi egale.
lndicatie. Procedura va avea un parametru formal de tip functie.
22. Sa se scrie o unitate de program care contine urmatoarele proceduri !?i
funqii utile In calculul cu matrice:
procedura de citire a unei matrice cu m linii !?i n coloane;
procedura de tiparire a unei matrice cu m linii !?i n coloane;
procedura de interschimbare a doua linii ale unei matrice;

procedura de interschimbare a doua coloane ale unei matrice;
functie intreaga care intoarce numarul componentelor pozitive ale unei
matrice;
functie reala care intoarce valoarea maxima dintre toate componentele unei
matrice.
Unitatea va contine !?i definitia tipului matrice.
23. Scrieti un program care utilizeaza o parte din subprogramele din pro
blema anterioara. Apelarea acestora se va face din cadrul unitatii de program.
24. Scrieti un program care creeaza o inregistrare (de tip RECORD) care are
urmatorul continut:
nr de tip integer (retine un numar intreg);
o variabila de tip procedura numita CIT care va contine o procedura ce
cite!?te un numar intreg (de fapt adresa catre o astfel de procedura);
o variabila de tip procedura numita TIP care contine o procedura ce tipare!?te
un numar intreg.
Considerati doua variabile de tipul descris anterior. Cu ajutorul lor cititi !?i
tipariti doua numere intregi. Nu gasiti o mare asemanare intre acest mod de
lucru !?i variabilele obiect? $i o variabila de tipul de date creat acum !?i o
variabila de tip obiect contin date !?i proceduri (metode).
25. Creati un obiect numit MATRICE. Acesta va contine urmatoarele date
l?i metode:
N - numarul de linii ale matricei; M - numarul de coloane ale matricei;
MAT - o structura de tip matrioe cu elemente numere reale;
CIT - o metoda care cite!?te o matrice;
TIP- o metoda care tipare!?te o matrice.
Observatie. Cele doua metode vor fi preluate din unitatea de program creata
Ia problema 22. De fapt, in dezvoltarea aplicatiilor se scriu intai unitati de
program care contin diverse subprograme utile !?i cu ajutorul acestora se scriu
diverse obiecte, care apoi se mol?tenesc, !?.a.m.d.
26. Scrieti o procedura care aduna doua variabile de tip MA TRICE.
27. Creati un obiect numit ABSOLVENT care contine urmatoarele:
Numele bsolventului (string[30]);
Situatia !?Colara - o matrice in care liniile reprezinta cei 4 ani de studiu iar
coloanele notele obtinute de acesta Ia diverse materii, in ordinea in care
acestea au fost trecute in catalog;
o metoda in care se cite!?te situatia !?COiara;
o metoda de tiparire a situatiei;
o metoda care calculeaza media generala pe diveri ani de studiu;
o mete:da care calculeaza media generala;
o metoda care valideaza notele (sa fie intre 5 si 1 0).
Se cere ca acest obiect sa mo!?teneasca obiec.tul MATRICE.
28. inzestrati obiectul creat Ia problema 27 cu o alta metoda de tiparire a
situatiei !?Colare (mai eleganta decat tiparirea unei matrice) i care are acela i
nume cu metod3 care tipare!?te matricea. Cum putem selecta dupa dorinta, o
metoda sau alta de tiparire?

29. Creati un obiect numit NUMAR_MARE. Acesta va con ine urmatoarele:
un vector care re ine numarul (pe cifre);
o procedura care citel?te de Ia tastatura (pe cifre) un astfel de numar;
o procedura care tipare!?te un astfel de numar;
30. Scrieti o procedura care are ca parametri formali trei variabile de tip
NUMAR_MARE. Procedura aduna doua numere mari !?i returneaza rezultatul.
31. Scrieti o procedura care Tnmultel?te un NUMAR_MARE cu un numar Tntre
0 !?i 9.
32. Utilizand procedura de Ia problema 30, scrieti o procedura care
Tnmulte!?te con inutul a doua variabile de tip NUMAR _MARE.
33. Cum ati concepe !?i programa un obiect
coeficientii acestuia sa fie numere reale?
numit POLINOM, in care
Capitolul 7
Unitatea de program CRT

7.1. Memoria video
De regula, informatiile pe care ni le trimite calculatorul se afiseaza pe
monitor. Ne-am intrebat ,oare de unde se preiau aceste imagini?" cele ce
urmeaza raspundem Ia aceasta intrebare.
Exista o memorie cu un rol special numita memorie video. Monitorul extrage
in permanenta din aceasta memorie imaginile pe care le reprezinta. Orice modi
ficare survenita in continutul memoriei video se reflecta pe ecran. Memoria vi
deo se afla plasata fizic pe adaptor. Calculatoarele compatibile IBM utilizeaza
mai multe adaptoare (CGA, EGA, VGA). lntrucat i cele mai noi adaptoare
suporta modul de lucru CGA (Color Graphics Adapter), acesta va fi luat d,eJlt
model in cadrul acestui capitol.
lnterfata CGA lucreaza in dpua regimuri: text !?i grafic. In acest capitol ne ocu
pam exclusiv de regimul text. In acest regim se pot afi:;;a numai caractere. Adresa
memoriei video este $b800:0. Cunoa!?terea acestei adrese permite programatorului
sa lucreze direct in memoria video (cu alte cuvinte sa ii gestioneze singur
imaginea). Ecranul vazut de noi se imparte in 25 de linii si 80 de coloane. Orice
caracter se afiseaza lntr-o anumita linie si o anumita colo.ana. In memoria video,
pentru fiecare 'caracter se utilizeaza dof octeti. intr-unul din ei se retine codul
caracterului iar In celalalt se retin atributele grafice. Ce intelegem prin acestea?
Spatiul de afi!?are a unui caracter (un patratel) are o anumita culoare (se
nume!?te culoare de fond). La randul sau, !?i caracterul se afi!?eaza cu o anumita
culoare. lnformatiile referitoare Ia aceste culori se gasesc retinute pentru
fiecare caracter intr-un octet. Structura acestuia (pe biN este urmatoarea:
BFFFCCCC. Cei 4 biti, notati cu C, retin culoarea de afi are a caracterului.
Rezulta ca avem Ia dispozitie 16 culori, codificate de Ia 0 Ia 1 5. Culoarea de
fond se reprezinta pe 3 biti notati F (avem Ia dispozitie 8 culori de fond, codifi
cate de Ia 0 Ia 7). Bitul B indica afi!?area continua (valoarea 0) sau intermitenta
(valoarea 1). Orice culoare rezulta ca amestec de ro u, verde i albastru, iar
pentru culorile caracterelor poate diferi !?i intensitatea.
Culorile ce pot fi utilizate se gasesc in tabelul de mai jos:
Culoarea
RO j U
Verde
Albastru
Valoare
Intens
Negru (Black)
Albastru (Blue)
Valoare
lntens
Ro u
Verde
Albastru
Verde (Green)
Turcoaz (Cyan)
Rou (Red)
Violet (Magenta)
Maro (Brown)
Gri deschis (LightGray)
Vernil (LightGreen)
10
Bleu deschis (LightCyan)
11
Roz (LightRed)
12
Violet deschis (LightMagenta)
13
Galben (Yellow)
14
Alb (White)
15
Culoarea
Gri inchis (DarkGray)

Bleu (LightBiue)
..
Fondul poate avea numai primele 8 culori din tabel.

Pentru a putea Iuera direct in memoria video, o declaram ca masiv cu 25
de linii, 80 de coloane, i doi octei pentru fiecare caracter, cerand in acela!?i
timp
ca spa iul pentru aceasta variabila sa fie in zona de memorie video (clauza
absolute).
Tn programul urmator intreaga memorie video se umple cu 'x'. Observa i

efectul pe ecran.
program mv1;
type mv =array[1..25,1..80,1.. 2] of char;
var ecran: mv absolute $b800:0;
i,j:integer;
begin
for i:=1 to 25 do
for j:=1 to 80 do ecran[i,j,1]:=x
end.
De multe ori este necesar sa adresam octe ii memoriei video in doua moduri:
ca octeti care retin caractere;
ca octei care re in numere.
: Din acest motiv se face o dubla declarare a memoriei video (este numai una
din modalita i). in programul urmator, se umple memoria video cu spa ii (pe
fond negru) !?i se scrie in prima linie !?i prima coloana caracterul 'a'. Scrierea se
face negru, pe fond 8lb. Pentru aceasta scriere, octetul de atribute culoare ia
valoarea 112 (01110000).
program mv2;
type mv=array[1.25,1.80,1.2] of char;
mvb=array[1..25,180,1..2] of byte;
var
ecran: mv absolute $b800:0;
ecran1:mvb absolute $b800:0;
i,j:integer;
begin
for i:=1 to 25 do
for j:=1 to 80 do
begin
ecran1[i,j,2]:=0;
ecran[i,j,l] :=' ';
end;
ecran1[1,1,2]:=112;
ecran1,1,1]:='a';
end.
7.2. Ferestre
0 fereastraJeprezinta o portiune dreptunghiulara a ecranului in care se fac
citiri !?i scrieri. lntreg ecranul este o fereastra implicita (daca nu se declara alte
ferestre). Procedurile si functiile unitatii CRT se refera Ia o anumita fereastra
(cea care este activa (a un moment dat).
Observatie: o singura fereastra este activa Ia un anumit momen .
Deschiderea unei ferestre se face utilizand procedura WINDOW care are
forma urmatoare:
WINDOW (x1,y1,x2,y2).
Perechile (x1,y1), (x2,y2) reprezinta coordonatele colturilor din stanga sus
i dreapta jos. Este de mentionat faptul ca x1, x2 reprezinta coloane i y1,y2
reprezinta linii. Coltul din stanga sus al unei ferestre are coordonatele ( 1,1 ) .
in programul f1, deschidem o fereastra.
program f1;
uses crt;
begin
window
end.
(10,10,20,20)
Daca vom analiza efectul acestui program, vom ramane surprini de faptul
ca fereastra nu este vizibila. Cu toate acestea cursorul este pozitionat in coiJul
din stanga sus al ferestrei deschise.
Faptul ca fereastra deschisa este invizibila se explica prin culoarea ei de
fond care este aceea!jii cu cea a ferestrei initiale.

Pentru precizarea culorii de fond se folose!jite procedura TEXTBACKGROUND.
TEXTBACKGROUND (culoare)
Aceasta are un singur parametru formal, !jii anume culoarea. Culoarea poate
fi data Tn doua moduri: printr-o cifra cuprinsa Tntre 0 !jii 7 (vezi tabelul din
paragraful anterior), sau printr-un cuvant Tn engleza ce exprima culoarea
(prezent Tn acela!jii tabel). Aceasta ultima forma de exprimare a culorii este
posibila Tntrucat, Tn unitatea CRT, numele culorilor au fost declarate drept
constante cu valorile codurilor respective. in programul" f2 deschidem o
fereastra Ia care stabilim culoarea de fond.
program 2;
uses crt;
begin
window (10,10,20,20);
textbackground(O)
end.
Dupa rularea lui, nu observam nimic diferit fata de modul in care a decurs
executia Tn programul anterior. Culoarea de fond devine vizibila Tn doua cazuri:
dupa rularea procedurii CLRSCR;
dupa ce am scris efectiv Tn fereastra.
Procedura CLRSCR nu are p rametri !jii are urmatoarele efecte:
umple fereastra cu blancuri (curata fereastra);
atribuie Tntregii ferestre culoarea sa de fond (declarata cu TEXTBACK
GROUND); pozitioneaza cursorul Tn coltul din stanga sus.
Prin rularea programului urmator va veti convinge de acest lucru.
program 3;
uses crt;
begin
_
window (10,10,20,20);
textbackground(3);
clrscr;
end.
Fixarea culorii cu care se scriu caracterele se face utiliznd procedura

TEXTCOLOR. Forma generala este:
TEXTCOLOR(culoare)
Parametrul culoare trebuie sa contina un numar Tntre 0 si 1 5 sau un cuvant ce
exprima aceasta culoare (vezi tab.elul).
Dupa rularea programului f4 observam urmatoarele:

fereastra nu a devenit vizibila;
cuvantul 'text' este scris pe fondul cerut !jii cu culoarea solicitata.
program 4;
uses crt;
begin
window (10,10,20,20);
textbackground(3);
textco1or(O);
write('text')
end.
Pentru a face vizibila intreaga fereastra se utilizeaza procedura CLRSCR.

program 5;
uses crt;
begin
window {10,10,20,20);
textbackground(3);
textcolor(O);
clrscr;
write('text')
end.
Exista posibilitatea ca fiecare text scris intr-o fereastra sa fie identificat prin
propriile culori de fond l?i de scriere a caracterelor. Tocmai acesta este motivul
pentru care, dupa executia procedurii TEXTBACKGROUND, intreaga fereastra
nu capata culoarea de fond solicitata.
program 6;
uses crt;
begin
window (10,10,20,20);
textbackground(3);
textcolor(O);
-:,.clrscr;
'writeln('text1');
textbackground(O);
textcolor(15);
writeln('text2')
end.
Nu exista o procedura prin care se inchide o fereastra. Prin deschiderea altei

ferestre, fereastra anterioara inceteaza de a mai fi activa (se inchide). Pentru a
o activa se folosesc din nou procedurile WINDOW, TEXTBACKGROUND,
TEXTCOLOR cu aceia$i parametri efectivi. in exemplul care urmeaza se
deschide o fereastra in care se citeste o variabila, se deschide o alta fereastra
in care acea variabila se tiparel?te, apoi se redeschide prima fereastra in care
se tipare te variabila citita.
program 7;
uses crt;
var a:integer;
begin
clrscr;
window (1,1,10,10);
textbackground(3);
textcolor(15);
clrscr; write('a='l;
readln(a);
window(ll,l1,40,25);
textbackground(2);
textcolor(7);
clrscr;
write('a=',a);
window(l,l,lO,lO);
textbackground(3);
textcolor(lS);
clrscr;
write('a=',a)
end.
in finalul acestui paragraf facem o observa ie: toate procedurile prezentate

aici (ale unita!ii CRT) lucreaza asupra memoriei video. Acest lucru 11 putem face
!?i noi, fara ajutorul lor, lnsa sa recunoa tem ca este mai u or sa le folosim pe
cele gata facute.
7.3. Alte proceduri i
functi"i specifice unitatii CRT
Pana acum, In cazul tuturor scrierilor si citirilor efectuate nu aveam un

control a supra pozi!iei cursorului. Din acest motiv rezultatele programelor
noastre nu erau estetice (obtineam rezultate corecte, lnsa scrise pe un ecran
care con!inea i lucruri care nu intereseaza In cadrul aplica iei).
Procedura GOTOXY ne scapa de astfel de inconveniente. Ea are rolul de a
pozi iona cursorul intr-o anumita pozitie.
I

GOTOXY(x,y),
unde x i y reprezinta coloana i linia de pozi ionare a cursorului.
in programul urmator se cite!?te o valoare numerica. in situa!ia in care, din
gre eala, se introduce o valoare nenumerica, aceasta este tearsa i se face o
noua citire. Noua este modalitatea de citire intr-o pozi!ie unica. Tot aici,
observam o noua procedura a CRT numita CLREOL. Forma generala a acestei
proceduri este:
CLREOL
i are rolul de a terge linia pe care se afla cursorul, incepand din pozitia
curenta a acestuia.
program a1;
uses crt;
var a:integer;
begin clrscr;
gotoxy(lO,lO);
write('dati o valoare numerica
repeat
gotoxy(35,10);
');
end.
clreol;
{$i-} read(a) {$i+}
until ioresult=O
Procedura DELLINE l?terge intreaga linie pe care se aW:i

cursorul.
Functiile
numerice
WHEREX, WHEREY (fara
parametri
formali) intorc coloana respectiv linia pe care se afla cursorul.
in programul af2 se scriu trei mesaje pe randuri diferite (saltul
de Ia un rand Ia altul se face cu GOTOXY) !?i randul din mijloc
este !jiters. Cursorul se pozitioneaza pe randul urmator.
program a2;
uses crt;
beg
i
n
c
l
r
s
c
r
;
write('am scris un
mesaj');
gotoxy(l,wherey+l
); write('scriu
alt mesaj');
gotoxy(l,wherey+l
); write('al
treilea mesaj');
gotoxy(l,wherey1);
delline
end.
Pentru citiri speciale de Ia tastatura, unitatea CRT contine

doua functii
READKEY l?i KEYPRESSED.
Functia READKEY este de tip caracter fara parametri formali
!?i lntoarce caracterul tastat. Daca in timpul executiei acestei
functii nu se apasa nici o tasta, programul a!jiteapta. Citirea
caracterului se face fara ecou (adica acel caracter nu apare pe
ecran).
Este bine sa rulam programul urmator, spre a vedea ,pe
viu" executia acestei functii.
program a3;
uses crt;
var c:char;
beg
i
n
c
:
=
r
e
a
d
k
e
y
end.
Utili
zata In
mod
intelige
nt,
aceasta
functie
se
dovede!
jite a fi
extrem
de
utila.
Multe
program
e
raman
in a!
j>teptare
pana se
apasa o
anumita
tasta.
Unele
taste
returnea
za
caracte
re cu
codul
cuprins
intr-un
octet,
altele
(special
e)
returne
aza
caracte
re cu
codul
pe doi
octeti (din care primul contine numarul 0). Sagetile (extrem de

folosite pentru realiza ea unor programe cu interfata prietenoasa)
intra in cea de-a doua categorie. In cazul caracterelor cu codul pe
doi octeti, functia returneaza numai primul octet, dar reapelata, il
returneaza !jii pe eel de-al doilea. Astfel, daca Ia primul apel codul
este 0, reapelam functia. Citirea caracterelor fara ecou constituie
de asemenea un mare avantaj (serve!jite Ia introduceri de parole
sau citirea unor taste speciale de Ia care a!jiteptam o
acriune). In programul urmator se arata cum se pot citi tastele corespunzatoare

sageTilor In sine. Programul nu realizeaza mare lucru, dar mecanismul ramane
valabil pentru secvenre mai interesante.
program a4;
uses crt;
var c:char;
begin c:=readkey;
if c=#O then c:=readkey;
case c of
#72: write ('am apasat sageata
else write('nu am apDsat sageti')
end {case}
end.
sus');
jos');
stanga');
d eapta')
FuncTia booleana KEYPRESSED, fara parametri formali, returneaza valoarea

TRUE daca a fost apasata o tasta, Tn caz contrar valoarea returnata fiind FALSE.
Este folosita in situaTii in care se ruleaza o secvenTa pana cand este apasata o
tasta. Programul urmator a teapta apasarea unei taste pentru a se opri.
program a5;
uses crt;
begin
repeat
until keypressed
end.
Observa.tie: in situaTia in care aceasta functie se reapeleaza trebuie golit

bufferul (utilizand READLN tara parametri), altfel functia returneaza valoarea
TRUE, tara ca vreo tasta sa fie apasata. De asemenea, exista taste care, chiar
apasate, nu au nici un efect asupra acestei functii (ALT, SHIFT etc.).
De multe ori, pentru avertizarea operatorului (sau in jocuri) programul
trebuie sa emita sunete. Pentru aceasta, Tn unitatea CRT se gasesc doua
proceduri SOUND !;ii NOSOUND.
Procedura SOUND este de forma:
SOUND (h:Word).
Parametrul h furnizeaza frecvena sunetelor (in Hz). Dupa apelul acestei
proceduri sunetul persista pana cand se apeleaza procedura NOSOUND.
Aceasta procedura nu are parametri !jii rolul ei este de a opri sunetullansat prin
SOUND. Procedura DELAY pune programul in a!jiteptare pentru o perioada de
timp. Forma generala a acesteia este:
DELAY(n:word).
Parametrul n exprima timpul de a!jiteptare exprimat in milisecunde.
Combinate, cele trei proceduri pot produce un sunet o anumita durata de timp.
program a6;
uses crt;
begin
sound(lOOO);
delay(2000);
nosound
end.
7.4. Aplicatii
7.4.1. Unitatea de program UTIL
in paragrafele anterioare s-a aratat modul de lucru cu ferestre. Pentru a
scrie cu U!?urinta programe in care intervin aceste ferestre vom prezenta o
unitate de program (numita UTIL) care contine o serie de proceduri utile in
acest caz. Tot aici se gasesc definite constante, o serie de caractere din codul
ASCII cu care vom Iuera des. in continuare, prezentam pe larg procedurile
continute in unitate.
7.4.1.1. Procedura DESCHID F
Are rolul de a deschide o fereastra Ia care au fost precizate culorile de fond
!?ide scriere a caracterelor. Odata deschisa, fereastra capata culoarea de fond.
Forma generala de apel pentru aceasta procedura este:
DESCHID_F (xc1,yc1,xc2,yc2,fd,cnl);
Toti parametrii sunt de tip byte, sunt transmi!?i prin valoare l?i au urmi'hoarea
semnificatie:
xc 1,yc 1 _ coordonatele coltului din stanga sus al ferestrei;
yc1,yc2 - coordonatele coltului din dreapta jos al ferestrei;
fd,cnl
- culorile de fond !?i de scriere a caracterelor.
Programul urmator deschide o fereastra utilizand aceasta procedura.
program ul;
uses util;
var a:integer;
begin
deschid f(3,3,20,20,rosu,verde);
write ('a=') i
readln(a);
end.
7.4.1.2. Procedura SCRIU F

Are rolul de a scrie un text in fereastra. Scrierea se face direct in
memoria video. in acest fel, in cazul in care se scrie in ultima linie a unei
ferestre, nu mai apare efectul de SCROLL (toate liniile urea !?i ultima linie
se elibereaza). in
scrierea meniurilor, acest lucru se dovede!jite extrem de util.

. Apelul acestei proceduri se realizeaza astfel:
SCRIU_F(sir,xc,yc,coloana,linie)
Toti parametrii sunt transmi!jii prin valoare !jii au semnificatia urmatoare:
!jiir
- un !jiir de tip STRING ce se va tipari;
xc,yc
- coordonatele coltului din stanga sus al ferestrei;
coloana,linie - coloana !jii linia din cadrul ferestrei in care va fi scris mesajul.
in programul urmator se scrie un mesaj pe ultima linie a unei ferestre ce se
creeaza.
program u2;
uses util;
var mesaj:string;
begin
deschid f(3,3,10,20,verde,rosu);
scriu ('12345678',3,3,1,18);
end.
-
Este important ca lungimea mesajului sa nu depa!jieasca numarul de

caractere ce se pot scrie pe o linie (procedura nu efectueaza acest control).
Cum s-a realizat aceasta procedura? Dispunem de coordonatele coltului din
stanga sus al ferestrei. Aceste coordonate sunt acelea!jii !jii in cazul in care ne
adresam direct memoriei video. Punctul de coordonate (coloana,linie) in cadrul
ferestrei va
avea coordonatele (xc + coloana-1,yc + coloana-1) in
cadrul
ecranului. Astfel, punctul de coordonate ( 1,1) in cadrul ferestrei va avea
coordonatele (xc,yc) in ecranul complet, pu.[lctul din colo ma 2 !jii linia 3 va
avea coordonatele absolute (xc + 1,yc + 2). lncepand din punctul ales, dupa
conversia coordonatelor, !jiirul se copiaza caracter cu caracter pe linie.
Urmatoarele proceduri ce vor fi prezentate se vor dovedi utile atunci cand
scriem rutine pentru meniuri. in ce constau acestea?
Unele programe pot efectua mai multe operatii, dupa dorinta utilizatorului.
Exista forme primitive da solicita optiunea (de exemplu o cifra) sau forme
evoluate (prin meniuri). In acest din urma caz, programul afi!jieaza un tablou
dreptunghiular in care sunt scrise optiunile. Optiunea luata in consideratie este
scrisa in video invers (vom vedea o bara luminoasa deasupra ei). Cu ajutorul
sagetilor se poate lua in consideratie orice optiune (prin deplasarea acelei bare
luminoase). In momentul in care tastam ENTER, programul executa optiunea
pe care este plasata bara luminoasa. Daca se tasteaza ESC, inseamna. ca nu
ne-am hotarat asupra vreunei optiuni. in acest caz fereastra se inchide.
-,
7.4.1.3. Procedura A D BARA

Are un dublu rol:
in situatia'in care se dore!jite aparitia barei luminoase deasupra unei optiuni;
in situatia in care bara este prezenta !jii se dore!jite ca ea sa dispara.
Modalitatea de apel este urmatoarea:
A_D_BARA(xc,yc,coloana,linia,lungime).
Toti parametri formali sunt de tip byte !jii au semnificatia:
(xc,yc)
- coordonatele coltului din stanga sus al ferestrei de meniu;
(coloana,linia)
- coordonatele primului caracter caruia i se vor inversa
atributele de culoare;
lungime
- numarul de caractere pentru care se inverseaza atributele de
culoare (lungimea barei).
Care este principiul de lucru al acestei proceduri? Aparitia barei luminoase
se face prin inversarea culorilor de fond !jii de scriere a caracterelor (ne aducem
aminte ca pentru fiecare caracter ce apare pe ecran exista in memoria video un
octet care retine atributele de culoare) iar daca bara este prezenta, reinversarea
culorilor va duce Ia disparitia ei.
Pentru a realiza inversarea culorilor se procedeaza astfel:

se identifica primul caracter pentru care trebuie reiversate culorile
(mecanismul de identificare este identic cu eel folosit in procedura
SCRIU F);
din informatia continuta de octetul de atribute al acestui caracter se
identifica ce'le doua' culori:
o culoarea de scriere (ultimii 4 biti ai octetului) reprezinta restul impartirii
Ia 1 6 a numarului continut In octet;
o culoarea de fond (de Ia bitul al doilea pana Ia bitul al patrulea) se obtine
izoland continutul primilor 4 biti (catullntreg din impartirea Ia 16) i prin
izolarea din cadrul acestuia a informatiei continute In ultimii 3 biti (restul
lmpaqirii Ia 16);
se construie te noul octet de atribute prin lnmultirea cu 16 a numarului care

reprezenta culoarea Ia care se adauga numarul care reprezinta fondul (in
acest fel numarul ce reprezenta culoarea va ocupa primele 4 pozitii din octet
i numarul ce reprezenta fondul ultimele pozitii);
operatiile descrise se fac pentru toate caracterele ce se afla pe lungimea
barei, lncepand cu primul.
Observa,tie: pentru a reu!jii inversarea, pentru ambele culori se folosesc numai
coduri intre 0 !jii 7.
7.4.1.4. Procedura PLIMB BARA V

Are rolul de a deplasa bara I!;Jminoasa a supra meniului de sus in jos i invers
cu ajutorul sagetilor (sus, jos). In situatia in care se da comanda sus A!?i bara se
afla plasata pe prima pozitie (de sus), ea va aparea In ultima pozitie. In situatia
in care bara se afla plasata pe ultima pozitie !?i se da comanda jos, ea va aparea
pe prima pozitie (bara se deplaseaza circular). Aceasta procedura se activeaza
numai In situatia In care bara luminoasa este prezenta deasupra unei optiuni
(initial se activeaza A_D_BARA pe prima opJiune). Procedura returneaza trei
valori si anume:
(xb:yb) coordonatele unde a ramas bara atunci cand s-a tastat ENTER sau
ESC;
codul ENTER sau ESC.
Cu aceste informatii se decide in programul care utilizeaza aceste proceduri
ce este de facut !jii anume:
daca s-a tastat ESC fereastra se inchide;

daca s-a tastat ENTER, se analizeaza coordonatele xb, yb spre a vedea care
anume optiune a fost ceruta pentru ca programul sa o execute.
Analiza
modului de realizare a acestei proceduri ramine in seama
cititorului. Apelul se realizeaza prin:
PLIMB_BARA_V(x1,y1,x2,y2,1ung,xb,yb,c);
Toti parametrii formali sunt de tip byte. Ultimii trei parametri sunt transmi!jii
prin referinta (se declara cu var in blocul apelator). restul sunt transmi!jii prin
valoare. Semnificatia lor este urmatoarea:
(x1,y1) - coordonatele coltului din stanga sus al ferestrei;
(x2,y2) - coordonatele coltului din dreapta jos al ferestrei;
lung
- lungimea barei;
xb,yb
- coordonatele primului caracter al barei (se transmit Ia apel coordo
natele initiale !jii se regasesc Ia revenirea in program coordonatele
primului punct in care a ramas bara);
c
- codul caracterului cu care s-a revenit Tn blocul apelator (poate fi
ENTER sau ESC).
7.4.1.6. Procedura PLIMB -BARA -0
Are rolul de a plimba bara pe directie orizontala (se utilizeaza in cadrul
meniurilor orizontale). Se apeleaza prin:
PLIMB_BARA_O(x1,y1,x2,y2,1ung,p,xb,yb,c);
x1,y1,x2,y2,1ung,xb,yb,c - au aceea!jii semnificatie !jii sunt de acela!jii tip cu
cei prezentati Ia procedura anterioara;
p - se transmite prin referinta, este de tip byte !jii permite ca intre doua
aparitii cosecutive ale barei sa se sara un numar de caractere (acest numar
trebuie incarcat in p Ia apelul procedurii).
7.4.1.6. Procedura CURSOR
Are rolul de a face sa apara sau sa dispara cursorul (este lipsit de eleganta
ca Tn cadrul unui meniu cursorul sa fie prezent).
Se apeleaza prin
CURSOR(TRUE) sau CURSOR(FALSE).
Primul caz duce Ia aparitia cursorului iar Tn eel de-al doilea caz - Ia
disparitia lui.
Modul de realizare a acestei proceduri depa!jie!jite cadrul
acestui manual. Procedura este prezentata pentru utilitatea ei.
in partea de implementare a unitatii de program se gase!jite !jii functia de tip
byte CODUL. Aceasta functie are rolul de a citi codul unei taste apasate !jii este
utilizata de celelalte proceduri ale unitatii. La prezentarea procedurii READKEY
s-a explicat modul in care se cite!jite codul unei taste apasate; aceasta
procedura nu face altceva decat sa concretizeze cele deja aratate.
in continuare, vom scrie un program care folose!jite un meniu simplu de tip
vertical.
program u3;
uses util,crt;
var xb,yb,c:byte;
begin
deschid f(50,20,53,23,rosu,negru);
seriu f('opt1',50,20,1,1);
scriu-f('opt2',50,20,1,2);
scriu-f('opt3',50,20,1,3);
scriu-f('opt4',50,20,1,4);
cursor(false);
ad bara(50,20,1,1,4);
xb:-;1; yb:=1;
plimb bara v(50,20,53,23,4,xb,yb,c);
desehid f(l,l,80,25,negru,alb);
cursor(true);
gotoxy(1,1);
if c=enter then
case yb of
1: writeln('optiunea 1');
4: writeln('optiunea 4')
end {ease}
end.
Se deschide o fereastra cu 4 linii !?i 4 coloane. Se va scrie cu negru pe un

fond ro!?u. Procedam astfel:
se scriu cele 4 Opliuni posibile cu ajutorul procedurii SCRIU_F:
se elimina aparilia cursorului prin apelul procedurii CURSOR;
se activeaza bara luminoasa pe prima linie a meniului (A D BARA);
se activeaza procedura PLIMB BARA V pe prima linie !?i coloana a ferestrei;
in cazul in care s-a tastat ENTER se deschide o alta fereastra ce marcheaza
intreg ecranul :;;i se scrie ce opliune a fost selectata (un program complex,
in acest punct, ar fi activat subprogramele care efectuau operalia selectata
de utiIizator).
lata unitatea de program ce a fost prezentata:
unit util;
interface
eonst
sus jos =72;
dreapta =80;
stanga =77;
enter
=75;
=13;
esc
=27;
colt s s
=
eolt_d_s
=
colt-d-j
=
colt-a-j
=
orizontal
=
vertical
=
vertical1
=
orizontal1 =
#201;
#187;
#188;
#200;
#205;
#186;
#179;
#196;
colt s s1
= #218;
co1t-s-j1
= #192;
co1t-d-s1
= #191;
colt d j1
#217;
Negru=O; Albastru=l; Verde=2; Bleu=3; Rosu=4; Mov=S; Maro=6;
GriDeschis=7; Griinchis=8; AlbastruDeschis=9; VerdeDeschis=10;
BleuDeschis=ll; RosuDeschis=12; RozDeschis=13; Galben=14;
Alb=15; Clipitor=16;
procedure deschid f(xc11yc11 XC21 yC21 fd1 cn1:byte);
.
procedure
scriu
f(sir:string;XC1
YC1
Coloana1
linie:byte);
procedure
ad
bara(xc
yclcoloanalliniellung:byte);
procedure pfimbbara v(x11y11 X21 y21 lung:byte;var xb1yb1c:byte);
procedure plimb-bara o(x11y11x21y21lunglp:byte1var
.
xb I yb 1 c:bytef j
procedure cursor(afisare:.boolean);
implementation
uses CRT1DOS;
type aleg=(caracter atribute);
var ecran :array[1251 1.801 caracteratribute] of char
absolute $b800:0;
ecran1 :array[l..251 1..801 caracteratribute] of
byte
absolute $b800:0;
procedure deschid ;
begin
Window(xc11yc1 xc21yc2);
TextBackground(fd);
TextCo1or(cnl);
clrscr
end;
procedure scriu f;
var x1y1i:byte;
begin
x:=xc+coloana-1;
y:=yc+linie-1;
for i:=O to length(sir)-1 do ecran[y1 X+i1 caracter]:=sir[i+1];
end;
procedure a_d_bara;
var
ilxlylcnl1fd:integer;
begin
X::XC+COloana-1;
y:=yc+1inie-1;
cnl:=ecran1[yx1 atribute] mod 16;
fd:=(ecran1[y x atribute] div 16) mod 8;
for i:=O to lung-1 do
ecran1[ylx+ilatribute]:=cnl*16+fd;
end;
function codu1:byte;
var c:char;
begin
c:=readkey;
if ord(c)=O then,c:=readkey;
codul:=ord(c)
end;
procedure plimb_bara_v;
begin
repeat
c::codul;
case c of
sus: if yb=l then
begin
ad bara(x1,yl,xb,yb,lung);
yb:-;y2-y1+1;
ad bara(x1,yl,xb,yb,lung)
end-else
begin
ad bara(x1,y1,xb,yb,lung);
yb:-;yb-1;
a d bara(x1,y1,xb,yb,lung)
end;- jos: if yb=y2-y1+1 then
begin
yb:-;1;
a d bara(x1,y1,xb,yb,lung)
end - else
begin
ad bara(xl,y1,xb,yb,lung);
yb:;yb+l;
ad bara(x1,y1,xb,yb,lung)
end;- end; {case}
until (c=esc) or (c=enter);
end;
procedure plimb bara o;
begin
repeat
c:=codul;
case c of
stanga: if xb=l then
begin
ad bara(xl,y1,xb,yb,lung);
xb:;x2-xl-lung+2;
a d bara(x1,yl,xb,yb,lung)
end-else
begin
xb:;xb-lung-p;
ad bara(x1,y1,xb,yb,lung)
end;-
dreapta:
if xb+lung-2 = x2-xl then
begin
ad bara(xl,yl,xb,yb,lung);
xb:;l;
ad bara(x1,yl,xb,yb,lung)
end-else
begin
ad bara(xl,yl,xb,yb,lung);
xb:;xb+lung+p;
a d bara(xl,yl,xb,yb,lung)
end;- end; {case}
until (c=esc) or (c=enter);
end;
procedure cursor;
var r:registers;
begin
r.ah:=l;
if afisare then
begin
r.ch:=6;
r.cl:=7;
end
else
begin
r.ch:=32;
r.cl:=7
end;
intr(16,r);
end;
end.
7.4.2. Fereastra obiect

Pana acum am invatat sa construim o fereastra. De asemenea, avem si
proceduri care U!jiUreaza' mult programarea in cazullucrului cu ferestre. De ce
nu am avea !jii o fereastra obiect? In acest mod, o fereastra va fi pentru
progra mul nostru o variabila.
Ca orice obiect, obiectul FEREASTRA va contine date !jii metode. Datele
sunt urmatoarele:
nr f reprezinta numarul ferestrei;
XCS,yCS,XCj,ycj SUnt COOrdonatele COiturilor din Stanga SUS l?i dreapta jos ale
ferestrei;
fond,culoare - culorile de fond si de scriere a caracterelor;
tip f- reprezinta tipul ferestrei (0- fereastra tara chenar, 1 - fereastra cu
chenar simplu, 2 - fereastra cu chenar dublu);
xcursor,ycursor- pozitiile curente ale cursorului;
vizibil - variabila booleana care retine daca este vizibil sau nu cursorul.
Metodele continute de obiectul FEREASTRA sunt urmatoarele:
7 .4.2.1. Metoda
DESCHID Se apeleaza
astfel:
nume variabila.DESCHID(x1,y1,x2,y2,fd,cl,n,tip,vizibil);
Parametrii au urmatoarea semnificatie:
x1 ,y1,x2,y2: coordonatele colturilor din stanga sus !jii dreapta jos ale
ferestrei;
fd,cl - culorile de fond !?i cerneala;
n - numarul ferestrei;
tip - tipul ferestrei (fara chenar- 0, chenar simplu- 1,chenar dublu - 2);
vizibil - parametru ce precizeaza daca este vizibil sau nu cursorul in fereastra.
Cu exceptia ultimului parametru (care este de tip boolean) restul sunt de tip
byte. Toti parametrii sunt transmi!?i prin valoare.
7.4.2.2. Metoda SALVEZ
Are rolul de a salva continutul unei ferestre (salvarea se face in memoria
interna a calculatorului; de fapt se salveaza intregul ecran pentru a nu pierde
:?i contextul in care se gase:?te fereastra). Se apeleaza prin:
nume variabila.SALVEZ
7.4.2.3. Metoda RESTAUREZ
Are rolul de a reface o fereastra pe ecran (o aduce din locul de unde a fost
salvata). Apelui se face prin:
nume variabila.RESTAUREZ.
Mecanismul de realizare al ultimelor doua proceduri il vom invata anul
urmator.
Programul urmlHor exerr.plifica lucrul cu acest obiect 9i realizeaza:
se declara doua variabile de tip fereastra;
pentru intreg ecranul se stabile9te fondul negru !?i culoarea de scriere a
caracterelor- alba.
se deschide o fereastra pe care se scrie o linie (fereastra are chenar simplu
iar cursorul este prezent);
e aceasta fereastra se salveaza;
se deschide o alta fereastra cu chenar dublu in care cursorul nu este prezent;
se scrie prima linie a acestei ferestre;
se restaureaza prima fereastra.
program ferl;
uses fers,util,crt;
var a,b:fereastra;
begin
textbackground(negru);
textcolor(alb);
clrscr;
a.deschid(l,l,S,S,negru,rosu,l,l,true);
write(l,2,3);
delay(3000);
a.salvez;
b.deschid(l,l,lO,lO,rosu,negru,2,2,false);
write(1,2,3,4,5,6,7,8);
delay(3000);
a.restaurez;
end.
in continuare se prszinta unitatea ce Contine obiectul FEREASTRA.

unit fers;
interface
type ecran=array[l..25,1.80,12] of byte;
type ref=Aecran;
fereastra=object
nr f,xcs,ycs,xcj,ycj,fond,tip f,
cuioare,xcursor,ycursor:byte;
viz:boolean;
procedure deschid (xl,yl,x2,y2,fd,cl,n,
tip:byte;vizibil:boolean);
procedure salvez;
procedure restaurez;
end;
implementation
uses util,crt;
var v:array[l9]
of ref;
procedure fereastra.deschid;
var i:integer;
begin
nr f:=n;
tip_f:=tip;
xcs:=xl;
ycs:=yl;
xcj:=x2;
ycj:=y2;
fond:=fd;
culoare:=cl;
viz:=vizibil;
cursor(vizibil);
deschid f(xl,yl,x2,y2,fd,cl);
if tip >0 then
begin
if tip=l
then write(colt s all
else write(colt-s-s);
for i:=2 to xcj-xcs do
begin
gotoxy(i,l);
if tip=l
then write(orizontall)
else write(orizontal);
gotoxy(i,ycj-ycs+l);
if tip=l
then write(orizontall)
else write(orizontal);
end;
gotoxy(xcj-xcs+l}l);
if tip=l
then write(colt d sl)
else write(colt-d-s);
for i:=2 to ycj-ycs do
-begin
gotoxy(l,i);
if tip=l
then write(verticall)
else write(vertical);
gotoxy(xcj-xcs+l,i);
,
if tip=l
then write(verticall)
end;
else write(vertical);
gotoxy(l,ycj-ycs+l);
if tip=l
then write(colt s jl)
else write(colt-s-j);
if tip=l then scriu f(colt djf:.xcs,ycs,xcj-xcs+l,ycj-ycs+l)
else scriu-f(colt-dj,xcs,ycs,xcj-xcs+l,ycjycs+l);
deschid f(xcs+l,ycs+l,xc]-l,ycj1,3,7);
,i7
end;
end;
proced
ure
ferea
stra.
salve
z; var
b:ecra
n
absolu
te
$b800
:0;
begin
new(v[nr ]);
v[nr f]...:=b;
xcursor:=wherex;
ycursor:=wherey;
end;
procedu
re
fereas
tra.re
staure
z; var
b:ecran
absolut
e
$b800:
0;
begin
b:=v[nr ] ... ;
dispose(v[nr ]);
window(xcs+l ycs+l,xcj-l,ycj-1);
gotoxy(xcursor,ycursor);
cursor(viz);
end;
end.
7
.
4
.
3
. Meniul
obiect
Pentru
scrierea cu
U!?Urinla a
meniurilor, In
cele ce
urmeaza e
prezinta
obiectul MEN
(obiect de tip
meniu) care
se gase!?te
plasat in
unitatea
MENU. Acest
obiect
mosteneste
obiectul
FEREASTRA
(deci toate
datele si
metodele
prezentate In
cadi-ul acelui
obiect se
regasesc aici).
Tn plus, acesta
a're alte date
!?i metode.
Datele noi
sunt:
xb,
yb:
coordonat
ele
In
cadrul
ferestrei
ale
primului
caracter
al
barei
luminoase;
lung, hi:
lungimea !?i
inaltimea
ferestrei de
meniu;
rasp:
raspunsul
operatorului in
cadrul
selecliei
(ENTER sau ESC);

lbar: lungimea barei luminoase.
Prezentam noile
metode ale
obiectului MEN.
Metoda DESCHID
Mare urmatoarele
functii:
construieste meniul;
.
activeaza.bara luminoasa pe prima optiune a
acestuia;
permite operatorului sa manipuleze bara
asupra
optiunilor !?i
intoarce raspunsul
acestuia (selectie !?i ce anume s-a selectat
(ENTER) sau lipsa seleqiei (ESC)).
Daca Tnaltimea ferestrei de meniu este 1,
meniul se considera orizontal, In
caz contrar meniul este vertical. Apelul metodei se realizeaza astfel:

nume variabila.deschidm(x1,y1,1,h,fd,cl,n,lb,a,vizibil);
Toti parametrii se transmit prin valoare. Primii 8 para-metri sunt de tip byte,
parametrul a este de tip string, parametrul vizibil este boolean. Semnificatia
parametrilor este urmatoarea:
x1, y1 -- coordonatele coltului din stanga sus al ferestrei meniu;

I, h - lungimea !?i inaltimea ferestrei meniu;
fd,cl - culorile de fond !?i de scriere a caracterelor;
n - numarul ferestrei meniu;
lb - lungimea barei luminoase;
vizibil - parametru ce precizeaza daca se vede sau nu cursorul.
Precizam faptul ca, Tn cazul unui meniu vertical, !?irul de tip string ce contine
optiunile se imparte automat intr-un numar de parti egale ca lungime. Numarul
de parti este dat de numarul de linii din meniu.
Am invatat faptul ca nu este permis sa se acceseze datele din cadrul unei
variabile obiect deci.H prin intermediul metodelor pe care le are obiectul. Astfel
am Tnzestrat obiectul cu urmatoarele metode de tip functie:
SELECT AT - functie booIeana ce specifica daca revenirea din selectie sa facut prin ENTER:
iNCHIS- functie booleana ce specifica daca revenirea din seleqie s-a facut
prin ESC (de fapt ar putea exista o singura functie, intrucat dintr-un meniu
nu se poate reveni decat cu ENTER sau ESC);
funqiile CITXB, CITYB de tip byte returneaza pozitia barei Tn momentul
selectiei (coloana, linie).
Obiectul MEN mai are o metoda de tip procedura fara parametri numita
RESTAUREZM. Aceasta are rolul ca, pe langa restaurarea unui meniu salvat
anterior, sa activeze si bara luminoasa (se foloseste Tn cadrul meniurilor duble
(lansez un meniu din cadrul altui meniu).
.
fn programul urmator se realizeaza un meniu orizontal.
program ml;
uses menu,util,crt;
var a:men;
begin
clrscr;
a.deschidm(20,10,9,1,verde,rosu,l,4,'optl opt2',false);
if a.selectat then
begin
deschid f(l,l,80,25,negru,alb);
if a.citxb=l
then writeln('optiunea 1')
else writeln('optiunea 2')
end
end.
in programul m2 se realizeaza un meniu vertical.

program m2;
uses menu,crt,util;
var a:men;
begin
c1rscr;
a.deschidm(1011014141verde
rosul1141
1false);
if a.selectat then
begin
deschid f(1111 801251 negru1 a1b);
case a.cityb of
1: writeln('optiunea 1 1 );
2: writeln( 1 optiunea 2 1 );
3: writeln( 1 optiunea 3 1
);
4: write1n( 1 0ptiunea 41 )
end {case}
end
end.
1 opt1opt2opt3opt4 1
in programul care urmeaza se construie!?te un meniu dublu. Initial avem un

meniu orizontal cu doua optiuni (adunare I scadere sau lnmultire I impartire).
Odata ce am selectat o astfel de optiune se deschide un alt meniu vertical ce
prezinta alte doya optiuni. De exemplu, daca in primul meniu am selectat
ADUNA_RE I SCADERE acum trebuie sa ne pronuntam daca dorim ADUNARE
sau SCADERE. Oricare meniu se poate inchide prin utilizarca tastei ESC, caz
in care se revine in meniul anterior sau se termina programul (in situatia In care
tastam ESC In cadrul meniului orizontal). lndiferent de operatia solicitata, se
deschide o fereastra in care aceasta este executata.
program fS;
uses menu crt1 Util1 fers;
var
a 1 b I c:men;
d1e1f:string;
g:fereastra;
mln:rea1;
procedure adunare;
begin
1
write
(1 m=
);
readln(m);
write ('n='); readln(n);
write( 1
&= 1
m+n:3:2);
delay(1000)
end;
procedure scadere;
begin
1
write
(1 m=
);
readln(m); write (11 n=');1
write(
S=
readln(n);
1m-n:3:2);
delay(1000)
end;
procedure inmu1tire;
begin
1
write
(1 m=
);
readln(m);
write
1
( n=');
read1n(n);
write('tl= 1 ,m*n:3:2);
de1ay(1000)
end;
procedure impartire;
begin
write ('m='); readln(m);

wr!te ('n:'); readln(n);
if n<:>O then write('C=',m/n:3:2)
else write('num=O');
delay(lOOO)
end;
begin
textbackground(O);
clrscr;
d:'ADUN/SCAD INML/IMPR';
e:='ADUNARE SCADERE ';
f:='INMDLTZRE
IMPARTZRE ';
a.deschidm(20,1,20,l,Bleu,GriDeschis,l,lO,d,false);
repeat
if a.selectat then
if a.citxb=l then
begin
a.salvez;
b.deschidm(l0,3,8,2,Bleu,GriDeschis,2,8,e,false);
repeat
if b.selectat then
if b.cityb=l then
begin
b.salvez;
g.deschid(10,3,20,20,Albastru,Rosu,4,2,true);
adunare;
b.restaurezm
end
else
begin
b.salvez;
g.deschid(l0,3,20,20,Albastru,Rosu,4,2,true);
scadere;
b.restaurezm
end
until b.inchis
end
else
begin
a.salvez;
c.deschidm(10,3,10,2,Bleu,GriDeschis,3,10,f,false);
repeat
if c.selectat then
if c.cityb=l then
begin
c.salvez;
inmultire;
c.restaurezm
end
else
begin
c.salvez;
impartire;
c.restaurezm
end
until c.inchis
end;
if a.se1ectat then restaurezm
until a.inchis
end.
Tn final, prezentam unitatea de program ce contine obiectul MEN.

unit menu;
interface
uses fers,uti1;
type men=
object(fereastra)
xb,yb,rasp,1ung,hi,lbar:byte;
procedure deschidm(x1,y1,l,h,fd,c1,n,lb:byte;
a:string; vizibi1:boolean);
procedure restaurezm;
function se1ectat:boo1ean;
function citxb:byte;
function cityb:byte;
function inchis:boolean;
end;
implementation
procedure men.des hidm;
var
i:byte;
c:string;
begin
lung:=1;hi:=h;lbar:=1b;
deschid(x1,y1,xl+l-1,y1+h-1,fd,cl,n,O,vizibil);
cursor(false);
if h=1 then
begin
scriu f(a,x1,y1,1,1);.
ad bara(x1,y1,1,1,1b);
xb: 1;yb:=1;
.
plimb bara o(x1,y1,x1+l-l,y1+h-1,lb,O,xb,yb,rasp);
end
else
begin
for i:=1 to 1er..gth(a) div 1 do
begin
c:=copy(a,(i-1)*1+1,1);
scriu f(c,x1,y1,1,i);
end;
ad bara(x1,y1,1,1,1);
xb: 1;
.
yb:=1;
plimb bara v(x1,y1,x1+1-1,y1+h-1,l,xb,yb,rasp)
end;
end;
function men.se1ectat:boo1ean;
begin
se1ectat:= (rasp=enter)
end;
function men.citxb:byte;
begin
citxb:=xb
end;
function men.cityb:byte;
begin
cityb:=yb
end;
function men.inchis:boolean;
begin
inchis:= (rasp=esc);
end;
procedure men.restaurezm;
begin
restaurez;
if hi<>l then
plimb_bara_v(xcs,ycs,xcs+lung-l,ycs+hi-l,lung,xb,yb,rasp)
else
plimb bara_o(xcs,ycs,xcs+lung-l,ycs+hi-1,lbar,O,xb,yb,rasp);
end;
end.

7.5.1. Aplicatii ale unitatii de program CRT
1. Sa se scrie o procedura care cite!;ite o parola (citirea unei parole se face
tara sa se vada pe ecran ce se tasteaza).
2. Sa se scrie o procedura care cite!;ite o valoare numerica pe care o
valideaza (din punct de vedere al naturii numerice), iar Tn caz ca nu este valida,
calculatorul va emite un sunet o perioada, dupa care se va relua citirea. Citirea
se face Tn pozitie fixa.
3. Sa se scrie o procedura care cite!;ite o valoare de tip STRING. Valoarea
citita se valideaza din punct de vedere al naturii alfabetice, iar in cazul in care
nu corespunde se va emite un sunet, dupa care citirea se va relua in acela!?i
loc.
4. Sa se scrie o procedura care cite!;ite o valoare de tip STRING. in cazul in
care se introduce !;iirul vid, citirea se va relua din aceea!?i pozitie.
5. Sa se scrie o procedura care cite!;ite o matrice de trei linii !?i trei coloane.
Citirea se va face intr-o fereastra care are o culoare distincta de restul
ecranului. Elementele se introduc in pozitia curenta a cursorului (acesta va fi
pozitionat in a!?a fel incat elementele citite sa fie pozitionate Tn fereastra ca !?i
in matrice).
6. Sa se scrie o procedura care tipare!?te o matrice cu trei linii i trei coloa
ne. Tiparirea se face Tntr-o fereastra cu o culoare de fond diferita de restul
ecranului. in cadrul ferestrei elementele vor fi pozitionate intocmai ca intr-o
matrice.
7. Scriei un program care folose:;;te un meniu cuprinzand patru op iuni:

citirea unui vector;
tiparirea unui vector;
tiparirea sumei elementelor sale;
ie:;;irea din aplica ie.
8. Sa se scrie un meniu cu urmatoarele optiuni:

citirea unei matrice;
tiparirea unei matrice;
calcule;
ie ire aplica ie.
in cazul op iunii calcule se va deschide un nou meniu cu optiunile:

suma elementelor matricei;
suma modulelor elementelor matricei;
calculul elementului maxim;
calculul elementului minim;
revenirea in meniul principal.
La selec ia unei op iuni se va apela o procedura specifica ce rezolva

problema.
9. Sa se scrie o procedura care modifica o variabila de tip string. de o
lungime prestabilita In felul urmator:
.
modificarea se face utilizand o fereastra c.u fond si culoare de desen
prestabilite, In care se scrie con inutul variabilef;
exista posibilitatea plimbarii cursorului In cadrul ferestrei cu ajutorul

sage ilor Stanga j dreapta;
exista posibilitatea inserarii unui caracter in stanga cursorului;
exista posibilitatea tergerii unui caracter aflat In stanga cursorului (cu BS)
saupe pozitia curenta a cursorului (cu DEL).
Observatie. 0 astfel de procedura se dovede te extrem de utila In doua

cazuri:
eel prezentat, atunci cand variabila are un anumit continut care se modifica;
cazul in care variabila se cite:;;te efectiv (variabila de tip string care se
transmite procedurii contine numai blancuri).
10. Utilizand procedura de Ia problema anterioarAa cititi o variabila de tip
string care va fi convertita In valoare de tip INTEGER. In cazul In care conversia
nu reu e te, se va emite un sunet, dupa care se va relua citirea din aceea!?i
pozi ie.
11. Citii Ia fel ca Ia problema 10 o variabila reala.
12. Concepei un obiect numit CAMP care cuprinde:
lungimea campului (numarul de caractere);
o variabila de tip string (continutul campului);
coordonatele ferestrei in care va fi tiparit campul pe ecran;
culoarea de fond a ferestrei; .
culoarea cu care se scriu caracterele In aceasta fereastra;
o metoda care cite te elegant variabila de tip string (poate fi eventual
procedura de Ia problema 9);
o metoda care lncarca variabila de tip string cu un ir dorit;
o metoda care returneaza valoarea de tip integer rezultata din conversia
continutului variabilei de tip string (daca nu reuseste conversia, se va

semnala);
o metoda care returneaza valoarea de tip real rezultata din conversia
continutului variabilei de tip string;
o metoda care testeaza continutul alfabetic al acestui c;,amp.
Observa.tie. Odata realizat, acest obiect se va dovedi extrem de util in

citirea !jii tiparirea diverselor valori pe care le solicita programele. Avern avantaje
ca validarea simpla, posibilitatea de !jitergere a unor caractere din interiorul
campului, posibilitatea de actualizare a unor valori, etc.
13. Cititi !jii actualizati o variabila de tip RECORD cu o structura Ia alegerea
dumneavoastra. Programul va utiliza variabile obiect de tip CAMP.
lndica.tii I rezolvari
1. Citirea se face cu readkey. lata procedura !jii un apel al ei:
program parola;
uses crt;
var par, parl: string;
procedure citpar(varpar: string);
var c: char;
begin
writeln('dati parola: ');
par:='';
repeat
c:=readkey;
if C=#O then c:=readkey;
if C<>#13 then par:=par+c
until c=#13;
end;
begin
parl:='Costinesti';
citpar(par);
if par=parl then writeln
end.
('ok')
Explicati funqionarea procedurii.
2.
program citnum;
uses crt;
var n,i_o: integer;
pro9edure citn(var n:integer);
beg1n
repeat
gotoxy(lO,lO);
write('n=');
clreol;
{$i-} read(n) {$i+};
J._o:=ioresult;
if i o <>0 then
begin
sound(SOOO);
delay(lOO);
nosound
end
unt;il i o =0;
end;
begin
citn(n);
writeln('valoarea
end.
cititD este: ',n)
Explicati funqionarea procedurii.

9. Vom prezenta procedura !?i un program demonstrativ care o utilizeaza:
program citel;
uses crt, util;
var
a: string;
i: integer;
procedure cit(var a:string; fond, culoare, xl, yl: byte);
var
c: char;
n: byte;
begin
n:=length(a);
.
window(xl,yl,xl+n-l,yl);
textbackground(fond);
textcolo (culoare);
clrscr;
scriu f(a,xl,yl,l,l);
repeat
c:=readkey;
if c=#O then
begin
c:=readker;
if {ord(c =stanga) and (wherex>l) then
gotoxy(wherex-1, wherey);
if (ord(c)=dreapta and (wherey<n) then
gotoxy(wherex+l, wherey);
{del}
if (c=#83) then
begin
.
a:=copy(a,l,wherex-l)+copy(a,wherex+l,-wherex)+' ';
scriu f(a,xl,yl,l,l):
end;
end
else
begin
if (a[wherex]=' ') and (ord(c)<>8) and (ord(c)<>13) then
begin
a:=c;:opy(a,l,wherex-l)+C+Copy(a,wherex+l, n-wherex);
scr1u f(a,xl,yl,l,l);
gotox(wherex+l, wherey)
end
else
.
if(a[wherex]<>'')and(ord(c)<>B)and(ord(c)<>enter)
then begin
a:=c;:opy(a,l,wherex-l)+C+Copy(a,wherex,n-wherex);
scr1u f(a,xl,yl,l,l);
gotox(wherex+l;wherey)
end;
{bs}
if (c=#S) and (wherex>l) then
begin
a:=copy(a,l,wherex-2)+copy(a,wherex,n-1)+' ';
scriu (a, l,yl,l,l);
gotox(wherex-l,wherey)
end;
end
until ord(c)=enter;
end;
begin
textcolor(alb);
clrscr; a:='l2345678';
cit(a,verde,rosu,37,10);
window(l,l,S0,25);
textcolor(alb);
clrscr;
write(a)
end.
Procedura deschide o fereastra de un anumit fond si culoare in care se

tiparel?te conJinutul actual al variabilei de tip STRING (aceasta poate fj cu spaJii
daca se doreste numai citire). Citirea tastelor se face cu READKEY. In functie
de caracterul'tastat, l?irul existent in cadrul variabilei de tip string se inlocuie te
cu un alt l?ir, dupa care se tiparel?te noul conJinut al variabilei.
Se trateaza urmatoarele cazuri:
sageata stanga (se deplaseaza cursorul'la stanga, cu o poziJie);
sageata dreapta (se deplaseaza cursorul spre dreapta, cu o pozitie);
DEL - se !?terge caracterul aflat pe poziJia curenta, Ia care se adauga l?irul
existent in variabila de tip string pana in poziJia curenta, Ia care se adauga
!?irul existent, incepand cu poziJia urmatoare celei curente pana Ia sfar it);
o litera sau o cifra se trateaza diferentiat astfel:
o daca in poziJia curenta a cursorului 'se gase!?te caracterul spaJiu, acesta
este inlocuit cu caracterul care se tasteaza;
o daca in poziJia curenta a cursorului se gase!?te un alt caracter, atunci
noul ir se obJine concatenand !?irul existent pna in poziJia curenta cu caracterul tastat i cu !?irul care se gase!?te incepand cu poziJia
curenta pna Ia penultima pozitie (se insereaza un caracter);
o daca s-a tastat BS,noul l?ir se obtine !?tergnd caracterul aflat inaintea
pozitiei curente (ultima pozitie ramane Iibera).
Atentie! Unele caractere au codul pe 2 octeti.
Capitolul 8
Fiiere Pascal
8.1. Fiiere text
Se nume te fiier text o succesiune de caractere ASCII terminata cu carac
terul AZ . Putem considera fiierul ca fiind alcatuit din linii separate prin doua
caractere (CR i LF) i care nu au in mod obligatoriu lungimea egala, dei, in
practica, intalnim de multe ori fiiere text cu o singura linie.
Fi ierele text au o importanta deosebita din doua motive:
sunt direct afiabile;
orice editor de texte lucreaza cu fi iere de acest tip.
Structura generala a unui fiier text se observa in figura de mai jos.
TIP
.,_
-FI$1ERTEXT
Figura 8.1.1.
intrucat, in general, liniile nu au acelai numar de caractere, accesul Ia o

anumita linie din fiier se face secvential (se citesc pe rand liniile, pfma se
ajunge Ia linia cautata).
in program, un fiier text se declara ca variabila de un tip predefinit i
anume TEXT:
VAR a,b:text;
Pentru a face legatura intra numele fi ierului din program i numele sau de
pe suportul extern pe care se afla sau se creeaza, se folosete procedura
ASSIGN. Apelul procedurii se realizeaza prin:
ASSIGN (nume fi ier in program, 'nume fiier pe suport extern').
Exemplul 1:
var a:text;
assign(a,'fl.dat')
In acest caz, fi ierul va fi creat sau se va gasi in directorul in care ne aflam

i se nume te f1.dat.
0 forma echivalenta pF3ntru o asignare de acest tip este:
Exemplul 2:
var a:text;
b:string;
b:='fl.dat'
assign(a,b)
Exemplul 3:
Fi!?ierul se gase!?te sau se va gasi pe a !?iva avea numele t.txt.
var a:text;
assign
(a,'a:\t.txt')
Exemplul 4:
Fi!?ierul se gase!?te sau se va gasi pe C in subdirectorul v al directorului h
!?i se nume te util. .
var a:text;
assign(a,c:\h\v\util).
8.1.1. Crearea !j>i exploatarea fi!j>ierelor text

Odata declarat i realizeaza legatura intre numele sau din program !?i numele
sau de pe suportul extern, un fi ier se poate crea. Procedura care deschide un
fi ier pentru a fi creat este REWRITE: Forma generala este:
REWRITE (variabila fi!?ier).
Scrierea lnregistrarilor In fi!?ier se face utilizand doua proceduri - WRITE
i WRITELN. Pentru lnceput, vom face scrieri i citiri in fi!?ier utilizand numai
variabile de tip string. Din acest motiv vom prezenta o forma simplificata a
procedurilor enuntate. Forma de apel simplificata a procedurii WRITELN este:
WRITELN (var Fi!?ier, variabila de tip string);
Procedura WRITELN scrie o linie in fisier, continutul liniei este dat de
continutul variabilei de tip string !?i marcheaza sfar!?ftul de linie (CR,LF) .
Dupa ce a fost creat, fi!?ierul se inchide (se marcheaza sfar!?itul de fi ier).
lnchiderea se face utilizand procedura CLOSE. Forma generals a acesteia este:
CLOSE (nume fi!?ier).
Programul urmator creeaza un fi!?ier text cu mai multe linii.
program txtl;
var
f:text;
a:string;
begin
assign(f,'fl.dat');
rewrite();
while not eo do
begin
readln(a);
writeln(f,a)
end;
close()
end.
Datele sunt introduse de Ia tastatura. Sa presupunem ca introducem

urm!itoarele date:
asdfghj(ENTER)
12weh(ENTER)
a g(ENTER)
1...z (ultimul caracter introdus s-a oblinut tastand (CTRL + Z).
Fi ierul creat va conline 4 linii:
linia
linia
linia
linia
1
2
3
4
asdfghj
1 2weh
ag
1
Liniile sunt separate cu CR + LF. Funclia booleana EOF ia valoarea TRUE

dadi este Tntalnit caracterul ...z (acesta va marca sfar!jiitul introducerii datelor).
Consideram programul urmator ce creeaza un fi!jiier text.
program txt3;
var
f:text;
a:string;
begin
assign(f,'f2.dat');
rewrite();
while not eof do
begin
readln(a);
write(f,a)
end;
close(f)
end.
in acest program am inlocuit procedura WRITELN cu procedura WRITE.

Consecinta ? La acela!jii !?ir de intrare, noul fi!jiier text va avea o singura linie ce
contine toate caracterele illtroduse, maipulin CR. Putem acum prezenta forma
simplificata a procedurii WRITE. Aceasta este:
WRITE (variabila de tip string).
Are rolul de a scrie in fi ier conlinutul variabilei string dar nu marcheaza
sfar11itul de linie. Astfel, Ia un eventual apel ulterior al 2cestei proceduri se va
scrie in continuarea liniei.
Este normal sa !?i putem citi fi!?ierele reate anterior.
Pentru aceasta, trebuie prezentate alte trei proceduri: RESET, READLN,READ.
Procedura RESET deschide un fi ier pentru citire !jii are forma generala:
RESET (variabila fi!?ier);

Pentru procedurile READ, READLN se vor prezenta forme simplificate.
Forma procedurii READLN este:
READLN (var Fi!?ier, variabila de tip string):
Citeste maximum 256 de caractere din linia curenta a fisierului. Daca linia
are mai' putin de 256 de caractere este citita toata iar continutul efectiv al
variabilei de tip string va fi !?irul de caractere pana Ia CR. lndiferent de caz,
dupa citire se trece Ia linia urmatoare a fi!?ierului. Functia booleana EOF
(variabila fi!?ier) ia valoarea TRUE daca s-a ajuns Ia sfar!?itul fi ierului, in caz
contrar ia valoarea FALSE.
Programul urmator cite!?te fi ierul creat cu ajutorul lui WRITELN.
program txt3;
var
f:text;
a:string;
begin
assign(f,'fl.dat');
reset();
while not eof(f) do
begin
readln(f,a);
writeln(a)
end;
end.
Procedura READ are forma generala:

READ(var Fi!?ier, variabila de tip string).
Pentru a Tntelege exact cum functioneaza READ, ne imaginam o linie de
fi!?ier cu mai mult de 256 de caractere. Dupa deschiderea fi!?ierului !?i plasarea
Ia inceputul acestei linii apelam pentru prima data READ. Vor fi citite 256 de
caractere. La al doilea apel vor fi citite sau urmatoarele 256 ( daca au mai
ramas atatea caractere necitite in linie) sau cate au mai ramas pana Ia intalnirea
sfar!?itului de linie. in programul txt4 se cite!?te fi ierul text f2.dat (eel creat pe
o singura linie).
program txt4;
var
:text;
a:string;
begin
assign(f,'fl.dat');
reset();
while not eof(f) do
begin
read(f,a);
writeln(a)
end;
end.
Oare variabilele de tip string sunt singurele care se pot scrie i citi din
fi!?iere? Raspunsul Ia aceasta intrebare este negativ, i acum este momentul sa
prezentam instructiunile de citire !?i scriere in mod generalizat.

Atat cu READ cat !jii cu READLN se pot citi mai multe tipuri de variabile:
de tip char;
de tip string;
de tip numeric.
Forma lor generala este: READ(var
nume fi!jiier,v1[,v2,...,vn]); READLN(var
nume fi!jiier,v1[,v2,... ,vn]).
Variabilele v 1 ...vn sunt de tipurile prezentate anterior.
Procedura READLN se executa Ia fel ca READ dupa care se face saltul Ia
linia urmatoare.
Pentru a intelege exact modul de citire (scriere) a acestor variabile, sa ne
imaginam intregul fi!jiier text (ca in!jiiruire de caractere ASCII). De asemenea, ne
imaginam o sageata (se nume!jite de altfel pointer) care ne indica in permanenta
Ia ce caracter am ajuns. Cand deschidem un fi!jiier pentru citire, pointer-ul
indica primul caracter din prima linie a acestuia. Consideram, de asemenea,
multimea caracterelor ASCII impartita in doua submultimi:
submultimea caracterelor cu rol de separator (spatiu, CR, LF, TAB,
BACKSPACE, BELL).
submultimea alcatuita din restul caracterelor.
8.1.2. Citirea variabilelor de tip char

Se cite!jite acel caracter care se gase!jite pe pozi ia curenta a pointer-ului (nu
intereseaza daca este vorba de caractere care au sau nu rol separator. Dupa
citire, pointer-ul avanseaza in fi!jiier cu un caracter. Ca este a!jia, o
demonstreaza programul urmator:
program txtS;
var
f:text;
a:char;
begin
assign(f,'fl.dat');
reset();
while not eof(f) do
begin
read(f,a);
wr-ite(a)
end
end.
Acest program listeaza fi!?ierul creat Ia inceputul acestui capitol. Liniile apar
listate exact in ordinea in care au fost introduse (se stie ca f1.dat a fost creat
pe mai multe linii).
8.1.3. Citirea variabilelor de tip string

Aceste variabile se citesc lncepand din pozitia curenta a cursorului pana
este citit numarul de caractere necesar tipului sau pana s-a ajuns Ia sfar!?it de
linie. Programul urmator demonstreaza acest fapt (daca linia 1 a fi!?ierului are
3 caractere, se vor tipari doua pe un rand !?i unul pe al doilea rand). Dupa
citirea unei astfel de variabile, pointer-ul se afla sau pe caracterul ce urmeaza
dupa ultimul caracter citit sau pe CR. Tn sit,uatia In care pointer-ul se ami pe
CR !?i se forteaza o noua citire de tip string, se returneaza !?irul vid.
program txt6;
var
:text;
a:string[2];
b:string;
begin
assign(f,'fl.dat');
reset();
read(f,a);
writeln(a);
read(f,b);
writeln(b)
end.
8. 1.4. Citirea variabilelor de tip numeric

Se pleaca de Ia pozitia curenta a pointer-ului. Daca se intalne!?te un caracter
separator, pointer-ul sare Ia urmatorul caracter !?i procedeul se repeta pana s-a
ajuns_la un caracter ce nu este separator sau pana cand s-a ajuns Ia sfar!?it de
linie. In _al d9ilea caz, se solicita o noua linie iar pointer-ul sare Ia inceputulliniei
urmiHoare. In primul caz, se testeaza caracterele cuprinse intre pozitia curenta
a pointer-ului !?i primul caracter separator. Daca acestea se incadreaza In
diagrama de sintaxa pentru intreg (daca se cite!?te un tip intreg) sau real (daca
se cite!?te un tip real), citirea se face, iar pointer-ul se a!?eaza pe primul caracter
separator; daca sintaxa nu este indeplinita, programul se lncheie cu eroare.
Exemp/e:
Avem urmatoarele variabile a:inleger,.f:real, e:string, d:string[2].
Se executij read(f,a,f,e); pointer-ul este pozitionat pe primul caracter d!n
linie, iar linia este bbb 12b34bbbbt (prin b am notat caracterul blanc). In
urma executiei vom avea: a= 12, f = 34, e = bbbbt.
Se executa read(f,d,e,f), prima linie din fi!?ier este bm iar a doua 2b3 (prin bam
notat blanc). Variabila d va contine bm, eva Contine sirul vid, iar f va fi 2.
Se executa read( a) iar prima linie din fi!?ier va fi 3t (pointer-ul va fi
pozitionat pe primul caracter din linie). Executia se incheie cu eroare (a
nu respecta
tipul numeric).
Procedura Readln fara parametri de tip variabila produce saltul pe linia
urmatoare (exemplu READLN (F) ), iar cu parametri, dupa ce a reu!?it tentativa
de citire se sare pe linia urmatoare.
Pentru scriere, se folosesc procedurile WRITE i WRITELN. Forma generala
a acestor proceduri WRITE este:
WRITE(var nume fi ier,v1 [,v2,...,vn])
unde v1, v2,...,vn reprezinta nume de variabile sau date ce se scriu in fi!?ier.
Procedura WRITELN are forma generala:
WRITELN(var nume fi!?ier,v1[v2,...,vn]).
Parametrii au aceeai semnificatie ca Ia procedura WRITE. Spre deosebire de
WRITE, dupa scriere procedura WRITELN inchide linia in fil?ier (scrie CR !?i LF)
!}i trece pe linia urmatoare (pointer-ul este pozitionat pe primul caracter alliniei
urmatoare). Se pot scrie date de tipul:
numeric (intreg sau real);
char;
string;
boolean.
Scrierea se poate face in doua feluri:
cu format implicit;
cu format explicit.
8.1.5. Scrierea cu format implicit

in toate aceste cazuri, se scrie incepand din pozitia curenta a pointer-ului.
datele intregi se scriu cu toate cifrele semnificative, iar daca numarul este
negativ, se scrie in fata semnul -;
datele reale se scriu in forma tiintifica (exemplu: -3.35 se scrie
-3.3500000000E+OO, -0.7 se scrie -7.0000000000E-01) care se
che!}te ca numar (cu semn) * 10 Ia puterea (cu semn);
datele de tip caracter se scriu pe o singura pozitie;
datele de tip string se scriu pe lungimea efectiva a !}irului;
pentru o data de tip boolean se scrie !}irul TRUE sau FALSE.
8.1.6. Scrierea cu format explicit

8.1.6.1. Scrierea datelor de tip intreg
Pentru fiecare variabila intreaga (prezenta in instructiunea de scriere) se
poate preciza numarul m de pozitii pe care se face scrierea.
Exemp/u: WRITE(f,a:6).
in situa ia In care numarul de pozi ii ocupate de numar este mai mare

decilt numarul m, parametrul este ignorat. iar daca m este mai mare dedlt
numarul de pozitii ocupate efectiv, numarul se scrie aliniat dreapta (se va
ine cont de faptul ca un numar negativ va fi precedat de semn).
8.1.6.2. Scrierea datelor de tip real

Pentru aceste date se pot preciza doi parametri rn $in.
Exemplu: WRITE (f,a:5:2),
unde a este o variabila reala, m are valoarea 5 iar n are valoarea 2.
Parametrul m specifica numarul de pozitii pe care se scrie data reala.
Parametrul n specifica numarul de pozi ii rezervate paqii zecimale (exclusiv
punctul). in cazulln care sunt prezeni ambii parametri, numarul se scrie In
forma cunoscuta noua $i anume cu punct (de exemplu 23.67). Daca
valoarea parametrului m este prea mica (numarul ocupa mai multe pozitii),
ea este ignorata (se scrie numarul cu toate cifrele lui). Daca valoarea
parametrului n este prea mica (numarul are mai multe zecimale), numarul va
fi scris rotunjit cu un numar de zecimale egal cu valoarea lui n. in cazul lr.
care numarul ocupa mai putine cifre decat valoarea iui m, acesta se scrie pe
m pozitii aliniat dreapta (In fata se pun blancuri). Daca parametru! n lipse$te,
numarul este scris In forma $tiin!ifica. in acest caz, daca parametrul mare
o valoare prea mica, numarul este rotunjit, iar daca are o valoare prea mare,
el este scris aliniat dreapta.
8.1.6.3. Scrierea datelor de tip caracter

Pentru aceste date se poate folosi numai parametrul m care sern:1ifica
numarul de pozitii pe care se scrie data. Daca m este rnai mare dedit 1, aata
se scrie aliniata dreapta iar in fata se pun blancuri.
8.1.6.4. Scrierea datelor de tip string

Pentru date de acest tip, se iau in consideratie lungimea efectiva a $irului $i
valoarea parametrului m ce specifica numarul de pozitii pe care se face
scrierea. in cazul in care valoarea lui m este mai mica dedit lungimea
efectiva a !?irului, aceasta se ignora, $irul
va fi scris pe lungimea sa
efectiva. Daca valoarea lui m este mai mare de cat lungimea efectiva a $irului,
acesta este scris pe m pozitii aliniat dreapta, iar in fata se pun blancuri.
8.1.6.5. Scrierea datelor de tip boolean

Avem numai doua astfel de date, TRUE !?i FALSE. $i pentru date de acest
tip se poate preciza numarul de pozi ii pe care sa se faca scrierea. Daca
numarul de pozitii este mai mic, se ignora, iar daca este mai mare, acestea se
scriu aiiniat dreapta, In fa!a se pun blancuri (ex. WRITE(f,TRUE:9)).
8.1.7. Alte proceduri !j>i func!ii care lucreaza cu fi!j>iere text

8.1. 7 .1. Procedura APPEND
Aceasta pror:edura are rolul de a deschide un fi$ier text care a fost creat
pentru extindere (scriere Ia sfar$it de fi$ier). Forma genera!a este APPEND(var
fi$ier text).
In situatia in care fi$ierul nu exista, se genereaza o eroare de intrare ie$ir .

Pentru un fi ier deschis cu APPEND este posibila numai operatia de scriere. In
exemplul care urmeaza, se adauga alte linii fi$ierului f 1 .dat.
program txt;
var f: text;
a: string;
begin
assign(f, 1 f1. dat1
append();
while not eo do
begin
readln(a);
writeln(f,a)
end;
close()
end.
) ;
8.1.7.1. Functia EOLN

Areca parametru formal o variabila fi$ier $i este de tip boolean. La executie,
functia Tntoarce valoarea TRUE daca pointer-ul este Ia sfar!?it de linie $i FALSE
In caz contrar.
in programul care urmeaza se tipare$te ultimul caracter al primei linii pentru
un fi$ier text creat anterior.
program txt7;
var f: text;
a:char;
begin
assign(f,'fl.dat);
reset(f);
while not eoln(f) do
writeln(a);
close()
end.
read(f,a);
8.1.8. Fi!}iere text standard

8.1.8.1. Fi ierele INPUTi OUTPUT
Aceste fi:?iere se considera declarate (nu mai este necesara declararea lor ca
fi!?iere text).: Ele se asigneaza in mod automat Ia tastatura (INPUT) !?i monitor
(OUTPUT). In situatia_in care procedurile READ, READLN, WRITE, WRITELN nu
au precizata Ia apel variabila fi:?ier, aceasta este considerata automat INPUT
pentru procedurile de citire !?i OUTPUT pentru procedurile de scriere.
Toate operatiile de citire !?i scriere efectuate Tn programele din capitolele
anterioare au fost facute cu aceste fi!?iere.
8.1.8.2. Fi ierul PRN
Daca dorim ca rezultatele programului nostru sa fie scrise Ia imprimanta,
folosim fi!?ierul standard PRN. Acesta se declara in cadrul procedurii ASSIGN
ca nume extern pentru fi!?ier.
Vom lua, ca exemplu, o imprimanta care scrie pe hartie de format A4 (coala
normala de scris). Se considera ca pe o astfel de coala se pot scrie 55 de
randuri. in programul care urmeaza vom scrie in primele doua randuri texte,
dupa care se sare Ia pagina noua (se scriu 53 de randuri vide cu ajutorul
procedurii WRITELN).
program txt;
var imp:text;
i:integer;
begin
assign(imp,'prn');
rewrite(imp);
writeln(imp,'am scris un text');
writeln(imp,am scris alt text');
for i:=l to 53 do wri eln(imp);
close(imp);
end.
Regulile prin care se scriu diversele date Ia imprimanta sunt acelea!?i ca

pentru oricare alt fi!?ier text.
8.2. Validarea operaliilor de intrare I ie ire

Din categoria operatiilor de intrare I ie ire fac parte citirile, scrierile in !?i din
diverse fi iere (am vazut ca monitorul i tastatura sunt tot fi!?iere) dar !?i operatii
cum ar fi deschiderea unui fi!?ier pentru citire sau scriere. Nu intotdeauna
aceste operatii se desfa oara in mod normal. Sa ne imaginam urmatoarea
situatie: programul nostru cite!?te o variabila numerica !?i noi, din gre!?eala
introducem o litera. Programul se va opri i va da un mesaj de eroare. Poate

veti spune ca trebuie sa fim atenti Ia introducerea datelor. Dar sunt situatii in
care erorile sunt inerente. De exemplu, pentru a crea un fi ier ce se folose te
in practica (i nu unul didactic, care are doar cateva linii) se introduc mii de
date. Este aproape imposibil ca Ia introducerea lor sa nu se gre!?easca- caz In
care ar trebui sa o luam de Ia capat. Ce este de facut pentru prelntampinarea
acestor situatii? Limbajul Turbo Pascal ne permite sa prevedem in program
astfel de cazuri i sa actionam in consecinta.
Presupunem ca programul pe care l-am conceput nu a prevazut posibilitat a
ca operatiile de intrare I ie ire sa nu se desfa:;;oare in mod coresP..unzator. In
acest caz programul se lncheie cu eroare (se afi:;;eaza codul erorii). lntr-un prim
pas, este necesar ca programul sa nu se opreasca intr-o astfel de situatie.
Pentru aceasta exista o posibilitate !?i anume directiva de compilare {$i} ce
poate avea doua valori { $i-} :;;i { $i +}. Directiva { $i-} determina ca toate
operatiile de intrare I iel?ire cuprinse intre ea i directiva { $ i +} sau sfar itul
programului sa nu determine intreruperea acestuia.
Ne putem intreba _ce realizam daca procedam astfel, pentru ca oricum
rezultatele vor fi eronate. Exista posibilitatea sa determinam daca operatia de
intrare I ie ire a reu it sau nu. Functia IORESULT (functie de tip_byte care se
gase te prezenta in unit-ul SYS.TEM) ne ajuta in acest sens. In cazul unei
operatii reu ite, Ia executie functia ia valoarea 0, In caz contrar ia o valoare
diferita de 0. Prin testul valorii pe care o furnizeaza aceasta functie avem
posibilitatea sa reluam operatia p8na cand ea reu:;;e:;;te, su sa lasam pe eel
care utilizeaza programul nostru sa decida ce este de facut. In cele ce urmeaza,
vom da mai multe exemple care au menirea sa ne convinga de utilitatea de a
Iuera In acest mod.
Exemplu/1:
Programul v1 cite te o data numerica. in ituatia in care aceasta este

introdusa gre!?it (se introduce o litera) citirea se reia.
program vl;
var a:integer;
begin
repeat
write(1 a= 1 );
{$i-} readln(a) {$i+}
until ioresult=O
end.
Exemp/u/2:
Sa presupunem ca dorim crearea unui fisier text. Deschiderea lui pentru scriere
se face utilizand procedura REWRITE. in situatia in care pe suport se gase!?te alt
fi!?ier cu acelai nume, acesta din urma este :;;ters. Este bine sa fim avertizati in
acest sens. Prin urmare, se incearca deschiderea fi!?ierului care urmeaza a fi creat
(prin RESET). Daca el se gase:;;te pe sueort, functia IORESULTva lua valoarea 0
iar In caz contrar va lua valoarea 1. In cazul In care aceasta ia valoarea 0,
operatorul va decide daca fi:;;ierul se va crea (deci eel vechi se distruge) sau nu.
program v2;
var f: text;
a: string;
rasp:char;
begin
write('Dati numele fisierului ce se va crea ');
readln(a);
assign(f,a};
{$i-} reset(f) {i+};
if ioresult<>O then
begin
write (Fisierul se gaseste pe suport. continuam? (y/n)');
readln(rasp)
end;
if rasp='y' then
begin
writeln ('Fisierul a fost sters');
rewrite()
end
end.
E emp/u/3:
Dorim sa scriem un text Ia imprimanta. Exista mai multe motive pentru care
tentativa noastra poate e:?ua:
e imprimanta nu este deschisa;
o imprimanta nu este ON LINE;
e nu am pus hartie.
Tn toate aceste cazuri, un program neprotejat se opre:;;te. Programui care

urmeaza scrie mesajul pana cand opera ia de scriere reu$e te (IORESUL T ia
valoarea 0).
program v3;
var imp:text;
begin
assign(imp,'p:cn');
rewrite(imp);
repeat
{$i-} writeln(imp,
until ioresult=O
end.
'un mesaj');
8.2.1. Alte tipuri de validari

8.2.1.1.Validarea naturii d<>te!or
Din acest punct de vedere datele se pot clasifica astfel:
date numerice (numere lntregi $i reale);
date alfabetice (nu con in cifre, sunt formate din literele mari mici ale
alfabetului);
date alfanumerice (contin ath literele alfabetului cat $i cifre).
Sa presupunem ca se dore!?te citirea unor nume de persoane. Evident,
acestea sunt date alfabetice. Curn putem testa daca nu cumva, din gre$eala,
In cadrul unor nume nu s-au introdus !?i cifre? Exemplele de acest tip ar putea
continua.
8.2.1.2. Testarea naturii numerice a datelor
0 modalitate de test numeric a fost deja prezentata (prin introducerea unei
litere Ia citirea unei variabile numerice functia IORESULT ia valoarea 0).
Exista ;;i o alta modalitate de a efectua acest test. Pentru aceasta se
procedeaza astfel:
citirea datei s..: face lntr-o variabila de tip string (deci se pot introduce orice
fel de date);
se face o tentativa de conversie din tipul string Tn tipul numeric solicitat
(procedura VAL);
Tn situatia in care tentativa reu!?e!?te, data introdusa a fast numerica;
Tn caz contrar, data introdusa nu a fost numerica deci se reia citirea.
Aceasta modalitate de lucru prezinta !?i marele avantaj de a ne oferi
posibilitatea sa testam numarul de cifre introduse, prin analiza lungimii $irului
de tip string (funqia LENGTH).
in programul care urmeaza se cite!?te o data care trebuie sa fie numerica $i
sa fie scrisa pe trei cifre (care pot fi !?i 0).
program v4;
var a: string;
c_er,b:integer;
begin
repeat
write( 1 b= 1 ) ;
readln(a);
val(a,b,c er)
until (c er O)and(length(a)=3)
end.
-
8.2.1.3. Testarea naturii alfabetice a datelor

Pentru acest test se procedeaza astfel:
e literele mari i mici a:,; alfa etului alcatuiesc o mul ime ;;1 se declara
constante;
citirea se face intr-o variabila de tip string;
se testeaza toate caracterele $irului citit;
daca eel putin un caracter nu apartine multimii considerate, citirea se reia.
in programul care urmeaza se exemplifica acest test.

program vs;
const alfabet=[a ..'z','A'..z];
var a:string;
i,c_er:integer;
begin
repeat
c er:=o;
write{'dati data');
readln{a);
for i:=l to length(a) do
if not {a[i] in alfabet then c_er:=l
until c_er=o
end.
Datele alfanumerice nu necesita validare.
Toate tipurile de validare prezentate aici sunt valabile indiferent de tipul de
fi!?ier ales. Din acest motiv, In cele ce urmeaza le folosim fara explicatii
suplimentare.
8.3. Fi iere cu tip

Fi ?ierele cu tip sunt construite din articole cu lungirne fixa, de acela!?i tip,
motiv pentru care se mai numesc !?i fi iere cu prelucrare Ia nivel de articol.
Tipul fi!?ier cu tip se declara conform figurii de mai jos:
TIP FI!?IER
CUTIP
IDENTIFICATOR DE TIP
Figura 8.3.1.
Exemple de declarare:
Se declara doua fi:;;iere ale caror articole sunt constituite dintr-un singur
octet:
type fisoct=file of
byte var fl,f2:fisoct;
Acelea!?i doua fi iere se pot declara printr-un tip anonim:
var fl,2 : file of byte
Se declara un fi!?ier ale carui articole sunt numere lntregi:
type fisint=file of integer;
var a:fisint;
Se declara un fi ier cu articole de tip record:

type
inreg=record
nume:string[JO];
varsta:byte
end;
fi ier=file of inreg;
var f:fi ier;
Ca i pentru fi ierele text, procedura ASSIGN face legatura intre numele

fi!?ierului din program i numele sau de pe suportul extern. Forma generala este:
ASSIGN(nume fi ier in program, 'nume extern').
Numele extern este de tipul string.
Ex8mplu: assign (f,'fi ier'); unde f reprezinta numele variabilei fi ier In pro
gram iar 'fi!?ier' reprezinta numele sub care acesta se gase te pe suport.
8.3.1. Crearea fh;ierelor cu tip

Pentru a putea realiza o astfel de operatie, trebuie cunoscute cateva
proceduri !?i functii.
Procedura REWRITE are forma generala:
REWRITE(var fi!?ier)
!?i are rolul de a deschide un fi ier spre a fi creat. in situatia in care mai exista
un fi ier cu acelai nume, acesta se distruge. Din acest motiv, este bine sa se
faca testul de existenta (vezi paragraful anterior).
Procedura WRITE are forma generala:
WRITE(var fi ier,v1...vn)
Parametrii v1...vn reprezinta variabile ce vor fi scrise in fi!?ier. Principiul de
executie este urmatorul:
se scrie prima inregistrare preluata din cadrul variabilei v 1 ;
se scrie a doua inregistrare preluata din cadrul variabilei v2;
se scrie inregistrarea n din cadrul variabilei vn;

pointer-ul se pozitioneaza pe urmatoarea inregistrare.
Functia booleana EOF are forma generala:
EOF (var fi!?ier)
i returneaza TRUE daca pointer-ul se gase!?te Ia sfar it de fi!?ier,in caz contrar
returneaza FALSE.
Procedura CLOSE are forma generala:
CLOSE(var fi ier)
i are rolul de a Tnchide fi ierul.
in programul care urmeaza, dupa fiecare Tnregistrare citita de Ia tastatura i
scrisa Tn fi ier, utilizatorul este Tntrebat daca sa se continue sau nu. Dupa ce
au fost scrise toate Tnregistrarile, fi ierul se Tnchide.
program ftl;
type inr= record
nume:string[lO];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
fl:fisier;
c:char;
begin
assign(fl, 1 fdat 1 );
rewrite(fl);
repeat
write( 1 nume 1 ) ;
readln(inreg.nume);
write( 1 varsta 1 );
readln(inreg.varsta);
write(fl,inreg);
write( 1 continuati? (y/n)
readln (c);
unti1 c= 1 n 1 ;
close(fl)
end.
);
Evident, nu este obligatoriu ca un fi!?ier sa se creeze de !a tastatura, el poate

fi creat utilizand informatii preluate din alte fi!?iere, Tnsa pentru aceasta trebuie
sa !?tim cum se cite!?te un fi!?ier.
Pentru a fi citit, un fi!?ier se deschide cu ajutorul procedurii RESET, care are
forma generala:
RESET(var fi$ier).
Procedura READ are rolul de a citi una sau mai multe Tnregistrari ale unui
fi ier. Forma generala a acestei proceduri este :
READ(var fi ier,v1,v2,...,vn).
,

e se cite te Tnregistrarea pe care se afla pointer-ul Tn variabila v1;
pointer-ul trece pe urmatoarea Tnregistrare care este citita Tn variabila v2;
procedeul continua pana cand este citita variabila vn !?i pointer-ul se plaseaza
pe urmatoarea Tnregistrare necitita sau pe marcajul de sfilr!?it de fi!?ier.
Programul care urmeaza cite!?te fi!?ierul creat anterior !?i Tl tipare!?te pe monitor.
program ft2;
type in.r = record
nume:string[lO];
varsta;byte
end;
fi9ier=file of inr;
var inreg: inr;
fl:fisier;
begi:1.
assign(fl, 'fdat');
reset(fl);
while not eof(fl) do
begin
read (fl,in eg);
writeln(inreg.nume,
' ',inreg.virsta)
e!'"Jr.;
close(fl)
end.
Aplica,tie:
Concatenare de fi!jiiere
Daca se dau doua fi iere, prin opera ia de concatenare a ior se ln elege
crearea cu ajutorul lor a unui ai treilea fi ier care con ine lnregistrarile celor
doua In odinea urmatoare: lnregistrarile primului fi ier urmate de lnregistrarile
celui de-al doilea fi ier.
Programul care urmeaza concateneaza doua fi iere. in esenta, pentru a
realiza aceasta operatie, se procedeaza astfel:
se deschid toate fi ierele (doua pentru citire, unul pentru scriere);
e toate !nror;istrarile primului fi ier se copiaza In cadrul celui de-al treilea;
toate lnregistrariie celui de-al doi1ea fi ier se copiaza, In continuare, In
cadrul celui de-al treilea;
In final, se lnchid cele trei fi iere.
program ft3;
type inr= record
nume:string[lO];
virsta:byte
end;
fisier=file of inr;
var inreg:inr;
fl,f2,f3:fisier;
begin
assign(1,'fdat');
assign(2,'fdatl');
assign(f3,'fdat2');
reset(fl);
reset(2);
rewrite(3);
begin
read (f1,inreg);
write(f3,inreg);
end;
while not eo(2) do
begin
read(f2,inreg);
write(f3,inreg);
end;
close(1);
close(2);
close(3);
end.
8.3.2. Procedura SEEK 'i functia FILESIZE

inregistrarile unui fi ier cu tip au aceea!?i lungime. Fiecarei 'fnregistrari i se
poate asocia un numar de ordine cuprins 'fntre 0 (pentru prima 'fnregistrare) :?i
n-1 (pentru 'fnregistrarea n). Datorita lungimii fixe a 'fnregistrarilor, acestea pot
fi accesate direct (se poate pozitiona pointer-ul pe 'fnregistrarea cu un anumit
numar de ordine). Este firesc sa fie posibil acest lucru, Tntrucat daca se dore te
sa pozitionam pointer-ul pe 'fnregistrarea i, adresa de 'fnceput a acesteia (a
primului ei octet) se obtine 'fnmultind lungimea unei Tnregistrari cu i (Aten.tie!
Tnregistrarile sunt numerotate intre 0 i n-1).
Procedura SEEK are forma generala:
SEEK(var fi ier,numar Tnregistrare)
!?i are rolul de a pozitiona pointer-ul pe 'fnregistrarea cu numarul de ordine
'numar 'fnregistrare'.
Functia FILESIZE avand forma generala:
FILESIZE (var fi!?ier)
este tip longint !?i furnizeaza numarul de componente pe care le are fi ierul.
Daca din rezultatul furnizat de aceasta functie se scade 1, obtinem numarul de
ordine al ultimei componente din fi!?ier.
in programul care urmeaza, se listeaza un fi ier utiliznd functia FILESIZE

program ft4;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
i:integer;
begin
assign(1,'fdat2'):
reset(fl);
for i:=o to filesize(1)-1 do
begin
read (fl,inreg);
writeln(inreg.nume,
end;
close(fl)
end.
,inreg.varsta)
8.3.3. Adaugarea de articole

Fiind dat un fi!?ier, se cere sa-i adaugam un numar de articole. in programul
urmator, adaugarea articolelor se face Ia sfar!?itul fi!?ierului (deci dupa toate
articolele con1inute deja In fi!?ier).
Pentru a realiza acest lucru se pozi1ioneaza pointer-ul pe marcajul sfar!?itului
de fi ier (seek(f1,filesize(f1)), iar lnregistrarile care se adauga sunt citite de Ia
tastatura !?i scrise In continuare. Se observa ca deschiderea fi!?ierului a fost
facuta cu RESET (o deschidere cu RESET permite !?i scrierea In fi!?ier).
program ftS;
type inr= record
nume:string[lO];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
fl:fisier;
dfghjkl;c:char;
begin
assign(fl, 1 fdat2 1 );
reset(fl);
seek(fl,filesize(fl));
repeat
write(1 nume 1 );
readln(inreg.nume);
write( 1 varsta 1 );
write(fl,inreg);
write( 1 continuati? (y/n)
readln (c);
until c= 1 n 1 ;
close(fl)
end.
1 );
De multe ori, adaugarea noilor lnregistrari trebuie facuta In interiorul fil?ierului

(dupa o anumita lnregistrare). Limbajul Turbo Pascal nu permite ca aceasta
operatie sa se faca In mod direct. Din acest motiv, pentru a realiza ceea ce
dorim se procedeaza In felul urmator:
se deschide un al doilea fi!?ier;
se copiaza in acesta toate inregistrarile care se gasesc pia sate Tnaintea
celor care se adauga;
se scriu, In continuare, noile lnregistrari;
se copiaza restul inregistrarilor (din vechiul fh;;ier);

vechiul fi ier este ters, iar noul fi ier capata numele vechiu!ui fi ier.
Programul care urmeaza cite te de Ia tastatura lnregistrariie ce se edauga.
Pentru tergere, se folose te procedura ERASE care are -:- ormc: sc;iera!t:
ERASE(var fi:?ier)
lata dE ci Ca un fi$ier poate fj ters j din interiorul unui program.
Redenumirea unui fi$ier este facuta de procedura RE.ii.:,J\E av nd forma
general
a:
RENAME (var fi ier, 'nume')

unde 'nume' este
fi ierului.
un parametru de tip string 9; teprezinta nou: nurr1e al
program ft6;
type inr= record
nume:string[lO];
varsta:byte
end;
fisier;file of inr;
var inreg: inr;
fl,f2:fisier;
c:char;
i:integer;
begin
assign(fl, 1 fdat2');
reset(fl);
assign(2, 1 fisl 1 );
rewrite(f2);
for i:=l to 3 do
begi:1
read(fl,inreg);
write(f2,inreg);
end;
repeat
write( 1 nume 1 ) ;
readln(inreg.nume);
write('v rsta 1 );
readln(inreg.v rsta);
wr.ite(f2. in:r.:eg) ;
write(conti uati ? (y/n)
eadln
un '(. .i.l
=..:
'i
(c);
ai

begin
read(fl,inreg);
write(f2,inreg)
end;
close(fl);
close(2);
erase (fl.);
rename(2, 1 fdat2 1 )
end.
I'
I
'
De multe ori, este necesar sa modificam ur: camp (sau mai multe) al unei
inregistrari (sau ale mai rnultor inregistrari). P: ograrnul ft7 face modificare 1n
campul v8rst2 a! inregistrarii cu numele de ordine 4. Pentru aceasta, se
procedeaza Tn felul urmiHor:
dupa deschiderea fi!?ierului (cu RESET), pozi ionam pointer-ui pe
inregistrarea
care urmeaza a fi modificata (cu SEEK):
se cite!?te inregistrarea;
se
face
modificarea
in
campul
corespunziHor;
Tntrucat, Ia citire, pointer-ul s-a pozitionat pe inregistrarea urmatoare, acesta
se repozitioneaza pe inregistrarea care a fost citita;
aceasta inregistrare este suprascrisa (campul a fost modificat) cu procedura
WRITE.
program ft7;
type inr= record
nume:string[1o];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
begin
assign(f1,'fdat2');
reset(f1);
seek(f1,4);
read(f1,inreg);
inreg,varsta:=70;
seek(f1,4);
write(f1,inreg);
close(f1)
end.
Cum putem sterge una sau mai multe lnregistrari aie fi$ierului? In practica,
pentru aceasta se poate proceda in doua feluri:
inregistrarile se $terg fizic;
lnregistrihile se !?terg lo pic
.
$tergerea fizica nu este posibila decat prin a crea un nou fi$ier care sa nu
cantina inregistrarile care se !?terg. Vechiul fi!?ier este !?ters iar noul fi$ier capata
numele fi$ierului initial (eel din care s-au !?ters inregistraril. Programul care
urmeaza !?terge inregistrarea a patra din fi;;ier.
Din pacate, aceasta modalitate de !?tergere cere mult timp (pentru a !?terge
o inregistrare am creat un alt fi!?ier).
program ftB;
type inr= record
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1,f2:fisier;
i:integer;
begin
assign(f1, 1 fdat2 1 );
assign(f2,'fman');
reset(fl);
rewrite(f2);
for i:=l to 3 do
begin
read(fl,inreg);
write(f2,inreg) end;
seek(f1,filepos(f1)+1);
while not eof(1) do
begin
read(f1,inreg);
write(f2,inreg)
end;
close (1);
close(f2);
erase(f1);
rename(f2,'fdat2')
end.
end.
!?tergerea logica are Ia baza urmatorul mecanism: fiecare Tnregistrare a

fi!?ierului in care urmeaza sa se faca :;;tergeri are un camp in plus i anume un
indicator de !?tergere (is). Convenim ca acest camp sa contina valoarea 1 in
situatia i!" care inregistrarea nu este !?tearsa :;;i sa contina valoarea 0 in caz
contrar. In acest fel, a !?terge o inregistrare inseamna sa modificam campul is
(va lua valoarea 0). Aceasta modalitate de tergere este mult mai rapida, dar
prezinta dezavantajul ca inregistrarile terse raman.pe suport (se ocupa spatiu).
Urmatoarele trei programe creeaza, listeaza !?i efectueaza tergeri pentru un
fi!?ier.
Observa_tie: orice program care lucreaza cu un astfel de fi:;;ier trebuie sa

testeze, pentru fiecare inregistrare, valoarea indicatorului de !?tergere (nu vor
fi supuse prelucrarii inregistrari :;;terse).
program ft9;
type inr= record
is:byte;
nume:string[10];
varsta:byte;
end;
fisier=file of inr;
var inreg:inr;
fl:fisier;
c:char;
begin
assign(f1,'fdat2');
rewrite(fl);
repeat
write(nwne ');
readln(inreg.nume);
write(varsta ');
inreg.is:=1;
write(f1,inreg);
write(continuati? (y/n) ');
readln(c);
until c=n;
close(1)
end.
program ft10;
type inr= record
is:byte;
nume:string[10];
varsta:byte
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
c:char;
begin
assign(f1,'fdat2');
reset(1);
while not eof(1) do
begin
read(1,inreg);
if inreg.is=1 then writeln(inreg.nume,
end;
close(1)
end.
' ,inreg.varsta)
program ft11;
type inr= record is:byte;
nume:string[10];
varsta:byte;
end;
fisier=file of inr;
var inreg:inr;
f1:fisier;
begin
assign(f1,'fdat2');
reset(f1);
seek(1,5);
read(f1,inreg);
seek(f1,filepos(f1)-1);
inreg.is:=O;
write(f1,inreg);
close(1)
end.
Se considera un fi:;;ier. Se cere ca acesta sa fie c;ortat cresciHor (sau

descrescator) dupa valorile unui anumit camp. in prog amul care urmeaza,
fi!Jierul se sorteaza dupa valoarea campului nume (sortart.a alfabetica).
Pentru a realiza sortarea, se foloseste ,,metG,-Ja f)(:fe!or" care a fost

prezentata In cadrul acestui manual. In sen a, se parcurge fi ierul de mai
multe ori :?i se inverseaza lnregistrarile alaturate carer:: 1 ;,-: o:ai1:ea ceruta.
Daca Ia o oarcurgere sa efectuat eel pu in o inversare fi':'ie": 1 se pc;rcurge din
nou.
pr-:.,;:rz_.:-:.1 H-.. 12;
type inr record
:- r e: string (10];
varsta:byte
end;
fisier=file of inr;
var fl:fisier;
i:integer;
inv:boolean;
inrl,inr2:inr;
begin
assign(fl, dat2');
reset(fl);
repeat
in ::: :.:al.se;
for i: o to filesize(fl)-2 do
begin
seek(fl,i);
read(fl,inrl,inr2);
if inrl.nume>inr2.nume then
begin
seek(fl,i);
write(fl,inr2,inrl);
inv: =true
end
end
until not inv;
close(fl)
end.
8.4. Un exemplu de lucru cu un fi ier

Se cere sa se scrie un program care sa permita rrehJ r:'lrea pe calculator a
rezultatelor unui examen de admitere Ia 11ceu. Acest program trebuie sa creeze.
sa actualizeze !?i sa listeze un fi!?ier ce con1ine rezultatele ob inute de fiecare
candidat. Fiecare lnregistrare trebuie sa contina
numele elevului;
nota ob inuta Ia proba 1;
nota obtinuta Ia proba 2;
media generala.
Aceasta aplica ie urmare!?te sa demonstreze complexitatea programelor
care se folosesc In practica. Desigur, exista limbaje specializate pentru scrierea
aplicatiilor de acest gen (DBASE, FOXPRO), lnsa un elev Ia o clasa cu profil
informatica trebuie sa aiba cuno tin!e care sa-i permita 0 in1elegere prcfunda
a ceea ce se lntarnpla de fapt i nu doar cuno tine de suprafa a.
Programul realizeazurmatoarele:
crec;rea fi ierului;
adaugarea uno: Tn:egistrari;
tergere de lnregistrari;
modificarea Tn:egistrarilor;
!> sortarea fi$iert !ui In ordmea descrescatoare a mediilor;
w listarea lui pe monitor, Tn vederea verificarii informatiiio:;
e listarea Ia imprimanta a candida ilor admi i.
...,
e
in afara acestora, programul trebuie sa realizeze $i aite opera!ii cu1T1 ar fi:

" listarea Ia imprimanta a candida ilor respin$i;
e listarea pe monitor atat a candidatilor admi$i, cat i a ce!or respin :.
Aceste functii nu sunt realizate, le propunem ca sxerci\iu.
La sfar:?itul acestui paragraf prezentam schema de principiu a aplicatiei.
Apelul procedurilor care rea!izeaza func!iile specificate este realizat de
procedura APLIC, prezenta In cadrul unita ii de program FIS. Aceasta creeaza
un meniu prin utilizarea unitiHii MENU prezentata In paragraful precedent.
In afara proceduri!or care re.alizeaza funqiile specificate i care vor fi
explica
te ulterior, ma1 este ape lata o procedura numita DIA OG 1.
Procedura DIALOG1 cere numele fi:?ierului de candidati cu care se va iucra In
continuare. Procedura testeaza daca acest fi ier se gase te sau nu pe suportul
magnetic. Rezultatu! este afi at pe ecran. Pentru aceasta se procedeaza astfel:
o se Tncearca deschiderea pentru citire a fi ierului cu nume specificat (opriunile
de compilare { $ i--} i { $i +} ce lncadreaza procedura RESET au rolul de a
in
hiba o eventuala oprire a programului ca urmare a fapt;Jiui ca se Tncearca
deschiderea spre citire a unui fi ier inexistent iar funqia IORESULT returnea
za valoarea 0 In cazul unei operatii de intrare I ie ire reu ite, altfel returneaza
o valoare diferita de 0);
Tn funqie de reu$ita sau nu a opera;iei, se afi eaza mesajLI corespunzator;
o Tn cazul !n care fi ierul a fast deschis spre citire (deci se gase te pe suport)
este Tnchis;
oii numele fi$ierulul este retinut Tn variabila nume f, variabila Ia care au acces
toate procedurile din unitatea de program.
Proceduta CRfARE are rolul de a crea fi ierul cu candidati. Numele sau este
preluat din variabila nume f. Pentru aceasta se procedeaza astfel:
o pentru citirea informa iilor de pe ecran se folose te procedura CITIRE_TAST;
o media generala care este continuta Tn Tnregistrare se calculeaza Tnainte de a
scrie Tnregistrarea In fi ier;
e dupa fiecare Tnregistrare, utilizatorul este Tntrebat daca dorel?te sau nu sa
continue.
Procedura CITIRE TAST apeleaza repetitiv procedura INTERFATA (spre a citi
datele de pe ecran) p na cand utilizatorul considera ca datele tastate sunt corecte.
Procedura INTERFATA realizeaza urmatoarele:
$terge ecranui;
afi:?eaza numarul inregistrarii curente (care urmeaza sa fie citita);

afiseaza in locuri fixe numele informatiilor ce urmeaza a fi citite;
cite!?te in locuri fixe informatiile, procedand in felul urmator:
o citirea propriu-zisa se face in variabile de tip string;
o in cazul notelor, care sunt numere reale, citirea se face in mod repetitiv
pana cand sunt indeplinite simultan conditiile:
continutul tipului string in care au fost citite se poate converti fara eroa
re in variabile reale (pentru aceasta se utilizeaza procedura VAL cu cei
trei parametri: numele variabilei de tip string, numele variabilei reale in
care urmeaza sa se faca conversia :;;i numele variabilei care retine daca
operatia a reu!;>it, caz in care ia valoarea 0, altfl ia o valoare diferita de
0);
notele tastate sunt mai mari ca 0 !;>i mai mici sau egale cu 10;
!?irul citit nu este vid (datorita apasarii din gre:;;eala a tastei RETURN).
Procedura ADAUGARE are rolul de a adauga Ia sfar!?itul fi!?ierului una sau mai
multe inregistrari. Se procedeaza in felul urmator:
se deschide fi:;;ierul pentru citire;
se afla numarul de inregistrari ale fi ierului (pentru aceasta se utilizeaza
functia FILESIZE);
cu ajutorul functiei SEEK se face pozitionarea dupa ultima inregistrare (pe
marcajul sfar itului de fi!?ier);
cu ajutorul procedurii CITIRE T AST prezentate anterior se citesc informatiile
de Ia tastatura;
dupa calculul mediei generale, inregistrarea este scrisa;
procedeul continua pana cand utilizatorul, care este intrebat de fie care data
daca dore!?te sau nu acest lucru, raspunde negativ.
Procedura STERGERE are rolul de a terge o inregistrare. in acest scop se
procedeaza astfel:
se cere numele candidatului ce urmeaza a fi :;;ters;
intrucat in fi:;;iere secventiale nu exista o instructiune capabila de a !?terge o
inregistrare, fi!?ierul de unde urmeaza a fi !;>tearsa inregistrarea este citit iar
fiecare inregistrare diferita de cea care urmeaza a fi !?tearsa este trecuta
intr-un fi ier de manevra;in final, fi ierul initial este !;>ters iar fi!?ierul de mane
vra capata numele fi!?ierului initial;
in plus, daca este gasita inregistrarea ce urmeaza a fi !?tearsa, se
semnaleaza acest lucru intr-o variabila booleana iar Ia sffir!?it utilizatorul !?
tie dadactiu nea de !?tergere a fost incununata de succes sau nu.
Mentionam ca functia POS are rolul de a cauta un sub:;;ir intr-un !?ir !?i in cazul
in care acesta este gasit ia o valoare diferita de 0, in caz contrar ia valoarea 0.
Aceasta functie este'folosita in procedura pentru a cauta numele candidatului in
cadrul variabilei ce retine numele din inregistrarea citita (in felul acesta se evita
cerinta suplimentara ca atat numele prezent in cadrul inregistrarii cat !?i numele
tastat in procedura sa ocupe aceleai pozitii in cadrul variabilelor ce le corespund).
Procedura MODIFICARE are rolul de a modifica o inregistrare din cadrul
fi:;;ierului. Se procedeaza astfel:
se cere numele candidatului a carui inregistrare urmeaza a fi modificata;
se parcurge fi:;;ierul pana cand este gasita inregistrarea corespunzatoare sau
pana cand a fost citit tot fi!?ierul;

daca inregistrarea a fost gasita, pozi!ionam pointer-ul asupra ei (utilizand
func!ia FILEPOS, care furnizeaza numarul de inregistrari deja citite !?i proce
dura SEEK pentru pozi!ionare);
se citesc noile informa!ii corespunzatoare ei prin intermediul procedurii
CITIRE_T AST, informatii care sunt trecute in locul vechii inregistrari;
se semnaleaza utilizatorului daca inregistrarea cu numele citit in procedura
nu a fost gasita.
Procedura SORTARE are rolul de a sorta fi!?ierul de candida!i in ordinea
descrescatoare a mediilor.Pentru aceasta se folose!?te o metoda cunoscuta sub
numele de metoda bulelor. Algoritmul este urmatorul:
se compara media generala a candidatului care se gase!?te in prima
inregistrare cu media generala a candidatului ce se gase!?te in a doua
inregistrare din fi!?ier iar in cazul in care prima medie este mai mica decat a
doua cele doua inregistrari se inverseaza;
se compara in mod asemanator :;;i se inverseaza daca este cazul inregistrarile
a doua cu a treia;
se compara !?i se inverseaza daca este cazul penultima !?i ultima inregistrare
din fi!?ier;
daca in timpul parcurgerii fi:;;ierului s-a efectuat eel putin o interschimbare
de
inregistrari, se reia parcurgerea fi!?ierului,in caz contrar algoritmul se incheie
iar inregistrarile sale sunt sortate.
Procedura LISTARE_P listeaza pe monitor fi!?ierul de candidati. Tn comentariul
acestei proceduri vom preciza urmatoarele:
utilizeaza procedura CAPTAB ce are rolul de a tipari capul de tabel (intrucat
procedura CAPTAB are posibilitatea de a tipari capul de tabel atat pe monitor
cat :;;i Ia imprimanta, aceasta este apelata cu un parametru ce ia valoarea 0
pentru monitorvaloarea 1 pentru imprimanta);
pentru a evita consecintele neplacute ale fenomenului de defilare pe moni
tor, se cere numarul de randuri ce vor fi prezente simultan pe ecran (numar
ce include i cele 4 randuri ocupate de capul de tabel !?i titlul raportului);
dupa fiecare ecran listat utUizatorul este intrebat daca dore!?te sa continue
sau nu listarea.
Listarea Ia imprimanta a candidatilor admi:;;i se face prin apelarea a trei
proceduri:
DIALOG
ADMRESP
LISTARE A.
Procedura DIALOG ii cere utilizatorului numarul de locuri puse Ia dispozi!ia
candida1ilor. Dialogul cu utilizatorul se face luand masurile de protec!ie urmatoare:
de a nu introduce un numar gre:;;it (pentru siguran!a, utilizatorul este intrebat
daca ce a i'1trodus este corect sau nu);
de a inhiba o eventuala intrerupere de program ca urmare a introducerii unei
litere in locul unei cifre.
Procedura ADMRESP calculeaza numarul de candidati admi!?i !?i numarul de
candida1i respin i. Pentru ca un candidat sa fie admis este necesar sa indepli-
21::\
neasca urmatorele conditii:

sa aiba o medie generala mai mare sau egala cl! 5;
in ordinea descrescatoare a mediilor sa aiba o medie care se incadreaza In
numarul de locuri, sau egala cu cea a candidatului uitim admis;
numarul de candidai respini se calculeaza ca diferen1a dintre numarul
candidatilor (numarul de inregistrari din fi ier) i cei admi$i.
Procedura LISTARE_A are rolul de a lista Ia imprimanta candidz;1ii adm!$i. Ea
cere utilizatorului sa furnizeze numarul de randuri ce se vor tipari pe o pagina:
se tipare te capul de tabel utilizand procedura CAPTAB cu parametrui 1
(pentru a lista capul de tabel i titlul Ia iiT'orirnonta);
informatiile corespunzatoare fiecarei inregist 3i sut c :ver it8 in variabile
de tip string (cu procedura STR ce are doi f'"! c!'r!t::T : : .. , ...::1e vancbiiei sursa
:?i numele variabilei destinatie), iar acestea su;t ins:::: i.lte in variabiia de tip
string rand (cu .:::jutorul procedurii INSERT cu trPi pa.o;;r:'etri ::ji anurne variabi!a
destinatie, variabila sursa i lun:1imea pe care sa se faca transferul);
variabila rand este tiparita;
dupa fiecare pagina tiparita se a teapta int oduc8rea noii pagini dupa ca;e
procesul se reia pana Ia tiparirea tuturor candida ilor.
Procedura CAPTAB scrie titlul :?i capul de tabel pe monitor sau !a imprimanta,
di.Jpa parametrul cu care a fost apelata (0 sau 1). Pentru scrierea titlului se apelea
za procedura T!T!..U cu acela!?i parametru (0 sau 1) pentru monitor sau imprin1anta.
Programul utilizator care lanseaza aceasta aplicatie este urmatorul:
program exarnen;
uses fis;
begin
aplic
end.
lata !?i unitatea de program

unit lis;
interface
uses cr .menu,util;
procedure aplic;
implementation
type inr= record
nume:string[20];
notal,nota2,media:real
end;
var nl,n2:real;
nume,nume f:string[20];
tit:string[40];
buf:string[S];
c_er,i,nr_loc,nr_adm,nr_resp:integer;
inreg:inr;
f,h:file of inr;
imprim:text;
240
procedure interfata;
begin
window(l,l,80,25);
textcolor(alb);
clrscr;
cursor(true);
gotoxy(25,1);
write(' inregistrarea ',i);
gotoxy(3,3);
write('nume candidat');
gotoxy(3,5);
write('nota proba 1');
gotoxy(3,7);
write('nota proba 2');
repeat
gotoxy(20,3);
clreol;
readln(nume)
until nume<>
; repeat
gotoxy(20,5);
clreol;
readln(bu);
val(buf,nl,c er)
until (c_er=O)-and (buf<>'') and (nl> O) and (nl<=lO);
repeat
gotoxy(20,7);
clreol;
readln(buf);
val(buf,n2,c er)
until (c_er=O)-and (buf<>'') and (r..2>=0) and (::2<=10);
end;
procedure citire_tast;
var c:char;
begin
repeat
interfata;
gotoxy(3,2 o) ;
write('corect (y/n));
gotoxy(17,20);
c:=readkey;
until c<>'n'
end;
procedure creare;
var c: char;
begin
rewrite();
i:=O;
repeat
i:=i+l;
citire_tast;
inreg.nume:=nume;
inreg.notal:=nl;
inreg.nota2:=n2;
inreg.media:=(nl+n2)/2;
write(f,inreg);
gotoxy(3,21)..;
write(continuati (y/n)
gotoxy(20,21);
c:=readkey;
until c='n';
close()
end;
1 );
procedure dialogl;
var c:char;
begin
textcolor(alb);
clrscr;
gotoxy(10,4);
write(numele fisierului);
repeat
gotoxy(J0,4);clreol;
read(nwne f);
gotoxy(lo-;20};
write(corect (y/n)');
gotoxy(25,20);
readln;
c:-=readkey;
delline until
c='Y';
assign(f,nume ');
{$i-} reset(fi; {$i+}
gotoxy(l0,20);
if ioresult=O then
begin
close(); gotoxy(l0,20};
write('fisierul exista ')
end
else write(fisierul trebuie creat );
delay(2000);
end;
procedure adaugare;
var c:char;
begin
assign(f,nume f);
reset(f);
i:=filesize(f);
seek(f,i);
repeat
i:=i+l; citire tast;
inreg.nume:=nume;
inreg.notal: l;
inreg.nota2:=n2;
inreg.media:=(nl+n2)/2;
242
write(f,inreg);
gotoxy(3,21);
write(continuati
gotoxy(20,21);
c:=readkey;
until c='n';
close();
end;
(y/n)
1 );
procedure stergere;
var c:inr;
num:string[SO];
gasit:boolean;
a:string[l];
begin
window(l,l,80,25);
textcolor(alb);
clrscr;
write('numele candidatului pe care il stergeti: );
readln(num);
assign(f,nume f);
reset(f);
assign(h,man.dat);
rewrite(h);
gasit:=false;
while not eo() do
begin
read(f,c);
if pos(num,c.nume)<>O
then gasit:=true
else write(h,c);
end;
if gasit
then writeln ('succes-inregistrare stearsa)
else writeln ('inregistrare negasita ');
close();
close(h);
erase(f);
rename(h,nume f);
gotoxy(l,20);
writeln('apasati'o tasta...);
a:=readkey
end;
procedure modificare;
var c:inr;
num:string[SO];
gasit:boolean;
a:string[l];
begin
window(l,l,89,25);
textbackground.(negru);
textcolor(alb)";
clrscr;
cursor(true);
write ('numele candidatului ce urmeaza a fi modificat?

readln(num);
gasit:=false;
while (not eof(f)) and (not gasit) do
begin
read(f,c);
if num=c.nume then gasit:=true;
end;
i: =filepos(f);
if gasit then
begin citire_tast;
c.nume:=nume;
c.notal:=nl;
c.nota2:=n2;
c.media:=(nl+n2)/2;
seek(f,i-1);
write(f,c);
end
else writeln(nu exista aceasta inregistrare');
writeln('apasati o tasta);
a:=readkey;
close(f)
end;
procedure sortare;
var c,d:inr;
n,j:integer;
inversari:boolean;
begin
assign(f,nume f);
reset();
n:=filesize(f);
repeat
inversari:=false;
for j:=0 to n-2 do
begin
seek(f,j);
read(f,c);
read(f,d);
if d.media>c.media
begin
seek(f,j);
write(f,d);
write(f,c);
inversari:=true
end
end
close()
end;
then
procedure titlu(t:integer);
var c:char;
begin
if t=o then
');
begin clrscr;
gotoxy(14,1);
write(tit)
end
else
begin
writeln('deschideti imprimanta');
writeln('apasati o tasta ');
c:=readkey;
repeat
{$i-}
writeln(imprim,tit);
{$i+}
until ioresult=O
end;
end;
procedure captab(t:integer);
var a,b:string[60];
begin
a:= '**************Y*********************************;
b:= '*nc*
nume elev
*notal* nota2 *media*';
titlu(t);
if t=o then
begin
gotoxy(l,2);write(a);
gotoxy(1,3);write(b);
gotoxy(l,4);write(a):
end
else
begin
a:='
'+a; b:='
'+b;
writeln(imprim,a);
writeln(imprim,b);
writeln(imprim,a;;
end
end;
procedure listare_p;
var nr rand,j:integer;
c:string[l];
begin
tit:='lista de verificare';
repeat
window(l,l,B0,25);
texccolor(alb);
clrscr;
cursor(true);
write('cite randuri sa se tipareasca pe ecran?
readln(nr rand)
until (nr rind>=4) and (nr_rand<=20);
');
c: = 'y';
i:=l;
while (not eo()) and (c<>'n') do
begin
j: =5;
captab(O);
while (j<=nr rand) and (not eof(f)) and (c<>'n') do
begin
read(f,inreg); gotoxy(2,j);
write(i); gotoxy(S,j);
write(inreg.nume);
gotoxy(26.,j); write(inreg.notal:2:2);
gotoxy(34,j); write(inreg.nota2:2:2);
gotoxy(42,j); write(inreg.media:2:2);
j:=j+1 i
i:=i+l end;
gotoxy(1,21);
write('continuati? (y/n) ');
gotoxy(20,21);
readln(c);
end;
clbse(f)
end;
procedure listare a;
var c:char;
n,j,k:integer;
rand :string[60];
man:string[3];
manl:string[S];
begin
if nr adm<>O then
beginclrscr;
assign(f,nume );
reset();
t:epeat
write('cate randuri pe pagina (5..55) ');
{$i-} readln(n) {$i+}
until (ioresult=O) and (n>=5) and(n<=55);
j: =1;
assign(imprim,prn');
rewrite(imprim);
repeat
k:=5;
tit:=' candida i admi i;
captab(l);
repeat
read(f,inreg);
rand:='
I'
man:='
I
manl:='
';
str(j,man);
insert(man,rand,2);
insert(inreg.nume,rand,S);
str(inreg.notal:2:2,manl);
insert(manl,rand,26);
str(inreg.nota2:2:2,manl);
insert(manl,rand,34);
str(inreg.media:2:2,manl);
insert(manl,rind,42);
rand::I
I +rand;
writeln(imprim,rand);
j:=j+l;
k:=k+l
until (k=n) or (j=nr_adm+l)
until j=nr adm+l;
close();close(imprim)
end
end;
procedure dialog;
var c:char;
begin window(l,1,80,25);
textcolor(alb);
cursor(true);
clrscr;
repeat
repeat
write( 1 cate locuri sunt? ');
{$i-} readln(nr loc);{$i+}
until ioresult=o7
write (1 corect (y/n) 1 );
readln(c);
until c= 1 y 1
end;
procedure admresp;
var c:inr;
n:real;
d:char;
begin
nr adm:=o;
assign(f,nume );
reset(f);
repeat
read(f,c);
if c.media>=S then nr adm:=nr adm+l
until eof(f) or (c.media<S) or(nr_adm=nr_loc);
n:=c.media;
while (c.media=n) and (n>=S) and (not eof\f))do
begin
read(f,c);
if c.media=n then nr_adm:=nr_adm+l;
end;
nr resp:=filesize(f)-nr adm;
clrscr;
221
writeln( 1 nr adrn= 1 , nr adrn);

writeln( 1 nr-resp=,nr resp);
close(f); writeln( 1 apasati o tasta 1 );
d: =readkey
end;
procedure aplic;
var a:men;
b:string;
begin
dialog1;
clrscr;
b:,= 1 CREARE
ADAUGARE
b:=b+ 1 MODIFICARE
SORTARE
STERGERE
I;
'
b:=b+ 1 LIST-PROB LIST-ADMS 1 ;

a.deschidrn(2,1,77,1,rosu,verde,0,1l,O,'c,fa1se);
repeat
if a.selectat then a.salvez;
case a.citxb of
1: creare;
12: adaugare;
23: stergere;
34: modificare;
45: sortare;
56: listare_p;
67: begin
dialog;
admresp;
listare a
end
end {case};
a.restaurezm
until a.inchis
end;
end.
Schema de pr:ncipiu a aplica1iei:
Figura 8.4.1.
SORTARE
8.5. Fi iere
fara tip
Fi!?ierele fara tip sunt constituite din blocuri de lungime fixa, motiy pentru
care acestea sE: iilai nurnesc i fi iere cu prelucrare Ia nivel de bloc. In cadrul
blocurilor, inforrnatia se scrie direct sub forma in care apare In memoria interna,
fara a se converti.
Blocurile se numeroteaza cu numere cuprinse intre 0 !?i n. Din acest motiv
se poate folosi procedura SEEK in forma cunoscuta !?i ea are rolu! de a
pozi iona pointer-ul pe un anume bloc. 0 variabila de tip fi ier fara tip se
declara cu ajutorul cuvantului cheie FILE.
Exemplu: a:file;
Asignarea fi ierului Ia suportul extern se face cu ajutorul procedurii ASSIGN,
exact cum se procedeaza !?i in cazul celorlalte tipuri de fi iere.
Deschiderea fi ierelor pentru creare se realizeaza cu ajutorul procedurii
REWRITE. Forma generala a acestei proceduri este:
REWRITE(var nume fi!?ier,[numar de octeti pentru un bloc))
in cazul in care al doilea parametru este absent. blocul va avea o lungime
standard de 128 octeti.
Scrierea blocurilor se face cu ajutorul procedurii BLOCKWRITE care are
urmatoarea forma generala:
BLOCKWRITE(nume fi9ier, nume variabila In care se face citirea, numar de
blocuri care se citesc [,variabila ce retine numarul de blocuri efectiv citite]).
in cazul in care ultimul parametru este absent !?i se citesc mai putine blocuri
decat au fost solicitate, procedura se termina cu eroare de intrare I ie9ire.
Programul care urmeaza creeaza un fi ier tara tip cu n inregistrari.
program fftl;
type inreg= record
nume:string[16];
varsta:integer;
end;
var f:file;
inr:inreg;
n,i:integer;
begin
assign(f,'fblk');
write( 1 n= 1 ) ;
readln(n);
rewrite(,19);
for i:=l ton do
begin
write('nume= 1 );
readln(inr.nume);
write( 1 varsta= 1 );
readln(inr.varsta);
249
end;
close()
end.
Deschiderea pentru citire (sau scriere, in caz de actualizare a fi!?ierului) se

face cu ajutorul procedurii RESET care are forma de apel:
RESET(variabila fil?ier [,numar de octeti pe care a fost scris blocul]).

Citirea unui bloc se face cu ajutorul procedurii BLOCKREAD, in care:
BLOCKREAD(variabila fi!?ier, variabila unde se face citirea, numarul de blocuri
care se vor citi[, variabila care retine numarul de blocuri efectiv citite]).
Sfar!?itul de fi!?ier se testeaza cu ajutorul functiei booleene EOF, Ia fel ca i
Ia celelalte tipuri de fi!?iere.
Programul care urmeaza cite!?te fi!?ierul care a fost creat anterior.
program fft2;
type inreg= record
nume:string[16];
varsta:integer;
end;
var f:file;
inr:inreg;
begin
assign(f, 1 fblk 1 );
reset(,19);
while not eo() do
begin
blockread(f,inr,1);
writeln(inr.nume, 1
end;
close(f)
end.
inr.varsta)
Nu este obligatoriu sa citim un fi ier fara tip intr-o variabila de tip record.
Blocul se memoreaza incepand cu o anumita variabila, pe toata lungimea lui
(acolo trebuie sa se gaseasca alte variabile in care sa se faca memorarea). Un
exemplu,in acest sens, il constituie programul urmator (listeaza acelai fi ier).
program fftl;
{$a-}
var :file;
nume:string[16];
varsta:integer;
begin
assign(, 1 fblk 1 );
reset(,19);
while not eo() do
begin blockread(f,nume,l);
1 , Varsta)
Writeln(nume, I
end;
close()
end.
Ne putem intreba care este rezultatul optiunii de compilare {$a-}. in

absenta ei, compilatorul rezerva spatiu pentru variabile in memoria interna,
dupa un anumit mecanism. Astfel, pentru o variabila de tip integer se rezerva
doi octeti Ia o adresa multiplu de 2. Din acest motiv, apar octeti neocupati de
variabile, care insa sunt folositi Ia citirea blocului. in acest fel, e'ste posibil.sa
nu regasim rezultatele pe care le a!?teptam. Rolul optiunii de compilare este
acela de a comanda compilatorului ca toate variabilele sa fie retinute Ia adrese
multiple de
1 (deci nu raman octeti nerezervati).
$i pentru aceste fi!?iere poate fi folosita funqia FILESIZE Ia fel ca Ia cele cu
tip. Toate operatiile de actualizare se fac Ia fel ca Ia fi9ierele cu tip, motiv
pentru care nu le prezentam aici.

8.6.1. Aplicatii ale fi ierelor
8.6.1.1. Fi iere text
1. Scrieti un program care creeaza un fi!?ier text.
Observatie. Un fi!?ier text poate fi creat !?ide Ia tastatura prin comanda COPY
CON, dupa care se introduc liniile acestuia (liniile se separa prin enter, iar Ia
sfar!?it se apasa simultan tastele (CTRL + Z).
2. Se considera un fi!?ier text cu mai multe inregistrari. Sa se afi!?eze pe
monitor (se va tine cont ca dupa scrierea a 20 de randuri sa se a!?tepte
apasarea unei taste).
3. Aceea!?i problema, numai ca fi!?ierul se va copia Ia imprimanta (pentru o
pagina de format A4 se vor scrie 55 de randuri).
4. Sa se creeze un fi!?ier text care contine !?i inregistrari cu un numar mai

mare de 65 de caractere. Fi!?ierul se va gasi pe unitatea a.
5. Utilizand fi!?ierul text de Ia problema anterioara, sa se creeze un alt fi!?ier

text in felul urmator:
o inregistrare cu un numar mai mic sau egal cu 65 de caractere se va copia
identic in eel de-al doilea fi!?ier;
o inregistrare cu un numar mai mare de 65 de caractere se va transforma in
doua sau mai multe lnregistrari cu 65 de caractere (exceptie, eventual,
ultima).
6. Se considera un fi!?ier text cu mai multe inregistrari. Sa se scrie un
program care numara aparitiile unui cuvant. Separatorii pentru cuvinte sunt:
spatiul, punctul, virgula sau sfan?itul unei lnregistrari.

7. Se citesc, dintr-un fi!?ier text, n, Tntreg, l?i n valori intregi. Sa se
tipareasca minimul din cele n valori.
Observatie. in concursurile !?Colare, datele de test, furnizate de comisie, se

gasesc in fi!?iere text. Programul candidatului trebuie sa citeasca aceste date
din fi!?ier.
8. in cazul programelor care listeaza situatii complexe se procedeaza l?i
astfel:
situatia este scrisa intr-un fi!?ier text;
fi!?ierul text astfel creat se listeaza atunci cand este cazul.
lmaginati o situatie care va fi scoasintr-un fi!?ier text (atentie Ia aliniere).
9. Scrieti un program care listeaza fi!?ierul text creat Ia problema anterioara.
lndicatii:
7.
program maxim;
var a:text;
n,i,max,v:integer;
begin
assign(a,'f.dat);
reset(a);
read(a,n);
read(a,max);
for i:=2 ton do
begin
read(a,v);
if max<v then max:=v
end;
writeln('maximul este ,max);
end.
8.6.1.2. F iere cu tip
1. Sa se creeze un fi!?ier cu inregistrari care au urmatoarea structura:

cod material: string[5];
denumire material: string[20];
cod magazie: integer;
cantitate: real;
unitate de masura: string[4];
pret unitar: real.
Citirea campurilor unei inregistrari se va face In pozitii fixe. Datele referitoare

Icantitate !?i pret unitar vor fi validate din punct de vedere al naturii numerice.
(In situatia in care o inregistrare nu este valida, calculatorul va emite un sunet
iar cursorul se va pozitiona pe campul incorect.) Se va testa daca fi!?ierul exista
sau nu pe suport iar in caz afirmativ se va avertiza operatorul.
2. Sa se scrie un program care actualizeaz2 fi!?ierul din problema precedenta.
in acest sens, se va deschide un meniu cu trei operatii posibile:

adaugare - se adauga Ia sfar!?itul fi!?ierului o inregistrare citita dupa regulile
prezentate in problema anterioara;
!?tergere - se identifica inregistrarea care va fi !?tearsa dupa continutul
campurilor cod material !?i cod magazie (in caz ca nu este gasita se da un
mesaj de eroare);
modificare - se modifica continutul unei inregistrari identificata dupa cod
material !?i cod magazie (In caz ca lnregistrarea nu este gasita se da mesaj
de eroare);
pentru modificare se afi!?eaza inregistrarea cu valorile curente ale campurilor
(cursorul se afla pozitionat pe valoarea existenta in primul camp);
cu aj4torul sagetilor (sus, jos) putem deplasa cursorul pe valorile continute
in alte campuri;
campurile se pot modifica (!?tergerea unui caracter aflat in stanga cursorului,
inserarea unuia sau mai multor caractere);
odata corectata o astfel de inregistrare se apasa ENTER (in situatia in care
un camp este incorect, calculatorul va emite un sunet iar cursorul se va gasi
asupra acelui camp).
3. Sa se scrie un program care sorteaza fi!?ierul descris anterior dupa valorile

campului cod material.
4. Sa se scrie un program care sorteaza fisierul dupa cod magazie, iar in
cadrul acestuia dupa cod material (sortare du.pa doua chei). in mod practic,
fi!?ierul va contine lnregistrarile magaziei cu eel mai mic cod sortate dupa codul
material, urmate de 'fnregistrarile magaziei cu codul imediat superior, sortate
dupa codul materialului etc.
lndicatie. Alaturati cele doua coduri (intai codul magazie, apoi codul material)
intr-o variabila de tip string. Sortati fi!?ierul dupa aceasta valoare.
Altfel: realizati o procedura care sorteaza dupa cod material inregistrarile
dintr-un fi!?ier aflate intre anumite limite. Initial se sorteaza dupa cod magazie
tot fi!?ierul, apoi cu procedura scrisa se sorteaza inregistrarile care au acela!?i
cod magazie dupa cod material.
5.
Sa se scrie un program care scoate Ia imprimanta situatia caracterizata
astfel:
titlul va fi "SITUATIA MATERIALELOR PE MAGAZII";
subtitlul 1 va fi "MAGAZIA ...'';
cap tabel (cuprinde informatii referitoare Ia o lnregistrare);
lnregistrarile cu materialele din prima magazie;
total valoric pe magazie;
subtitlul 2 va fi "MAGAZIA ..."
cap tabel;
inregistrari cu materiale din cea de-a doua magazie;
total valoric pe magazie;
total valoric general (suma valorilor pe toate magaziile);
Programul va fi realizat in urmatoarele conditii:
se a!?teapta ca imprimanta sa fie operationala;
dupa ce au fost scrise datele referitoare Ia o magazie se sare Ia pagina noua,
se continua listarea dupa apasarea tastei ENTER, numai daca imprimanta

este pregatita de lucru.
6. Scrieti o aplicatie complexa care tine evidenta elevilor unui liceu (nume,
note pe materii !?ian !?Colar, etc.). Aplicatia va folosi in diverse raportari tacute
de liceu Catre inspectoratele !?COiare.
Observatii. Aceasta aplicatie se va realiza de o grupa cu cl putin cinci elevi.

La realizarea aplicatiei se va consulta secretariatul liceului. lncercati sa puneti
in practica aplicatia realizata. Daca aceasta nu a fost bine gandita nu se va
utiliza. Daca dupa toate perteqionarile aduse, tot nu se utilizeaza - v-ati lovit
de adevarata problema a intormaticii Ia noi in tara.
7. Se considera un fi!?ier cu inregistrari care au o structura Ia alegerea
dumneavoastriL Fi!?ierul este sortat crescator dupa valorile unui camp. Se cere.
sa se precizeze daca o anumita inregistrare se gase!?te sau nu in ti!?ier.
(Generalizare pentru tis iere a problemei cautarii.) ,.
8. Se considera o matrice cu m linii !?in coloane. Se presupune ca matricea

nu incape in memorie. Ca urmare a acestui fapt este re inuta intr-un ti!?ier in
care fiecare inregistrare retine un element a[i,j]. Matricea este retinuta pe linii
(intai toate elementele din prima linie, in ordinea coloanelor, apoi cele din linia
2 in ordinea coloanelor .a.m.d.). Sa se scrie o funqie care returneaza
elementul a[i,j].
9. Adunati doua matrice cu m linii !?i n coloane care sunt retinute in ti!?iere
ca -aceea din problema anterioara.
10. Calculati suma elementelor plasate sub diagonala principala a unei
matrice patratice retinuta intr-un fi!?ier.
8.6.1.3. Fi iere
fara tip
1. Scrieti o procedura care creeaza un tisier fara tip care are o singura
inregistrare !?i anume o imagine ecran.
lndicatie. Se copiaza continutul memoriei video.

,2. Scrieti o procedura care reface o imagine citita dintr-un ti$ier fara tip
(creat Ia problema precedenta).
3. Scrieti o procedura care salveaza continutul unei ferestre intr-un fi!?ier tara tip.
4. Scrieti o procedura care reface
procedura anterioara.
continutul unei terestre salvat prin
5. Concepei un meniu care va fi salvat !?i restaurat utilizand procedurile de

mai sus.
6. 0 aplicatie deosebit de importanta a fi!?ierelor tara tip este aceea ca se
poate exploata, ca fi!?ier fara tip, orice fi!?ier. Sa se scrie un program care
copiaza un fi!?ier cu un nume care se cite!?te, intr-un alt fi!?ier cu un nume citit.
Datorita importantei pe care o are aceasta problema, programul se prezinta
mai jos.
program fft;
var a,b: file:
inr:byte;
nume,numel:string;
begin
write('numele fisierului care se copiaza:');
readln(nume);
write('numele noului fisier:');
readln(numel):
assign(a,nume);
assign(b,numel);
reset(a,1):
rewrite(b,l);
while not eof(a) do
begin
blockread(a,inr,l);
blockwrite(b,inr,l)
end;
close(a);
close(b)
end.
7. Scrieti un program care vizualizeaza cate 80 de caractere consecutive ale

unui fi!?ier. Deplasarea in cadrul fi!?ierului se realizeaza cu ajutorul sage ilor.
Capitolul 9
Unitatea de program DOS

9.1. Prelucrarea datei
Unitatea de program DOS contine
modificarea datei !?i orei.
4 proceduri
care permit
citirea !?i
Procedura GETDATE(an, luna, zi, zi sapt: word) returneaza data curenta.

Ziua din saptamana este returnata ca un numar "fntre 0 !?i 6, unde 0 lnseamna
duminica.
Procedura GETTIME(ora, minut, secunde, sutimi: word) returneaza ora exacta.
Programul care urmeaza afi!?eaza data !?i ora exacta.
program timp;
uses dos;
var an,luna,zi,ora,minut,secunda,zi_sapt,sutimi:word;
begin
getdate(an,luna,zi,zi_sapt);
writeln('data curenta);
writeln(anul ,an);
writeln(luna ,luna);
writeln(ziua
,zi);
case zi sapt of
o: wrTteln(duminica);
1: writeln('luni');
2: writeln('marti);
3: writeln('miercuri');
4: writeln(joi');
5: writeln(vineri);
6: writeln(sambata)
end {case};
gettime(ora,minut,secunda,sutimi);
writeln(ora ,ora);
writeln('minute ,minut);
wr-iteln( secunda ,secunda)
end.
Procedura SETDA TE(an, luna, zi: word) modifica data curenta retinuta de
sistem.
Procedura SETTIME(ora, minut, secunda, sutimi:word) modifica ora exacta
retinuta de sistem.
9. 2. Cautarea unui fi ier

in multe aplica ii este necesar sa cautam un fi!?ier. A gasi un fi!?ier inseamna
sa gasim calea catre el. Func ia FSEARCH are exact acest rol. Exemplu: ne
propunem sa cautam fi!?ierul TPC.EXE (acesta este un program livrat de firma
BORLAND care compileaza un fi!?ier text cu extensia .PAS). Funqia FSEARCH
are doi parametri formali: numele fi!?ierului care se cauta !?i cataloagele sau
subcataloagele In care se face aceasta cautare.
in f!_xemplu/ care urmeaza se cauta fi!?ierul TPC.EXE in cataloagele WS TP !?i
BGI. In cazul In care fi!?ierul este gasit se returneaza calea catre acesta (de
exemplu C:\TP\TPC.EXE), in caz contrar se returneaza !?irul vid.
program caut;
uses dos;
begin
writeln(fsearch('tpc.exe,c:\ws;c:\tp;c:\bgi'));
end.
Cateodata este utiI sa cautam un fi!?ier in toate caile definite prin PATH in
fi!?ierul AUTOEXEC.BAT (aici, se dau caile de cautare separate PJin ";"). Funqia
GETENV returneaza valoarea unei variabile din mediul DOS. Cum valoarea acestei
variabile este l?irul de cai precizat mai sus, cautarea se face prin utilizarea lor.
program cautl;
uses dos;
begin
writeln(fsearch( 1 tpc.exe,getenv('path')));
end.
Observa.tie. in cazul in care fi!?ierul se gase!?te in mai multe cataloage este

returnata numai prima cale in care a fost gasit.
9.3. Execu1ia unui program

Un program poate apela spre executie unul sau mai multe programe. Tnain!e
de a prezenta acest lucru, analizam parametrii de apel ai unui program. In
general, apelul unui program executabil se face prin numele lui. Uneori, acesta
este urmat de unul sau mai multi parametri. De exemplu, apelul editorului !?i
compilatorului TURBO PASCAL se poate face !?i prin cuvantul TURBO urmat de
un nume (acesta precizeaza cum se nume!?te fi!?ierul text care contine
programul sursa). Unele programe (de exemplu ARJ) apelate fara nici un
parametru se autoprezinta, iar apelate cu unul sau mai mul i parametri
realizeaza ceea ce li se cere prin ace!?ti parametri. Parametrii (daca sunt mai
mul i) sunt separai prin spatii. Atunci cand scriem noi un astfel de progrflm
(care va fi apelat prin parametri) trebuie sa putem afla doua lucruri:

care este numarul de parametri cu care a fost apelat programul?
care sunt parametrii cu care a fost apelat?
Numarul de parametri cu care a fost apelat programul este dat de funqia
PARAMCOUNT, funqie de tip WORD. Continutul unui parametru poate fi gasit
cu ajutorul funqiei PARAMSTR(i). Aceasta returneaza un !?ir care contine
parametrul i.
Programul care urmeaza deschide un fi!;iier text !?i cite!?te o prima linie a sa
(nu mai mult de 255 de caractere). Numele fi!;iierului este dat ca parametru Ia
apelul acestui program. Atentie! Pentru a putea testa acest program, este
necesar ca el sa fie intr-o forma executabila. Apelati acest program dand ca
parametru numele unui text sursa PASCAL.
Observatie: cele doua funqii prezentate nu apartin unitatii DOS.
program tparam;
var a:text;
b:string;
begin
if paramcount=l then
begin
assign(a,paramstr(l));
reset(a);
read(a,b);
writeln(b);
close(a);
end
else writeln(precizati numele fisierului');
end.
Revenim Ia problema initiala !?i anume cum putem apela spre executie, din
cadrul unui program, un altul. Acest apel este realizat de procedura EXEC.
Aceasta procedura are doi parametri:
primul este dat de !?irul ce contine numele programului care urmeaza sa se
execute;
al doilea reprezinta !;iirul parametrilor de apel ai programului care se va
executa (daca acest !?ir este vid se presupune ca programul nu este folosit
cu parametri de apel).
Procedura EXEC trebuie sa fie precedata l?i urmata de apelul unei alte
proceduri numita SWAPVECTORS. Rolul acestei proceduri este mai greu de
explicat cu ajutorul cuno tintelor pe care le avem in acest moment. Retinem ca
ea salveaza i restaureaza sistemul de intreruperi ale programului care face
apelul. Programul care urmeaza sa fie rulat are nevoie de memorie interna unde
sa fie lncarcat. Din acest motiv, se folose te directiva de compilare $M.
Cu ajutorul acestei directive se reduce marimea stivei pe care o ocupa progra
mul (dimensiunea ei este data de primul parametru) i se precizeaza de asemenea
minimul i maximul zonei HEAP (ultimii doi parametri). Despre stiva !?i heap se
invata in anul urmator, aa ca, aici, ne multumim sa afirmam ca dimensiunea
acestora se reduce pentru a putea fi incarcat programul ce va fi executat.

Programul care urmeaza apeleaza spre executie un altul care se nume!?te
CITEL. Acesta nu are parametri de lansare in executie (al doilea parametru al
procedurii EXEC este !?irul vid).
program exemplu;
{$m 4000,0,$1oooo}
uses dos;
begin swapvectors;
exec(citel.exe','');
swapvectors
end.
Programul exemplu2, pentru a putea fi testat trebuie sa fie executabil. El

este apelat cu un parametru care contine numele unui executabil ce va fi
lansat in executie.
program exemplu2;
{$m 4000,0,$10000}
uses dos;
begin
if paramcount=1 then
begin
swapvectors;
exec(paramstr(l), );
swapvectors
end
end.
Programul exemplu3 cauta compilatorul PASCAL numit TPC. in mod normal,

apelul acestuia se face prin comanda TPC urmata de numele unui fi!?ier care
contine un text sursa PASCAl !?i are rolul de a compila textul sursa !?ide a cr9a
un executabil. Daca programul TPC este gasit, este lansat in executie spre a
compila un text sursa al carui nume se cite!?te In variabila de tip string B.
program exemplu3;
{$m 4000,0,$10000}
uses dos;
var a,b:string;
begin
a:=fsearch(tpc.exe,getenv('path'));
if a<>'' then
begin
write('compilam programul :');
readln(b);
exec(a,b)
end
end.
Un program se poate termina cu ajutorul unei proceduri numita HALT.

Aceasta intrerupe brusc executia programului (de multe ori este folosita pentru
ie!?iri fortate, fapt care incalca principiile programarii structurate). Aceasta
procedura are lnsa !?i un mare avantaj !?i anume ca poate fixa un cod de retur
cu care s-a terminat un program. Pentru a putea realiza aceasta ultima functie,
se apeleaza prin HALT(i). De exemplu, putem lncheia executia unui program
prih HALT( 1 ), ceea ce inseamna ca programul s-a terminat cu codul de retur
1. Acest cod de retur poate fi exploatat de un program care a apelat spre
executie un altul. De exemplu, in functie de situatie, un program se poate
incheia cu codul de retur 0 (daca nu s-a folosit HALT sau s-a lncheiat cu
HALT(O) sau cu un alt cod de retur). in functie de valoarea codului de retur se
poate lua in mod automat o decizie sau alta.
Daca a fost dat spre compilare programului TPC un text care contine erori
de sintaxa (compilarea nu a reu!?it) programul se termina cu un cod de retur di
ferit de 0,in caz contrar se termina cu codul de retur 0. Functia DOSEXITCODE
(de tip word) cite!?te codul de retur cu care s-a terminat un program.
in final, mentionam faptul ca unitatea DOS contine multe alte proceduri !?i functii
pe care nu le prezentam aici pentru ca depa:;;esc cu mult nivelul acestei clase.
9.4. Probleme propuse

1. Scrieti un program ,de:;;teptator" care cite!Jte o ora Ia care calculatorul va
emite un sunet.
2. Scrieti o secventa care efectueaza un anumit calcul. Cum putem preciza
timpul ei de rulare?
3. Aflati numarul de zile pe care le-ali trait (data curenta o preluam din sistem).
4. Completati programul de Ia jocul CENTRATE (vezi ca itolul referitor Ia
subprograme) in a!?a fellncat parteneruluman sa piarda daca :;;e!?te un anumit
timp pana efectueaza o mutare. Timpul scurs va fi prezent mpul pe ecran.
5. Scrieti un program care creeaza i actualizeaza un fi!?ier cu un nume care
figureaza ca parametru de apel pentru program.
6. Scrieti un program care copiaza un fi ier. Numele fi!?ierului sursa !?i eel al
fi!?ierului destinatie se dau ca parametri de apel.
7. Scrieti un program care selecteaza spre executie alte trei programe.
Selectia se va face utilizand un meniu.
8. Scrieti un program care cite!?te un vector. Programul se termina cu codul
de retur 0, daca vectorul are componentele distincte !?i 1 In caz contrar. Acest
program va fi apelat spre executie de un altul, In mod repetitiv, pana cand
vectorul citit va avea componentele distincte.
Capitolul 10
Grafica pe calculator
10.1. lntroducere
in perioada actuala este de neconceput sa realizam programe care se pot
utiliza in practica, tara sa folosim grafica pe calc1,1lator. De multe ori un desen
valoreaza mai mult decat o mie de vorbe. Explicai cuiva cum se ajunge acasa
Ia dumneavoastra 9i veti observa ca in elege mai u9or acest lucru dupa un
desen.
Limbajul TURBO PASCAL contine o serie de proceduri 9i functii care, chiar
daca nu stralucesc di(l_punct de vedere al moduluiin care func ioneaza, permit
realizarea unor aplicatii grafice. Acestea sunt reunite in unitatea GRAPH care
se gase9te In subcatafogul BGI. in cadrul acestui capitol se vor prezenta o serie
de proceduri 9i func ii, des folosite, cu rol didactic, care se gasesc intr-o
unitate de program numita UTILG, prezentata Integral Ia sfar9itul acestui
capitol.
10.2. lnitializarea modului grafic

Pentru ca o imagine sa poata aparea pe ecran, calculatorul trebuie inzestrat
cu o placa grafica ce contine memoria video (in care se retin informatii asupra
imaginii). Exista mai multe tipuri de placi grafice (CGA, EGA, VGA) care difera
prin memorie 9i alti parametri. intrucat fabricantii acestor placi nu au ajuns Ia
o concluzie comuna in ceea ce prive:;;te folosirea lor, un program care functio
neaza perfect pe una din ele nu se poate folosi pe o alta. in concluzie, orice
limbaj care folose9te aceste placi trebuie sa cantina rutine specifice lor. in
acest sens, limbajul TURBO PASCAL contine mai multe componente soft care
lucreaza cu diversele placi, numite DRIVERE. in functie de placa grafica gasita,
se lncarca un driver sau altul. Acestea se gasesc in fi9iere cu extensia .BGI.
Astfel, exista drivere CGA, VGA etc. Odata ales un driver se alege modul de
lucru: in unele moduri de lucru avem o rezolutie mai buna (se reprezinta mai
multe puncte pe ecran) dar avem mai putine culori 9i se pot retine mai putine
pagini video (informatia referitoare Ia imaginea grafica continuta de un ecran),
in altele avem o rezolutie mai proasta dar putem reprezenta un desen utilizand
mai multe culori 9i putem retine mai multe pagini video. Deci, un mod de lucru
este un compromis intre numarul de culori, rezolutie 9i numarul de pagini video.
in acest capitol nu vom studia placi grafice depa9ite moral cum ar fi cele CGA
:;;i EGA. Ne vom concentra aten ia in special asupra placii VGA, careia ii
corespunde driverul VGA care poate Iuera in mai multe moduri de lucru:
1. modul VGALo cu o rezolu\ie de 640 * 200, poate folosi 16 culori Ia un
moment dat 9i retine 4 pagini video;
2.
modul VGAMED cu o rezolutie de 640* 350, 16 culori, 2 pagini video;
3. modul VGAHI cu rezolutie 640*480, o singura pagina video, 16 culori.
Selectarea driverului !?i a modului de lucru se face prin utilizarea procedurii
INITGRAPH. Aceasta are trei parametri: gdriver (integer) care contine driverul
(codul asociat acestuia), gmode (integer) care con ine modul de lucru !?i ova
riabila de tip string care arata calea catre unitatea GRAPH. Forma generala a
acestei proceduri este: INITGRAPH(gdriver,gmode,'cale'). Primii doi parametri
sunt transmi!?i prin referinta. lnitializarea sistemului grafic se poate face in doua
moduri:
prin a solicita sa se identifice automat placa grafica !?i corespunzator ei sa
se incarce un anumit driver !?i sa se selecteze un anumit mod de lucru (in
acest caz se alege acel mod de lucru care are cea mai buna rezolutie
grafica);
prin indicarea cu ajutorul primilor doi parametri a unui driver !?i a unui mod
de lucru solicitate de programator (un astfel de program nu se poate executa
daca nu avem placa grafica corespunzatoare);
In cazul primului mod de initializare se poate folosi procedura INITG care se
gase9te in unitatea UTILG.
procedure initg;
begin
gdriver: =detect;
initgraph(gdriver,gmode,c:\tp\bgi');
if graphresult<>o then
begin
writeln('tentativa esuata);
halt
end
end;
Constanta DETECT
are
valoarea 0
!?i ii specifica procedurii
identificarea automata a driverului !?i a modului de lucru.
Tentativa de initializare 9 dfica poate e!?ua din diverse motive cum ar fi: Iipsa
uniHitii GRAPH, calea indicata este gre!?ita etc. Pentru a testa daca initializarea
modului grafic a reu!?it se folose!?te functia intreaga GRAPHRESULT care
returneaza valoarea 0 in caz afirmativ si o valoare diferita de 0 in caz contrar.
in caz de nereu!?ita se opre!?te fortat p ogramul (halt). in acest caz se renunta
Ia programarea structurata, insa este absurd sa scriem intregul program sub
clauza ELSE.
in cazul modului 2 de initializare se poate folosi o secventa ca aceea de mai
jos:
gdriver:=VGA; gmode:=VGALo;
if graphresult<>O then
begin
writeln('tentativa
halt
end;
esuata);
VGA, VGALo sunt constante de tip integer care reprezinta numerele asociate
modului !?i driverului solicitate. Driverele !?i modurile pot fi adresate prin
utilizarea acestor constante.
Odata intrati intr-un mod grafic nu se mai poate scrie pe monitor, ca pana
acum (cu WRITE !?i WRITsLN). le!?irea din modul grafic se face prin utilizarea
procedurii CLOSEGRAPH. In cazul in care nu folosim aceasta procedura, dupa
executia unui program grafic riscam disparitia cursorului.
1 0.3. Culori
Cum putem programa culorile cu care urmeaza sa apara un desen pe moni
tor? Aceasta este intrebarea Ia care ne propunem sa raspundem In acest para
graf. De Ia bun inceput trebuie sa precizam faptul ca programarea culorilor tine
cont de placa grafica folosita (in concluzie, de driverul folosit) precum !?i de
modul grafic In care se lucreaza. Astfel, exista moduri grafice monocrome in
care avem numai doua culori !?i moduri gralice care dispun de mai multe culori.
Fiind data o placa grafica, putem folosi memoria ei in mai multe moduri.
Astfel (Ia placa CGA), putem renunta Ia utilizarea culorilor (de fapt vom utiliza
numai doua). in a._cest caz,intrucat pentru fiecare pixel se retine doar daca este
aprins sau stins, in memoria video se pot reprezenta mai multi biti, deci se
ob!ine o rezolutie superioara.
In situatia In care se folosesc mai multe culori reprezentam pe ecran mai
putini pixeli.
in cele ce urmeaza,,vom presupune ca dispunem de o placa grafica VGA,
caz in care pentru culoarea unui pixel se retin 4 biti. Rezulta de aici ca putem
utiliza maximum 16 culori, numerotate intre 0 !?i 15. Nu este cam putin? Nu ati
observat ca jocurile folosesc uneori mai multe culori? Daca le-am folosi, ar fi
necesara o memorie video mult mai mare. Pentru a putea reprezenta mai multe
culori (dar nu in acela!?i timp) se poate schimba setul de culori folosite. Acum
intervine notiunea de paleta de culori. Acea ta este, in esenta, multimea
culorilor care pot fi folosite Ia un moment dat pentru a reprezenta o imagine
grafica. Culorile sunt date prin codullor si sunt retinute intr-un vector. Fiecare
componenta a .._a cestui vector retine codul unei 'anumite culori. in acest fel,
continutul celor 4 biti rezervati pentru culoare este un indice de adresare in
paleta de culori (nu culoarea). Astfel, daca presupunem continutul celor 4 biti
de culoare ai unui pixel de pe ecran ca fiind 0011 (3 in baza 10), culoarea cu
care apare efectiv pixelul pe monitor depinde de codul culorii care se gase!?te
in componenta de indice 3 a paletei. Schimbarea paletei de culori atrage
modificarea instantanee a culorilor cu care apare. un desen pe ecran. 0 paleta
de culori poate fi retinuta intr-o variabila de un tip predefinit in unitatea GRAPH
!?i anume tipul PALETTETYPE:
type palettetype
= record
size:byte;
colors [d maxcolors] of shortint
end
Maxcolors este o constanta definita in graph care are valoarea 15. Campul
SIZE contine numarul de culori din paleta (in cazul placilor VGA are valoarea 1 6).
Culoarea de fond este intotdeauna culoarea care se gaseste in componenta
de indice 0 a paletei. in absenta unei alte optiuni, culoarea cu care se face
desenul este culoarea al carei cod se gase!?te in componenta 1 5 a paletei. La
seleqia unui mod grafic se selecteaza automat o anumita paleta, numita paleta
implicita. Aceasta poate fi schimbata. Paleta care da culorile de pe ecran Ia un
moment dat se nume!?te paleta activa.
Programul care urmeaza deseneaza 16 zone dreptunghiulare care sunt
colorate cu ajutorul culorilor continute in paleta implicita (care este !?i cea
activa).
program coll;
uses graph,crt;
var gdriver,gmode,i:integer;
begin
gdriver:=vga;
gmode:=vgalo;
initgraph(gdriver,gmode,c:\tp\bgi);
if graphresult<>O then halt;
for i:=O to 15 do
begin
setfillstyle(l,i);
bar(o,i*l0,200,i*lO+lO);
end;
readln;
end.
Cele mai multe programe folosesc numai culori apartinand paletei implicite.
In cazul paletei implicite, pentru selectia culorilor se pot folosi constantele de
culoare continute in GRAPH. Astfel, fiecare culoare din paleta are un nume
caruia i se atribuie o constanta intre 0 !?i 1 5 care reprezinta indicele compo
nentei din paleta care retine codul culorii (vezi tabelul).
in cazul in care schimbam paleta, aceste constante nu mai pot fi folosite.
Culoare
Constanta
Valoare
negru
black
albastru
blue
verde
green
turcoaz
cyan
rO!?U
red
Culoare
Constanta
Valoare
violet
magenta
maro
brown
gri deschis
lightgrey
gri inchis
darkgrey
albastru deschis
lightblue
verde deschis
lightgreen
10
turcoaz deschis
lightcyan
11
ro!?u deschis
lightred
12
violet deschis
lightmagenta
13
galben
yellow
14
alb
white
15
in concluzie, in cazul paletei implicite putem regasi cu mare U!?Urinta numele

culorilor. Stabilirea culoti de fond (daca se dore!?te o alta decat culoarea
neagra) se face cu ajutorul procedurii SETBKCOLOR(culoare). Parametrul
culoare poate avea ca valoare una din constantele definite mai sus sau un
numar intre 0 !?i 15. De fapt, aceasta procedura copiaza codul culorii care se
gase!?te Ia indicele specificat in prima componenta a paletei (de indice 0). La
indicele culoare codul ramane neschimbat. Automat, culoarea de fond se
schimba (chiar daca facusem un desen). Selectarea culorii cu care se desenea
za se face .prin utilizarea procedurii SETCOLOR(culoare), unde culoarea are
aceea!?i semnificatie ca in procedura anterioara. Schimbarea culorii de desen
cu SETCOLOR nu influenteaza desenul facut anterior, ci numai ce desenam
dupa apelul acestei proceduri. Programul care urmeaza deseneaza un patrat
utilizand linii de culoare albastra pe un fond de culoare alba.
program t;
uses utilg,graph;
var i:integer;
procedure desen(culoare:integer);
begin
setcolor(culoare);
moveto(lO,lO);
lineto(20,10);
lineto(20,20);
lineto(l0,20);
lineto(lO,lO);
end;
begin initg;
setbkcolor(white);
desen(blue);
readln
end.
Cum putem schimba paleta !?i cum putem selecta culorile in cadrul ei? Pentru
a putea raspunde acestor intrebari trebuie sa analizam modul de formare a
culorilor (codurile lor).
Fiecare culoare se obtine ca o combinatie intre 3 culori fundamentale: rosu,
verde, albastru. Culorihfundamentale a'u !?i ele mai multe nuante, dec( !?i
pentru reprezentarea lor sunt necesari mai multi biti. De exemplu, in modul
VGA fiecare culoare fundamentala poate avea un cod intre 0 !?i 63 (in functie
de nuanta ei). Codul final al culorii se obtine din combinarea culorilor funda
mentale (fiecare cu nuanta ei).
Procedura SETRGBPALETTE atribuie culorii din paleta care are codul C, cadul
obtinut din combinatia culorilor fundamentale Ia gradele de intensitate (nuante) n1,
n2, n3 (n1 este codul asociat pentru nuanta de rO!?U, n2 pentru verde !?i n3 pentru
albastru). Aceasta procedura are forma SETRGBPALETTE(C, n1, n2, n3).
Procedura SETPALETTE are rolul de a modifica in paleta culoarea care are
indicele de intrare In paleta i, cu un cod de culoare notat C, !?i are forma
generaIa SETPALETTE(i,C1).Evident, prin utilizarea acestei proceduri se obtine
o alta paleta. Pentru a ilustra acestea, sa consideram programul urmator:
program col2;
uses graph;
procedure schimb_pal;
begin
for i:=O to 15 do setpalette(i,i);
for i:=O to 15 do setrgbpalette(i,0,0,4i);
end;
begin
gdriver:=vga;
gmode:
=vgalo;
schimb_pal;
for i:=O to 15 do
begin
setfillstyle(1,i);
bar(O,i10,200,i*10+10);
end;
readln;
closegraph;
end.
in program, se deseneaza 16 benzi dreptunghiulare colorate cu diferite

nuante de albastru. Pentru a obtine aceste culori avem nevoie de o aleta care
sa le contina. Aceasta se obtine cu ajutorul procedurii schimb_pal. Cum se
procedeaza? Orice componenta i a paletei initiale capata ca valoare culoarea
cu codul i. Aceste noi culori nu le folosim in desen ci ca index de adresare
pentru procedura SETRGBPALETTE (aceasta procedura adreseaza culorile din
paleta dupa codurile lor i este convenabil sa avem codurile 0,1 ... 15). Ultimul
parametru al acestei proceduri contine codul nuantei de albastru.
Procedura GETPALETTE(paleta) are rolul de a copia continutul paletei curente
in cadrul variabilei paleta de tipul PALETTETYPE.
in programul col3 se schimba paleta Ia fel ca in programul col2. Se
deseneaza un dreptunghi (culorile le avem in noua paleta). Aceasta figura se
,stinge", In sensul ca apare intr-o culoare de albastru din ce in ce mai inchis,
pana cand figura nu mai este vizibila.
Efectul de ,stingere" il realizam in felul urmator:
desenam figura (automat se alege culoarea de index 15), deci albastru
intens;
se cite te paleta activa intr-o variabila de tipul palettetype (in acest fel
devine aceesibil codul culorii care se gase te in cadrul componentei i a
paletei active);
componenta de index 15 va lua pe rand valorile 14, 13, ..., 0, fapt ce
atrage modificarea instantanee a culorii desenului.
program coll;
uses graph,crt;
paleta:palettetype;
procedure desen;
begin
setfillstyle(1,15);
bar(100,100,200,200);
end;
procedure schimb_pal;
begin
for i:=O to 15 do setpalette(i,i);
for i:=O to 15 do setrgbpalette(i,0,0,4i);
end;
begin
gdriver: =vga;
gmode:=vgalo;
schimb_pal; desen;
getpalette(paleta);
for i:=14 downto o do
begin delay(40);
setpalette(lS,paleta.colors[i]);
end;
closegraph;
end.
Paleta de culori
poate fi modificata 9i prin intermediul procedurii
SETALLPALETTE(paleta), unde paleta este o variabila de tipul PALETTETYPE.
Cum poate fi folosita aceasta procedura? Variabila paleta este incarcata de
utilizator cu codurile culorilor care se vor folosi. Procedura SETALLPALETTE
face ca paleta definita de utilizator sa devina activa (deci, in situatia in care era
desenat ceva, culorile de fond si desen se schimba instantaneu).
Functia GETMAXCOLOR este. de,tip WORD 9i intoarce eel mai mare indice
de intrare in paleta (pentru modul VGA 15).
Funqia GETBKCOLOR este de tip word 9i intoarce indexul in paleta al culorii
de fond active.
Procedura GETDEFAULTPALETTE(paleta) atribuie variabilei paleta (de tipul
palettetype) valoarea paletei implicite pentru modul grafic curent. Aceasta
procedura poate folosi In refacerea paletei implicite dupa ce aceasta a fost
schimbata (pentru refacere se utilizeaza 9i SETALLPALETTE).
Observatie: Pentru a obtine codurile curente ale culorilor continute In paleta

implicita a modului grafic curent se pot folosi 9i constantele definite in GRAPH
pentru acestea 9i anume EGABLACK, EGABLUE, EGARED etc.
Procedura CLEARVIEWPORT 9terge ecraniJI cu culoarea de fond. Ea este
aplicabila 9i ferestrelor, despre care vom discuta mai tarziu.
10.4. Coordonate ecrani reprezentarea punctelor

Oricare ar fi modul de lucru ales, un punct se reprezinta printr-un pixel de
coordqnate x 9i y (x reprezinta coloana 9i y linia). Punctul din coltul din stanga
sus este de coordonate (0,0). Un punct se poate reprezenta cu ajutorul
procedurii PUTPIXEL(x,y,culoare). Funqia GETPIXEL(x,y):word - intoarce
indicele culorii din paleta a punctului de coordonate x 9i y (INTEGER) in cadrul
paletei de culori activa. in mod paradoxa!, de9i acestea ar fi singurele rutine
indispensabile programarii grafice, ele se utilizeaza extrem de rar. Coordonata
maxima x de pe ecran se poate afla cu ajutorul functiei de tip lntreg
GETMAXX, iar coordonata maxima Y cu ajutorul functiei GETMAXY. Este bine
ca programele de grafica sa-9i stabileasca coordonatele in care deseneaza, in
functie de valorile returnate de aceste funqii. Tn acest fel se asigura o relativa
independenta a programelor fata de modul grafic folosit 9i chiar fata de driver.
10.5. Punct curent

Atunci cand lucram in modul text se poate utiliza cursorul. Orice operatie de
scriere sau de citire se face In pozitia curenta a cursorului. $i In modul grafic
dispunem de un mecanism asemanator. Exista proceduri grafice care tin cont
de pozitia unui cursor (invizibil pe ecran), in sensul ca pornesc trasarea
desenului din acel punct. Coordonatele cursorului imaginar se numesc
coordonatele punctului curent. Stabilirea coordonatelor punctului curent se face
cu ajutorul procedurii MOVETO(x,y), unde x i y sunt valori de tip INTEGER i
reprezinta coordonate ecran.
Nu avem lntotdeauna o pozitie implicita a punctului curent i nu toate
procedurile tin cont de punctul curent. Dupa executia unora din procedurile
grafice, pozitia punctului curent se poate modifica; dupa executia altora,
coordonatele punctului curent raman neschimbate. Functiile de tip intreg GETX
i GETY returneaza coordonatele x, respectiv y, ale punctului curent.
10.6. Trasarea segmentelor

Doua puncte date prin coordonatele lor pot fi unite printr-un segment. Acest
segment poate fi trasat prin linii de grosimi diferite, punctate sau nu. Limbajul
TURBO PASCAL contine o procedura care are rolul de a fixa modul de trasare
a segmentelor (SETLINESTYLE). Forma generala a acesteia este:
SETLINESTYLE(tip_linie,model,grosime).
Toti parametrii sunt de tip WORD. Odata executata, aceasta procedura are
efect pana Ia intalnirea altui apel al ei sau pana Ia sfir!?it.
Tipul linie poate avea urmatoarele valori care sunt recunoscute !?i prin
constantele date:
Tip linie
Valoare
Cod constanta
continua
SOLIDLN
punctata
DOTTEDLN
linie punct
CENTERLN
linie intrerupta
DASHEDLN
definita de utilizator
USERBITLN
Parametrul model trebuie sa capete valoarea 0, daca tipul liniei nu este

definit de utilizator.. in caz contrar, definim printr-o constanta hexa tipul de linie
dorit. Definirea se face Ia nivel de bit (pentru succesiuni de 16 pozitii). Tn
constructia constantei hexa se tine cont de faptul ca un bit{) inseamna pixel

neaprins iar un bit 1 inseamna pixel aprins. Astfel, .daca se dore!?te definirea
unei linii In care un pixel sa fie aprins, un pixel neaprins, se obtine !?irul de biti
1q10101010101010,deci $AAAA.
Parametrul grosime poate avea 2 valori: 1 (NORMWIDTH), pentru linie
su tire, !?i 3 (THICKWIDTH) pentru linie groasa.
In absenta acestei proceduri, segmentele se traseaza cu linie continua !?i
sub tire.
Urmatoarele trei proceduri traseaza segmente:
1. LINE(x1,y1,x2,y2)- traseaza segmente intre punctul de coordonate (x1,
y1) !?i punctul de coordonate (x2, y2). Aceasta procedura nu modifica
coordonatele punctului curent;
2.
LINETO(x,y) - traseaza un segment intre punctul curent !?i punctul de
coordonate (x,y). Dupa trasare punctul curent are coordonatele (x,y);
3. LINEREL(dx,dy) - traseaza un segment intre punctul curent !?i punctul de
coordonate (x + dx, y + dy). Dupa trasare coordonatele punctului curent devin
(x+dx, y+dy).
Programul care urmeaza traseaza doua segmente pentru care a fost precizat
stilul.
program stil;
uses graph,utilg;
begin initg;
setlinestyle(dottedln,normwidth,l);
moveto(O,lO);
lineto(200,10);
setlinestyle(userbitln,$,3);
moveto(0,20);
lineto(200,20);
readln;
closegraph
end.
10.7. Raportul aspect

in general, pixelii nu sunt patrati, de!?i exista !?i anumite placi grafice In care,
daca lucram cu anumite moduri de lucru, pixelii indeplinesc aceasta conditie.
Exemplu, pentru o placa VGA, daca se lucreaza in modul VGAHI pixelii sunt
patrati. Dar ce ne facem in celelalte cazuri?
Procedura GETASPECTRATIO ne ajuta In acest sens. Forma generala. de apel
este GETASPECTRATIO(n1,n2), unde n1 !?i n2 sunt de tip WORD. Proceclura
furnizeaza doua marimi, n1 !?i n2. Definim raportul aspect ca fiind n1 /n2 !?i il
folosim astfel:
lungimea unui segment, pe orizontala, ramane nemodificata;
lungimea unui segment pe verticala se obtine ca lungimea dorita inmultitc':i cu

n1/n2.
in programul urmator se traseaza un patrat, in doua moduri:
a tine cont de raportul aspect;
tinand cont de acesta.
i
tara
program ra;
uses graph;
var gdriver,gmode:integer;
nl,n2:word;
begin
gdriver:=vga;
gmode:=vgalo;
moveto(O,O);
lineto(O,lOO);
lineto(lOO,lOO);
lineto(100,0);
lineto(O,O);
readln; clearviewport;
getaspectratio(nl,n2);
moveto(O,O);
lineto(O,round(lOO(nl/n2)));
lineto(lOO,round(lOO(nl/n2)));
lineto(lOO,O);
lineto(O,O);
readln;
closegraph;
end.
10.8. Desenarea obiectelor grafice

10.8. 1. Desenarea unei linii frante
Se considera n puncte de coordonate (x1, y1), (x2, y2), (xn, yn). Coordonatele
acestor puncte pot fi retinute intr-un vector cu componente POINTTYPE. Acest
ultim tip este definit in GRAPH astfel:
type pointtype=
record
x,y:integer
end
Procedura DRAWPOLY traseaza o linie franta obtinuta prin unirea primului

punct cu al doilea, al celui de-al doilea cu al treilea !?.a.m.d.
Forma generala a acestei proceduri este: DRAWPOLY(n,varfuri), unde n este
un parametru de tip word !?i transmite numarul de puncte ce se vor um, 1ar
varfuri este un vector de componente POINTTYPE, care retine coordonatele
eelor n puncte.
Programul urmator traseaza o linie franta:
program 1;
uses graph,utilg;
var varfuri:array[1.. 4] of pointtype;
begin initg;
varfuri[1].x:=1;
varfuri[1].y: =1;
varfuri[2].x:=100;
varfuri[2].y:=200;
varfuri[3].x:=SO;
varfuri[l].y:=SS;
varfuri[4].x:=200;
varfuri[4].y:=200;
drawpoly(4,varfuri);
readln;
closegraph
end.
in situatia in care se doreste trasarea unei linii frante inchise, vectorul

V ARFURI a avea n + 1 componente !?i ultima componenta va contine coordo
natele primului punct. Tipul segmentelor care alci:Huiesc linia franta se stabile!?
te cu ajutorul procedurii SETLINESTYLE.
10.8.2. Desenarea cercurilor, arcelor de cere
ide elipsa
Desenarea unui cere se face cu ajutorul procedurii CIRCLE(x,y,r), unde (x,y)

reprezinta coordonatele centrului iar r reprezinta raza. Toti parametrii sunt de
tip WORD.
Desenarea unui arc de cere se face cu ajutorul procedurii:
ARC(x,y,unghi_pornire, unghi_final,r).
Toti parametrii sunt de tip WORD !?i au urmatoarea semnificatie: (x,y)
coordonatele centrului, unghi initial !?i Linghi final se dau In grade !?i precizeaza
limitele arcului, iar r este raza arcului de cere. Pentru a intelege limitele In care
se traseaza cercul, sa ne imaginam cercul trigonometric in care raza vectoare
a parcurs in sens trigonometric arcul corespunzator unghiului initial. Din acest
punct (varful razei) se traseaza arcul de cere pana in momentul In care s-a
ajuns In punctul corespunzator arcului final. Cu ajutorul acestei proceduri se
poate trasa !?i un cere, daca arcul initial este 0 !?i eel final este 360 grade.
Desenarea unui arc de elipsa se realizeaza cu ajutorul procedurii:
ELLIPSE(x,y,unghi_pornire,unghi_final,a,b).
Parametrii, de tip WORD, au semnificatia:
(x,y) coordonatele centrului;

unghi_pornire, unghi_final au aceea!?i semnifica ie caIn cazvi arcului de cere;
a,b semiaxele elipsei.
in situa ia in care a este egal cu b se traseaza un arc de cere.
Programul care urmeaza exemplifica aceste proceduri:
program cere;
uses graph,utilg;
begin initg;
circle(SO,S0,20);
arc(lOO,l00,0,270,20);
ellipse(lSO,lS0,0,270,10,30);
readln;
closegraph;
end.
10.8.3. Desenarea unor obiecte ha!?urate

Limbajul TURBO PASCAL ofera !?i posibilitatea desenarii unor obiecte
ha!?urate in mod direct, prin utilizarea unor proceduri specifice.
Stabilirea ha!?urii se face cu ajutorul procedurilor SETFILLSTYLE sau
SETFILLPATTERN.
Procedura SETFILLSTYLE (tip hasura,culoare). Ambii parametri sunt de tip
WORD. Valorile parametrului tip_hasura pot fi:
Constanta
Valoare
Descriere interior
EMPTY FILL
culoare de fond
SOLIDFILL
plin in culoare de umplere
LINEFILL
cu linii ortzontale
LTSLASHFILL
cu linii de forma Ill subtiri
SLASHFILL
cu linii de forma Ill groase
BKSLASHFILL
cu linii de forma \\\ groase
LTBKSLASHFILL
cu linii de forma \\\ subtiri
HATCHFILL
cu linii orizontale !?i verticale
XHATCHFILL
cu linii oblice lntretesute rar
INTERLEAVEFILL
cu linii oblice intretesute des
Constanta
Descriere interior
Valoare
WIDEDOTFILL
10
cu puncte rare
CLOSEDOTFILL
11
cu puncte dese
Parametrul culoare reprezinta culoarea de desen.

in cazul in care nici un astfel de model nu convine, avem posibilitatea de a
defini un model propriu. Unitatea GRAPH contine definit tipul urmator:
TYPE FILLPATTERNTYPE
= array[1..8] of
integer;
0 variabila de acest tip define!?te un piHrat de 8 * 8 biti din model. Un bit 1

determina aprinderea pixelului, iar pentru un bit 0, pixelul ramane stins.
Procedura SETFILLPATTERN(model,culoare), unde model este o variabila
de tipul FILLPA TTERNTYPE !?i contine tipul propriu definit de utilizator iar
culoarea are semnificatia din procedura anterioara.
Procedura BAR(x1 ,y1 ,x2,y2) deseneaza o bara al carei contur se traseaza,
cu modelul definit de una din cele doua proceduri anterioare. Parametrii, de tip
INTEGER, reprezinta coordonatele coltului din stanga sus i dreapta jos.
Procedura BAR3D(x1,y1,x2,y2,adancime,capac) traseaza un paralelipiped
pentru care partea frontala este ha urata. Parametrii au urmatoarea sernnifica ie:
x 1, y 1, x2, y2 (de tip INTEGER) coordonatele partii frontale (stanga sus
i dreapta jos);
adancime;
capac (boolean), daca este TRUE se traseaza partea superioara, iar daca are
valoarea FALSE, partea superioara nu se traseaza.
Programul care urmeaza exemplifica aceste proceduri:
program ob;
uses graph,utilg;
begin initg;
setcolor(green);
setfillstyle( solidfill,red);
bar(20,20,lOO,lOO);
bar3d(l20,l20,200,200;lo,true);
readln;
closegraph
end.
Procedura FILLELLIPSE(x,y,a,b) deseneaza !?i hC!!?Ureaza o elipsa. Parametrii

au aceea!?i semnificatie ca Ia procedura ELLIPSE.
Procedura SECTOR(x,y, unghi start,unghi f,a,b) deseneaza !?i ha!?ureaza un
sector de elipsa. Parametrii sunt-cei de Ia procedura ELLIPSE.
Procedura PIESLICE(x,y,unghi start,unghi f, r) deseneaza i ha ureaza un
sector de cere (vezi parametrii procedurii AR-C).
Procedura FILLPOLY(n,varfuri) deseneaza !?i ha ureaza un poligon.
274
CAPAC =TRUE
CAPAC = FALSE
h
a
ha
ur
Figur
a
10.1.
Parametrii sunt
aceia!?i cu cei ai
procedurii
DRAWPOLY.
se
Programul care
urmeaza arata modul
cum se poate realiza
grafic o situatie
statistica. Se
considera o firma
care are n magazine.
in fiecare luna
raprteaza vanzarile
efectuate in cele n
magazine. Acestea se
reprezinta procentual
faa de total vanzari
firma, prin sectoare de
cere, aa cum rezulta
din figura urmatoare.
Figura
10.2.
Observatie: Programul
nu scrie texte. Pentru a
rezolva aceasUi
problema, vezi paragraful
urmator.
program statisl;
uses graph,utilg;
var i,n,s,u i,u :integer;
realiz:array[l..15] of integer;
begin
write('n=);
readln(n);
s:=O;
for i:=l ton do
begin
write('realizari magazin ,i, ');
readln(realiz[i]);
s:=s+realiz[i];
end;
initg;
u i:=O;
u-:=0;
for i:=l ton do
begin
if i=n then u_:=360
else u f:=u f+round(realiz[i]/s360);
setfillstyle(solidfill,i);
pieslice(getmaxx div 2,getmaxy div 2,u_i,u_f,lOO);
u i:=u ;
end;
readln;
closegraph
end.
10.9. Afi area textelor

Exista mai multe considerente pentru care limbajul a fost dotat cu rutine
specifice pentru afil?area textelor in regim grafic. Dintre acestea enumeram
doua:
regimul text este extrem de sarac in ce prive te caracterele afi ate (dupa
cum am vazut, exista un singur tip de caractere);
exista posibilitatea de a crea noi tipuri de caractere.
intrucat In regimul grafic dispunem de mai multe tipuri de caractere, trebuie
sa existe o procedura care sa ne permita sa alegem intre ele. Aceasta este
procedura SETTEXTSTYLE i are forma urmatoare:
SETTEXTSTYLE(stil_caracter,direcfie,marime).
Toti parametrii suntde tip WORD.
_ Stil_c.a_rJICter poate avee mai multe valori, dupa cum rezulta i din tabelul
urmator:
-- ---
Nume constandi
Valoare
DEFAULTFONT
TRIPLEX FONT
SMALLFONT
SANSSERIFFONT
GOTHICFONT
4
-
Parametrui ,cii e. specific a direqia de scriere a unui text. Aceasta poate

fi orizontala (Constanta NORMDIR = 0) sau verticala (Constanta VERTDIR = 1).
Directia verticala are sens atunci cand tiparim imaginea creata pe ecran (sa
poata fi tiparita pe o coala a ezata normal, adica avand baza mica In jos).
Marime- specifica marimea caracterelor scrise. Acest parametru trebuie sa
capete valori intre 0 i 10 (0 pentru eel mai mic posibil).
Tipurile de caractere se pot observa 'fn PLAN$A 1, obtinuta cu ajutorul
programului TEXT1.
Textele se afi eaza colorate in culoarea stabilita cu ajutorul procedurii
SETCOLOR (culoarea de desen).
Scrierea textelor se face prin utilizarea a doua proceduri: OUTTEXT i
OUTTEXTXY. Problema este sa stabilim locul de scriere a textelor. Aceasta se
realizeaza cu ajutorul procedurii SETTEXTJUSTIFY(orizontal,vertical). Parametrii,
ambii de tip WORD, pot lua valori intre 0 !?i 2. Valorile luate de parametrul
orizontal rezulta din urmatorul tabel:
Constanta
Valoare
Textul se gase te
LEFTTEXT
in dreapta punctului curent
CENTERTEXT
de o parte i de alta a punctului curent
RIGHTTEXT
in stanga punctului curent
Tabelul de mai jos prezinta valorile luate de parametrul vertical:

Constanta
Valoare
Textul se gase te
TOPTEXT
deasupra punctului curent
CENTERTEXT
de o parte !?i de alta a punctului curent
BOTTOMTEXT
sub punctul curent
in mod evident, parametrul orizontal este luat in considerare cand textele se

scriu orizontal, iar eel vertical Ia scrierea verticala a textelor.
in absenta acestei proceduri, valorile implicite sunt LEFTTEXT i TOPTEXT.
Procedura OUTTEXT( ir) scrie un text care se gase!?te in variabila !?ir de tip
STRING. Scrierea textului se face tinand cont de punctul curent, a!?a cum a
fost aratat mai sus.
Procedura OUTTEXTXY(x,y, ir) face ca punctul curent sa aiba coordonatele
x i y, dupa care sc'rie textul ca !?i procedura prezentata mai sus.
lata programul text1 care listeaza tipurile de caractere:
program textl;
uses graph,utilg;
var i,j:integer;
begin initg;
setcolor(red);
for i:=O to 4
do begin
settextstyle(i,horizdir,6);
outtextxy(O,i*60,'aAbBcCdD123');
end;
readln;
closegraph
end.
Programul care urmeaza scrie de doua ori cuvantul text, orizontal:;;i vertical,
in centrul ecranului (cuvintele se intersecteaza).
program text2;
uses graph,utilg;
begin initg;
setcolor(yellow);
se textstyle(triplexfont,horizdir,lO);
settextjustify(centertext,bottomtext);
outtextxy(getmaxx div 2, getmaxy div 2, text);
settextstyle(triplexfont,vertdir,lO);
. outtextxy(getmaxx div 2, getmaxy div 2, text);
readln;
closegraph
end.
Ap/icatie:
Se considera o firma care dispune den (n mai mic sau egal cu 8) magazine.
Fiecare magazin raporteaza lunar citra vanzarilor In milioane lei (lntre 0 !?i 999).
Se cere sa se reprezinte grafic vanzarile efectuate in cele n magazine (repre
zentari prin paralelipipede de lnaltime proportionala cu vanzarile efectuate).
Pentru rezolvarea problemei propuse procedam astfel:
orice paralelipiped va avea latimea fetei frontale de 50;

un paralelipiped de 'fnaltime maxima va avea y cuprins intre getmaxy-50 !?i
50;
inaltimea unui paralelipiped oarecare este exprimata propoqional fata de
inaltimea paralelipipedului de inaltime maxima (corespunzator magazinului cu
vanzari maxime).
Analizati programul de mai jos !?i justificati formulele folosite.
program text3;
uses graph,utilg;
var realiz:array[l..8] of integer;
i,n,max,xl,yl,x2,y2:integer;
sir:string;
begin
write('n=');
readln(n);
for i:=l to n do
begin
write(realizari[,i,]=');
. readln(realiz[i]);
end;
max: =realiz[1];
for i:=2 ton do
if max<realiz[i] then max:=realiz[i];
initg;
setcolor(yellow);
settextstyle(sansseriffont,horizdir,O);
setfillstyle(hatchfill,red);
outtextxy(lSO,O, 1 Situatia vanzarilor');
xl:=o; x2:=So; y2:=getmaxy-so;
for i:=l to n do
begin
yl:=getmaxy-50-round((getmaxy-lOO)(realiz[i]/max));
bar3d(xl,yl,x2,y2,10,true);
str(realiz[i],sir);
outtextxy(xl,getmaxy-40,sir);
xl:=xl+BO; x2:=x2+80;
end;
readln;
closegraph
end.
Sirul de octeti necesar reprezentarii unui caracter se nume!?te font.

Caracterele tipului DEFAULTFONT sunt reprezentate in memorie pe cate 8
octeti. Pentru a genera un astfel de caracter se procedeaza astfel:
se considera
o matrice
binara (numai cu 1 sau 0) de .8 *8,
corespunzatoare unui patratel de cate 8*8 pixeli in care se reprezinta un
astfel de caracter. Pentru orice element 1 din matrice, pixelul corespunzator
se considera aprins (are culoarea tabilita de SETCOLOR) iar pentru orice
element 0 pixelul se considera stir:; (are culoarea fondului). Pentru fiecare
linie a matricei se obtine un oct .t care reprezinta un numar. in acest fel se
obtine !?irul celor 8
octe i. Un astfel de font este de tip raster. Daca am Tncerca sa deformam un

astfel de caracter (sa Tnmul im cu doua numere diferite Tnal imea !?i latimea
caracterului) imaginea rezultata ar fi de slaba calitate.
Celelalte tipuri de caractere au fonturi de tip vectorial. Ce este un font de tip
vectorial? Fiecare caracter se reprezinta Tn memorie prin mai multe perechi de
octeti (nu exista un numar fix de perechi). Fiecare pereche de octeti cuprinde
abscisa !?i ordonata unui punct. Desenul caracterelor se obtine unind punctele
ale caror coordonate sunt date de perechile de octeti (de fapt, ultimul bit al
octetului care reprezinta ordonata unui punct are valoarea 1 daca nu se face
trasare din punctul anterior Ia acesta !?i 0 Tn caz contrar). Caracterele generate
prin fonturi vectoriale se pot deforma cu multa U!?urinta (se obtin tot puncte
care sunt unite prin segmente).
10. 10. Tehnici de animatie

Tn acest paragraf ne propunem sa raspundem Ia urmatoarea Tntrebare: cum
facem o figura sa se mi!?te pe ecran? Pentru rezolvarea acestei probleme exista
mai multe tehnici care vor fi prezentate Tn continuare, dar toate au acela!?i
principiu de executie !?i anume:
se deseneaza figura;
se a!?teapta o perioada de timp;
se !?terge figura !?i se deseneaza Tntr-o alta pozitie.
Pentru ca figura sa para ca se mi!?ca Tn mod real, un rol fundamental Tl are
timpul de a!?teptare (timpul Tn care figura ramane pe ecran pana a se !?terge).
Acesta se regleaza de Ia caz Ia caz cu ajutorul procedurii DELAY.
Tn principal, exista trei tehnici de realizare a anima iei. Ele difera prin
procedurile pe care le utilizeaza !?i prin viteza de executie. Pentru exemplificarea
lor vom folosi o singura problema !?i anume de a mi!?ca un patrat pe orizontala.
Tehnica 1
Operatiile de desenare !?i !?tergere a figurii se fac cu ajutorul procedurii

SETWRITEMODE, pe care o vom prezenta Tn continuare.
Forma generala a acestei proceduri este SETWRITEMODE(valoareTntreaga).
Vom folosi aceasta procedura cu un singur para.metru !?i anume XORPUT
(valoarea 1 predefinita Tn unitatea GRAPH). In concluzie, vom pune
SETWRITEMODE(XORPUT).
Dupa apelul acestei proceduri procedam astfel:
apelam o procedura care deseneaza o figura (aceasta va fi vizibila pe ecran);
a!?teptam o perioada de timp;
apelam din nou procedura care realizeaza desenul, exact Tn aceea!?i pozitie
(Ia acest apel desenul va disparea, pentru ca, de fapt, desenul se realizeaza
acum utilizand culoarea fondului);
apelam procedura care realizeaza desenul intr-o alta pozitie (acesta va

deveni vizibil, pentru ca se realizeaza utilizand culoarea curenta);
a!?teptam o perioada de timp;
_procedeul se repeta pana cand figura a ajuns in pozitia dorita.
Programul care urmeaza utilizeaza aceasta tehnica pentru a plimba patratul
pe o distanta de 1 00 de pixeli.
program a1;
uses graph,utilg,crt;
var i:integer;
procedure desen(x,y,l:integer);
begin moveto(x,y);
lineto(x+l,y);
lineto(x+l,y+l);
lineto(x,y+l);
lineto(x,y)
end;
begin initg;
setwritemode(xorput);
for i:=1 to 100 do
begin
desen(i,1,20);
delay(100);
desen(i,1,20)
end;
closegraph
end.
Tehnica 2
Pentru a intelege aceasta tehnica, trebuie sa prezentam in prealabil cateva
proceduri.
Orice imagine care se afla pe ecran poate fi salvata in memoria interna. Sa
fim mai expliciti. Exista posibilitatea ca anumite informatii (cum ar fi cele care
permit vizualizarea unei imagini) sa fie salvate in memoria interna, alocand
spatiul necesar pentru aceasta in timpul executiei programului. 0 astfei de
alocare a memoriei poarta numele de alocare dinamica i se va studia in detaliu
in clasa a zecea. Totu i, acum ne sunt necesare cateva cuno!?tinte minima!e.
Tn programul care urmeaza, am retinut o variabila a de un tip inca

necunoscut, numit POINTER. 0 astfel de variabila are posibilitatea de a retine
o adresa de memorie (atentie, nu faceti confuzie intre adresa unei zone de
memorie l?i continutul ei - e'ste ca !?i cu'ni am face confuzie intre adresa unei
persoane i persoana propriu-zisa). Alocarea spatiului in memorie (un numar de
octeti consecutivi Ia o anumita adresa) se face cu ajutorul procedurii GETMEM
care are forma urmatoare:
GETMEM(variabila de tip POINTER, numar octeti).

Aceasta procedura, dupa ce rezerva In memorie numarul cerut de octeti,
incarca adresa primului octet in variabila de tip POINTER.
Cum salvam imaginea? De fapt, se salveaza imaginea continuta lntr-un
dreptunghi pentru care se cunosc coordonatele colturilor din stanga sus !?i
dreapta jos. De unde !?tim cati octeti sunt necesari pentru a salva o imagine?
Aici, ne este de mare folos functia IMAGESIZE. Aceasta functie este de tip
WORD !?i returneaza numarul de octeti necesari pentru salvarea unei imagini In
cazul cand dispunem de acest spatiu, in caz contrar se returneaza valoarea 0.
Pana acum 9tim cum putem afla numarul de octeti necesari memorarii
imaginii, cum sa rezervam spatiul necesar memorarii imaginii, dar nu !?tim cum
salvam efectiv imaginea (octetii corespunzatori ei aflati in memoria video).
Pentru a putea realiza aceasta, folosim procedura GETIMAGE care are fo;ma
urmatoare:
GETIMAGE(x1,y1,x2,y2,a").
Parametrii au urmihoarea semnificatie:
x1,y1,x2,y2 - coordonatele coltului din stanga sus !?i dreapta jos ale
dreptunghiului care contine imaginea;
a" - spatiul in care se face salvarea. Referitor Ia ultimul parametru, facem
urmatoarele precizari:
a este variabila de tip POINTER;
cand scriem a, ne referim Ia aeresa unde s-a facut rezervarea;
cand scriem a.... ne referim Ia continutul de Ia adresa care se gase!?te In
variabila a.
In concluzie, procedura GETIMAGE are rolul de a salva o imagine in
memorie. Operatia inversa, de a reface imaginea prin aducerea octetilor de
informatie In memoria video, se face prin utilizarea procedurii PUTIMAGE.
Aceasta are forma generala:
PUTIMAGE(x1,y1 ,a.... ,xorput).
Parametrii au urrilatoarea semnificatie:
x1,y1 coordonatele coltului din stanga sus al dreptunghiului care contine
imaginea (nu este obligatoriu sa refacem imaginea in pozitia pe care a avut-o
inainte de salvare, acest fapt permite 9i animatia); ,
a" - continutul zonei de memorie a carei adresa se gase!?te in a;
parametrul xorput, prezentat !?i Ia setwritemode !?i care are rolul ca odata
figura sa fie vizibila, odata nu (se deseneaza utilizand culoarea de fond).
Acum cunoa!?tem cum salvam !?i cum refacem o informatie, dar problema era
sa realizam animatia. Utilizand tehnica salvarii !?i refacerii imaginii, se
procedeaza astfel:
se des.eneaza figura intr-o prima pozitie;
se calculeazanumarul de octeti necesari salvarii ei In memoria interna;
se salveaza imaginea;
se a!?te; pta un interval de timp;
se reface imaginea dar cu culoarea fondului, ceea ce duce de fapt Ia
!?tergerea ei;
repetitiv se procedeaza astfel:

o se reface imaginea intr-o pozi1ie noua;
o se a!?teapta un interval de timp;
o se reface imaginea in aceeai pozi1ie dar, datorita parametrului xorput, de
fapt se !?terge;
o procedeul continua pana cand s-a ajuns in pozitia finala.
Aceasta tehnica de animatie este superioara primei tehnici, datorita faptului
ca este mai rapida operatia de aducere din memorie pe ecran a unei imagini,
decat desenarea ei. Acest fapt constituie un mare avantaj in cazul imaginilor
complexe.
program a2;
uses
graph,utilg,crt;
var i,dim:integer;
a:pointer;
procedure desen(x,y,l:integer);
begin
moveto(x,y);
lineto(x+l,y);
lineto(x+l,y+l);
lineto(x,y+l);
lineto(x,y);
end;
begin initg;
desen(l,l,lO);
dim:=imagesize(l,l,lO,lO);
getmem(a,dim);
getimage(l,l,ll,ll,a);
delay(lOO);
putimage(l,l,a,xorput);
for i:=2 to 100 do
begin
putimage(i,l,a,xorput);
delay(lOO);
putimage(i,l,a,xorput)
end;
closegraph
end.
Tehnica 3
Aceasta tehnica nu este aplicabila in general, ci numai in cazul in care se
lucreaza intr-un mod grafic, cu un driver grafic ce permite utilizarea mai multor
pagini video. 0 pagina video este memoria necesara (existenta fizic pe placa
grafica) ce permite retinerea unei imagini.
Un exemplu in care putem folosi aceasta tehnica este atunci cand folosim
driverul VGA !?i lucram in modul VGALo, caz in care dispunem de 4 pagini
video. Apar doua notiuni noi !Ji anume pagina vizualizata i pagina activa.
Pagina vizualizata este aceea care se vede pe ecran, iar cea activa este cea Tn
care actioneaza proce_durile grafice. Daca avem o singura pagina video, cele
doua notiuni coincid. In cazul Tn care se lucreaza cu mai multe pagini video,
una poate fi vizualizata 9i alta poate fi activa. Stabilirea paginii care se
vizualizeaza se face cu ajutorul procedurii SETVISUALPAGE(nr), unde nr
reprezinta numarul paginii. Facem precizarea ca paginile se numeroteaza
Tncepand cu 0 (astfel, daca dispunem de 4 pagini video, acestea sunt
numerotate Tntre 0 !?i 3). Stabilirea paginii active se face cu procedura
SETACTIVEPAGE(nr), unde parametrul nr este de tip integer !?i are semnificatia
de numar al paginii.
Sa analizam exemplul urm<'Hor:
se vizualizeaza pagina 0 (fara altprecizare, aceasta este !?i pagina activa);
se deseneaza un segment de dreapta, care este vizibil pe ecran;
se a!?teapta citirea unei taste spre a ne convinge de cele prezentate;
pagina activa devine pagina 1;
.
in pagina activa se deseneaza un alt segment de dreapta (acesta nu este
vizibil);
se a!?teapta citirea unei taste spre a ne convinge de aceasta;
se vizualizeaza pagina 1, moment Tn care apare pe ecran noul desen.
program tpl;
var gdriver,gmode:integer;
begin
gdriver: =vga; gmode:=vgalo;
initgraph(gdriver,gmode,c:/tp/bgi');
if graphresult<>o then halt;
setvisualpage(O);
moveto(l,l);
lineto(getmaxx,getmaxy);
readln;
setactivepage(l);
moveto(l,l);
lineto(lOO,lOO);
readln;
setvisualpage(l);
readln;
end.
Cum putem utiliza toate acestea spre a putea realiza animatia?

ldeea de baza este urmatoarea: atat timp cat este vizualizata o pagina, Tntr-o
alta se realizeaza desenul Tn noua pozitie. Va imaginati cat timp se ca!?tiga?
Sa analizam programul urmator:
se vizualizeaza pagina 0 Tn care se deseneaza patratul;
pagina 1 devine activa !?i aici se deseneaza patratul Tn pozitia urmatoare;
repetitiv se procedeaza astfel:
o se a!?teapta o perioada de timp;
o se vizualizeaza pagina 1;
o pagina activa devine pagina 0;

o aici, se terge desenul din pozitia curenta : se reface acesta In pozitia
urmatoare celei din pagina vizualizata (procedura mi care);
se a teapta o perioada de timp;
se vizualizeaza pagina 0;
pagina activa devine pagina 1;
aici, se terge desenul ;;i se redeseneaza In pozitia urmatoare celei din
pagina vizualizata;
procedeul continua pana cand se ajunge cu figura In pozitia finala.
program tpl1;
uses graph crt;
var gdriver gmodelilnrp:integer;
procedure desen(xy1 l:integer);
begin
moveto(x1 y);
lineto(x+l y);
lineto(x+l,y+l);
lineto(x y+l);
lineto(x,y)
end;
procedure miscare(i:integer);
begin
desen(i 1 11 1o ) ;
desen(i+2111 10)
end;
begin
gdriver:=vga;
gmode:=vgalo;
initgraph(gdriver,gmode,c:/tp/bgi');
setvisualpage(O);
desen(1,1110);
setactivepage(1);
desen(2 1 11 1o ) ;
nrp:=1;i:=1;
repeat delay(100);
setvisualpage(nrp);
setactivepage(1-nrp);
miscare(i);
nrp: =1-nrp;
i:=i+1
until i>100;
end.
10. 11. Fi iere imagine

in diverse aplicatii apare problema salvarii imaginilor sub forma de fi!?iere, iar
dind este cazul, aceste imagini se refac. Din pacate, limbajul nu are proceduri
care sa rezolve aceasta problema. in prezentul paragraf propunem o modalitate
simpla, care rezolva cele propuse.
Unitatea UTILG contine doua proceduri SCRIMG i CITIMG.
Procedura SCRIMG salveaza o imagine. Pentru aceasta folose!?te doua fi!?iere,
!?i anume: unul text care contine dimensiunea imaginii salvate !?i unul fara tip care
contine imaginea propriu-zisa. Pentru salvarea imaginii, procedam astfel:
se calculeaza dimensiunea imaginii ce va fi salvata (procedura imagesize) !?i
aceasta se scrie intr-un fi ier text;
se salveaza in memorie imaginea (procedurile getmem !?i getimage);
de aici, imaginea este scrisa intr-un fi!?ier tara tip.
Parametrii acestei proceduri sunt:
x1, y1, x2, y2: coordonatele colturilor din stanga sus !?i dreapta jos ale
dreptunghiului ce contine imaginea;
fdim, fimg: parametri de tip string care contin numele fi!?ierelor text !?i al celui
tara tip;
cod parametru de tip byte care se testeaza Ia revenirea din procedura (daca
salvarea a reu!?it are valoarea 0, in caz contrar are valoarea 1).
procedure scrimg(xl,yl,x2,y2:integer;fdim,fimg:string;var cod:byte);
var a:pointer;
dim:integer;
fl:text;
f2:file;
begin assign(fl,fdim);
assign(f2,fimg);
dim:=imagesize(xl,yl,x2,y2);
if dim<>O then
begin
getmem(a,dim);
getimage(xl yl,x2,y2,aA);
rewrite(fl);
rewrite(f2,dim);
write(fl,dim);
blockwrite(f2,aA,l);
close(fl);
close(2);
cod:=O
end
else cod:=l
end;
Procedura CITIMG are rolul de a reface imaginea continuta in fi!?iere. Pentru

a realiza acest lucru, se procedeaza astfel:
se cite!?te dimensiunea din fi ierul text;
se rezerva in memorie spatiu pentru citirea imaginii (procedura getmem);
se cite te in memorie imaginea din fi ierul fara tip (procedura blockread);

se vizualizeaza imaginea (procedura putimage).
Parametrii acestei proceduri sunt urmatorii:
x,y- coordonatele coltului din stanga sus al dreptunghiului care va contine
imaginea;
fdim, fimg - parametrii de tip string care contin numele celor doua fi iere.
procedure citimg(x,y:integer;fdim,fimg:string);
var fl:text;
f2:file;
dim: integer;
a:pointer;
begin
assign(fl,fdim);
assign(f2,fimg);
reset(fl);
read(fl,dim);
reset(2,dim); getmem(a,dim);
blockread(f2,a,l);
putimage(x,y,a,xorput);
close(1);
close(2);
end;
Urmatoarele doua programe testeaza cele prezentate.

Programul IMSALV deseneaza un cere l?i il salveaza.
program imsalv;
uses graph,utilg;
var cod:byte;
begin initg;
circle(lO,lO,lO);
scrimg(0,0,20,20,'dimg,img,cod);
close11raph;
if cod=O
then writeln(imagine salvata)
else writeln('tentativa de salvare esuata)
end.
Programul IMCIT reface imaginea salvata de programul anterior (se observa

faptul ca imaginea este refacuta intr-o alta pozitie, pentru ca aa am solicitat).
program imcit;
u-ses graph,uti.lg;
begin initg;
citimg(lOO,lOO,'dimg,img);
readln;
closegraph;
end.
10.12. Ferestre grafice

fn studiul unitatii CRT ne-am obi!?nuit sa lucram cu fprestre Tn care se puteau
reprezenta caractere. Se poate iur:;a cu ferestre !?i Tn grafica, Tnsa procedurile
puse Ia dispozi ie de unitatea de program GRAPH, pentru aceasta problema,
sunt mult mai modeste.
Deschiderea unei ferestre se face prin procedura SETVIEWPORT. Forma
generaIa de apel a acestei proceduri este urmatoarea:
SETVIEWPO_RT(x1 ,y1,x2,y2,clip);
(x1, y1) reprezinta coordonatele col ului din stanga sus al ferestrei;
(x2, y2) reprezintf :::oordonatele col ului din dreapta jos al ferestrei;
parametrul clip estc boolean, daca are valoarea ti'ue nu este permisa scrierea
Tn afara ferestrei (Ia tentativa de desenare a unui segment care intersecteaza
fereastra, se traseaza numai portiunea din interiorul ferestrei), Tn caz contrar
se poate scrie 9i Tn afara ei.
Odata deschisa o fereastra, orice prosedura grafica ce folose9te coordonate
de puncte, va utiliza coordonatele relativ Ia fereastra nou creata. Acest aspect
permite scrierea unor programe independente de fereastra folosita.
Culoarea cu care se deseneaza Tntr-o fereastra se stabileste, cum este si
normal, cu ajutorul procedurii setcolor. Dar culoarea fonduiui?.Tn cazul ut:lizar.ii
procedurii setbkcolor, nu numai fereastra capata culoarea ceruta, ci Tntreg
ecranul. Nici macar nu exista o alta procedura care sa ofere aceasta posibili
tate. De asemenea, chiar daca avem deschisa o fereastra, funqiile getmaxx i?i
getmaxy sunt relative Ia Tntreg ecranul.
Programul care urmeaza afi9eaza cele mai mari coordonate de afi are (care
sunt relative Ia Tntregul ecran, de!?i s-a deschis o fereastra).
program tl;
uses graph,utilg;
var a,b:integer;
begin initg;
setviewport(l,l,S,S,true);
a:=getmaxx; b:=getmaxy;
closegraph;
writeln(a, 1 1 ,b);
end.
Datorita acestor neajunsuri, este necesar sa construim un obiect numit fers

(fereastra obiect)/ care elimina o parte din ele. Acest obiect are urmatoarele
date:
x1/ y1, x2, y2 - coordonatele ferestrei;
cf, cc - culorile de fond !?i de desen;
maxx, maxy- coordonatele maxime care pot fi afi9ate Tn fereastra;
lung - dimensiunea Tn octeti necesara salvarii ferestrei;
clip - daca fereastra este cu taiere sau nu;
adres a - retine adresa Tn cazul Tn care fereastra a fost salvata.
Acest obiect con ine

continuare.
i c
erie de metode care vor fi prezentate Tn
Metoda INIT rezolva urmatoarele:

deschide o fereastra;
retine pentru ea culorile de fond, de desen $i parametrul de taiere;
calculeaza maxx i maxy;
atribuie ferestrei culoarea de fond (de fapt deseneaza poqiunea
corespunzatoare ei, a ferestrei implicite, cu ajutorul procedurii BAR, dupa
care o deschide);
stabile te culoarea de desen (SETCOLOR).
Metodele CITMAXX Sl CITMAXY sunt funqii de tip integer asemanatoare

funqiilor GETMAXX !?i GETMAXY, care au rolul de a furniza utilizatorului
continutul variabilelor MAXX i MAXY (coordonate maxime de afi are pe
ecran).
Metoda SALVEZ are rolul de a salva o fereastra In memorie (de fapt,
imaginea asociata ei). Pentru a realiza aceasta, se procedeaza astfel:
se redeschide fereastra mare (cea implicita);
se calculeaza dimensiunea necesara salvarii imaginii ferestrei;
se aloca spatiu Tn memorie i se salveaza fereastra (In cazul unei tentative
nereu ite, variabila cod capata valoarea 0).
Metoda RESTAUREZ are rolul de a restaura o fereastra salvata (sa reapara
imaginea ei pe ecran). Dupa restaurare, se elibereaza spatiul de memorie rezer
vat imaginii.
Metoda INCHID are rolul de a Tnchide fereastra.
lata unitatea de program:
unit tfer;
interface
uses utilg,graph;
type fers = object
xl,yl,x2,y2,cf,cc,maxx,maxy,lung:integer;
clip:boolean;
adresa:pointer;
procedure init(xa,ya,xb,yb,cfond,codc: integer;
tai:boolean);
function citmaxx:integer;
function citmaxy:integer;
procedure salvez(cod:integer);
procedure restaurez;
procedure inchid;
end;
implementation
procedure fers.init;
var i:integer;
begin
xl:=xa;
yl: =ya;
x2:=xb;
y2:=yb;
cc:=codc;
cf:=cfond;
clip:=tai;
maxx:=x2-xl;
maxy:=y2-yl;
setfillstyle(l,cf);
bar(xl,yl,x2,y2);
setcolor(cc);
setviewport(xl,yl,x2,y2,clip);
end;
function fers.citmaxx:integer;
begin
citmaxx; =maxx;
end;
function fers.citmaxy:integer;
begin
citmaxy:=maxy;
end;
procedure fers.salvez;
begin
setviewport(O,O,getmaxx,getmaxy,false);
cod:=imagesize(xl,yl,x2,y2);
if cod<>O then
begin
lung:=cod;
getmem(adresa,lung);
getimage(xl,yl,x2,y2,adresaA);
clearviewport
end
end;
procedure fers.restaurez;
begin
setviewport(o,o,getmaxx,getmaxy,false);
putimage(xl,yl,adresaA,O);
setviewport(xl,yl,x2,y2,true);
setcolor(cc);
freemem(adresa,lung);
end;
procedure fers.inchid;
begin
clearviewport;
setviewport(O,O,getmaxx,getmaxy,false);
end;
Programul care urmeaza testeaza obiectul FERS. Acesta

urmatoarele:
deschide o fereastra in care traseaza un segment;
realizeaza
salveaza fereastra;
deschide o a doua fereastra in care traseaza un segment;
restaureaza prima fereastra In care traseaza un nou segment;
lnchide cele doua ferestre.
program test;
uses graph,utilg,tfer;
var a,b:fers;
cod: integer;
begin initg;
a.init(30,lOO,J00,200,red,green,true);
moveto(O,O);
lineto(a.citmaxx,a.citmaxy);
readln;
a.salvez(cod);
readln;
b.init(lOO,l00,200,200,yellow,black,true);
moveto(o,b.citmaxy);
lineto(b.citmaxx,o);
readln;
b.inchid;
a.restaurez;
readln;
moveto(lO,lO);
lineto(SO,SO);
readln;
a.inchid;
readln;
closegraph
end.
10. 13. Elemente de grafica 20

10. 13. 1. Desenarea graficului unei functii
Se considera functia f definita pe intervalul [a,b] cu valori Tn multimea
numerelor reale. Se cere sa se reprezinte grafic funqia f.
Reamintim definitia graficului unei funqii f, definitie cunoscuta din
matematica: Gf={(x,y)ia<x<b & y=f(x)}. Evident, graficul unei funqii
definita pe un interval va contine o infinitate de puncte (x,f(x)). Numarul de
puncte care pot fi reprezentate pe ecran este finit, motiv pentru care nu le
putem reprezenta pe toate. 0 functie poate fi reprezentata printr-un numar
maxim de puncte egal cu numarul de pixeli continuti de un rand al ecranului
(getmaxx + 1).
Programul care urmeaza reprezinta grafic functia f = sin(x) pe intervalul
[-""].
program gra1;
uses utilg,graph;
var i:integer;
begin initg;
moveto(O,round(getmaxy/2));
lineto(getmaxx,round(getmaxy/2));
moveto(round(getmaxx/2),0);
lineto(round(getmaxx/2),getmaxy);
moveto(O,round(getmaxy/2-sin(-pi)getmaxy/2));
for i:=l to getmaxx do
lineto(i,round(getmaxy/2-sin(-pi+2pi/getmaxxi)getmaxy/2))
end.
Cum s-a procedat?

in primul rand au fost trasate axele OX !?i OY. intrucat domeniul de defini!ie
al functiei considerate este simetric ([-"'"]), axa OY se traseaza Tn mijlocul
ecranului. Un punct apartinand graficului funqiei are doua coordonate, x !?i y.
lndiferent de functie !?i de domeniul ei de defJni!ie, x va lua pe rand valorile 0,
1,...,getmaxx. Care sunt valorile luate dey? In mod normal y= sin(x). Dar x ia
valorile aratate, care nu au nici o legatura cu intervalul [ -"'"]. Calculam:
y =sin(-pi+2*pi/getmaxx*i),
unde i ia valori Tntre 0 !?i getmaxx. Cand i ia valoarea _ 0 se calculeaza
y =.sin(-pi). Cand i ia valoarea getmaxx se calculeaza sin(pi). In esenta, se face
un calcul de forma sin(-pi+r*i), unde r=2*pi/getmaxx. Nici acest calcul nu
permite reprezentarea grafica dorita. Se !?tie ca functia sinus ia valori Tn interva
lul [ -1,1]. Deci y va lua valori apartinand acestui interval. Ordonata unui punct
de pe ecran trebuie sa fie cuprinsa lntre 0 !?i getmaxy, altfel graficul apare pe
ecran ca o linie. Calculam:
y = sin(-pi + 2*pi/getmaxx*i)*getmaxy/2.
in acest fel, valorile y se vor gasi Tn intervalul [-getmaxy/2,getmaxy/2). Cele
doua valori extreme au fost obtinute tinand cont ca sinusul ia valori Tntre -1 si
1. Nici aceasta forma nu este suficienta daca tinem cont de faptul ca, pe
ecran, pixelul aflat In coltul din stanga sus are coordonatele (0,0) !?i nu eel din
stanga jos cum ar fi fost normal. Tinand cont de aceasta ultima observatie, y
se calculeaza astfel:
y: = getmaxy/2-sin(-pi + 2*pi/getmaxx*i) *getmaxy/2
Cand sinusul ia valoarea -1, y va fi getmaxy, iar cand sinusul ia valoarea 1,
y va fi 0. Tinand cont de faptul ca procedurile grafice solicita valorile x !?i y
intregi, y se calculeaza prin rotunjirea valorii obtinute (functia ROUND).
Trasarea graficului se face unind printr-un segment orice pereche de puncte
consecutive care apartin graficului functiei. Mecanismul de trasare a acestui
grafic rezulta !?i din Figura 10.3.
Observatie. Nu avem aceeal?i unitate de masura pe OX !?i OY !?i nici nu ar fi

posibil acest fapt. Din acest motiv, graficele pot aparea uneori deformate.
Cum putem trasa graficul unei functii oarecare?
GETMAXX, 0
0,0
(
M (.1 [ GETMAXY - sIn-rc
'
2rc
GETMAXX
)]
!_
0, GETMAXY
GETMAXX, GETMAXY
Figura 10.3.
Programul care urmeaza traseaza graticul unei funqii care se gase!?te Tn
unitatea de program FSTAND l?i care este definita pe intervalul [a,b]. Programul
trebuie sa funqioneze oricare ar fi functia continuta Tn unitatea de program.
Cum se procedeaza? Initial, se cite!?te domeniul de definitie al functiei
(valorile a !?i b), se trece in mod grafic !?i se traseaza axa OX. Trasarea axei OY
se face numai in situatia in care intervalul [a,b] contine valoarea 0 (in caz
contrar, axa OY nu este vizibila pe ecran). A!?a cum de altfel a rezultat !?i din
programul anterior, graficul se traseaza utilizand getmaxx + 1 puncte (de Ia 0
Ia getmaxx). lntervalul [a,b] se imparte 'fn getmaxx paqi egale (avem pasul de
lucru (b-a)/getmaxx). Se
calculeaza f(a + pas*i), pentru i = 0,
1,...getmaxx. Cand i ia valoarea 0 se calculeaza f(a) iar cand i ia
valoarea getmaxx se
calculeazaf(a + (b-a)/getmaxx*getmaxx) = f(a + b-a) = f(b). Toateaceste
valori
se retin intr-un vector cu componente numere reale, numit VALF. Problema
care apare este de a stabili unitatea de masura pe axa OY. Problema nu este
banala. Pentru programul anterior se !?tia faptul ca funqia sinus ia valori Tntre
-1 !?i 1, dar aici avem o functie oarecare, pentru care nu cunoa!?tem in
prealabil multimea valorilor ei. Mai mult decat atat, chiar daca am cunoa!?te
funqia, daca aceasta are o expresie complicata nu putem, prin procedee strict
matema tice, sa determinam multimea valorilor ei. Din cele prezentate, rezulta
faptul ca singurul mecanism posibil de lucru este de a calcula Tn vectorul
VALF
toate valorile pe care le ia functia Tn punctele din intervalul
considerat, dupa care
urmeaza stabilirea unitalii de masura pe axa OY. Pentru aceasta, trebuie sa

vedem care este valoarea minima !?i care este valoarea maxima luata de functie
(In program acestea se calculeaza In cadrul variabilelor MINF !?i MAXF).
Din pacate, nu in toate cazurile acestea sunt simetrice fata de axa OX (cum
se intampla In cazul funcliei sinus pe intervalul considerat, unde valoarea
minima este -1 !?i valoarea maxima este 1). Aici, este posibil sa avem valoarea
maxima 100 !?i cea minima -10. Pentru a putea reprezenta corect aceste valori,
convenim urmatoarele: cea mai mare valoare in modul se reprezinta in partea
de sus a ecranului (prin pixeli care au y = 0), daca este pozitiva, sau in partea
de jos a ecranului (prin pixeli care au y = getmaxy), in cazul cand aceasta este
negativa. Restul valorilor se reprezina propor1ional.
in concluzie, programul ac1ioneaza astfel:
se compara cele doua valori (In modul);
o in cazul In care cea mai mare valoare in modul este cea maxima, se
inlocuie!?te fiecare valoare a functiei din VALF prin expresia: valf[i]: =
getmaxy/2-getmaxy/(2*maxf)*valf[i], i = 0,1, ...,getmaxx;
o in cazul in care cea mai mare valoare in modul este cea negativa, se
inlocuie!?te fiecare valoare a functiei din VALF prin expresia: valf[i]: =
getmaxy/2-getmaxy/(2 *abs(minf)) *Valf[i].
Ce am obtinut astfel? in prima situatie, valorii maxime a func1iei ii corespunde:
valf[i] = getmaxy /2-getmaxy/(2 * maxf) *maxf =
0, iar In al doilea caz, valorii minime ii
corespunde:
valf[i]:
= getmaxy/2-getmaxy/(2*abs(minf))*min(f) = getmaxy,
daca tinem cont de faptul ca, In acest caz, minimul este ne ativ. in oricare din
situalii, restul valorilor se reprezinta proportional pe ecran. In final, se traseaza
graficul prin unirea prin segmente a oricaror doua perechi de puncte
consecutive, secventa pe care, datorita simplitatii ei, nu o comentam.
program curba;
uses crt,graph,utilg,fstand;
var a,b,pas,minf,maxf:real;
valf:array[O..1000] of real;
i:integer;
begin
clrscr;
writeln(domeniul de definitie [a,b] ');
write(a=);readln(a);
write('b=');readln(b);
initg;
moveto(O,getmaxy div 2);
lineto(getmaxx,getmaxy div 2);
if (a<O) and (b>O) then
begin
moveto(round(abs(a)/(abs(a)+b)getmaxx),O);
lineto(round(abs(a)/(abs(a)+b)getmaxx),getmaxy)
end;
pas:=(b-a)/getmaxx;
for i:=O to getmaxx do valf[i]:=f(a+pasi);
minf:=valf[O]; maxf:=valf[O];
for i:=l to getmaxx do
begin
if minf>valf[i] then minf:=valf[i];
if maxf<valf[i] then maxf:=valf[i];
end;
if abs(maxf)>=abs(minf)
then for i:=O to getmaxx do
valf[i]:=getmaxy/2-getmaxy/(2maxf)valf[i]
else for i:=O to getmaxx do
valf[i]:=getmaxy/2-getmaxy/(2abs(minf))valf[i]
i:=O;
moveto(0 1 round(valf[O]));
repeat
lineto(i1 round(valf[i]));
i:=i+l;
until i>getmaxx;
repeat
until keypressed
end.
A!?a cum am conceput pana in acest moment programul, pentru a putea sa-l
rulam trebuie sa cream in prealabil unitatea de program FSTAND care contine
functia ce se reprezinta grafic. De cate ori dorim sa reprezentam grafic o alta
functie, unitatea FSTAND trebuie recreata. Sa recunoa!?tem ca acest procedeu
este destul de greoi !?i se pierde mult timp. Din pacate, limbajul TURBO
PASCAL nu permite citirea unei functii oarecare, careia sa-i putem calcula
valorile. Ce artificii ar trebui sa facem pentru ca acest fapt sa devina posibil?
Exista posibilitatea sa scriem noi un program care sa citeasca expresia unei
funqii !?i sa genereze o secventa de calcul care, Ia executie, sa calculeze
valorile functiei in diverse puncte. Despre modul in care se realizeaza un astfel
de program vom invata in anul urmator (sunt necesare cuno!?tinte care depa
sesc nivelul clasei a noua).
Pentru moment, vom folosi o alta metoda. in ce consta aceasta?
Programul GRAFIC F se apeleaza de cate ori dorim sa facem graficul unei noi
functii. Acesta realizeaza urmatoarele:
apeleaza, spre a fi executat, programul CITF;
apeleaza programul compilator TPC spre a compila programul de realizare a
graficului unei functii oarecare (program numit CURBA !?i care a fost
prezentat anterior);
apeleaza spre executie programul CURBA.
program grafic f;
uses dos;
{$m 40001 01 0}
begin swapvectors;
exec(citf.exe 1 1' 1 );
swapvectors;
exec(c:\tp\tpc.exe' 1 1 Curba);
swapvectors;
exec(curba.exe,
'); swapvectors;
end.
Programul CITF creeaza unitatea de program FSTAND. Aceasta este creata

ca un fi ier text oarecare. Numele fi!?ierului trebuie sa aiba extensia PAS.
Fiecare Tnregistrare a acestui fi!?ier va con ine o linie din unitatea de program.
Astfel, se scriu pe rand liniile:
unit stand;
interface
function f(x:real):real;
implementation
function f(x:real):real;
begin
Tn acest moment, programul cite!?te valoarea funqiei lntr-o variabi!a de tip

STRING. Se scrie Tn continuare:
f:=continutul variabilei STRING;
end;
end.
Dupa Tnchiderea fi!?ierului FSTAND.PAS se apeleaza compilatorul TPC care

compileaza unitatea de program. Tn cazul Tn care Ia compilare apar erori,
acestea provin de Ia introducerea incorecta a expresiei functiei. Tn acest caz,
prin analiza codului prin care s-a terminat programul TPC (functia
DOSEXITMODE), se reia crearea fi ierului FSTAND.PAS.
program citf;
{$m 4000,0,0}
uses dos;
var f: text;
exp:string;
tpc,numep:string;
begin
assign(,'fstand.pas');
repeat
writeln;
rewrite();
writeln(f,unit stand;);
writeln(f,'interface');
writeln (,function f(x:real):real;);
writeln(f,'implementation)-;
writeln (,'function f(x:real):real;');
writeln(f, begin);
write('f:=');readln(exp);
write(f,'f:=);writeln(f,exp);
writeln(f,end;');
writeln(f,end.');
close();
tpc:=fsearch ('tpc.exe,getenv('path'));
numep:=fstand.pas;
swapvectors;
exec(tpc,numep);
swapvectors
until dosexitcode=O
end.
in momentul Tn care avem unitatea FSTAND.PAS gata compilata se poate

compila programul care realizeaza graficul. Care este motivul pentru care este
necesara aceasta compilare? in definitiv, am fi putut compila o singura data
programul CURBA. in realitate, programul ob inut (in cod ma!?ina) cantina Tn
cadrul lui toate subprogramele pe care le apeleaza. Din acest motiv, daca nu
compilam programul CURBA in momentul in care avem Ia dispozi ie noua
unitate de program, nu realizam ceea ce dorim.
in continuare prezentam cateva din rezultatele obtinute cu acest lant de
programe:
10. 13.2. Desenarea curbelor plane

La matematica am invatat ecua ia cercului cu centrul in origine, de raza data.
Consideram reprezentarea cercului in plan. Este acesta un grafic de functie?
Evident nu, deoarece exista valori ale lui x pentru care corespund doua valori
ale lui y (o paralela Ia axa 'JY poate sa taie cercul in doua puncte). Atunci cum
am putea proceda ca sa trasam un cere? 0 prima posibilitate este sa obtinem
reprezentarea grafica a cercului reprezentand grafic urmatoarele doua "functii
de mai jos:
1 12
2
2 1/2
y 2=r 2 -x 2; y 1_ 2 =(r2 -x2 )';
f=(r -x) , xE[-r,r];
2
2 1/2
Q=-(r -x)
.,xE[-r,r]
Nu este _cam greu? Dar daca o curba are o ecua ie mult mai complicata, din
care nu mai rezulta a$a de U!?Or funqiile care trebuie reprezentate? Din acest
motiv, s-a ajuns Ia concluzia ca este necesar un alt mecanism prin care sa fie
data o curba. Astfel, putem alege (deloc U!?or) doua func ii, f !?i g, de variabila
t, cut apaqinand intervalului [a,b], astfel incat x = f(t) !?i y = g(t). Prin
eliminarea lui t, se ajunge Ia ecuatia initiala a curbei. Astfel, cercul poate fi
reprezentat ca
fiind dat de ecuatiile x: = r*sin(t) !?i y: = r*COs(t), cu t apaqinand intervalului
[0,2 * "]. Eliminarea lui t se face ca mai jos, obtinand astfel ecua ia cercului.
Problema care se pune in continuare este urmatoarea: se da o curba

exprimata parametric, x = f(t) !}i y = g(t), t apartine lui [a,b], !}i se cere sa se
reprezinte grafic.
Citirea functiilor f !}i g se face ca In paragraful precedent, in care citeam o
singura functie. Programul GRAFIC P gestioneaza lntregul proces, dupa cum
se vede mai jos:
program grafic_p;
uses dos;
{$m 4ooo,o,o}
begin swapvectors;
exec(citfp.exe,);
swapvectors;
exec(c:\tp\tpc.exe,curbap);
swapvectors;
exec(curbap.exe,);
swapvectors;
end.
Programul CITFP creeaza unitatea FSTAND (care contine expresiile functiilor

f i g) i o compileaza.
program citfp;
{$m 4000,o,o}
uses dos;
var f: text;
exp:string;
tpc,numep:string;
begin
assign(f,fstand.pas);
repeat
writeln;
rewrite();
writeln(f,unit stand;'); writeln(f,'interface);
writeln (,'function f(t:real):real;');
writeln(f,'function g(t:real):real;');
writeln(f,'implementation);
writeln (f, function f(t:real):real;);
writeln(f,'begin');
write('f: =);-readln(exp);
write(f,'f:=);writeln(f,exp);
writeln(f,'end;);
writeln (,unction
g(t:real):real;'); writeln(f,'begin);
write(g:=);readln(exp);
write(f,g:=);writeln(f,exp);
writeln(f,end;);
writeln(f,end.);
300
close();
tpc:=fsearch ('tpc.exe',getenv('path'));
numep:='fstand.pas;
swapvectors;
exec(tpc,numep);
swapvectors
until dosexitcode=O
end.
Programul CURBAP deseneaza curba pe monitor, dupa ce, in prealabil,
cere domeniul de definitie al celor doua funqii.
Care este mecanismul prin care se traseaza desenul curbei?
in primul rand, intervalul [a,b] se imparte in o mie de parti egale. in
fiecare punct astfel obtinut, se calculeaza x = f(t) i y = g(t). In acest fel
obtinem
coordonatele reale ale unui punct apartinand curbei, coordonate care se retin
in cadrul a doi vectori XE (pentru valorile lui x) 9i YE (pentru valorile lui y).
Coordonatele astfel obtinute trebuie transformate in coordonate ecran. Pentru
aceasta, se procedeaza astfel:
se calculeaza valoarea minima i maxima a lui
x;
se calculeaza valoarea minima !?i maxima a lui y;
se calculeaza r1 ca fiind variatia lui x (din maximul lui x se scade valoarea
minima a lui x);
se calculeaza, in mod asemanator, r2 ca fiind variatia lui y;
se calculeaza rca fiind maximul dintre r1 !?i r2 impartit Ia getmaxy.
Pentru ce am procedat astfel? Acest procedeu a fost aplicat pentru a stabili
unitatea de masura (astfel, daca x a avut o variatie mai mare, curba
reprezentata va ocupa intreg spatiul disponibil pentru x, !?i numai cat este
necesar pentru y, !?i invers, daca y a avut o variatie mai mare, curba va ocupa
intreg spatiul disponibil pentru y !?i numai cat este :1ecesar pentru x). Care este
motivul pentru care r a fost obtinut prin impartirea Ia getmaxy !?i nu prin impar
tirea Ia getmaxx ? Am dorit sa obtinem aceasta reprezentare intr-un patrat !?i
patratul de latura maxima continut pe ecran este cu getmaxy + 1 puncte
adresabile (daca acceptam sa reprezentam curba pe dreptunghiul continut de
intregul ecran, un cere ar fi aratat ca o elipsa ...).
in continuare, se transforma efectiv coordonatele gasite in XE !?i YE in
coordonate ecran. in acest scop, se folosesc formulele de mai jos:
xe[i]: =(xe[i]-minx)/r;
ye [i] : =getmaxy-(ye [i] -miny)/r;
end;
Sa presupunem ca x a avut variatia maxima. in punctul in care x este
maxim, xe[i] va fi:
(maxx-min) *Qetmaxy/(maxx-min) = getmaxy;
in punctul in care x este minim, xe[i] va fi 0. Restul valorilor se raspandesc
proportional in intervalul [O,getmaxy]. intrucat variatia lui y este mai mica
decat aceea a lui x, ye[i] va avea valori in acela!?i interval, tara sa-l
acopere in
'fntregime (in transformarea lui y se tine cont de faptul ca un punct cu y minim
trebuie sa se reprezinte In partea de jos a ecranului, deci va avea o valoare

apropiata de getmaxy).
Dupa aceasta transformare, trasam curba prin unirea punctelor consecutive
prin segmente.
program curbap;
uses graph,utilg,fstand;
var nrt,i,j:integer;
a,b,t,minx,miny,maxy,maxx,r1,r2,r:real;
xe,ye:array[1..1000] of real;
begin
write('a=');readln(a);
nrt:=1000;
t:=a;
for i:=1 to nrt do

begin
xe[i]:=f(t);
ye[i] : =g(t)
;
t:=t+(b-a)/nrt;
end;
minx:=xe[1];maxx:=xe[1];
miny:=ye[1];maxy:=ye[1];
for i:=1 to nrt do
begin
if xe[i]<minx then
if xe[i]>maxx then
if ye[i]<miny then
if ye[i]>maxy then
end;
minx:=xe[i];
maxx:=xe(i];
miny:=ye(i];
maxy:=ye[i];
initg;
r1:=(maxx-minx);
r2:=(maxy-miny);
;if rl>r2
then r: =r1/getmaxy
else r:=r2/getmaxy;
for i:=1 to nrt do
begin
xe[i]:=(xe
[i]
-minx)/r;
ye[i]:=getmaxy-(ye[i]-miny}/r;
end;
moveto(round(xe(1]),round(ye(1])};
for i:=2 to nrt do
begin
lineto(round(xe[i]),round(ye(i]));
end;
readln;
closegraph;
end.
Un exemplu de reprezentare grafica se gase!?te In PLAN$A 5.
10. 13.3. Rotatii

In prezentul paragraf raspundem Ia intrebarea: cum rotim o figura plana?
Aceasta problema se reduce Ia una mai simpla, $i anume: cum rotim un
punct cu un unghi dat in jurul altui punct. Dadi $tim sa raspundem Ia aceasta
intrebare, putem roti o figura in jurul unui punct prin rota ia punctelor care o
caracterizeaza. De exemplu, pentru rotatia unui pi'Hrat In jurul unui punct, se
rotesc punctele care constituje varfurile acestuia $i se traseaza patratul rotit
prin intermediul acestor puncte. Fie figura 10.4., in care punctul de coordonate
(x1,y1) se rote$te in jurul punctului de coordonate (xc,yc) cu un unghi dat.
Dorim sa ob inem noile coordonate ale punctului P (x1,y1 ).
x=
Xc
+ MT1
Xc
+ MP'cos(tp + 8) = Xc + MP'(costp cos8-sintp
sin8)
4
y ------------------- - ------------------
p' (X, y)
--------
Y1 --------------------
Ta
Yc
""""
'\
\P (
----------
X1, Y1 )
------------------Mi( xc, Yc)

I
X
0
Figura 10.4.
Dar MP= MP' (raza); MT 2 = x 1 -xc; MT 3 = y 1-vc;
cos8= MT2 /MP= (x 1-
xcl/MP';
sin8= PT 2 /MP= MT 3 /MP= (y 1-vcl/MP'

x=xc+MP'[costp(x 1-xc)/MP'- sintp(y 1-yc)/MP')
x=xc+lx 1-xc)costp- (y 1-Yc)sintp
Analog y=yc + MT4 =vc + MP'cos[90-(8+tp)] =vc + MP'sin(8+tp) =
=vc+MP'(sin 8 costp+sinU' cos 8)=vc+MP'[(y 1 - Yc)/MP')costp+
+ [(x 1-xc)/MP']sintp) =vc 1- (y1-yc)costp+ (x 1xc)sintp v= Yc + (y
1-Yc)costp+
(x 1-xc)sintp
Formulele gasite sunt con inute de procedura ROTPLAN care se gase!?te in

cadrul unita ii UTILG.
procedure rotplan
(xc,yc,xl,yl:integer;
var x,y:integer;unghi:real);
begin
x:=round(xc+(xl-xc)cos(unghi)-(yl-yc)sin(unghi));
y:=round(yc+(xl-xc)sin(unghi)+(yl-yc)cos(unghi))
end;
Programul care urmeaza deseneaza un patrat, il plimba pe orizontala !?i

verticala, il rote!?te 'fn jurul unui punct al sau. Pentru acestea, se folose!?te
tehnica de animatie care utilizeaza procedura setwritemode.
program trot;
var xl,yl,x2,y2,x3,y3,x4,y4,x,y,l,i:integer;
procedure desen(xl,yl,x2,y2,x3,yJ,x4,y4:integer);
begin
moveto(xl,yl);
lineto(x2,y2);
lineto(x3,y3);
lineto(x4,y4);
lineto(xl,yl)
end;
begin initg;
xl:=lOO; yl:=lOO;
x2:=120; y2:=100;
x3:=120; y3:=120;
x4:=100; y4:=120;
desen (xl,yl,x2,y2,xl,y3,x4,y4);
for i:=l to so do
begin
.
delay(lOO);
desen(xl;yl,x2,y2,xl,yl,x4,y4);
xl:=xl+l;
x2:=x2+1;
xl:=x3+1;
x4:=x4+1;
desen(xl,yl,x2,y2,xl,y3,x4,y4);
end;
desen(xl,yl,x2,y2,x3,y3,x4,y4);
for i:=l to so do
begin
y1:=y1+1;
y2:=y2+1;
y3:=y3+1;
y4:=y4+1;
desen(x1,y1,x2,y2,x3,y3,x4,y4);
delay(100);
desen(x1,y1,x2,y2,xl,y3,x4,y4);
end;
x: =x1; y: =y1;
l:=x2-x1;
for i:=1 to 100 do
begin desen(x1,y1,x2,y2,x3,y3,x4,y4);
rotplan(x,y,x+l,y,x2,y2,pi*i/SO);
rotplan(x,y,x+l,y+l,x3,yl,pi*i/SO);
rotplan(x,y,x,y+l,x4,y4,pi*i/SO);
delay(100);
end;
readln;
closegraph;
end.
10.13.4. Curbe BSPLINE

Se considera trei puncte A(x1,y1 ), B(x2,y2), C(x3,y3) (consideram ca
punctele pot fi afi!?ate pe ecran utilizand direct aceste coordonate). Fie curba
data prin ecuatii parametrice:
2
2
2
x = f(t) = 0,5[( 1-t) x 1 + ( 1 + 2t-2t )x2 + t x 3 ]
2
2
2
y = g(t) = 0,5[( 1-t) y, + ( 1 + 2t-2t )y2 + t y3]
A ( x1,
y1 j
Figura 10.5.
0 astfel de curba se nume!?te curba BSPLINE !?i are urmatoarele proprietati:

este tangenta segmentului AB Tn mijlocul sau;
este tangenta segmentului BC Tn mijlocul sau;
aproximeaza linia poligonala ABC, a!?a cum se vede Tn figura 1 0.5.
Punctele A, B, C se numesc puncte de ghidaj ale curbei.
Programul care urmeaza arata cum se poate desena pe monitor o astfel de curba.
program bspline;
uses graph,utilg;
procedure xy(xl,yl,x2,y2,x3,yl:integer;t:real;var x,y:integer);
begin
x:=round(O.S*(Xl*(l-t)*(l-t)+x2*(1+2*t-2*t*t)+x3*t*t));
y:=round(O.S*(Yl*(l-t)*(l-t)+y2*(1+2*t-2*t*t)+y3*t*t));
end;
procedure trasez(xl,yl,x2,y2,xl,y3,nrp:integer);
var pas,t:real;
x,y,i:integer;
begin
t:=O;
xy(xl,yl,x2,y2,x3,y3,t,x,y);
moveto(x,y);
pas:=l/nrp;
for i:=l to nrp do
begin
t:=t+pas;
xy(xl,yl,x2,y2,xl,y3,t,x,y);
lineto(x,y)
end
end;
begin initg;
moveto(O,O);
lineto(lOO,lOO);
lineto(200,0);
trasez(O,O,lOO,l00,200,0,lOO);
end.
Curbele BSPLINE sunt utilizate in realizarea desenelor. in princ1p1u, se

traseaza desenul, format din linii frante, pe o hartie milimetrica. Atunci cand se
reprezinta pe monitor, se folosesc aceste curbe, ce permit realizarea unui desen
cu forme rotunjite. incercati sa realizati astfel de desene spre a va convinge.
10.14. Elemente de grafica 3D

in acest paragraf se prezinta cateva notiuni strict necesare intelegerii modului
in care se pot reprezenta pe monitor obiecte din viata reala, !?i anume cele cu
3 dimensiuni. Multe din notiunile prezentate sunt imprumutate din desenul
tehnic, datorita faptului ca aceste obiecte se reprezentau pe hartie cu mult timp

inaintea apari iei calculatoarelor.
Fie un punct M, de coordonate (xO, yO, zO), reprezentat in sistemul de axe

OXYZ. Fie un plan P care are o pozi ie oarecare faa de sistemul OXYZ. Atat
punctul M cat !?i axele OX, OY, OZ se proiecteaza pe planul P. Proiec ia unui
punct oarecare pe planul P se face printr-o dreapta paralela cu o directie data
(nu se realizeaza neaparat prin perpendiculara pe plan, deoarece nu este vorba
de o proiectie ortogonala ci de una oblica).
z
p
---
z*
Z 0* <--
--- ---
---
---
-- --- -7," M ( Xo' Yo

I
I
I
I
---
I
I
I
x. y. z )
'frrc,
I
'
I
I
I
'
I
f
0* ,
, '
'
'
I
I
I
I
2o)
I
I
I
I
I
I
''
'
'
--: ------
---
''
'I '1
'..., '.. .'..!..,,; ,.
----- --- ---
Figura 10.6.
Notam cu N proiec ia punctului M cu 0* proiec ia punctului 0, cu

O*X*proiectia axei OX, cu O*Y* proieqia axei OY !?i cu O*Z* proiec ia axei
OZ. O*X*Y*Z* reprezinta un sistem de axe In planul P. Fata de acest sistem
de axe punctul N va avea coordonatele xO *, yO*, zO *. Evident, coordonatele
punctului N nu coincid ca valoare cu coordonatele punctului M. Astfel, xO* va
fi diferit de xO !?.a.m.d.
Exista procedee de exprimare a coordonatelor punctului N in functie de
coordonatele punctului M, lnsa acestea depa!?esc cu mult cuno!?tin ele de
1
matematica din liceu !?i, dupa cum vom vedea in continuare, este chiar util sa
ne lipsim de acest calcul.
Din cele prezentate, retinem faptul ca avem un sistem de axe (intr:un plan
oarecare P) 0 *X*Y*Z*,rezultat din proieqia sistemului de axe OXYZ. In acest
sistem putem reprezenta un punct oarecare M(x,y,z) in sistemul OXYZ
masurand pur !?i simplu x, y, z unitati pe axele O*X*, O*Y*, O*Z*. A!?a cum
putem reprezenta un punct in cadrul acestui sistem de axe, putem reprezenta
!?i un obiect din spatiul cu 3 dimensiuni. Tn cele ce urmeaza vom Iuera numai
'fn planul P.
Problema care apare in continuare este urmatoarea: pentru a putea
reprezenta un punct pe monitor, nu putem folosi 'fn mod direct coordonatele
punctului masurate Tn sistemul O*X*Y*Z*, deoarece avem nevoie numai de
2 coordonate !?i nude 3. Tn concluzie, trebuie gasita o modalitate de trecere de
Ia 3 coordonate Ia 2 coordonate. Pentru a putea rezolva aceasta problema, se
consider a un sistem de axe cu centrul Tn 0 *, prin trasarea dreptelor
perpendiculare 0 *XO, 0 *YO !?i se gase!?te o relatie de transformare a
coordonatelor punctului Tn acest sistem ((x 0 *, y 0 *, z 0 *)- (x 0 , y 0 )) .
. in figura 10.7. punctul N (x0 *, y *, z *) 'fn sistemul 0 *X *Y*Z* are
coordo natele (x0;y0) .in sistemul 0 0* X0 Y 00 . Notam cu alfa, beta, gama
unghiurile formate 'fn sens trigonometric intre axa 0 * X 0 !?i axele 0 *X*,
respectiv 0 *Y*,
0 *Z *. Trebuie gasite relatiile care dau pe x0 , Yo in functie de x 0 *, Yo*, z 0 *,
alfa, beta, gama..
intrucat vom utiliza calculul vectorial, mai putin folosit in orele de
matematica, vom prezenta cateva notiuni strict necesare intelegerii
demonstratiei.
.
Fie M(xm,ym) !?i N(xn,yn) doua puncte Tn sistemul de axe OXY. Acestor
doua puncte le corespund doi vectori !?i
care se obtin prin unirea punctului
0 cu cele doua puncte.
?upa cum !?tim, cei doi vectori t fi insumati
utilizand
regula paralelogramului. In acest mod, obtinem vectorul v cu extremitatile Tn 0
!?i P. Se cere sa aflam coordonatele punctului P (figura 10.8.).
Vi
Avem urmatoarele relatii:
xp=xm+xn; yp=ym+yn.
Demonstram prima relatie. Segmentele OM !?i NP sunt paralele !?i congruente

(laturi opuse ale unui parale!:::>gram). Rezulta ca proieqiile lor pe axa OX s:.mt
congruente.
Avem deci relatia: xm = xp-xn, de unde rezulta ce trebuia demonstrat. A
doua relatie se demonstreaza Tn mod analog.
Revenim Ia problema noastra.
paralelogram. Rezulta
0 *T 3T 1T 2
......
......
......
O*T 1 =0*T3 +O*T2
0 *T 1NT4 este paralelogram. Rezulta

----+...... _,.. _,.. _,..
......
O*N=O*T4 +O*T 1 =O*T4 +O*T3 +O*T2
Utilizand ceea ce am demonstrat anterior putem transcrie relatia scalar:
x 0 = XT3 + XT2 + XT4 ; Yo= YT 3 + YT2 + YT4 ,
z*
z
, 4
',,,, N
------ \
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
I
Figura 10.7.
unde XT2 , XT 1 XT 4 reprezinta coordonatele pe axa OX0 ale punctelor T2 1
T 3, T4 iar YT2 , 3YT 3 , YT 4 reprezinta coordonatele pe axa OY
0 ale punctelor T2
, T 3, T 4 . Dar avem:
XT 3 = x 0 * *Cos(alfa); XT 2 = y0 * *COs(beta); XT4 = z0 * *COs(gama),
intrucat lungimea proieqiei unui segment este egala cu lungimea segmentului
inmultita cu cosinusul un hiului fo mat de dreapta care contine segmentul !?i
dreapta pe care se face proieclia. In mod analog avem:
YT 3 = x0 *cos(90-alfa) = x0 *sin(alfa); YT 2 =y0 *COs(90-beta) =

Yo*Sin(beta);
YT 4 = Zo*COs(90-gama) = Zo*sin(gama).
Am demonstrat astfel relatiile:
x 0 = x 0 * *COs(alfa) +Yo** cos(beta) + z0 *
*COs(gama); Yo= x 0 * *Sin(alfa) + y 0 * *Sin(beta) + z0 *
*Sin(gama).
Aceste transformari le efectueaza procedura d3d2g, care se gase!?te in
unitatea de program UTILG.
procedure d3d2g(alfa,beta,gama:real;xl,yl,zl:real;varx,y:real);
begin
x:=xlcos(alfa)+ylcos(beta)+zlcos(gama);
y:=xlsin(alfa)+ylsin(beta)+zlsin(gama);
end;
intrucat procedura areca date de intrare unghiurile in radiani, a fost necesara

construc ia unei func ii, numita RAD, care are rolul de a transforma masura
unui unghi din grade in radiani.
function rad(x:integer):real;
begin
rad:
=pi*x/180 end;
y
Yp ----------------------------------------
I
I
I
YN -----------
----- -----=-----;-->
XM
XN
Xp
Figura 10.8.
in situatia in care alfa = 0 , beta= 90 , gama = 45 o avem proiectia

cabinet,
care da imagini destul de apropiate de realitate.
in acest caz, formulele de calcul pentru x !?i y se simplifica:
X=X+Z*COS(45);
y=y+Z*COS(45).
Pentru a face calcule mai rapid prezentam !?i procedura d3d2, procedura de cal
cui al coordonatelor x !?i yin cazul proieqiei cabinet. Este de mentionat faptul ca
aceasta procedura furnizeaza direct coordonatele de ati are pe ecran (se tine cont
de taptul ca punctul de coordonate (0,0) se gase!?te in centrul ecranului).
procedure d3d2(xl,yl,zl:integer;var x,y:integer);
begin
x:=getmaxx div 2 + round(xl+sqrt(2)zl/4);
y:=getmaxy div 2 - round(yl+sqrt(2)zl/4)
end;
Y0 ,Y*
X0 ,X*
Figura 10.9.
Un alt triplet de valori pentru unghiurile alta, beta !?i gama (In grade) este:
alta= 165, beta= -135, gama = 135.
Acest triplet de valori este des folosit in reprezentarea suprafetelor in spatiu.
in continuare ne propunem sa desenam o prisma cu lungimile laturilor x1,
y1, z1 unitati. Modul de realizare a acestui program este foarte simplu. Se
reprezintii prisma intr-un sistem de axe !?i se tree pe desen coordonatele
tiecarui punct.
Cele 3 coordonate ale fiecarui punct sunt convertite in 2 coordonate prin
procedura D3D2G. Aceste puncte sunt unite prin segmente. in plus, programul
ere !?i unghiurile alta, beta gama, unghiuri necesare conversiei din 03 in 02.
lncercati programul pentru tripletele:
alta= 0, beta= 90, gama = 45 (proiectia cabinet);
alfa = 165, beta= -135, gama = 135.
Atentie! Programul nu testeaza daca prin valorile

tentativa de scriere in afara ecranului.
program prisma;
uses graph,utilg;
x1,y1,z1 nu se face o
z........ ....
........
.... ....
....
....
........
....
I
I
"
v
*
0
Fi
g
u
r
a
1
0.
1
0.
315
y
Figura
316
var alfa,beta,gama:integer;
xl,yl,zl,x,y:real;
begin
1
write( 1
alfa=
);
readln(alfa); write(1 beta= 1 )
;
readln(b_eta); write( 1 gama=
1
); readln(gama);
1
1
write(
xl=
);
readln(xl); write( 1 yl= 1
);
readln(yl);
write( 1
zl= 1 ); readln(zl); initg;
d3d2g(rad(alfa),rad(beta),rad(gama),o,o,o,x,y);
moveto(getmaxx div 2 +round(x),getmaxy div 2+round(y));
d3d2g(rad(alfa),rad(beta),rad(gama),O,yl,O,x,y);
lineto(getmaxx div 2 +round(x),getmaxy div 2+round(y));
d3d2g(rad(alfa),rad(beta),rad(gama),xl,yl,O,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),xl,O,O,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),o,o,o,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),O,O,zl,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),O,yl,zl,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),O,yl,O,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),xl,O,zl,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),xl,O,O,x,y),;
d3d2g(rad(alfa),rad(beta),rad(gama),xl,o,zl,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),xl,yl,zl,x,y);
lineeo(getmaxx div 2 +round(x),getmaxy div 2+round(y));
d3d2g(rad(alfa),rad(beta),rad(gama),O,yl,zl,x,y);
dld2g(rad(alfa),rad(beta),rad(gama),xl,yl,zl,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),xl,yl,O,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),xl,O,zl,x,y);
d3d2g(rad(alfa),rad(beta),rad(gama),O,O,zl,x,y);
readln;
closegraph
end.
10.4.1. Rotalia unei figuri in spajiu

!n programul care urmeaza se rote te un cub cu latura 50 in jurul axei OY.
In principiu, se procedeaza astfel:
se considera 24 de pozitii intermediare ale cubului rotit in jurul axei OY cu
unghiuri diferite;
o pozi ie a cubului este desenata, tearsa, dupa care se deseneaza pozitia

urmatoare, se terge etc. (se folose te procedura setwritemode).
0 pozitie a cubului este retinuta prin coordonatele celor 8 varfuri ale sale.
Fiind data o pozitie, se poate obtine desenul cubului cu ajutorul procedurii
DESEN. Pozitiile cubului sunt retinute in cadrul variabilei P. Pentru ca programul
sa mearga mai repede (dand astfel impresia de rota ie), coordonatele varfurilor
cubului in cele 24 de pozitii ale sale se calculeaza Ia inceput. Rotatia cubului
in jurul axei OY se reduce Ia o rota ie in planul OXZ in jurul punctului 0 a
patratului care constituie baza cubului. Rotatia patratului se reduce Ia rotatia
punctelor care constituie varfurile sale. Coordonatele varfurilor fetei opuse
bazei se obtin din coordonatele varfurilor bazei modificand coordonata y.
Calculul coordonatelor varfului unei pozi ii oarecare se face de catre procedura
COORD.
in concluzie se procedeaza astfel:
se considera o pozi ie particulara a cubului (in care 3 laturi ale sale coincid
cu axele OX, OY, OZ) !?i se noteaza coordonatele fiecarui varf al sau;
se rote!?te fiecare varf al cubului cu un anumit unghi, obtinand o pozi ie
care se retine;
procedam in mod similar pana se ob in toate cele 24 de pozitii, care se
memoreaza;
fiecare pozi ie se deseneaza apoi se !?terge, creandu-se astfel impresia de
rota tie.
program g2;
uses graph crt1 utilg;
type figura=array[1..2411..81 1, .2] of integer;
var p:figura;
i1j:integer; procedure coord(X1 Y1 Z:integer);
procedure coord(x1 y1 z:integer);
var ilj,xr1 zr:integer;
begin
j:=O; i:=1;
repeat
rotplan(01 01 01 01 Xr,zr1
pij/180); d3d2(xr I 01 zr1P[il 11
1]1 p[i1 1,2]); rotplan(O,Oix,o
xr1 Zr1 pij/1BO); d3d2(Xr1
0,zr,p[i1 21 1]1 p[i1 21 2]);
rotplan(O,OIX1 Z1 Xr 1 Zr1
pij/180); d3d2(xr 1 01 zr I p[i 1 31
1]1 p[i 1 31 2]);
rotplan(010101zlxr1 Zr1
pij/180); d3d2(xr 101 zr 1P[il41
1],p(i,412]); d3d2(01y101 p[i1 51
1]1 p[i1 51 2]);
rotplan(OI01X101Xr1Zr1
pij/180); d3d2(Xr 1 Y 1 zr I P[i 1 6 1
1]1 P[i 1 6 1 2])i rotplan(0101X1Z1Xr1
Zr1pij/180); d3d2(xr I y I Zr I p[i I
7 I 1]1 p[i 1 7 I 2]) i
rotplan(olololzlxr1Zr1
pij/180);
3d(xr y zr p(il811]1p[i1812])
1:=1+1;
j:=j+15;
until
end;
i>24;
p cedure desen(i:integer);
var j:integer;
begin
moveto (p [i, 1, 1] ,p [i, 1, 2]);
for j:=2 to 4 do lineto(p[i,j,1],p[i,j,2]);
lineto (p [i, 1, 1] ,p [i, 1,2]);
moveto(p[i,5,1] ,p[i,5,2]);
for j:=6 to a do lineto(p[i,j,1],p[i,j,2]);
lineto(p[i,5,1] ,p[i,5,2]);
moveto (p [i, 1, 1] ,p [i, 1, 2]); lineto (p [i, 5, 1] ,p [i, 5,
2]); moveto(p[i,2,1] ,p[i,2,2]) ;lineto(p[i,6,1]
,p[i,6,2]); move to (p [ i, 3, 1] , p [ i, 3, 2] ) ; line to (p [ i,
7, 1] , p [ i, 7, 2] ) ;
move to (p [ i, 4, 1] , p [ i, 4, 2] ) ; line to (p [ i, a, 1] , p [i, 8, 2] ) ;
end;
begin initg;
coord(50,50,50);
for j:=1 to 10 do
for i:=1 to 24 do
begin
desen(i);
delay(100);
desen(i)
end;
desen(24);
closegraph
end.
10.14.2. Reprezentarea unei suprafele in spatiu
Se considera
expresie de forma z=f(x,y), unde perechea (x,y) apartine lui
[a,b] * [c,d]. Funqia f este o functie de doua variabile.
Exemp/u: z=x+y-3 (x, y) apartine [0, 5]*[8, 10]. Pentru fiecare pereche (x,
y), unde x apartine intervalului [0, 5] !?i y apartine intervalului [8,10] se poate
obtine o valoare pentru z. Astfel, x = 2, y = 9 rezulta z = 2 + 9-3 = 8.
Obtinem
astfel un triplet (2, 9, 8), care reprezinta coordonatele unui punct in spatiu.
Avem o infinitate de triplete (care verifica aceasta expresie), deci avem o
infinitate de puncte date prin coordonatele lor. Tn cadrul cursurilor de
matematica (din facultate) se arata ca aceste puncte se gasesc plasate pe o
suprafata din spatiu (in cazul expresiei considerate, suprafata este un plan).
Problema care se pune in continuare este urmiHoarea: se da o astfel de functie
!?i se cere sa se reprezinte pe monitor suprafata pe care o reprezinta. Pentru
asigurarea generalitatii programului, procedam 'fntocmai ca Ia desenmea
graficelor de functii.
Un program numit GRAFIC S lanseaza In executie un altul numit CITSUPR
care are rolul de a crea !?i compila o unitate de program numita FSTAND care
contine o functie data de utilizator, dupa care compileaza !?i lanseaza 'fn
executie programul care deseneaza suprafata considerata. Rulati cele trei

programe de mai jos i va veti convinge.
program grafic s;
uses dos;
-
{$m 4000,0,0}
begin swapvectors;
exec('citsupr.exe','');
swapvectors;
exec(c:\tp\tpc.exe,supra);
swapvectors;
exec(supraf.exe','');
swapvectors;
end.
program citsupr;
{$m 4000,0,0}
uses dos;
var f:text;
exp:string;
tpc,numep:string;.begin
assign(f,fstand.pas);
repeat
writeln;
rewrite();
writeln(f,'unit stand;');
writeln(f,'interface);
writeln (,function f(x,y:real):real;');
writeln(f,'implementation);
writeln (,'function f(x,y:real):real;');
writeln(f,begin');
write(':='); readln(exp);
write(,:=); writeln(f,exp);
writeln(f,'end;);
writeln(f,end.');
close();
tpc:=fsearch (1 tpc.exe,getenv( 1 path 1 ));
numep:=fstand.pas;
swapvectors;
exec(tpc,numep);
swapvectors
until dosexitcode=O
end.
program supra;
var nrx,nry,alfa,beta,gama,i,j:integer;
a,b,c,d,x,y,minx,miny,maxy,maxx,rl,r2:real;
var xe,ye:array[l..50,1..SO] of real;
begin
write(numar valori x =');
readln(nrx);
write('numar valori y=');
readln(nry);
write('a='); readln(a);
write('b='); readln(b);
write(c=); readln(c);
write(d='); readln(d);
write('alfa='); readln(alfa);
write(beta='); readln(beta);
write('gama=); readln(gama);
x:=a;
for i:=1 to nrx do
begin
y:=c;
for j:=1 to nry do
begin
d3d2g(rad(alfa)1 rad(beta)1 rad(gama),xlylf(x
y),xe[ilj]l ye [i, j]) ;
y:=y+(d-c)/(nry-1)
end ;
x:=x+(b-a)/(nry-1)
end;
minx:=xe(1 1];
maxx:=xe[11
1]; miny:=ye[1
1];
maxy:=ye[111];
for i:=1 to nrx do
for j:=1 to nry do
begin
if xe[ilj]<minx then minx:=xe[i1 j];
if xe[i j]>maxx then maxx:=xe[i1 j];
if ye[ilj]<miny then miny:=ye[i1 j];
if ye(i 1 j] >maxy then maxy:=ye[ilj];
end;
initg;
r1:=(maxx-minx)/ getmaxx;
r2:=(maxy-miny)/getmaxy;
for i:=1 to nrx do
for j:=1 to nry do
begin
xe[i I j]:=(xe[i I j]-minx)I r1;
ye[i I j]: =getmaxy-(ye[i1 j]miny)/r2;
end;
for i:=1 to nrx do
begin
moveto(round(xe[i 1]) round(ye[i 1]));
for j:=2 to nry do lineto(round(xe[i j]) round(ye[ilj]))
end;
for j:=1 to nry do

begin
moveto(round(xe[1 jJ) round(ye[11j]));
for i:=2 to nrx do lineto(round(xe[i jJ) round(ye[i jJ))
end;
readln;
closegraph;
end.
in continuare, aratam modul in care am procedat pentru a desena suprafata

asociata funqiei. Consideram sistemul de axe din spatiul cu 3 dimensiuni, in
care este desenata o suprafata. Se alege o retea de puncte, situate pe
suprafata considerata, care vor fi reprezentate pe monitor, unite intre ele prin
segmente. Pentru alegerea retelei, s imparte intervalul [a,b] in nrx parti egale
!?i intervalul [c,d] in nry paqi egale. Consideram dreptunghiul [a,b]*[c,d] si uat
in planul XOY. Prin fiecare punct obtinut in urma impartirii intervalului [a,b] se
duce o paralela Ia axa OY !?i prin fiecare punct al intervalului [c,d] se duce o
paralela Ia axa OX. La intersectia celor doua paralele se gase!?te un punct
caracterizat de un anumit x, un anumit y. Pentru aceasta pereche x,y se
calculeaza z ca fiind f(x,y). in acest mod am obtinut punctele care vor fi
reprezentate. Toate punctele din retea cu acela!?i x se unesc prin segmente,
toate punctele din retea cu acela!?i y se unesc prin segmente. Acestea se
reprezinta pe monitor, obtinandu-se astfel imaginea retelei. Urmariti cele
prezentate in Figura 10. 12.
X
I I
J_LJ....J_
Figura 10.12.
A ramas de rezolvat o singura problema, aceea de Tncadrare pe ecran a

coordonatelor punctelor ce vor fi reprezentate. Din cate !?tim, pentru a putea
reprezenta pe ecran un punct, avem nevoie numai de doua coordonate l?i nu
de trei. Pentru a se putea realiza aceasta conversie, programul cere cele trei
unghiuri intre axe, alfa, beta, gama (unghiuri a caror semnificatie a fost
prezentata). Procedura D3D2G transforma cele trei coordonate ale fiecarui
punct in doua coordonate. Coordonata x a fiecarui punct este retinuta in
matricea xe, iar coordonata y a fiecarui punct este retinuta in matricea ye.
Fiecare coordonata este retinuta intr-o matrice deoarece avem nrx*nrv puncte,
deci xe[i,j] reprezinta coordonata x a punctului (i, j) cu i de Ia 1 Ia nrx !?i j de Ia
1 Ia nry. Problema se pune in mod similar pentru matricea ye. Acum, fiecare
punct de pe suprafata este reprezentat prin doua coordonate, dar cum le
reprezentam pe acestea pe ecran? Pentru fiecare element al matricei xe se
calculeaza minimul !?i maximul, pe care le numim minx !?i miny. Calculam doua
valori r1 = (maxx-minx)/getmaxx !?i r2 = (maxy-miny)/getmaxy;
Fiecarui elemental matricei xe i se atribuie valoarea xe[i,j]: = (xe[i,j]-minx)/r1 !?i
fiecarui element al matricei ye
i se atribuie valoarea ye[i,j]: =
getmaxy
-(ye[i,j]-miny)/r2.
Care este motivul pentru care am facut aceste atribuiri?
Sa presupunem un punct care are coordonata x minima. Rezulta de aici ca
xe[i,j] va fi 0 (a!?a cum trebuie spre a fi reprezentat pe ecran). Daca un punct
va avea coordonata x maxima, atunci vom avea: xe[i,j]: = (maxxminx)*
*9etmaxx/(maxx-minx) = getmaxx.
.
in mod similar avem !?i pentru y. Daca un punct are coordonata y minima
vom avea ye[i,j] = getmaxy (se reprezinta In partea de sus a ecranului), iar
daca y este maxim vom avea ye[i,j] = 0. Un punct oarecare se reprezinta
undeva pe ecran, proportional cu valorile lui. Daca avem coordonatele ecran,
suprafata se poate reprezenta fara probleme.
Cateva exemple de suprafete se gasesc in PLAN$ELE 6, 7 !?i 8.
10. 14.3. Coordonatele sferice !?i aplicatiile lor

Se considera sistemul de axe din spatiul cu trei dimensiuni. Fie M (x,y,z). Se
pune problema de a exprima coordonatele punctului M in functie de alti trei
parametri !?i anume:
distanta de Ia origine Ia punctul M, notata R;
unghiul format de proiectia dreptei OM cu axa OX, notat t;
unghiul format de dreapta OM' cu OM, notat s;
in aceste conditii obtinem:
OM'= OMcos(s) = Rcos(s); x= OM'cos(t) = Rcos(s)cos(t);
y= OM'cos(90-t) = OM'sin(t) = Rcos(s) sin(t); z= OMsin(s) =
Rcos(s). Deci:
x = Rcos(s) cos(t); y
= Rcos(s) sin(t);
z = Rsin(s)
Acestea sunt coordonatele sferice.
Figura 10.13.
Putem obtine coordonatele oricarui punct M din spatiu, dad! tE [0, 2")
sE [-"/2, "/2].
Fie planul GMZ. in acest plan, consideram un sistem rectangular de axe OZ

i OX 0 (coincide ca directie cu OM') i o curba oarecare. Dupa cum am vazut,
o curba poate fi exprimata i parametric, deci consideram exprimarea sa
parametrica, i anume: xO = x 0 (u) i z = z 0 (u). Procedand Ia fel ca in
calculul
coordonatelor sferice, scriem coordonatele unui punct T de pe aceasta curba,
in sistemul OXYZ. Ca atare vom avea:
X=Xo(U)*COS(t); y=yo(U)*Sin(t); z=z 0 (u).
Daca rotim planul OMZ in jurul axei OZ, curba considerata in planul OMZ va
descrie o suprafata de rotatie. Rotatia planului in jurul axei OZ se face prin
modificarea unghiului t.
in general, o suprafata poate fi descrisa parametric sub forma:
x = f(s,t);
y = g(s,t);
z = h(s,t).
in cele ce urmeaza, suntem interesati sa vizualizam o suprafata de rotatie.

Pentru a putea asigura generalitatea, vom folosi procedeul, de acum bine
cunoscut, de a citi de Ia tastatura functiile f, g i h. Tinand cont de faptul ca
rotatia planului se va face automat prin modificarea unghiului t, nu are sens sa
citim decat exprimarea parametrica a curbei In planul OMZ, scrierea completa
a formulelor urmand sa se faca in programul citsuprp (care creeaza unitatea
de program FSTAND). Cum realizam acest lucru se poate observa cu u urinta,
analizand programul sursa. Modul de desenare a suprafetei de rotatie este
acelai cu eel folosit In paragraful anterior pentru a desena o suprafata data
neparametric.
zt
',,, M
.,
I
I
I
I
I
T (.x0(u), yJu))
Figura 10.14.
program grafic sr;
uses dos;
{$m 4000 1 01 0}
begin
swapvectors;
exec( citsuprp.exe','');
swapvectors;
exec(c:\tp\tpc.exe,suprafp');
swapvectors;
exec(suprafp.exe,'');
swapvectors;
end.
program citsupr;
{$m 4000,0,0}
uses dos;
var f:text;
exp:string;
tpc,numep:string;
begin
assign(,'fstand.pas);
repeat
writeln;
rewrite();
writeln(f,'unit stand;');
writeln(f,'interface);
writeln (,unction f(x,y:real):real;');
writeln(f,implementation);
writeln (,'function f(x,y:real):real;);
writeln(f,'begin');
write(':='); readln(exp);
write(,:=); writeln(f,exp);
writeln(f,end;);
writeln(f,'end.');
close(f);
tpc:=fsearch ('tpc.exe,getenv('path'));
numep:='fstand.pas;
swapvectors;
exec(tpc,numep);
swapvectors
until dosexitcode=O
end.
program suprafp;
var nrs,nrt,i,j:integer;
a,b,c,d,s,t,mins,mint,maxs,maxt,r1,r2,
alfa,beta,gama:real;
var xe,ye:array[1..50,1.. so] of real;
begin
write(numar valori s ='); readln(nrs);
write('numar valori t='); readln(nrt);
write ('a=); readln(a);
a:=rad(trunc(a));
b:=rad(trunc(b)); c:=O; d:=2*pi;
alfa:=rad(210); beta:=rad(-30);gama:=rad(90);
s: =a;
for i:=1 to nrs do
begin
t:=c;
for j:=1 to nrt do
begin
d3d2g(alfa,beta,gama,f(s,t),g(s,t),h(s,t),xe[i,j],
ye [i, j] ) ;
t:=t+(d-c)/(nrt-1)
end ;
s:=s+(b-a)/(nrs-1)
end;
mins:=xe[1,1]; maxs:=xe[1,1];
mint:=ye[1,1]; maxt:=ye[1,1];
for i:=l to nrs do
for j:=1 to nrt do
begin
if xe[i,j]<mins then mins:=xe[i,j];
if xe[i,j]>maxs then maxs:=xe[i,j];
if ye[i 1 j]<mint then mint:=ye[i 1 j];

if ye[i jl>maxt then maxt:=ye[i j];
end;
initg;
rl:=(maxs-mins)/ getmaxx;
r2:=(maxt-mint)/getmaxy;
for i:=l to nrs do
for j:=l to nrt do
begin
xe[i 1 j]: =(xe[i 1 j]-mins)/r1;
ye[i 1 j]: =getmaxy-(ye[i1 j]mint)/r2;
end;
for i:=l to nrs do
begin
moveto(round(xe[i 1 l]) round(ye[i 1 l]));
for j:=2 to nrt do lineto(round(xe[i 1j]) round(ye[i j]))
end;
for j:=l to nrt do
begin
moveto(round(xe[l 1 j])1 round(ye[l 1 j]));
for i:=2 to nrs do lineto(round(xe[i 1 j]) 1 round(ye[i 1 j]))
end;
readln;
closegraph;
end.
in PLAN$ELE
9, 10 !?i 11 puteti observa cateva rezultate.
10. 14.4. Prezentarea integrala a unitatii UTILG

unit utilg;
interface
uses graph;
var gdriver 1 gmode:integer;
procedure initg;
function rad(x:integer):real;
procedure rotplan(xc 1yc xl 1yl:integer; var x y:integer;
unghi:real);
procedure d3d2(xl,yl,zl:integer; var x,y:integer);
procedure d3d2n(xllyl,zl:integer; var x,y:integer);
procedure citimg(x 1y:integer;fdim,fimg:string);
procedure scrimg(xl,yl,x2,y2:integer; fdim,fimg:string;
var cod:byte);
procedure d3d2g(alfa,beta,gama:real; xl,yl,zl:real;
var x,y:real);
implementation
procedure initg;
begin
gdriver:=detect;
if graphresult<>O then
begin
writeln('tentativa esuata);
halt
end
end;
function rad;
begin
rad:=pix/180
end;
procedure d3d2;
begin
x:=getmaxx div 2 +round(xl+sqrt(2)z1/4);
y:=getmaxy div 2 -round(y1+sqrt(2)z1/4)
end;
procedure d3d2n;
begin
x:=round(x1+sqrt(2)z1/4);
y:=round(y1+sqrt(2)z1/4)
end;
procedure rotplan(xc,yc,x1,y1:integer; var x,y:integer;
unghi:real);
begin
x:=round(xc+(xi-xc)cos(unghi)-(y1-yc)*sin(unghi));
y:=round(yc+(x1-xc)sin(unghi)+(y1-yc)cos(unghi))
end;
procedure citimg;
var f1:text;
f2:file;
dim: integer;
a:pointer;
begin
assign(f1,fdim);
assign(f2,fimg);
reset(1);
read(f1,dim);
reset(2,dim);
getmem(a,dim);
blockread(f2,aA,1);
putimage(x,y,aA,xorput);
close(1);
close(2);
end;
procedure scrimg;
var a:pointer;
dim:integer;
fl:text;
f2:file;
begin assign(fl,fdim);
assign(f2,fimg);
dim:=imagesize(xl,yl,x2,y2);
if dim<> o then
begin
getmem(a,dim);
getimage(xl,yl,x2,y2,aA);
rewrite(fl);
rewrite(f2,dim);
write (fl, dim);
blockwrite(f2,aA,l);
close(fl);
close(2);
cod:=O
end
else cod:=l
end;
procedure d3d2g;
begin
x:=xlcos(alfa)+ylcos(beta)+zlcos(gama);
y:=xlsin(alfa)+ylsin(beta)+zlsin(gama);
end;
10. 15. Probleme propuse

1. Desenati 16 benzi colorate cu nuante diferite de ro u.
2. Fie secventa: setbkcolor(white); setcolor(black); moveto(O,O);
lineto(50,0).
Care vor fi culorile de fond !?i de culoare pentru segmentul considerat?
3. Trasati toate tipurile de linii cunoscute.
4. Scrieti un program care sa execute un desen Ia alegerea dumneavoastra.
5. Scrieti o procedura carP. deplaseaza un punct curent in 8 directii. Denla
sarea f?Unctului intr-o directie anume se va face prin apasarea unei taste presta
bilite. In cazul apasarii continue a tastei, punctul va avea o deplasare continua.
Procedura va primi ca parametru de intrare o variabila booleana care va indica
daca punctul lasa urma sau nu. Atentie Ia ie!?irea din ecran!
6. Utilizand eventual procedura de Ia punctul 5, realizati un program care ne
permite sa desenam prin apasarea tastelor ( tergerea unei figuri se va face
prin a plimba punctul, care nu lasa urma, asupra ei). Programul va fi inzestrat
!?i cu optiuni de stabilire a culorilor de fond !?i de desen.
7. Prin executia programului de Ia problema 6 realizati un desen ,artistic".

8. Salvati intr-un fi!?ier imaginea creata
salvarea, prin readucerea imaginii pe ecran.
de dumneavoastra. Verificati
9. Se considera un fi!?ier de personal in care fiecare inregistrare contine
numele unei persoane !?i varsta sa. ealizati o situatie statistica privind
repartizarea persoanelor pe grupe de varsta (0-20, 21-30, 31-40 !?.a.m.d.).
Situatia se va realiza in doua feluri:
prin utilizarea procedurii BAR3D;
prin utilizarea procedurii PIESLICE.
10. Realizati un meniu prin utilizarea unei ferestre grafice. Selectarea optiunii
se va face prin plimbarea unei bare luminoase deasupra optiunilor.
11. Aceea!?i problema ca Ia problema 10, dar selectarea optiunii se va face
prin pla,sarea unui cadru dreptunghiular deasupra optiunii, urmata de apasarea
tastei ENTER.
12. Realizati un program in care o bila se mi!?ca aleator pe ecran. Programul
va fi conceput de trei ori, utilizand cele trei variante de animatie.
13. Realizati un program in care un omulet stilizat i!?i mi!?Ca picioarele !?i mai
nile.
14. Afi!?ati Tn mod grafic numele persoanelor continute in fi!?ierul PERSONAL
(vezi problemele de Ia fi!?iere).
15. Dintr-un pachet de carti de joe se extrag aleator 4, care vor fi afi!?ate pe
ecran.
16. SimulaJi un jocde carti in care un participant Ia joe este calculatorul.
17. Exprimati grafic notiunea de arc capabil de un unghi dat.
18. Rezolvati grafic problema mi!?carii Tn plan a unui punct, astfel Tncat suma
piHratelor distantelor Ia doua puncte fixe este o constanta.
19. Considerati, Ia alegere, o problema de loc geometric din manual.
lntocmiti un material didactic pentru orele de matematica, in care sa se vada
efectiv mi!?carea pe ecran.
20. Realizati prin programe proprii graficul functiei de gradul doi. Se va

considera restriqia [a, b] a domeniului de definitie.
21. Rotiti un segment in jurul unuia din capetele sale, cu un unghi alfa (Ia
realizarea desenului tineti cont de raportul aspect).
22.Rotiti un triunghi echilateral in jurul ortocentrului sau. Efectuati mai mul!e
rotatii cu un unghi convenabil ales, pana cand se ajunge Ia figura initialiL In
cazul in care figura rotita nu este !?tearsa, cum arata figura astfel creata?
23. Reprezentati Tn spaJiu o piramida patrulatera regulata.
24. Rotiti piramida de Ia punctul anterior in jurullnaltimii.
25. RotiJi, pe rand, un cub in jurul celor trei axe.
26. Desenati un con !?i un trunchi de con.
27. ReprezentaJi o seqiune plana (nu neaparat paralela cu baza) lntr-o pira
mida.
28. RotiJi desenul din problema anterioara In jurullnaltimii.
ANEXA
Utilizarea meniurilor in limbajul

TURBO PASCAL
Limbajul TURBO PASCAL este inzestrat cu un sistem de meniuri care permite
lucrul cu textele sursa, depanarea programelor, informari asupra diverselor
instructiuni !?i proceduri pe care le contine mediul integrat (editor de texte,
compilator, depanator, sistem de meniuri etc.). Exista mai multe forme de a
prezenta toate acestea. in ce ne prive!?te, vom prefera prezentarea acestuia in
funqie de operatiile cele mai frecvente care se efectueaza cu ajutorul
meniurilor.
Fereastra de lucru
Orice text sursa PASCAL se scrie intr-o fereastra. De cele mai multe ori se
lucreaza cu una singura !?i acesta este cazul pe care-1 vom discuta in
continuare. De regula (daca nu au fost precizate alte optiuni) Ia apelul
editorului !?i compilatorului TURBO PASCAL se deschide o fereastra care are un
nume pus de editor !?i anume NONAMExx.pas (xx reprezinta un numar de
ordine). Exista !?i posibilitatea de a deschide direct o fereastra cu un anumit
nume (apelul se face cu TURBO nume).
in aceasta fereastra se scrie textul sursa. Pentru inceput retinem faptul ca
Ia comanda CTRL + F9 textul este compilat !?i rulat. Pentru a vedea rezultatele
rularii se tasteaza ALT + F5 iar pentru a reveni Ia textul sursa se tasteaza
ENTER sau ALT + F5.
in partea de sus a ferestrei apare meniul cu care este inzestrat mediul
integrat al limbajului. Astfel apar optiunile urmatoare:
FILE EDIT SEARCH RUN COMPILE DEBUG OPTIONS WINDOW HELP
Avem doua posibilitati de a selecta o optiune:

se tasteaza F10, apoi ne deplasam cu ajutorul sagetilor pe una din optiunile
dorite;
se tasteaza ALT +litera de inceput a optiunii (de exemplu, pentru optiunea
FILE tastam ALT +F);
in ambele cazuri, dupa pozitionarea pe o anumita optiune se tasteaza ENTER
iar pentru revenire se tasteaza ESC.
Cum lucram eficient utilizand sistemul de meniuri ?
intrucat in timpullucrului pot aparea o serie de surprize neplacute (blocarea
calculatorului,intreruperea curentului, etc.) este bine sa salvam textulla fiecare

cateva randuri scrise. Cum procedam pentru aceasta?
1. Se apeleaza meniul FILE i se selecteaza optiunea SAVE (dupa care se
tasteaza ENTER).
2. Se tasteaza direct F2 (aceasta este una din tastele ,fierbinti", in sehsul ca
este foarte folosita).
In cazul In care fereastra are un nume implicit, se deschide automat o
fereastra In care suntem lntrebati sub ce nume sa se faca salvarea. indata ce
tastam un nume se face salvarea iar fereastra in care lucram capata numele
sub care a fost salvata.
Dar sa analizam l?i alte optiuni pe care le avem Ia dispozitie in cadrul meniului
FILE.
Meniul FILE
OPEN
NEW
SAVE
SAVE AS...
SAVE ALL
CHANGE DIR
PRINT
GET INFO
DOS SHELL
EXIT
F3
F2
ALT+X
Optiunea OPEN permite deschiderea unei alte ferestre. Dacii am selectat

aceasta optiune, se deschide o fereastra in care suntem intrebati care este
numele ferestrei care sa se deschida. Dupa ce am dat numele, se deschide
acea fereastra, in care se incarca un text sursa (daca pe suport se gase te un
fi ier sursa cu acel nume i extensia PAS) sau, In caz contrar, se deschide
fereastra cu numele soli itat, In fereastra nefiind afi at nici un text.
Deschiderea unei ferestre se poate face i prin apasarea tastei ,fierbinti" F3.
Daca se dore te deschiderea unei ferestre fara nici un text, cu numele implicit
NONAME, aceasta se poate face prin utilizarea optiunii NEW.
in mod normal, salvarea textului sursa se face In catalogul curent (de unde
s-a tacut apelul TURBO). Daca se dore te salvarea textului In alt catalog
(subcatalog) se apeleaza optiunea SAVE AS. La apelul acestei optiUfli se
deschide o fereastra de dialog In care se precizeaza i calea pe care se va gasi
fi ierul salvat. Tot aceasta optiune se face i In situatia In care se dore te
salvare In paralel cu schimbarea numelui.
Optiunea SAVE ALL permite salvarea continutului tuturor ferestrelor cu care
se lucreaza Ia un moment dat. Lucrul cu mai multe ferestre va fi studiat intr-un
alt paragraf, motiv pentru care ne oprim aici cu explicatiile.
Optiunea CHANGE DIR permite deplasarea lntr-un subcatalog al catalogului
curent. La apelul aceste1 optiuni apare o fereastra in care se vizualizeaza

subcataloagele. Dad! se tasteaza TAB ne putem depiasa in aceasta
arborescenta.
Optiunea PRINT permite tiparirea textului sursa Ia imprimanta (Ia apelul
acestei optiuni imprimanta trebuie sa fie deschisa, altfel apare un mesaj de
eroare care se anuleaza prin apasarea tastei ENTER).
Optiunea DOS SHELL permite ie!?irea rapida .in sistemul DOS. Aici se pot
executa diverse comenzi DOS, dupa care se revine prin tastarea cuvantului
EXIT. Continutul ferestrei (ferestrelor) in care am lucrat ramane nemodificat.
Daca se dore!?te ie!?irea definitiva din mediul integrat TURBO PASCAL se
tasteaza ALT +X sau se apeleaza optiunea EXIT a meniului FILE.
Facilitati de editare
Meniul SEARCH
Acesta are urmatoarele optiuni care U!?ureaza procesul de editare:
FIND
REPLACE
SEARCH AGAIN
GO TO LINE NUMBER
FIND PROCEDURE
FIND ERROR
Optiunea FIND
Are rolul de a cauta un !?ir in textul programului sursa. in mod practic, se
afi!?eaza o fereastra in care suntem solicitati sa introducem textul care se va
cauta.
De asemenea, in fereastra se prezinta alte cateva optiuni (se ajunge Ia ele
prin apasarea tastei TAB !?i se marcheaza cu spatiu):
CASE SENZITIVE - daca este marcata (cu X) se face distinctie intre !iterele
mari i cele mici;
WHOLE WORDS ONLY- considera textul ca un cuvant separat (prin blanc uri
sau alti separatori);
REGULAR EXPRESION - textul poate contine !?i caractere de control;
DIRECTION- stabile!?te directia in care se face cautarea:
o FORWARD- spre sfar!?it;
o BACKWARD- spre lnceput;
ORIGIN - stabile!?te locul de unde incepe cautarea:
o FROM CURSOR - lncepand de Ia cursor;
o ENTIRE SCOPE - intregul domeniu.
OK - s-au terminat optiunile, se inchide fereastra !?i se fac inlocuirile;
CANCEL - se renunta Ia cautare;
HELP - se dau informatii despre cautare.

Optiunea REPLACE
inlocuieste un sir cu altul. in acest sens, se deschide o fereastra care permite
sa se scrie !?irulcare se inlocuie!?te !?i !?irul care se va inlocui. in aceasta
fereastra se gasesc optiunile care au fost prezentate anterior !?i altele care
urmeaza:
PROMPT ON REPLACE- Ia fiecare inlocuire se deschide o fereastra in
care utilizatorul este intrebat daca sa se faca sau nu inlocuirea;
OK - se face o singura inlocuire;
CHANGE ALL - se inlocuiesc toate aparitiile sub!?irului cautat.
Optiunea SEARCH AGAIN - permite reluarea ultimei cautari sau inlocuiri.
Optiunea GO TO LINE NUMBER- permite deplasarea cursorului pe o anumita
linie (iinia !?i coloana in care se gase!?te cursorul sunt afi!?.ate In permanenla).
Optiunea FIND PROCEDURE- se deschide o fereastra in care se introduce
numele unui subprogram (procedura sau functie). Se cauta acel subprogram (se
cauta declaratia lui, !?i nu apelul).
Optiunea FIND ERROR permite aflarea adresei din memorie unde s-a produs
o eroare.
Un rol special in operatiunea de editare il are o fereastra numita
CLIPBOARD. Daca nus-a dat o optiune speciala, aceasta nu este vizibila, dar
are un rol mare
!?i anume, in ea se pot depozita blocuri (portiuni de text marcate intr-un mod
anume). La cerere, textele pot fi aduse In cadrul unei ferestre de lucru.
Dar ce este un bloc? Un bloc este o portiune din textul sursa care este
marcata (in textul sursa un bloc este vizibil intr-o culoare speciala). Pentru a
marca un bloc, procedam in felul urmator:
se deplaseaza cursorul pe prima linie care se dore!?te a fi marcata;
se apasa tasta SHIFT (in mod continuu);
parcurgem liniile din textul sursa care vor fi marcate cu ajutorul sagetilor
(sus sau jos).
Ce putem face cu un bloc, putem vedea analizand meniul EDIT. Acesta are
urmatoarele optiuni:
RESTORE LINE
CUT
COPY
PASTE
SHOW CLIPBOARD
CLEAR
SHIFT-DEL
CTRL-INS
SHIFT-INS
CTRL-DEL
Optiunea CUT - permite mutarea blocului In fereastra CLIPBOARD. Mutarea

1
se face prin !?tergerea blocului din textul sursa.
Optiunea COPY- se muta bloculln CLIPBOARD, fara a fi !?ters din fereastra
In care lucram.
Optiunea PASTE - reia blocul din CLIPBOARD !?i il scrie in fereastra activa,
incepand din pozitia curenUi a cursorului.
Din cele prezentate se poate trage lesne concluzia ca, in acest fel, putem
muta blocuri dintr-un text in altul sau in cadrul aceluia!?i text.
Optiunea SHOW CLIPBOARD - se vizualizeaza
CLIPBOARD.
Optiunea CLEAR - se !?terge din text blocul selectat.
continutul
ferestrei
Observatie: La vizualizarea ferestrei CLIPBOARD se observa ca este marcat

ca bloc numai ultimul text salvat. Cu toate acestea, celelalte texte se
pastreaza. Din acest motiv, daca acestea prezinta interes, se pot marca direct
in CLIPBOARD, dupa regulile cunoscute.
Optiunea RESTORE LINE - permite refacerea ultimei linii modificate (numai
daca nu am deplasat cursorul din acea linie).
Lucrul cu mai multe ferestre

De multe ori este util sa lucram simultan cu mai multe ferestre. De exemplu,
sa presupunem un program care lucreaza cu doua unitati de program.
Deschidem o fereastra pentru program !?i cate o fereastra pentru cele doua
unitati. Deschiderea unei noi ferestre se face tot cu F3. De Ia bun inceput
trebuie precizat faptul ca, dintre toate ferestrele deschise Ia un moment dat,
numai una este activa !?i i1. ea se gase!?te cursorul (toate comenzile prezentate
pana acum se refera Ia fereastra activa).
in lucrul cu mai multe ferestre este util meniul WINDOW. Optiunile acestuia
se impart in doua categorii:
optiuni privitoare Ia lucrul cu ferestre;
optiuni pentru depanare.
Aici, vom prezenta numai prima categorie de optiuni:
SIZE/MOVE
ZOOM
TILE
CASCADE
NEXT
PREVIOUS
CLOSE
CTRL-F5
F5
F6
SHIFT-F6
ALT-F3
Optiunea SIZE/MOVE - Permite modificarea dimensiunilor ferestrei active.

Daca am selectat aceasta optiune, fereastra curenta i!?i schimba culoarea. Din
acest momentli putem schimba dimensiunile. Aceasta se realizeaza cu ajutorul
sagetilor !?i tastei SHIFT. in mod practic, prin apasarea tastei SHIFT !?i a sagetii
In sus se reduce dimensiunea verticala a ferestrei. Tot a!?a, prin apasarea tastei
SHIFT !?i a sagetii stanga se reduce dimensiunea orizontala. Daca se apasa
numai sagetile, fereastra se deplaseaza pe ecran In sensul indicat de sageti.
Atunci cand am terminat aranjarea unei ferestre se tasteaza ENTER iar fereastra
revine Ia culorile normale. in continuare se poate Iuera In ea in mod obi nuit.
Optiunea ZOOM - are rolul de a maximiza fereastra activa. Daca exista
deschise mai multe ferestre acestea devin invizibile.
Optiunea TILE - are rolul de a afia in prim plan toate ferestiele deschise.
Toate ferestrele au dimensiuni egale.
Optiunea CASCADE - are rolul de a dispune ferestrele una peste alta (in
stiva) iar fereastra activa este in prim plan.
Optiunea NEXT- are rolul de a activa fereastra urmatoare celei curente.
Optiunea PREVIOUS - activeaza fereastra ce a fost activa anterior celei
curente.
Optiunea CLOSE- Ia activarea acestei optiuni se inchide fereastra curenta.
Daca in cadrul textului s-au facut modificari, utilizatorul este intrebat daca se
salveaza sau nu continutul.
Autodocumentarea
Se poate lntampla sa nu !?tim cum functioneaza o anumita procedura, functie
sau sa avem alte nelamuriri. Prin activarea meniului HELP sistemul integrat
TURBO PASCAL ne ofera posibilitatea sa ne autodocumentam (fara a ne mai
uita lntr-o carte sau sa intrebam pe altcineva).
in cadrul acestui meniu exista urmatoarele optiuni:
CONTENTS INDEX
TOPIC SEARCH
PREVIOUS TOPIC
HELP ON HELP
SHIFT-F1
CTRL-F1
ALT-F1
Optiunea CONTENTS-Ia selectia acestei optiuni se deschide o fereastra care

contine lista capitolelor sistemului HELP.
Optiunea INDEX -Ia selectarea ei se afi!?eaza o fereastra care contine numele
diverselor instructiuni, proceduri, directive de compilare etc. despre care ne
putem informa. Daca dorim informatii despre un cuvant anume (de exemplu
numele unei proceduri) se apasa pe tasta SHIFT In mod continuu $i se tasteaza
cuvantul respectiv. Dupa tastare, apare in fereastra explicatia solicitata, un
exemplu !?i, eventual, numele altor proceduri care au funqii inrudite cu
procedura In cauza. Exemplele le putem copia in CLIPBOARD. Pentru aceasta,
se apeleaza meniul EDIT cu optiunea COPY EXAMPLE. Mai departe !?tim ce
avem de facut, lntrucat am vazut cum se poate introduce un bloc din
CLIPBOARD in fereastra curenta. Aici, putem rula acest exemplu.
Optiunea TOPIC SEARCH- afi eaza aceeai fereastra ca optiunea anterioara.
Deosebirea consta 'fn faptul ca, in cazul 'fn care cursorul se afla pozitionat pe
un cuvant cheie, cautarea acestuia se face automat.
Optiunea HELP ON HELP - se ofera informatii despre cum putem utiliza
meniul HELP.
Depanarea programelor
De multe ori, de:;;i credem ca avem un program corect, acesta nu furnizeaza
rezultatele cerute sau se intrerupe ca urmare a unei erori de programare.
Trebuie sa aflam unde am gre!?it. Mecanismele puse Ia dispozitie ne ajuta mult
in acest caz (problema este cu atat mai importanta cu cat programul este mai
mare).
Pentru a depana un program, avem urmatoarele posibilitati:
rularea pas cu pas;
vizualizarea unor variabile;
crearea punctelor de intrerupere.
Rularea pas cu pas

Se face prin apasarea tastelor F8 sau F7. Diferenta dintre ele este ca Ia
apasarea tastei F7 se ruleaza pas cu pas !?i procedurile sau functiile apelate de
program, chiar daca acestea apartin unor unitati de program (daca este gasita
sursa acestora). Prin apasarea tastei F8 se ruleaza pas cu pas doar programul
principal. De remarcat este faptul ca putem alterna utilizarea acestor taste in
functie de faptul daca sl;!ntem sau nu interesati sa rulam pas cu pas o anumita
procedura sau functie. In ce consta de fapt aceasta rulare pas cu pas? Sa
presupunem ca am lansat programul cu ajutorul tastei F8. Apare o bara
deasupra cuvantului BEGIN. Se apasa din nou F8. Bara se muta deasupra
instructiunilor care se gasesc pe linia de dupa BEGIN. La o citire sau scriere,
dispare textul sursa cu bara, apare partea de ecran unde programul_l!?i afi!?eaza
rezultatele. Dupa efectuarea operatiei se revine asupra textului. In acest fel
putem vedea care sunt instructiunile !?i, mai ales, ordinea In care sunt rulate
acestea. Este posibil ca o anumita secventa, pe care noi o consideram corecta,
sa nu fie nici macar parcursa. Atentie! in cadrul acestui tip de depanare, ur. rol
fundamental II are dispunerea instructiunilor pe o linie. Sa fim mai expliciti.
Consideram doua forme de dispunere a secventei urmatoare:
a.
b.
FOR i:=1 to n do s: =s+i;

FOR i:=l to n do
s:=s+i;
in cazul primei forme, plasarea barei pe secventa se face o singura data. in

cazul formei b, plasarea barei se face de n ori pe primul rand !?i de n ori pe al
doilea rand.
Vizualizarea continutului anumitor variabile

Pentru a vedea ce am gre!?it In program este util sa vizualizam !?i continutul
anumitor variabile (chiar daca acestea nu contin ur. rezultat final). Cum
procedam pentru a realiza aceasta?

De Ia bun inceput trebuie precizat ca se dispune de o fereastra cu un rol
special, numita WATCH. in aceasta fereastra se vizualizeaza continutul diverse
lor variabile care ne intereseazi:L Pentru a realiza aceasta, se deschide fereastra
WATCH cu ajutorul comenzii WATCH din cadrul meniului WINDOW. La tasta
rea ENTER se deschide o fereastra de dialog in care se cere numele variabilei
al carei continut urmeaza sa fie vizualizat in WATCH. Odata tastat acest nume,
se afi!?eaza continutul (daca acesta este cunoscut in acel moment), in caz
contrar se afi!?eaza un mesaj corespunzator iar continutul va fi afi!?at imediat
ce este cunoscut. De mentionat este !?i faptul ca in WATCH se poate vizualiza
continutul mai multor variabile.
Tehnica .de vizualizare a continutului anumitor variabile se poate utiliza in
paralel cu tehnica rularii pas cu pas. in acest fel, avem posibilitate?l de a vedea
valorile intermediare ale acestor variabile.
Observatie: in perioada de introducere in programare, utilizarea combinata
a celor doua tehnici este utila, chiar pentru programe corect concepute. De
fapt, de aici se poate intelege eel mai bine funqionarea unui program
(algoritmul). De multe ori, cand explica un algoritm, profesorul reproduce
tocmai aceasta rulare pas cu pas, in care evidentiaza valorile curente ale
variabilelor.
Crearea punctelor de intrerupere
De multe ori suntem siguri ca o prima secventa de program functioneaza
corect (de exemplu o secventa de introducere a datelor). Cu toate acestea,
programul functioneaza incorect. Ce avem de facut? Daca rulam pas cu pas
programul, pna Ia secventa pe care dorim sa o analizam, pierdem timpul !?i
rabdarea ne este pusa Ia grea incercare. Din acest motiv, este bine sa trecem
repede peste secventa de care suntem siguri.
Pentru a opri rularea programului acolo unde incepe secventa pe care dorim
testam, trebuie sa cream un punct de intrerupere.
Cum procedam ? Plasam cursorul pe linia din textul sursa Ia care dorim sa
se intrerupa executia programului. Lansam spre executie programul cu ajutorul
tastei F4. Daca suntem interesati, dupa aceasta putem muta din nou cursorul
pe o noua linie Ia care, cand se ajunge, dorim sa ne oprim. AceasHi tehnica o
putem utiliza combinat cu afi!?area continutului variabilelor. De asemenea,
dintr-un punct de intrerupere se poate porni rularea pas cu pas a programului
(cu tastele F7 sau F8, dupa cum se dore!?te intrarea in subprograme sau nu).
sa
De fapt, cele prezentate pna acum constituie optiuni ale meniului RUN.
Acestea sunt:
RUN
PROGRAM RESET
GO TO CURSOR
TRACE INTO
CTRL-F9
CTRL-F2
F4
F7
STEP OVER
PARAMETERS
F8
Optiunea RUN - lanseaza in executie un program.

Optiunea PROGRAM RESET
Consideram urmiHorul program:
program test;
var n:integer;
begin
write('n=');readln(n);
while 1<>2 do
end.
Acesta cicleaza (nu se termina niciodata). De multe ori, din grel?eala, facem
astfel de programe. Trebuie sa gasim o modalitate sa-l oprim. Pentru aceasta
se tasteaza CTRL + BREAK(PAUSE). Programul se intrerupe, iar pe una din
liniile
textului sursa apare o bara care indica instructiunea Ia care s-a oprit programul
nostru. Aceasta informatie ne este de mare folos, deoarece astfel putem
identifica secventa unde programul cicleaza. Daca dorim sa relansam
programul in executie (eventual cu alte date de intrare, ca sa vedem daca !?i in
acest caz programul cicleaza), constatam ca rularea programului porne!?te
din punctul
unde aceasta a fost intrerupta (I ansarea a fost facuta cu CTRL+ F9). Deci
tentativa noastra e!?ueaza. Avem insa posibilitatea de a porni rularea de Ia
inceput, daca tastam, in prealabil, optiunea PROGRAM RESET.
Crearea unui punct de intrerupere se poate face l?i cu ajutorul optiunii GO TO
CURSOR (in loc de F4).
Optiunile TRACE INTO !?i STEP OVER au fost prezentate Ia rularea
pr'ogramului pas cu pas.
Optiunea PARAMETERS permite introducerea unui !?ir care are acelasi rol ca
!?irul ce urmeaza numelui program in cazul apelului din DOS al unui program
care prime!?te anumiti parametri pe linia de intrare (vezi unitatea de program
DOS).
.
Exista !?i posibilitatea crearii mai multor puncte de intrerupere, de Ia inceput.
Pentru a realiza aceasta, se procedeaza astfel:
se pozitioneaza cursorul pe linia Ia care, cand se ajunge, se dore!?te crearea
primului punct;
se apeleaza optiunea TOGGLE BREAKPOINT, din meniul DEBUG, optiune
care are rolul de a marca primul punct de intrerupere (pe ecran apare o bara
ro!?ie);
se pozitioneaza cursorul pe urmatorul punct de intrerupere;
se tasteaza optiunea TOGGLE BREAKPOINT.
in acest fel se marcheaza toate punctele de intrerupere.
Rularea programului se face cu F4.
Exist!?i alte op\iuni care permit depanarea programelor,ins

acestea sunt suficiente.
a considerm c
Compilarea programelor
Daca se dore!?te numai compilare, fara lansare In executie, se poate tas!a F9.
Cand compilarea a decurs fara erori se afi:;;eaza un mesaj corespunzator. In caz
contrar, apare un mesaj de eroare iar cursorul se pozitioneaza acolo unde se
banuie te a fi eroarea.
Observatie: nu se poate identifica cu precizie locul In care a aparut eroarea.
Vom lntelege motivul care duce Ia aceasta,in cursul anului viitor. Este sarcina
programatorului sa identifice cu precizie cauza erorii.
in anumite cazuri, dorim sa cream un program executabil (extensia .exeL in
acest caz se procedeaza astfel:
se apeleaza meniul COMPILE;
se tasteaza D (in mod normal, un program compilat se gase:;;te in memoria
interna) care dete mina ca programul compilat sa se gaseasca pe suportul
magnetic.
Crt:
N
.-t
Q
-c
CVJ
['f)M
C
\
1
o
r
I
a
344
II)
'
c
N
r
u
I
a
v
=
4
0::
CJ
rcJ
ttl
rn
III u
.Q
()
<
(
a:
345
- 'E'
II)
ca
.c
ca
c
ca
ii:
'ii)
N
I
N
II)
II \.V
-><
:;::
><
*
(' t)
c
"iii
('t)
ca
II)
a
:
ca
> *<
'E'
-* ..!..t::
-*
"iii
"iii
-><
II
:;::
\.V
-c:
0
or-
><
I
><
Q)
'1:1'
fl)o
ca
>*<
>*<
.!!
II)
>*<
*
I (
'ii)
II
N
'E
I
t::
.._...
\.V
X
-...*
(' t)
u;
0
u
-.
*..
N*
II)
*;:
u;
0
Ln
ca
c
II)
ICft
<0
-.
..
II
ca
it
-... ...!..
0
\!)
+-'
'ii)
.*..
N*
:5
-. .
I I )
"E
--
!::.
313
314
.....
co11)
co
Q..
1
1
1
1
1
1
1
1
1
LP
(")
1
\\
1
('LP
1
(")
1
I
\\
(!).. 1
>
*> LP<D 1
+) (
1
... ( II
1
a11),...:;
0 1
c:
1
'0 ci
1
\I I
N \1)
> 1
0 1
1
0
1
I
IJ)
1
)(
1
1
1
1
1
1
1
1
315 1
-..- .
--
1
1
1
1
1
1.0
\\
(.(..).
<1.0
(..(.).
\1
en .
- !.!)
>< 0
0 .. .. 1
-c*
co
<
1
l
<
0
Q
)(
'ii)
II
N
\\
C:l
..-.
0
....
o....
w
1
1
>
....
0
....I
..-.
... .....
IJ)
)(
1
1
1
1
1
1
316
>
.::
0
iii
>
0
LC')
II)
II
><
;::
u; ..2
113
":E >
0
LC')
II)
II
II)
;::
v
II
n
0
II
ca
317
>
;::
0
ctl
>
0
1.0
c
;;
II
0
;::
0
ctl
>
or-
..c 0
1.0
0::
.,
.cac
ca
II)
u
II 0
0)
u;
;
II
.0
0)
II
ctl
318
-c
>
u; ;::
..Q
ctl
c >
u; 0
10
u*;
u; X
rr-
caVI
c
ca
5:
;::
II
u; >co
-.c
U")
VI
-*
(.)
VI
0)
(.)
"
u*;
iii 0
0
(.)
II
u;
:;:::-
0)
II
ctl
119
Bibliografie
T. Balanescu
Horia Georgescu
M. Gheorghe
I. Vaduva
,Pascal $i Turbo Pascal"
Doina Rancea
,Limbajul Turbo Pascal"
Editura Tehnica, 1 992
Editura Libris, 1 993
Constantin Apostol
loan Ro!?ca
Bogdan Ghilic
,Prelucrarea fi$ierelor fn Pascal"
V. Cristea
& colectiv
,lnitiere fn Turbo Pascal"
lon Ivan
,Structuri de date"
Editura ALL, 1994
Editura Teora, 1995
1992
lnforma.tica pentru clasele IX-XII

.
Conceput In .conformitate cu programa 9COIara

In vigoare, pentru
disciplinele Algoritmi_ si
.
.
.
'
limbaje de programare -si Aplicatii . practice
'
'
dlaborator - clasa- a IX-a, profil informatica ::
manualul este rezultatul lndelungatei expe
riente did-acti'ce a autorului.
'
Fiecare capitol este Insoit de un set de
. probleme propuse, prezentate In func ie de ,
complexitatea, lor. Elevilor li se ofera acum
posibilitatea de a acoperi dintr-o singura
sursa, atat programa tat 9i aplica ii ain afara
ei, pentru care exista un interes dovedit:
unitai de program, programare pe obiecte,
crearea meniur11or, formatarea ecranelor,
validarea datelor de intrare, reprezentari
grafice de functii 9i suprafe e, salvarea
ime3ginilor etc.
.
Retineti culorile seriilor de cartipentru elevi:
'
'
'
ISBN 973-'SO:t -21'2-.3
Le18000

Turbo Pascal Algoritmi Si Limbaje de Programare

Încărcat de

Drepturi de autor:

Formate disponibile

Turbo Pascal Algoritmi Si Limbaje de Programare

Încărcat de

Informații document

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

Turbo Pascal Algoritmi Si Limbaje de Programare

Încărcat de

Drepturi de autor:

Formate disponibile

lr!

formatica pentru clasale IX""'XU

Manual pentru clasa a IX-a

Conceput in conformitate cu programa colara

ofera acum posibilitatea de a acoperi dintr-o

obiecte, crearea meni urilor, format area

Acopera programa cursurilor de algoritmi, limbaje de programare i lucrari

Teora - Cartea prin po ta

3. Elemente de baza ale limbajului Pascal ........................... 46

3.3.3. Constanta !?ir de caractere ..................... 52

3.4.2. Tipuri ordinale definite de utilizator ................ 57

4. lnstructiunile limbajului Turbo Pascal ............................ 62

6.4. Functii (declarare !?i apel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

8. Fi!?iere Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

8. 1. 7.1. Functia EOLN . . . . . . . . . . . . . . . . . . . . . .

9. Unitatea de program DOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

10. Grafica pe calculator ..................................... 235

10.14.1. Rotatia unei figuri In spatiu . . . . . . . . . . . . . . . . . . 285

Utilizarea meniurilor In limbajul TURBO PASCAL

Notiunea de algoritm, caracteristici

Ce avem de facut? Consideram prima valoare a lui x, i anume -3.1. Obser

Notiuhea de algoritm este primara, nu se define te, intocmai ca i no iunea

1.1. Obiectele cu care lucreaza algoritmli: date, variabile,

Datele pot fi clasificate dupa tipul lor:

Exemplu: In loc de 3,25 se scrie 3.25.

Exemplu: 'un text'.

se tipare te f. Pentru algoritmul nostru, x if sunt variabile. Orice aigoritm lucreaza

Ca i variabilele, expresiile sunt Je mai multe tipuri:

1.1.3.2. Expresii reale

1.1.3.3. Expresii logice

Exemplu: a+ ' text', unde a este o variabila de tip

1.1.4.2. Opera1ii de decizie

Principiile programarii structurate

2.1. Structuri de baza. Descrierea acestora cu ajutorul

2.1.1. Operatii de intrare-iel?ire

2.1.2. Operatii de atribuire

2.1.3. Operatii de decizie

In cazul algoritmilor cu un grad mai mare de complexitate, este dificil sa

Pana acum, am aratat cum se reprezinta operatiile pe care le executa un

lnterpretarea acestei scheme este urmatoarea:

2.1.4. Reguli de detaliere a unei operatii complexe

2.1.5. Structura alternativa

vedem care este mai mare i il tiparim.

2.1.6. Structura repetitiva

Structura repetitiva conditionata anterior se mai nume9te 9i structura de tip

ini ializarea variabilei s, in care vom calcuia suma (prin initializare se

i este egaI cu n, dec( s va lua valoarea 3 + 3 = 6 iar i va lua valoarea

Tema : Refaceti algoritmul anterior utilizand aceasta structura.

2.2. Structuri de baza. Descrierea acestora cu ajutorul

Exemp/u: INTEGER a,b.

Am declarat doua variabile Tntregi a 9i b.

Am declarat trei variabile reale numite c, d 9i e.

Variabile logice (boolene)

h; Am declarat o variabila numita h, de tip boolean.

lnstructiuni de intrare-ie ire

Preia o informatie din exterior in memoria principala. Pentru simplitate

Se cite te de Ia tastatura un numar intreg in cadrul variabilei a (pe scurt

Este de forma v: =e.

in urma executiei acestei secvente a va contine numarul intreg 5.

in urma executiei acestei secvente, c va avea valoarea FALSE.