Utilizarea Calculatoarelor: &dphold Dyulo 9Lruho3Hwuhkxú

UTCB
UNIVERSITATEA TEHNICA DE CONSTRUCTII

BUCURESTI
&DPHOLD*DYULO 9LRUHO3HWUHKXú
UTILIZAREA
CALCULATOARELOR
/HFLLSHQWUXVWXGHQLLDQXOXL,
1
UTCB
0. Introducere
/HFLLOHGHIDUHSUH]LQWFRQLQXWXOFXUVXOXLGHSURJUDPDUHGLQFDGUXO
GLVFLSOLQHL8WLOL]DUHD&DOFXODWRDUHORUOD)DFXOWDWHDGH,QVWDODLLGLQFDGUXO
87&%LQXWGHDXWRUL
2YHUVLXQHWLSULWPDLvQWLQVDDSUXWODHGLWXUD87&%vQDQXO
XQGHPDLHUDXFRDXWRUL$QFD,RUGQHVFXúL&HFLOLD5DGX0DWHULDOXOGHID
UHSUH]LQWSDUWHDGHSURJUDPDUHvQ3DVFDOFDUHDIRVWVFULVvQSURSRULHGH
GH&*DYULOúL93HWUHKXú
%XFXUHúWLIHEUXDULH
2
UTCB
Programare în limbajul Pascal
3XQHUHDúLUH]ROYDUHDXQHLSUREOHPHSHFDOFXODWRU
In mod natural, rezolvarea cu calculatorul a unei probleme conduce la

XUPWRDUHOHHWDSH
DQDOL]D vQHOHJHUHD SUREOHPHL úL VWDELOLUHD FHULQHORU QHFHVDUH
UH]ROYULLHL
SURLHFWDUHDDOJRULWPXOXLúLYHULILFDUHDOXL
3. realizarea programului(sursa): transpunerea algoritmului intr-un limbaj
de programare (codificarea algoritmului)
FRPSLODUHDSURJUDPXOXLWUDGXFHUHDSURJUDPXOXLvQFRGPDúLQ
UXODUHDSURJUDPXOXLODQVDUHDvQH[HFXLHDSURJUDPXOXL
6. testarea programlui
LPSOHPHQWDUHDSURJUDPXOXLLQWURGXFHUHDvQXWLOL]DUHFXUHQWDDFHVWXLD
1.1. Algoritmi
$OJRULWPXOHVWHRPXOLPHRUGRQDWúLILQLWGHRSHUDLLFXGXUDWILQLW
FHVHH[HFXWDVXSUDXQRUGDWHGHLQWUDUHSURGXFkQGGDWHGHLHúLUH
Un algoritm este:
-generalHVWHDSOLFDELORULFUXLVLVWHPGHGDWHGHLQWUDUHGLQGRPHQLXOGH
GHILQLLH
-secventialILHFDUHRSHUDLHDDOJRULWPXOXLUHSUH]LQWRFRPDQGFDUHVH
H[HFXWGXSFHDUHORFLQFKHLHUHDSUHFHGHQWHL
-FODUúLQHDPELJXX
-finitWUHEXLHVVHWHUPLQHLQWUXQQXPUILQLWGHSDúL
1.2. Reprezentarea algoritmilor
Algoritmii se pot reprezenta prin:

-scheme logige
-limbaj logico-matematic
-limbaj pseudocod
-limbaj de programare
6FKHPDORJLF5HSUH]HQWDUHDJUDILFDELGLPHQVLRQDODXQXLDOJRULWPFX
ajutorul unor simboluri standard: tipuri de operatii ce se executa asupra
datelor care se prelucreaza in algoritm.
3
UTCB
,QUHSUH]HQWDUHDDOJRULWPLORUSULQVFKHPHORJLFHIRORVLPXUPWRDUHOH
simboluri:
VLPEROXULGHLQLLHUHWHUPLQDUH
VLPEROXULSHQWUXSURFHVGHLQWUDUHGDWHLHúLUHGDWH
3. simboluri pentru proces propriu-zis de prelucrare a datelor
4. simboluri pentru proces predefinit (procedura,functie)
VLPEROXULSHQWUXGHFL]LHORJLFVDXDULWPHWLF
VLPEROXULSHQWUXLQGLFDUHDGLUHFLHLGHGHSODVDUHDIOX[XOXL
→
7. simboluri de conectare
n
1.3. Limbaje de programare
/LPEDMHOH GH SURJUDPDUH UHSUH]LQW PRGDOLWL GH FRPXQLFDUH D

