Universitatea Tehnic!

a Moldovei


Catedra Sisteme Optoelectronice






Programare


Ciclu de prelegeri








Limbajul de programare Pascal










Chi"in!u 200#


2
Adnotare








Pentru studen!ii anului I "i II , facultatea de Radioelectronic#


specializ#rile IMT "i SOE (de zi "i f#r# frecven!#)









Alc#tuitor: lector asistent Sergiu Istrati




Redactor responsabil: conf. univ. dr. Pavel Nistiriuc




Recenzent: conf. univ. dr. Veaceslav Sidorenco








U.T.M.,200$



3
Tema #: Scurt istoric al apari!iei calculatoarelor

Activit#!ile mintale efectuate de c#tre oameni necesit# uneori un volum de
munc# foarte mare "i un procent de inteligen!# mediu sau sc#zut. Multe dintre aceste
activit#!i necesit# calcule elaborate. Pe parcursul timpului matematicienii au ncercat
s# creeze ma"ini, care s# efectueze aceste calcule automat, l#snd astfel oamenilor
timpul necesar pentru a se concentra asupra problemelor esen!iale. Dar cu toate
eforturile depuse, ma"inile automate de calcul sau, cu alte cuvinte, calculatoarele, au
ap#rut doar n momentul n care tehnologia a permis acest lucru, pe la mijlocul anilor
40 ai secolului XX. ns# pn# n acel moment au fost puse bazele tehnicii de calcul
mederne.
In $64$ matematicianul "i filosoful Blaise Pascal inventeaz# o ma"in# de calcul
care putea efectua primele dou# ecua!ii aritmetice elementare cu "ase cifre zecimale.
Cu cteva decenii mai trziu, n $67$ aceast# ma"ina este perfec!ionat# de
matematicianul Wilhelm Leibnitz, asigurnd-o cu patru opera!ii aritmetice.
In $823, matematicianul "i economistul englez Charles Babbage a c%nceput
construc!ia ma"inii diferen!iale, care a fost conceput# pentru realizarea automat# a
tabelelor matematice necesare n naviga!ie. Calculatorul era capabil de a rula un
singur algoritm. Din necesitatea de a crea un calculator de uz general, n $834 el a
conceput ma"ina analitica. In $834 Babbage elaboreaza proiectul ma"inii analitice,
care con!ine unit#!ile de baz# ale unui calculator modern:
- memoria (numit# "i depozit )
- unitatea aritmetic# ( moara sau fabrica )
- unitatea de comand#
- dispozitivele de intrare ie"ire.
Aceast# ma"in# putea memora $000 numere a cte 50 cifre zecimale "i realiza
adunarea a dou# cifre ntr-o secund#, iar nmul!irea - intr-un minut.
Primul dispozitiv de calculator cu o comand#-program este realizat de savantul
german Konrad Zuse n $94$. Programul era memorat pe o band# de cinematograf "i
era citit# serial. Calculatorul era construit din 2600 releuri, putea num#ra 64 cifre a
cte 22 cifre binare.
In $946 n SUA firma "Bell Telephone" realizeaz# mai multe calculatore.
Primul calculator se numea Bell-v. El era construit din 9000 de relee "i ocupa o
suprafa!# de 90 m
2
avnd masa de $0 tone.
n $943$946 se construie"te primul calculator electronic universal , ce se
numea ENIAC (Electronic Numerical Integrator And Computer). Calculatorul
con!inea $8 mii tuburi electronice "i $500 relee, suprafa!a era de $35 m
2
, cu masa de
30 tone. Structura "i principiile de func!ionare ale unui calculator modern au fost
propuse de americanul Neumann: un calculator modern universal trebuie s# includ#
dispozitivul aritmetic, dispozitivul de comand#, memoria "i unit#!ile de intrareie"ire.
Astfel n memorie se vor nmagazina nu numai datele de prelucrare, dar "i programul.
Instruc!iunile unui program se ncarc# n memorie n acela" mod ca "i datele de
prelucrat. Dupa nceperea procesului de calcul instruc!iunile din memoria
calculatorului vor fi extrase "i executate automat.
4
n ceea ce prive"te dezvoltarea tehnicii de calcul n timp, ea a cunoscut mai
multe etape, respectiv genera!ii de calculatoare:
Prima genera!ie de calculatoare o constituie calculatoarele proiectate n baza
tuburilor electronice (pn# n $959). Aceste calculatoare aveau un volum mare, vitez#
de calcul redus# (circa $000 opera!ii/sec.), capacitate de memorare redus#,
programabile n limbaj-ma"in#.
Genera!ia a doua cuprinde calculatoarele realizate ntre anii $959-$964, locul
tuburilor fiind luate de tranzistoare. Drept consecin!# volumul calculatorului s-a
mic"orat, iar viteza de func!ionare a crescut sim!itor, de asemenea a crescut "i
capacitatea memoriei, s-au extins si posibilit#!ile de programare: a ap#rut posibilitatea
program#rii n limbajele Assembler, Cobol, Fortran; volumul sporit de memorie a
stimulat lucr#rile ndreptate spre automatizarea program#rii calculatoarelor; au ap#rut
primele sisteme opera!ionale. Exemple de calculatoare de genera!ia a doua snt
Minsk-22, Minsk-32, &'()-4, &'()-6.
Genera!ia a treia a ap#rut n anii $964-$972. La baza acestor calculatoare stau
circuitele integrate, datorit# c#rora dimensiunile calculatoarelor au sc#zut cu mult,
viteza de lucru "i capacitatea memoriei au crescut cu cteva ordine.
Din anul $972 pna n $980 calculatoarele proiectate apar!in genera!iei a patra.
Ca element de baz# serve"te microprocesorul "i alte circuite integrate mari.
Din $980 pna n zilele noastre se dezvolt# genera!ia a cincea de calculatoare,
la baza proiect#rii c#rora stau circuite integrate foarte complicate "i cu capacit#!i de
lucru foarte mari. Aceste circuite con!in sute de mii de tranzistoare n corpul lor,
avnd dimensiuni foarte mici.
Parametrii principali ce caracterizeaz# un calculator modern snt: Memoria
operativa RAM(Mb), Memoria permanenta ROM(Gb),Frecventa de lucru(MHz).

Tema 2: Concep!ii generale despre calculatoare
2.# Principiul de func$ionare al calculatoarelor "i structura lor.
De"i un calculator este ansamblul de dispozitive "i circuite foarte diverse "i
complicate, studiul func!ion#rii lui este mult u"urat prin faptul, c# circuitele
componente snt grupate n unit#!i avnd func!ii mai complexe bine precizate.
Structura clasic# a calculatorului este urmatoarea:
unde UAL - unitate aritmetic#-logic#;
UC - unitate de control sau dirijare;
(UC+UAL=procesor);
M - memoria;
I/O - dispozitive de intrare/ie"ire (input/output).
Pentru a n!elege mai bine principiul de func!ionare a unui calculator, o vom face pe
baza analizei lucrului unui program introdus n memoria calculatorului. Deci, avnd
un text al unui program scris ntr-un limbaj orecare, prin intermediul dispozitivelor de
intrare (tastatura, unitatea de disc flexibil, ".a) el se introduce n memoria
calculatorului, de unde este citit "i procesat de c#tre unitatea aritmetic#-logic#; apoi
datele rezultante snt scoase la r#spuns prin intermediul dispozitivelor de ie"ire
(monitorul, imprimanta ".a). Toate aceste opera!ii snt efectuate sub supravegherea
unit#!ii de control.
5
Din punct de vedere a dispozitivelor de baz#, calculatorul modern este alc#tuit
din urmatoarele componente :
- unitatea central#, menit# sa gestioneze func!ionarea ntregului sistem;
- monitorul, destinat afi"#rii datelor alfanumerice "i grafice;
- tastatura , a carei destina!ie este introducerea datelor sau programelor;
- unit#!ile de discuri flexibile;
- unit#!ile de discuri rigide;
n afar# de componentele de baz# la un calculator personal mai pot fi
conectate:
- imprimanta - unitate pentru tip#rirea pe hartie a informa!iilor alfanumerice "i
grafice;
- "oricelul sau mouse-ul, a carui destina!ie este facilitatea proceselor de introducere
a informa!iei "i de manipulare a programelor;
- videomaneta sau joistik, utilizat# n dispozitivele de antrenament "i diverse
simulatoare, la animarea jocurilor pe calculator;
- scanerul, a carui destina!ie este copierea imaginii de pe hrtie n memoria
calculatorului;
- alte dispozitive ce u"ureaz# lucrul la calculator.

2.2 Destina$ia dispozitivelor de baz!.
Unitatea central! a calculatorului se compune din microprocesorul central,
memoria operativ# RAM, controlere "i porturile de intrare/ie"ire (I/O).
Microprocesorul central determin# viteza de lucru a calculatorului. n cazul
microprocesoarelor slabe, cum ar fi INTEL8088, INTEL80286, INTEL80386 nu
exist# comenzi speciale pentru efectuarea opera!iilor complicate (n virgul# flotant#)
"i se recomanda folosirea coprocesoarelor aritmetice, care m#resc viteza de lucru de
5-$5 ori. Cu apari!ia procesoarelor Pentium aceasta problem# dispare "i vitezele se
m#resc sim!itor.
n memoria operativ# se ncarc# temporar componentele sistemului de operare
necesare la un moment dat, precum "i programul utilizatorului cu datele acestuia.
Datele se p#streaz# n memoria operativ# pn# la renc#rcarea calculatorului, apoi
dispar. Capacitatea memoriei operative se masoar# n octe!i (bytes). Un octet
reprezint# o structura de memorie de 8 pozi!ii (celule), numite bi!i.($Kb=$024 octe!i,
$Mb=$024Kb). Calculatoarele personale actuale au o memorie operativ# ntre 8Mb "i
256Mb (pe cnd 30 pagini Word formatate = 250 Kb, $ pagina text=2.5Kb).
Controlerele reprezint# dispozitive electronice care controleaz# activitatea
imprimantei, monitorului, unit#!ilor de disc flexibil "i rigid etc.
Porturile de inrare/ie"ire (I/O) realizeaz# schimbul de date ntre unitatea
central# "i unit#!ile periferice. Porturi I/O exist# de 2 feluri: paralele (LPT$, LPT2 )
"i seriale asincrone (COM$, COM2 ). Porturile paralele efectuiaz# opera!iile de I/O
cu o vitez# mai mare dect porturile seriale, dar necesit# un numar mai mare de
circuite pentru schimbul de date. La porturile I/O se pot conecta diferite dispozitive
periferice: imprimanta, mouse-ul, scaner-ul, joistik-ul, tastatura, monitorul, etc.
Unit!"ile de discuri flexibile asigur# scrierea "i citirea informa!iei pe dischete.
Dischetele snt purt#tori de informa!ie, ce permit transportarea ei de la un calculator
6
la altul, p#strarea ei n form# de copii de arhiv# etc. Capacitatea dischetelor se
masoar# n Kb "i Mb. n prezent cele mai r#spndite snt dischetele cu capacitatea de
$.44 Mb avnd diametrul de 3.5 inches (89 mm). Mai exist# "i dischete cu diametrul
de 5.25 inches ($33 mm) cu o capacitate de 360Kb, 720Kb, $.2Mb. nainte de a pune
n aplicare, dischetele trebuie formatate. Formatarea dischetelor se realizeaz# cu
ajutorul comenzii FORMAT al SO MS-DOS. Este de men!ionat faptul c# fiecare
model de unitate de disc flexibil este calculat "i destinat pentru folosirea unui anumit
tip de dischete.
Unit!"ile de discuri rigide servesc la p#strarea permanent# a informa!iei n
calculator: programe, chituri de instalare, editori de texte "i alte produse soft,
documente importante n form# textual#, grafic#. Discurile rigide snt fixate. Din
punct de vedere al utilizatorului discurile rigide se deosebesc prin durata de acces "i
capacitate (volumul de informa!ie care poate fi stocat pe disc). Calculatorul IBM
PC/XT posed# disc rigid cu capacitatea de zeci Mbytes, iar discul rigid al
calculatorului IBM AT are o capacitate de sute Mbytes. Calculatoarele moderne
posed# discuri rigide cu o capacitate de ordinul Gbytes.
Durata de acces este timpul necesar unit#!ii de disc pentru a pozi!iona capul
pentru citire-scriere pe pista indicat# "i pentru a citi sectorul cerut de unitatea
central#. Durata de acces la discului rigid al calculatorului cu procesor intel 80386
este aproximativ egal# cu $2-25 ms.
n sistemele de operare ale calculatoarelor unit#!ile de disc se noteaz# prin
litere latine urmate de simbolul ":". Ex: A:,B:,C:,D:, Z: .
Imprimanta este unitatea periferic# destinat# tip#ririi informa!iei. Toate
imprimantele pot tip#ri informa!ii numerice "i grafice, alb-negru "i color. Exist# mai
multe tipuri de imprimante:
- matriciale;
- cu jet de cerneal#;
- laser.
Imprimanta matricial! are un cap de tip#rit care con!ine un set de ace metalice
sub!iri, care la momentul dat lovesc prin banda de tip#rire n foaia de hrtie. La
imprimanta cu jet de cerneal! caracterele tip#rite se formeaz# din pic#turi
microscopice pulverizate pe hrtie de ni"te duze speciale. Ele asigur# o calitate destul
de nalt# a tiparului "i snt comode pentru imprimarea color. Viteza de imprimare este
comparabil# cu cea a imprimantelor matriciale. Pre!ul imprimantelor cu jet de
cerneal# este mai mare ca la cele matriciale. Imprimanta laser asigur# cea mai bun#
calitate a tiparului. La baza acestor imprimante se afl# principiul de xerografie.
Caracterul se imprim# pe un cilindru pe care a fost format, prin intermediul
semnalelor electrice cu vopsea special# - toner. Viteza de tip#rire este mai mare ca la
primele 2 tipuri de imprimante "i constituie 3-$5 sec. pentru o pagina. Aceste
imprimante snt cele mai scumpe.
Monitorul e destinat afi"#rii pe ecran a informa!iei alfanumerice "i grafice.
Exist# monitoare color "i monocolor. Ele pot func!iona n dou# moduri: alfanumeric
"i grafic. n cazul regimului alfanumeric, ecranul e imp#r!it n zone conven!ionale
numite zone caracter. De obicei aceste zone alcatuiesc 25 linii cu 80 caractere pe linie.
n fiecare zon# poate fi afi"at un singur caracter dintr-un set de 256 caractere. Printre
7
caracterele afi"ate pe ecran pot fi: litere mari "i mici ale alfabetului latin, cifre, semne
de punctua!ie "i matematice, precum "i alte litere din alte alfabete. Regimul grafic al
monitorului este destinat afi"#rii pe ecran desenelor, graficelor, diagramelor "i
textelor. Ecranul e alc#tuit din puncte numite pixeli, fiecare punct poate fi pe
monitorul monocrom iluminat sau ntunecat, sau de una din culorile de care dispune
monitorul color. Numarul de puncte pe orizontal# "i vertical# determin# rezolu!ia
monitorului. Ex: 640x480, 800x600, $024x768.
Din punct de vedere al rezolu!iei "i graficii exist# mai multe norme
interna!ionale pentru monitoare. Ex: CGA, EGA, VGA, SVGA.
Tastatura este dispozitivul care permite introducerea informa!iei n calculator
"i gestiunea sistemului. Tastaturile se clasific# n func!ie de !ara c#reia i snt destinate.
Tastatura are mai multe tipuri de taste:
- alfa-numerice (a,b,c,,z,0,$,,9,(,.,:,",*,$,@, etc.);
- func!ionale (F$-F$0);
- speciale (Shift, Alt, Ctrl, Enter).
Mouseul are destina!ia de a m#ri comoditatea lucrului la calculator, de a
gestiona sistemul. Mouse-ul poate fi cu 2 sau 3 clape. Cele mai r#spndite snt cele cu
2 clape. Clapa din stnga are func!ia confirm#rii unei comenzi "i este echivalent# cu
tasta <ENTER> de pe tastatur#. Clapa din dreapta deschide meniuri ad#ug#toare
ajut#toare, avnd specifica!ii diferite pentru fiecare obiect n particular.

2.3 Bazele aritmetice ale calculatorului.
2.3." Sistemele de numera!ie.
n calculatoarele digitale informa!ia de orice categorie este reprezentat#,
stocat# "i prelucrat# n form# numeric#. Numerele se reprezint# prin simboluri
elementare numite cifre.Totalitatea regulilor de prezentare a numerelor mpreun# cu
mul!imea cifrelor reprezint# un sistem de numera!ie.Numarul cifrelor folosite
serve"te drept baz# a sistemului de numera!ie. Cel mai frecvent snt folosite
sistemele:
- Zecimal: sistem de numera!ie n baza $0, cifrele utilizate: 0. . 9;
- Binar: baza-2, numarul de cifre utilizate 2: 0,$. Cifrele se numesc bi!i;
- Ternar: baza-3, cifre: 0,$,2;
- Octal: baza-8, cifre 0..7;
- Hexazecimal baza-$6, $6 cifre:0,$,9, A(zece), B,C,D,E,F($5)
Regula de reprezentare a numerelor din sistemul zecimal rezult# din urmatorul
exemplu: (3856,43)
$0
=3*$0
3
+8*$0
2
+5*$0
$
+6*$0
0
+4*$0
$
+3*$0
2
. Se observ#, c#
n aceast# reprezentare semnifica!ia(valoarea) fiec#rei cifre depinde de pozi!ia pe care
o ocupa n numar (sute, mii,sutimi,miimi etc).
Sistemele n care semnifica!ia cifrelor depinde de pozi!ia ocupat# n cadrul
numerelor se numesc sisteme de numera!ie pozi!ionale.
Presupunem c# num#rul N are partea ntreg# format# din n+$ cifre , iar partea
frac!ional# din m cifre: N=C
n
*C
n-$
C
$
*C
0,
C
-$
C
m.

Valoarea acestui numar se evalueaz# n func!ie de baza sistemului de
numera!ie: (N)
b
=C
n
b
n
+ C
n-$
b
n-$
+ + C
0
b
0
+ C
-$
b
-$
+ C
-m
b
-m
.
8
Efectund calculele respective se va realiza conversia numarului N(b) din baza
respectiv# n baza zece . Ex:
($$0.$$)
$0
=$*$0
2
+$*$0
$
+0*$0
0
+$*$0
$
+$*$0
2
=$$0.$5;
($$0.$$)
2
=$*2
2
+$*2
$
+0*2
0
+$*2
$
+$*2
2
=6.75;
($$0.$$)
3
=$*3
2
+$*3
$
+0*3
0
+$*3
$
+$*3
2
=$2.444;
($$0.$$)
8
=$*8
2
+$*8
$
+0*8
0
+$*8
$
+$*8
2
=72.$40625;
($$0.$$)
$6
=$*$6
2
+$*$6
$
+0*$6
0
+$*$6
$
+$*$6
2
=272.06640625;
Formal sistemul zecimal nu prezint# nici un avantaj deosebit fa!# de celelate sisteme
de numera!ie. Se presupune c# acest sistem a fost adoptat din cele mai vechi timpuri
datorit# faptului c# procesul de num#rare a folosit ca instrumente ini!iale degetele
minilor.
O ma"ina de calcul automat# poate fi construit# s# lucreze n orice sistem de
numera!ie. Pe parcursul dezvolt#rii tehnicii de calcul s-a stabilit c# cel mai avantajos
este sistemul binar. Acest sistem a fost preferat din urm#toarele motive:
- Simplitatea regulilor pentru opera!iile aritmetice "i logice.
- Materializarea fizic# a cifrelor n procesul prelucr#rii sau stoc#rii numerelor se
face mai u"or pentru dou# simboluri dect pentru zece: perforat-neperforat, contact
nchis - contact deschis, prezen!# de curent sau absen!# de curent etc.
- Circuitele care trebuie s# diferen!ieze numai ntre 2 st#ri snt mai sigure n
func!ionare dect cele care trebuie s# diferen!ieze ntre zece st#ri.
n procesul dezvolt#rii civiliza!iei umane au fost create "i sisteme de numera"ie
nepozi"ionale. Drept exemplu poate servi sistemul roman, care utilizeaz# cifrele
I,V,X,L,C,D,M. ntruct regulile de prezentare a numerelor "i de efectuare a
opera!iilor aritmetice snt foarte complicate, sistemele nepozi!ionale au o utilizare
foarte restrns#.

2.3.2 Conversia numerelor dintr-un sistem n altul.
Conversia num#rului (N)
b
n echivalentul s#u zecimal se efectuiaz# conform
formulei : (N)
b
=C
n
b
n
+ C
n-#
b
n-#
+ + C
0
b
0
+ C
-#
b
-#
+ C
-m
b
-m
.
Conversia num#rului zecimal (N)
$0
n echivalentul s#u n baza b se efectuiaz#
conform urmatoarelor reguli:
$) Pentru partea ntreaga. Se mparte la baza respectiv# partea ntreag# "i cturile
ob!inute dup# fiecare mp#r!ire, pna se ob!ine ctul zero. Rezultatul conversiei
p#r!ii ntregi este compus din resturile ob!inute luate n ordinea invers# apari!iei.
2) Pentru partea frac!ionar#. Se nmul!e"te cu baza partea frac!ionar#, apoi toate
p#r!ile frac!ionare ob!inute din produsul anterior pn# cnd partea frac!ionar# a
unui produs este zero sau pn# la ob!inerea unui num#r frac!ionar cu num#rul de
cifre dup# virgul# dorit. Rezultatul conversiei p#r!ii frac!ionare este constituit din
p#r!ile ntregi ale produselor considerate n ordinea apari!iei.
Analiz#m cteva exemple:
$) De efectuat conversia num#rului zecimal 37.0625 n echivalentul s#u binar.
Pentru partea ntreag#: 37:2=$8+$/2; $8:2=9+0/2; 9:2=4+$/2; 4:2=2+0/2;
2:2=$+0/2; $:2=0+$/2;
9
Pentru partea frac!ionar#: 0.0625*2=0.$25; 0.$25*2=0.250; 0.250*2=0.5;
0.5*2=$.0;
Prin urmare (37.0625)
$0
= ($00$0$, 000$);
2) De transformat num#rul 43.9 din sistemul zecimal n sistemul binar.
Pentru partea ntreaga: 43:2=2$+$/2; 2$:2=$0+$/2; $0:2=5+0/2; 5:2=2+$/2;
2:2=$+0/2; $:2=0+$/2;
Pentru partea frac!ionar#: 0.9*2=$.8; 0.8*2=$.6; 0.6*2=$.2; 0.2*2=0.4;
0.4*2=0.8; 0.8*2=$.6;
Observ#m c# procesul nmul!irii poate continua pn# la infinit. n acest caz
rotungim cifra cu num#rul de pozi!ii dup# virgul# dorit. Deci (43.9)
$0
=
$0$0$$, $$$00$$00)
2
.
3) S# se transforme ($456.40625)
$0
n sistemul octal.
Partea ntreaga: $456:8=$82+0/8; $82:8=22+6/8; 22:8=$6+6/8; $6:8=2+0/8;
2:8=0+2/8;
Partea frac!ionar#: 0.40625*8=3.25; 0.25*8=2.0;
Prin urmare : ($456, 40625)
$0
= (20660, 32)
8
;
4) S# se efectuieze conversia num#rului zecimal 3786,25 n echivalentul s#u
hexazecimal.
Partea ntreaga: 3786:$6=236+$0/$6; 236:$6=$4+$2/$6; $4:$6 =0+$4/$6;
Partea frac!ionar#: 0.25*$6=4.
Deci: (3786, 25)
$0
= (ECA, 4)
$6
.