DOJRULWPLORUFWUHPDúLQ(OHSRWIL
-GH QLYHO VF]XW OD vQFHSXW OLPEDMXO HUD FRG PDúLQ DSRL D DSUXW
limbajul de asamblare dependent de tipul calculatorului.
-de nivel inalt ; este independent de calculator
)2575$1DIRVWSULPXOOLPEDMGHQLYHOvQDOWXWLOL]DWLQDSOLFDLLWHKQLFR
VWLLQWLILFH &2%2/ D IRVW GH]YROWDW SHQWUX FUHDUHD GH DSOLFDLL HFRQRPLFH
BASIC, ALGOL, PASCAL, C, ADA, MODULA, JAVA sunt câteva din
QXPUXOPDUHGHOLPEDMHDSUXWHSQDVW]L
9HUVLXQLQRLDOHDFHOXLDúLOLPEDMvQFHDUFVLQSDVXOFXQRLOHRULHQWUL
vQ LQGXVWULD LQIRUPDWLF KDUG GLQ FH vQ FH PDL SHUIRUPDQW VLVWHPH GH RSHUDUH
QRLGH]YROWDUHDUHHOHORUGHFDOFXODWRDUH
Pachete de programe dezvoltate pentru anumite probleme devin prin
implementarea unor mecanisme de interpretare a comenzilor limbaje
4
UTCB
VSHFLDOL]DWH $úD DU IL )R[3UR 'EDVH 3DUDGR[ SHQWUX ED]H GH GDWH
Mathematica, Matlab, MathCad pentru calcule matematice.
Orice limbaj de programare contine:
-un vocabular (totalitatea semnelor ce se pot utiliza in continutul
unei propozitii)
- R VLQWD[ WRWDOLWDWHD UHJXOLORU XWLOL]DWH SHQWUX VFULHUHD FRUHFW D
SURSR]LLHL
- RVHPDQWLFWHPDWLFDSULQFDUHXQRUSURSR]LLLOLVHDFRUGXQvQHOHV
1.4. Exemple de reprezentare a algoritmilor
([HPSOXO6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPGH
calcul:
A = x2 + y2
B = x + y + 2 ⋅ A SHQWUX[úL\QXPHUHUHDOH
C = x⋅ y + A+ B
Algoritmul:
VHFLWHVF[úL\
VHFDOFXOHD]$
- se calculeaza B;
- se calculeaza C;
-se scrie A, B, C;
Start
Citeste x, y
A:=x*x+y*y
B:=x+y+A
C:=x*y+A+B
Scrie A, B, C
Stop
([HPSOXO6VHGHVFULHvQOLPEDMSVHXGRFRGXQDOJRULWPGHFDOFXODO
YDORULLXQHLIXQFLL
5
UTCB
 [ + \ ≤ [ − \ ≤
I =
 [ + \ LQ UHVW
Algoritmul:
-start
FLWHúWH x úL y ;
GDF x − y ≥ 0 úL x − y ≤ 10 atunci f:= x 3 + y 3
altfel f:= x 2 + y 2 ;
-scrie valoarea lui f ;
-stop.
6VHGHVFULHvQOLPEDMSVHXGRFRGXQDOJRULWPGHFDOFXODVXPHL
∑ + L respectiv al produsului

∏ ⋅ L − .
=
=
L L
Algoritmul:
-start;
- 6 = 3 =
SHQWUXLGHODODH[HFXW
L
6 = 6 + +

3 = 3 ⋅ ⋅ L −
- scrie S úL P ;
-stop.
([HPSOXO6VHGHVFULHvQOLPEDMSVHXGRFRGXQDOJRULWPGHFDOFXODO
sumei componentelor unui vector: X = (x1 ,x 2 ,...,x n ) unde n se cunoaste.
-start;
-citeste n;
SHQWUXLGHODODQH[HFXW
citeste X (i);
- S:= 0 ;
SHQWUXLGHODODQH[HFXW
S:= S + X [i] ;
-scrie S ;
-stop.
([HPSOXO6VHGHVFULHvQSVHXGRFRGúLFXDMXWRUXOXQHLVFKHPHORJLFH
un algoritm de calcul al lui n!úLVVHWLSUHDVFUH]XOWDWXO
6
UTCB
In pseudocod algoritmul este:

1. p=1; k=1;
2. p=p*k
'DFNQDWXQFLN NúLUHLDGHOD
altfel scrie p
4. Stop.
6FKHPDORJLFHVWH
Start
p:=1
k:=1
p:=p*k
nu da
k<n
k:=k+1
Scrie p
Stop
([HPSOXO6HGúLUXOGHQXPHUH x1 ,x 2 ,...,x n 6VHGHVFULHFX
DMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHGHWHUPLQQXPUXOWHUPHQLORU
úLUXOXLGDWDSDULQLQGLQWHUYDOXOXL [A ,B ] úLVDVHFDOFXOH]HSURGXVXOORU
Start
a[i], i=1,..,n
T:=0
P:=1
i:=1
da
a[i]<=B
nu da
a[i]>=A
T:=T+1
P:=P*a[i]
i:=i+1
nu i<=n
Stop
7
UTCB
([HUFLLL
6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHFDOFXOHD]PHGLD
DULWPHWLFDWHUPHQLORUúLUXOXL x1 ,x 2 ,...,x n FXSULQúLLQWUH$úL%$%
6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHVGHWHUPLQHFHOPDL
PDUHQXPDUúLQXPUXOGHQXPHUHSR]LWLYHGLQWUXQúLUGHQXPHUHGDWH x1 ,x 2 ,...,x100 .
6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHVFDOFXOH]H
c.m.m.d.c. al numerelor pozitive a1 ,a2 ,...,an .
([HUFLWLXO6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHVFDOFXOH]H
produsul scalar al vectorilor:
X = (x1 ,x 2 ,...,x n )
Y = ( y1 ,y 2 ,...,y n ) .
6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHGHWHUPLQQXPUXOGH
coloane cu toate elementele negative dintr-o matrice de tip m × n .
6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHGHWHUPLQFHOPDL
mare element dintr-o matrice de numere cu m OLQLLúL n coloane.
7. Fie (a0,a1,...anúLE0,b1,..bmFRHILFLHQLLDGRXSROLQRDPH6VHDOFWXLDVF

DOJRULWPXOGHFDOFXOSHQWUXFRHILFLHQLLSURGXVXOXL
6VHGHVFULHFXDMXWRUXOXQHLVFKHPHORJLFHXQDOJRULWPFDUHIRORVLQGXQSURFHGHX
LWHUDWLYFDOFXOHD]RYDORDUHDSUR[LPDWLYDVROXLHLHFXDLHL x + x − 1 = 0 FXSULQVLQWUH
3
0 úL1 IUDIRORVLUDGLFDOLPHWRGDWDQJHQWHL

6VHGHVFULHXQDOJRULWPGHUH]ROYDUHDHFXDLHLI[ SHLQWHUYDOXO>DE@SULQ
vQMXPWLUHDVXFFHVLYDLQWHUYDOXOXLúWLLQGFIDIE
10. Fie M o matrice n× QFXHOHPHQWHOHVDX6HQXPHúWHLQVXOvQPDWULFHR

VXEPXOLPHGHHOHPHQWHDVWIHOFDLGHODXQHOHPHQWODDOWXOVHSRDWHDMXQJHSULQHOHPHQWH
YHFLQHGRXFkWHGRXSHRUL]RQWDOYHUWLFDOVDXGLDJRQDOLLGHODQLFLXQHOHPHQWDO
LQVXOHLQXVHSRDWHDMXQJHODXQFHQXHvQLQVXOSULQWUXQúLUGHHOHPHQWHYHFLQH6VH
GHVFULHXQDOJRULWPGHGHWHUPLQDUHDQXPUXOXLGHLQVXOHGLQ0
6HGDXQúLNQXPHUHQDWXUDOHNQ!6VHGHVFULHXQDOJRULWPGHWLSULUHD
WXWXURUVXEPXOLPLORUPXOLPLL^Q`FDUHDXFkWHNHOHPHQWH
6VHGHVFULHXQDOJRULWPGHGHWHUPLQDUHDPRGXULORUGHDúH]DUHDUHJLQHSHWDEOD
GHúDKIUVVHDWDFHXQDSHDOWD
8
UTCB
/LPEDMXO3DVFDO3ULPHOHLQVWUXFLXQL
,QFHOHFHXUPHD]VHYDVWXGLDVLVWHPDWLFOLPEDMXOGHSURJUDPDUH3DVFDO
$FHVWOLPEDMIRVWFRQFHSXWLQDQXOODVFRDOD3ROLWHKQLFGLQ=XULFKGHXQ
FROHFWLYFRQGXVGH1LNODXV:LUWK(OHVWHGHVWLQDWLPSOHPHQWULLSHFDOFXODWRDUH
D DOJRULWPLORU ,Q VD UVSkQGLW vQ OXPHD FHUFHWULL úL D XQLYHUVLWLORU
Limbajul PASCAL a fost ales de diferite firme ca limbaj de dezvoltare de
VRIWZDUH&'&,&/7(;$;,167580(176,17(5'$7$úLDOWHOH
2.1. Structura unui program
8QSURJUDP3DVFDODSDUHFDXQWH[WvQFDUHVHGHOLPLWHD]GLYHUVHVHFLXQL
conform schemei de mai jos:
PROGRAM nume_program ;
USES nume_unit1, nume_unit2 ;
LABEL
GHFODUDLLGHHWLFKHWH
CONST
GHFODUDLLGHFRQVWDQWH
TYPE
GHFODUDLLGHWLSXUL
VAR
GHFODUDLLGHYDULDELOH
GHILQLLLGH352&('85(úL)81&7,21
BEGIN
LQVWUXFLXQLOHSURJUDPXOXLSULQFLSDO
END.
Program, Procedure úL Function se numesc blocuri. Procedure úL
Function SRWDYHDODUkQGXOORUVHFLXQLOHGHPDLVXVFXH[FHSLDVHFLXQLORU
programúLuses.
'LQWUH DFHVWH VHFLXQL program GHILQHúWH EORFXO PD[LP DO
SURJUDPXOXLDSDUHRVLQJXUGDWúLHVWHREOLJDWRULXFDúLSDUWHDGLQWUHbeginúL
endQXPLWSURJUDPXOSULQFLSDO&HOHODOWHVHFLXQLVXQWRSLRQDOHGDUGHRELFHL
VHFLXQHD var HVWH QHOLSVLW $LFL VXQW GHFODUDWH GDWHOH FX FDUH RSHUHD]
OLPEDMXOúLFDUHVHSRWPRGLILFDvQFXUVXOH[HFXLHL
Programul scris ca text Pascal cu ajutorul unui editor de texte
oarecare, numit SURJUDPVXUVVXIHURVHULHGHWUDQVIRUPULSkQDMXQJHVXE
IRUPH[HFXWDELOWUDQVIRUPULHIHFWXDWHGHSURJUDPHVSHFLDOL]DWHDOHPHGLXOXL
de programare utilizat. Ne vom referi mai departe la mediul de programare
Turbo Pascal, versiunea 6.0 sau la mediul Borland Pascal 7.0. Acest proces de
9
UTCB
WUDQVIRUPDUHSHQWUXPXOWHOLPEDMHHVWHvPSULWvQGRXID]HQXPLWHcompilare
úL linkeditare VDX HGLWDUHD OHJWXULORU ,Q 7XUER 3DVFDO DFHVWH ID]H DX IRVW
FRPDVDWH vQ XQD VLQJXU QXPLW FRPSLODUH 3ULQ DFHDVWD WH[WXO 3DVFDO HVWH
WUDQVIRUPDW vQWUR VHFYHQ GH RFWHL QXPLW SURJUDP H[HFXWDELO $FHDVW
SURJUDPHVWHSVWUDWILHSHGLVFILHvQPHPRULDFDOFXODWRUXOXLúLSRDWHILH[HFXWDW
ODQHYRLH$FHDVWWUDQVIRUPDUHvQSURJUDPH[HFXWDELOSRDWHILLQIOXHQDWSULQ
directive de compilarePLFLWH[WHSXVHGLQORFvQORFvQSURJUDPXOVXUVSULQ
FDUH VH VSHFLILF SDUWLFXODULWWL GH WUDQVODLH D SURJUDPXOXL VXUV 'XS
FRPSLODUH SURJUDPXO SRDWH IL ODQVDW vQ H[HFXLH 0HGLXO GH GH]YROWDUH 7XUER
3DVFDO SXQH OD GLVSR]LLH IDFLOLWL SHQWUX UHDOL]DUHD WXWXURU SDúLORU QHFHVDUL
RELQHULLIRUPHLH[HFXWDELOHDSURJUDPXOXL
2.2. Utilizarea mediului de dezvoltare Turbo Pascal
0HGLXOGHSURJUDPDUH7XUER3DVFDOQHSXQHODGLVSR]LLHXQHGLWRU
de texte performant pentru scrierea programului, compilator pentru
WUDQVIRUPDUHD WH[WXOXL vQ ILúLHU H[HFXWDELO, un depanator pentru a asista
programatorul la depistarea erorilor 7RDWH DFHVWH IDFLOLWL VH DSHOHD] SULQ
PHQLXULIUDSUVLPHGLXO7XUER3DVFDO)HUHDVWUDGHED]DPHGLXOXLFRQLQH
meniurile: File, Edit, Search, Run, Compile, Debug, Tools, Options,
Window, Help,FDUHFkQGVXQWDSHODWHDUDWVXEPHQLXULPDLVSHFLDOL]DWH
• (GLWDUHDSURJUDPXOXLVHIDFHODIHOFDúLFXDOWHGLWRU:RUNV(GLWHWF
• 3HQWUXH[HFXLHWH[WXOSURJUDPXOXLWUHEXLHcompilatIRORVLQGRSLXQHD
&RPSLOHGLQPHQLXO&RPSLOHVDXFRPELQDLDGHWDVWH$OW)'DFVHJVHVF
HURUL GH VLQWD[ QX GH ORJLF VH RSUHúWH FRPSLODUHD OD SULPD HURDUH FDUH H
VHPQDOL]DWúLXUPHD]VILHH[DPLQDWúLFRUHFWDWGHSURJUDPDWRU
• /DQVDUHDvQH[HFXLHDSURJUDPXOXLVHIDFHFXRSLXQHD5XQGLQPHQLXO
5XQVDXFRPELQDLD&WUO)5H]XOWDWHOHVHDILúHD]vQWURIHUHDVWUGLIHULWGHD
HGLWRUXOXL úL GH DFHHD SHQWUX D OH YHGHD DSVP $OW) FDUH FRPXW vQWUH
IHUHDVWUDHGLWRUIHUHDVWUD(GLWúLIHUHDVWUDFXUH]XOWDWHIHUHDVWUD2XWSXW
• ,QFD]FSURJUDPXOGUH]XOWDWHQHDúWHSWDWHvQVHDPQFHRHURDUHvQ
ORJLFDGHFRQVWUXLUHDOXL,QDFHVWFD]vOSXWHPODQVDvQH[HFXLHFX6WHSRYHU
VDX 7UDFH LQWR GLQ PHQLXO 5XQ UHVSHFWLY WDVWHOH ) VDX ) úL VO H[HFXWP
LQVWUXFLXQH FX LQVWUXFLXQH 'XS ILHFDUH OLQLH GH SURJUDP VH DúWHDSW SkQ
DSVPGLQQRX)VDX)FDVVHH[HFXWHOLQLDXUPWRDUH,QDFHVWWLPSSXWHP
V GHVFKLGHP R IHUHDVWU :DWFK PHQLXO 'HEXJ RSLXQHD :DFK vQ FDUH V
LQFOXGHPYDULDELOHPHQLXO'HEXJRSLXQHD$GGZDFKVDXWDVWHOH&WUO)D
FURUPRGLILFDUHRXUPULPH[HFXWkQGSURJUDPXOSDVFXSDV,QPRPHQWXOFkQG
YDORULOHORUGHYLQQHYHURVLPLOHYHGHPFHLQVWUXFLXQHGLQSURJUDPVDH[HFXWDW
úLJVLPSUREDELOHURDUHDGHSURJUDPDUH
10
UTCB
• 0HGLXO DUH XQ SURJUDP GH DMXWRU +HOS $SVDUHD WDVWHORU &WUO)
ODQVHD] SURJUDPXO +HOS FX LQIRUPDLL GHVSUH QRLXQHD XQGH H FXUVRUXO vQ
IHUHDVWUD (GLW LDU DSVDUHD WDVWHL ) ODQVHD] SURJUDPXO +HOS FX H[SOLFDLL
GHVSUHIHUHDVWUDDFWLY6HSRWDOHJHGLQPHQLXO+HOSGLYHUVHQRLXQLGHVSUHFDUH
VHSULPHVFH[SOLFDLLGHVWXOGHWDOLDWHXQHRULFXH[HPSOH
2.3. Vocabularul limbajului
&DUDFWHUHOHFHDOFWXLHVFOLPEDMXO7XUER3DVFDOVXQWFLIUH0-9),
litere (a-z,A-ZúLVLPEROXULVSHFLDOHFXPDUILRSHUDWRULL(+ - * / div mod = <>
< > <= >= not and or := in ^úLGHOLPLWDWRULL( ) ‘ . , : ; { } ... .Limbajul
7XUER 3DVFDO FXSULQGH XUPWRDUHOH FXYLQWH FKHLH FH DX R VHPQLILFDLH ELQH
VWDELOLWabsolute, and, array, begin, case, const, div, do, downto, else, end,
external, file, for, forward, function, goto, if, implementation, in, inline,
interface, interrupt, label, mod, nil, not, of, or, packed, procedure,
program, record, repeat, set, shl, shr, string, then, to, type, unit, until, uses,
var, while, with, xor.
8QLGHQWLILFDWRUVHGHILQHúWHFDILLQGRVHFYHQGHOLWHUHúLFLIUH
FXSULPXOFDUDFWHUOLWHUGHOXQJLPHGHFDUDFWHUH'DFLGHQWLILFDWRUXODUH
PDL PXOWH FXYLQWH DFHVWHD VXQW OHJDWH SULQWUR OLQLX GH VXEOLQLHUH H[HPSOX
nr_întreg).
In program se pot introduce comentarii cu rol explicativ între paranteze
DFRODG ³^ `´ VDX vQWUH SDUDQWH]H URWXQGH úL DVWHULVFXUL ³ ´ $FHVWH
FRPHQWDULLQXDIHFWHD]H[HFXLDSURJUDPXOXL
3HQWUXVHSDUDUHDLQVWUXFLXQLLORUVHIRORVHúWHFDUDFWHUXO³´
2.4. Tipuri simple de date
/LPEDMXO7XUER3DVFDOFRQLQHWLSXULGHGDWHVWDQGDUGFHVXQWSUHGHILQLWH
úL WLSXUL QRL GH GDWH FRQVWUXLWH GH XWLOL]DWRU 7LSXULOH VLPSOH GH GDWH DOH
limbajului standard sunt:integer, real, char, boolean.
7LSXULOHQXPHULFHúLRSHUDWRULLDULWPHWLFL
1XPHUHOHvQWUHJLVHQRWHD]vQ3DVFDOvQPRGRELúQXLW
HWF 1XPHUHOH UHDOH VH QRWHD] FX SXQFW vQ ORF GH YLUJXO ]HFLPDO GXS
PRGHOXO DQJORVD[RQ HWF 'H DVHPHQHD VH IRORVHúWH
SHQWUX UHSUH]HQWDUHD QXPHUHORU UHDOH IRUPD H[SRQHQLDO ( vQVHDPQ
× − LDU ( vQVHDPQ − × . Tipurile integer úL real descriu

QXPHUH úL GH DFHHD VH QXPHVF úL GDWH QXPHULFH (OH VXQW GH PDL PXOWH WLSXUL
GXSFXPVHDUDWvQWDEHOHOHFDUHXUPHD]
11
UTCB
7LSXULOHvQWUHJLVXQWXUPWRDUHOH
WLSGHGDWGRPHQLXGHYDORULPRGGHUHSUH]HQWDUH
byte ELLIUVHPQ
ShortInt ELLFXVHPQ
word ELLIUVHPQ
integerELLFXVHPQ
LongInt ELLFXVHPQ
7LSXULOHUHDOHVXQWXUPWRDUHOH
WLSGDW domeniu de valori mod de reprezentare

real 2.9E-39..1.7E39 RFWHL FLIUH
senmificative
single 1.5E-45..3.4E38 RFWHL FLIUH
semnificative
double 5.0E-324...1.7E308 RFWHL FLIUH
semnificarive
extended 3.4E-4932..1.1E4942 RFWHL FLIUH
semnificative
comp -2E63+1...2E63-1 RFWHLFLIUH
2EVHUYDLH 7LSXO comp este un tip întreg cu valori din intervalul

SUHFL]DWGDUvQFDOFXOHLQWUFDXQQXPUUHDOIUSDUWH]HFLPDO
2SHUDLLOH DULWPHWLFH FH VH H[HFXW FX GDWHOH QXPHULFH VXQW GDWH GH
XUPWRDUHOHQRWDLL+ pentru adunare, - pentru VFGHUH pentru vQPXOLUH
pentruvPSULUH cu rezultat real, divSHQWUXvPSULUHDXQRURSHUDQ]LvQWUHJLFX
rezultat întreg, modSHQWUXUHVWXOvPSULULLvQWUHJLDXQRURSHUDQ]LvQWUHJL
7LSXOORJLFERROHDQúLRSHUDWRULLORJLFL
7LSXO ORJLF UHSUH]LQW YDORULOH ORJLFH DGHYUDW true) sau fals (false).
2SHUDLLOH FX YDORUL ORJLFH VXQW not (nu logic), and úL ORJLF or (sau logic),
xor VDX H[FOXVLY 2SHUDWRUXO QRW HVWH SULRULWDU FHORUODOL RSHUDWRUL ORJLFL
Operatorul andDUHDFHHDúLSULRULWDWHFDúLRSHUDWRULLDULWPHWLFL GLYúLPRG
Operatorii or úL xorDXDFHHDúLSULRULWDWHFDúLRSHUDWRULLDULWPHWLFLúL,QPRG
X]XDO YDORULOH ORJLFH VH RELQ SULQ FRPSDUDLL úL RSHUDLL ORJLFH 3HQWUX
FRPSDUDLLVHIRORVHVFVHPQHOH ! !
&RPSDUDLD 1RWDLDvQ3DVFDO Exemplu
= = 2=3 are valoarea false
≤ <= 2<=3 are valoarea true
12
UTCB
< < 3<2 are valoarea false

≥ >= 4>=4 are valoarea true
> > 3>6 are valoarea false
Exemplu: (3>5) and (x<=3) or not a are valoarea trueGDFa este false
2.4.3.Tipul caracter (Char)
Caracterele sunt reprezentate în calculator pe un octet. Codificarea pe

FDUH R UHVSHFW OLPEDMXO 7XUER 3DVFDO HVWH $6&,, FRGLILFDUH SULQ FDUH VH
DVRFLD]ILHFUXLQXPU Q XQVLPEROOLWHUFLIUVHPQXO SDUDQWH]H
HWF /D H[HUFLLL HVWH GDW XQ PLF SURJUDP FDUH OLVWHD] FRGXULOH $6&,, DOH
caracterelor. Caracterele cu numerele de ordine mai mic de 32 nu au simboluri
VWDQGDUGDVRFLDWHúLVHIRORVHVFSHQWUXDWUDQVPLWHFRPHQ]LFWUHGLYHUVHDSDUDWH
conectate la calculator, în primul rând imprimanta. Ele au denumiri ca Escape,
Enter, PgUp, LF, etc.
([LVWGLIHULWHPRGXULGHVFULHUHDFRQVWDQWHORUGHWLSFDUDFWHUGXSFXP
XUPHD]
- un caracter scris între apostrofuri (exemplu:'q' ; '[' etc.)
XQ QXPU vQWUH úL SUHFHGDW GH FDUDFWHUXO H[HPSOX
UHSUH]LQW FRGXO WDVWHL (QWHU $FHVW PRG HVWH XWLO SHQWUX LQWURGXFHUHD
FDUDFWHUHORUFHQXDXVLPERODVRFLDWSHRWDVW3HQWUXDFHDVWDDYHPQHYRLHGH
XQWDEHOFXQXPHUHOHDVRFLDWHILHFUXLFDUDFWHU
- un caracter precedat de simbolul ^ :permite exprimarea caracterelor de
control de la 0 la 31 (exemplu: Â este tot una cu #1, ^B este #2, ^F este #6,
^[ este #27, respectiv ESC) . In general ^semnvQVHDPQFDUDFWHUXOFXQXPUXO
de ordine cu 64 mai mic decât al lui semn.
Cu tipurile de date de mai sus se pot construi expresii utilizând
SDUDQWH]HOH

úL

vQPRGX]XDO
Exemple de expresii numerice:
2+(12+1.3e-4-14/1.75)/(1-1.45e-3) ; 2*(12e-1+1.43e-3)*(1.54-(3-
1.2))/3.14;
Exemple de expresii logice:
((2.1/4.5-11)>1.) or (1.5/2.2-14>0) ; not(1>5) and (3-4<0);
,QH[SUHVLLSRWLQWUDúLPULPLYDULDELOHDúDFXPYHGHPvQFRQWLQXDUH1.7
9DULDELOHúLFRQVWDQWHVLPSOH
3HQWUXFDRGDWGHWLSXOGHPDLVXVVSRDWVXIHULPRGLILFULvQWLPSXO
UXOULLXQXLSURJUDPWUHEXLHGHFODUDWHvariabileGHWLSXOUHVSHFWLY2GHFODUDLH
GH YDULDELOH LQGLF SURJUDPXOXL UH]HUYDUHD vQ PHPRULD FDOFXODWRUXOXL D XQHL
]RQHGHDWkLRFWHLFkLVHVSHFLILFSHQWUXWLSXOUHVSHFWLYGHYDULDELO,QDFHD
13
UTCB
]RQ GH PHPRULH VH SXQ YDORULOH SH FDUH OH LD YDULDELOD UHVSHFWLY 2 YDORDUH
QRX DWULEXLW DFHOHL ]RQH LPSOLF DXWRPDW úWHUJHUHD YDORULL YHFKL 'HFODUDUHD
YDULDELOHOHRUVHIDFHvQVHFLXQHD9$5úLHVWHGHIRUPD
nume_variabila:tip_variabila;
De exemplu:
VAR
x,y,x:real; i1,i2:integer; c1,c2:char; b1:byte
vQVHDPQ F vQ SURJUDPXO QRVWUX YRP DYHD QXPHUHOH UHDOH SH FkWH
RFWHLILHFDUH[\]QXPHUHOHvQWUHJLLúLLSHFkWHGRLRFWHLGRXFDUDFWHUH
FFúLEGHWLSE\WHWRDWHPRGLILFDELOH
2H[SUHVLHSRDWHFRQLQHFRQVWDQWHúLYDULDELOHFDGHH[HPSOX
(x>1.2) and (12/y-11<0) or L;
$LFL[úL\WUHEXLHVILHQXPHUHLDU/WUHEXLHVDLEWLSXOERROHDQSHQWUX
FDH[SUHVLDVDLEVHQV
&RQVWDQWHOHVHGHFODUvQVHFLXQHD&2167úLDXGRXVHPQLILFDLL
i) LGHQWLILFDWRULGHYDORULFHQXVHVFKLPEvQFXUVXOSURJUDPXOXL:
CONST
a=2; x=120.34; q='W'; L=TRUE;
$LFLD[VXQWQXPHUHTHFDUDFWHU/HFRVWDQWORJLF
ii) LGHQWLILFDWRULGHYDULDELOHLQLLDOL]DWH
CONST
a:integer=2; x:real=120.34; q:char='W'; l:logical=TRUE;
,QVWUXFLXQHDGHDWULEXLUH
,QVWUXFLXQHDGHDWULEXLUHDUHIRUPD
YDULDELO H[SUHVLH
úL DUH FD HIHFW DVRFLHUHD YDORULL H[SUHVLHL GLQ PHPEUXO GUHSW YDULDELOHL
GLQPHPEUXOVWkQJ&HLGRLPHPEULLVXQWvQWRWGHDXQDVHSDUDLSULQ:=
7UHEXLH DYXW JULM FD YDULDELOD úL H[SUHVLD V ILH GH DFHODúL WLS VDX
tipuri compatibile.
Exemplu de atribuire :
program atribuire;
var i,j:integer;
r:real;
l:boolean;
begin
i:=15;
14
UTCB
j:=(9+i*2) div 4;
r:=3.6*(i+j)/(4+i*i);
l:=true;
end.
,Q LQVWUXFLXQHD GH DWULEXLUH SDUWHD VWkQJ HVWH R YDULDELO LDU SDUWHD
GUHDSWRH[SUHVLH
,QVWUXFLXQLGHFLWLUHúLVFULHUH
,QVWUXFLXQLOHGHFLWLUHVXQWXUPWRDUHOH
read(variabila);
úL
readln(variabila);
(IHFWXO LQVWUXFLXQLL GH FLWLUH HVWH XUPWRUXO VH FLWHúWH GH OD
WDVWDWXU YDORDUHD LQWURGXV GH FWUH XWLOL]DWRU YDORDUHD ILLQG SUHOXDW GXS
DSVDUHD WDVWHL (17(5 GXS FDUH YDORDUHD FLWLW VH DWULEXLH YDULDELOHL
YDULDELOD
/DLQVWUXFLXQHDGHFLWLUHUHDGOQYDULDELODFXUVRUXOYDILSR]LLRQDW
OD vQFHSXWXO OLQLHL XUPWRDUH 9DORDUHD LQWURGXV GH OD WDVWDWXU WUHEXLH V ILH
FRPSDWLELOFXWLSXOYDULDELOHLDOWIHOVHDILúHD]XQPHVDMGHHURDUH
2EVHUYDLH9DORULOHGHWLSERROHDQQXSRWILFLWLWHFLGRDUWLSULWH
,QVWUXFLXQLOHGHVFULHUHVXQWXUPWRDUHOH
write('mesaj');
are ca efect scrierea pe ecran a mesajului cuprins între apostrofuri :
'mesaj'
ZULWH
QXPUXOHVWH
QU
DUHFDHIHFWVFULHUHDSHHFUDQDPHVDMXOXLFXSULQVvQWUHDSRVWURIXULúLDSRL
WLSULUHDYDORULLYDULDELOHLQU
write(nr);
DUHFDHIHFWDILúDUHDYDORULLYDULDELOHLQU
$FHODúLHIHFWvODXLQVWUXFLXQLOHGHVFULHUH writelnGRDUFVHWUHFH
ODOLQLDXUPWRDUH'DFYDULDELODGHVFULVHVWHQXPUUHDOSXWHPXWLOL]D
write(variabila:m:n); writeln(variabila:m:n);
FDUHDUHFDHIHFWVFULHUHDOXLYDORULLOXLYDULDELODSHPSR]LLLGLQFDUHQ
zecimale.
'DFVHGRUHúWHFLWLUHDVDXúLVFULHUHDPDLPXOWRUYDULDELOHDFHVWHD
YRUILGHVSULWHSULQYLUJXO'HH[HPSOXLQVWUXFLXQHD
read(a,b,c);
DúWHDSWLQWURGXFHUHDGHODWDVWDWXUDWUHLYDULDELOHFHYRUILDWULEXLWHOXL
a,b,c).
15
UTCB
Exemplu:
program citire_scriere;
var a,b,c:integer;
d:real;
begin
ZULWHµSULPXOQXPUHVWH¶
{scrie pe ecran mesajul dintre apostrofuri}
readln(a);
^FLWHúWHGHODWDVWDWXUYDORDUHDOXLDúLWUHFHODOLQLDXUPWRDUH`
ZULWHµDOGRLOHDQXPUHVWH¶
readln(b);
d:=(a+b)/2;
^FDOFXOHD]H[SUHVLDDEúLLRDWULEXLHYDULDELOHLG`
ZULWHµPHGLDDULWPHWLFDFHORUGRXQXPHUHHVWH¶G
^VFULHPHVDMXOGLQWUHDSRVWURIXULúLDILúHD]YDORDUHDOXLG`
end.
)XQFLLHOHPHQWDUH
,QH[SUHVLLOHSHFDUHOHFRQVWUXLPFXFRQVWDQWHúLYDULDELOHVLPSOH
SXWHP XWLOL]D úL IXQFLLOH QXPHULFH X]XDOH D FURU QRWDLH vQ 3DVFDO H GDW PDL
jos:
Numele Numele în Exemplu de Tipul Tipul

uzual al Pascal folosire argumentului rezultatului
IXQFLHL
Modul Abs Abs(x) real,întreg tipul lui x
$UFWDQJHQW Arctan Arctan(x) real real
Cosinus Cos Cos(x) real real
([SRQHQLDO Exp Exp(x) real real
H[
Partea Frac Frac(x) real real
IUDFLRQDU
Partea Int Int(x) real real
vQWUHDJ
Logaritm Ln Ln(x) real>0 real
natural
π Pi Pi real
Rotunjire Round Round(x) real integer
Sinus Sin Sin(x) real real
16
UTCB
Radical Sqrt Sqrt(x) real>0 real

Ridicare la Sqr Sqr(x) real, integer tipul lui x
SWUDW
Trunchiere Trunc Trunc(c) real longint
)XQFLLOHSRWILXWLOL]DWHSHQWUXFRQVWUXFLDGHH[SUHVLLPDLFRPSOLFDWH
x+1+Ln(1+1/(2+sqrt(x*x+4)))-sin(0.5*y) este expresia în Pascal pentru
\
[ + + OQ + − VLQ .
+ [ +
([HUFLLL
6VHVFULHXQSURJUDP3DVFDOSULQFDUHVHFLWHVFDEFúLVHWLSUHVFVLQDFRVEúL

a+2bc.
6VHVFULHXQSURJUDPvQFDUHVHFLWHVFDEFúLVHDILúHD][[VROXLLOHHFXDLHL

D[ + E[ + F = 6H YD DYHD JULM FD OD LQWURGXFHUHD GDWHORU V DYHP GH H[HPSOX _E_! úL
DFSHQWUXFD[ú[VILHUHDOH
6VHVFULHXQSURJUDPFDUHSULPHúWHGHODWDVWDWXUSH[úLVFULHSHHFUDQSH[úLSH
[ + H [
I [ = $ILúDUHDVHIDFHSHSR]LLLFX]HFLPDOH
[ + OQ [ +
5XODLSURJUDPXOGHPDLMRV
program caractere_ASCII;
uses crt;
var i:integer;
begin clrscr;
for i:=32 to 255 do
write(i:3,' ', chr(i),' ');
readln;
end.
17
UTCB
3. Tipuri ordinale de date definite de utilizator
/LPEDMXO3DVFDORIHUSURJUDPDWRUXOXLSRVLELOLWDWHDGHDGHILQLQRL
tipuri de date, conform specificului datelor prelucrate în program. Aceste date
SRWILUHVWULFLLVDXH[WHQVLLDOHWLSXULORUGHGDWHSUHGHILQLWH1RLOHWLSXULGHGDWH
SRWILLGHQWLILFDWHSULQWUXQQXPHGDWGHSURJUDPDWRUGHUHJXOvQFRQFRUGDQ
FXVHPQLILFDLDRELHFWHORUGHWLSXOUHVSHFWLYVDXSRWILDQRQLPH(VWHSUHIHUDELO
FD RULFH QRX WLS GH GDW V ILH GHILQLW H[SOLFLW $FHVWH QRL WLSXUL GH GDWH VH
GHILQHVFvQVHFLXQHD7<3(DúDFXPVHYDYHGHDvQH[HPSOHOHFHXUPHD]
3.1. Tipul enumerare
In anumite probleme intervin date care au caracter nenumeric,de exemplu

]LOHOH XQHL VSWPkQL OXQLPDUL GXPLQLF FXORDUHD XQXL RELHFW DOE
DOEDVWUX URúXHWF RFXSDLD XQHL SHUVRDQH VWXGHQWSURIHVRUHWF 9RP GHILQL
DWXQFL XQ QRX WLS GH GDWH SULQ HQXPHUDUHD FRQVWDQWHORU FH DSDULQ WLSXOXL
respectiv. Tipul de date definit astfel se numeste tipul enumerare .
7LSXO HQXPHUDUH SHUPLWH GHFL GHILQLUHD XQHL PXOLPL RUGRQDWH GH
LGHQWLILFDWRULGHILQLLGHSURJUDPDWRU$FHúWLLGHQWLILFDWRULWUHEXLHVDSDUGRDU
vQWUR OLVW DFHODúL LGHQWLILFDWRU QHSXWkQG DSUHD vQ GRX WLSXUL HQXPHUDUH
diferite.
Un identificator al unui tip enumerare poate fi privit ca element al unei
PXOLPL RUGRQDWH SXWkQG GHWHUPLQD QXPUXO GH RUGLQH DO DFHVWXLD vQ OLVW
SULPXO LGHQWLILFDWRU DUH QXPUXO GH RUGLQH SUHFXP úL UHIHULUHD OD XQ
LGHQWLILFDWRUFXXQQXPUGHRUGLQHGDW
7LSXULOH HQXPHUDUH VH GHILQHVF vQ VHFLXQHD 7<3( DYkQG XUPWRDUHD
VLQWD[
TYPE tip_enumerare = (identificator1, identificator2,...);
Exemplu:
TYPE
]LOH OXQLPDULPLHUFXULMRLYLQHULVkPEWGXPLQLF
FXORDUH DOEDOEDVWUXURúX
9DORULOHSRVLELOHDOHDFHVWRUWLSXULVXQWLGHQWLILFDWRULLOXQLPDULDOE
albastru,... Referirea la un element al listei se face prin scrierea elementului
H[HPSOX VkPEW DOE VDX SULQ VSHFLILFDUHD QXPUXOXL GH RUGLQH DO
HOHPHQWXOXLGRULWGLQOLVWH[HPSOXVkPEWYDILVSHFLILFDWSULQ]LOH
9DULDELOHOHGHWLSHQXPHUDUHSRWILGHFODUDWHúLvQVHFLXQHD9$5DVWIHO
VAR nume1,nume2,...:tip_enumerare;
9DULDELOHOHGHWLSHQXPHUDUHSRWOXDXQDGLQYDORULOHHQXPHUDWHvQOLVW
Elementele tipului enumerare nu pot fi citite sau scrise , cu ele putându-
VHHIHFWXDGRDUXUPWRDUHOHRSHUDLL
18
UTCB
1. Atribuirea
Exemple:
DQXPH VkPEW
b) nume2:= zile(4); { nume2 va avea valoarea vineri}
2. &RPSDUDLD! ! !vQVHQVXORUGRQULLORFXORFXSDWvQ
OLVW
Exemple:
D ,Q XUPD FRPSDUDLHL µOXQL MRL µ YRP RELQH YDORDUHD ERROHDQ
TRUE.
E ,Q XUPD FRPSDUDLHL QXPH QXPH YRP RELQH YDORDUHD ERROHDQ
FALSE.
3. 'HWHUPLQDUHDQXPUXOXLGHRUGLQHDOXQXLHOHPHQWGLQOLVW (ORD)
3ULPXOHOHPHQWDOOLVWHLDUHUDQJXOVDXQXPUXOGHRUGLQH,QFRQWLQXDUH
UDQJXOFUHúWHFXXQXSkQODXOWLPXOHOHPHQWDOOLVWHLFDUHDUHUDQJXOQXQGH
QUHSUH]LQWQXPUXOGHHOHPHQWHDOOLVWHL
Exemple:
2UGURúX UHSUH]LQW UDQJXO LGHQWLILFDWRUXOXL
URúX
GLQ OLVWD
FXORDUH
DGLFQXPUXO
4. 2ELQHUHDHOHPHQWXOXLSUHGHFHVRU (PRED) úLVXFFHVRU (SUCC),al unui
element al listei.
3.2. Tipul interval
,Q DQXPLWH SUREOHPH GRPHQLLOH GH GHILQLLH DOH YDORULORU GDWHORU VXQW
subdomenii ale tipurilor de date simple predefinite (cel mai des ale tipurilor
LQWHJHUúLFKDUVDXDOHXQRUWLSXULHQXPHUDUH'HH[HPSOXYDORULOHQRWHORUXQXL
VWXGHQWVXQWFXSULQVHvQWUHúL
7LSXO LQWHUYDO HVWH XQ WLS FDUH VH JHQHUHD] GLQWUXQ WLS RUGLQDO úL
UHSUH]LQW R VHFYHQ GH HOHPHQWH GLQ WLSXO RUGLQDO UHVSHFWLY,QWHUYDOXO HVWH
GHILQLW SULQ HOHPHQWXO FHO PDL PLF úL FHO PDL PDUH vQ VHQVXO QXPUXOXL GH
RUGLQH DO VHFYHQHL GH HOHPHQWH 3URJUDPXO vQ FD]XO IRORVLULL RSLXQLL GH
FRPSLODUH ^5` YD YHULILFD DSDUWHQHQD XQHL YDORUL OD PXOLPHD GHILQLW GH
tipul interval, altfel nu.
6LQWD[DGHGHILQLUHDXQXLWLSLQWHUYDOHVWHXUPWRDUHD
7<3(WLSBLQWHUYDO SULPDBFRQVWDQWXOWLPDBFRQVWDQW
XQGHSULPDFRQVWDQWúLXOWLPDFRQVWDQWVXQWYDORULFRQFUHWHFRQVWDQWH
DOHDFHOXLDúLWLSRUGLQDO
Exemple:
TYPE
const nrmaxim=10;
type nota=1..10; { toate numerele întregi de la 1 la 10 }
19
UTCB
literemici=‘a’..’z’; { toate literele mici de la a la z}
,QVWUXFLXQLFRQGLLRQDOH
De multe ori, în rezolvarea unor probleme, apare un algoritm ce

SUHVXSXQHDOHJHUHDXQHLYDULDQWHGLQWUHPDLPXOWHSRVLELOHvQIXQFLHGHGDWHOH
SUREOHPHLúLGHPRGXOvQFDUHHYROXHD]UH]XOWDWHOH
'HFL HVWH QHFHVDU R UDPLILFDUH vQ IXQFLH GH YDORDUHD GH DGHYU D XQHL
FRQGLLL$VWIHOGHSUREOHPHVHUH]ROYFXDMXWRUXOLQVWUXFLXQLORUFRQGLLRQDOH
,)úL&$6(
,QDLQWH GH D WUHFH OD LQVWUXFLXQLOH FRQGLLRQDOH GHILQLP LQVWUXFLXQHD
FRPSXV VDX EORFXO GH LQVWUXFLXQL FD XQ úLU GH LQVWUXFLXQL FXSULQVH vQWUH
cuvintele beginúLend.
,QVWUXFLXQHD,)
,QVWUXFLXQHD,)SHUPLWHDOHJHUHDXQHLYDULDQWHGLQWUHGRXSRVLELOHFDUH
deci, se exclud reciproc).
6LQWD[DLQVWUXFLXQLL,)HVWHXUPWRDUHD
,)FRQGLLH
THEN
LQVWUXFLXQHSHQWUXFD]XO758(
sau
,)FRQGLLH
THEN
LQVWUXFLXQHSHQWUXFD]XO758(
ELSE
LQVWUXFLXQHSHQWUXFD]XO)$/6(
unde:
• FRQGLLH H[SUHVLHERROHDQDUHYDORDUHDWUXHVDXIDOVH
• LQVWUXFLXQH LQVWUXFLXQH RDUHFDUH FKLDU YLG VDX R vQúLUXLUH GH
LQVWUXFLXQLvQFDGUDWHvQWUHbeginúLend (EORFGHLQVWUXFLXQL).
'HOLPLWDWRUXO DUDW VIvUúLWXO LQVWUXFLXQLL ,) GH DFHHD vQ FD]XO DO
GRLOHD QX VH SXQH GXS LQVWUXFLXQHD SHQWUX FD]XO 758( GHRDUHFH
LQVWUXFLXQHD,)QXVDWHUPLQDWXUPkQGDOWHUQDWLYD(/6(
,QVWUXFLXQHD,)IXQFLRQHD]GXSXUPWRUXODOJRULWP
$6HHYDOXHD]YDORDUHDGHDGHYUDH[SUHVLHLERROHHQH
FRQGLLH

% ,Q FD]XO FkQG DFHDVWD DUH YDORDUHD 758( VH H[HFXW LQVWUXFLXQHD
SHQWUX758(úLVHFRQWLQXFXLQVWUXFLXQHDXUPWRDUHLQVWUXFLXQLL,)
&,QFD]XOvQFDUHYDORDUHDHVWH)$/6(VHH[HFXWLQVWUXFLXQHDSHQWUX
)$/6(DOWHUQDWLYD(/6(úLVHFRQWLQXFXLQVWUXFLXQHDLPHGLDWOXL,)'DF
20
UTCB
DOWHUQDWLYD(/6(QXH[LVWDWXQFLVHWHUPLQLPHGLDW,)úLVHFRQWLQXFX
LQVWUXFLXQHDXUPWRDUH
Exemplu:
6 SUHVXSXQHP F XQ VWXGHQW DUH YRLH V LQWUH vQ H[DPHQ GDF
vQGHSOLQHúWHXUPWRDUHOHFRQGLLLVDLEFHOSXLQSUH]HQHODFXUVvQWLPSXO
DQXOXLúLPHGLDDQXDORELQXWvQWLPSXOWHVWULORUODVHPLQDULLVILHFHOSXLQ
6 VFULHP XQ SURJUDP FDUH V QH VSXQ GDF XQ VWXGHQW DUH VDX QX YRLH V
intre în examen.
2EVHUYDLH vQ FD]XO GH ID FRQGLLD HVWH FRPSXV ILLQG IRUPDW GLQ
GRXFRQGLLLSUH]HQDúLPHGLD3HQWUXFDVWXGHQWXOVLQWUHvQH[DPHQWUHEXLH
DYXWJULMVILHvQGHSOLQLWHDPEHOHFRQGLLL
program examen;
YDUQUSUH]HQHLQWHJHU
media:real;
begin
ZULWHµLQWURGXFHLQXPUXOSUH]HQHORUúLPHGLD

UHDGOQQUSUH]HQHPHGLD
,)QUSUH]HQH!DQGPHGLD!
THEN writeln(‘Studentul poate intra în examen. Succes !’)
ELSE writeln(‘ Studentul nu poate intra în examen’) ;
end.
,QVWUXFLXQHD&DVH
,Q FD]XO LQVWUXFLXQLL ,) H[SUHVLD ERROHDQ GLQ

FRQGLLH
DYHD GRX
YDORUL 758( VDX )$/6( ,Q IXQFLH GH DFHDVW YDORDUH LQVWUXFLXQHD ,)
H[HFXWXQDGLQFHOHGRXLQVWUXFLXQLGHILQLWH'HFLDYHDPGRXSRVLELOLWLGH
alegere.
,QVWUXFLXQHD &$6( SHUPLWH DOHJHUHD GLQWUH PDL PXOWH LQVWUXFLXQL 6H
IRORVHúWH R H[SUHVLH GH WLS RUGLQDO LQWHJHUFKDUERROHDQVDX GHILQLW GH
utilizator prin enumerare sau subdomeniu) QXPLW VHOHFWRU ,QVWUXFLXQHD
&$6( SHUPLWH DOHJHUHD GLQ DWkWHD LQVWUXFLXQL FkWH YDORUL GLVWLQFWH DUH WLSXO
expresiei selector.
6LQWD[DLQVWUXFLXQLL&$6(HVWHXUPWRDUHD
CASE selector OF
FRQVWLQVWUXFLXQH
FRQVWLQVWUXFLXQH
.
.
(/6(LQVWUXFLXQH^SRDWHVOLSVHDVF`
END;
21
UTCB
unde
• selector = expresie de tip ordinal;
const1, const2,... = constante compatibile cu 'selector' sau intervale.
9DORULOHXWLOL]DWHFDHWLFKHWHWUHEXLHVILHGLIHULWHvQWUHHOH
,QVWUXFLXQHD&$6(IXQFLRQHD]GXSXUPWRUXODOJRULWP
$6HHYDOXHD]YDORDUHDH[SUHVLHL
VHOHFWRU

% 'DF H[LVW R LQVWUXFLXQH HWLFKHWDW FX DFHDVW YDORDUH VH H[HFXW
LQVWUXFLXQHDGDFQXH[LVWVHH[HFXWLQVWUXFLXQHDFDUHXUPHD]GXS(/6(
GDF DFHVWD HVWH SUH]HQW VDX QX VH YD H[HFXWD QLPLF GDF (/6( OLSVHúWH 6H
WUHFHODODH[HFXWDUHDSULPHLLQVWUXFLXQLGHGXS(1'
Exemplu:
8Q MXFWRU DUXQF GRX ]DUXUL úL ILH Q SURGXVXO ORU 'DF Q
MXFWRUXO SOWHúWH OHL GDF Q VH PDL MRDF R GDW GDF
Q MXFWRUXOFkúWLJOHLLDUGDFQ FkúWLJOHL6VHIDF
XQSURJUDPvQFDUHVHLQWURGXFYDORULOHFHORUGRX]DUXULúLVHDILúHD]FkúWLJXO
VDXSLHUGHUHD6HYDWHVWDúLGDFYDORULOH]DUXULORUVXQWvQWUHúL
3URJUDPXOFHUXWDUDWDVWIHO
program test;
YDUQXPUQXPDUQLQWHJHU
begin
write(‘numar1=’); readln(numar1);
IF(numar1<1 or numar1>6)
THEN
begin
writeln(' nu e bun numarul ');halt; ^VHRSUHúWHSURJUDPXO`
end;
write(‘numar2=’); readln(numar2);
IF(numar2<1 or numar2>6)
THEN
begin
writeln(' nu e bun numarul ');halt;
end;
n:=numar1*numar2;
CASE n of
1..10 : writeln(‘a-ti pierdut 1000 lei’);
11..20 : writeln(‘mai jucati o data’);
21..35 : writeln(‘a-ti castigat 1000 lei’);
36 : writeln(’a-ti castigat 2000 lei’);
HOVHZULWHOQµUVSXQVXOFRUHFWHVWHGHSDUWHGHGXPQHDYRDVWU¶
END
end.
22
UTCB
,QVWUXFLXQHDGHVDOW
,QVWUXFLXQHD GH VDOW QX IDFH SDUWH GLQ LQVWUXFLXQLOH FRQGLLRQDOH GDU H
IUHFYHQWOHJDWGHHOH
( −) Q Q
Exemplu. Fie de calculat + ∑ [ , care este seria cosinusului. Vrem
Q ( Q )
( −) Q [ Q
VDGXQPWHUPHQLGLQVHULHSkQ < ε 6FKHPDORJLFHVWH
( Q )
$&LWHúWH[HSV
B: s:=0; t:=1; n:=0;
C: s:=s+t;
''DF_W_HSVDWXQFLVFULHVúLVWRS
altfel n:=n+1; t:=-t*x2/((2*n-1)*(2*n)); s:=s+t; reia
calculele de la punctul C.
7HUPHQLL VHULHL vL GHWHUPLQP SULQ UHFXUHQ Wn=-x2tn-1/((2n-1)(2n)). Pe
post de termen general folosim variabila t care trece de la tn-1 la tnFkQGQFUHúWH
FXRXQLWDWH9HGHPFHQHYRLHVUHYHQLPvQSURJUDPvQXUPDUH]XOWDWHORUXQXL
WHVW,QVWXFLXQHDFHQHSHUPLWHDVHPHQHDVDOWXULHVWHGoTo. )RUPDHLJHQHUDO
este:
*R7RHWLFKHW
XQGHHWLFKHWHVWHPDUFDXQHLLQVWUXFLXQLXQGHVHIDFHVDOWXO0DUFDUHDVH
face astfel:
L ,Q VHFLXQHD /$%(/ VH GHFODU HWLFKHWHOH IRORVLWH LGHQWLILFDWRUL GLQ
OLWHUHúLFLIUH
LABEL eticheta1,eticheta2,..;
LL3XQHPHWLFKHWDvQIDDLQVWUXFLXQLLODFDUHIDFHPUHIHULUH
HWLFKHWDLQVWUXFLXQH
3URJUDPXOFRUHVSXQ]WRUVFKHPHLGHPDLVXVHVWH
Program exemplu;
Label C;
Var s,t,x,eps:real; n:integer;
Begin
write('x='); readln(x); write('eps='); readln(eps);
s:=0; t:=1; n:=0;
C: s:=s+t;
IF(abs(t)<eps)
THEN begin writeln('rezultat=', s:10:6); halt;
end
ELSE begin n:=n+1; t:=-t*x*x/((2*n-1)*(2*n)); GOTO C;
end;
23
UTCB
End.
([HUFLLL
1)6VHFDOFXOH]HPD[LPXODGRXQXPHUHFLWLWH
6HFLWHVFWUHLYDORULvQWUHJL6VHSUHFL]H]HSULQSURJUDPGDFHOHSRWILODWXULOHXQXL
triunghi.
6HFLWHVFDEFFRHILFLHQLLXQHLHFXDLLGHJUDGXODOGRLOHD
D )U D UH]ROYD HFXDLD V VH SUHFL]H]H QDWXUD UGFLQLORU UHDOH VDX FRPSOH[H úL
semnul acestora (în cazul în care sunt reale).
E5H]ROYDLHFXDLD
6H FLWHVF D E F G SDWUX YDORUL UHDOH 6 VH VFULH GRX SURJUDPH XQXO IRORVLQG
LQVWUXFLXQHD,)FHOODOWIRORVLQGLQVWUXFLXQHD&$6(vQFDUHVVHHYDOXH]HH[SUHVLD
 D + E + F GDFD G >

( =  D − E − F GDFD G =
 D ⋅ E + F GDFD G <

)RORVLQGLQVWUXFLXQHD&$6(VVHVFULHSURJUDPXOFDUHFLWHúWHXQQXPUQLQWHJHU
GHODWDVWDWXUúLDILúHD]XUPWRDUHOHPHVDMH

VDWLVIFWRU
GDF Q

GHVWXOGHELQH
GDF Q

ELQH
GDF Q

IRDUWHELQH"
GDF Q

GHQHDSUHFLDW
GDFQQXHvQQLFLXQFD]GHPDLVXV
6H FLWHVF GH OD WDVWDWXU WUHL QXPHUH UHDOH DEF 6 VH WLSUHDVF vQ RUGLQH
FUHVFWRDUH$FHHDúLFHULQSHQWUXSDWUXQXPHUHDEFG
 D[ + E\ = F
6VHUH]ROYHVLVWHPXO  DQDOL]kQGWRDWHSRVLELOLWLOH&RHILFLHQLLDE
 G[ + H\ = I
F G H I VH FLWHVF GH OD FRQVRO LDU VROXLLOH [ úL \ VH WLSUHVF SH HFUDQ GDF VLVWHPXO H
compatibil unic determinat).

Q +
6 VH FDOFXOH]H VXPD V ∑ Q
IRORVLQG RSHUDLL DULWPHWLFH úL LQVWUXFLXQL
Q=
FRQGLLRQDOH
24
UTCB
Q +
+
Q
6 VH FDOFXOH]H SURGXVXO S ∏
IRORVLQG RSHUDLL DULWPHWLFH úL
Q=
+
Q
LQVWUXFLXQLFRQGLLRQDOH
,QVWUXFLXQLUHSHWLWLYH
,QUH]ROYDUHDDQXPLWRUSUREOHPHDYHPQHYRLHGHRVHFYHQ GH
LQVWUXFWLXQLFHWUHEXLHVVHH[HFXWHvQPRGUHSHWDWHYHQWXDODVXSUDXQRUYDORUL
GLIHULWH6HVSXQHvQDFHVWFD]FDYHPQHYRLHGHRSUHOXFUDUHFLFOLFvQFDUH
VHFYHQDGHLQVWUXFLXQLFHVHUHSHWVHQXPHúWHFRUSXOFLFOXOXL
,QOLPEDMXOGHSURJUDPDUH7XUER3DVFDOH[LVW WUHLLQVWUXFLXQLUHSHWLWLYH
)25:+,/(úL5(3($7&XDMXWRUXODFHVWRUDVHFYHQDGHLQVWUXFLXQLFH
constituie corpul ciclului, se poate repeta de mai multe ori.
,QVWUXFLXQHD)25
,QVWUXFLXQHDUHSHWLWLYforVHIRORVHúWHDWXQFLFkQGQXPUXOGHLWHUDLL
GHUHSHWLLLHVWHFXQRVFXW'HDFHHDLQVWUXFLXQHDfor permite folosirea unui
FRQWRUGHFLFOXFDUHYDGDQXPUXOGHUHSHWULDOH[HFXWULLLQVWUXFLXQLORUGLQ
cadrul corpului ciclului.
6LQWD[DLQVWXFLXQLLIRUHVWHXUPWRDUHD
)25FRQWRU YDORDUHBLQLLDO72YDORDUHBILQDO'2
corpul ciclului;
sau
)25FRQWRU YDORDUHBLQLLDO'2:172YDORDUHBILQDO'2
corpul ciclului;
unde:
FRQWRU YDULDELOGHWLSRUGLQDO
YDORDUHLQLLDOYDORDUHILQDO H[SUHVLLFRPSDWLELOHFXWLSXOFRQWRUXOXL
FRUSXOFLFOXOXL LQVWUXFLXQH3DVFDOVLPSOVDXFRPSXV
,QVWUXFLXQHDUHSHWLWLY)25IXQFLRQHD]FRQIRUPXUPWRUXODOJRULWP
$6HHYDOXHD]H[SUHVLLOHYDORDUHLQLLDOúLYDORDUHILQDO6HWHVWHD]
GDFYDORDUHLQLLDO YDORDUHILQDOvQFD]XO72UHVSHFWLYGDFvaloare
LQLLDO! YDORDUHILQDOvQFD]XO'2:172'DFYDORDUHDRELQXWvQXUPD
WHVWULLHVWH)$/6(VHWHUPLQFLFOXOúLVHWUHFHODSULPDLQVWUXFLXQHGXSFLFOX
'DFYDORDUHDHVWH758(VHFRQWLQXFX%
%VHH[HFXWFRUSXOLQVWUXFLXQHDFLFOXOXL
25
UTCB
&6HWHVWHD]GDFYDULDELODcontor=valoare finala.'DFUH]XOWDWXOHVWH
758(DWXQFLVHWHUPLQFLFOXOFRQWLQXvQGXVHFXSULPDLQVWUXFLXQHGXS
FRUSXOFLFOXOXLLDUGDFUH]XOWDWXOHVWH)$/6(VHWUHFHOD'
',QFD]XO72YDORDUHDFRQWRUXOXLFUHúWHODYDORDUHDXUPWRDUH
6XFFFRQWRULDUvQFD]XO'2:172GHVFUHúWHODYDORDUHDSUHFHGHQW
3UHGFRQWRU6HUHLDXRSHUDLLOHGHOD%
Exemplu:
8QSURJUDPVLPSOXFDUHXWLOL]HD]LQVWUXFLXQHD)25HVWHFDOFXOXO
factorialului:
Program factorial;
var i,n,f:integer;
begin
ZULWH
FDOFXOPIDFWRULDOXOQXPUXOXL
Q
readln(n);
f:=1;
for i:=1 to n do { începutul ciclului FOR }
f:=f*i;^LQVWUXFLXQHDFLFOXOXL`
writeln(n,’!= ‘,f) ^DILúHD]YDORDUHDIDFWRULDOXOXL`
end.
5.2. Instructiunea WHILE (test înainte)
$PY]XWFLQVWUXFLXQHD)25HVWHIRORVLWDWXQFLFkQGúWLPQXPUXOGH
LWHUDLL([LVWvQVFD]XULFkQGYUHPVUHSHWPRVHFYHQDWkWDWLPSFkWHVWH
vQGHSOLQLWRDQXPLWFRQGLLH'DFODvQFHSXWXOFLFOXOXLFRQGLLDGHH[HFXLHD
FRUSXOXLFLFOXOXLQXHVWHVDWLVIFXWQXVHH[HFXWQLFLRLQVWUXFLXQHGLQFDGUXO
ciclului.
6LQWD[DLQVWUXFLXQLL:+,/(HVWHXUPWRDUHD
:+,/(FRQGLLH'2FRUSXOFLFOXOXL
unde
FRQGLLH H[SUHVLHERROHDQ
FRUSXOFLFOXOXL LQVWUXFLXQH3DVFDOVLPSOVDXFRPSXV
,QVWUXFLXQHDUHSHWLWLY:+,/(IXQFLRQHD]GXSXUPWRUXODOJRULWP
$6HHYDOXHD]H[SUHVLDERROHDQ
FRQGLLH

%'DF
FRQGLLH
DUHYDORDUHD758(VHWUHFHODSDVXO&DOWIHOVHWUHFH
la pasul D.
&6HH[HFXWFRUSXOFLFOXOXLúLVHUHYLQHODSDVXO$
'6HWUHFHODLQVWUXFLXQHDLPHGLDWXUPWRDUHLQVWUXFLXQLL:+,/(
'HFLDWkWWLPSFkW
FRQGLLH
HVWHDGHYUDWVHH[HFXWFRUSXOFLFOXOXL
&kQG
FRQGLLH
HVWHIDOVVHLHVHGLQFLFOXODSULPDLQVWUXFLXQHGXSFRUSXO
ciclului.
26
UTCB
2EVHUYDLL
7UHEXLHVDYHPJULMFDFLFOXOVQXILHLQILQLWDGLFH[SUHVLD
FRQGLLH
VGHYLQODXQPRPHQWIDOVúLGHFLVDYHPWUHFHUHDODSDVXO'
,QFD]XOFkQGH[SUHVLD
FRQGLLH
DUHYDORDUHD)$/6(GHODSULPD
WHVWDUHDWXQFLFRUSXOFLFOXOXLQXVHYDH[HFXWDQLFLRGDW
Exemplu:
6UH]ROYPDFHHDúLSUREOHPGHPDLVXVFDOFXOXOIDFWRULDOXOXLXQXL
QXPUIRORVLQGLQVWUXFLXQHDUHSHWLWLY:+,/(
program factorial;
var i,n,f:integer;
begin
BZULWH
Q
readln(n);
f:=1;
i:=1;
while i<=n do { începutul ciclului WHILE }
begin
f:=f*i;
i:=i+1;
end; ^VIkUúLWXOFLFOXOXL:+,/(`
write(n,'!= ',f) ^DILúHD]YDORDUHDIDFWRULDOXOXL`
end.
,QVWUXFLXQHD5(3($7WHVWGXS
6LQWD[DLQVWUXFLXQLL5(3($7HVWHXUPWRDUHD
REPEAT
corpul ciclului
817,/FRQGLLH
unde:
FRQGLLH H[SUHVLHERROHDQ
FRUSXOFLFOXOXL VHFYHQGHLQVWUXFLXQL
,QVWUXFLXQHDUHSHWLWLY5(3($7IXQFLRQHD]GXSXUPWRUXODOJRULWP
$6HH[HFXWFRUSXOFLFOXOXL
%6HHYDOXHD]H[SUHVLD
FRQGLLH
'DFYDORDUHDRELQXWHVWH758(VH
trece la pasul C, altfel se trece la pasul A.
&6HWUHFHODLQVWUXFLXQHDLPHGLDWXUPWRDUHFLFOXOXL
2EVHUYDLL
7UHEXLHVDYHPJULMFDFLFOXOVQXILHLQILQLWDGLFH[SUHVLD
FRQGLLH
VGHYLQODXQPRPHQW758(GHFLVVHWHUPLQHFLFOXO
27
UTCB
,QGLIHUHQWGHYDORDUHDH[SUHVLHL
FRQGLLH
FRUSXOFLFOXOXLVHYDH[HFXWD
FHOSXLQRGDWGDWRULWIDSWXOXLFWHVWDUHDH[SUHVLHL
FRQGLLH
VHIDFHOD
VIkUúLWXOFRUSXOXLFLFOXOXL
3. Corpul ciclul nu trebuie încadrat între begin úL end, fiind delimitat de
FXYLQWHOHFKHLH5(3($7úL817,/
Exemplu:
)RORVLQGLQVWUXFLXQHD5(3($7VFDOFXOPIDFWRULDOXOXQXLQXPU
program factorial;
var i,n,f:integer;
begin
ZULWH
Q
readln(n);
f:=1;
i:=1;
repeat { începutul ciclului REPEAT }
f:=f*i;
i:=i+1;
until i>n; ^VIkUúLWXOFLFOXOXL5(3($7`
writeln(n,'!= ',f)
end.
2EVHUYDLLJHQHUDOH
1. Se pot include cicluri unul în altul. De exemplu pentru calculul sumei

L+ M
duble 6 = ∑ ∑ SXWHPIRORVLVHFYHQD
L = M = L + L M + M
s:=0;
for i:=1 to 20 do
for j:=1 to 30 do
s:=s+(i+j)/(i+i*j+j);
writeln('s=', s);
([LVWVLWXDLLFkQGYUHPVWHUPLQPXQFLFOXvQDLQWHGHDIDFHWRDWH
FDOFXOHOHGLQFRUSXOFLFOXOXL,QDFHVWFD]SXQHPvQORFXOXQGHYUHPVVH
WHUPLQHFLFOXOLQVWUXFLXQHDbreak;
,QDQXPLWHVLWXDLLYUHPFDVVHUHLDFLFOXOvQDLQWHGHWHUPLQDUHD
FRUSXOXLFLFOXOXL,QDFHVWFD]vQORFXOUHVSHFWLYSXQHPLQVWUXFLXQHDcontinue;
([HUFLLL
6VHFDOFXOH]HVXPHOH
a. S= 1+1*2+1*2*3+...+1*2*...*n ;
28
UTCB
b. S= 1*2*3+2*3*4+...+n*(n+1)*(n+2).
6HFLWHúWHQXPUXOQDWXUDOQ6VHSUHFL]H]HGDFHVWHSULPVDXQX
,QGLFDLHWHVWPGDFQVHGLYLGHODPSULQLI(n mod m)=0'DFH[SUHVLDDUH
valoarea TRUE atunci n se divide la m altfel nu.
6VHVFULHXQSURJUDPFDUHDILúHD]SULPHOHQQXPHUHSULPHXQGHQHVWHXQQXPU
QDWXUDOFLWLWGHODWDVWDWXU
6HFLWHúWHXQQXPUQDWXUDOQ6VHFDOFXOH]HVXPDFLIUHORUVDOHvQED]D
IRORVLQGLQVWUXFLXQHD:+,/(
VLQ Q
6HG ε XQQXPUSR]LWLY6VHFDOFXOH]H6 = ∑ W Q , unde W = ,
Q <ε
Q +
W
Q
Q ∈ 1 − ^` )RORVLL:+,/(SHQWUXVXP
6VHFDOFXOH]H ∑ P + Q unde P Q ∈ = × = úLP + Q < úLPHVWHSDU

N+L
6VHFDOFXOH]HH[SUHVLD ( = ∑ ∏
N
N = L = L + N
[
)LHúLUXO [ = D > [ = Q
'DWD!VVHGHWHUPLQHSULPXOQQDWXUDOSHQWUX
Q
+ [ Q
care xn <1/1000.
∞
( −) [ + Q Q
9 Avem VLQ [ = ∑ W XQGH W = .

Q Q
( Q + )
D3HQWUX[GDWVVHFDOFXOH]HVLQ[GXSIRUPXODGHPDLVXVSkQWn devine 0 în
calcuator.
E3HQWUXYDORULOHOXL[GHODODFXSDVXOVVHFDOFXOH]HVLQ[FDODSXQFWXOD
úLVVHWLSUHDVFSULPXOQSHQWUXFDUHWn devine zero de calculator.
 D 
6HúWLHFúLUXO[n) cu xo D!úL [ =  [ − +  pentru n>0 este convergent la
 [ − 
Q Q
a1/2'DWD!VVHFDOFXOH]HSULPXO[n pentru care [ − [ − < − . Q Q
11. Fie triunghiul cu vârfurile A(100,50), B(0,70), C(-4, -30). Câte puncte cu
FRRUGRQDWHvQWUHJLH[LVWvQLQWHULRUXODFHVWXLWULXQJKL"'DUvQLQWHULRUXOFHUFXOXLGHFHQWUX
2úLUD]D"
)LHQXPUXOFRPSOH[FúL]0 )LHúLUXOGHQXPHUHFRPSOH[HGHILQLWGHUHODLDGH
UHFXUHQ]n=zn-12F6VHGHWHUPLQHSULPXOQ!SHQWUXFDUH_]n_!GDFXQDVHPHQHDQ
H[LVW
29
UTCB
6. Tipul tablou
8QWDEORXHVWHRVWUXFWXUGHGDWHDYkQGXQQXPUIL[GHHOHPHQWHWRDWH
GHDFHODúLWLSVWRFDWHvQWUR]RQFRQWLJXGHPHPRULH. Referirea la elementele
WDEORXOXL VH UHDOL]HD] SH ED]D XQXLD VDX PDL PXOWRU LQGLFL FDUH UHSUH]LQW
YDORUL DOH XQRU WLSXUL RUGLQDOH (OHPHQWHOH WDEORXOXL VXQW PHPRUDWH XQXO GXS
DOWXO YDULLQG YDORULOH WLSXULORU FDUH GHILQHVF LQGLFLL vQ RUGLQH FUVFWRDUH úL
considerând dimensiunile de la dreapta la stânga.
'HILQLUHDúLXWLOL]DUHDWDEORXULORU
6LQWD[DGHFODUULLWLSXOXLWDEORXHVWHXUPWRDUHD
TYPE
tip_tablou=ARRAY[tip_ind_1, tip_ind_2,.......] OF tip_elem;
unde tip_tablou este identificatorul tipului ARRAY, tip_ind_i sunt tipuri

RUGLQDOH DGLF LQWHJHU VKRUW E\WH FKDU ERROHDQ HQXPHUDUH LQWHUYDO FDUH
GHILQHVFPXOLPLOHGHYDORULDOHLQGLFLORUSHQWUXILHFDUHGLPHQVLXQHDWDEORXOXL
iar tip_elemUHSUH]LQWWLSXOHOHPHQWHORUWDEORXOXL7DEORXOSRDWHILLQGH[DW SH
ILHFDUH GLPHQVLXQH FX WRDWH YDORULOH WLSXOXL GH LQGLFH FRUHVSXQ]WRU 3ULQ
XUPDUH QXPUXO GH HOHPHQWH DOH WDEORXOXL HVWH GDW GH SURGXVXO QXPUXOXL GH
YDORUL DOH WLSXOXL ILHFUXL LQGLFH 1XPUXO GH GLPHQVLXQL DOH XQXL WDEORX HVWH
nelimitat. Pentru indici se folosesc frecvent intervale ale tipului întreg: 1..100, -
HWF 6H SRW vQV XWLOL]D úL LQWHUYDOH DOH DOWRU WLSXUL RUGLQDOH µ$¶¶=¶
URúXDOEDVWUX HWF 7LSXO HOHPHQWHORU WDEORXOXL SRDWH IL XQ WLS
standard sau un tip definit de utilizator.
&RQVWDQWHOHGHWLSWDEORXVHGHFODUDVWIHO
CONST
nume_tablou:tip_tablou=(const_1, const_2, .......);
unde nume_tablou UHSUH]LQW LGHQWLILFDWRUXO DVRFLDW YDULDELOHL GH WLS

tip_tablou, iar const_i sunt atâtea expresii constante de tip tip_elem, câte
elemente are tabloul. In cazul constantelor tablou multidimensionale,
constantele pentru fiecare dimensiune sunt incluse la rândul lor, separate prin
virgule, în perechi separate de paranteze. Constantele din parantezele interioare
corespund dimensiunilor celor mai din dreapta.
5HIHULUHDODXQHOHPHQWDOXQLWDEORXVHUHDOL]HD]FRQIRUPVLQWD[HL
30
UTCB
nume_tablou[ind_1,ind_2,....];
XQGH QXPHBWDEORX UHSUH]LQW LGHQWLILFDWRUXO DVRFLDW WDEORXOXL LDU LQGBL
UHSUH]LQW H[SUHVLL FRPSDWLELOH FX WLSXO LQGLFLORU FRUHVSXQ]WRUL GLQ GHFODUDLD
tabloului
([HPSOHGHGHFODUDLL
Declarare de tipuri:
type
vector=array[1..10] of real;
matrice=array[1..10,1..10] of real;
tablou3D=array[0..1,0..1,0..1] of integer;
Declarare de variabile ori constante:
var
x,y:array[1..10] of integer;
a,b:array[1..10,1..10] of integer;
const
t:vector=(1,2,1,3,5,7,8,7,9,4);
cub:tablou3D=(((0,1),(2,3)),((4,5),(6,7)));
0DLVXVVHUHDOL]HD]LQLLDOL]DUHDWDEORXOXLFXEGXSFXPXUPHD]
cub[0,0,0]=0 cub[0,0,1]=1 cub[0,1,0]=2 cub[0,1,1]=3
cub[1,0,0]=4 cub[1,0,1]=5 cub[1,1,0]=6 cub[1,1,1]=7
Exemplul 1:
6 VH UHDOL]H]H XQ SURJUDP FDUH V FDOFXOH]H SURGXVXO VFDODU D GRL
vectori.
2VROXLHHVWHXUPWRUXOSURJUDP
Program vectori;
uses crt;
const n=10;
type vector=array[1..n] of real;
var x,y:vector;
i:integer;
ps:real;
Begin
clrscr;
ZULWHµ,QWURGXFHLGLPHQVLXQHDYHFWRULORUµ
readln(n);
ZULWHµ,QWURGXFHLHOHPHQWHOHYHFWRUXOXL;µ
for i:=1 to n do
begin
write(‘X(‘,i:2,’)=‘);
31
UTCB
readln(x[i]);
end;
ZULWHµ,QWURGXFHLHOHPHQWHOHYHFWRUXOXL<µ
for i:=1 to n do
begin
write(‘y(‘,i:2,’)=‘);
readln(y[i]);
end;
ps:=0;
for i:=1 to n do ps:=ps+x[i]*y[i];
writeln('produsul scalar a vectorilor X si Y este : ',ps);
repeat until keypressed;
End.
2EVHUYDLH ,Q DFHVW SURJUDP DP IRORVLW 86(6 &57 FHHD FH LQGLF
utilizarea unui pachet de programe grupate sub numele CRT, programe ce
IDFLOLWHD] OXFUXO FX HFUDQXO ,Q DFHVW SDFKHW VH DIO clrscr FDUH UHDOL]HD]
úWHUJHUHDHFUDQXOXLúLIXQFLDkeypressedFDUHGYDORDUHD758(GDFVDDSVDW
RWDVW'HWDOLLVXSOLPHQWDUHODXQLWXO&57
Exemplul 2:
6 VH UHDOL]H]H XQ SURJUDP FDUH RUGRQH] FUHVFWRU HOHPHQWHOH XQXL
vector.
Program ordonare;
uses crt;
const
n=10;
type
vector=array[1..n] of real;
var
x:vector;
i,j:integer;
t:real;
Begin
clrscr;
ZULWHµ,QWURGXFHLGLPHQVLXQHDYHFWRUXOXLµ
readln(n);
write(‘,QWURGXFHLHOHPHQWHOHYHFWRUXOXLµ
for i:=1 to n do
begin
write('X(',i:2,')=');
readln(x[i]);
32
UTCB
end;
for i:=1 to n -1do
for j:=i+1 to n do
if x[i]<x[j] then
begin
t:=x[i];
x[i]:=x[j];
x[j]:=t;
end;
for i:=1 to n do writeln(‘X(‘,i:2,’)=,x[i]);
End.
Exemplul 3:
6 VH UHDOL]H]H XQ SURJUDP FDUH GHWHUPLQ HOHPHQWXO PD[LP DO XQHL
PDWULFHFXQOLQLLúLPFRORDQH
Program matrice;
uses crt;
const
n=5; m=7;
type
matrice=array[1..n,1..m] of real;
var
a:matrice;
i,j:integer;
max:real;
Begin
clrscr;
ZULWH
,QWURGXFHLHOHPHQWHOHPDWULFHL

for i:=1 to n do
for j:=1 to m do
begin
write('a(',i:2,',',j:2,')=);
readln(a[i,j]);
end;
max:=a[1,1];
for i:=1 to n do
for j:=1 to m do
if max<a[i,j] then max:=a[i,j];
writeln ('Elementul maxim al matricei este : ',max);
33
UTCB

End.
([HUFLLL
6VHUHDOL]H]H]HXQSURJUDPFDUHRUGRQHD]GHVFUHVFWRUXQYHFWRUGHQXPHUHUHDOH
6 VH UHDOL]H]H]H XQ SURJUDP FDUH GHWHUPLQ HOHPHQWXO PD[LP DO XQXL YHFWRU GH
numere reale.
6VHUHDOL]H]HXQSURJUDPFDUHFDOFXOHD]SURGXVXODGRXPDWULFH
6VHUHDOL]H]HXQSURJUDPFDUHUHDOL]HD]vQPXOLUHDXQHL PDWULFH SWUDWLFH FX HD

vQVúL6VHFRQVLGHUHúLXQSURJUDPGHULGLFDUHODSXWHUHDXQHLPDWULFLSWUDWLFHUHDOH
6VHUHDOL]H]HXQSURJUDPFDUHFDOFXOHD]DSRLWLSDUHúWHYDORDUHDOXLVXQGHVHVWH
n m
s= ∑ ∑ aij , a find o matrice n× m
i=1 j=1
6VHUHDOL]H]HXQSURJUDPFDUHGHWHUPLQQXPUXOGHFRORDQHFXWRDWHHOHPHQWHOH
negative dintr-o matrice de tip m × n .
7. Se dau numerele D L = M = úL E M = 6VHUHDOL]H]H

LM M

XQSURJUDPFDUHFDOFXOHD] F = ∑ D E L = .
L LM M
M =
)LHDXQYHFWRUSHQWUXFDUHY>L@HVWHVDX6VHGHWHUPLQHQXPUXOGHLQVXOHGLQ
Y$LFLQXPLPLQVXORPXOLPHPD[LPDOGHHOHPHQWHGLQYHFWRUYHFLQHGRXFkWHGRX
9. Elementele unei matrici reale n× Q DX YDORULOH vQ SURJUHVLH DULWPHWLF GDU
numerotate circular: a[1,1]=1, a[2,1]=2, ..a[n,1]=n, a[n,2]=n+1, ... a[n,n]=2n-1, a[n-1,n]=2n,
D>Q@ QD>Q@ QD>@ QGXSFDUHvQFHSHPLDUSHGLDJRQDOD>@ Q
HWF6VHIDFXQSURJUDPFDUHWLSUHúWHPDWULFHDDSHQWUXGLYHUVHYDORULDOHOXLQ
6HGRSHUPXWDUHDQXPHUHORUQ6VHGHWHUPLQHVLJQDWXUDSHUPXWULL
8Q WDEORX DDUUD\> @ RI UHDO DUH YDORULOH GDWH GH UHODLD
D>LMN@ LMN6VHSXQFUHVFWRUDFHVWHYDORULvQWUXQYHFWRUEDUUD\>@RIUHDOúLV
VHWLSUHDVFYDORULOHOXLEGLQvQ
34
UTCB
3URFHGXULúL IXQFLL
ÌQ PXOWH VLWXDLL R DQXPLW VXFFHVLXQH GH FDOFXOH LQWHUYLQH IRDUWH GHV
3HQWUX D QX VH VFULH SDUWHD FRUHVSXQ]WRDUH GH SURJUDP GH PDL PXOWH RUL
SURJUDPDWRULLDXODvQGHPkQSRVLELOLWDWHDGHDúLGHILQLEORFXULGHLQVWUXFLXQL
LGHQWLILFDELOHSULQXQQXPHúLROLVWGHSDUDPHWULDVWIHOFDGHILHFDUHGDWFkQG
H QHYRLH GH FDOFXOHOH GLQ EORFXO UHVSHFWLY V SRDW IL DSHODW IU D PDL VFULH
vQFRGDWLQVWUXFLXQLOHGLQEORFÌQIHOXODFHVWDSURJUDPHOHGHYLQPDLscurte
úL PDL clare $VHPHQHD EORFXUL GH LQVWUXFLXQL VH QXPHVF VXESURJUDPH LDU vQ
3DVFDOVXQWGHGRXIHOXULproceduriúLIXQFLL:
7.1. Proceduri
8Q EORF GH WLS SURFHGXU VDX IXQFLH WUHEXLH GHFODUDW úL WUHEXLH VFULV
FRGXOGHH[HFXLHvQDLQWHGHD IL IRORVLW 'HFODUDUHD XQHL SURFHGXUL VH IDFH FD
mai jos:
SURFHGXUHQXPHSDUDPHWULGHLQWUDUHLHúLUHWLSXOSDUDPHWULORU
GHFODUDLL GH FRQVWDQWH YDULDELOH HWLFKHWH QRL SURFHGXUL VDX IXQFLL
valabile doar în interiorul procedurii
begin
programul de calcul al procedurii;
end;
3ULPDOLQLHVHFKHDPDQWHWXOSURFHGXULL$SHOXOSURFHGXULLVHIDFHSULQ
QXPHSDUDPHWULLDFWXDOLGHLQWUDUHLHúLUH
3DUDPHWULL DFWXDOL WUHEXLH V ILH GHFODUDL vQ SURJUDPXO FDUH DSHOHD]
SURFHGXUD úL V ILH GH DFHODúL WLS FX SDUDPHWULL FRUHVSXQ]WRUL GLQ GHILQLLD
procedurii.
'DWHFHVHSRWXWLOL]DvQSURFHGXU
1. Variabilele globale, definite înaintea procedurii. Acestea sunt definite
vQ DIDUD RULFUHL SURFHGXUL VDX IXQFLL. 3ULQ HOH VH SRW WUDQVPLWH GDWH FWUH
SURFHGXUúLVHSRWRELQHUH]XOWDWHIXUQL]DWHGHSURFHGXU
2.9DULDELOHOHGLQGHILQLLDSURFHGXULL(OHUHSUH]LQWGDWHOHGHLQWUDUHLDU
GDFvQGHILQLLDSURFHGXULLDSDUHVSHFLILFDLDvar vQIDDORUDWXQFLUHSUH]LQWúL
GDWHGHLHúLUHUH]XOWDWHIXUQL]DWHGHSURFHGXU
3.&RQVWDQWHOHúLYDULDELOHOHGHILQLWHvQ]RQDGHGHFODUDLLDSURFHGXULL
Ele se numesc locale úLQXSRWILXWLOL]DWHvQDIDUDSURFHGXULL'HDOWIHODFHVWH
YDULDELOHQXH[LVWGHFkWSHWLPSXOFDOFXOXOXLvQSURFHGXUPRPHQWvQFDUHVH
UH]HUYVSDLXSHQWUXHOHvQWUR]RQGHPHPRULHQXPLWVWLY.
,QFRQWLQXDUHLOXVWUPSULQH[HPSOHWRDWHDFHVWHD
35
UTCB
Exemplu
1HSURSXQHPVFRPSDUPIXQFLDVLQ[FXVXPD
=
k = n (− 1 )k x k
s ∑
k = 0 (2 k + 1 )!
SHQWUXGLYHUVHYDORULDOHOXL[úLQ3HQWUXDFHDWDGHILQLPRSURFHGXUFDUH
DUHFDSDUDPHWULGHLQWUDUH[UHDOúLQLQWHJHULDUFDSDUDPHWUXGHLHúLUHSHVUHDO
FDUH YD IL YDORDUHD VXPHL ÌQ SURJUDPXO SULQFLSDO GP YDORUL SHQWUX [ úL Q
FDOFXOP VXPD SULQ DSHOXO SURFHGXULL DSRL IDFHP GLIHUHQD VVLQ[ SH FDUH R
WLSULP
3URJUDPXOFRUHVSXQ]WRUHVWH
program exemplu;
var valoare,sinaprox:real;
lung:integer;
procedure calcul_suma(x:real; var s:real; n:integer);
var k:integer; t:real;
begin
t:=x; ^SULPXOWHUPHQGLQVXPSWN `
s:=t;
for k:=1 to n do
begin
^GHWHUPLQPWHUPHQLLSULQUHFXUHQ`
t:=-t*x*x/((2*k)*(2*k+1));
^SXQHPWHUPHQLLvQVXP`
s:=s+t;
end;
end;{terminarea procedurii}
BEGIN {programul principal}

ZULWH
LQWURGXFHLYDORDUHDSHQWUXFRPSDUDW

readln(valoare);
ZULWH
LQWURGXFHWLQXPUXOGHWHUPHQLGLQVXPD

readln(lung);
calcul_suma(valoare,sinaprox,lung);
writeln('diferenta este=', sin(valoare)-sinaprox:8:5);
END. ^VIkUúLWXOSURJUDPXOXL`
Comentarii asupra programului:
i) Variabilele valoare, sinaprox, lung sunt variabile globale. Ele pot fi
IRORVLWHvQRULFHSURFHGXUGLQSURJUDP
36
UTCB
ii) Variabilele x,s,n VXQW SDUDPHWULL SURFHGXULL (L VH PDL QXPHVF úL
parametri formali. x úL n sunt parametri de intrare iar s este parametru de
LQWUDUHLHúLUH,QSURJUDPHIRORVLWGRDUFDSDUDPHWUXGHLHúLUH
iii) Variabilele k,t sunt locale. Ele nu au valabilitate decât în interiorul
SURFHGXULL'DFvQDIDUDSURFHGXULLVHvQWkOQHVFYDULDELOHFXDFHODúLQXPHHOH
QXDXQLFLROHJWXUFXFHOHGLQSURFHGXU
LY,QSURJUDPXOSULQFLSDOGXSLQVWUXFLXQLOHGHLQWURGXFHUHDGDWHORUVH
DSHOHD] SURFHGXUD SULQ calcul_suma(valoare,sinaprox,lung). Valoare,
sinaprox, lung se numesc parametri actuali. Prin acest apel parametrul actual
valoare se transmite lui x, parametrul actual lung se trnsmite lui n iar adresa lui
sinaprox se transmite FD DGUHV SHQWUX s. La terminarea procedurii valorile
pentru valoare úL lung UPkQQHVFKLPEDWHFKLDUGDFxúL n s-ar schimba în
SURFHGXU LDU sinaprox care a corespuns cu s GLQ SURFHGXU FRQLQH XOWLPD
valoare a lui s,DGLFVXPD
Pe scurt, deoarece sDIRVWGHFODUDWvQGHILQLLDSURFHGXULLFXvarvQID
PRGLILFULOH OXL VXQW úL PRGLILFUL DOH SDUDPHWUXOXL DFWXDO FDUH vL FRUHVSXQGH
aici sinaprox.
)XQFLL
'HFODUDUHDXQHLIXQFLLVHIDFHDVWIHO
IXQFWLRQQXPHOLVWDGHSDUDPHWULIRUPDOLWLSXOWLSXOBIXQFLHL
GHFODUDLLGHFRQVWDQWHYDULDELOHHWLFKHWHSURFHGXULVDXIXQFLLYDODELOH
GRDUvQLQWHULRUXOIXQFLHL
begin
SURJUDPXOGHFDOFXODOIXQFLHL
QXPH RYDORDUHUH]XOWDWGLQFDOFXO
end;
ÌQ FH SULYHúWH YDULDELOHOH GLQ IXQFLH VXQW YDODELOH REVHUYDLLOH GH OD
SURFHGXUL FX FRPSOHWDUHD vQ vQWHULRUXO IXQFLHL VH SRDWH XWLOL]D úL variabila
numeDGLFQXPHOHIXQFLHL$FHDVWYDULDELOYDILXWLOL]DWca membru stâng
úL GH UHJXO VH IRORVHúWH vQDLQWH GH LHúLUHD GLQ IXQFLH 9DULDELOD nume este
SDUDPHWUX GH LHúLUH GLQ IXQFLH GHFL vQDLQWH GH WHUPLQDUHD VXESURJUDPXOXL
IXQFLHWUHEXLHVLVHDWULEXLHRYDORDUH9RPYHGHDPDLGHSDUWHFXPVHSRDWH
XWLOL]D QXPHOH IXQFLHL úL vQ PHPEUXO GUHSW vQ IXQFLL UHFXUVLYH Prin urmare
IXQFLLOH UHDOL]HD] WRW FH UHDOL]HD] SURFHGXULOH SOXV UHWXUQDUHD XQXL UH]XOWDW
VXSOLPHQWDU LGHQWLILFDW FX QXPHOH IXQFLHL 8WLOL]DUHD IXQFLHL VH IDFH vQ RULFH
H[SUHVLHODIHOFDIXQFLLOHVWDQGDUG
YDULDELO H[SUHVLHQXPHSDUDPHWULDFWXDOL
37
UTCB
'DF VH IDFH FRPSLODUHD SURJUDPXOXL FX GLUHFWLYD ^;` DWXQFL VH SRW
DSHOD IXQFLLOH FD SURFHGXUL 5H]XOWDWXO DVRFLDW QXPHOXL IXQFLHL QX VH PDL
IRORVHúWH
Exemplu
6VHFDOFXOH]H
[ + D
∫

L( D ) = H−[ G[
[ + [ +
SHQWUX D IRORVLQG VXESURJUDPH IXQFLH SHQWUX
H[SULPDUHDIXQFLHLGHVXELQWHJUDOúLSHQWUXFDOFXOXOLQWHJUDOHL. Pentru calculul
integralei ne folosim de metoda trapezelor:
E − D
∫
E
D
I [ G [ ≈
Q
( I [ + I [Q + ( I [ + I [ + + I [ Q − ) )
E−D
unde [ L
=D+
Q
L $FHDVW IRUPXO UHSUH]LQW vQORFXLUHD DULHL GH VXE
JUDILFXOOXLI[SULQVXPDDULLORUWUDSH]HORUFDvQILJXUDXUPWRDUH
f(x)
a=x0 x1 xn-1 b=xn
Programul este:
program functii;
var a:real; n:integer;
function f(x:real):real;
^SDUDPHWUXO[VHWUDQVPLWHSULQYDORDUHLDUDFDYDULDELOJOREDO`
begin
f:=(x*x+a)/(x*x+x+1);
end;^VIkUúLWXOIXQFLHLI`
function int(st,dr:real; n:integer):real;

^VWúLGUVXQWPDUJLQLOHLQWHUYDOXOXLGHLQWHJUDUHLDUQ QXPUXO
GHVXELQWHUYDOHHJDOHvQFDUHHVWHGLYL]DW>VWGU@WRLSDUDPHWULLOXLLQWVH
transmit prin valoare }
var s, pas,x:real; i:integer;
{ avem nevoie de câteva variabile locale: s, pas, x,i}
begin
s:=f(st)+f(dr); pas:=(dr-st)/n;
^VVDLQLLDOL]DWFXI[0)+f(xn) }
38
UTCB
for i:=1 to n-1 do

begin
x:=st+pas*i; s:=s+2*f(x);
end;
^VDDGXJDWODVH[SUHVLDI[1)+f(x2)+...+f(xn-1) ) }
s:=s/(2*n);
int:=s;
^VHWHUPLQH[SUHVLDSHQWUXLQWHJUDOSULQGLYL]DUHDVXPHLODQ
DSRLVHDWULEXLHQXPHOXLIXQFLHLYDORDUHDV UH]XOWDWXOLQWHJUDOHL`
end;^VIkUúLWXOIXQFLHLLQW`
n:=100;
a:=0;
while a<=1.01 do
begin
writeln('a=',a:5:2,' integrala=', int(0,1,n):7:4);
a:=a+0.1;
end;
readln;
END. ^VIkUúLWXOSURJUDPXOXL`
5HPDUFP F vQ LQVWUXFLXQHD ZULWHOQ DP XWLOL]DW IXQFLD int la fel cum
XWLOL]P IXQFLLOH VWDQGDUG DP VFULV LQWQ DúD FXP DP VFULH VLQ VDX
H[S[ GRDU F DP IRORVLW QXPUXO FRUHVSXQ]WRU GH SDUDPHWUL úL vQ RUGLQHD
GLQ GHILQLLD IXQFLHL LQWQ vQVHDPQ UH]XOWDWXO LQWHJUDOHL GH OD OD
folosind o divizare a intervalului [0,1] în n subintervale egale. De asemenea în
IXQFLDLQWVHXWLOL]HD]IXQFLDIGHILQLWDQWHULRU
7.3. Procedura Exit
$FHDVW SURFHGXU VH XWLOL]HD] SHQWUX WHUPLQDUHD EORFXOXL FXUHQW GH

LQVWUXFLXQL ÌQ SDUWLFXODU GDF VXQWHP vQ LQWHULRUXO XQHL IXQFLL VDX SURFHGXUL
SULQDSHOXOSURFHGXULLH[LWGHWHUPLQPWHUPLQDUHDDFHOHLSURFHGXULVDXIXQFLLvQ
RULFHPRPHQW'HH[HPSOXSHQWUXFDOFXOXOIXQFLHLXUPWRDUH
 GDFD [ <

 ( [ + ) GDFD ≤ [ <
I ([) =  H[ +
 [ GDFD ≤ [ <

 [ − GDFD ≤ [
SXWHPIRORVLVHFYHQDGHLQVWUXFLXQL
function f(x:real):real;
begin
39
UTCB
if x<0 then begin f:=1;exit;end;

if(x>=0) and (x<1) then begin f:=x*x+1;exit;end;
if(1<=x) and (x<2) then begin f:=2;exit;end;
if (x>=2) then f:=x*x-2;
end;
$LFLSURFHGXULOHH[LWDSHODWHIDFVQXVHPDLDSHOH]HLQVWUXFLXQLOHLIFDUH
XUPHD]GHvQGDWFHVDGHWHUPLQDWvQFHFD]VHvQFDGUHD][
3URFHGXULúLIXQFLLUHFXUVLYH
5HFXUVLYLWDWH vQVHDPQ DSHODUHD XQHL SURFHGXUL VDX IXQFLL GH FWUH HD

vQVúL 3HQWUX D QX VH UHDOL]D XQ úLU LQILQLW GH DSHOXUL WUHEXLH DYXWH vQ YHGHUH
GRXOXFUXUL
$ ,Q LQWHULRUXO SURFHGXULL VDX IXQFLHL WUHEXLH LQWURGXV XQ WHVW SHQWUX
UHFXUVLYLWDWHFDUHvQFD]XO758(VSHUPLWDSHOXOUHFXUVLYLDUvQFD]XO)$/6(
VQXSHUPLWDSHOXOUHFXUVLYVDXLQYHUV
% 0RGLILFDUHD vQ SURFHGXU VDX IXQFLH D XQRU SDUDPHWUL DVWIHO FD vQ
DSHOXULOH UHFXUVLYH V DSDU YDORUL QRL SHQWUX DFHúWL SDUDPHWUL GH DúD PDQLHU
vQFkWGXSXQQXPUILQLWGHFKHPULWHVWXOSHQWUXUHFXUVLYLWDWHVRSUHDVFQRL
apeluri.
Exemplu.
6FDOFXOP)DFWQ QSULQWURIXQFLHUHFXUVLY
Rezolvare:
function Fact(n:integer):integer;
begin
if(n<=0) then Fact:=1
else Fact:=n*Fact(n-1);
end;
$LFL WHVWXO GH UHFXUVLYLWDWH HVWH LIQ 'DF VH SHUPLWH UHFXUVLYLWDWHD
(clauza else) atunci noile apeluri se fac cu n diminuat cu o unitate ceeea ce ne
DVLJXUFVHYDDMXQJHODQ úLGHFLODRSULUHDGHQRLDSHOXUL
9DULDELOHGHWLSIXQFLHVDXSURFHGXU
Limbajul Turbo Pascal permite definirea de variabile-subprogram de tip

SURFHGXU VDX IXQFLH FDUH OD UkQGXO ORU SRW IL SDUDPHWUL vQ DOWH SURFHGXUL VDX
IXQFLL 'HILQLUHD WLSXOXL GH GDWH procedure sau function VH IDFH vQ VHFLXQHD
typeDSURJUDPXOXLFDvQH[HPSOXOXUPWRU
program ex;
type
proc= procedure;
40
UTCB
func= function:real;
proc1= procedure(x,y:real; var n:integer);
func1= function(a:char; b:real):boolean;
ÌQ VHFYHQD GH PDL VXV VD GHILQLW proc GUHSW XQ WLS GH YDULDELO
VXESURJUDP GH IRUPD XQHL SURFHGXUL IU SDUDPHWUL func GUHSW WLS GH IXQFLH
IUDUJXPHQWHGDUFXUH]XOWDWUHDOproc1FDWLSGHSURFHGXUFHGHSLQGHGHGRL
SDUDPHWUL UHDOL WUDQVPLúL SULQ YDORDUH úL XQ SDUDPHWUX vQWUHJ WUDQVPLV SULQ
DGUHVLDUfunc1HVWHWLSXOJHQHUDOGHIXQFLHFHDUHFDDUJXPHQWHXQFDUDFWHUúL
XQ QXPU UHDO vQ DFHDVW RUGLQH úL DUH FD UH]XOWDW R YDORDUH ERROHDQ DGLF
TRUE sau FALSE).
ÌQVHFLXQHDvar se pot defini variabile de tipurile de mai sus:
var f:func1; g:proc1;
&LQHYRUIúLJvQSURJUDP"'DFvQSURJUDPDYHPPDLPXOWHIXQFLLI
f2, f3, f4, etc. de tipul func1, atunci f poate fi oricare din acestea. Atribuirea se
IDFH SULQ I I VDX I I HWF vQ IXQFLH GH QHYRLOH GLQ SURJUDP $QDORJ VWDX
lucrurile cu g.
3HQWUX IXQFLRQDUHD SURJUDPXOXL FRPSLODUHD WUHEXLH IFXW FX GLUHFWLYD
^)`ÌQH[HPSOXOXUPWRUVHOPXUHVFPDLELQHOXFUXULOH
Exemplu.
Fie i1, i2, i3 YDORULOH LQWHJUDOHORU GH OD OD DOH IXQFLLORU
I ( [ ) = [ VLQ [ + [ , I [ = [ + + H [ , I ( [ ) = + [ + [ . 6 VH calculeze
LL
valoarea expresiei V = .
L
6ROXLH 6FULHP XQ VXESURJUDP IXQFLH SHQWUX FDOFXOXO LQWHJUDOHL SULQ
PHWRGD WUDSH]HORU DúD FXP DP IFXW PDL vQDLQWH úL vO QXPLP LQW GDU vL PDL
punem un parametru de intrare f:func XQGH IXQF VH GHILQHúWH FD WLSXO IXQFLH
UHDOGHRYDULDELOUHDO$SHOPDSRLGHWUHLRULLQWRGDWFXIvQORFGHISH
XUPFXIvQORFGHIúLvQVIkUúLWIvQORFGHIIIIVXQWIXQFLLGHWLS
IXQF úL FRQLQ IRUPXOHOH SHQWUX I1, f2 úL I3. Compilarea o facem obligatoriu cu
GLUHFWLYDÎ`3URJUDPXODUDWDVWIHO
{$F+}
program exemplu;
type func=function(x:real):real;
function f1(x:real):real;
begin
f1:=(x*sin(x))/(1+x*x);
end;
41
UTCB
begin
f2:=(x*x+1)/(1+exp(x));
end;
begin
f3:=Sqrt(1+x+x*x);
end;
function int(st,dr:real; n:integer; f:func):real;

^DLFLDSDUHIFDYDULDELOGHWLSIXQFDGLFIXQFLHUHDO`
var s, pas,x:real; i:integer;
begin
s:=f(st)+f(dr); pas:=(dr-st)/n;
for i:=1 to n-1 do
begin
x:=st+pas*i; s:=s+2*f(x);
end;
s:=s/(2*n);
int:=s;
end;
begin
writeln('s=',int(0,1,100,f1)*int(0,1,100,f2)/int(0,1,100,f3):10:5);
readln;
end.
ÌQ DFHVW IHO VH HYLW V VH VFULH SURFHGXUD int de trei ori, pentru f1, f2
respectiv f3.
2EVHUYDLLJHQHUDOH
L 3XWHP GXS DQWHWXO XQHL SURFHGXUL VDX IXQFLL V DGXJP FXYkQWXO
forward $FHDVWD vQVHDPQ F QX H QHYRLH V úL VFULHP SURJUDPXO SURFHGXULL
VDX IXQFLHL LPHGLDW 3XWHP IRORVL SURFHGXUD VDX IXQFLD vQ FDOFXOH úL V
DGXJPPDLWkU]LXSURJUDPXOHL
LL3URFHGXULOHVDXIXQFLLOHFHVHvQJOREHD]vQSURJUDPGLQDOWHVXUVHVH
GHFODUexternal.
LLL 3URFHGXULOH úL IXQFLLOH inline VH IRORVHVF SHQWUX VHFYHQH VFXUWH GH
SURJUDP GH RELFHL vQ FRG PDúLQ úL VXQW WUDWDWH LQWHULRU vQ DOW IHO ID GH
SURFHGXULOHúLIXQFLLOHRELúQXLWH
42
UTCB
LY3URFHGXULOHúLIXQFLLOHinterrupt VXQWúLHOHWUDWDWHvQPRGVSHFLDOGH
compilator. Ele se folosesc pentru a prelua controlul microprocesorului prin
mecanismul de întreruperi
Pentru mai multe detalii se poate consulta un manual mai complet de
programare în Pascal.
ÌQ JHQHUDO XWLOL]DUHD SURFHGXULORU úL IXQFLLORU XúXUHD] VFULHUHD úL
vQHOHJHUHD SURJUDPHORU 0HGLXO GH SURJUDPDUH 7XUER 3DVFDO FRQLQH
QXPHURDVH SURFHGXUL úL IXQFLL SHQWUX UH]ROYDUHD D GLYHUVH SUREOHPH úL VH
vPERJHúWHSULQELEOLRWHFLGHVXESURJUDPHRULHQWDWHSHWLSXULGHSUREOHPH
([HUFLLL
[ Q ( −)
Q
6HG I ( [ ) = ∑

6VHWLSUHDVFYDORULOHOXLI[SHQWUX[vQWUHúLFX
Q= Q +

SDVXO6HYDIRORVLXQVXESURJUDPIXQFLHSHQWUXI[
2. Fie
 GDFD [ <

 ( [ + ) GDFD ≤ [ <
I ( [) =  H[ +
 [ GDFD ≤ [ <

 [ − GDFD ≤ [

6VHFDOFXOH]H ∫ I [ G[ prin metoda trapezelor, luînd n=120.

−
 −
 
3. Fie a= −  6 VD FDOFXOH]H E D20 IRORVLQG R SURFHGXU GH IRUPD
 
 − − 
procedure mult(var a,b:matrice)vQFDUHVHvQPXOHúWHDFXELDUUH]XOWDWXODSDUHvQE7LSXO
PDWULFHVHGHILQHúWHtype matrice=array[1..3,1..3] of real.

6HGHILQHúWHH[S$ , + $ + $ ++ $ Q +XQGH$HVWHRPDWULFHSWUDWLF

Q
LDU,HVWHPDWULFHDLGHQWLWDWH6VHVFULHXQSURJUDPGHFDOFXODSUR[LPDWLYDOOXLH[S$SULQ

DGXQDUHDWHUPHQLORUGLQVHULHSkQ $ Q ≤ ε $LFLPDWULFHD$SWUDWLFúL ε > se dau. Se
Q
FHUHVVHIRORVHDVFRSURFHGXUsuma(var s,a:matrice)SULQFDUHPDWULFHDDHVWHDGXQDWOD
PDWULFHD V R VXEUXWLQ prod(var t,a:matrice) SULQ FDUH VH UHDOL]HD] W W D R IXQFLH
∑ ∑ (W )

norma(t:matrice):realFDUHGHWHUPLQQRUPDOXLWGXSIRUPXOD W = L M
L M
6VHFDOFXOH]H1000.6HSRWUHLQHFLIUHOHVHPQLILFDWLYHvQED]DvQWUXQYHFWRU
GHWLSE\WHúLVVHIDF R SURFHGXU GH vQPXOLUH D GRX QXPHUH GH DFHVW IHO 'H H[HPSOX
JVLP20=22199679011334534360755686462799509931608401.
43
UTCB
)LH $ULDDEFUHDOUHDO R IXQFLH FH QH G DULD XQXL WULXQJKL vQ IXQFLH GH ODWXUL
8QJKL$DEFUHDOUHDOIXQFLDFHQHGXQJKLXO$úLDQDORJ8QJKL%8QJKL&6VHIDFXQ
SURJUDPFDUHFLWHúWHODWXULOHDEFúLDILúHD]XQJKLXULOHXWLOL]kQGIXQFLLOHGHPDLVXV
6HUHSHWDVXSUDXQHLPDWLFLXUPWRDUHOHGRXRSHUDLLLVHVLPHWUL]HD]PDWULFHD
a:=(a+at LL VH SHUPXW FRORDQHOH ! ! Q!Q úL Q! &H GHYLQH PDWULFHD
 − 
 
D =  GXSGHDVWIHOGHWUDQVIRUPUL)DFHLFkWHRSURFHGXUSHQWUXILHFDUHWLS
 
 
GH WUDQVIRUPDUH ,QFHUFDL úL FX DOWH PDWULFH ( DGHYUDW F UH]XOWDWXO WLQGH VSUH R PDWULFH
VLPHWULFRGDWFXFUHúWHUHDQXPUXOXLGHRSSHUDLL"
8. Fie a o matrice Q × Q úL b XQ YHFWRU Q GLPHQVLRQDO 0DL MRV HVWH GDW R IRUP
UXGLPHQWDU GH UH]ROYDUH D VLVWHPXOXL ax=b SULQ PHWRGD OXL *DXVV /D VIkUúLW VH FHUH
SHUIHFLRQDUHDDFHVWHLSURFHGXUL
program sistem;
const nmax=20;
type matrice=array[1..nmax,1..nmax] of real;
vector=array[1..nmax] of real;
{completarea 1}
procedure gauss(ndim:integer;var a:matrice; var b:vector; var kod:integer);
var i,j,k:integer;
s,piv,f:real;
begin
for i:=1 to ndim do
begin
piv:=a[i,i];
^SHUIHFLRQDUHD`
for j:=i to ndim do a[i,j]:=a[i,j]/piv;
b[i]:=b[i]/piv;
for k:=1 to ndim do
begin
if(k<>i)then
begin f:=-a[k,i];
for j:=i to ndim do a[k,j]:=a[k,j]+f*a[i,j];
b[k]:=b[k]+f*b[i];
end;
end;
end;
kod:=0;
end;
{completarea 2}
END.
44
UTCB
L 6 VH SXQ YDULDELOHOH QHFHVDUH vQ completarea 1 úL V VH SXQ vQ completarea 2
LQVWUXFLXQLOHGHFLWLUHDPDWULFLLDGHGLPHQVLXQHQGLP QGLP úLDYHFWRUXOXLEGHGLPHQVLXQH
QGLP QPD[ SUHFXP úL LQVWUXFLXQHD GH DSHO D SURFHGXULL JDXVV úL GH VFULHUH D UH]XOWDWXOXL
5HPDUFDLFUH]XOWDWXODSDUHvQE
LLLÌQSURJUDPXOGHPDLVXVSLYRWXOHVWHOXDWD>LL@6VHDGDXJHRFRPSOHWDUHvQORFXO
PHQLRQDW SULQ SHUIHFLRQDUHD prin care pivotul este luat cel mai mare element în modul
GLQWUHD>LL@D>LL@D>QGLPL@'DFHOHVWHD>ORFL@FXLORF QGLPDWXQFLVHVFKLPEvQWUH
HOHOLQLLOHLúLORFGLQVLVWHP
LY6XQWVLWXDLLvQFDUHVLVWHPXOHVWHLQFRPSDWLELOúLDWXQFLGHWD ÌQDOJRULWPDFHVW
OXFUXVHUHIOHFWSULQSLYRWXOpiv foarte mic în modul. Prin variabila kodVFRDWHPvQHYLGHQ
GDFVLVWHPXOVDUH]ROYDWVDXQX8QGHDUWUHEXLSODVDWVHFYHQDGHSURJUDP
if(abs(piv)<1.e-15)then
begin
kod:=1;exit;
end;
SHQWUX FD SURFHGXUD V GHD YDORDUHD OXL NRG GDF VLVWHPXO QX VH UH]ROY ELQH GLQ
FDX]D SLYRLORU PLFL úL NRG GDF VLVWHPXO VH UH]ROY QRUPDO" 0RGLILFDL SURJUDPXO
SULQFLSDOSHQWUXDWHVWDYDORDUHDOXLNRGúLDDILúDUH]XOWDWXOQXPDLGDFVLVWHPXOVDUH]ROYDW
normal.
8. Tipul String
2SHUDLLFXYDULDELOH6WULQJ
$FHVWWLSUHSUH]LQWúLUXULOHGHFDUDFWHUH'HFODUDLDGHYDULDELOHGHDFHVW
tip se face astfel:
VAR variabila:String;
sau
VAR variabila:String[lungime];
)LHFDUHFDUDFWHUVHUHSUH]LQWSHXQRFWHW,QWURYDULDELOúLUGHFDUDFWHUH
SULPXO RFWHW FRQLQH QXPUXO GH FDUDFWHUH LDU FHLODOL RFWHL FRQLQ FRGXULOH
FDUDFWHUHORU /XQJLPHD PD[LP D XQXL úLU HVWH GH FDUDFWHUH
'HFODUDLD ch:String HVWH HFKLYDOHQW FX ch:String[255] úL LPSOLF DORFDUHD D
RFWHL RFWHW SHQWUX OXQJLPH RFWHL SHQWUX FDUDFWHUH 'HFODUDLD
ch:String[n]vQVHDPQFVHDORFQRFWHLRFWHWSHQWUXOXQJLPHQRFWHL
pentru caractere).
&RQVWDQWHOHGHWLS6WULJVHGHFODU
CONST nume='Sirul considerat';
2YDORDUH6WULQJVHUHSUH]LQWvQ3DVFDOSULQúLUXOUHVSHFWLYGHFDUDFWHUH
încadrate de ' '.
&DUDFWHUHOH FDUH QX DX FRUHVSRQGHQW SH WDVWDWXU VH SRW LQWURGXFH SULQ
QXPUXOGHRUGLQHSUHFHGDWGH'HH[HPSOXVLU
(QWHU
HVWHXQúLUFDUH
VHWHUPLQFXFDUDFWHUXODOOHDGLQOLVWD$6&,,FDUHHVWH(QWHU
2SHUDLLFXúLUXUL
45
UTCB
)LHVXQúLU$WXQFLV>@QHGOXQJLPHDúLUXOXLV>@GSULPXOFDUDFWHU
s[2] pe al doilea etc. Schimbarea unui caracter se poate face prin s[i]:='caracter'
LDUVFKLPEDUHDvQWUHJXOXLúLUSULQV QRXOBúLU
&RQFDWHQDUHDPDLPXOWRUúLUXULVHQRWHD]FX
'HH[HPSOXV
DLFL

VL

DFROR
GSHQWUXVYDORDUHD
DLFLVLDFROR

/LPEDMXO 7XUER 3DVFDO QH SXQH OD GLVSR]LLH XQ PDUH QXPU GH
SURFHGXULGHOXFUXFXúLUXUL,DWROLVWDORU
)XQFLD $FLXQHD Exemplu
Function Chr(x:Byte):Char ' FDUDFWHUXO FX QXPUXO &KUGYDORDUHD

$
de ordine x
Function &RQFDWHQHD] úLUXULOH V &RQFDW
DD

E
G
DDE
Concat(s1,s2,..:String):String s2,...
Function &RSLD] GLQ úLUXO V XQ Copy('program',4,10)
Copy(s1:String;i,nr:integer):Strin QXPU GH FHO PXOW QU are ca rezultat 'gram',
g FDUDFWHUH GDF H[LVW SHQWUX F QX H[LVW
vQFHSkQGGLQSR]LLDL caractere.
)XQFLD $FLXQHD Exemplu
Procedure Delete(Var s:String, ùWHUJHQUFDUDFWHUHGLQV s:='abcdef'
i,nr:integer); vQFHSkQGGLQSR]LLDL 'HOHWHVG
s:='aef'
Procedure Insert(s1:String; Var ,QVHUHD]SHVvQV s2:='doi';
s2:String; i:Integer); vQFHSkQGGLQSR]LLDL ,QVHUW
XQX
VG
'dunuoi'
Function Pos(s1,s:String):Byte &DXWSHVvQV'DFvO 3RV
GRL

LQGRLW
G
JVHúWH3RVGSR]LLDGH valoarea 3
XQGHvQFHSHVDOWIHOG
Function Length(s:String):Integer; ,QWRDUFHOXQJLPHDúLUXOXL /HQJWK
3DVFDO
G
valoarea 6
Procedure 3XQHvQVVXEIRUPGH X:=1.24E+1;
Str(X[:m:n]; Var s:String); caractere valoarea 6WU;VG
variabilei numericee X s:='12.4 '
(eventual pe m poz. cu n
zecimale)
Procedure Val(s:String; &RQYHUWHúWHúLUXOVvQ Val('1.2ee2',s,cod) va
X:tip_numeric; Var cod:Integer); QXPUDWULEXLWOXL[úL GDFRG DGLFDO
FRG 'DFHRHURDUH doilea e nu corespunde
FRG SR]LLDXQGHHHURDUHD unui format numeric
,QYHUVLXQLOHPDLQRLGH7XUER3DVFDOVDLPSOHPHQWDWúLWLSXOPchar úLU
GHSkQODFDUDFWHUHGLIHULWHGHùLUXOVHWHUPLQODSULPXOFDUDFWHU
([HUFLLL
6HFLWHVFGHODWDVWDWXUGRXúLUXULúLVHWLSUHúWHúLUXORELQXWSULQFRQFDWHQDUHDORU
46
UTCB
6HFLWHVFGHODWDVWDWXUGRXúLUXULúLVHWLSUHúWHFHPDLUPkQHGLQSULPXOúLUGXS
HOLPLQDUHDFDUDFWHUHORUFHDSDUúLvQúLUXODOGRLOHD
6HFLWHúWHGHODWDVWDWXUXQúLUQXPHSUHQXPHGHSHUVRDQVHSDUDWHSULQVSDLX6
VHWLSUHDVFvQRUGLQHLQYHUVSUHQXPHQXPH
6HFLWHVFGHODWDVWDWXUúLUXUL3HQWUXILHFDUHúLUVHIDFHFRQYHUVLDvQQXPU'DF
VHUHXúHúWHDWXQFLVHWLSUHúWHQXPUXOúLVLQGHDFHOQXPULDUGDFQXVHUHXúHúWHVHWLSUHúWH
mesajul "nu e format numeric".
6 VH IDF R SURFHGXU GH RUGRQDUH DOIDEHWLF D GRX úLUXUL úL FX DMXWRUXO HL V VH
RUGRQH]HDOIDEHWLFúLUXULLQWURGXVHGHODWDVWDWXUvQWUXQYHFWRUGHWLSVWULQJ
6HLQWURGXFHGHODWDVWDWXUXQúLUúLVHDILúHD]úLUXOFXFDUDFWHUHOHVFKLPEDWH
a) în litere mari; b) în litere mici.
,QGLFDLH)XQFLD8S&DVHFKGSHQWUXOLWHUDFKFRUHVSRQGHQWXOOLWHUPDUH/LWHUHOH
PLFL DX QXPUXO GH RUGLQH FX PDL PDUH FD OLWHUHOH PDUL FRUHVSXQ]WRDUH RUG
$

RUG
=
LDUFHOHODOWHOLWHUHPDULDXQXPUXOGHRUGLQHvQWUHúL
9. Tipul Set
3ULQ DFHVW WLS GH GDWH VH UHSUH]LQW PXOLPLOH FX SkQ OD OD GH
elemente de tip ordinal: Char, Byte, Boolean, enumerare, interval. Declararea se
face prin:
Type
WLSBPXOLPH 6HWRIWLSBRUGLQDO
9DULDELOHOHVHGHFODUvQVHFLXQHD9DUSULQ
Var
YDULDELODWLSBPXOLPH
&RQVWDQWHOH VH GHFODU vQ VHFLXQH &RQVW SULQ VSHFLILFDUHD HOHPHQWHORU
PXOLPLLvQWUH>úL@'HH[HPSOX
Const m=['A', #13, 'M'..'Z' ];
GHILQHúWHPXOLPHDPGHWLS6HWRI&KDUIRUPDW GLQOLHUD$FDUDFWHUXO
(QWHUúLOLWHUHOHPDULGLQWUH0úL=
2SHUDLLFXPXOLPL
2SHUDLD $FLXQHD Exemplu
* ,QWHUVHF LD $ % G LQWHUVHF LD OXL $ FX %
+ Reuniunea $% G UHXQLXQHD OXL $ FX %
- 'LIHUHQ D $% G GLIHUHQ D PXO LPLORU $ úL %
Atribuirea a:=['1','2','3'];
in 9HULILF DSDUWHQHQ D [ LQ $ DUH YDORDUHD 758( GDF [ HVWH HOHPHQW
GLQ $ úL )$/6( vQ FD] FRQWUDU
47
UTCB
<= 9HULILF LQFOX]LXQHD $ % HVWH 758( GDF $ H VXEPXO LPH D OXL %
úL )$/6( vQ FD] FRQWUDU
>= 9HULILF LQFOX]LXQHD $! % H VXEPXO LPH D OXL$

% HVWH 758( GDF
<> 9HULILF LQHJDOLWDWHD $!% HVWH 758( GDF $ úL % VXQW GLIHULWH
= 9HULILF HJDOLWDWHD $ % HVWH 758( GDF $ úL % VXQW HJDOH
3XWHPIRORVLPXOLPLOHODFRQVWUXFLDPHQLXULORUFDPDLMRV
program exemplu;
Label din_nou;
Const m=['A', 'B', 'V',#27];
Var ch:Char; x,y:Real;..............
{Definirea procedurilor sort, bilant, verificare}
Procedure meniu;
Begin
din_nou: ClrScr;
writeln('A=sort'); writeln('B=bilant');
writeln('V=verificare');writeln('Esc=gata');
repeat ch:=UpCase(Readkey) until ch in m;
Case ch of
'A' : sort;
'B' : bilant;
'C' : verificare;
#27: halt;
End; {end case}
Goto din_nou;
End; { end meniu}
BEGIN {programul princ.}

meniu;
END.{end program}
48
UTCB
10. Tipul înregistrare

(record)
Un tip cu structura de inregistrare, pe scurt numit tip “înregistrare”,
FRQVWGLQWUXQQXPDUIL[GHFRPSRQHQWHDYkQGWLSXULRDUHFDUH
'HFODUDUHDúLXWLOL]DUHDWLSXOXLUHFRUG
([LVWGRXYDULDQWHGHGDWHUHFRUG
DvQUHJLVWUDUHFXVWUXFWXUDIL[
Type
nume_articol=RECORD
câmp1:tip1;
câmp2:tip2;
..................;
câmpn:tipn;
END;
EvQUHJLVWUDUHFXVWUXFWXUDYDULDELO
Type
nume_articol=RECORD
câmp1:tip1;
câmp2:tip2;
..................;
CASE câmp_selector : tip_selector of
const1:(campvar1:tipvar1;campvar2:tipvar2;...);
const2:(campvar1:tipvar1;campvar2:tipvar2;....);
.............................................................................;
END;
2EVHUYDLH7LSXO³WLSBVHOHFWRU´WUHEXLHVDILHXQWLSRUGLQDOGHGDWH
$SDULWLDXQXLLGHQWLILFDWRUvQGHILQLLD unui câmp al unei
vQUHJLVWUULQHFHVLWGHILQLUHDVDLQSUHDODELO
Exemple:
1)Type
adresa=record
strada:string[20];
nr:byte;
loc:string[25];
end;
49
UTCB
persoana=record
nume:string[30];
adr:adresa;
end;
Var
a:adresa;
p:persoana;
2EVHUYDLH5HIHULUHDODXQFkPSDOvQUHJLVWUULLVHIDFHDVWIHO
DORF
,DúL

p.adr.nr:=25;
p.adr.strada:='Carol'
sau cu ajutorul prepozitiei “WITH”:

with p,a do
begin
nume:='Ion';
strada:='Carol';
nr:=25;
ORF
,DúL
end;
2)Type
studii=(elementare,medii,superioare);
persoana=record
nume:string[20];
salariu:500000..1000000;
case preg:studii of
elementare:();
medii:(bac:real);
superioare:(anabs:1950..2000;stat:boolean);
end;
Var
x,y,z:persoana;
2EVHUYDLH1XPDLRYDULDQWSRDWHILDFWLY
Referirea la un câmp se face astfel:
x.nume:='Ion' x.salariu:=520000; x.preg:=elementare;
y.nume:=‘George’; y.salariu:=700000; y.preg:=medii;
y.bac:=8.5 z.nume:='Geta'; z.salariu:=1000000;
z.preg:=superioare; z.anabs:=1990; z.stat:=true;
50
UTCB
Exemplu
6DVHUHDOL]H]HXQSURJUDPFDUHvQUHJLVWUHD]DQXPLWHGDWHUHIHULWRDUHOD
PDL PXOL FDQGLGDL FH SDUWLFLS OD R FRPSHWLLH VSRUWLY úL DILúHD] SH HFUDQ
clasamentul acestora.
Program clasament;
uses crt;
const max=100;
type candidat=record
nume:string[25];
loc:string[15];
punctaj:real;
end;
clasament=array[1..max] of candidat;
var a:clasament;
b:candidat;
i,j,n:integer;
Begin
clrscr;
repeat
write(‘n=‘);
readln(n);
until n<=max;
for i:=1 to n do with a[i] do
begin
write(‘nume: ‘);readln(nume);
write(‘loc: ‘);readln(loc);
write(‘punctaj: ‘);readln(punctaj);
end;
for i:=1 to n-1 do
for j:=i+1 to n do
if a[i].punctaj<a[j].punctaj
then begin
b:=a[i];
a[i]:=a[j]:
a[j]:=b;
end;
writeln;
writeln(‘ CLASAMENT’);
51
UTCB
writeln;
writeln(‘ Nume si prenume Localitatea Punctaj’);
writeln(‘*******************************************’);
for i:=1 to n do with a[i] do
writeln(nume:20,loc;10,’ ‘,punctaj:7:3);
End.
([HUFLLL
6DVHUHDOL]H]HXQSURJUDPFDUHFLWHúWHGHODWDVWDWXUDFDPSXULOHXQXLDUWLFRO
-nume:string;
-nota1:real;
-nota2:real;
-nota3:real;
-media:real; (o calculeaza in program)
si afiseaza pe ecran numele si media.
)LH XQ YHFWRU D FX FRPSRQHQWH GH WLS UHFRUG FD OD H[HUFLLXO 'DWHOH QXPH
QRWDQRWDQRWDVHDIOvQILúLHUXOWH[W
QRWHGDW
SHILHFDUHOLQLHILLQGGDWHOHXQHLSHUVRDQH
L6VHFLWHDVFDFHVWHGDWHvQYHFWRUXODLL6VHFDOFXOH]HPHGLLOHúLúDVHDILúH]HSHHFUDQ
LLL 6 VH SXQ vQWUXQ QRX ILúLHU WH[W
QRWHGDW
GDWHOH SXQkQG SH DFHHDúL OLQLH LQIRUPDLLOH
SHQWUXDFHHDúLSHUVRDQ
6DVHUHDOL]H]HXQSURJUDPFDUHFLWHúWHGHODWDVWDWXUFkPSXULOHXUPDWRUXOXLDUWLFRO
nume,
GDWDQDúWHULL
-zi ,
-luna,
-an.
VLDILúHD]SHHFUDQQXPHOHSHUVRDQHORUQVFXWHvQ
52
UTCB
)LúLHUH
3VWUDUHD LQIRUPDLLORU GXS RSULUHD FDOFXODWRUXOXL VH IDFH SH XQ VXSRUW
PDJQHWLF VDX RSWLF GDU QH SXWHP DúWHSWD úL OD DOWH YDULDQWH GH VDOYDUH D
LQIRUPDLHLvQYLLWRU/LPEDMXO7XUER3DVFDOQHSXQHODGLVSR]LLHLQVWUXFLXQLGH
WUDQVIHU D GDWHORU vQWUH PHPRULD HOHFWURQLF 5$0 úL GLVSR]LWLYHOH IL]LFH GH
SVWUDUH D LQIRUPDLHL FRQHFWDWH OD FDOFXODWRU $úD FXP úWLP LQIRUPDLD vQ
DVHPHQHDGLVSR]LWLYHHVWHRUJDQL]DWvQILúLHUHFDUHODUkQGXOORUVXQWRUGRQDWH
în directoare iar sistemul de operare (Dos de exemplu) este înzestrat cu
SURJUDPHSXWHUQLFHGHPDQLSXODUHDLQIRUPDLHLSHDFHVWHGLVSR]LWLYH8QOLPEDM
GH SURJUDPDUH GH H[HPSOX OLPEDMXO 3DVFDO QH SXQH OD vQGHPkQ SURFHGXUL
FRPRGHGHOXFUXFXILúLHUHOHSURFHGXULFDUHODUkQGXOORUXWLOL]HD]GLQSOLQGDU
în mod transparent pentru utilizator, resursele sistemului de operare.
,QSURFHVXOGHPDQLSXODUHDILúLHUHORUGLVWLQJHP
a) )LúLHUXOIL]LFGHUHJXOXQILúLHUSHGLVFXOPDJQHWLFVDXXQGLVSR]LWLY
periferic:
tastatura......INPUT
ecranul.........OUTPUT
imprimanta...LST
b) )LúLHUXO ORJLF FDUH HVWH XQ QXPH VLPEROLF vQ SURJUDP úL FDUH YD IL
DVRFLDWFXXQILúLHUIL]LF
2SHUDUHDFXILúLHUHSUHVXSXQH
L$VRFLHUHDQXPHOXLVLPEROLFGLQSURJUDPFXXQQXPHGHILúLHUIL]LFSULQ
procedura Assign
LL'HVFKLGHUHDILúLHUXOXLFXSURFHGXUDreset sau crearea lui cu procedura
rewrite. In ambele cazuri se depun în anumite variabile create automat de
OLPEDMXO 3DVFDO LQIRUPDLL GHVSUH ILúLHUXO IL]LF QXPHOH SR]LLD SH GLVF
lungimea, etc.
LLL6FULHUHDvQILúLHUFXSURFHGXUDwriteVDXFLWLUHDGLQILúLHUFXSURFHGXUD
read
LY,QFKLGHUHDILúLHUXOXLFXSURFHGXUDclose.
7XUER 3DVFDO FXQRDVWH WUHL WLSXUL GH ED] GH ILúLHUH FX FDUH VH SRW
transfera date de la un dispozitiv la altul:
FILE : este un tip general care permite transferul datelor în bloc
TEXT : DGPLQLVWUHD]UkQGFXUkQGXQILúLHULQPRGVHFYHQLDO
FILE OF tip: HVWHJkQGLWSHQWUXILúLHUHFXDFFHVGLUHFW
$FFHV VHFYHQLDO vQVHDPQ F R FRPSRQHQW GDW GLQ ILúLHU SRDWH IL
JVLWGRDUFLWLQGILúLHUXOSDVFXSDVGHODvQFHSXWSkQODGDWDUHVSHFWLY$FFHV
GLUHFWvQVHDPQFRULFHGDWSRDWHILDFFHVDWSULQWUXQQXPUGHRUGLQHIUD
53
UTCB
ILQHYRLHGHSDUFXUJHUHDWXWXURUvQUHJLVWUULORUGHODvQFHSXWSkQODJVLUHDGDWHL
respective.
11.1. Fisiere de tip text
$FHVWH ILúLHUH VXQW JkQGLWH SHQWUX D SUHOXD WH[WH VXE IRUP GH úLUXUL
SHQWUX D OH WUDQVIHUD úL D OH VWRFD UkQG FX UkQG GHFL XQ ILúLHU GH WLS WH[W
UHSUH]LQW R VHFYHQ GH FDUDFWHUH VWUXFWXUDWH SH OLQLL D FDURU OXQJLPH HVWH
YDULDELOGHDFHHDHOHQXSRWILH[SORDWDWHGHFkWVHFYHQLDO
Sintaxa de declarare:
Var
nume_fisier:TEXT;
3URFHGXULúLIXQFLLGHOXFUX
3URFHGXUDVDXIXQFLD $FLXQHD
procedure ASSIGN(var f, nume_extern) DVRFLD] QXPHOH ORJLF I FX QXPHOH GH SH GLVF
nume_extern
procedure RESET(var f) deschide fisierul la inceput; suporta proceduri
orientate spre citire
procedure REWRITE(var f) creaza si deschide un nou fisier;suporta
proceduri orientate spre scriere
procedure APPEND(var f) GHVFKLGH ILúLHUXO OD VIkUúLW SHQWUX DGXJDUH GH
date
procedure READLN(var f ,numevar); FLWHúWH GLQ ILúLHUXO I úL GHSXQH vQ YDULDELOD
numevar
procedure WRITELN(var f ,numevar); LDGLQYDULDELODQXPHYDUúLVFULHLQILúLHUXOI
procedure TRUNCATE(var f); VH HOLPLQ GLQ ILúLHU WRDWH LQIRUPDLLOH GH OD
SR]LLDFXUHQWSkQODVIkUúLW
function EOL(var f):boolean; functie care testeaza sfarsitul de linie
function EOF(var f):boolean; functie care testeaza sfarsitul de fisier
procedure CLOSE(var f); vQFKLGHILúLHUXOFXQXPHOHORJLFI
2EVHUYDLH 'DF DUH ORF R HURDUH OD RSHUDLLOH FX ILúLHUH vQ JHQHUDO VH
WHUPLQH[HFXLDSURJUDPXOXLúLVHDILúHD]XQPHVDM3HQWUXDHYLWDDFHVWOXFUX
VH FRPSLOHD] SURJUDPXO FX GLUHFWLYD ^,` vQ IDD XQRU SURFHGXUL XQGH DSDU
frecvent erori (reset, append, rewrite), apoi se pune din nou {$I+}. Efectul
DFHVWHLGLUHFWLYHHVWHGHHYLWDWHUPLQDUHDIRUDWDSURJUDPXOXLGDUXUPWRDUHD
RSHUDLHFXILúLHUHVHSRDWHIDFHQXPDLGDFHVWHDSHODWIXQFLDIOResult care
QHIXUQL]HD]FRGXOHURULL'DFHOHVWHQXDDSUXWQLFLR HURDUH GDF HVWH
GLIHULWGH]HURDWXQFLSURJUDPDWRUXOXUPHD]VLDPVXULOHSHFDUHOHGRUHúWH
Intr-un manual mai complet de Pascal se descriu toate codurile de eroare.
3URJUDPXOXUPWRULOXVWUHD]IRORVLUHDDFHVWRUSURFHGXULúLIXQFLL
Program afisare;
^SURJUDPXOYL]XDOL]HD]ILúLHUHWH[WDQDORJFXFRPDQGD'RV7\SH`
54
UTCB
uses crt;
const nmax=200;
type ttext=array[1..nmax] of string;
var f:text;
nume:string[20];
ch:char;
linie,nlinii:integer;
ptext:ttext;
i1,i2:integer;
procedure scrie (i1,i2:integer); {scrie liniile dintre i1 si i2};

begin
clrscr;
for linie:=i1 to i2 do writeln (ptext[linie]);
end;
procedure deschide; {deschide fisierul pentru a-l putea citi};

label start;
begin
clrscr;
start: write ( ' nume program : ' );
readln ( nume );
if ( nume=' ' ) then halt;
assign ( f,nume );
{ $i - } reset ( f ); { $i + }
if ioresult <>0
then begin
writeln ( ' fisier inaccesibil ' );
goto start
end;
end;
procedure citeste; {citeste liniile din fisier in vectorul ptext};

begin
linie:=1;
nlinii:=0;
while ( not eof (f) and (nlinii<nmax)) do
begin
readln ( f,ptext[linie] );
linie:=linie+1;
nlinii:=nlinii+1;
55
UTCB
end;
close ( f );
end;
function max ( i1,i2:integer ):integer; {maximul a doi intregi};
begin
if i1<i2 then max:=i2
else max:=i1;
end;
function min (i1,i2:integer):integer; {minimul a doi intregi};

begin
if i1<i2 then min:=i1 else min:=i2;
end;
BEGIN
{ dupa deschidere se afiseaza cate o transa de 20 linii };
{cu tastele A si Z se muta transa inapoi sau inainte};
deschide;
citeste; i1:=1; i2:=min(nlinii,i1+20);
scrie ( i1,i2);
repeat
ch:=upcase(readkey);
case ch of
'A': begin i1:=max(1,i1-1);
i2:=min(nlinii,i1+20);scrie(i1,i2);end;
'Z': begin i1:=min(i1+1,nlinii); i2:=min(nlinii,i1+20);
scrie(i1,i2); end;
#13: halt;
end;
until ch=#13;
END.
2EVHUYDLH 3URJUDPXO FLWHúWH GLQ ILúLHUXO I OLQLLOH XQXL WH[W SH FDUH OH
GHSXQH SH UkQG vQ YHFWRUXO SWH[W GXS FDUH OH DILúHD]D SH HFUDQ FkWH
1DYLJDUHDSULQILúLHUVHIDFHFXWDVWHOH
$
vQDSRL
=
vQDLQWH'DFILúLHUXODUH
SHVWHQPD[ GHOLQLLDWXQFLOLQLLOHGHODvQVXVQXVHDILúHD]&RUHFWDL
acest lucru.
8UPWRUXOSURJUDPFUHD]XQILúLHUGHWLSWH[WFDUHDUHGUHSWFRPSRQHQWH
diferite date referitoare la anumite persoane; datele (nume, vârsta, loc) se citesc
GHODWDVWDWXUDSRLVHVFULXLQILúLHU
56
UTCB
program creare;
var fpers:text;{ fisierul de creat }
nume:string[20];virsta:integer;loc:string[15];
begin
assign ( fpers,’PERSOANE.DAT’ );
rewrite ( fpers);{creare si deschidere fisier}
write ( ’nume persoana: ’);
readln (nume);write ( fpers,nume );
repeat
write ( ’ virsta: ’ );readln (virsta);write ( fpers;virsta );
write ( ’localitatea: ’ );readln ( loc );writeln ( fpers,loc );
write ( ’ Nume persoana ( return pt iesire ): ‘);
readln ( nume );write ( fpers,nume );
until length ( nume )=0; { daca s-a tastat return nu se mai citeste }
close ( fpers );
readln;
end.
3URJUDPXOXUPWRUFLWHVWHGHODWDVWDWXUDXQQXPH'DFUHJVHVWHDFHVW
QXPHvQILúLHUDWXQFLDILúHD]DGXSFD]YkUVWDVDXORFDOLWDWHD
program exploatare;
var fpers:text;
nume,nume1:string [20];loc1:string [15];virsta1:string [2];rasp:char;
begin
assign ( fpers,’PERSOANE.DAT ’ );
write ( ’introduceti numele persoanei: ’ );
readln ( nume);
while lengh ( nume ) < >0 do
begin
reset ( fpers ) ; {deschidere fisier }
repeat
readln ( fpers,nume1,virsta1,loc1 );
until ( eof ( fpers ) ) or ( nume=nume1 );
if nume < > nume1 then writeln ( ’ nu exista persoana ’ )
else begin
write ( ’ doriti sa aflati virsta pers.? ( d/n ): ’ );
read ( rasp );if rasp= ’d’ then writeln ( virsta1,’ ani’ );
write (’ doriti sa aflati localitatea unde are domiciliul? (d/n:’ );
readln;read ( rasp );readln;if rasp=’d’ then writeln ( loc1 )
end;
write ( ’ introduceti numele persoanei ( return pt iesire ): ’ );
57
UTCB
readln ( nume );close ( fpers );

end;
end.
)LúLHUHFXWLS
,Q DFHVWH ILúLHUH LQIRUPDLD H RUJDQL]DW SH XQLWL GH DFHHDúL OXQJLPH
QXPLWH DUWLFROH 7RDWH DUWLFROHOH DX DFHHDúL VWXFWXU úL SRW IL FLWLWH vQ RULFH
ordine.
'HFODUDUHDXQXLILúLHU
var numef_logic:File of tip_de_baza;
3ULQ DFHDVW GHFODUDLH VH VSHFLILF IDSWXO F ILúLHUXO H vPSULW vQ
vQUHJLVWUULDUWLFROHDYkQGWRDWHWLSXOtip_de_baza.
3URFHGXULúLIXQFLLXWLOL]DWH
procedurile ASSIGN, RESET, REWRITE, CLOSE, EOFVXQWODIHOFDSHQWUXILúLHUHWH[W
procedure SEEK(var f,n:longint); SR]LLRQHD]D PDUFDWRUXO GH ILúLHU SH DUWLFROXO
dorit; numerotarea articolelor incepe cu 0; în
XUPD XQHL RSHUDLL GH VFULHUH VDX FLWLUH
PDUFDWRUXOvúLPUHúWHYDORDUHDFXRXQLWDWH
procedure TRUNCATE(var f); VHúWHUJDUWLFROHOHGHODSR]LLDFXUHQWSkQOD
VIkUúLWXOILúLHUXOXL
function FILEPOS(var f):longint; indica pozitia marcatorului de fisier
function FILESIZE(var f):longint; indica numarul articolelor fisierului
procedure WRITE(var f, v:tip_de_baza) VH VFULH vQ ILúLHUXO ORJLF I vQ SR]LLD FXUHQW
variabila v
procedure READ(var f, v:tip_de_baza); VH FLWHúWH GLQ ILúLHUXO ORJLF I DUWLFROXO FXUHQW
în variabila v
'PPDLMRVXQH[HPSOXGHXWLOL]DUHDILúLHUHORUFXWLS
Program fisier_cu_tip;
uses crt;
type student=record
nume:string[20];
alg:real;
analiza:real ;
media:real;
end;
^DFHDVWDHVWHVWUXFWXUDXQHLvQUHJLVWUULGLQILVLHU`
var f:file of student;
v:student;
58
UTCB
nume:string[10];
nr_art:integer;
{ pentru comoditatea programarii programul e împartit in proceduri}
Procedure deschide; {deschide sau creaza fisierul};

begin
clrscr;
write ('nume fisier:');readln (nume);
if nume='' then halt;
assign (f,nume);
{$i-};
reset (f)
{$i+};
if ioresult <>0 then rewrite (f);
end;
Procedure pune_date(nr_art:integer);
{se citeste o inregistrare de la tastatura si se pune in fisier};
{ la pozitia nr_art};
begin
clrscr;
Writeln('se pune in fisier inregistrarea nr:', nr_art+1);
write ('nume student: ');readln (v.nume);
write ('nota alg: ');readln (v.alg);
write ('nota analiza: ');readln (v.analiza);
v.media:=(v.alg+v.analiza)/2;
seek(f, nr_art);
write(f,v);
writeln('===== date puse in fisierul:',nume)
end;
Procedure afiseaza(nr_art:integer);
{se afiseaza pe ecran inregistrarea nr_art};
begin
seek(f,nr_art);read(f,v);
clrscr;
writeln('continutul inregistrarii nr:',nr_art+1);
writeln(' nume= ', v.nume);
writeln('algebra=',v.alg:5:2);
writeln('analiza=',v.analiza:5:2);
writeln(' media=',v.media:5:2);
59
UTCB
writeln('=====================');
end;
Procedure manipulare;
{se navigheaza prin fisier inainte si inapoi};
{se adauga sau se modifica inregistrari};
{ in functie de tasta apasata};
label 1;
const optiuni=['C','X','Z','A','S'];
var ch:char;
begin
{e afisata lista de optiuni};
1: writeln('z=inapoi, x=inainte, c=corectie, a=adaugare, s=stop');
{se alege optiunea};
repeat ch:=upcase(readkey) until ch in optiuni;
{ in functie de optiunea aleasa};
{ se apeleaza procedura corespunzatoare};
case ch of
'A':begin nr_art:=filesize(f);pune_date(nr_art);end;
'C':pune_date(nr_art);
'Z':begin if nr_art>0 then nr_art:=nr_art-1;afiseaza(nr_art);
end;
'X':begin if(nr_art<filesize(f)-1)then nr_art:=nr_art+1;
afiseaza(nr_art);
end;
'S':begin close(f);halt;end;
end;
goto 1;
end;{end manipulare};
Begin
deschide;
if filesize(f)=0 then pune_date(0)
else afiseaza(0);
manipulare;
{fisierul este inchis in procedura manipulare};
End.
60
UTCB
)LúLHUHIUWLS
$FHVWHILúLHUH VH IRORVHVF SHQWUX WUDQVIHU GH GDWH LQ EORF 0ULPHD XQXL
EORFHVWHVSHFLILFDWODGHVFKLGHUHDILúLHUXOXL
Declararea lor se face prin:
Var
nume_logic:File;
Proceduri folosite:
procedurile ASSIGN, EOF, CLOSEVXQWODIHOFDSHQWUXILúLHUHWH[W
procedure RESET(var f); VH GHVFKLGH ILúLHUXO XQ EORF DYkQG GH
procedure RESET(var f; n:word) RFWHLvQFD]XODOGRLOHDXQEORFDUHQRFWHL
procedure REWRITE(var f); VH FUHD] XQ ILúLHU IU WLS FX GLPHQVLXQHD
procedure var f; n:word); XQXLEORFGHRFWHLvQFD]XODOGRLOHDXQ
EORFDUHQRFWHL
procedure BLOCKREAD(var f; var bufer; VHvQFHDUFDVHWUDQVIHUDGLQIvQFHSkQGFX
nr:word; [rezultat:word]) EORFXOFXUHQWXQQXPUGHQUEORFXULvQ
memorie, la adresa lui bufer; rezultat este egal
FXQXPUXOEORFXULORUHIHFWLYWUDQVIHUDWH
procedure BLOCKWRITE(var f; var VH vQFHDUF D VH WUDQVIHUD vQ I vQFHSkQG FX
bufer; nr:word; [rezultat:word]) EORFXO FXUHQW XQ QXPU GH QU EORFXUL GLQ
memorie, de la adresa lui bufer; rezultat este
HJDOFXQXPUXOEORFXULORUHIHFWLYWUDQVIHUDWH
procedurile FILESIZE FILEPOSúLSEEK VXQWODIHOFDSHQWUXILúLHUHFXWLS
$YHPvQFRQWLQXDUHXQH[HPSOXGHXWLOL]DUHDDFHVWRUILúLHUH
Program fisier_fara_tip;
var sursa,destinatie:file;
citit,scris:word;
tampon:array[1..2048] of char;
numsursa,numdestinatie:string[15];
Begin
write(‘Fisierul sursa: ‘);
redln(numsursa);
write(‘Fisierul destinatie: ‘);
readln(numdestinatie);
assign(sursa,numsursa);
reset(sursa,1);{lungimea componentelor este 1 octet}
assign(destinatie,numdestinatie);
rewrite(destinatie,1);
writeln(‘Copiere de ‘,Filesize(sursa),’ octeti !’);
61
UTCB
repeat
blockread(sursa,tampon,2048,citit);
blockwrite(destinatie,tampon,citit,scris);
until (citit=0) or (scris<>citit);
close(sursa);
close(destinatie);
END.
2EVHUYDLH$FHVWSURJUDPFRSLD]FRQLQXWXOXQXLILúLHUILúLHUVXUVvQ

DOWILúLHUILúLHUGHVWLQDLH
([HUFLLL
6 VH UHDOL]H]H XQ SURJUDP FDUH V DGDXJH XQ WH[W GH OD WDVWDWXU vQ ILúLHUXO
LQFHUFDUHGDWILVLHUXOHVWHGHWLSWH[WVLH[LVWSHGLVF
2). Sa se realizeze un program care citeste toate liniile din fisierul Inf.dat (fisier de tip
WH[WúLOHDILVHD]DSHHFUDQFXOLWHUHPDUL
6DVHUHDOL]H]HXQSURJUDPFDUHDILVHD]SHHFUDQFRQWLQXWXOXQXLILVLHUGHWLSWH[W
numerotând liniile acestuia.
6VHUHDOL]H]HXQSURJUDPGHvQFULSWDUHGHFULSWDUHDXQXLILúLHUWH[WVHFLWHúWHFkWH
ROLQLHVHPRGLILFGXSROHJHFDUDFWHUHOH>GHH[HPSOXFK!&KU2UGFKPRG@úL
VH VDOYHD] OLQLD vQ DOW ILúLHU WH[W /D GHFULSWDUH VH VFKLPE FDUDFWHUHOH LQYHUV
[ch>Chr((Ord(ch)+239) mod 256))]
5). Sa se realizeze un program care creaza un fisier numit Personal.Dat. Componentele

DFHVWXLILúLHUVXQWGHWLSDUWLFROFXXUPDWRDUHOHLQIRUPDWLLUHIHULWRDUHODDQJDMDWLLXQXLLQVWLWXW
-nr.crt.
-nume si prenume
- salariu
6). Fisierul Examen.Dat contine articole de tipul:
-nume student
- media
6DVHUHDOL]H]HXQSURJUDPFDUHVSHUPLWDDGDXJLULúLPRGLILFULGHDUWLFROH
3ULQSURJUDPVVHFLWHDVFXQILúLHU
([DPHQ'DW
FDvQH[HUFLLXOúLVVHSXQ
GDWHOHvQWUXQILúLHUWH[WXQDUWLFROILLQGSXVvQWUROLQLH
6VHvQFULSWH]HXQILúLHUSULQUHVFULHUHDOXLGHODVIkUúLWVSUHvQFHSXW
6VHIDFXQSURJUDPFDUHFDXWXQDQXPLWúLUGHFDUDFWHUHvQWUXQILúLHU
6VHIDFXQSURJUDPFDUHWUDQVIRUPXQILúLHUWH[WvQWUXQQRXILúLHUWH[WFXWRDWH
OLQLLHGHFDUDFWHUHFRPDVkQGODQHYRLHOLQLLVDXWLQGGLQHOH
62
UTCB
9DULDELOHUHIHULQ
3XWHUHDXQXLOLPEDMFRQVWSULQWUHDOWHOHvQSRVLELOLWDWHDGHDDYHDDFFHVOD
RULFH]RQGHPHPRULH GH D FUHD úL GLVWUXJH GXS QHYRLH ]RQH GH GDWH $FHVW
OXFUXVHSRDWHIDFHvQ3DVFDOSULQYDULDELOHUHIHULQúLSRLQWHULSXQFWDWRUL
5HDPLQWLPFXQDQXPLWRFWHWHVWHORFDOL]DWvQFDOFXODWRUSULQWURDGUHV
2DGUHVHVWHIRUPDWGLQGRXFXYLQWH RFWHLGHIRUPDFFXQGHFúL
FVXQWGHRELFHLGDLvQED]DIRORVLQGVLPEROXULOH
$ % & ' ( ) 3HQWUX UHSUH]HQWDUHD XQXL FXYkQW ZRUG GHFL D GRL RFWHL
avem nevoie de cel mult 4 cifre hexazecimale. De exemplu $AF0E este
14+0*16+15*162+10*163. Numerele hexazecimale sunt precedate de $ iar cel
PDL PDUH QXPU FH VH UHSUH]LQW SH GRL RFWHL HVWH )))) ,Q
UHSUH]HQWDUHDFFDXQHLDGUHVHvQFDOFXODWRUFVHQXPHúWHDGUHVDGHVHJPHQW
LDU F VH QXPHúWH GHSODVDPHQWXO VDX RIIVHWXO 2 DVWIHO GH DGUHV DU IL
DGUHV vQ FDUH VHJPHQWXO DUH YDORDUHD F LDU GHSODVDPHQWXO
F 2ULFH YDULDELO VDX FRQVWDQW GLQ SURJUDP VH UHSUH]LQW
vQ FDOFXODWRU vQFHSvQG GH OD R DQXPLW DGUHV vQ VXV SH XQ QXPU GH RFWHL
SRWULYLWFXOXQJLPHDDFHOHLYDULDELOHUHDOSHRFWHLLQWHJHUSHRFWHLORQJLQW
SHRFWHLHWF
Datele dintr-un program Pascal sunt se pot clasifica în:
statice - HOH VH FUHHD] vQWUR ]RQ GH PHPRULH FDUH H RFXSDW vQ WRW
WLPSXO H[HFXLHL SURJUDPXOXL VXQW YDULDELOHOH GHFODUDWH vQ VHFLXQHD YDU GLQ
programul principal);
auto HOHVHFUHD]DXWRPDWFkQGHVWHQHYRLHGHHOHúLVHGLVWUXJDXWRPDW
FkQGVHWHUPLQOXFUXOFXHOHVXQWYDULDELOHOHGLQIXQFLLúLSURFHGXUL
dinamice VXQW FUHDWH úL GLVWUXVH GH SURJUDPDWRU GXS QHYRLOH
programului.
Utilizarea variabilelor dinamice presupune declararea, crearea,
XWLOL]DUHDúLGLVWUXJHUHDORU
'HFODUDUHDXQHLYDULDELOHUHIHULQ
0RGXOGHGHFODUDUHDOXQHLYDULDELOHUHIHULQHVWHXUPWRUXO
WLSBUHIHULQAWLSBED]
^WLSBUHIHULQYDFRQLQHDGUHVDXQHLYDULDELOHWLSBED]`
FDvQH[HPSOHOHXUPWRDUH
var p:^real; { S YD FRQLQH DGUHVD XQXL QXPU UHDO GHFODUDW vQ
VHFLXQHDYDU`
TYPE
tabel=record
63
UTCB
nume:string[20];
nota1,nota2,nota3,media:real;
obs:string;
end;
VAR
q:^tabel;
In exemplul de mai sus qYDFRQLQHDGUHVDXQHLYDULDELOHGHWLSWDEHOWLS

definit înainte de q.
TYPE
adresa_tabel=^tabel;
tabel=record
nume:string[20];
nota1,nota2,nota3,media:real;
obs:string;
end;
VAR
qq:adresa_tabel;
In acest exemplu qq HVWH FD vQ H[HPSOXO SUHFHGHQW R DGUHV D XQHL
YDULDELOH GH WLS WDEHO 6H YHGH F vQ VHFLXQHD W\SH VH SHUPLWH GHFODUDUHD
adresa_tabel=^tabel imediat înainte de declararea lui tabel . Acest lucru
SHUPLWHFUHHDUHDGHODQXULGHGDWH
TYPE
adresa_tabel_nou=^tabel_nou;
tabel_nou=record
x,y,z:real;
obs:string;
alt_tabel:âdresa_tabel_nou;
end;
VAR
q2:adresa_tabel_nou;
Aici q2 FRQLQH DGUHVD XQHL YDULDELOH GH WLS WDEHOBQRX YDULDELO FDUH vQ
LQWHULRU DUH XQ FkPS QXPLW DOWBWDEHOBQRX FH FRQLQH DGUHVD XQHL DOWH YDULDELOH
tabel_nou, care la rândul ei are un câmp alt_tabel_nou.... Se pot crea astfel
ODQXUL GH GDWH GH WLS WDEHOBQRX vQ ILHFDUH GDW DIOkQGXVH vQWUXQ FkPS DO HL
DOWBWDEHOBQRXDGUHVDGDWHLXUPWRDUH
/DvQFHSXWXOH[HFXLHLSURJUDPXOXLWRDWHYDULDELOHOHUHIHULQDXYDORDUHD
nil. $FHDVWYDORDUHvQVHDPQFvQFQXFRQLQQLFLRDGUHVGHPHPRULHGHFL
QX VD H[HFXWDW LQVWUXFLXQHD GLQ SURJUDP SHQWUX FUHDUHD GLQDPLF D GDWHORU
DGUHVDWHGHYDULDELODUHIHULQUHVSHFWLY
64
UTCB
&UHDUHDGLQDPLFDGDWHORU
3HQWUXUH]HUYDUHGHPHPRULHúLDGUHVDUHD]RQHLUHVSHFWLYHGHRYDULDELO
UHIHULQIRORVLPLQVWUXFLXQLOH
QHZYDULDELODBUHIHULQ
sau
*HW0HPYDUBUHIHULQOXQJLPH
ca mai jos:
new(p); new(q); new(q1); new(q2); getmem(p,600);...
=RQDGHPHPRULHvQWUHVIkUúLWXOSURJUDPXOXLúLVIkUúLWXOPHPRULHLSHQWUX
XWLOL]DWRU VH QXPHúWH heap úL HVWH vQ SULQFLSLX OLEHU /D DSHOXO LQVWUXFLXQLL
new(p)vQDFHDVW]RQVHUH]HUYR]RQGHRFWHLSHQWUXXQQXPUUHDOLDU
DGUHVD GH vQFHSXW D DFHVWHL ]RQH HVWH SXV vQ p SHQWUX F p HVWH UHIHULQ OD
UHDO$QDORJODDSHOXOLQVWUXFLXQLLnew(q)VHUH]HUYvQKHDSR]RQHJDOFX
lungimea tuturor datelor din tabel, SizeOf(tabel) úL vQ q se pune adresa de
vQFHSXWDDFHVWHL]RQH(SRVLELOFDOXQJLPHDGDWHLVILHVXILFLHQWGHPDUHvQFkW
V QX vQFDS vQ KHDS ,Q DFHVW FD] YDULDELOD UHIHULQ UPkQH FX YDORDUHD QLO
3HQWUX D FRQWUROD SULQ SURJUDP GDF H[LVW PHPRULH VXILFLHQW SHQWUX FUHDUHD
YDULDELOHLDYHPODGLVSR]LLHIXQFLLOH
MemAvail=PULPHDWRWDODPHPRULHLGLVSRQLELOHGLQKHDSvQRFWHL
MaxAvail OXQJLPHDFHOHLPDLPDUL]RQHFRQWLJXHGLQKHDSvQRFWHL
Ele se pot utiliza astfel:

If(MaxAvail>SizeOf(tabel)+10000) then new(q) else ....
(VWHELQHVUPkQvQKHDSXQVSDLXOLEHUODGLVSR]LLDVLVWHPXOXL
3ULQ LQVWUXFLXQHD getmem(p,600) VD UH]HUYDW GLQ KHDS R ]RQ GH
RFWHLDFUHLDGUHVGHvQFHSXWVHSXQHvQS'DFSHVWHUHIHULQODXQQXPU
UHDO DWXQFL VD UH]HUYDW SUHD PXOW LDU GDF IRORVHDP getmem(p,4) se rezerva
SUHDSXLQ
&D V UH]HUYP PHPRULH H[DFW FkW WUHEXLH IRORVLP ILH new(p) fie
getmem(p,SizeOf(tip_variabila)).
12.3. Utilizarea datelor create dinamic
$FFHVDUHDXQHLYDULDELOHDFUHLDGUHVHVWHvQYDULDELODBUHIHULQVHIDFH
prin
YDUBUHIHULQkA
Mai explicit
XWLOL]DUHDQXPUXOXLUHIHULWGHSVHIDFHSULQ p^ ca de exemplu sin(p^);
65
UTCB
- utilizarea câmpurilor din tabelul referit de q se face prin q^.nume,

q^.nota1, q^.nume:='Ion';
q^.media:=(q^.nota1+q^.nota2+q^.nota3)/3
12.4. Distrugerea datelor
Distrugerea datelor create dinamic se face astfel:
Creare Distrugere
new(p) dispose(p)
getmem(p,lungime) freemem(p,lungime)
De exemplu dispose(p)HOLEHUHD]]RQDGHPHPRULHGLQKHDSRFXSDWGH
QXPUXOUHDOSAúLDWULEXLHOXLp valoarea nil, deci p nu mai are adresa nici unei
]RQH GH PHPRULH 'DF VH DORF PHPRULH GLQ KHDS SULQ getmem(p,600),
dealocarea se face prin freemem(p,600).
6XQW VLWXDLL FkQG QX DYHP QHYRLH FD YDULDELOD FH FRQLQH R DGUHV GH
PHPRULHILHHDSVILHUHIHULQODXQDQXPLWWLSGHGDW$WXQFLRGHFODUP
simplu
var p:Pointer;
Alocarea de memorie se face prin getmem(p, lungime) iar dealocarea
prin freemem(p,lungime).
$WULEXLUHD XQHL DGUHVH XQHL YDULDELOH UHIHULQ GH H[HPSOX S VH SRDWH
face prin:
1) alocare de memorie prin new sau getmem din heap ca mai sus;
2) S $GGUYDULDELO^SLDDGUHVDYDULDELOHLYDULDELO`
3) S #YDULDELO{ un alt mod echivalent cu 2}
4) S DOWYDULDELOUHIHULQ^FHOHGRXYDULDELOHUHIHULQWUHEXLHV
fie compatibile}
5) p:=Ptr(c1,c2); {p este adresa c1:c2}
,Q FD]XULOH QX VH UH]HUY VSDLX GLQ KHDS 3ULQ SXWHP FRQWUROD
RULFH]RQGHPHPRULHGLQFDOFXODWRU$VWIHOp:^byte úL p:=Ptr(c1,c2) G vQ
p^ valoarea octetului de la adresa c1:c2
12.5. Exemple
Exemplul 1.
6H FLWHVF GRX QXPHUH D úL E SHQWUX FDUH VH UH]HUY VSDLX vQ PRG
GLQDPLF6HWLSUHúWHVXPDORU
66
UTCB
3URJUDPXOFRUHVSXQ]WRUHVWH
program nr1;
var pa,pb:^real;
s:real;
BEGIN
new(pa); new(pb);
write('a,b='); readln(pa^,pb^);
s:=pa^+pb^; writeln('suma=',s:10:3);
dispose(pa); dispose(pb);
readln;
END.
Exemplul 2.
6H LQWURGXFH GH OD WDVWDWXU XQ QXPU QDWXUDO Q úL SH XUP VH FLWHVF vQ
memorie doi vectori reali u, v, fiecare de lungime n. Se va rezerva minimul de
PHPRULH QHFHVDU SHQWUX X úL Y 6H FDOFXOHD] SURGXVXO ORU VFDOU
S X>@ Y>@X>@ Y>@X>Q@ Y>Q@FDUHVHDILúHD]
3URJUDPXOFDUHUHDOL]HD]DFHVWOXFUXHVWH
program nr2;
type vector=array[1..1]of real;
var u,v:^vector;
i,n:integer;
p:real;
BEGIN
{$R-}
write('lungimea vectorilor=');readln(n);
{se testeaza daca exista suficienta memorie libera};
if(MaxAvail>10000+2*n*SizeOf(real)) then
begin
{se aloca memorie pentru 2 vectori};
getmem(u,SizeOf(real)*n);getmem(v,SizeOf(real)*n);
end
else halt;
{se citesc cei doi vectori};
for i:=1 to n do
begin
write('componentele:',i:3,' pentru u si v sunt:');
readln(u^[i],v^[i]);
end;
{se calculeaza produsul scalar};
p:=0;
67
UTCB
for i:=1 to n do p:=p+u^[i]*v^[i];

writeln('produsul scalar=',p:10:3);
{se elibereaza memoria ocupata de cei doi vectori};
freemem(u,SizeOf(real)*n);freemem(v,SizeOf(real)*n);
readln;
END.
6H YHGH F H QHYRLH GH GLUHFWLYD GH FRPSLODUH ^5` SHQWUX D QX VH
YHULILFDIDSWXOFXA>L@HIRORVLWúLSHQWUXL!GHúLXHUHIHULQODRYDULDELOGH
tip array[1..1] of real.
Exemplul 3.
6H GDX P úL Q 6 VH FRQVWUXLDVF GLQDPLF R PDWULFH P× Q DOH FUHL
HOHPHQWHVHFLWHVFGHODWDVWDWXUVHGHSXQvQPHPRULHúLVHWLSUHúWHVXPDORU
Programul:
program nr3; {$R-}
type vector=array[1..1] of real;
pvector=^vector;
matrice=array[1..1]of pvector;
pmatrice=^matrice;
var a:pmatrice;
i,j,m,n:integer;
s:real;
BEGIN
write('m=');readln(m);
write('n=');readln(n);
getmem(a,m*SizeOf(pvector)); { a este adresa unei zone de m adrese
referite prin a^[1], a^[2], ... a^[m]};
for i:=1 to m do getmem(a^[i],SizeOf(real)*n);
{fiecare din cele m pozitii ale lui a^ devine adresa unui vector cu n
componente reale; comonenta j a vectorului cu adresa in a^[i] este a^[i]^[j]};
{se citesc elemente in matrice};
for i:=1 to m do
for j:=1 to n do
begin
write('elementul ', i:3,' ',j:3,' este:');
readln(a^[i]^[j]);
end; { s-a citit matricea};
{se calculeaza suma elementelor};
s:=0;
for i:=1 to m do
68
UTCB
for j:=1 to n do
s:=s+a^[i]^[j];
writeln('suma=',s:10:3);
{se elibereaza memoria alocata};
for i:=1 to m do freemem(a^[i],SizeOf(real)*n);
freemem(a,SizeOf(pvector)*m); {gata dealocarea}
readln;
END.
([HUFLLL
,QH[HPSOXOSXQHLvQDLQWHGHDORFDUHDGLQDPLFDPHPRULHLRLQVWUXFLXQHFDvQ
exemplul 2 de testare a memoriei disponibile.
,Q H[HPSOXO FRQVWUXLL PDWULFHD FD XQ YHFWRU FX PÂQ FRPSRQHQWH RELQXW SULQ
DúH]DUHDOLQLLORUXQDGXSDOWD6HREVHUYFHOHPHPWXOLMGLQPDWULFHHVWHHOHPHQWXO
L QMGLQYHFWRU5HVFULHLSURJUDPXO
6 VH IDF SURGXVXO D GRX PDWULFH $ % & SULQ UHSUH]HQWDUHD GLQDPLF D
PDWULFLORU0DWULFLOH%úL&VHYRUFLWLGLQWUXQILúLHUWH[W
)LHVLVWHPXO; $;%XQVLVWHPGHQHFXDLLFXQQHFXQRVFXWHFX$>LM@ UDQGRPQ

GDF L!M úL $>LM@ GDF L M $FHDVW DOHJHUH D OXL $ QH DVLJXU ∑ $ <1 pentru orice i.
Q
LM
M =
6ROXLDVLVWHPXOXLHVWH ; = OLP ; unde X1 DUELWUDUúL;n=AXn-1%PHWRGDOXL,DFREL6

Q
Q →∞
se rezolve sistemul, reprezentând A,B,X dinamic pentru n=20, n=100, n=500.(Un Xn e
DFFHSWDELOFDVROXLHGDF_;n-Xn-1|<0.01)
5. Se dau structurile:
Type
adresa:êlement;
element=record
precedentul:adresa;
valoare:Real;
urmatorul:adresa;
end;
)LH úLUXO [1=1, xn=sin(1/xn-1) * xn-1/(2+xn-12)=f(xn-1 6 VH GHWHUPLQH SULPXO P FX
|xm|<eps=0.001
D6VHVFULHWHUPHQXO[[m/2]
E6VHOLVWH]HWHUPHQLLúLUXOXLvQRUGLQHLQYHUVGHODPOD
,QGLFDLH 2 YDULDQW SRVLELO 6 VH UHLQ WHUPHQLL SkQ OD SULPXO P DVWIHO FD
|xm_ HSVvQWUROLVWvQFDUH
var x1:element; p:adresa;
p:=@x1; p^.valoare=1; p^.precedentul:=nil;
/,. |p^.valoare|>=eps
69
UTCB
atunci new(p^.urmatorul); v:=f(p^.valoare);

p^.urmatorul^.precedentul:=p; p:=p^.urmatorul; p^.valoare:=v
altfel p^.urmatorul:=nil;
Acum putem parcurge lista în orice sens.
6H G IXQFLD I[ YDORDUHD [0 úL HSV! 6 VH GHWHUPLQH SULPXO Q DVWIHO DVWIHO FD
SHQWUXXQ LQVDYHP_[n-xi|<eps. Exemplu: f(x)=sin(x), eps=0,001, iar x0VHFLWHúWHGHOD
FRQVRO
)LHYHFWRUXOYFXFRPSRQHQWHUHDOHLDUY>L@ UDQGRPDFHDVWDvQVHDPQF

Y>L@HVWHXQQXPUvQWkPSOWRULQWUHúL3HQWUXFHYDORDUHLYDORDUHD_Y>L@Y>L@_HVWH
PLQLP"
13. Unituri
8QLWXULOHFRQVWLWXLHED]DSURJUPULLPRGXODUHvQ785%23$6&$/
(OHUHSUH]LQWRFROHFLHGHGHFODUDLLFRQVWDQWHWLSXULYDULDELOHSRFHGXUL
úLIXQFLLFDUHSRDWHILXWLOL]DWvQFRQVWUXFLDDOWRUSURJUDPH
8QLWXULOHVXQWvQFUFDWHVXEIRUPFRPSLODWvQSURJUDPHOHFDUHIDFX]GH
HOHGHFLVHHFRQRPLVHúWHWLPSODFRPSLODUHDXQXLSURJUDP
Sintaxa de declarare :
USES nume_unit_1, [nume_unit_2,...];
785%23$6&$/DUHXUPWRDUHOH81,7XULVWDQGDUG
1. SYSTEM FRQLQH GHFODUDLL GH FRQVWDQWH YDULDELOH SURFHGXUL úL
IXQFLLVWDQGDUGXWLOL]DWHvQWURPDUHGLYHUVLWDWHGHSURJUDPHVFULVHvQ
7XUER3DVFDOúLGHDFHHDHVWHLQFOXVDXWRPDWvQWRDWHSURJUDPHOHI UD
ILQHFHVDUVSHFLILFDUHDVDvQWURFODX]86(6
2. CRTLPSOHPHQWHD]RVHULHGHUXWLQHFDUHSHUPLWXQFRQWUROVXSHULRU
DVXSUDHFUDQXOXLFXORULIHUHVWUHWDVWDWXULLúLSURGXFHULLGHVXQHWH
3. DOSLPSOHPHQWHD]XQQXPUGHUXWLQHIRDUWHXWLOHDOHVLVWHPXOXLGH
RSHUDUH'26LQFOX]kQGFRQWUROXOGDWHLúLRUHLRSHUD LLFXGLUHFWRDUHúLH[HFXLD
programelor;
4. OVERLAY- permite programelor mari partajarea memoriei rapide:
5. PRINTER IDFLOLWHD] OXFUXO FX LPSULPDQWD GHFODUkQG XQ ILúLHU GH
WLSWH[WQXPLW/VWSHFDUHvODVRFLD] GLVSR]LWLYXOXL/37
6. GRAPHFRQLQHXQSDFKHWGHVXESURJUDPHJUDILFHSHUIRUPDQWH
7. TURBO3 - permite utilizarea programelor scrise în Turbo Pascal 3.0;
8. GRAPH3 LPSOHPHQWHD] VXESURJUDPH JUDILFH GLQ 7XUER 3DVFDO
3.0.
70
UTCB
&XH[FHSLDXOWLPHORUXQLWXULFHOHODOWHXQLWXULVWDQGDUGVXQWLQFOXVHvQ
ELEOLRWHFD785%273/FDUHHVWHDXWRPDWvQFUFDWODODQVDUHDPHGLXOXL7XUER
Pascal.
3H OkQJ DFHVWHD PDL H[LVW úL DOWH XQLWXUL FDUH IDF SDUWH GLQ PHGLXO GH
dezvoltare Turbo Pascal, grupate sub numele Turbo Vision.
%RUODQG 3DVFDO IRU :LQGRZV DUH LPSOHPHQWDWH úL DOWH XQLWXUL SHQWUX D
UVSXQGHQHYRLORUGHSURJUDPDUHvQVLVWHPXOGHRSHUDUH:LQGRZV
13.1. Structura unui unit:
1. ANTETUL VSHFLILF QXPHOH XQLWXOXL FDUH WUHEXLH V ILH DFHODúL FX

QXPHOHILúLHUXOXLvQFDUHVHVFULHXQLWXO
,17(5)$&( FRQLQH GRDU DQWHWXO SURFHGXULORU úL IXQFLLORU SXEOLFH

DGLF DO IXQFLLORU úL SURFHGXULORU DSHODELOH GLQ SURJUDPHOH XQGH VH XWLOL]HD]
XQLWXO XUPkQG FD EORFXO DFHVWRU VXESURJUDPH V ILH LQFOXV vQ VHFLXQHD
IMPLEMENTATION.
,03/(0(17$7,21 GHILQHúWH EORFXO WXWXURU SURFHGXULORU úL
IXQFLLORU SXEOLFH ,Q SOXV GHILQHúWH HWLFKHWH FRQVWDQWH WLSXUL YDULDELOH
SURFHGXULúLIXQFLLSULYDWHDGLFLQDFFHVLELOHSURJUDPHORUVDXXQLWXULORUFDUH
XWLOL]HD]XQLWXOUHVSHFWLY$FHVWHVXESURJUDPHSRWILUHIHULWHvQRULFHRUGLQHvQ
VHFLXQHD ,03/(0(17$7,21 'LQ DQWHWHOH VXESURJUDPHORU SXEOLFH GLQ
VHFLXQHD,03/(0(17$7,21SRWVOLSVHDVFOLVWHOHGHSDUDPHWULIRUPDOLGDU
GDF VXQW SUH]HQWH HOH WUHEXLH V ILH LGHQWLFH FX FHOH GLQ VHFLXQHD
INTERFACE.
4. INITIALIZARE FRQVW ILH GLQ FXYvQWXO (1' ILH GLQWUR VHFLXQH GH
LQVWUXFLXQLFDUHWUHEXLHH[HFXWDWHSHQWUXDLQLLDOL]DXQLWXO
Exemplu
Unit mat;
INTERFACE
Const linie=‘*********************************’;
Function sumdiv(n:integer):longint;
IMPLEMENTATION
Function sumdiv(n:integer):longint;
var i:integer;
f:longint;
71
UTCB
Begin
f:=0;
for i:=2 to n-1 do
if (n mod i)=0 then f:=f+i;
sumdiv:=f;
end;
END.
Program utiliz_unit;
uses crt,mat;
var n:integer;
Begin
ZULWHµ,QWURGXFHLQ! µUHadln(n);
writeln(n,’ are suma divizorilor =‘,sumdiv(n));
writeln(linie);
End.
2EVHUYDLH 3HQWUX D SXWHD IL XWLOL]DW XQLWXO PDW DFHVWD WUHEXLH V ILH
FRPSLODWSHGLVFVH[LVWHILúLHUXO0$7738
13.2. Unit-ul PRINTER
$FHVWXQLWIDFLOLWHD]OXFUXOFXLPSULPDQWDGHFODUkQGXQILúLHUGHWLSWH[W
QXPLW/VWSHFDUHvODVRFLD]GLVSR]LWLYXOXL/37
Exemplu
Program listare;
uses crt,printer;
var text:string;
Begin
writeln(‘Scieti un text pe ecran ! :’);
readln(text);
ZULWHOQµSUHJWLWLLPSULPDQWD pentru a scrie textul pe foaia de
hirtie!’);
ZULWHOQµ&LQGVXQWHWLJDWDDSVDWLRWDVW¶
writeln(lst,text);
End.
72
UTCB
([HUFLLL
6VHUHDOL]H]HXQXQLWFDUHVFRQLQXUPWRDUHOHSURFHGXUL
UH]ROYDUHDXQHLHFXDLLWUDQVFHQGHQWHSULQPHWRGDELVHFLHL
UH]ROYDUHDXQXLVLVWHPGHHFXDLLOLQLDUHSULQPHWRGD*DXVV6HLGHO
- calculul aproximativ al unei integrale definite,
UHSUH]HQWDUHDJUDILFDXQHLIXQFLL
6 VH JUXSH]H vQWUXQ XQLW SURFHGXULOH GLQ VHFLXQHD )LúLHUH úL V VH UHVFULH
programele de acolo, folosind unitul creat.
73
UTCB
14. Un rezumat al limbajului Turbo Pascal
14.1. Tipuri de date în Turbo Pascal
Tipul Descriere Exemplu

boolean o =TRUE sau FALSE var a:boolean; a:=(2<3);
char o caracter Ascii c:='D'; c:=#10; c:=Chr(27);
shortint o întreg cu semn pe un octet i:=-128; i:=127;
byte o vQWUHJIUVHPQSHXQRFWHW i:=0; i:=255;
integer o vQWUHJFXVHPQSHGRLRFWHL i:=-32768; i:=32767
word o vQWUHJIUVHPQSHRFWHL i:=0; i:=65535
longint o vQWUHJFXVHPQSHRFWHL i:=-2147483648
single UHDOSHRFWHL x:=9.67; x:=-12.56e-4;
real UHDOSHRFWHL x:=9.67; x:=-12.56e-4;
double UHDOSHRFWHL x:=9.67; x:=-12.56e-4;
extended UHDOSHRFWHL x:=9.67; x:=-12.56e-4;
comp vQWUHJSHRFWHL x=234e10
enumerare o OLVWGHQXPH type e=(eu, tu, el, ea);
interval o interval de date ordinale type litera=('a'..'Z');
array vectori, matrici, masive de var a:array[1..3,1..4] of real
GDWHGHDFHODúLIHO a:[1,3]:=7;
string úLUXULGHFDUDFWHUH var s:string[20]; s:='Pas'+'cal'
set PXOLPL const a=['1', 'a', 'm'..'z']
procedure WLSSURFHGXU type proc=procedure(x,y,z:real);
function WLSIXQFLH type func=function(x:real):real;
pointer DGUHVGHvQFHSXWGH]RQ var p1:^real; p2:pointer; new(p1);
de memorie p1^:=1.2; p2:=p1
record grupare de diverse date type fel=record
x:real;
optiune:boolean;
obs:string;
end;
file ILúLHUH var f:text; f1: file of real; f2:file;
'DWHOHFDUHDXVHPQXO
R
UHSUH]LQWWLSXULOHRUGLQDOH
74
UTCB
14.2. Instructiuni ale limbajului Turbo Pascal
,QVWUXFLXQHD Forma ([SOLFDLLH[HPSOH

atribuire variabila:=expresie x:=x+3;
read read(v1); read(v1,v2);... FLWHúWHGHODFRQVROSH
v1,etc.
readln readln(v1); readln(v1,v2);.. FLWHúWHGHODFRQVROúLVH
WUHFHODOLQLDXUPWRDUH
write write(v1); write('text',v1); VFULHODFRQVROHYHQWXDOFX
write('text',v1:m:n); WH[WvQIDSHPSR]LLLQ
zecimale
writeln writeln(v1); etc. ZULWHOQ
[
[GXS
scriere se trece la linia
XUPWRDUH
if LIFRQGLLHWKHQLQVWU if x<0 then x:=x*x+y;
LIFRQGLLHWKHQLQVWU if x<0 then x:=x*x+y
else insstr2; else begin x:=1/x;
y:=x;
end;
goto JRWRHWLFKHW label et;
....
et: x:=x*y+1/x;
....
goto et;
case case selector of permite alegerea între mai
varianta1: instr1; multe variante.
varianta2: instr2;
....
else instr;
end;
for for var:=val1 to val2 do instr; for i:=1 to 10 do x:=x*i;
for var:=v2 downto v1 do inst for i:=10 downto 1 do x:=x/i;
while while conditie instructiune; while i<1 do begin x:=x+i;
i:=i+1; end;
repeat repeat instr until conditie repeat x:=x+i;i:=i+1 until
i=10
3XWHUHDOLPEDMXOXLFUHúWHIRDUWHPXOWSULQSRVLELOLWDWHDGHDIRORVL
VXESURJUDPHSURFHGXULúLIXQFLLSULQSRVLELOLWDWHDGHIRORVLGLQDPLF
PHPRULDúLSULQSRVLELOLWDWHDGHXWLOL]DPHPRULLSHUPDQHQWHFDGLVFXULOH
PDJQHWLFH6LVWHPXO3DVFDOGHED]FRQLQHPXOWHDVHPHQHDIDFLOLWLVXEIRUP
GHSURFHGXULúLIXQFLLOLVWDWHvQFRQWLQXDUH'HDVHPHQHDODGLVSR]L LD
SURJUDPDWRULORUH[LVWXQLWXULVWDQGDUGRULHQWDWHVSUHSUREOHPHVSHFLILFH8QHOH
GLQHOHVXQWGHVFULVHvQFHOHFHXUPHD]
75
UTCB
3URFHGXULOHúLIXQFLLOHFDUHXUPHD]IDFSDUWHGLQFHHDFHVHFKHDP
unitul SYSTEM, iar acest unit este utilizat pentru toate programele scrise în
Turbo Pascal.
)XQFLLúLSURFHGXULVWDQGDUG7XUER3DVFDO
Functii numerice
Abs, Arctan, Cos, Exp, Frac, Int, Ln, Pi, Round, &DOFXOHD]YDORULOHXQRUIXQFLL
Sin, Sqrt, Sqr, Trunc numerice elementare
Detalii în pagina 56..
Prelucrarea tipurilor ordinale
procedure Dec(var x[;n:longint]); GHFUHPHQWHD]SH[>FXQ@
procedure Inc(var x[;n:longint]); LQFUHPHQWHD]SH[>FXQ@
function Ord(x):longint; GQXPUXOGHRUGLQHDOOXL;vQ
WLSXOVX
function Pred(x):tipul lui x; predecesorul lui x
function Succ(x):tipul lui x; succesorul lui x
)XQFLLVXSOLPHQWDUHSHQWUXWLSXULOHLQWHJHUúLFKDU
function Chr(x:byte):char; UHWXUQHD]FDUDFWHUXOFXQXPUXOGH
ordine x, în codul ASCII
function Lo(x):byte; UHWXUQHD]RFWHWXOLQIHULRUDO
întregului x
function Hi(x):byte; GRFWHWXOVXSHULRUDOOXL[LQWHJHU
sau word
function Odd(x:longint):boolean HVWH758(GDF[HLPSDU
function Swap(x):tipul lui x; VFKLPEvQWUHHLRFWHLLOXL[LQWHJHU
sau word
function UpCase(ch:char):char; UHWXUQHD]FDUDFWHUXOPDMXVFXO
FRUHVSXQ]WRUOXLFKGDFHFD]XO
Prelucrarea sirurilor de caractere
function Insert(s:string; var s1:string;i:integer) LQVHUHD]vQVSHVGLQSR]LLDL
function Concat(s1,s2,..:string):string; FRQFDWHQHD]úLUXULOHVV
function Copy(s:string; i, nr:integer):string H[WUDJHXQVXEúLUGHQUFDUDFWHUH
GLQVvQFHSkQGFXSR]LLDL
procedure Delete(var s:string; i, nr:integer); VHúWHUJHRSRULXQHGHQUFDUDFWHUH
GLQúLUXOVvQFHSkQGFXSR]LLDL
function Pos(s1,s2:string):byte; GHWHUPLQSR]LLDOXLVvQVGDF
VQXHVXEúLUvQVDWXQFLG
valoarea 0
procedure Str(x[:m:n]; var s:string); IRUPDWHD]QXPDUXO[vQV
SURFHGXUH9DOVVWULQJ[QXPUFRGLQWHJHU FRQYHUWHúWHúLUXOVvQQXPUSXVvQ
x
function Length(s:string):integer; GOXQJLPHDúLUXOXLV
Gestiunea memoriei
function Addr(x):pointer; UHWXUQHD]DGUHVDOXL[
76
UTCB
function CSeg:word; UHWXUQHD]SDUWHDGHVHJPHQWGLQ

adresa de început a codului
SURFHGXUH'LVSRVHYDUSWLSBUHIHULQ HOLEHUHD]]RQDGHPHPRULH
RFXSDWGHYDULDELODSAvQKHDS
function DSeg:word; adresa de început a segmentului de
date
procedure FillChar(var x; nr:word; ch:pe_octet); umple .de la adresa lui x în sus, nr
RFWHLFXYDORDUHDFK
procedure FreeMem(var p:pointer; n:word); HOLEHUHD]QRFWHLGLQKHDS
DGUHVDLGHS
procedure GetMem(var p:pointer; n:word); DORFGLQKHDSQRFWHLDGUHV
SULPXOXLRFWHWHSXVvQS
function MaxAvail:longint; GOXQJLPHDFHOHLPDLOXQJL]RQH
contigue din heap
function MemAvail:longint; UHWXUQHD]PULPHD]RQHLOLEHUHGL
KHDSvQRFWHL
procedure Move(var x1,x2; nr:word); PXWQURFWHLvQFHSkQGGHODDGUHVD
OXL[vQR]RQFHvQFHSHODDGUHVD
lui x2
procedure new(var p); FUHD]RYDULDELOvQKHDSúLDWULEXLH
OXLSDGUHVDHLSHUHIHULQODDFHO
tip)
procedure Seg(x):word UHWXUQHD]DGUHVDGHVHJPHQWDOXL
x
function Ofs(X):word IXUQL]HD]SDUWHDGHRIIVHWGLQ
adresa de ceput a lui X
function Ptr(seg,ofs:word):pointer; FRQYHUWHúWHDGUHVDVHJRIVvQ
pointer
SURFHGXUH0DUNYDUSSRLQWHUúLSURFHGXUH VXQWIRORVLWHSHQWUXDORFDUHúL
Release(var p:pointer); dealocare de memorie din heap. Nu
VHIRORVHVFvPSUHXQFXQHZúL
dispose.
function SSeg:word; UHWXUQHD]DGUHVDGHVHJPHQWD
stivei.
function SPtr:word; IXUQL]HD]RIIVHWXOVWLYHL
Prelucrarea fisierelor
procedure Append(f:text); GHVFKLGHXQILúLHUWH[WSHQWUX
DGXJDUH
procedure Assign(var f; nume:string); DVRFLD]QXPHOHORJLFIFXQXPHOH
pe disc nume
procedure BlockRead(var f:File; var buffer; WUDQVIHUQUBEORFXULGLQILúLHUXOIvQ
nr_blocuri:word [var rezultat:word]); EXIIHUUH]XOWDWFRQLQHFkWVD
transferat efectiv
procedure BlockWrite(var f:file; var buffer; WUDQVIHUQUBEORFXULGLQEXIIHUvQ
nr_blocuri;[; var rezultat:word]); ILúLHUXOIUH]XOWDWGQUGHEORFXUL
efectiv scrise
77
UTCB
procedure Close( var f); vQFKLGHILúLHUXOI

function Eof(var f):boolean; HVWH758(GDFVDDMXQVOD
VIkUúLWXOILúLHUXOXLI
procedure Erase(var f); úWHUJHILúLHUXOIGHSHGLVF
function Eoln(var f:text):boolean HVWH758(GDFHVIkUúLWGHOLQLH

function FilePos(var f):longint; GHWHUPLQQXPUXOGHRUGLQHDO
articolului sau blocului curent
function FileSize(var f):longint; GHWHUPLQOXQJLPHDILúLHUXOXLvQ
RFWHL
procedure Flush(var f) GHWHUPLQJROLUHDEXIIHUXOXLSHGLVF
function IOResult:word; LDRYDORDUH!GDFDSDUHR
HURDUHODRSHUDLLOHFXILúLHUH,2
procedure Read(f; v1,v2,...) FLWHúWHGLQILúLHUXOIYDULDELOHOH
v1,v2,..
procedure ReadLn(var f:text; v1,..); FLWHúWHYúLWUHFHODOLQLD
XUPWRDUH
procedure Rename(var f; nume_nou:string); GXQQRXQXPHSHGLVFILúLHUXOXL
logic f
procedure Reset(var f:file;[lungime_bloc:word]); GHVFKLGHILúLHUXOISHQWUXRSHUDLL
I/O, blocurile având lungimea
lungime_bloc
procedure Rewrite(var f:file;[lungime_bloc:word]); FUHD]ILúLHUXOI
procedure Seek(var f; nr:longint); bloc sau articol curent devine cel cu
QXPUXOQU
function SeekEof(var f:text):boolean HVWH758(GDFSkQODVIkUúLWXO
ILúLHUXOXLWH[WVXQWGRDUVHSDUDWRUL
VSDLX7DE
function SeekEoln(var f:text):boolean; HVWH758(GDFSkQODVIkUúLWXO
OLQLHLVXQWGRDUVHSDUDWRULVSDLX
Tab
procedure Truncate(var f); VHWUXQFKLD]ILúLHUXOGHODSR]LLD
FXUHQWDLQGLFDWRUXOXLGHILúLHU
procedure Write(var f; v1,...); VFULHvQILúLHUXOIYDORDUHDY
procedure Writeln(var f:text; v1,..); VFULHvQILúLHUXOWH[WIYDORDUHLOH
YFXWUHFHUHODRQRXOLQLH
Operatii cu Directoare
procedure ChDir(s:string); VFKLPEGLUHFWRUXOFXUHQWvQFHOGDW
de s
procedure GetDir(d:byte;var s:string); UHWXUQHD]vQVGLUHFWRUXOFXUHQWSH
discul d
procedure MkDir(s:string); FUHD]XQGLUHFWRUGHILQLWGHV
procedure RmDir(s:string); úWHUJHVXEGLUHFWRUXOVGDFHJRO
Diverse
procedure Exit; FDX]HD]LHúLUHDGLQEORFXOFXUHQW
78
UTCB
procedure RunError(n:word); VHRSUHúWHH[HFXLDSURJUDPXOXLúL

VHIXUQL]HD]FRGXOGHHURDUHQ
procedure Halt; FDX]HD]WHUPLQDUHDLPHGLDWD
programului
function ParamCount:word; GQXPUXOSDUDPHWULORUGLQOLQLD
GHFRPDQG
function ParamStr(i:word):string; UHWXUQHD]SDUDPHWUXOQXPUXOLGLQ
OLQLDGHFRPDQG
procedure Randomize LQLLDOL]HD]JHQHUDWRUXOGHQXPHUH
aleatoare
function Random(n:word):real sau word; JHQHUHD]XQQXPUDOHDWRUvQ
domeniul [0,n]:word sau [0,1]:real;
function SizeOf(x):word; UHWXUQHD]OXQJLPHDvQRFWHLDOXL
[YDULDELOVDXWLS
&RQVWDQWHúLYDULDELOHDOHXQLWXOXL6\VWHP
1. ExitProc:pointer=nilFRQLQHDGUHVDXQHLSURFHGXULFHVHH[HFXW
înainte de terminarea programului.
2. ErrorAddr:pointer=nilFRQLQHDGUHVDXQGHVDSURGXVHURDUHDGDF
s-a produs); altfel este nil.
3. ExitCode:word=0FRQLQHFRGXOGHHURDUHvQFD]GHHURDUHGHH[HFX LH
altfel este 0.
([LVWúLDOWHGHFODUDLLGHFRQVWDQWHúLYDULDELOHFDUHSRWILJ VLWHvQ+HOS
ul mediului Turbo Pascal.
14.5. Unele directive de compilare
{$F+} {$F-} FX)VHIDFDSHOXUL)DUFWUHSURFHGXULVHIRORVHúWHFXWLSXULGHGDWH

procedure sau function; implicit F-
{$R+} {$R-} FX5VHYHULILFGDFLQGHFúLLWDEORXULORUVXQWvQGRPHQLXOVSHFLILFDWvQ
GHILQLLDORULPSOLFLW5
{$I+} {$I-} FX,VHJHQHUHD]FRGGHRSULUHDSURJUDPXOXLGDFDSDUHRHURDUH,2DOWIHO
VHDúWHDSWFRQVXOWDUHDFRGXOXLGHHURDUHFX,25HVXOWLPSOLFLW,
{$S+} {$S-} FX6VHYHULILFSHUPDQHQWGDFHPHPRULHvQVWLYLPSOLFLW6
{$V+} {$V-} FX9VHIDFHRYHULILFDUHVWULFWFDSDUDPHWULLDFWXDOL6WULQJVDLEDFHODúL
tip cu cei formali; implicit V+
{$M,s,mi,ma} VHIRUHD]VWLYDODVRFWHLLDUKHDSDUHPLQLPXOQHFHVDUPLúLPD[LPXOPD
{$L nume} LQFOXGHXQILúLHURELHFWFRPSLODWvQORFXOUHVSHFWLY
{$I nume} LQFOXGHODFRPSLODUHILúLHUXOSDVFDOQXPHvQORFXOUHVSHFWLY
{$X+} {$X-} FX;VHDGPLWHVLQWD[DH[WLQVIXQFLLOHSRWILXWLOL]DWHFDSURFHGXUL
79
UTCB
([HUFLLL
6VHVFULHXQSURJUDPFDUHFLWHúWHXQúLUGHODWDVWDWXULDUGDFúLUXOHVWHIRUPDWGLQ
FDUDFWHUHOH

úL

vOFRQVLGHUQXPUvQED]DúLDILúHD]YDORDUHDUHVSHFWLYvQED]D
)LH PXOLPHD 0 ^DEFGHI` 6 VH IDF XQ SURJUDP GH DILúDUH D WXWXURU
VXEPXOLPLORUOXL0
6H JHQHUHD] FX DMXWRUXO IXQFLHL UDQGRP XQ YHFWRU FX FRPSRQHQWH UHDOH
YHFWRUFHVHVWRFKHD]vQWUXQILúLHU6VHIRORVHDVFGDWHOHGLQILúLHUSHQWUXDGHWHUPLQD
D&HOPDLPDUHQXPUGLQWUHFRPSRQHQWHOHYHFWRUXOXL
E3ULPHOHQXPHUHFDPULPH
F6VHFDOFXOH]HVXPDV = ∑ D D − . L L
=
L
6HGDXQP6VHGHVFRPSXQWRDWHQXPHUHOHSDUHvQWUHQúLPFDVXPGHGRX
numere prime.
6VHSURJUDPH]HDOJRULWPLLSURSXúLODSDJ
15. Unitul CRT
,QXQLWXO&57VHGHILQHVFFRQVWDQWHYDULDELOHSURFHGXULúLIXQF LLSHQWUX
lucrul cu ecranul în regim text. Culorile sunt definite prin: Black=0; Blue=1;
Green=2; Cyan=3; Red=4; Magenta=5; Brown=6; LightGray=7; DarkGray=8;
LightBlue=9; LightGreen=10; LightCyan=11; LightRed=12; LightMagenta=13;
Yellow=14; White=15.
9DULDELOHIXQFLLúLSURFHGXULDOHXQLWXOXL
windmin:word; FRQLQHFRRUGRQDWHOHFROXOXLVWkQJDVXVDOIHUHVWUHLFXUHQWH
(octetul superior pe x, cel inferior pe y)
windmax:word; FRQLQHFRRUGRQDWHOHFROXOXLGUHDSWDMRVDOHIHUHVWUHLFXUHQWH
textattr:byte; FRQLQHLQIRUPDLLOHGHVFULHUHELLLFXORDUHDWH[WXOXLELLL
4-6 culoarea fondului, bitul 7 =1 clipitor altfel normal
lastmode:word; directvideo:boolean; checksnow:boolean; checkeof:boolean;
checkbreak:boolean sunt alte variabile ale unitului.
)XQFLDVDXSURFHGXUD ([SOLFDLLH[HPSOH
)XQFLLúLSURFHGXULSHQWUXOXFUXOFXIHUHVWUH
procedure window(x1,y1,x2,y2:byte); FUHHD]RIHUHDVWUFXFROXULOH[\VWkQJD
sus, (x2,y2)-dreapta jos;
procedure gotoxy(x,y:byte) SR]LLRQHD]FXUVRUXOvQSR]LLD[\vQ
IHUHDVWUDFXUHQW
80
UTCB
function wherex:byte; GHWHUPLQSR]LLD[DFXUVRUXOXL

function wherey:byte GHWHUPLQSR]LD\DFXUVRUXOXL
procedure textbackground(culoare:byte); VHWHD]FXORDUHDIRQGXOXLvQIHUHDVWUDDFWLY
procedure clrscr; úWHUJHIHUHDVWUDDFWLYFXFXORDUHDIRQGXOXL
Procedure textcolor(culoare:byte); VHWHD]FXORDUHDFXUHQWSHQWUXWH[W
procedure insline; LQVHUHD]ROLQLHLQORFXOFXUVRUXOXL
procedure delline; úWHUJHOLQLDSHFDUHHFXUVRUXO
procedure clreol; úWHUJHOLQLDFXUHQWGHODFXUVRUSkQODFDSW
)XQFLLúLSURFHGXULSHQWUXVXQHWWDVWDWXUHWF
procedure sound(hz:word); JHQHUHD]XQVXQHWFXIUHFYHQDK]
procedure nosound; RSUHúWHJHQHUDWRUXOGHVXQHWH
procedure delay(timp:word); produce o întârziere de timp milisecunde;
function readkey:Char; UHWXUQHD]FRGXOWDVWHLDSVDWHIUDODILúD
pe ecran
function keypressed:boolean UHWXUQHD]758(GDFVDDSVDWRWDVW
assigncrt( var f:text); VHVFULHSHHFUDQFDvQWUXQILúLHUWH[W
3URJUDPXO XUPWRU FUHD] R IHUHDVWU SHQWUX LQWURGXFHUHD GH QXPHUH úL QX

SHUPLWHLHúLUHDGLQHDSkQQXHHGLWDWFRUHFWQXPUXO
program uz_crt;
uses crt;
var a:real; st:string;
procedure c_n(x,y,l:byte;var a:real;var st:string);
const m=['1'..'9','0','.','e','E','-',#13,#8];
var code,ls:integer;
af:char;
attrib,o1,v1,o2,v2:byte;
xv,yv:byte;
begin
o1:=lo(windmin);v1:=hi(windmin);o2:=lo(windmax);v2:=hi(windmax);
attrib:=textattr; xv:=wherex; yv:=wherey;
window(x+o1,y+v1,x+o1+l,y+v1); textbackground(red);
textcolor(white); clrscr;
st:='';ls:=0;
repeat
repeat
repeat af:=readkey until af in m;
case af of
#8 :if(length(st)>0)then begin delete(st,length(st),1);
clrscr;write(st);
end;
81
UTCB
'1'..'9','0','+', '-', '.' ,'e', 'E' : begin st:=st+af; st:=copy(st,1,l);

clrscr;write(st);
end;
end;
until af=#13;
val(st,a,code);
until code=0;
window(o1+1,v1+1,o2+1,v2+1);textattr:=attrib;gotoxy(xv+l,yv);
end;
begin
ZULWH
LQWURGXFHLQXPUXOD
FBQZKHUH[ZKHUH\DVW
end.
([HUFLLL
1. Fie a[i,j]:=random; 1<=i,j<=10. Se împarte intervalul [0,1] în 10 subintervale egale
úLVHWLSUHúWHPDWULFHDDSULQFXORULvQSR]LLDLMVHYDSXQHFXORDUHDNGDFD>LM@FDGHvQ
subintervalul k.
6 VH IDF XQ WDEHO SH HFUDQ FX GRX FRORDQH SULPD FRORDQ FRQLQH FD WH[W
[[[LDUSHDGRXDFRORDQVHFLWHVFYDORULOHYDULDELOHORUUHVSHFWLYHvQFkWHRIHUHDVWU
GH DOW FXORDUH FX OLPHD GH FDUDFWHUH úL vQOLPHD GH XQ FDUDFWHU /D ILHFDUH QXPU
QHJDWLYVHJHQHUHD]XQVXQHW
16. Unit-ul GRAPH
Unit-ul GRAPH DOYHUVLXQLL7XUER3DVFDOLPSOHPHQWHD]DRELEOLRWHF

din peste 50 de rutine grafice. Orice program are acces la aceste subprograme
grafice prin invocarea unit-ului GRAPH SULQWURLQVWUXFLXQH86(6
Pentru compilarea programelor care utilizeaza rutinele unit-ului GRAPH
FRPSLODWRUXO 7XUER 3DVFDO WUHEXLH VD DLE DFFHV OD XUPWRDUHOH ILúLHUH XQLWXO
TURBO.TPL (biblioteca standard), unit-ul GRAPH.TPU, driverul grafic (cu
H[WHQVLD%*,úLHYHQWXDOILúLHUHFXVHWXULGHFDUDFWHUHFXH[WHQVLD&+5
16.1. Ecranul grafic
(FUDQXO JUDILF VH SUH]LQW FD R ]RQ GUHSWXQJKLXODU FDUDFWHUL]DW SULQ

dimensiuni bine stabilite pentru fiecare tip de ecran. Sistemul de coordonate
XWLOL]DWSHQWUXSUHFL]DUHDSR]LLHLFXUVRUXOXLJUDILFDUHRULJLQHDLQFROWXOVWkQJD
82
UTCB
sus al ecranului grafic, asa cum se poate vedea în figura de mai jos, iar
coordonatele utilizate se numesc coordonate ecran.
Valoarea coordonatei
(0,0) (GetMaxX,0)
ecran x (pe directia
orizontala) creste spre
drapta, iar valoarea
coordonatei ecran y (pe
(x,y)
directia verticala) creste in
jos. Valorile maxime ale
(0,GetMaxY) (GetMaxX,GetMaxY) coordonatelor x si y
corespunzatoare punctelor de
SHHFUDQXOJUDILFSRWILREWLQXWHFXDMXWRUXOIXQFLLORU*HW0D[;úL*HW0D[<
'HFODUDLLDOHXQLWXOXL*UDSK
Pentru determinarea tipului de linie se pot folosi constantele:

Const SolidLn=0; { linie continua}
DottedLn=1; {-----------------}
CenterLn=2; {_._._._._._._.}
DashedLn=3; {- - - - - - - - - }
UserBitLn=4; {stil definit de utilizator}
Const NormWidth=1; {grosime normala }
ThickWidth=3 {linie groasa}
3HQWUX GHILQLUHD PRGHOXOXL GH KDúXUDUH VH SRW XWLOL]D XUPWRDUHOH
constante predefinite:
Const
EmptyFill=0; SolidFill=1; LineFill=2;
LtSlashFill=3; SlashFill=4; BkSlashFill=5;
LtBkSlashFill=6; HatchFill=7; XHatchFill=8;
InterLeaverFill=9; WideDotFill=10; CloseDotFill=11;
UserFill=12;
,QLLDOL]DUHDPRGXOXLJUDILF
Pentru initializarea modului grafic si testarea erorilor interne ale unit-ului

Graph se poate folosi urmatoarea secventa:
Var gd,gm,cod:integer;
Begin
gd:=detect;
InitGraph(gd,gm,'');
83
UTCB
cod:=GraphResult;
if cod<>grok then
begin
writeln('eroare grafica: ',GraphErrorMsg(cod));
halt(1);
end;
3URFHGXULúLIXQFLLDOHXQLWXOXL*UDSK
6XESURJUDPHRULHQWDWHVSUHSXQFWHúLOLQLL
Procedure PutPixel(x,y:integer, produce un punct, unde x si y definesc
cul:word);- coordonatele punctului, iar cul defineste
culoarea punctului;
Function GetPixel(x,y):word; determina culoarea unui punct de coordonate
date
Procedure Line(x1,y1,x2,y2:integer); deseneaza o linie intre punctele (x1,y1) si
(x2,y2);
Procedure LineTo(x,y:integer);- GHVHQHD]DROLQLHGHODSR]LWLDFXUVRUXOXLSkQ
la punctul dat de coordonatele (x,y);
Procedure LineRel(dx,dy:integer);- GHVHQHD]DROLQLHGHODSR]LLDFXUVRUXOXLSkQ
ODXQSXQFWFHDUHFRRUGRQDWHOHPULWHFXG[
respectiv dy;
Procedure MoveTo(x,y:integer);- PXWFXUVRUXOLQSXQFWXO[\
Procedure MoveRel(dx,dy:integer);- PXWFXUVRUXOLQWUXQSXQFWFHDUH
coordonatele incrementate cu dx, respectiv
dy;
procedure SetWriteMode(mod:integer); VWDELOHúWHFXPVHWUDVHD]OLQLLOHDWXQFLFkQG
ajung peste alte desene:
LPRG &RS\3XWVHWUDVHD]SHVWHGHVHQ
LLPRG ;RU3XWVHIDFHRSHUDLDORJLF;RU
FXGHVHQXOGHGRXRUL;RU !UHDSDUHGHVHQXO
Procedure SetColor(culoare:word); GHILQHúWHFXORDUHDDFWLYFXFDUHVHYRU
desena linii; 0<=culoare<=15.
Procedure SetRGBPalette(nr:word; r,v, VHUHGHILQHúWHFXORDUHD QU GLQSDOHW
a:integer); SULQRQRXSURSRULHGHURúXYHUGHúL
DOEDVWUX UYD vQGHFODUDLDGH
FRQVWDQWHDOHXQLWXOXLVHJVHVFFXORULOH
implicite.
Procedure IL[HD]DVWLOXOXQHLOLQLLVWLOXOúLJURVLPHDVH
SetLineStyle(stil,model,grosime:word); iau din constantele unitului; model=0, cu
H[FHSLDFD]XOXLFkQGVWLO XVHUELWOQFkQG
PRGHOHVWHXQvQWUHJSHRFWHL
6XESURJUDPHRULHQWDWHVSUHDUFHFHUFXULúLDOWHFXUEH
84
UTCB
Procedure Arc(x,y:integer;Ustart, [úL\VXQWFRRUGRQDWHOHFHQWUXOXLFHUFXOXLU

Ufinal,r:word); HVWHUD]DFHUFXOXLLDU8VWDUW8ILQDOUHSUH]LQW
XQJKLXOGHLQFHSXWUHVSHFWLYGHVIkUúLWDO
arcului (în grade hexazecimale)
Procedure Circle(x,y:integer; r: word); GHVHQHD]XQFHUFGHFHQWUX[\úLUD]DU
Procedure Ellipse(x,y:integer; Ustart, GHVHQHD]DXQDUFGHHOLSVFXFHQWUXO[\
Ufinal:word; Xraza, Yraza:word);- VHPLD[HOH;UD]DúL<UD]DFDUHvQFHSHOX
XQJKLXO8VWDUWúLVHWHUPLQOD8ILQDOJUDGH
Procedure Rectangle(x1,y1,x2,y2:integer); GHVHQHD]XQGUHSWXQJKL
Procedure DrawPoly(nrpct:word; var GHVHQHD]ROLQLHSROLJRQDO
puncte) Exemplu:
Type PointType=record
x,y:integer;
end;
Const
Triunghi:array[1..4]of
PointType((x:50,y:100),(x:100,y:100),(x:150,y:150),
(x:50,y:100));
..........................................................
DrowPoly(4,Triunghi);
Proceduri orientate spre figuri pline