2.3.3 Conversia numerelor din sistemul binar n octal,
hexazecimal #i invers.
Deoarece 8=2
3
, conversia din binar n octal "i invers se poate face direct. Orice
cifr# octal# se reprezint# prin 3 cifre binare: 0=000; $=00$; 2=0$0; 3=0$$; 4=$00;
5=$0$; 6=$$0; 7=$$$.
Dac# se consider# un numar octal, pentru conversia lui n binar se va scrie
fiecare cifr# octal# prin 3 cifre binare. De exemplu:
(352, 45$)
8
= (0$$ $0$ 0$0, $00 $0$ 00$)
2
;
($26, 23)
8
= (00$ 0$0 $$0, 0$0 0$$)
2
;
(5, 065)
8
= ($0$, 000 $$0 $0$)
2
;
Dac# se consider# un num#r binar, pentru conversia lui n octal se vor grupa
cte 3 cifre binare pornind de la pozi!ia virgulei spre stnga pentru partea ntreag#,
respectiv spre dreapta pentru partea frac!ionar#, g#sind corespondentul n octal.
Pentru completarea unui grup de 3 cifre binare se pun zerouri naintea num#rului
pentru partea ntreaga, respectiv dup# numar pentru partea frac!ionar#; aceste
schimb#ri a num#rului nu vor modifica valoarea lui. Exemple:
($0$, $00$0$)
2
= ($0$, $00 $0$)
2
= (5, 45)
8
;
($0, $00$$)
2
= (0$0, $00 $$0)
2
= (2, 46)
8
;
($0$0, $0$0)
2
= (00$ 0$0, $0$ 000)
2
= ($2, 50)
8
;
n mod similar se procedeaz# "i n cazul sistemului hexazecimal, baza c#ruia $6=2
4
.
Orice cifr# hexazecimal# se reprezint# prin 4 cifre binare:
0=0000; $=000$; 2=00$0; 3=00$$; 4=0$00; 5=0$0$; 6=0$$0; 7=0$$$;
8=$000; 9=$00$; A=$0$0; B=$0$$; C=$$00; D=$$0$; E=$$$0; F=$$$$;
$0
Exemple de conversii hexazecimal binar:
(4B5F,B7)
$6
= (0$00 $0$$ 0$0$ $$$$, $0$$ 0$$$)
2
;
(A5$, 3DE)
$6
= ($0$0 0$0$ 000$, 00$$ $$0$ $$$0)
2
;
Exemple de conversii binar hexazecimal:
($0$$, $00$$$)
2
= ($0$$, $00$ $$00)
2
= (B, 9C)
$6
;
($0, $$0$$00$)
2
= (00$0, $$0$ $00$)
2
= (2, D9)
$6
;

2.3.4 Operatii aritmetice n binar.
Opera!iile aritmetice cu numerele binare, octale, hexazecimale difer# de la un
sistem la altul. Cele mai simple snt opera!iile cu numerele binare. Toate opera!iile
aritmetice cu numerele binare snt bazate pe regulile de adunare, sc#dere "i nmul!ire
binar#, prezentate n tabel.

Opera!ii aritmetice cu numerele binare.

Adunarea binar# Scaderea binar# Inmul!irea binar#
0 + 0 = $ 0 0 = 0 0 * 0 = 0
0 + $ = $ $ 0 = $ 0 * $ = 0
$ + 0 = $ $ $ = 0 $ * 0 = 0
$ + $ = $0 $0 $ = $ $ * $ = $

Pentru nsu"irea mai u"oar# a temei, vom prezenta exemple concrete:
Ex.$: Adunarea n binar a numerelor zecimale $7 "i 38:
Pentru a efectua adunarea binar# a 2 numere zecimale, nti de toate ele vor fi
convertate n sistenul binar:
($7)
$0
= ($000$)
2
; $7:2=8+$/2; 8:2=4+0/2; 4:2=2+0/2; 2:2=$+0/2; $:2=0+$/2;
(38)
$0
= ($00$$0)
2
; 38:2=$9+0/2; $9:2=9+$/2; 9:2=4+$/2; 4:2=2+0/2;
2:2=$+0/2; $:2=0+$/2;
Adunarea binar#: deci: ($000$)
2
+($00$$0)
2
= ($$0$$$)
2

$000$ iar ($$0$$$)
2
=$*2
5
+$*2
4
+0*2
3
+$*2
2
+$*2
$
+$*2
0
=(55)
$0
;
$00$$0 +
$$0$$$ Verificare ($7)
$0
+(38)
$0
= (55)
$0
;
Ex.2: Efectua!i adunarea binar# a numerelor (26)
$0
si (23)
$0
;
(26)
$0
= ($$0$0)
2
; (23)
$0
= ($0$$$)
2
;
Adunarea binar#: Deci ($$0$0)
2
+ ($0$$$)
2
= ($$000$)
2
;
$$0$0
$0$$$ + Verificare : ($$000$)
2
= (49)
$0
;
$$000$ (26)
$0
+ (23)
$0
= (49)
$0
;
Ex.3: De efectuat sc#derea n binar a numerelor zecimale: (45)
$0
(35)
$0
;
(45)
$0
= ($0$$0$)
2
; (35)
$0
= ($000$$)
2
;
Efectu#m sc#derea:
$0$$0$ Deci ($0$$0$)
2
- ($000$$)
2
= (00$0$0)
2
;
$000$$ - Verific#m: (00$0$0)
2
= ($0)
$0
;
00$0$0 (45)
$0
(35)
$0
= ($0)
$0
;

$$
La efectuarea adun#rii "i sc#derii binare a numerelor zecimale frac!ionare p#r!ile
ntregi "i p#r!ile frac!ionare snt adunate sau scazute aparte.
Ex.4: nmul!irea n binar a numerelor zecimale: (5, $25)
$0
* (2, 25)
$0
;
Dup# transformare primim: (5, $25)
$0
= ($0$, 00$)
2
; (2, 25)
$0
= ($0, 0$)
2
;
Efectu#m nmul!irea binar#:
$0,0$ Am primit ca rezultat: ($0$, 00$)
2
* ($0, 0$)
2
= ($0$$,$000$)
2
;
$0$,00$
$00$ Verific#m: ($0$$,$000$)
2
= ($$, 53$25)
$0
;
0000 (5, $25)
$0
* (2, 25)
$0
= ($$, 53$25)
$0
;
0000
$00$
0000
$00$
$0$$,$000$
Ex.5: De efectuat mp#r!irea binar# a numerelor zecimale: ($20)
$0
: (4)
$0
;
($20)
$0
= ($$$$000)
2
; (4)
$0
= ($00)
2
; Efectu#m mp#r!irea binar#:
$$$$000 | $00
$00 |_______ Rezultatul este: ($$$$000)
2
: ($00)
2
= ($$$$0)
2
;
$$$ $$$$0
$00 Verificare: ($$$$0)
2
= (30)
$0
;
$$0
$00 ($20)
$0
: (4)
$0
= (30)
$0
;
$00
$00
0

Not#: n cazul nmul!irii sau mp#r!irii virgula, care desparte partea ntreag# de cea
frac!ionar# este pozi!ionat# ca "i n cazul sistemului de numera!ie zecimal.
Opera!ii aritmetice se pot efectua de asemenea "i asupra numerelor octale "i
hexazecimale. Pentru u"urarea proceselor de adunare, nmul!ire exist# tabele cu
rezultatele adun#rii "i nmul!irii a dou# cifre dintr-un sistem sau altul. Aici nu vom
prec#uta efectuarea opera!iilor n octal "i hexazecimal, presupunnd studierea acestei
teme n viitor la un obiect specializat cum ar fi Tehnica numeric# de calcul.

Tema 3: Metodica rezolv$rii problemelor cu ajutorul calculatoarelor.
3.# Etapele de rezolvare a problemelor cu ajutorul tehnicii de calcul