Procedure SetFillStyle(m:word;c:word); IL[HD]DPRGHOXOúLFXORDUHDGHKDúXUDUH
PRGHOXOHVWHJVLWSULQWUHFRQVWDQWHOH
XQLWXOXLLDUFXORDUHDHVWHvQWUHúLGDF
se alege modelul userfill atunci se umple
figura cu modelul dat de setfillpattern
Procedure PRGHOXOHGDWGHXQYHFWRUGHRFWHLFDUHVH
6HW)LOO3DWWHUQRFWHL)LOO3DWWHUQ7\SH SRDWHGHILQLvQVHFLXQHDFRQVWLDUFXORDUHD
culoare:word); HVWHvQWUHúL
/DGHVHQDUHDILJXULORUKDúXUDWHXUPWRDUHFRQWXUXOHVWHGHVHQDWFXFDUDFWHULVWLFLOHVHWDWHFX
VHWOLQHVW\OHLDUKDúXUDUHDVHIDFHFXFDUDFWHULVWLFLOHVHWDWHFXVHWILOOVW\OH
Procedure GHVHQHD]úLKDúXUHD]RHOLSV
FillEllipse(x,y:integer;Xraza,Yraza:word);
-
Procedure GHVHQHD]DúLKDúXUHD]DXQVHFWRUGHFHUFFX
PieSlice(x,y:integer,Ustart,Ufinal,r:word);- FHQWUXO[\úLFXSULQVvQWUHXQJKLXULOH8VWDUW
úL8ILQDO
Procedure Sector(x,y:integer; Ustart, GHVHQHD]úLKDúXUHD]DXQVHFWRUGHHOLSV
Ufinal, Xraza, Yraza:word);- SDUDPHWULLDXDFHHDúLVHPQLILFDLHFDOD
Ellipse
Procedure Bar(x1,y1,x2,y2:integer); GHVHQHD]DXQGUHSWXQJKLúLOKDúXUHD]D
Procedure Bar3D(x1,y1,x2,y2:integer; GHVHQHD]XQSDUDOHOLSLSHG[\[\
ad:word; top:boolean); VXQWFRRUGRQDWHOHFROXULORUGUHSWXQJKLXOXL
GLQIDGDFWRS 758(VHGHVHQHD]úL
plafonul, altfel nu;
Procedure FillPoly(nrpct:word;var GHVHQHD]DúLKDúXUHD]DXQSROLJRQ
puncte);
85
UTCB
Procedure FloodFill(x,y:integer; KDúXUHD]FXPRGHOXODFWXDOR]RQFH

cul:word); FRQLQH[\úLHPUJLQLWGHSXQFWHFX
culoarea cul;
Deplasare de imagini
function UHWXUQHD]PULPHDvQRFWHLD]RQHLHFUDQ
ImageSize(x1,y1,x2,y2:word):word; dreptunghiulare cu coordonatele
(x1,y1):stânga sus, (x2,y2):dreapta jos.
Procedure Getimage(x1,y1,x2,y2:integer; VHWUDQVIHULPDJLQHDJUDILFGLQGUHSWXQJKLXO
YDUYDULDELO FXFROXULOH[\[\vQPHPRULHGHOD
adresa lui variabil în sus
Procedure PutImage(x,y:integer; var VHWUDQVIHULPDJLQHDGHODDGUHVDOXL
YDULDELODRSHUDLHZRUG YDULDELODSHHFUDQvQFHSkQGGLQFROXOGH
VXVVWkQJD[\RSHUDLHSRDWHIL&RS\3XW
;RU3XW2U3XW$QG3XW1RW3XWúLGHVFULH
modul de transfer al imaginii
Definiri de ferestre si pagini
Procedure (x1,y1) sunt coordonatele din stânga sus ale
SetViewPort(x1,y1,x2,y2:integer; ferestrei curente, iar (x2,y2) sunt
Clip:boolean); coordonatele din dreapta jos; noile
FRRUGRQDWHVHYRUUDSRUWDIDDGHFROXOVWkQJD
sus al ferestrei curente; Clip=true =>ce
XUPHD]DVHGHVHQDúLFDGHvQDIDUDIHUHVWUHL
curente se taie; Clip=false=>invers (se
GHVHQHD]WRWXO
Procedure ClearViewPort; VWHUJHIHUHDVWUDJUDILFDFWXDO
Procedure ClearDevice; VWHUJHHFUDQXOJUDILFDFWXDOVLSR]LWLRQHD]
pointerul actual in pozitia (0,0).
Procedure SetVisualPage(nrpag:word); vQJHQHUDOH[LVWPDLPXOWHSDJLQLJUDILFH
GLQFDUHXQDHYL]XDODGLFDSDUHSHHFUDQ
úLXQDDFWLYDGLFSURFHGXULOHJUDILFHIDF
PRGLILFULvQDFHDSDJLQ
Procedure SetActivPage(nrpag:word); IL[HD]DSDJLQDDFWLYSHQWUXHFKLSDPHQWXO

JUDILFGHLHVLUHGDFHDHWUDQVIRUPDWvQ
SDJLQYL]XDODWXQFLLPDJLQHDGLQHDDSDUH
brusc pe ecran
$ILúDUHDWH[WXOXL
Procedure OuttextXY(x,y:integer; VHDILúHD]WH[WXOWH[WUHODWLYODSXQFWXO
text:String); (x,y);
SetTextJustify(o,v:word); o poate fi lefttext, centertext sau righttext, iar
v poate fi bottomtext, centertext sau toptext;
în procedura outtextxy, punctul (x,y) de pe
HFUDQYDFGHDvQXQWUXO]RQHLWH[WvQSR]LLD
(o,v)
Procedure SetTextStyle(font:word; VHVWDELOHúWHIRQWXOGLUHFLDGH
GLUHFLDZRUGPDULPH&KDUZRUG VFULHUH+RUL]'LU9HU'LUúLPULPHD
caracterelor 1, 2, 3,..
86
UTCB
function TextHeight(t:string); GHWHUPLQvQOLPHD]RQHLGHWH[WSHQWUXúLUXO

t
Function TextWidth(t:string); GHWHUPLQOLPHD]RQHLWH[WSHQWUXúLUXOV
Diverse
function GetMaxX:integer UHWXUQHD][PD[LPvQPRGXOJUDILFFXUHQW
function GetMaxY:integer; UHWXUQHD]\PD[LPvQPRGXOJUDILFFXUHQW
Exemplu de desenare a unor figuri pe ecran:
uses graph,crt;
var coderoare,gd,gm,i:integer;
sir:string;
procedure startgraph;
begin
gd:=detect;
initgraph(gd,gm,'c:\bp\bgi');
coderoare:=graphresult;
if coderoare<>grOk
then begin writeln (grapherrormsg(coderoare)); halt(1);
end;
end;
BEGIN
startgraph;
rectangle(20,40,100,80);
outtextxy(10,10,'rectangle(20,40,60,80)');readln;
cleardevice;
bar(20,40,100,80); outtextxy(10,10,'bar(20,40,100,60)');readln;
cleardevice;
for i:=10 to 40 do line(0,8*i,getmaxx,8*i);
outtextxy(10,10,'for i:=10 to 40 do line(0,8*i,getmaxx,8*i)');readln;
cleardevice;
circle(getmaxx div 2, getmaxy div 2,100);

outtextxy(10,10,' circle(getmaxx div 2, getmaxy div 2,100)');readln;
cleardevice;
ellipse(getmaxx div 2,getmaxy div 2, 0,270,200, 50);

outtextxy(10,10,'ellipse(getmaxx div 2,getmaxy div 2, 0,270,200, 50)');
readln;
cleardevice;
87
UTCB
for i:=0 to 14 do
begin
setfillstyle(i,white);
fillellipse(getmaxx div 2,getmaxy div 2,200-10*i,150-8*i);
end;
outtextxy(10,10,'for i:=0 to 14 do');
outtextxy(10,20,'begin setfillstyle(i,white);');
outtextxy(10,30,
' fillellipse(getmaxx div 2,getmaxy div 2,200-10*i,150-8*i)');
outtextxy(10,40,'end;');
readln;
cleardevice;
outtextxy(10,10,
'putpixel(random(getmaxx),20+random(getmaxy-20), random(15))');
repeat
putpixel(random(getmaxx),20+random(getmaxy-20), random(15));
until keypressed;
cleardevice;
settextstyle(gothicfont,horizdir,4);
sir:='Studiati Unitul Graph';
outtextxy(getmaxx div 2-textwidth(sir) div 2,getmaxy div 2, sir);
readln;
readln;
closegraph;
END.
2EVHUYDLH 3H PVXU FH R ILJXU HVWH DILúDW SH HFUDQ DSDUH
LQVWUXFLXQHDFDUHJHQHUHD]UHVSHFWLYDILJXU
5HSUH]HQWDUHDJUDILFDIXQFLLORU
Fie f:[xm in ,x m ax ] → [ y m in ,y m ax ] 3HQWUXDUHSUH]HQWDJUDILFIXQFLDSH