Orice problem#, destinat# rezolv#rii cu ajutorul calculatorului, n procesul
realiz#rii sale neap#rat trece prin cele 5 etape:
$. Alegerea modelului matematic
2. Elaborarea algoritmului
3. Verificarea algoritmului
4. Realizarea algoritmului
5. Verificarea programului
6. Documentarea programului.
$2
$. Alegerea modelului matematic. Fiecare problem# independent de complexitatea
sa sau de ramura disciplinii poate fi formulat# matematic naintea rezolv#rii sale.
Aceast# formulare constituie modelul matematic al problemei. El este simplu sau
complicat dupa natura problemei n studiu. La alegerea modelului matematic
influien!eaz# urmatorii factori:
- marginea cuno"tin!elor programatorului n ceea ce prive"te num#rul metodelor.
- comoditatea prezent#rii datelor.
- simplitatea datelor.
- posibilit#!ile tehnicii de calcul.
Dup# alegerea modelului matematic, problema n cauz# se reformuleaz# n termenii
obiectelor matematice corespunz#toare.
2. Elaborarea algoritmului. Prin algoritm se n!elege o mul!ime de reguli care
indic# o succesiune de opera!ii necesare pentru rezolvarea unui tip specific de
probleme. Mul!imea de reguli, care indic# modul de ob!inere a rezultatelor,
constituie pa"ii algoritmului. Execu!ia pa"ilor algoritmului n ordinea cerut# duce
la rezolvarea problemei. Orice algoritm are 3 propriet#!i de baza:
- Generalitate (const# n faptul c# algoritmul trebuie s# fie realizat nu n caz
particular, ci n caz general, fiind luate n considera!ie toate situa!iile ce pot s#
apar# n tipul respectiv de probleme;
- Realizabilitate (este calitatea care scoate n eviden!# faptul, c# tot ceea ce se
ntreprinde este exprimat corect, adic# posibil de realizat);
- Finitudine (nseamn# c# ntr-un timp finit rezolvarea problemei ia sfr"it, adic#
n cadrul algoritmului lipsesc procese ce duc mersul rezolvarii n impas ciclic).
Orice algoritm mai are date de intrare, n urma prelucr#rii c#rora se cap#t# datele
rezultante - de ie"ire. n ceea ce prive"te reprezentarea algoritmului, exist# o mare
varietate de forme. Cele mai r#spndite din ele snt: a)reprezentarea cu ajutorul
schemelor logice, b) reprezentarea cu ajutorul unui limbaj de tip pseudocod, etc.
Reprezentarea algoritmului sub forma de schem# logic# folose"te urmatoarele
elemente logice:
$. START/STOP. Bloc-delimitator. Indic# nceputul/sfr"itul schemei.

2. Bloc de atribuire.

3. Bloc de intrare. Pune n eviden!# o opera!ie de citire a datelor.

4. Bloc de ie"ire. Indic# necesitatea scoaterii datelor pentru a le vizualiza.

5. Blocul de condi!ie(decizie).

6. Blocul de procedur#. Indic# corpul unui subprogram
ncorporat n cel principal.

7. Blocul de ciclu FOR. Destinat realiz#rii proceselor
ce necesit# cteva repet#ri.

$3
8. Nod. Este folosit n cazul intersec!iei "i suprapunerii s#ge!ilor
ntr-un punct.

9. Elementul de trecere pe alt# foaie ( bloc de leg#tur#).

$0. S#geata de legatur# ntre blocuri.

ntre elementele schemei logice de calcul snt unele grup#ri pentru reprezentarea
proceselor mai complicate folosindu-se elementele prezentate mai sus.

3. Verificarea algoritmului. Este una din cele mai complicate etape. Presupune
verificarea corectitudinii mersului rezolv#rii, ncercarea algoritmului cu diferite
date de intrare, "i echivalen!a rezultatelor primite prin alte metode de rezolvare.
Algoritmul se descrie sub pa"i numerota!i (0n) "i se face analiza, controlul "i
motiva!ia fiec#rui pas, de asemenea este necesar# demonstrarea faptului c#
algoritmul este finit(pentru aceasta trebuie controlate toate datele potrivite "i
primite rezultatele respective.
4. Realizarea algoritmului. Presupune analiza profund# a sarcinilor algoritmului,
alegerea limbajului de programare "i traducerea algoritmului n limbajul respectiv.
5. Verificarea programului. Pentru verificarea unui program cele mai utilizate
metode snt: a)metoda analitic#, b) metoda constructiv#, c) metoda test#rii. Ne
oprim la metoda 3.
Testarea programului este nso!it# de depanarea lui. Depanarea stabile"te cauzele,
care au determinat apari!ia erorilor "i const# n folosirea unor metode "i
instrumente pentru nl#turarea lor. n cazul limbajului BP7.0 depanarea se face cu
ajutorul compilatorului ncorporat n mediul BP.
6. Documentarea programului. Prevede descrierea metodei algoritmului, a
programului, a tuturor variabilelor folosite, construc!iilor logice, rezultatelor
ob!inute "i indica!ii pentru lucrul cu programul.

Tema 4:Limbajul de programare Pascal
4.# No$iuni generale
4."." Alfabetul, vocabularul #i sintaxa limbajului.
Numim limbaj de programare un limbaj prin care putem comunica unui
calculator metoda de rezolvare a unei probleme. Iar metoda de rezolvare a problemei,
dupa cum "tim deja o numim algoritm. ntreaga teorie informatic# se ocup#, de fapt,
cu elaborarea unor noi calculatoare, limbaje de programare "i algoritmi. Datoria
oric#rui limbaj de nivel nalt este s# ne pun# la dispozi!ie o sintax# ct mai comod#
prin care s# putem descrie datele cu care lucreaz# programul nostru "i instruc!iunile
care trebuiesc executate pentru a rezolva o anumit# problem#.
Limbajul de programare Pascal, ca "i orice alt limbaj de programare "i are
alfabetul s#u "i specificul de utilizare a simbolurilor. Alfabet al unui limbaj de
programare se nume"te un set de simboluri permis pentru utilizare "i recunoscut de
compilator, cu ajutorul c#ruia pot fi formate m#rimi, expresii "i operatori ai acestui
limbaj de programare. Alfabetul oric#rui limbaj de programare con!ine cele mai
$4
simple elemente cu semnifica!ie lingvistic#, iar sintaxa limbajului define"te modul n
care se combin# elementele vocabularului pentru a ob!ine fraze corecte (instruc!iuni,
secven!e de instruc!iuni, declar#ri de tipuri, variabile, constante, etichete, func!ii,
proceduri etc.).
Elementele vocabularului snt alc#tuite din caractere. Orice caracter este
reprezentat n calculator, n mod unic, printr-un num#r natural cuprins ntre 0 "i $27,
numit cod ASCII.
Alfabetul limbajului de programare Pascal este compus din:
$. Simboluri folosite pentru formarea identificatorilor:
literele mari "i mici ale alfabetului latin,
cifrele arabe de la 0 la 9,
simbolul de subliniere __ (cod ASCII:95).
2. Simboluri de desp#r!ire:
simbolul spa!iu(cod ASCII:32).Are func!ia de desp#r!ire a cuvintelor cheie
"i numerelor.
simboluri de conducere (ASCII:03$), se pot folosi la descrierea
constantelor. Simboluri tabulare (ASCII:9) "i simbolul de trecere n alt rnd
{ D c b : a + = e identic cu

+
=
D c
b : a
.
3. Simboluri speciale care ndeplinesc anumite func!ii n alc#tuirea diferitor
construc!ii ale limbajului de programare Pascal
+ * / { } [ ] ( ) < > . , : ; ^ @ # $
4. Simboluri compuse grupe de simboluri, recunoscute de c#tre compilator ca un
tot ntreg:
<= => := (* *) (. .) .. ,
5. Simboluri neutilizate. Simboluri ale tabelei ASCII extinse (cod
$28255). Aici se con!in literele alfabetului rus, simboluri de pseudografic#, "i
cteva simboluri ale tabelului ASCII (Ex.: & , ! , % , ~ , "i altele).Ele nu intr#
n alfabetul limbajului, dar pot fi folosite n textul comentariilor, n textul
mesajelor.
Vocabularul limbajului de programare Pascal.
Cele mai simple elemente, alc#tuite din caractere "i care au semnifica!ie
lingvistic# snt unit#!ile lexicale. Acestea formeaz# vocabularul limbajului.
Distingem urm#toarele unit#!i lexicale:
- simboluri speciale, identificatori, numere, "iruri de caractere, etichete, comentarii,
directive;
- simboluri speciale;
- cuvintele cheie:
and array begin case const div do downto else end file for function goto if in label
mod nil not of or origin otherwise packed program record repeat set then to type
until var while with etc.
Cuvintele cheie snt rezervate, adic# snt utilizate n program doar cu
semnifica!ia dat# explicit prin defini!ia limbajului. Celelalte simboluri speciale snt
folosite ca operatori "i delimitatori.
$5
Identificatorii snt nume asociate constantelor, variabilelor, tipurilor de date,
procedurilor "i func!iilor. Primul caracter al numelui este o liter# sau $, iar celelalte
snt litere, cifre, semnul $ sau .
Numerele pot fi de tip ntreg sau real. Numerele de tipul ntreg desemneaz#
numere ntregi "i snt scrise n reprezentare zecimal#, precedate sau nu de semnele +
sau . Numerele de tipul real desemneaz# numere ra!ionale cu num#r finit de
zecimale. n mod uzual ele snt reprezentate prin numere frac!ionare(n baza $0) cu
partea frac!ionar# separat# de partea ntreag# prin punct. La scrierea numerelor de
tipul real se poate utiliza "i un factor de scal#. Acesta este un num#r ntreg precedat
de litera E (Ex. 7,354E+02) "i are efectul de nmul!ire a num#rului real cu $0 la
puterea egal# cu valoarea factorului de scal#.
*irurile de caractere snt "iruri de caractere imprimabile, delimitate de
apostrof, n "irul de caractere, apostroful apare dublat. Ex. "ir de caractere
Etichetele snt "iruri de cifre zecimale. Ex. $, 0$, 20, 0.
Comentariile snt "iruri de caractere precedate de { "i urmate de }.
Comentariile con!in informa!ie despre:
numele fi"ierului n care se p#streaz# programul,
o descriere scurt# a destina!iei programului,
drepturile de autor,
limbajul de programare folosit,
versiunea programului,
nsemn#ri despre destina!ia unor p#r!i a programului etc.
Directivele snt cuvintele rezervate forward, external, nonpascal "i
%include.
n scrierea oric#rei unit#!i lexicale nu se face distinc!ie ntre literele mari "i mici.
La scrierea consecutiv# a identificatorilor, a cuvintelor cheie, a literelor numerice ele
trebuie s# fie desp#r!ite de (spa!iu).
Prin sintaxa unui limbaj de programare se n!elege, n general, un ansamblu de
reguli de agregare a unit#!ilor lexicale pentru a forma structuri mai complexe
(instruc!iuni, declara!ii, programe etc.). Forma general# a unui program n limbajul de
programare Pascal de asemenea "i are regulile ei de sintax# dup# cum urmeaz#: un
antet, urmat de o parte declarativ# "i de o instruc!iune compus#. *i pentru descrierea
n detaliu a acestor componente snt necesare, desigur "i alte reguli.

4.".2 Structura general$ a unui program
Programele, scrise n limbajul de programare Borland Pascal 7.0 se compun
conform unor reguli extinse "i pu!in mai slabe ale sintaxei standardului limbajului de
programare Pascal. ns# "i aceste reguli trebuie neap#rat s# fie respectate. Structura
general# a unui program n limbajul de programare Pascal se poate mp#r!i n cteva
p#r!i de baz#:
antetul de program ,
partea declarativ# ,
partea procedurilor "i func!iilor,
partea blocului principal.
care snt amplasate n cadrul programului n urm#torul mod:
$6
$. Antet
Program nume;
2. Partea declarativ#
{$} directive globale ale compilatorului
USES bibliotecile (pentru folosire) incluse
LABEL declararea etichetelor globale
CONST declararea constantelor globale
TYPE declararea tipurilor globale
VAR declararea variabilelor globale
3. Partea procedurilor "i func!iilor:
Procedure (function) antetul procedurii(func!iei)
LABEL declararea etichetelor locale
CONST declararea constantelor locale
TYPE declararea tipurilor locale
VAR declararea variabilelor locale
BEGIN blocul principal al procedurii (func!iei)
END;
4.Partea blocului principal
BEGIN blocul principal al programului
END.

$. n prima parte se afl# rndul antetului programului. El const# din cuvntul
rezervat PROGRAM "i denumirea programului. n Borland Pascal antetul nu este
obligatoriu, dar e preferabil de-l folosit pentru o comoditate n citirea programului "i
informa!iei suplimentare despre program.
2. n partea a doua se comunic# compilatorului cu ce identificatori se noteaz#
datele, deasemenea se determin# tipurile noi create de programator. n aceast# parte a
programului se poate de-i dat compilatorului unele indica!ii, ce determin# regimurile
de lucru la translarea programului. Aceste indica!ii se oformeaz# n textul
programului ca comentarii, ce se ncep cu simbolurile {$ "i se termin# cu }.
Aceste comentarii pot con!ine indica!ii la includerea n textul programului a
fragmentelor din alte programe (din fi"ierele corespunz#toare), informa!ie despre
necesitatea folosirii coprocesorului aritmetic.
Operatorul USES joac# un rol important n includerea n textul programului
a modulelor de sistem din biblioteci. n acest operator se indic# compilatorului, din ce
bibliotec# se folosesc module n cadrul programului dat, pentru a fi includse n
program. Bibliotec# este un set de module, fiecare din care este nchis, "i are
numele s#u, se compileaz# aparte "i se include n program ca un tot ntreg cu o
interfa!# cunoscut#. Fiecare modul (bloc,UNIT) reprezint# un program ce con!ine
declara!ii de tipuri "i variabile, proceduri "i func!ii. Denumirea bibliotecilor, ce se
includ n program cu ajutorul operatorului USES se despart prin virgul#:
Ex.: USES CRT,GRAPH,DOS,SYS;
Dup# rndul operatorului USES urmeaz# declararea etichetelor, constantelor,
tipurilor, variabilelor. (Ele pot fi amplasate n ordine aleatoare).
$7
n partea de declarare a etichetelor se con!in, desp#r!ite prin virgul#, numele
etichetelor de trecere, care nu trebuie s# fie dublate. Numele etichetei de trecere poate
fi un num#r ntreg (0..9999), un "ir de caractere sau o construc!ie din numere "i
caractere. Ex.: LABEL $, 2, a, b, $a, 2b;
Descrierea constantelor ce vor fi folosite n program are loc n sec!iunea
CONST. Constantele pot avea orice nume compus din caractere sau construc!ii din
caractere "i cifre. ns# n orice caz un nume de constant# nu poate ncepe cu o cifr#.
Dup# numele constantei urmeaz# semnul = dup# care este specificat# valoarea
constantei. O constant# poate avea valoare de diferite tipuri:
ntreg, real, caracterial etc. Ex.: CONST a=$9; AN=$998; MONTH=Iulie; pi=3.$4.
Partea de descriere a tipurilor permite programatorului s# determine tipuri noi n
program.
Ex.: TYPE zi = (luni, mar!i, miercuri, joi, vineri, smb#t#, duminic#);
Partea de descriere a variabilelor globale con!ine lista variabilelor folosite n
cadrul programului cu indicarea tipurilor lor.
Ex.: VAR A,B,C:INTEGER; NUME:REAL;
P#r!ile LABEL, CONST, TYPE "i VAR se pot plasa n program n ordine aleatoare.
3. Proceduri "i func!ii.
Procedur# "i func!ie snt termenii n Pascal ce se folosesc pentru identificarea
ntr-un mod special a unei consecutivit#!i de instruc!iuni(subprograme). Dac# n
program se folosesc proceduri (func!ii), atunci e necesar de descris antetul lor
indicnd lista parametrilor folosi!i de ele (a"a ca tipul sau valoarea variabilelor). n
a"a fel se realizeaz# posibilitatea chem#rii unei proceduri/func!ii cu diferite date "i
din diferite locuri a programului. Ex.: Procedure suma (VAR sum: INTEGER; VAR
x, y: INTEGER); n interiorul procedurii se poate de declarat etichete, constante,
tipuri, variabile care vor fi accesibile numai n interiorul procedurii/func!iei unde au
fost declarate. Corpul (blocul principal) func!iei/ procedurei joac# acela"i rol ca "i
corpul programului. *i are ca hotare cuvintele cheie BEGIN "i END, cu o deosebire
c# dup# END urmeaz# ; "i nu .
4. Corpul (blocul principal) programului.
Corpul programului const# dintr-o succesiune de operatori, lucrul programului
ncepndu - se de la primul operator. Corpul este m#rginit de cuvintele cheie BEGIN
"i END care pot con!ine n interior operatori, diferite construc!ii, apel#ri la
func!ii/proceduri "i acelea"i construc!ii BEGIN_END incluse una n alta , dar cu ;
la sfr"it .Variabilile,constantele,etichetele,tipurile noi pot fi folosite n program
numai n cazul declar#rii la nceput.

4.2 Tipuri de date.
Un program n limbajul Pascal con!ine o descriere a ac!iunilor ce trebuie s#
fie executate de calculator "i o descriere a datelor ce snt prelucrate de aceste ac!iuni.
Ac!iunile snt descrise prin instruc!iuni, iar datele prin declara!ii(sau defini!ii). Prin
tip de date se n!elege o mul!ime de valori care pot fi atribuite unei variabile sau
constante. Pe tipurile de date ale unui program se definesc o serie de opera!ii,
rezultatul fiind o algebr# multisortat# avnd ca domenii aceste tipuri. Se disting trei
categorii de tipuri de date: simple(elementare), compuse(structurale) "i de
$8
referin!#(pointer). n general, tipurile de date snt definite explicit prin declara!iile
TYPE, iar opera!iile asociate - prin declara!iile FUNCTION sau PROCEDURE, "i
snt specifice programului n care apar. Exist# ns# tipuri de date elementare de
interes mai general, numite tipuri predefinite a c#ror defini!ie se consider# cunoscut#
"i nu cade n sarcina programatorului. O serie de opera!ii relative la aceste tipuri snt
deasemenea predefinite.

4.2." Tipuri de date simple
Exist# 3 categorii de tipuri simple: predefinite, enumerate "i
subdomeniu(interval). Tipurile simple se mai numesc scalare.

4.2."." Tipuri predefinite .
Exist# 5 tipuri de date simple predefinite: INTEGER, REAL, BOOLEAN,
CHAR, TEXT,.
Tipul INTEGER este o mul!ime de numere ntregi ntre cel mai mic "i cel
mai mare num#r ntreg, ce se pot reprezenta pe un calculator. Adic# orice num#r
ntreg N trebuie s# respecte condi!ia: maxint <= N< = +maxint . Prelucrarea unui
num#r ntreg din afara acestui diapazon duce la rezultat gre"it sau la stoparea
execut#rii programului. Asupra numerelor ntregi se pot efectua urm#toarele opera!ii
de baz#, rezultatul c#rora de asemenea este un num#r ntreg. Toate aceste opera!ii se
ndeplinesc asupra 2 argumen!i "i snt urm#toarele :+ adunarea; sc#derea; *
nmul!irea; div mp#r!irea f#r# rest; mod restul de la mp#r!ire;
Ex.: 3+5=8 ; 5-3=2 ; 5*3=$5 ; 5div2=2 ; 5mod2=$;
Dup# gradul de ndeplinire aceste opera!ii snt aranjate n felul urm#tor:
(*,div, mod, + "i ). Mai exist# "i alte opera!ii asupra numerelor ntregi cu un grad
mai jos: ABS(x); x ntreg, rezultatul-modulul lui x; SQR(x); x-ntreg, rezultatul-
p#tratul lui x; TRUNC(x); x-real, rezultatul-partea ntreag# a lui x; ROUND(x); x-
real, rezultatul-valoarea rotungit# a lui x: pentru x>0 round(x)=trunc(x+0,5); pentru
x<0 round (x)= trunc (x-0,5). Deoarece tipul ntreg este ordonat, asupra numerelor
ntregi se pot aplica "i func!iile: SUCC(x); rezultatul: urm#torul num#r ntreg dup# x;
PRED(x); rezultatul: num#rul precedent lui x. Adic# opera!iile "i func!iile ce pot fi
aplicate asupra numerelor ntregi "i dau un rezultat ntreg snt: *; DIV; MOD; +; ;
ABS(X); SQR(X); TRUNC(X); ROUND(X); SUCC(X); PRED(X).
Tipul REAL este mul!imea numerelor reale "i ocup# un loc deosebit printre
tipurile scalare. n particular tipul real nu-i ordonat "i func!iile SUCC(X) "i PRED(X)
nu se aplic#. n compara!ie cu tipul ntreg, tipul real con!ine o submul!ime infinit# de
numere reale. Numerele reale se reprezint# incorect n calculator (cu aproxima!ie).
Din aceast# cauz# "i opera!iile asupra lor se execut# incorect (adic# dup# regulile
aproxima!iei). *i se recomand# ca opera!ia de comparare a valorilor tipului real s# fie
ignorat# din pricina unui rezultat incorect.
Urm#toarele opera!ii au un rezultat real cu condi!ia c# cel pu!in un argument
va fi real, iar cel#lalt ntreg: (+) adunarea; () sc#derea; (*) nmul!irea; (/) mp#r!irea.
Rezultatul va fi real chiar dac# ambii argumen!i vor fi reali. Mai exist# n Pascal
func!ii ce au un rezultat real independent de tipul argumentului: SIN(X); COS(X);
$9
ARCTAN(X); LN(X); EXP(X); SQRT(X). Func!iile ABS(X) "i SQR(X) de
asemenea au rezultat real cu un X real. Formatul numerelor reale este:
Ex.: 7.3450$E+03;
Tipul BOOLEAN con!ine dou# elemente referite prin constantele
predefinite FALSE "i TRUE. Opera!iile predefinite ale acestui tip snt AND,OR "i
NOT "i definesc o structur# de algebr# boolean#. Tipul este succesiv n ordinea:
FALSE<TRUE; 0<$. Opera!iile logice AND(conjunc!ie), OR(disjunc!ie), NOT
(nega!ie) se pot aplica asupra unor argumen!i deasemenea logici "i au un rezultat
logic.
Conjunc!ie: AND: Disjunc!ie: OR: Nega!ie: NOT:
X Y X&Y X Y X vY X X

$ $ $ $ $ $ $ 0
$ 0 0 $ 0 $ 0 $
0 $ 0 0 $ $
0 0 0 0 0 0

n Pascal exist# func!ii ce au un rezultat logic: ODD(X) dac# num#rul
ntreg(x) este impar, rezultatul va fi : true, n caz contrar - false.
EOLN(F) = true dac# cursorul se afl# la sfr"itul unui rnd, altfel - false.
EOF(F) = true dac# cursorul e la sfr"itul fi"ierului, n caz contrar - false.
Tipul CHAR este o mul!ime finit# "i ordonat# de caractere ce con!ine
litere, cifre "i caracterul spa!iu, adic# toate caracterele ASCII. Deoarece tipul char
este o mul!ime ordonat# snt caractere cu index (num#r de ordine) mai mare "i mai
mic. Conform numerelor de ordine elementele tipului char snt aranjate astfel:
A<a<B<b<<Z<z<0<$<<9<?. E posibil# "i altfel de ordine
0<$<2<<9<a<b<c<<z<?<A<B<<Z.
Ordinea conform num#rului de ordine a elementelor tipului CHAR depinde
de realizarea limbajului.
O constant# de tip CHAR este un element al mul!imii CHAR delimitat de apostrof.
Exemplu: 7;f;A.
Pentru reprezentarea direct# "i indirect# a mul!imii CHAR exist# 2 func!ii:
ORD(X)ntoarce num#rul de ordine al caracterului x n mul!imea char.
CHR(I) ntoarce caracterul cu num#rul de ordine i.
n Pascal nu exist# careva opera!ii asupra tipului char care ar avea "i
rezultatul char. Func!iile PRED "i SUCC aici snt valabile. Pentru primul(ultimul)
element al mul!imii char func!ia pred(succ) nu-i determinat#. Asupra elementelor
mul!imii char se pot aplica opera!iile de comparare.

4.2.".2 Tipul enumerare
Un tip enumerat este o mul!ime ordonat# de valori specificate prin
identificatori. Aceast# specificare are forma: (id$, id2,, idn) "i induce o rela!ie de
ordine astfel c# id(i)<id(j) pentru i<j;
Ex.: type lun# =(ianuarie, februarie, martie, aprilie, mai, iunie, iulie, august,
septembrie, octombrie, noiembrie, decembrie);
var a: lun#; B: real;
20
Opera!iile aplicabile elementelor de tip enumerare snt cele rela!ionale(=,<,>,
<=,=>,<>), "i func!iile succ, pred, ord; (ord(id$)=0).

4.2.".3 Tipul subdomeniu (interval)
Fiind dat un tip ordinal, din acest tip se poate genera un nou tip, numit tipul
interval. Defini!ia unui interval indic# valoarea constant# cea mai mic# "i cea mai
mare din interval (n sensul num#rului de ordine) "i cuprinde toate valorile dintre ele.
Sintaxa unui tip interval este
Type nume_tip=valoarea_minim$ . . valoarea_maxim$;
Valoarea minim# trebuie s# fie mai mic# sau egal# cu valoarea maxim#.
Subliniem faptul c# nu este permis# definirea unui interval al tipului real, deoarece
acesta nu este tip ordinal. Exemple de declarare a diferitor intervale:
Type
indice=#..#0; {interval de integer)
Litera='A' .. 'Z' ; {interval de char}
zile=(l,ma,mi,j,v,s,d); {tip de enumerare}
zile_lucrat=l..v; {interval de tip de enumerare}
var:
i:indice; {valori posibile: #,2,,#0}
l:litera; {valori posibile: 'A', 'B', ... ,'Z'}
z: zile_lucrat; {valori posibile: l; ma, ,v}
O variabil# de tip interval mo"tene"te propriet#!ile variabilelor tipului de
baz#, dar valorile variabilei trebuie s# fie numai din intervalul specificat. n cazul,
cnd valoarea variabilei de tip interval nu intr# n limitele intervalului definit,
programul va fi executat incorect sau va fi primit mesajul de eroare.
Dac# este validat# op!iunea de compilare Range Cheking (vezi meniul
Options, comanda Compiler), sau dac# este prezent# directiva de compilare {$R+},
n execu!ie se va verifica apartenen!a valorii unei variabile de tip interval la
intervalul desemnat. n caz de neapartenen!# este semnalat# o eroare de execu!ie "i
programul se opre"te. Implicit nu se efectueaz# nici o verificare. Exemplu:
Program test;
Type cifra=0..9;
var c#,c2,c3:cifra;
Begin
{$R+} c#:=5; {valid}
c2:=c#+3; {valid,c#+3<=9}
{$R-} c3:=25; {invalid, dar nu se semnaleaza eroare}
{$R+} c3:=30; {invalid, se semnaleaza eroare}
end.

4.2.2 Tipuri structurate n Pascal
Pn# n momentul de fa!# s-au prec#utat numai tipurile de date simple(n
special cele scalare). Fiecare valoare a oric#rui din aceste tipuri de date este
cunoscut# "i compus# dintr-o singur# component#. n cazul tipurilor de date
structurate fiecare valoare a oric#rui din tipuri reprezint# o structur# cu valoare
2$
nedeterminat# n sensul c# aceast# valoare are mai mult de o component#. n acela"i
timp orice dat# concret# la rndul s#u deasemenea reprezint# o structur# de date. Mai
pe scurt, tipurile de date structurate reprezint# structuri alc#tuite din cteva elemente
de acela"i tip, n caz simplu fiecare fiind de tip simplu.

4.2.2." Tipul ARRAY
Un tablou (masiv) este un set ordonat a unui num#r fixat de valori
(componente ale masivului). Toate componentele masivului trebuie s# fie de unul "i
acela"i tip care-l numim tipul componentelor sau tip de baz# (pentru masiv). n cazul
componentelor de tip real avem un vector, adic# un masiv real. n cazul
componentelor de tip char, masivul poate fi interpretat ca un rnd de text. De obicei
fiec#rui masiv aparte folosit n program trebuie de-i atribuit un nume. Acest nume l
vom numi variabil# complet# din cauza c# valoarea ei este masivul ntreg. Fiecare
component# a masivului trebuie evident notat# prin indicarea numelor masivului
dup# care urmeaz# selectorul de componente: indexul luat n paranteze p#trate care
red# regula de calculare a num#rului componentei necesare. Deci, pentru referirea la
un element al masivului folosim sintaxa:
< nume masiv>[<index>]; Ex.: x[i];
x[i] se mai nume"te variabil# par!ial# din cauz# c# valoarea ei este o parte
component# a masivului "i nu masivul ntreg. n caz general, n calitate de index
poate fi folosit# o expresie, valoarea c#reia determin# num#rul componentei
masivului. n acela"i timp, n cadrul programului aceast# expresie poate s# ob!in#
diferi!i parametri. n a"a fel, una "i aceia"i variabil# cu index n procesul ndeplinirii
programului poate indica la diferite componente ale masivului.
Not#: Tipul indexului sau a expresiei ce reprezint# indexul trebuie s# fie neap#rat
ordonat. Cele mai mari posibilit#!i pentru prelucrarea masivelor ne ofer# indexul de
tipul: subdomeniu al tipului ntreg.
Sintaxa de declarare a masivului este urm#toarea :
Var : <nume> : array [C$..C2] of <tip>.
unde <nume> - numele masivului; C$,C2 limetele dimensiunii masivului
<tip> - tipul componentelor masivului . Ex. : var: x : array [$..4] of real;
n timp ce componentele masivului pot fi de orice tip, indexul masivului neap#rat
trebuie s# fie tip subdomeniu al tipului ntreg.
Fie un masiv X din 4 elemente. Inscrip!ia X[$] indic# la primul element al masivului
X[2] la al doilea element etc. X[i] la elementul cu indexul i. Anume acest index
este folosit n cadrul ciclului FOR pentru prelucrarea masivelor: FOR i:=$ to N do;
n Pascal nu exist# nici o restric!ie n ceea ce prive"te tipul elementului masivului.
Este necesar numai ca toate elementele s# fie de acela"i tip. n particular, elemente
ale unui masiv pot fi de asemenea masive. *i dac# aceste din urm# snt compuse din
elemente scalare, atunci avem un masiv bidimensional numit "i matrice. Dac# la
urm#toarea etap# elementele masivului snt de asemenea masive ,atunci avem un
masiv tridimensional. Sintaxa de declarare a unui masiv bidimensional este:
ARRAY [<tip index>] OF <tip element>;
Deoarece elementele masivului snt de asemenea masive, avem
ARRAY [<tip index>] OF ARRAY [<tip index>] OF <tip scalar>;
22
Aceast# sintax# poate fi exprimat# n urm#toarea form#:
ARRAY [C$..C2 , C3..C4] OF <tip scalar>;
unde C$,C2,C3,C4 - m#rimile masivului (limitele dimensiunii).
Ex.: X:ARRAY [$..$0, $..20] OF real;
i j
Deoarece avem "i linii "i coloane exist# doi indici: i "i j.

4.2.2.2 Tipul #ir de caractere
Pentru prelucrarea unor seturi de caractere, cuvinte, propozi!ii n Turbo Pascal
este folosit tipul de date "ir de caractere numit string. Valoarea unei variabile de acest
tip este format# dintr-un num#r de caractere oarecare. Din cauza, c# variabila de acest
tip are ca valoare cteva elemente de tip simplu ("i anume de tip char), tipul string
este un tip structurat (compus).
Tipul "ir de caractere se specific# prin string[lungime] sau folosind numai cuvntul
string. Exemplu:
Var a:string[lungime]; b:string;
n primul caz "lungime" reprezint# lungimea maxim# a "irului de caractere,
avnd valori de la 0 la 255. Un tip "ir de caractere f#r# specificarea atributului de
lungime reprezint# de fapt un "ir de lungime implicit egal# cu 255. Variabilele de tip
string[lungime] pot avea ca valori orice "iruri de caractere a c#ror lungime nu
dep#"e"te lungimea declarat#. Lungimea unui "ir de caractere n unele cazuri este
necunoscut#. Ea poate fi schimbat# pe parcursul realiz#rii programului, sau fiind
declarat# variabila de tip string f#r# specificarea lungimii . Pentru a determina
valoarea actual# a lungimii unei variabile de tip string n Pascal este folosit# func!ia
standard Length. Exemplu:
Var a#:string[#0]; a2:string; n#,n2:integer;
Begin a#:=Programare; a2:=Radioelectronica;
n#:=Length(a#); {n#=#0} n2:=Length(a2); {n2=#6}
Writeln (Lungimea a# este:,n#); Writeln (Lungimea a2 este:,n2); end.
Dup# cum se vede din exemplu valoarea returnat# de func!ia Length este de tip
ntreg, n a"a mod determinnd num#rul de caractere ce se con!in n variabila de tip
string.
Variabilele de tip "ir de caractere snt memorate n loca!ii succesive de
memorie, pe lungime+$ octe!i, unde octetul de nceput con!ine lungimea actual# a
"irului de caractere. Anume din acest octet de nceput este luat# valoarea lungimii
actuale a "irului de caractere de c#tre func!ia Length. Aceast# valoare poate fi
modificat# de programator, printr-o instruc!iune de atribuire de forma: sir[0]:=#nr
sau sir[0]:=chr(ord(nr)); unde nr este cuprins ntre 0 "i lungime maxim# admis#.
Dac# nr are valoarea zero, "irul este considerat vid.
O variabil# de tip "ir poate fi folosit# fie n totalitatea ei, fie par!ial, prin
referirea unui caracter din "ir. n primul caz referirea se face numai prin numele
variabilei, n cel de-al doilea caz trebuie specificat# ntre paranteze p#trate pozi!ia
caracterului din "ir, cu o construc!ie de forma [expresie], unde rezultatul expresiei
trebuie s# fie o valoare ntreag# n intervalul 0 "i lungimea declarat# a "irului. De
exemplu:
23
Var a:string[#5];
Begin a:=student; n:integer;
Writeln (primul caracter:,a[#]); {ca rezultat litera s}
n:=Length(a); Writeln(Ultimul caracter:, a[n]); {ca rezultat litera t}
writeln(caracterul din mijloc:, a[n-(ndiv2)]); {ca rezultat litera d} end.
Asupra "irurilor de caractere se poate efectua opera!ia de concatenare, notat#
cu +. Dac# s "i t snt doi operanzi de tip "ir de caractere sau char, rezultatul
concaten#rii s+t este compatibil cu orice tip "ir de caractere (dar nu "i cu tipul char).
Dac# lungimea "irului rezultant dep#"e"te 255 de caractere, "irul se trunchiaz# dup#
caracterul cu num#rul de ordine 255. Exemplu:
Program sir;
var s#:string[#0]; s2:string[20]; l:integer;
begin s#:'Turbo'; s2:=sl+'Pascal'; #:=length(s2);
writeln(s2); writeln('Lungime actuala =',#); end.
Operatorii rela!ionali =, <>, <,> , =, >= "i <= compar# "iruri de caractere, n
conformitate cu ordonarea setului extins de caractere ASCII. Deoarece toate "irurile
de caractere snt compatibile, pot fi comparate dou# valori arbitrare de tip "ir.O
valoare de tip caracter este compatibil# cu o valoare de tip "ir de caractere; cnd
aceste valori snt comparate, valoarea de tip caracter este considerat# ca "i cum ar fi
un "ir de lungime $.

4.2.2.3 Tipul set
n Pascal o variabil# de tip set este echivalat# cu o mul!ime. Un tip set
(mul!ime) se define"te n raport cu un tip de baz#, care trebuie s# fie un tip ordinal.
Fiind dat un asemenea tip de baz#, valorile posibile ale tipului set snt formate din
mul!imea tuturor submul!imilor posibile ale tipului de baz#, inclusiv mul!imea vid#.
Tipul mul!ime se define"te astfel: type numeTip=set of tip_de_baza
unde tip_de_baz# este tip ordinal (char, interval, enumerare, boolean, byte). Cu
toate c# tipurile ntregi snt ordinale, nu este permis dect tipul set of byte.
Dac# tipul de baz# are n valori, tipul mul!ime va avea 2 la puterea n valori, cu
restric!ia c# n<=256.
Exemplu:
Type cifre=5..7; {tip interval}
mult=set of cifre; {tip mul"ime}
var m:mult; {variabil! de tip mul"ime}
Variabila m de tip mul!ime poate avea 8 valori, "i anume mul!imea tuturor
submul!imilor posibile ale tipului mult, inclusiv mul!imea vid#. Aceste valori snt:
[5], [6], [7], [5,6], [5,7], [6,7], [5,6,7] "i [ ], ultima valoare reprezentnd mul!imea
vid#.
O valoare de tip mul!ime poate fi specificat# printr-un constructor (generator)
de mul!ime. Un constructor con!ine specificarea elementelor separate prin virgule "i
nchise ntre paranteze p#trate. Un elemnt poate s# fie o valoare precizat# sau un
interval de forma inf. - sup., unde valorile inf "i sup precizeaz# valorile limitelor
inferioare "i superioare. Att elementul ct "i limitele de interval pot fi expresii.
Dac# sup<inf, nu se genereaz# nici un element.
24
Exemplu:
Program exemplu;
type octet=0..255; {tip interval}
numar=set of octet; {tip mul"ime}
cuvint=set of char; {tip mul"ime}
culoare=(alb,gri,negru); {tip enumerare}
nuanta=set of culoare; {tip mul"ime}
var: n:numar; c:cuvint; a:nuanta; i:integer;
begin n:=[2..4,8,#0..#2]; {elementele din constructor:2,3,4,8,#0,##,#2}
i:=#0; n:=[i-#..i+#, 2*i, 30]; {elemente:9,#0,ll,20,30}
c:=['A'..'C','K','S']; {elementele:'A','B','C','K','S'}
a:=[alb,gri]; { elementele: alb, gri} end.
Dac# tipul de baz# are n valori, o variabil# de tip mul!ime corespunz#toare
tipului de baz# va fi reprezentat# n memorie pe n bi!i, depu"i ntr-o zon# de memorie
continu# de: (n div 8)+$ octe!i, dac# n nu este divizibil cu 8; "i (n div 8) octe!i, dac#
n este divizibil cu 8. De exemplu, set of char va fi reprezentat pe 256 div 8, adic# pe
32 octe!i.
Opera!iile care se pot face cu valorile tip mul!ime snt:
Reuniunea: o valoare de tip ordinal c este n a+b, dac# c este n a sau b.
Diferen"a: o valoare de tip ordinal c este n a-b dac# c este n a "i nu n b.
Intersec"ia: o valoare de tip ordinal c este n a*b, dac# c este n a "i n b.
Rela!ii referitoare la mul!imi: Dac# a "i b snt operanzi tip mul!ime, rela!ia
a = b este adev#rat# numai dac# a "i b con!in exact aceia"i termeni; altfel aob.
a <= b este adev#rat# dac# fiecare termen al lui a este de asemenea un termen al lui b.
a >= b este adev#rat# dac# fecare termen al lui b este de asemenea un termen al lui a.
Rela!ia de apartenen!# este aplicabil# n cazul mul!imilor. Fiind X o variabil#
de tip ordinal t, iar a o variabil# de tip mul!ime (a c#rei mul!ime de baz# este
compatibil# cu t), rela!ia (X in a) este adev#rat#, dac# X este element al mul!imei a.
n opera!iile "i rela!iile de mai sus a "i b trebuie s# fie mul!imi compatibile.
Dac# not#m cu elmin cea mai mic# valoare ordinal# a rezultatului unei opera!ii
cu mul!imi, iar cu elmax cea mai mare valoare ordinal# a opera!iei, tipul rezultatului
este set of a..b. Constructorii pot fi folosi!i pentru scrierea mai complet# a unor
condi!ii. De exemplu, dac# ch este o variabil# de tip caracter, condi!ia:
if (ch= T) or (ch='U') or (ch='R') or (ch='B') or (ch='O') then {...}
poate fi exprimat# prin: if ch in ['T','U','R','B','O'] then {...}
iar condi!ia if (ch='0') and (ch<='9') then {...} poate f exprimat# prin:
if ch in [
r
0'..'9'] then {...}
Exemplu: Verificarea opera!iilor cu mul!imi:
program opmult;
type multime=set of #.. #0;
var a,b,int,reun,dif: multime; i:integer;
begin a:=[#..3,7,9,#0]; b:=[4..6,8..#0];
int:=a*b; {9,#0} reun:=a+b; {#..#0} dif:=a-b; {l,2,3,7}
writeln(''intersec"ie'); for i:=# to #0 do if i in int then writeln(i);
writeln('reuniune'); for i:=# to #0 do if i in reun then writeln(i);
25
writeln('diferen"a'); for i:=# to #0 do if i in dif then writeln (i);
end.

4.2.2.4 Tipul articol
Pn# n momentul de fa!# au fost studiate tipurile de date compuse, elementele
c#rora apar!ineau aceluia"i tip de date (simplu sau de asemenea compus). n cazul
unui masiv, toate elementele masivului erau de acela"i tip (integer, real, char etc.)
f#r# a fi posibil# atribuirea diferitor elemente ale masivului valori de diferite tipuri.
ns# deseori apar situa!ii, cnd este necesar# prelucrarea "i p#strarea unei informa!ii
mai complexe, a"a ca: informa!ia despre o persoan#, despre reu"ita unui student,
orarul lec!iilor etc. Dac# prec#ut#m cazul cu reu"ita unui student, atunci este simplu
de presupus c# vor fi necesare urm#toarele date: numele studentului, grupa, notele la
examenele unei sesiuni, balul mediu calculat. Aceste date snt legate ntre ele prin
faptul c# apar!in aceleia"i persoane. Ca urmare ar fi justificat# tratarea lor ca o
singur# valoare compus#. ns# tipurile datelor difer# ntre ele: numele "i grupa vor fi
de tip string, notele la examene tip integer, iar balul mediu de tip real. n
consecin!# nu putem grupa aceste componente ca un tablou, care reprezint# o
structur# omogen#. Gruparea lor o permite structura de nregistrare n Pascal numit#
tip articol.
Tipul articol este un tip compus format dintr-un num#r de componente,
numite cmpuri. Num#rul componentelor poate s# fie fix sau variabil. n cazul
num#rului de componente fix se spune c# avem o structur# fix#, n cel de-al doilea
caz avem o structur# cu variante.
Spre deosebire de tablouri, cmpurile pot f de tipuri diferite. Fiecare cmp are un
nume (identificator de cmp) "i un tip (numit tip de cmp), de asemenea cum "i toat#
structura articol "i are numele s#u.
Forma general# a unei structuri cu articole fixe este:
nume_articol = record ;
nume_cmp_l :tip_cmp_#;
nume_cimp_2 : tip_ cmp_2;

nume_cmp_n : tip_ cmp_n;
end;
De exemplu:
type data=record
an:#900..2000;
luna:(ian,feb,mar,apr,mai, iun, iul, aug, sep, oct, nov, dec);
ziua:#..3#;
end;
var ast!zi:data;
Tipul unui nume de cmp este arbitrar, astfel un cmp poate s# fie la rndul lui tot de
tip articol, deci se pot defini tipuri imbricate. Exemplu:
Type ntlnire = record
cnd:data; {tip articol}
ora: real;
26
unde:string[20];
end;
var a:ntlnire;
Un nume de cmp trebuie s# fie unic numai n tipul articol n care a fost definit.
Deci, dac# n program evem declarate mai multe articole, atunci numele cmpurilor
din eceste articole pot s# se repete, adic# s# fie acelea"i, cu condi!ia c# numele
articolelor vor fi unice. Exemplu:
Type student#=record
Nume: string; Grupa: string; Nota#: integer; Nota2:integer; Media: real;
End;
student2=record
Nume: string; Grupa: string; nota#: integer; nota2:integer; nota3:integer;
media: real;
End;
Pentru u"urarea redact#rii programelor, declararea cmpurilor de acela"i tip ale unui
articol se face ca "i n cazul declar#rii ctorva variabile simple de acela"i tip ele snt
desp#r!ite prin virgul#. Exemplu:
Type student=record
Nume, Grupa: string; nota#, nota2, nota3: integer; media: real;
End;
Valorile variabilelor de tip articol pot lua parte la diferite opera!ii, calcule,
formule. ns# aceste valori nu snt valorile articolului ntreg, ci valorile concrete ale
cmpurilor articolului. Un cmp al unei variabile de tip articol este referit prin numele
variabilei "i numele de cmp, separate printr-un punct. Exemplu:
Ast!zi.an:=#99#; ast!zi.luna:=nov; ast!zi.ziua:=#3; a.ora:=#3,40; a.cnd.ziua:=5;
Operatiile care pot fi efectuate asupra cmpurilor tipului articol snt opera!iile
aplicabile tipului de date, c#rui i apar!ine cmpul corespunz#tor. Exemplu:
Calcularea balului mediu la sesiune al unui student
Program p#;
Type student=record
Nume, Grupa: string; nota#, nota2, nota3: integer; media: real;
End;
Var a:student;
Begin a.nume:=vasile; a.grupa:=ABC-98#;
a.nota#:=8; a.nota2:=9; a.nota3:=7;
a.media:=( a.nota#+ a.nota2+ a.nota3) / 3; writeln(media=,a.media);
end.
Pentru a u"ura scrierea anevoioas# n cazul referirii unui cmp al articolului
prin nume de variabile "i cmpuri separate prin punct se poate folosi instruc!iunea
with. Ea permite o referire prescurtat# a cmpurilor unui articol. n interiorul unei
instruc!iuni with cmpurile uneia sau a mai multor variabile de tip articol pot fi
referite folosind numai numele cmpurilor lor. Sintaxa instruc!iunii este: with
list!_de_variabile_tip_articol do instruc"iune;
unde" list#_de_variabile_tip_articol" este una sau mai multe variabile tip articol,
referirea c#rora va avea loc prin intermediul instruc!iunii with. Exemplu:
27
type calendar= record
an:#990.. 2000; luna:#..#2; ziua:#..3#; end;
var data:calendar;
begin with data do
if luna = #2 then begin
luna:=l; an:=an+l;
end;
else luna=luna+#;
end.
Aceast# instruc!iune este echivalent# cu urm#toarea:
if data.luna = #2 then begin
data.luna:=#;
data.an:=data.an+#; end
else data.luna:=data.luna+#;
n interiorul unei instruc!iuni with, la ntlnirea unui nume de variabil# prima dat# se
testeaz# dac# variabila poate fi interpretat# ca un nume de cmp al unui articol. Dac#
da, variabila va fi interpretat# ca atare, chiar dac# n acel moment este accesibil# "i o
variabil# avnd acela"i nume
Type punct = record
x,y:integer; end;
var x:punct; y:integer;
n cazul nostru att x, ct "i y, pot s# reprezinte fe o variabil#, fe un cmp al
articolului. Dar n instruc!iunea: with x do begin x:=l; y:=2; end;
identificatorul x situat ntre with "i do se refer# la variabila de tip articol x, iar
identificatorul x ntre begin "i end se refer# la variabila de tip integer, adic# la cmpul
articolului. n cazul necesit#tii referirii din una "i aceia"i instruc!iune with a mai
multor variabile tip articol se procedeaz# n felul urm#tor:
with vl,v2,...,vn do instructiune;
Aceast# instruc!iune este echivalent# cu urm#toarea:
with vl do with v2 do {...} with vn do instructiune;
Articol cu variante. Uneori apare necesitatea s# se includ# n structura unui
articol informa!ii care depind de o alt# informa!ie deja prezent# n articol. Fie c# se
prelucreaz# informa!ia despre 3 persoane n ceea ce prive"te numele, salariul "i
preg#tirea profesional#. Preg#tirea profesional# poate fi elementar#, medie "i
superioar#. *i este impus# urm#toarea condi!ie: (a)dac# preg#tirea este superioar#,
atunci apare necesitatea de informa!ia despre anul absolvirii "i validitatea licen!ierii ;
(b)dac# preg#tirea este medie, atunci se mai adaog# "i balul mediu de absolvire;
(c)dac# preg#tirea este elementar#- nu trebuie nici o informa!ie suplimentar#.
Problema aceasta poate fi rezolvat# cu ajutorul articolului cu structur# fix#, declarnd
toate cmpurile susnumite "i folosindu-le numai n caz de necesitate. n acest caz
unele cmpuri vor fi declarate, dar nu vor fi folosite n program, ceea ce duce la
folosirea nera!ional# a resurselor calculatorului. n Pascal exist# tipuri articol, care au
o structur# flexibil# (cu variante). *i anume n cazul respect#rii unei condi!ii anumite
apare cmpul necesar ad#ug#tor, iar n cazul, cnd condi!ia nu este respectat#, n
28
componen!a articolului acest cmp lipse"te. Astfel de tipuri snt articole cu variante.
Forma general# a unei astfel de structuri este:
Nume_articol = record
nume_cmp_l :tip_l; {cmpurile fixe}

nume_cmp_n:tip_n;
case
cmp_sel:tip_sel of {cmpuri variabile}
const_#:(cmp_var#_# : tip_var#_#; cmp_var#_2 : tip_var#_2; cmp_var#_n :
tip_var#_n) const_2:(cmp_var2_# : tip_var2_#; cmp_var2_2 : tip_var2_2;
cmp_var2_m : tip_var2_m)
end;
Diferitele variante snt selectate de valorile posibile ale lui tip_sel (tip selector)
al cmpului cmp_sel (cmp selector). Fiecare din variant# este "etichetat#". Aceste
"etichete" notate mai sus cu const_l, const_2, ... con!in diferite valori ale tipului
selector; valorile specificate pot fi scrise "i sub forma de interval de valori, astfel:
inf. - sup. Fiecare valoare a tipului selector trebuie s# apar# ntr-una din aceste
"etichete".
Dac# o variant# este vid#, adic# nu are nici un cmp, forma ei este const: ( ) O
list# de cmpuri poate s# con!in# numai o singur# clauz# case, plasat# dup# cmpurile
fixe. Tipul selector trebuie s# fie ordinal.
Exemplu: Type studii =(elem,medii,sup);
inform=record
Nume:string[20];
salar:5000..#5000;
Case preg : studii of
{preg-cmp selector, studii-tip selector. Cpmul preg de tip studii}
elem:(); {nu avem nici un cmp, variant! vid!}
medii:(bal: real);
{ dac! cmpul selector = medii, atunci apare un cmp nou: bal tip real}
sup:(an_abs:#950..2000; licen"a:boolean) {cnd preg=sup}
end;
var x,y,z:inform;
begin
x.nume:='JOHN'; x.salar:=6 0 0 0; x.preg:=elem;
y.nume:='MARY'; y.salar:=7000; y.preg:=medii; y.bal:=8.50;
z.nume:='BILL'; z.salar:=8000; z.preg:=sup;z.an_abs:#990; z.licen"a:=true;
end.
Numai o singur# variant# poate s# fie activ# la un moment dat. Astfel, dac# este
activ# varianta medii, prin y.preg: = medii, nu are sens o atribuire de forma
y.anabs:=$980.
Lungimea unei variabile de tip articol este egal# cu lungimea p#r!ii fixe propriu
zise plus lungimea cmpului selector, plus lungimea celei mai mari p#r!i variabile ( n
caz c# exist#).
29
4.2.2.5 Tipul reper
n timpul de ast#zi problema memoriei n tehnica de calcul este cea mai
stringent#. Pe parcursul dezvolt#rii sale tehnica de calcul se perfec!ioneaz# "i pune la
dispozi!ia utilizatorului posibilit#!i mai vaste de lucru. Odat# cu dezvoltarea tehnicii
de calcul se dezvolt# cu pa"i gigan!i "i asigurarea soft a ei. Astfel apar noi aplica!ii
cu cerin!e mai mari c#tre resursele calculatorului. n cele mai dese cazuri problema
folosirii acestor aplica!ii const# n insuficien!a memoriei operative RAM. Astfel de
situa!ii pot ap#rea "i n cazul program#rii Pascal, cnd se prelucreaz# un volum mare
de date "i programele devin voluminoase "i complicate necesitnd un volum mare de
memorie RAM. Pentru a"a cazuri Pascal "i are instrumentul s#u numit variabile
dinamice.
n Turbo Pascal variabilele pot fi statice sau dinamice. Variabilele statice snt
alocate n memorie n timpul compil#rii, iar locul ocupat de ele n memorie nu poate
fi modificat n execu!ie; ele exist# pe durata ntregii execu!ii a blocului (program,
procedur#, func!ie). ns# n Pascal exist# variabile care pot fi create "i distruse
dinamic n timpul execu!iei programului; o astfel de variabil# este denumit# variabil#
dinamic#.
Crearea "i distrugerea variabilelor dinamice se realizeaz# cu procedurile New
"i GetMem respectiv Dispose "i FreeMem. Aceste proceduri aloc#, respectiv
elibereaz# spa!iu de memorie pentru variabilele dinamice. Adresa zonei de memorie
alocat# unei vanabile dinamice va fi depus# ntr-o variabil# de tip special, numit
reper. Lungimea zonei de memorie atribuit# unei variabile dinamice depinde de tipul
variabilei dinamice: n func!ie de tip se aloc# un num#r variabil de octe!i variabilei
respective. De exemplu, dac# tipul variabilei dinamice este ntreg, se aloc# 2 octe!i,
dac# tipul este real, se aloc# 6 octe!i. n consecin!#, variabila de tip reper care va
con!ine adresa zonei alocate variabilei dinamice trebuie s# comunice procedurilor de
alocare de memorie tipul variabilei dinamice. Men!ion#m c# variabilele dinamice snt
alocate ntr-o zon# special# de memorie, denumit# "heap".
Definirea unui tip reper se poate face n sec!iunea type, n felul urm#tor:
type nume_reper = ^tip_variabil!_dinamic!;
unde semnul ^ semnific# o adres#. Mul!imea valorilor reper de tip "nume_reper"
const# dintr-un num#r nelimitat de adrese; fiecare adres# identific# o variabil# de tip
"tip_variabil#_dinamic#". La aceast# mul!ime de valori se mai adaog# o valoare
special#, numit# nil, care nu identific# nici o variabil#.
Limbajul permite ca n momentul ntlnirii tipului variabilei dinamice acesta s#
nu fie cunoscut nc# (referire nainte); acest tip ns# trebuie declarat mai trziu, n
aceea"i declara!ie de tip. De exemplu, secven!a urm#toare este corect#:
Type rep = ^art; {referire inainte}
art = record x,y:integer; end;
var r#,r2:rep; {reperarea variabilelor tip art}
r3:^integer; {reperarea var. dinamice}
r4:^char; {de tip intreg si caracter}
O alt# facilitate a limbajului const# n posibilitatea utiliz#rii tipurilor care se
autorefer# (snt definite recursiv). De exemplu,
type lista = ^articol; articol = record
30
a,b: integer; urmator : lista; end;
var : l:lista;
Aici tipul reper "lista" repereaz# un tip "articol", n care cmpul "urm#tor" la rindul
lui este de asemenea de tip "list#". Aceast# facilitate poate fi folosit# de exemplu la
alc#tuirea listelor nl#n!uite.
Dup# crearea unei variabile dinamice a c#rei adres# este depus# ntr-o variabil#
de tip reper, ea poate fi accesat# prin a"a zisa dereperare: numele variabilei de tip
reper este urmat de semnul ^. Acest semn poate urma "i dup# un alt calificator (de
cmp, de tablou, etc.).
Dereperarea unei variabile de tip reper cu con!inut nil declan"eaz# o eroare de
execu!ie. Variabilele de tip reper snt alocate pe 4 octe!i (2 octe!i pentru memorarea
adresei de segment, 2 octe!i pentru memorarea deplasamentului).
Opera!iile rela!ionale care snt permise cu operanzii de tipul reper compatibile
snt = "i < >. Dac# p$ "i p2 snt dou# valori tip reper compatibile, rela!ia pl =p2 este
adev#rat# dac# snt egale p#r!ile de segment "i de deplasament. Astfel pot exista dou#
valori de tip reper care indic# aceea"i loca!ie, dar totu"i ele nu snt egale n sensul de
mai sus. 'De exemplu, $0040:$0049 "i $0000:30449 indic# aceea"i adres# fizic#,
totu"i n sensul limbajului ele nu snt egale. Adresele returnate de procedurile New "i
Getmem snt totdeauna normalizate, adic# partea de deplasament este n intervalul
$0000...$FFFF. Astfel compar#rile vor fi efectuate corect. Cnd ns# valorile de reper
snt create cu func!ia Ptr, trebuie de acordat o mare aten!ie la compararea lor,
deoarece deplasamentele nu snt neap#rat normalizate. Exemplul $:
Opera!ii simple cu variabile dinamice:
type pc=^char; pintrg= ^ integer; pcmp=^art;
art=record x:integer; y:array[$..2] of integer; end;
var c:pc; intrg:pintrg; cmp:pcmp;
begin new(c); {crearea unei var. dinamice tip caracter}
c^ :='*'; {inc!rcarea variabilei create}
new(intrg); {crearea unei variabile dinamice}
intrg^:=#23; {de tip ntreg $i nc!rcarea ei}
new(cmp); {crearea unei variabile dinamice}
cmp^.x:=4; {de tip articol $i ncarcarea}
cmp^.y[#]:=5; {cmpurilor variabilei}
cmp^.y[2] :=6; {...}
writeln(c^); writeln(intr^); write(cmp ^.x); write(' ',cmp^.y[#]);
writeln(' ',cmp^.y[2]); {variabilele dinamice nu mai snt necesare}
dispose(cmp); {distrugerea variabilei dinamice}
dispose(intrg);
dispose (c); {se poate reutiliza spa"iul de memorie ocupat anterior}
{} end.

4.2.2.6 Tipul pointer
Tipul predefinit pointer este un tip reper f#r# tip de baz#. Astfel, o variabil# de
acest tip poate s# repereze o variabil# de orice tip, motiv pentru care acestui tip i se
mai spune "i tip reper liber. Declararea unei variabile de acest tip se face de exemplu
3$
astfel: Var a:pointer; Variabilele de tip pointer nu pot fi dereperate: scrierea
simbolului ^ dup# o astfel de variabil# constituie o eroare. Variabilele de tip pointer
snt utilizate pentru memorarea valorii unor variabile de tip reper legat. Unei variabile
de acest tip i poate fi atribuit# "i valoarea predefinit# nil. Observa!ie: Valori de tip
reper pot fi create $i cu operatorul @ ,$i cu func"ia standard Ptr. Aceste valori snt
tratate ca $i cum ele ar fi repere pentru variabile dinamice.
Exemplu: program test;
type e=integer; pe=^e; pin=^integer;
var alfa:e; beta:integer; p,p#:pointer; vpe:pe; vpi:pin;
begin writeln(Test cu tipul pointer);
alfa:=5; beta:=6;
vpe:=@alfa; vpi=@beta;
writeln('alfa=',vpe^, 'beta=', vpi^);
p#:=@alfa;
{writeln('alfa=',p2^); {eroare 64: Cannot Read or Write variables of this type }
{(Nu pot fi citite sau scrise variabile de acest tip) }
{alfa#^:=p#^}; {eroare 26:Type mismatch (Incompatibilitate de tip) }
p:=@beta; vpi:=p; vpe:=p#; writeln('alfa=',vpe^,'beta=',vpi^);
readln; end.
Pe ecran vor fi afi"ate urm#toarele rezultate:
Test cu tipul pointer
alfa=5 beta=6
alfa=5 beta=6

4.2.2.7 Fi#iere n Pascal
4.2.2.7." Generalit$!i despre fi#iere.
Prin fi"ier n general se n!elege o structur# de date care const# dintr-o secven!# de
componente. Fiecare component# din secven!# are acela"i tip. Num#rul acestor
componente nu este fixat. Aceasta este o caracteristic# prin care se distinge clar
fi"ierul de tablou. La un moment dat ns#, este accesibil# direct numai o singur#
component# a secven!ei. Celelalte componente snt accesibile progresnd secven!ial n
fi"ier. Progresarea n componentele unui fi"ier se realizeaz# prin subprograme de
citire "i de scriere. Datele fi"ierului snt stocate de obicei pe un suport magnetic. n
limbajul Pascal, pot fi definite trei structuri de tip fi"ier: $)fi"ier cu tip; 2)fi"ier text;
3)fi"ier f#r# tip.
S# not#m cu f o variabil# de tip fi"ier. nainte ca variabila s# fie utilizat#, ea
trebuie asociat# cu un fi"ier extern, prin apelul procedurii Assign. n general, fi"ierul
extern este un fi"ier pe disc, dar variabila de fi"ier poate fi asociat# "i cu un dispozitiv
(de exemplu tastatura, ecran). Fi"ierul extern marcheaz# informa!iile scrise n fi"ier
sau furnizeaz# informa!iile depuse. Dup# ce s-a stabilit asocierea cu un fi"ier extern,
fi"ierul trebuie "deschis". Aceast# deschidere preg#te"te fi"ierul pentru citire "i/sau
scriere. Un fi"ier existent poate fi deschis cu ajutorul procedurii Reset. Un fi"ier nou
poate fi deschis cu procedura Rewrite. Fi"ierele de tip text deschise cu Reset permit
doar opera!ii de citire; fi"ierele de tip text deschise cu procedura Rewrite sau Append
permit numai opera!ii de scriere. Fi"ierele cu tip sau f#r# tip permit att citirea ct "i
32
scrierea, indiferent dac# ele au fost deschise cu Rewrite sau cu Reset. Fi"ierele text
standard Input "i Output snt deschise automat n momentul n care ncepe execu!ia
programului. Input este un fi"ier text care permite numai opera!ii de citire "i este
asociat cu claviatura. Output este un fi"ier text care permite numai opera!ii de scriere
"i este asociat cu ecranul. Fiecare fi"ier este o secven!# liniar# de componente,
fiecare component# avnd tipul de baz# al variabilei fi"ier. Fiecare component# a
f"ierului are asociat un num#r, numit num#rul componentei. Prima component# a
f"ierului este considerat# avnd num#rul de component# zero. Cea de a doua
component# are num#rul $ ".a.m.d. n mod normal accesul la componentele fi"ierului
este secven!ial. Aceasta nseamn#, c# atunci cnd se cite"te o component# cu ajutorul
procedurii standard Read, sau cnd se scrie o component# cu ajutorul procedurii
standard Write, pozi!ia curent# de fi"ier se deplaseaz# la urm#toarea component#, n
sensul ordon#rii numerice. In afar# de acest mod de acces, fi"ierele cu tip "i fi"ierele
f#r# tip permit "i accesul direct (aleator) la componentele fi"ierului. Accesul direct se
bazeaz# pe procedura de c#utare Seek, care mut# pozi!ia curent# n fi"ier pe o
component# specificat#. Dup# aceast# pozi!ionare componenta astfel aleas# poate fi
citit#. Func!iile standard FilePos "i FileSize permit determinarea pozi!iei curente n
fi"ier, respectiv a dimensiunii actuale a fi"ierului. Cnd prelucrarea componentelor
unui fi"ier se termin#, fi"ierul trebuie nchis cu procedura standard Close. Dup# ce
fi"ierul a fost nchis, se vor actualiza datele fi"ierului extern asociat. Dup# fiecare
apel de procedur# "i func!ie stndard de intrare/ie"ire se testeaz# automat reu"ita
opera!iei de intrare/ie"ire. n cazul n care apare o eroare, programul se termin# "i se
afi"az# un mesaj de eroare n execu!ie. Directiva de compilare $I permite ca aceast#
eroare s# fie tratat# n program. n stare decuplat# {$I-}, programul nu se opre"te la o
eroare de intrare/ie"ire. Pentru a analiza cauza erorii, se apeleaz# func!ia standard
IOResult, care n caz de opera!ie reu"it# returneaz# valoarea zero, iar n caz de e"ec
returneaz# o valoare diferit# de zero, care codifc# natura erorii.
*tergerea fi"ierului extern asociat unui fi"ier nchis poate fi realizat# cu
procedura Erase. n procesul de citire a unui fi"ier, faptul c# s-a ajuns la sfr"itul
fi"ierului poate fi urm#rit cu func!ia Eof. Aceast# func!ie returneaz# valoarea logic#
true dac# s-a ajuns la sfr"itul fi"ierului, respectiv false n caz contrar.

4.2.2.7.2 Fi#iere cu tip
Fi"ierul cu tip este o secven!# de componente, fiecare component# avnd
acela"i tip, numit tipul de baz# al fi"ierului. 0 vanabil# de acest tip poate fi declarat#
printr-o declara!ie de forma:
var nume_fi$ier : file of tip_de_baz; unde tip_de_baz# este un tip arbitrar,
exceptnd tipul fi"ier.
Exemplul $: Crearea unui fi"ier cu tip cu nume extern persoana.txt. Componentele
snt de tip articol, cu informa!iile referitoare la angaja!ii unui institut.
Program fi$iercutip;
type angajat=record
marca:integer; nume:string[20]; salar:integer; end;
var f:file of angajat; { variabila f este un fi$ier tip articol}
a:angajat; contin:char; k:integer; {r!spunsul operatorului}
33
begin
assign(f , 'persoana.txt'); {asocierea variabilei f cu fi$ierul de pe disc persoana.txt}
rewrite(f); {deschiderea fi$ierului pentru prima dat!}
repeat writeln('marca='); readln(a.marca);
writeln('nume=' ); readln(a.nume);
writeln('salariu='); readln(a.salar);
write(f,a); {scriere de componenta n fi$ier}
writeln('Continuam? d/n' ); readln(contin);
until upcase(cont)='N';
k:= filesize(f) {func"ia FilSize determin! m!rimea actual! a fi$ierului}
writeln('Numarul de componente n fi$ier=',k);
close(f); {nchiderea fi$ierului}
end.
Exemplul 2. Acces direct la fi"ierul persoana.txt. Se livreaz# informa!iile referitoare
la un angajat, pe baza num#rului de component# asociat unui angajat.
Program accesdirect;
type angajat=record
marca:integer; nume:string[20]; salar:integer; end;
var f :file of angajat; a:angajat; fs:integer; nr:integer;
begin
assign(f,persoana.txt) {asocierea variabilei f cu fi$ierul de pa disc persoana.txt}
reset(f); {deschiderea fi$ierului existent pentru citire/scriere}
fs:=filesize(f); {func"ia FilSize determin! m!rimea actual! a fi$ierului}
writeln('nr.componentei='); readln(nr);
if nr>fs then writeln('eroare, fi$ierul e mai mic') else
begin seek(f,nr); {pozi"ionare pe componenta cu num!rul nr.}
read(f,a); {citirea compnentei selectate din fi$ier}
writeln('marca=',a.marca); writeln('nume=', a.nume); writeln('salar=',a.salar);
end; close(f); {nchiderea fi$ierului}
end.

4.2.2.7.3 Fi#iere de tip text
Fi"ierul text con!ine caractere structurate pe linii, fiecare linie fiind terminat#
cu un caracter de sfr"it de linie (EOLN caracter). Lungimea liniilor este variabil#.
Caracterul de sfr"it de linie este de regul# CR[ENTER] (ASCII #$3). Un fi"ier text
este terminat cu un caracter de sfr"it de fi"ier CTRL-Z. Un fi"ier text este declarat
prin tipul predefinit text, de exemplu: var f:text. Un fi"ier text nu este echivalent cu
un fi"ier de tip file of char. Lungimea liniilor fiind variabil#, pozi!ia unei linii n
cadrul fi"ierului nu este calculabil#. n consecin!#, la fi"iere text accesul nu poate fi
dect secven!ial. Asocierea numelui fi"ierului la suportul extern este realizat# cu
procedura Assign. Deschiderea fi"ierului poate fi realizat# prin trei subprograme
standard. Un fi"ier nou se deschide cu procedura Rewrite, un fi"ier existent poate fi
deschis fie la nceputul fi"ierului, fie la sfr"itul lui, n vederea ad#ug#rii liniilor noi.
Deschiderea la nceput se realizeaz# cu procedura Reset, iar la sfr"it cu procedura
Append. Pentru fi"iere text, formele speciale ale subprogramelor Read "i Write permit
34
citirea "i scrierea nu numai a valorilor de tip caracter, ci "i a valorilor de tip ntreg,
real "i de tip "ir de caractere. De exemplu, Read(f,i), unde i este o variabil# de tip
ntreg, va citi o secven!# de cifre, care vor f interpretate ca un ntreg zecimal, "i care
va fi depus n variabila i. Detectarea caracterelor de sfr"it de linie poate fi realizat#
cu func!ia Eoln, care returneaz# valoarea true dac# s-a ajuns la sfr"itul liniei curente.
Func!ia SeekEoln este similar# cu Eoln, exceptnd faptul c# se sare peste blanc-uri "i
tab-uri, dup# care se testeaz# starea de sfr"it de linie. Starea de sfr"it de fi"ier poate
fi testat# cu func!ia Eof, precum "i cu func!ia SeekEof, aceasta din urm# sare peste
blanc-uri "i tab-uri, dup# care se returneaz# true dac# s-a ajuns la sfr"itul fi"ierului.
Procedura SetTextBuf permite ata"area unui tampon de intrare/ie"ire de lungime dat#
la un fi"ier text. Golirea tamponului unui fi"ier text deschis pentru scriere poafe fi
realizat# cu procedura Flush.
A"a cum s-a ar#tat la generalit#!i despre fi"iere, exist# dou# fi"iere text
standard: Input "i Output. Fi"ierul Input este destinat numai pentru opera!ii de citire "i
este asociat cu fi"ierul standard de intrare al sistemului de operare (de regul#
claviatura). Fi"ierul Output este destinat numai pentru opera!ii de scriere "i este
asociat cu fi"ierul standard de ie"ire al sistemului de operare (de regul# ecranul).
Aceste fi"iere snt deschise automat nainte de nceputul execu!iei, ca "i cum ar fi
prezente instruc!iunile
Assign(Input,' ');Reset(Input); Assign(0utput,); Rewrite(Output);
Aceste fi"iere snt nchise automat dup# ce s-a terminat execu!ia programului.
Unele proceduri "i func!ii de intrare/ie"ire permit ca numele fi"ierului s# nu fie
specificat n lista de argumente; n acest caz se presupune c# fi"ierul text implicit este
sau Input, sau Output, n func!ie de natura subprogramului. De exemplu, Read(x) este
echivalent cu Read(Input,x), iar Write(x) este echivalent cu Write(Output,x). Un fi"ier
text deschis cu Reset suport# numai proceduri "i func!ii orientate spre citire. Analog,
un fi"ier deschis cu Rewrite sau Append permite utilizarea acelor proceduri "i func!ii,
care snt orientate spre scriere.
Exemplul $: Crearea unui fi"ier text carte.txt; liniile fi"ierului snt introduse de la
tastatur# (fi"ier INPUT)
Program crtext;
var c:char; f:text;
begin
assign(f , 'carte.txt'); {asocierea variabilei f cu fi$ierul extern carte.txt}
rewrite(f); {deschiderea fi$ierului nou pentru scriere}
while not eof do {control sfr$it de fi$er: eof(INPUT)}
begin while not eoln do {control sfr$it de linie: eoln(INPUT)}
beqin read(c); {citire de la tastatura: read(INPUT,c)}
write(f,c); {variabila c va fi scris! n fi$ier} end;
readln; {readln(INPUT)}
writeln(f); {scrie EOLN in f} end;
close(f); {scrie EOF n f $i-l inchide}
end
Exemplul 2. Afi"area fi"ierului creat anterior pe ecran, cu numerotarea liniilor.
Program extext;
35
var c:char; f:text; numlin:integer;
begin assign(f,'carte.txt'); reset(f); numlin:=0;
while not eof(f) do begin
numlin:=numlin+l; write(numlin,' ');
while not eoln(f) do begin
read(f,c); write(c); end;
readln(f); {citeste EOLN din f}
writeln; end;
close(f); end.

4.2.2.7.4 Fi#iere f$r$ tip
Fi"ierele f#r# tip snt canale de intrare/ie"ire de nivel inferior, utilizate n
primul rnd pentru accesul direct la orice fi"ier-disc, indiferent de tipul "i de
structurarea intern# a fi"ierului. n opera!iile de intrare/ ie"ire, la fi"ierele f#r# tip
informa!iile snt transferate direct ntre fi"ierul de pe disc "i variabile, economisndu-
se astfel spa!iul necesar zonei tampon. Un fi"ier f#r# tip este compatibil cu orice fi"ier
(cu tip sau text). 0 variabil# de acest tip se declar# cu tipul predefinit "file", "i nimic
altceva; de exemplu: var f:file;
Pentru fi"iere f#r# tip, procedurile de deschidere Reset "i Rewrite permit
folosirea unui parametru auxiliar. Acest parametru specific# lungimea unei
componente a fi"ierului. Valoarea acestui parametru, din motive istorice, este $28. Se
recomand# alegerea valorii $, deoarece aceast# valoare permite reflectarea corect# a
dimensiunii exacte a fi"ierului (cnd aceast# valoare este $, nu snt posibile
componente frac!ionate).
Exceptnd procedurile Read "i Write, toate procedurile "i func!iile standard
utilizabile pentru fi"ierele cu tip snt permise "i pentru fi"ierele f#r# tip. n locul
procedurilor Read "i Write, pentru realizarea transferurilor rapide de date snt folosite
procedurile BlockRead "i BlockWrite. Procedura BlockRead cite"te din fi"ierul f#r#
tip un num#r precizat de componente, care se depun n memorie de la o adres#
specificat#. La revenire din procedur#, o variabil# - care se poate specifica op!ional -
va con!ine num#rul componentelor citite efectiv. Dac# aceast# variabil# nu este
specificat# "i dac# nu s-a reu"it citirea tuturor componentelor, va apare o eroare de
intrare/ie"ire.
Procedura BlockWrite scrie n fi"ierul f#r# tip un num#r precizat de
componente, componentele fiind luate de la o adres# specificat#. La revenire din
procedur# o variabil# op!ional# va con!ine num#rul componentelor scrise efectiv.
Dac# aceast# variabil# nu este specificat# "i dac# nu s-a reu"it scrierea tuturor
componentelor, atunci va apare o eroare de intrare/ie"ire.
Este permis att accesul secven!ial, ct "i cel direct, datorit# faptului c# toate
componentele au aceea"i lungime. Pozi!ionarea pe o component# dorit# se realizeaz#
cu procedura Seek. Numerotarea componentelor ncepe de la zero. Num#rul
componentelor se determin# cu func!ia FileSize, iar num#rul componentei actuale se
determin# cu func!ia FilePos. Procedura Truncate permite trunchierea fi"ierului,
pornind de la componenta actual# din fi"ier. Exemplu. Programul urm#tor prezint# o
utilizare a fi"ierelor f#r# tip:copierea unui fi"ier de tip arbi trar.
36
program copiere;
var sursa,dest:file;
citit,scris:word; tampon:array[#..2048] of char;
numsurs,numdest:string[#4];
begin writeln('Fisierul sursa:'); readln(numsurs);
assign(sursa,numsurs);
reset(sursa,#); {lungimea componenta = #}
writeln('Fisierul destinatie:'); readln(numdest);
assign(dest,numdest); rewrite(dest,#);
writeln (' Copiere de', FileSize (sursa), ' octeti...');
repeat
BlockRead(sursa,tampon,2048,citit);
BlockWrite(dest,tampon,citit,scris);
until (citit = 0) or (scris <> citit); close(sursa); close(dest);
end.

4.3 Instruc$iuni
O instruc!iune este alc#tuit# dintro etichet# op!ional# prin intermediul
c#reia poate fi referit# din alte instruc!iuni, urmat# de instruc!iunea propriu-zis#, prin
care este descris# ac!iunea realizat# n momentul execu!iei sale. Se face distinc!ie
ntre instruc!iuni simple (instruc!iunea de atribuire, apelul de procedur#, instruc!iunea
de efect nul "i instruc!iunea de transfer necondi!ionat) "i instruc!iunile structurate
(instruc!iunea compus#, instruc!iunile iterative, instruc!iunile condi!ionale,
instruc!iunea with ".a.).

4.3." Instruc!iuni simple.
O instruc!iune se nume"te simpl# dac# nu con!ine alte instruc!iuni.

4.3."." Instruc!iunea de atribuire.
Aceast# instruc!iune are forma V:=E; unde V o variabil#, iar E o expresie.
Prin execu!ia instruc!iunii de atribuire, expresia E este evaluat# "i rezultatul se
atribuie variabilei V. Variabila "i rezultatul evalu#rii trebuie s# fie de tipuri identice
sau tipul uneia s# fie un subdomeniu al celeilalte, sau ambele s# fie subdomenii ale
aceluia"i tip, iar rezultatul n subdomeniul variabilei. Se admite ca excep!ie cazul cnd
variabila este de tipul real, iar rezultatul de tipul integer sau un subdomeniu al
acestuia. n dependen!# de tipul variabilei "i rezultatului exist#: atribuire aritmetic#,
logic#, caracterial#. Atribuirea aritmetic# serve"te pentru atribuirea unei valori
variabilei de tipul real sau integer. n calitate de expresie pot fi diferite func!ii "i
opera!ii ce pot fi aplicate asupra tipurilor real "i integer. n cazul atribuirii logice de
partea stng# se afl# o variabil# de tipul boolean, iar n partea dreapt# o expresie
logic# pentru calcularea unei valori logice(true sau false).De obicei la atribuirea
caracterial# n partea stng# se afl# o variabil# tip char, iar n dreapta - o expresie
caracterial# ce red# regula de determinare a valorii de tipul char, adic# un caracter
aparte. Ex.: a: = l; b: =succ (l);

37
4.3.".2 Instruc!iunea apel de procedur$
Aceast# instruc!iune se insereaz# n program n locul n care se dore"te
executarea instruc!iunilor specificate de o declara!ie de procedur# asupra unit#!ilor
particulare transmise ei din locul de apel. Sintactic apelul de procedur# poate fi
reprezentat astfel: P(L), unde P numele procedurii, L lista parametrilor actuali.
Parametrii actuali din L trebuie s# corespund# ca num#r, ordine "i tip cu
parametrii formali specifica!i n antetul declara!iei de procedur#. Ei pot fi expresii,
func!ii, proceduri. Ex.: o procedur# cu antetul procedure P( x, y: integer; var z, t:
real) se poate apela prin P(a, b, u, v) sau P(3, 5, u, v) sau P (3, 2*(a + b - c), u, v) etc.
unde a, b, c desemneaz# variabile ntregi. Instruc!iunea de apel la procedur# va fi
analizat# mai concret n punctul 4.4.

4.3.".3 Instruc!iunea de transfer necondi!ionat.
Instruc!iunile unui program snt executate secven!ial, a"a cum apar scrise n
textul programului. Instruc!iunea de transfer necondi!ionat ofer# posibilitatea de a
ntrerupe aceast# secven!# "i a relua execu!ia dintr-un alt loc al textului. Aceast#
instruc!iune are forma: GOTO e unde e etichet# declarat# prin label. Declararea
etichetei e prin label este obligatorie. Execu!ia instruc!iunii GOTO e are ca efect
transferul controlului la instruc!iunea precedat# de e .
Instruc!iunea GOTO e "i instruc!iunea marcat# cu e trebuie s# ndeplineasc#
condi!ia: instruc!iunea precedat# de e con!ine instruc!iunea GOTO e sau face parte
dintr-o secven!# de instruc!iuni s, iar instruc!iunea GOTO e este una, sau e con!inut#
n una dintre instruc!iunile secven!ei s.
Ex.: label 5,8
Const a=#,4; b=7,03;
Var x, y, z: real
Begin
Writeln (y); readln (y); X: =sqr (y);
5: if x>5 then goto 8
Z:= x+a+b;
X:= sqrt(z);
Goto 5;
8: end;

4.3.".4 Instruc!iunea de efect nul.
Executarea acestei instruc!iuni nu are efect asupra variabilelor programului
(starea acestora r#mne neschimbat#). n textul programului instruc!iunea de efect nul
nu este reprezentat# prin nimic dar, deoarece instruc!iunile snt desp#r!ite ntre ele
prin ; ,prezen!a sa este marcat# de apari!ia acestui delimitator. Ex.: a:=b+3;;;

4.3.2 Instruc!iuni structurate.
O instruc!iune se nume"te structurat# cnd are n componen!a sa cteva
instruc!iuni simple (2 "i mai mult).


38
4.3.2." Instruc!iunea compus$ BEGINEND.
Uneori, pentru compilarea corect# a unui program n limbajul Pascal este
nevoie ca ntr-un loc oarecare al construc!iei sintaxice s# fie prezent numai un singur
operator (instruc!iune), n timp ce dup# mersul algoritmului n acest loc trebuie s# fie
un set de instruc!iuni. Pentru rezolvarea acestui conflict dintre sintaxa limbajului "i
mersul algoritmului este folosit# instruc!iunea compus# begin - end, care une"te un
set de operatori simpli ntr-un tot ntreg "i care este n!eles de compilator ca o singur#
instruc!iune aparte. Cuvintele cheie la instruc!iunea compus# snt <begin> "i <end>.
Sintaxa este urm#toarea : begin <instr.$; instr.2;; instr. n> end.
Instruc!iunea compus# begin end poate con!ine una sau mai multe
instruc!iuni n corpul s#u (desp#r!ite prin ;). Executarea acestei instruc!iuni se
reduce la executarea consecutiv# a tuturor operatorilor inclu"i n corpul s#u.
Ex.: begin a: =b+3 end; begin y: =s + cos s; z: = y - 4ac; end;
Begin I:=$; begin c: = a + b; y: = sin c end; end;

4.3.2.2 Instruc!iuni condi!ionale.
O instruc!iune condi!ional# selecteaz# o singur# instruc!iune dintre
alternativele sale, pe care apoi o execut#. n structurile ramificate de calcul, unele
etape nu ntotdeauna se ndeplinesc n una "i aceia"i ordine, dar n dependen!# de
careva condi!ii, care snt controlate(verificate) pe parcursul calculelor, se aleg pentru
executare diferite consecutivit#!i de instruc!iuni. Pentru descrierea astfel de procese n
limbajul Pascal se folosesc instruc!iunile ramificate (sau condi!ionale).
Instruc!iunea conditional$ IF
Instruc!iunea condi!ional# IF are n Pascal 2 forme: complet# "i prescurtat#.
Forma complet# este urm#toarea:
If <condi!ie> THEN <instruc!iune> ELSE <instruc!iune>;
Forma prescurtat# este: IF <condi!ie> THEN <instruc!iune>;
unde IF(dac#), THEN(atunci) "i ELSE(altfel) snt cuvinte rezervate. Forma complet#
a instruc!iunii condi!ionale se mai poate prezenta n felul urm#tor:
If C THEN I$ ELSE I2; (C-expresie logic#, I$, I2-instruc!iuni). Executarea acestei
instruc!iuni structurate se reduce la executarea unei din instruc!iuni I$ sau I2. Dac#
condi!ia C din cadrul instruc!iunei se respect# (C prime"te valoarea TRUE), atunci
urm#toarea instruc!iune executabil# este I$, n caz contrar se ndepline"te I2. Exemple
de instruc!iuni IF form# complet#:
IF x<0 THEN i:=i+$ ELSE k:=k+$;
IF (x>0) and (y>0) THEN a: =SQRT (x * y) ELSE a: =SQR(x * y);
Not# $. Dac# n instruc!iunea IF C THEN I introducem nainte de I instruc!iunea de
efect nul (IF C THEN;I) atunci I nu intr# n componen!a instruc!iunii condi!ionale,
deci este executat# indiferent de valoarea lui C.
Not# 2. Dac# ns# n instruc!iunea IF c THEN I$ ELSE I2, introducem dup# I$ ;,
ob!inem un program incorect sintactic din pricina c# aceast# instruc!iune se consider#
un tot ntreg "i nu poate suporta prezen!a simbolului ; n interiorul s#u.
La formularea algoritmilor deseori este tipic# situa!ia cnd analiznd o condi!ie
oarecare "i n caz de respectare a ei este necesar de ndeplinit careva ac!iuni, iar n
cazul cnd condi!ia nu se respect# nu trebuie de executat nici o instruc!iune.
39
Ex.: if x<0 then x: =ABS(x) (Aflarea modulului unui num#r). n astfel de
situa!ii este destul de comod# forma prescurtat# a instruc!iunii condi!ionale:
if c then i. n acest caz dac# valoarea lui c este TRUE, atunci este executat#
instruc!iunea I, n caz contrar nici o ac!iune din partea compilatorului nu-i ndeplinit#,
adic# se controleaz# numai condi!ia C. Ex.: if a>b then c: =a-b;
Instruc!iunea condi!ional$ CASE.
n cazul, cnd n algoritm este necesar de luat n considera!ie mai mult de 3
variante posibile, construc!ia if then else poate fi foarte complicat#. n a"a
cazuri n calitate de alternativ# se folose"te comutatorul de tipul CASE. Aceast#
instruc!iune condi!ional# prezint# o structur# alc#tuit# dup# principiul MENIU "i
con!ine toate variantele posibile ale condi!iilor "i instruc!iunilor care trebuie de
ndeplinit n fiecare din cazurile concrete.
Instruc!iunea CASE const# dintr-o expresie numit# selector "i o list# de
instruc!iuni, fiecare precedat# de o constant# de acela"i tip cu selectorul sau de
cuvntul cheie OTHERWISE. Instruc!iunea CASE se execut# astfel: se evalueaz#
expresia ce define"te selectorul "i apoi se execut# fie instruc!iunea precedat# de
constanta egal# cu valoarea selectorului, fie instruc!iunea precedat# de OTHERWISE,
dac# valoarea selectorului nu coincide cu nici una din constantele ce eticheteaz#
instruc!iunile componente. n acest caz lipsa specifica!iei otherwise conduce la erori.
Sintaxa instruc!iunii case este urm#toarea:
CASE I OF CASE I OF
C$:<instruc!iunea $>; C$:<instruc!iunea $>;
C2:<instruc!iunea 2>; sau C2:<instruc!iunea 2>;
..
Cn: <instruc!iunea n>; Cn: <instruc!iunea n>;
OTHERWISE <instruc!iune> ELSE<indtruc!iune>;
end; end;
unde i este selector; c$,cn-constante. n standardul ini!ial al limbajului Pascal
construc!ia case este folosit# cu cuvntul cheie otherwise. n Turbo Pascal n loc de
otherwise se folose"te else. n calitate de selector poate fi o variabil# de tipul
INTEGER sau CHAR, ns# nici ntr-un caz de tipul real. n cazul, cnd selectorul I
coincide cu constanta c$ se ndepline"te <instruc!iunea $>, n caz contrar
compilatorul trece la controlul condi!iei din ramura 2. Dac# selectorul coincide m#car
cu una din constantele c$cn atunci se ndepline"te instruc!iunea respectiv#, n caz
contrar se ndepline"te instruc!iunea ce urmeaz# dup# OTHERWISE sau ELSE.
Ex.: var I, s: integer;
Begin writeln (culege I); case I of #: s:=3+I; 2: s:=3+sqrt(I);
3: s:=3+sqr(I); else s:=3+exp(I) end;

4.3.2.3 Instruc!iuni iterative(ciclice)
Instruc!iunile prec#utate mai sus redau opera!ii care trebuie efectuate conform
algoritmului "i fiecare din ele se ndeplinesc numai o dat#. n cazul, cnd una "i
aceia"i instruc!iune trebuie s# fie executat# de n ori cu diferite valori ale parametrilor
se folosesc instruc!iunile ciclice. Distingem 3 instruc!iuni ciclice n Pascal:
$) Instruc!iunea ciclic# cu parametru (FOR)
40
2) Instruc!iunea ciclic# cu postcondi!ie (REPEAT)
3) Instruc!iunea ciclic# precedat# de condi!ie (WHILE)
Instruc!iunea ciclic$ FOR.
Ciclul FOR posed# urm#toarele caracteristici:
num#rul de repet#ri ale ciclului este cunoscut de la nceputul execut#rii lui;
conducerea ciclului este efectuat# cu ajutorul unei variabile de tip scalar,
care, n acest proces ciclic prime"te valori consecutive de la valoarea
ini!ial# dat# pn# la valoarea final# dat#.
Pentru o redare mai compact# a proceselor de calcul de a"a tip se folose"te
urm#toarea construc!ie a ciclului: FOR I:=E$ to E2 do S;
unde FOR,TO,DO snt cuvinte cheie, I variabil# tip scalar (n afar# de real)
numit# parametrul ciclului, E$, E2 expresii de tip identic cu parametrul ciclului, S
operator numit corpul ciclului. n calitate de S poate fi prezent o singur#
instruc!iune sau un set de instruc!iuni unite n operatorul begin - end. Acest operator
ciclic(FOR) presupune atribuirea parametrului ciclic I valori consecutive de la
valoarea ini!ial# E$ pn# la valoarea final# E2 "i executarea instruc!iunii S pentru
fiecare valoare a lui i. Valorile expresiilor E$ "i E2 snt calculate o singur# dat#, iar
valoarea parametrului I nu trebuie s# fie schimbat# n rezultatul execut#rii
instruc!iunii S. Dac# E2 este mai mic# dect E$(ceia ce-i posibil) atunci instruc!iunea
S nu se execut# nici o dat#. Exemplu de ciclu for: y:=0; for I:=$ to n do y:=y+$/I;
n unele cazuri este comod ca parametrul ciclului s# primeasc# valori
consecutive ns# nu n ordine cresc#toare ci n ordine descresc#toare. Pentru a"a
cazuri n Pascal este prev#zut operatorul ciclului cu parametru de felul urm#tor:
FOR I:=E$ downto E2 do S
unde downto (mic"orndu-se pn# la) cuvnt cheie. n acest caz, dac# valoarea E$ e
mai mic# ca E2 atunci ciclul nu se va repeta nici odat#, adic# instruc!iunea S nu va fi
executat#. Parametrul ciclului I poate s# nu fie folosit n corpul ciclului (adic# n
interiorul lui S) din cauz# c# destina!ia lui de baz# este conducerea cu num#rul de
repet#ri al ciclului. Pasul schimb#rii lui fiind egal cu $.
Ex.: y:=$; for I:=$ to n do y: =y * x;
Instruc!iunea ciclic$ cu postcondi!ie (repeat).
Ciclul FOR cu parametru de obicei este folosit n cazurile, cnd num#rul de
itera!ii este cunoscut de la nceputul execut#rii ciclului. ns# deseori num#rul de
itera!ii nu este cunoscut de la nceput, dar se determin# n timpul realiz#rii acestui
proces ciclic. n acest caz este folosit ciclul REPEAT cu ajutorul c#rui este formulat#
condi!ia, n cazul respect#rii c#reia, acest proces ciclic trebuie s# fie terminat. Ciclul
cu postcondi!ie are urm#toarea sintax#: REPEAT S;S;;S UNTIL B
unde: Repeat(de repetat) "i until(pn# la) cuvinte cheie, S un operator oarecare, b
expresie logic#.
n tipul execut#rii acestui proces ciclic setul de instruc!iuni S ce se afl# ntre
cuvintele repeat "i until este executat de una sau de mai multe ori. Acest proces se
termin# atunci, cnd dup# executarea setului de instruc!iuni S expresia logic# B va fi
echivalat#(pentru prima dat#) cu TRUE. n a"a fel, cu ajutorul expresiei logice B este
determinat# condi!ia pentru terminarea execut#rii operatorului ciclului. Deoarece n
acest caz controlul condi!iei este efectuat dup# ndeplinirea setului de instruc!iuni S,
4$
acest ciclu e numit ciclu cu postcondi!ie. De asemenea ca "i ciclul for, ciclul repeat
con!ine un parametru, care conduce cu num#rul de repet#ri al ciclului. Acest
parametru trebuie s# fie prezent n expresia logic# B. Spre deosebire de ciclul for
unde parametrul nu poate fi schimbat n corpul ciclului, n cazul ciclului repeat
valoarea parametrului neap#rat trebuie s# fie schimbat# spre majorare sau mic"orare.
Adic# parametrul ciclului se va schimba n ordine cresc#toare sau descresc#toare.
Valoarea cu care se m#re"te(mic"oreaz#) parametrul ciclului se nume"te pasul
ciclului. *i n compara!ie cu ciclul for, n cazul dat pasul ciclului poate fi "i de tip
real "i mai mare ca $. Ex. : I:=#; repeat y:=y+x; I:=I+# until I>n;
Deoarece n instruc!iunea repeat - until condi!ia se controleaz# numai la
sfr"itul ciclului, setul de instruc!iuni S din care este compus corpul ciclului este
executat m#car o singur# dat#. *i n cazurile, cnd conform algoritmului este necesar
ca un set de operatori s# fie ndeplini!i cel pu!in o dat#, este binevenit ciclul repeat -
until.
Instruc!iunea ciclic$ precedat$ de condi!ie(while).
n cazul ciclului repeat setul de instruc!iuni S va fi executat cel pu!in o dat#.
ns# destul de frecvente snt cazurile cnd num#rul de itera!ii nu este cunoscut, dar
pentru ni"te valori concrete ale datelor ini!iale ac!iunile prev#zute pentru executarea
n cadrul ciclului nu trebuie s# fie executate nici o dat# "i chiar ndeplinirea de o
singur# dat# a ciclului poate duce la rezultat incorect sau nedeterminat. Pentru a reda
astfel de procese de calcul n Pascal este folosit ciclul WHILE, sintaxa c#rui este
urm#toarea: WHILE B DO S ;
unde while "i do snt cuvinte cheie, bexpresie logic#, s-operator. Aici operatorul S
se execut# de 0 sau mai multe ori, ns# nainte de fiecare urm#toare executare se
evalueaz# valoarea expresiei B "i operatorul S este executat numai n cazul, cnd
expresia B are valoarea TRUE. Executarea operatorului ciclului ia sfr"it atunci, cnd
expresia B pentru prima dat# se egaleaz# cu FALSE. Dac# expresia B se egaleaz# cu
FALSE chiar la prima evaluare a sa, atunci operatorul S nu va fi executat nici o dat#.
Din cauz# c# condi!ia de terminare a procesului ciclic este controlat# pn# la
executarea operatorului S, aceast# instruc!iune poart# denumirea de proces ciclic
precedat de condi!ie. Este remarcabil faptul, c# operatorul ciclic precedat de condi!ie
este cel mai universal dintre to!i operatorii ciclici. Cu ajutorul lui este posibil de redat
procese ciclice determinate de instruc!iuni ciclice cu parametru "i cu postcondi!ie. De
exemplu ciclu cu parametru for i:=E$ to E2 do S; este echivalent cu urm#toarea
succesiune de instruc!iuni: i:=E#; while i<=E# do begin S; i: = succ (i); end; "i n
primul caz, "i n al doilea rezultatul execut#rii acestor fragmente de program va fi
acela"i, diferen!a fiind numai n sintax# "i succesiunea de instruc!iuni. Operatorul
ciclului cu postcondi!ie de obicei de asemenea se poate de redus la operatorul ciclic
precedat de condi!ie, corespunz#tor schimbnd condi!ia, adic# expresia logic#. Avnd
la dispozi!ie ciclul cu postcondi!ie n urm#toarea componen!#:
i:=E# repeat S; i:=i+# until i>E2;
l putem reda cu ajutorul operatorului precedat de condi!ie while:
i:=E# while i<=E2 do begin S; i:=i+# end;
Deci, fiind cunoscute cele 3 instruc!iuni ciclice FOR,WHILE "i REPEAT le
putem folosi n diferite scopuri aparte pentru cazuri concrete. n cazul cnd
42
cunoa"tem num#rul de repet#ri al ciclului, pasul indexului fiind =$ folosim
instruc!iunea ciclic# FOR. n cazul cnd num#rul de repet#ri al ciclului e necunoscut,
dar corpul ciclului trebuie s# fie executat m#car o singur# dat# folosim instruc!iunea
ciclic# REPEAT. *i n cazul cnd nu este cunoscut num#rul de repet#ri al ciclului, iar
corpul ciclului e necesar s# fie executat de 0 sau mai multe ori, n dependen!# de o
condi!ie folosim instruc!iunea ciclic# WHILE.

4.4 Organizarea modular! a programelor. Proceduri "i func$ii n Pascal
Deseori, n timpul alc#tuirii unui program apar situa!ii, cnd e necesar ca una "i
aceia"i secven!# de instruc!iuni s# fie executat# de mai multe ori, dar prelucrnd date
diferite. n a"a cazuri e binevenit de folosit subprograme. Un subprogram corect
alc#tuit "i nscris n program o singur# dat#, care con!ine tipul "i num#rul necesar de
parametri poate fi apelat de mai multe ori, din diferite puncte ale programului, cu
diferite valori ale parametrilor, ns# realiznd unul "i acela"i algoritm.
n Pascal exist# 2 feluri de subprograme: proceduri "i func!ii. Deosebirea dintre
ele const# n num#rul valorilor calculate "i returnate n punctele din care a fost f#cut
apelul. Procedura calculeaz# oricte asemenea valori, pe cnd func!ia- numai una,
permi!nd ca apelul ei s# se fac# chiar din expresia care are nevoie de valoarea
calculat#. Procedurile "i func!iile se definesc n partea de declarare a subprogramelor
"i snt ultimele declara!ii din sec!iunea datelor. O astfel de declara!ie asociaz# un
identificator cu o parte a programului, astfel nct aceasta poate fi activat# cu ajutorul
instruc!iunii de apel la procedur# n orice moment.

4.4." Proceduri
Declararea procedurilor este amplasat# n partea procedurilor "i func!iilor "i are
urm#toarea sintax#:
Procedure nume(lista parametrilor formali);
Var [lista variabilelor locale];
Begin [corpul procedurii] end;
Pentru redarea mai clar# a temei vom folosi un exemplu concret. Fie c# trebuie
de calculat aria unui patrulater pentru care snt cunoscute cele 4 laturi
"i o diagonal#. Pentru a calcula aria patrulaterului, calcul#m aria
fiec#rui triunghi component n parte folosind formula lui Heron:
S=sqrt(p*(p-a)*(p-b)*(p-c)), unde p=(a+b+c)/2; a,b,c-lungimea laturilor triunghiului.
F#r# folosirea procedurilor rezolvarea acestei probleme va fi urm#toarea:
Program patrulater#;
Var AB, BC, CD, DA, BD, a,b,c,p,s,s#,s2:real;
Begin readln(AB,BC,CD,DA,BD);
a:=AB; b:=DA; c:=BD; p:=(a+b+c)/2;
S#:=sqrt(p*(p-a)*(p-b)*(p-c));
A:=BC; b:=CD; c:=BD; p:=(a+b+c)/2;
S2:= sqrt(p*(p-a)*(p-b)*(p-c));
S:=S#+S2; writeln(S=,S); end.
43
Se observ# repetarea unui set de instruc!iuni, "i anume calculul pentru p "i S. Anume
aceast# situa!ie cere folosirea unei proceduri. Versiunea programului cu folosirea
procedurii este urm#toarea:
Program patrulater2;
Var AB, BC, CD, DA, BD, a,b,c,p,s,s#,s2:real;
Procedure aria;
Begin p:=(a+b+c)/2; S:= sqrt(p*(p-a)*(p-b)*(p-c)); end.
Begin readln(AB,BC,CD,DA,BD);
a:=AB; b:=DA; c:=BD; aria;
S#:=S; A:=BC; b:=CD; c:=BD; aria;
S2:=S; S:=S#+S2; writeln(S=,S);
End.
Se observ# 2 adres#ri la procedura aria. ns# nainte de fiecare adresare se
ndeplinesc cteva instruc!iuni de atribuire, care determin# valorile variabilelor a,b,c.
Fiecare adresare activeaz# procedura "i ca rezultat este primit# valoarea suprafe!ei
triunghiului pentru laturile c#ruia au fost f#cute atribuirile. Deci leg#tura dintre
procedur# "i programul principal este efectuat# prin intermediul variabilelor a,b,c "i
S. ns# procedura mai con!ine "i variabila p, care este local# procedurii "i nu apare n
corpul programului principal. n a"a situa!ie declararea "i descrierea variabilei p poate
fi f#cut# n#untru procedurii. A"a variabile snt numite variabile locale (referitor la
procedur#). Ele nu pot ac!iona nici ntr-un mod asupra variabilelor globale (din
programul principal) cu acela"i nume. Diferen!a dintre ele const# numai n domeniul
de vizibilitate: variabila global# este v#zut# (de c#tre compilator) pe parcursul
intregului program, iar variabila local# procedurii este v#zut# numai n interiorul
procedurii.
No!iunea de bloc #i domeniu de vizibilitate
Corpul unui subprogram (procedur# sau func!ie) este un bloc sau o directiv#.
Un bloc este constituit din declara!ii de etichete (label), defini!ii de constante (const),
defini!ii de tip (type), declara!ii de variabile (var), declara!ii de procedur#
(procedure), declara!ii de func!ie (function) "i instruc!iuni (partea executabil# a
blocului). Deoarece programele snt incluse n blocul programului principal, iar
blocurile subprogramelor pot con!ine la rndul lor alte subprograme, rezult# c#
blocurile pot fi imbricate (suprapuse). Aceast# imbricare de blocuri este denumit#
structura de bloc a programelor Pascal, concept introdus de limbajul ALGOL60.
ntruct blocurile pot fi imbricate n alte blocuri prin declara!ii de proceduri sau
func!ii, fiec#rui bloc i putem ata"a cte un nivel de imbricare. Blocul programului
principal sau unit-ului principal este considerat de nivel 0, un bloc definit n acesta
este de nivelul $. n general, un bloc definit n nivelul n este de nivelul n+$.
O defini!ie sau declara!ie introduce un nume, care poate fi un identificator -care
serve"te la denumirea tipurilor, variabilelor, subprogramelor etc. Fiecare nume dintr-
un program Pascal are un punct de definire/declarare, unde se leag# diferitele atribute
de numele respectiv. Prin domeniu de vizibilitate al unui nume se n!elege acea parte
a programului n care numele respectiv p#streaz# acelea"i atribute.
Un identificator care a fost declarat/definit n blocul programului (unit-ului)
principal se nume"te global. Un identifcator este local blocului n care este
44
declarat/definit. Un identificator este nelocal ntr-un bloc, dac# declara!ia/defini!ia sa
a fost f#cut# ntr-un bloc exterior primului.
Exemplul patrulater2 ilustreaz# bine cazul folosirii procedurii f#r# parametri.
Aceast# metod# deseori se dovede"te a fi neefectiv# din cauza multor instruc!iuni de
atribuire pentru a,b,c. Pentru nl#turarea acestor neajunsuri Pascal ofer# posibilitatea
de a nu fixa valorile ini!iale ale variabilelor a,b,c pentru lucrul procedurii, dar face a
fi posibil# transformarea acestor variabile n parametri ai procedurii, valoarea c#rora
va fi concretizat# la momentul apelului procedurii. Astfel de parametri se numesc
parametri formali. Parametrii formali nu prezint# ni"te valori concrete, dar valori
virtuale. Le fiecare adresare c#tre procedur#, parametrii ei formali trebuie
concretiza!i, din aceast# cauz#, pentru simplificarea urm#toarelor apeluri la procedur#
parametrii formali snt indica!i n antetul procedurii "i n acela"i timp ordona!i dup#
cum au ap#rut n antet. n acela"i timp, pentru fiecare parametru formal se indic# tipul
valorii prezentate de acest parametru formal. Ca "i n cazul declar#rii variabilelor
globale, acest tip este indicat o singur# dat# dup# lista parametrilor formali
corespunz#tori. De exemplu: procedure aria(a,b,c:real); Fiecare parametru declarat
n lista parametrilor formali este local procedurii "i poate f referit n blocul asociat
procedurii prin identificatorul s#u. La ardesarea c#tre a"a o procedur#, n
instrusc!iunea de apel la procedur# dup# numele procedurei se indic# n paranteze
lista parametrilor actuali. Ace"ti parametri concretizeaz# valorile asupra c#rora ntr-
adev#r trebuie s# fie aplicat# procedura "i care n corpul ei au fost nota!i cu ajutorul
parametrilor formali. n exemplul nostru parametrii formali snt de tip real, deci ca
parametri actuali pot fi luate orice 3 numere reale. n acela"i timp corespunderea
dintre parametrii formali "i cei actuali este respectat# atunci cnd locul, num#rul "i
tipul parametrilor formali este identic cu locul, num#rul " tipul celor actuali.
Folosind aceste reguli, programul precedent poate avea urm#toerea redac!ie:
Program patrulater3;
Var AB, BC, CD, DA, BD, s,s#,s2:real;
Procedure aria(a,b,c:real);
Var p:real;
Begin p:=(a+b+c)/2; S:= sqrt(p*(p-a)*(p-b)*(p-c)); end.
Begin readln(AB,BC,CD,DA,BD);
aria(AB,DA,BD); S#:=S;
aria(BC,CD,BD); S2:=S;
writeln(S=,S#+S2);
End.
Dup# cum se observ# variabila global# p folosit# numai n cadrul procedurii
aria a fost transformat# n variabil# local# procedurii. Este u"or de v#zut c#
corespunderea dintre parametrii formali "i cei actuali este respectat#. La apelul
aria(AB,DA,BD) parametrului actual AB i corespunde parametrul formal a, lui DA-
b, lui BD-c. Parametrii a,b,c exist# numai att timp, ct este ndeplinit# procedura;
dup# terminarea execu!iei procedurei ace"ti parametrii snt nimici!i din memorie. La
urm#torul apel al procedurii aria, parametrilor formali noun#scu!i le corespund alte
valori, respectiv BC,CD,BD.
45
Mecanismul de substituire a parametrilor formali prin parametrii actuali se
nume"te transmiterea parametrilor.
Transmiterea parametrilor.
n Pascal exist# dou# mecanisme de baz# pentru transmiterea parametrilor: prin
valoare "i prin adres#.
Transmiterea prin valoare se realizeaz# ca "i cum la intrarea n procedura
apelat# s-ar g#si o declara!ie a parametrului formal cu tipul corespunz#tor "i o
instruc!iune de atribuire de forma:
parametru formal: =parametru actual;
Valoarea parametrului actual este memorat# n loca!ia corespunz#toare
parametrului formal. Un parametru formal al unei proceduri sau al unei func!ii se
comport# ca o variabil# local# a subprogramului, cu excep!ia faptului c# acesta este
ini!ializat la activarea subprogramului cu valoarea parametrului actual corespunz#tor.
Aceast# ini!ializare este echivalent# cu copierea valorii parametrului actual n spa!iul
datelor locale subprogramului.
Deseori la transmiterea prin valoare se modific# valoarea unui parametru formal.
Printr-o astfel de modificare informa!ia din exteriorul procedurii r#mne nealterat#.
Din aceast# cauz# mecanismul transmiterii parametrilor prin valoare prezint#
avantajul siguran!ei: informa!ia din exteriorul subprogramului nu este schimbat# dac#
se modific# valoarea parametrilor actuali respectivi.
Sintaxa de declarare a procedurii cu trsnsmiterea parametrilor prin valoare este
ca "i n exemplu precedent: Procedure nume(nume_parametru:tip_parametru);
Parametrul actual corespunz#tor parametrului formal ntr-o instruc!iune de apel
de procedur# este o expresie. Valoarea acestei expresii nu poate s# fie de tip fi"ier sau
un tip structurat care con!ine un tip fi"ier. Dac# tipul parametrului actual este string,
atributul de lungime al parametrului este 255.
Transmiterea prin adres$ se folose"te atunci cnd o variabil# trebuie redat#
procedurii sau func!iei apelante (adic# un rezultat ob!inut n subprogramul apelat
trebuie returnat subprogramului apelant). Aceast# metod# de transmitere este
semnalat# prin prezen!a cuvntului var n fa!a numelui parametrului formal, dar care
are "i atributul de tip. n acest caz sintaxa va fi urm#toarea:
Procedure nume( var nume_parametru:tip_parametru);
Parametrul actual trebuie s# fie o variabil#. Orice opera!ie ce se refer# la
parametrul formal se va efectua direct "i asupra parametrului actual corespunz#tor..
Parametrul actual nu poate s# fie de tip fi"ier. Dac# parametrul actual este o referin!#
la componentele unor variabile structurate, dereper#rile necesare snt executate
naintea activ#rii procedurii.
Subliniem faptul c# parametrul actual nu poate s# fie expresie sau constant#. Nu
exist# nici o conversie implicit# legat# de acest mod de transmitere a parametrilor:
ntreg pentru ntreg, real pentru real, interval pentru interval ("i nu un interval
oarecare al aceluia"i tip de baz#).
Exemplul cu programul patrulater3 prezint# mecanismul de transmitere a
parametrilor prin valoare.
Folosind mecanismul de transmitere prin adres# pogramul precedent va avea forma
urm#toare:
46
Program patrulater4;
Var AB, BC, CD, DA, BD,s#,s2:real;
Procedure aria(a,b,c:real; var s:real;);
Var p:real;
Begin p:=(a+b+c)/2; S:= sqrt(p*(p-a)*(p-b)*(p-c)); end;
Begin readln(AB,BC,CD,DA,BD);
aria(AB,DA,BD,S#);
aria(BC,CD,BD,S2);
writeln(S=,S#+S2);
End.
Se vede c# transmiterea parametrilor ntre AB "i a; DA "i b; BD "i c etc. a fost
f#cut# prin valoare, iar dintre S$ "i S (S2 "i S) prin adres#.
Declara!ii anticipate
Una dintre regulile de baz# ale limbajului Pascal este c# locul de defini!ie al
unui nume trebuie s# fie naintea utiliz#rii numelui respectiv. Astfel, compilatorul
poate s# efectueze, printr-o singur# trecere peste programul surs#, toate verifc#rile
necesare. Respectarea acestei reguli n unele cazuri ntmpin# greut#!i. S# consider#m
urm#torul exemplu: un program declar# dou# proceduri P "i Q astfel nct nici una nu
este declarat# n cadrul celeilalte. n afar# de aceasta, s# presupunem c# procedura P
activeaz procedura Q, iar procedura Q activeaz# la rndul ei pe P. n acest caz,
oricare ar fi forma textual# a programului, utilizarea numelui uneia dintre proceduri
apare naintea locului de definire a ei.
Pentru rezolvarea acestei probleme, n limbajul Pascal a fost introdus#
directiva forward prin care se pot separa fizic cele dou# componente de baz# ale
declara!iei unei proceduri: antetul procedurii de blocul procedurii. Directiva forward,
a"ezat# imediat dup# antet, nlocuie"te blocul programului "i permite apari!ia textual#
a blocului undeva mai jos n program, unde va fi precedat numai de identificatorul
subprogramului. Astfel, lista parametrilor formali se specific# numai n declara!ia
forward ("i nu se mai repet# "i n declara!ia de procedur# sau func!ie).
procedure Q(x,y,z:integer); forward;
procedure P (u, v, w: integer);
Begin Q(2,3,4); end;
procedure Q;{nu se repeta tipul parametrilor lui Q}
begin P(5,6,7); end;

4.4.2 Func!ii
n Pascal func!iile snt acelea"i subprograme ca "i procedurile. Adic# ca "i n
cazul procedurilor, redactnd corpul unui subprogram-func!ie o singur# dat# n partea
declara!iei subprogramelor, mai apoi putem apela la aceast# func!ie n orice loc al
programului principal, folosind numai numele func!iei respective. ns# exist# "i
diferen!e dintre proceduri "i func!ii. S-a spus c# procedura calculeaz# cteva valori, pe
cnd func!ia- numai una, permi!nd ca apelul ei s# se fac# chiar din expresia care are
nevoie de valoarea calculat#. Adic# n Pascal func!ia este un subprogram, care
calculeaz# "i ntoarce programului apelant o singur# valoare. n acela"i timp snt
permise numai a"a func!ii, valorile c#rora snt de tipuri simple. n a"a fel valoarea
47
unei func!ii nu poate fi nici ntr-un caz un masiv, o mul!ime sau o orecare alt# valoare
de tip compus.
n particular, orice expresie aritmetic# sau logic# n Pascal, care poate nici nu
folose"te no!iunea de func!ie, determin# o dependen!# func!ional# orecare. ns# nu
orice dependen!# func!ional# poate fi redat# n limbajul algoritmic folosind regulile
sintaxice matematice. n unele cazuri valoarea func!iei este determinat# de un proces
de calcul destul de complicat. De exemplu binecunoscuta dependen!a func!ional# din
matematc# n! (factorial) este imposibil de redat n Pascal cu ajutorul unei expresii
aritmetice de forma $*2*3**n din cauza restric!iilor impuse de c#tre sintaxa
acestui limbaj. Aceast# problem# este u"or de rezolvat cu ajutorul unei consecutivit#!i
de operatori. De exemplu: y:=#; for i:=# to n do y:=y*i;
*i dac# necesitatea folosirii acestei dependen!e func!ionale ntr-un program Pascal
este ntlnit# de mai multe ori, ar fi ra!ional# determinarea unei func!ii pentru
calcularea ei "i apelarea func!iei n locul dorit. Sintaxa de declarare a unei func!ii n
Pascal este urm#toarea: Function nume(parametri formali): tip_func"ie; unde prin
parametri formali se subn!elege lista numelor "i tipurilor acestor parametri.
n Pascal este posibil# declararea unei fun!ii "i f#r# parametri ca "i n cazul
procedurii. Parametrii func!iei (n caz c# snt necesari) pot fi "i parametri-valori "i
parametri-adrese. Lista parametrilor are sintaxa identic# ca "i la procedur#. Mai mult
ca att, tot ceea ce a fost spus la procedur# despre parametri formali "i actuali sau
domeniul de vizibilitate este aplicabil "i n cazul func!iei. Antetul func!iei se termin#
cu indicarea tipului valorii func!iei descrise. Acest tip trebuie s# fie un tip deja
predefinit n Pascal sau n prealabil declarat n programul principal. Rezultatul
calculat de o func!ie este asociat numelui ei, care a"a cum se vede din antet este
caracterizat de un tip concret. Numele func!iei apare ca o variabil# n cadrul blocului
unde a fost declarat# func!ia. De aceea numele func!iei trebuie s# fie folosit n cadrul
corpului func!iei n partea stng# m#car a unei atribuiri. Rezultatul func!iei va fi
ultima valoare astfel atribuit#. Apelul de func!ie este un operand ntr-o expresie. El se
insereaz# n locul n care este cerut# valoarea calculat# de func!ie. Cnd expresia este
evaluat# func!ia este activat#, iar valoarea operandului devine valoarea ntoars# de
func!ie.
n a"a mod au fost desf#"urate cele 3 deosebiri sintactice la declarare dintre
procedur# "i func!ie:
$) Descrierea func!iei se ncepe cu cuvntul cheie function
2) n antetul func!iei este indicat tipul valorii descrise de func!ie.
3) Corpul func!iei trebuie s# con!in# m#car o instruc!iune de atribuire, n partea stng#
a c#reie figureaz# numele func!iei "i aceast# instruc!iune trebuie s# fie executat#.
Adic# valoarea func!iei trebuie s# fie schimbat# in interiorul s#u. Ca exemplu s#
descriem func!ia n!(factorial) cu ajutorul unei func!ii Pascal.
Program factorial#;
Var z:integer; s:real;
Function fact(n:integer):integer;
Var i,k:integer;
Begin k:=#; for i:=# to n do k:=k*i; fact:=k; end;
Begin writeln(culege o cifr! ntreag!); readln(z);
48
Writeln(z,!=,fact(z)); {folosirea nemijlocit! a func"iei}
S:=#35+sin(62)*fact(z)/#0; {folosirea func"iei ca operand}
End.
Efect colateral
n general scopul unei func!ii este s# furnizeze ca rezultat o singur# valoare.
Aceast# valoare urmeaz# s# fie utilizat# n evaluarea unei expresii n programul
apelant. Astfel, singura interfa!# natural# dintre o func!ie "i programul apelant este
acest rezultat.
Prin efect colateral se n!elege o atribuire (ntr-o declara!ie de func!ie) a unei
valori la o variabil# nelocal# func!iei sau la un parametru variabil. Aceast# atribuire
complic# n mare m#sur# verificarea "i depanarea programelor. Din acest motiv se
recomand# evitarea utiliz#rii unor func!ii ce pot provoca efecte colaterale.
Exemplu:
program efectcolateral;
var a,b:integer;
function par(x:integer):integer;
begin b:=b-x;{efect colateral asupra lui b} par:=x*x; end;
begin b:=#0;
a:=par(b);
writeln(a,b);
end.
Programul produce urm#toarele rezultate:($00 0 ).

4.4.3 Tipul procedur$ #i func!ie
0 defini!ie de tip procedur# sau tip func!ie permite manipularea dinamic# a
subprogramelor (adic# a codului subprogramelor). Aceasta nseamn# c# un nume de
subprogram poate fi atribuit la o variabil# de tip procedur# sau func!ie. De asemenea,
un nume de subprogram poate fi plasat ca "i parametru actual la apeluri. O defini!ie
de tip procedur# specifc# numele tipului, numele "i tipul parametrilor; la o defini!ie
de tip func!ie apare "i tipul valorii returnate de func!ie.
De exemplu: type tipf = function (x, y: integer) : integer;
tipp = procedure(var n:real; v:integer);
var fl,f2:tipf;{variabile de tip functie}
p;tipp; {variabila de tip procedura}
De men!ionat c# la defni!ia tipului nu apare nici un fel de nume de
procedur#/func!ie.
Avnd o definire de func!ie de forma:
Function f (x, y: integer): integer;
Begin f:=x+y+#; end.
este posibil# o atribuire de forma: f # :=f;
Exemplu. n acest exemplu este definit un tip func!ie numit tipf. Se realizeaz# un apel
direct "i indirect al procedurii apelparf cu parametri actuali de tip procedur#:



49
{$F+}
program tip;
type tipf : function(x,y:integer):integer; {func"ie fara nume}
var varf:tipf;
procedure apelparf(fpar:tipf; x,y:integer);
begin writeln(fpar(x,y));{apel parametru functie} end;
function aduna(x,y:integer):integer;
begin aduna:=x+y; end;
function scade(x,y:integer):integer;
begin scade:=x-y; end;
begin {apel direct}
apelparf(aduna,2,3); apelparf(scade,2,3);
{apel indirect}
varf:=aduna;{o atribuire, nu un apel} apelparf(varf,4,5);
varf:=scade; apelparf(varf,4,5); end.
Observa!ii:
- Folosirea variabilelor de tip procedur# sau func!ie este permis# numai atunci cnd
compilarea se face sub controlul directivei {$F+}.
- O declara!ie de procedur#/func!ie genereaz# implicit o variabil# de tip
procedur#/func!ie. Numele acestei variabile este chiar numele folosit n declara!ie.
Variabila astfel generat# con!ine adresa codului obiect generat de declara!ia de
procedur#/func!ie,
- Dac# parametrul actual este o variabil# de tip procedur#/func!ie, parametrul formal
corespunztor trebuie s# fie de tip procedur#/func!ie. Listele de parametri trebuie
s# fie compatibile (acela"i num#r, nume "i tip de parametri; la func!ii trebuie s#
coincid# "i tipul valorilor retunate).

4.4.4 Apel recursiv de subprograme
Folosirea numelui procedurii (func!iei) n cadrul textului procedurii (func!iei)
se nume"te apel recursiv de procedur# (func!ie), lucru permis n limbajul Pascal.
Men!ion#m totu"i c# folosirea tehnicilor recursive nu constituie ntotdeauna solu!iile
optime. n exemplul urm#tor se apeleaz# recursiv func!ia putere, destinat# calcul#rii
bazei la puterea exponent:
program testputere;
function putere(baza,exponent:integer):integer;
begin if exponent <= 0 then putere:=# else putere:=baza*
putere(baza,exponent-#); end;
begin writeln('2^4=',putere(2,4)); end.
Observa!ii: La orice apel de procedur# n stiv# vor fi depuse urm#toarele informa!ii:
- adresa de retur (adic# adresa instruc!iunii ce urmeaz# dup# apel);
- valorile parametrilor transmi"i prin valoare;
- adresele parametrilor variabili
Astfel, la apeluri recursive, spa!iul ocupat din stiv# va cre"te rapid, riscnd dep#"irea
spa!iului rezervat stivei. La programe recursive se recomand# activarea controlului de
dep#"ire de stiv# prin directiva de compilare {$S +}.
50
BIBLIOGRAFIA

Nr.
crt.
Denumirea lucr#rii (manual,
material didactic,ndrumar)
Autor Anul edit#rii
$. Pascal "i Turbo Pascal B#l#nescu T. ".a $992
2. Ini!iere n Turbo Pascal Kalisz E. $997
3. Pascal pe interesul tuturor Anghel,Florin Stnga $992
4. Turbo Pascal 6.0 Ghid de utilizare Sandur Covax $993
5. Turbo Pascal 6.0 Programe Lucian Vasiu ".a. $994
6. Prelucrarea fi"ierelor n Pascal Ro"ca I. $994
7. ndrumare metodic# de laborator
N5$0
FCIM $996
8. Calculatoare personale Gremalschi A. $997
9. Structura calculatoarelor numerice Gremalschi A. $996
$0. Limbajele C "i C++ pentru
ncep#tori
Negrescu L. $996
$$. Turbo C++ Cojocaru C, O. $994
$2. +,-.-/0- , 1234 5674689 :;<6=%, +.>. $988
$3. +,-.-/0- , ?<%@<6==0<%,6/0-
/6 1234- 5674689
'<;7, A6B/C-'<0D,
EF%89C, GFF%.

$989
$4. +3H0780F-89/61 F-D/046 0
?<%@<6==0<%,6/0-

:8-47--, +.I.

$99$
$5. :/@8%-<J7740B 78%,6<9 ?%
?<%@<6==0<%,6/0K 0
0/L%<=6F04-

&%<4%,740B :.&.

$992
$6. MJ774%-6/@8%-/-=-C4%-
L<6/CJ2740B 78%,6<9 ?%
,3H0780F-89/%B F-D/04-

)678%,740B I.N.

$990
$7. O234 ?<%@<6==0<%,6/01 (0 N-</0@6/ &. M0FH0 P. $992
$8. 5<%@<6==0<%,6/0- /6 1234- (0
.81 ?-<7%/689/3D 4%=?9KF-<%,

><0@%<9-, :.

$990
$9. 5<%@<6==0<%,6/0- /6 1234-
(0, 7?<6,%H/%- ?%7%;0-

N%F80/7461 >.5.

$99$