ecran grafic nu se pot utiliza direct coordonatele utilizator (xm ,y m ), acestea
trebuind transformate in coordonate ecran, LP MP , pentru a se putea încadra în
GRPHQLLOHUHVSHFWLYHGHYDORULúLDSXWHDILXWLOL]DWHvQLQVWUXFLXQLOHJUDILFH
Procesul de transformare a coordonatelor utilizator în coordonate ecran se
QXPHúWHscalare.
88
UTCB
j
max
y
max j
min
y
min
x x x i i
min max min max
3HQWUXFDvQXUPDSURFHVXOXLGHVFDODUHUHSUH]HQWDUHDJUDILFSHGLVSOD\
VUPkQDSURSRUWLRQDOWUHEXLHFDvQWUHFRRUGRQDWHOHHFUDQúLFRRUGRQDWHOH
XWLOL]DWRUVH[LVWHRUHODLHOLQLDU
L = $[ ⋅ [ + %[
M = $\ ⋅ \ + %\
&RHILFLHQLLGHVFDODUH A x si B x VHGHWHUPLQGLQFRQGLLLOH
LPLQ = $[ ⋅ [ PLQ + %[
LPD[ = $[ ⋅ [ PD[ + %[
de unde
$[ = ( LPD[ − LPLQ ) ( [PD[ − [PLQ ) , %[ = LPLQ − $ ⋅ [ PLQ
Analog, coeficientii de scalare A y úL B y VXQWGDLGHUHODLLOH
$\ = M PD[ − MPLQ \ PD[ − \ PLQ , %\ = MPLQ − $\ ⋅ \PLQ
Exemplu de trasare de grafic:
Program grafic;
uses graph;
var mx,my,x,y,i,gd,gm:integer;
Function f(x:real):real;
begin
f:=sin(x);
end;
Begin
gd;detect;
Initgraph(gd,gm,’’);
If graphresult<>grok then halt(1);
mx:=getmaxx;
my=getmaxy;
{trasam axele de coordonate}
89
UTCB
Line(20,20,20,my);
Line(1,my div 2,mx-20,my div 2);
moveto(mx-20,my div 2);linerel(-10,-10);
moveto(mx-20,my div 2);linerel(-10,10);
moveto(20,20);linerel(-10,10);
moveto(20,20);linerel(10,10);
moveto(20,my div 2);
{se pun punctele pe grafic};
for i:=1 to 600 do
Lineto(20+i,my div 2-round(f(i/40)*60);
readln;
closegraph;
End.
2EVHUYDLH,QDFHVWSURJUDPPDLvQWkLVHLQLLDOL]HD]PRGXOJUDILFDSRL
VHWUDVHD]D[HOHGHFRRUGRQDWHGXSFDUHVHWUDVHD]JUDILFXOIXQFLHLIRORVLQG
LQVWUXFLXQHD
for i:=1 to 600 do
Lineto(20+i,my div 2-round(f(i/40)*60);
FDUH XQHúWH SULQWUR OLQLH FkWH GRL SL[HOL FRQVHFXWLYL V REVHUYP F
UHSUH]HQWDUHD JUDILF D IXQFLHL VH IDFH SH GH SL[HOL 9DORDUHD IXQFWLHL VH
URWXQMHVWHIRORVLQGIXQFLD³URXQG´GHRDUHFHFRRUGRQDWHOHXQXLSL[HOWUHEXLHV
fie intregi. Argumentul functiei se împarte la 40 pentru a stabili pe x ,iar
YDORDUHD IXQFWLHL VH vQPXOHVWH FX SHQWUX D VWDELOL DPSOLWXGLQHD JUDILFXOXL
IXQFLHL$FHVWHYDORULVHRELQFRQIRUPFDOFXOHORUIFXWHPDLVXV
([HUFLLL
6VHIDFXQSURJUDPFDUHVGHVHQH]HXQWULXQJKLFHUFXOFLUFXPVFULVVLPHGLDQHOH
6VHSDYH]HVXSUDIDDHFUDQXOXLFX× SWUDWHFRORUDWHDOEúLQHJUXFDRWDEO
GHúDK
,Q VLVWHPXO GH FRRUGRQDWH [2\ ILH $ SH 2[ úL % SH 2\ DVWIHO FD OXQJLPHD
VHJPHQWXOXL$%VUPkQFRQVWDQW6VHUHSUH]LQWHJUDILFORFXOJHRPHWULFDOSXQFWHORU&GH
pe segmentul AB astfel ca AC/CB=1/3.
6 IDF XQ SURJUDP FDUH V WUDVH]H vQ UHJLP JUDILF XQ WDEHO FX FRORDQHOH QXPH
QRWDQRWDQRWDPHGLD6VHFRPSOHWH]HOLQLLDOHWDEHOXOXLFXGDWHFRUHVSXQ]WRDUHGDWH
FDUHVHFLWHVFGLQWUXQILúLHUWH[W
90
UTCB
6VHVFULHXQSURJUDPFDUHVGHVHQH]HSHHFUDQRUHHDKLGUDXOLF&RQGXFWHOHVH
UHSUH]LQW SULQ VHJPHQWH LDU QRGXULOH SULQ FHUFXUL SOLQH 'DWHOH VH FLWHVF GLQWUXQ ILúLHU WH[W
FDUHFRQLQHQXPUXOGHQRGXULQXPUXOGHFRQH[LXQLvQWUHQRGXULFRRUGRQDWHOHQRGXULORU
SHUHFKLOHGHQRGXULSHQWUXILHFDUHFRQH[LXQH6HSUHVXSXQHFQRGXULOHVHQXPHURWHD]FX
vQRUGLQHDvQFDUHVXQWSXVHvQILúLHU
6VHUHDOL]H]HFDWHXQSURJUDPFDUHUHSUH]LQWDJUDILFXUPWRDUHOHIXQFWLL
[ +
I [ = [ ∈ >−@ J [ = − − [ [ ∈ >−
@
+ VLQ [
6VHUHSUH]LQWHJUDILFvQDFHODúLVLVWHPGHD[HI[D VLQD [[ [D DSHQWUX

D úL[vQLQWHUYDOXO>@
,QSURJUDPXOGHUHSUH]HQWDUHJUDILFDXQHLIXQFLLGLQSDJLQDDQWHULRDUVVHVFULH
SHD[HOHYDORULOHSHQWUX[úL\SHD[H
D 3URFHGXUD XUPWRDUH UHDOL]HD] SHQWUX XQHOH SULQWHUH FRSLHUHD HFUDQXOXL OD

LPSULPDQW 'DF IRDLD QX DUH GH UkQGXUL FRSLDL R SDUWH GLQ HFUDQ OXkQG for i:=10 to
getmaxx div 8vQOLQLDVHSLHUGHRSDUWHGLQVWkQJDHFUDQXOXL&XSODLDFHDVWSURFHGXUFX
SURJUDPXOGHWUDVDWJUDILFHSHQWUXDRELQHJUDILFHOHSHKkUWLH
procedure CopieEcran;
var n1, n2, i, ii, j, k, cod, doi: integer;
begin
write(lst, chr(27), '1');
n2 :=( getmaxy+1) div 256;
n1 := (getmaxy+1) mod 256;
for i := 0 to getmaxx div 8 do
begin
ii := i * 8;
write (lst, chr(27), 'K', chr(n1), chr(n2));
for j := getmaxy downto 0 do
begin
cod := 0;
doi := 1;
for k := 7 downto 0 do
begin
if GetPixel (ii + k, j) <> Black then
cod := cod + doi;
doi:=doi*2;
end;
write (lst, chr(cod))
end;
writeln (lst)
end;
write(lst, chr(27), '@')
end; { CopieEcran }
E0RGLILFDLSURFHGXUDFDVFRSLH]HSHLPSULPDQWXQGUHSWXQJKLGHSHHFUDQ
91
UTCB
17. Unitul DOS
Unitul DOS este un unit standard unde sunt implementate un

QXPUGHVXESURJUDPHSURFHGXULúLIXQFLLD[DWHSHVLVWHPXOGHRSHUDUHúLSH
WUDWDUHDILúLHUHORU3HQWUXPDLPXOWHLQIRUPDLLWUHEXLHFRQVXOWDWXQPDQXDOPDL
complet de Turbo Pascal.
8QHOHGLQGHFODUDLLOHXQLWXOXL'26
type SearchRec= const

record Readonly=$01; {fisier
Fill:array[1..21] of byte; utilizabil numai la citire }
Attrib:byte; Hidden=$02; {fisier ascuns}
Time:longint; SysFile=$04; {fisier sistem}
Size:longint; VolumeID=$08; {identificator
Name:string[12]; de volum}
end; Directory=$10; {director}
Archive=$20; {fisier arhivat}
DateTime= AnyFile=$3f;
record type
year:word; PathString=String[79];
month:word; DirString=String[67];
day:word; NameString=String[8];
hour:word; ComString=String[127]
min:word; ExtString=String[4]
sec:word;
end; Registers=record
var DosError:Integer; case integer of
0:(AX,BX,CX,DX,BP,SI,DI,DS,ES,
Flags:word);
1:(AL,AH,BL,BH,CL,CH,DL,DH:byte)
end;
&kWHYDGLQSURFHGXULOHúLIXQFLLOHXnitului DOS
)XQFLDVDXSURFHGXUD ([SOLFDLL
*HVWLXQHDILúLHUHORUDWULEXWHOHORUXOWLPDDFWXDOL]DUHVSD LXOSHGLVF
procedure FindFirst(p:PathStr; FDXWvQWUXQGLUHFWRUVSHFLILFDWVDXvQGLUHFWRUXO
attrib:word;var f:SearchRec) FXUHQWSULPXOILúLHUFXQXPHGDWúLFXDWULEXWH
GDWHGDFH[LVWDWXQFL'RV(UURU úLvQIDSDU
LQIRUPDLLOHGHVSUHIDOWIHO'RV(UURU!
92
UTCB
procedure FindNext(var f:SearchRec) VHFDXWXUPWRDUHDDSDULLHDILúLHUXOXL

VSHFLILFDWHDWUHEXLHDSHODWGRDUGXS
FindFirst; GDFQXPDLJVHúWH
ILúLHUH !'RV(UURU
function FSearch(nume:PathString; FDXWILúLHUXOQXPHvQOLVWDGHGLUHFWRDUH'LU/LVW
DirList:String):PathString; GDFvOJVHúWHUHWXUQHD]QXPHOHFRPSOHW
procedure FSplit(cale:PathStr; var VFLQGHD] FDOH QXPHOH FRPSOHW DO ILúLHUXOXL vQ
Dir:DirStr; var nume:NameStr; var director+nume+extensie.
Ext:ExtStr);
function H[SDQGHD]QXPHOHILúLHUXOXLFXFDOHDSHFDUHD
FExpand(nume:PathStr):PathStr; fost creat.
procedure GetFAttr(var f; var GHWHUPLQDWULEXWHOHXQXLILúLHUVSHFLILFDWXQGHf
atrib:word) UHSUH]LQW ILúLHUXO LDU YDULDELOD attrib de tipul
:RUGYDFRQLQHPXOLPHDWXWXURUDWULEXWHORU
procedure SetFAttrib (var f; SR]LLRQHD] DWULEXWHOH XQXL ILúLHU XQGH f

atrib:word) UHSUH]LQW ILúLHUXO LDU YDULDELOD attrib FRQLQH
DFHOHDWULEXWHFDUHYRUILSR]LLRQDWH
procedure GetFTime(var f; var UHWXUQHD]GDWDúLRUDXOWLPHLVFULHULvQILúLHUvQ

t:longint); IRUPFRQGHQVDWvPSDFKHWDW
procedure UnpackTime(t:longint; var VHGHVSDFKHWHD]GDWDúLRUDvQYDULDELODW
t1:datetime);
procedure PackTime(t1:datetime; var VHvPSDFKHWHD]WGDWHWLPHvQWORQJLQW
t:longint);
procedure SetFTime( var f; t:longint); vQILúLHUXOORJLFIVHSR]LLRQHD]WLPSXOODW
(împachetat)
function DiskFree(drive:byte):longint; PULPHDvQRFWHLD]RQHLOLEHUHSHGLVFXOGULYH
XQGHGULYH !XQLWDWHDFXUHQWGULYH !$
HWFGDFUH]XOWDWXOH !OLSVGLVFHWF
function DiskSize(drive:byte):longint; PULPHDvQRFWHLDGLVFXOXLGLQXQXWDWHDGULYH
Gestiunea proceselor; întreruperi
procedure SwapVectors; FRPXWDGUHVHOHDQXPLWRUvQWUHUXSHULFXXQHOH
salvate
procedure Exec(prog:PathStr; ODQVHD]vQH[HFXLHSURJUDPXOprog, cu linia de
comanda:ComStr) FRPDQGcomandaGHRELFHLvQDLQWHúLGXS
([HFVHXWLOL]HD]6ZDS9HFWRUVGDFQXSRDWH
lansa prog=>DosError<>0. Exemplu:
SwapVectors;
Exec('exemplu.exe','');
SwapVectors;
if doserror<>0 then writeln('nu a mers');
function DosExitCode:word; UHWXUQHD]FRGXOGHLHúLUHGLQXQSURJUDPDSHODW
cu exec
procedure GetIntVec(nrInt:byte; var UHWXUQHD]DGUHVDUXWLQHLGHvQWUHUXSHUHQU,QWvQ
p:pointer;) p
93
UTCB
procedure SetIntVec(nrInt:byte; VWDELOHúWHUXWLQDGHvQWUHUXSHUHQU,QWODDGUHVDS

p:pointer)
procedure Intr(nrInt:byte); var DSHOHD]LQWUHUXSHUHDQU,QWWUDQVPLkQGXLGDWH
r:Registers) prin r:registers
procedure MsDos(var r:Registers) VHDSHOHD]vQWUHUXSHUHD
procedure Keep(exitcode:word) VHLHVHGLQWUXQSURJUDPFDUHUPkQHUH]LGHQW
în memorie; pentru a putea fi apelat el e de
obicei apelat de o întrerupere
3URJUDPXOXUPWRUDUDWFXPSXWHPXWLOL]DSURFHGXULOHGHJHVWLXQHD
ILúLHUHORU&RQVWDQWDQGLUWUHEXLHPRGLILFDW ODYDORDUHDGLUHFWRUXOXLXQGHYUHP
VOXFUP
program ex_dos; if(vcaut.attr and sysfile)=sysfile then
uses crt,dos; write(' sistem')
const ndir='A:\'; else write(' nonsistem');if(vcaut.attr
var and directory)=directory then write('
vdata:DateTime; director');
vcaut:searchrec; readln;
t:boolean; if (length(vcaut.name)>2) then
x1,y1,x2,y2:integer; begin assign(f,ndir+vcaut.name);
f:file; setfattr(f,$FD and vcaut.attr);
end;
Procedure lucru(var vcaut:searchrec); writeln('_________________';
Begin; writeln;
UnpackTime(vcaut.time, vdata); End;
Procedure StareFisiere;
writeln(vcaut.name,' Begin
lung=',vcaut.size,' an=', vdata.year, findfirst(ndir+'*.*',anyfile,vcaut);
' luna=',vdata.month,' if doserror=0 then lucru(vcaut);
zi=',vdata.day,' ora=',vdata.hour, repeat
' min=',vdata.min,' sec=',vdata.sec); findnext(vcaut);
if(vcaut.attr and readonly)=readonly if doserror=0 then lucru(vcaut);
then write(' citire') until doserror<>0;
else write(' citire/scriere'); End;
if(vcaut.attr and hidden)=hidden then
write(' ascuns') BEGIN
else write(' vizibil'); clrscr;
if(vcaut.attr and archive)=archive StareFisiere;
then write(' arhiva') END.
else write(' ne arhiva');
3URJUDPXOOLVWHD]FRQLQXOWXOGLUHFWRUXOXLQGLUFXGDWDXOWLPHL
DFWXDOL]ULúLDWULEXWXOILHFUXLILúLHUDSRLSR]LLRQHD]DWULEXWXOILúLHUXOXLFD
vizibil.
94
UTCB
([HUFLLL
6VHIDFXQSURJUDPSULQFDUHVHDILúHD]XQPHQLXúLODILHFDUHDOHJHUHGH
ODQVHD]vQH[HFXLHXQILúLHUGHSHGLVFFXH[FHSLDXQHLDOHJHULFDUHWUHEXLHVILHKDOW
6VHIDFXQSURJUDPGHWUDQVIHUDWXWXURUILúLHUHORUGLQWUXQGLUHFWRUvQDOWGLUHFWRU
inclusiv subdirectoarele.
6VHIDFXQSURJUDPGHFXWDUHDXQXLILúLHUvQWUROLVWGHGLUHFWRDUHúLvQFD]GH
JVLUHVVHWUDQVIHUHvQWUXQGLUHFWRUGDW
95

Utilizarea Calculatoarelor: &dphold Dyulo 9Lruho3Hwuhkxú

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Utilizarea Calculatoarelor: &dphold Dyulo 9Lruho3Hwuhkxú

Enviado por

Direitos autorais:

Formatos disponíveis

UTCB

UNIVERSITATEA TEHNICA DE CONSTRUCTII

Programare în limbajul Pascal

In mod natural, rezolvarea cu calculatorul a unei probleme conduce la

1.2. Reprezentarea algoritmilor

Algoritmii se pot reprezenta prin:

3. simboluri pentru proces propriu-zis de prelucrare a datelor

4. simboluri pentru proces predefinit (procedura,functie)

1.3. Limbaje de programare

/LPEDMHOH GH SURJUDPDUH UHSUH]LQW PRGDOLWL GH FRPXQLFDUH D

1.4. Exemple de reprezentare a algoritmilor

In pseudocod algoritmul este:

7. Fie (a0,a1,...an úL E0,b1,..bm FRHILFLHQLLDGRXSROLQRDPH6VHDOFWXLDVF

0 úL1 IUDIRORVLUDGLFDOL PHWRGDWDQJHQWHL

10. Fie M o matrice n× QFXHOHPHQWHOHVDX6HQXPHúWHLQVXOvQPDWULFHR

2.1. Structura unui program

2.2. Utilizarea mediului de dezvoltare Turbo Pascal

2.3. Vocabularul limbajului

2.4. Tipuri simple de date

WLSGDW domeniu de valori mod de reprezentare

2EVHUYDLH 7LSXO comp este un tip întreg cu valori din intervalul

7LSXOORJLF ERROHDQ úLRSHUDWRULLORJLFL

< < 3<2 are valoarea false

2.4.3.Tipul caracter (Char)

Caracterele sunt reprezentate în calculator pe un octet. Codificarea pe

Numele Numele în Exemplu de Tipul Tipul

Radical Sqrt Sqrt(x) real>0 real

6VHVFULHXQSURJUDP3DVFDOSULQFDUHVHFLWHVFDEFúLVHWLSUHVFVLQ D FRV E úL

3. Tipuri ordinale de date definite de utilizator

3.1. Tipul enumerare

In anumite probleme intervin date care au caracter nenumeric,de exemplu

3.2. Tipul interval

literemici=‘a’..’z’; { toate literele mici de la a la z}

De multe ori, în rezolvarea unor probleme, apare un algoritm ce

,Q FD]XO LQVWUXFLXQLL ,) H[SUHVLD ERROHDQ GLQ

5.2. Instructiunea WHILE (test înainte)

9 Avem VLQ [ = ∑ W XQGH W = .

a1/2'DWD!VVHFDOFXOH]HSULPXO[n pentru care [ − [ − <  − . Q Q

unde tip_tablou este identificatorul tipului ARRAY, tip_ind_i sunt tipuri

unde nume_tablou UHSUH]LQW LGHQWLILFDWRUXO DVRFLDW YDULDELOHL GH WLS

repeat until keypressed;

6VHUHDOL]H]HXQSURJUDPFDUHUHDOL]HD]vQPXOLUHDXQHL PDWULFH SWUDWLFH FX HD

7. Se dau numerele D  L =  M = úL E M =  6VHUHDOL]H]H

BEGIN {programul principal}

a=x0 x1 xn-1 b=xn

function int(st,dr:real; n:integer):real;

for i:=1 to n-1 do

7.3. Procedura Exit

$FHDVW SURFHGXU VH XWLOL]HD] SHQWUX WHUPLQDUHD EORFXOXL FXUHQW GH

if x<0 then begin f:=1;exit;end;

5HFXUVLYLWDWH vQVHDPQ DSHODUHD XQHL SURFHGXUL VDX IXQFLL GH FWUH HD

Limbajul Turbo Pascal permite definirea de variabile-subprogram de tip

function int(st,dr:real; n:integer; f:func):real;

6VHFDOFXOH]H ∫ I [ G[ prin metoda trapezelor, luînd n=120.

)XQFLD $FLXQHD Exemplu

Function Chr(x:Byte):Char ' FDUDFWHUXO FX QXPUXO &KU  GYDORDUHD

<= 9HULILF LQFOX]LXQHD $ % HVWH 758( GDF $ H VXEPXO LPH D OXL %

úL )$/6( vQ FD] FRQWUDU

>= 9HULILF LQFOX]LXQHD $! % H VXEPXO LPH D OXL$

<> 9HULILF LQHJDOLWDWHD $!% HVWH 758( GDF $ úL % VXQW GLIHULWH

= 9HULILF HJDOLWDWHD $ % HVWH 758( GDF $ úL % VXQW HJDOH

{Definirea procedurilor sort, bilant, verificare}

BEGIN {programul princ.}

/LPEDMHOH GH SURJUDPDUH UHSUH]LQW PRGDOLWL GH FRPXQLFDUH D

7. Fie (a0,a1,...anúLE0,b1,..bmFRHILFLHQLLDGRXSROLQRDPH6VHDOFWXLDVF

0 úL1 IUDIRORVLUDGLFDOLPHWRGDWDQJHQWHL

10. Fie M o matrice n× QFXHOHPHQWHOHVDX6HQXPHúWHLQVXOvQPDWULFHR

2EVHUYDLH 7LSXO comp este un tip întreg cu valori din intervalul

7LSXOORJLFERROHDQúLRSHUDWRULLORJLFL

6VHVFULHXQSURJUDP3DVFDOSULQFDUHVHFLWHVFDEFúLVHWLSUHVFVLQDFRVEúL

,Q FD]XO LQVWUXFLXQLL ,) H[SUHVLD ERROHDQ GLQ

a1/2'DWD!VVHFDOFXOH]HSULPXO[n pentru care [ − [ − < − . Q Q

6VHUHDOL]H]HXQSURJUDPFDUHUHDOL]HD]vQPXOLUHDXQHL PDWULFH SWUDWLFH FX HD

7. Se dau numerele D L = M = úL E M = 6VHUHDOL]H]H

5HFXUVLYLWDWH vQVHDPQ DSHODUHD XQHL SURFHGXUL VDX IXQFLL GH FWUH HD

)XQFLD $FLXQHD Exemplu

Function Chr(x:Byte):Char ' FDUDFWHUXO FX QXPUXO &KUGYDORDUHD

<= 9HULILF LQFOX]LXQHD $ % HVWH 758( GDF $ H VXEPXO LPH D OXL %

<> 9HULILF LQHJDOLWDWHD $!% HVWH 758( GDF $ úL % VXQW GLIHULWH

= 9HULILF HJDOLWDWHD $ % HVWH 758( GDF $ úL % VXQW HJDOH

2EVHUYDLH$FHVWSURJUDPFRSLD]FRQLQXWXOXQXLILúLHUILúLHUVXUVvQ

In exemplul de mai sus qYDFRQLQHDGUHVDXQHLYDULDELOHGHWLSWDEHOWLS

)LHVLVWHPXO; $;%XQVLVWHPGHQHFXDLLFXQQHFXQRVFXWHFX$>LM@ UDQGRPQ

6ROXLDVLVWHPXOXLHVWH ; = OLP ; unde X1 DUELWUDUúL;n=AXn-1%PHWRGDOXL,DFREL6

)LHYHFWRUXOYFXFRPSRQHQWHUHDOHLDUY>L@ UDQGRPDFHDVWDvQVHDPQF

1. ANTETUL VSHFLILF QXPHOH XQLWXOXL FDUH WUHEXLH V ILH DFHODúL FX

,17(5)$&( FRQLQH GRDU DQWHWXO SURFHGXULORU úL IXQFLLORU SXEOLFH

,QVWUXFLXQHD Forma ([SOLFDLLH[HPSOH

procedure RunError(n:word); VHRSUHúWHH[HFXLDSURJUDPXOXLúL

{$F+} {$F-} FX)VHIDFDSHOXUL)DUFWUHSURFHGXULVHIRORVHúWHFXWLSXULGHGDWH

function wherex:byte; GHWHUPLQSR]LLD[DFXUVRUXOXL

3URJUDPXO XUPWRU FUHD] R IHUHDVWU SHQWUX LQWURGXFHUHD GH QXPHUH úL QX

Unit-ul GRAPH DOYHUVLXQLL7XUER3DVFDOLPSOHPHQWHD]DRELEOLRWHF

(FUDQXO JUDILF VH SUH]LQW FD R ]RQ GUHSWXQJKLXODU FDUDFWHUL]DW SULQ

Procedure Arc(x,y:integer;Ustart, [úL\VXQWFRRUGRQDWHOHFHQWUXOXLFHUFXOXLU

Procedure SetActivPage(nrpag:word); IL[HD]DSDJLQDDFWLYSHQWUXHFKLSDPHQWXO

function TextHeight(t:string); GHWHUPLQvQOLPHD]RQHLGHWH[WSHQWUXúLUXO

Fie f:[xm in ,x m ax ] → [ y m in ,y m ax ] 3HQWUXDUHSUH]HQWDJUDILFIXQFLDSH

6VHUHSUH]LQWHJUDILFvQDFHODúLVLVWHPGHD[HI[D VLQD [[ [D DSHQWUX

D 3URFHGXUD XUPWRDUH UHDOL]HD] SHQWUX XQHOH SULQWHUH FRSLHUHD HFUDQXOXL OD

procedure FindNext(var f:SearchRec) VHFDXWXUPWRDUHDDSDULLHDILúLHUXOXL

procedure SetFAttrib (var f; SR]LLRQHD] DWULEXWHOH XQXL ILúLHU XQGH f

procedure GetFTime(var f; var UHWXUQHD]GDWDúLRUDXOWLPHLVFULHULvQILúLHUvQ