Programare Procedurala

UNIVERSITATEADINORADEA FACULTATEADETIINE
Programareprocedural
[suportdecurs]
Lect.univ.dr.HoreaOros
[]
[LucrareareprezintsuportuldecurspentrudisciplinaProgramareProceduraldin
planuldenvmntalstudenilordelaspecializrileInformaticiMatematicanulI.]
Cuprins
1. Introducere ................................................................................................................ 5
Definiii ........................................................................................................................... 5
Paradigme de programare ............................................................................................... 7
Generaii de limbaje ........................................................................................................ 8
Istoria i evoluia limbajelor de programare ................................................................. 10
Tendine ........................................................................................................................ 16
2. Procesuldecreareasoftwareului ........................................................................ 17
Introducere .................................................................................................................... 17
Aspecte ale calitii software-ului ................................................................................. 18
Studiu de caz - Limbajul C ........................................................................................... 19
3. Traducereaiexecuiaprogramelor ..................................................................... 21
Specificarea sintaxei unui limbaj de programare .......................................................... 21
Traducerea programelor ................................................................................................ 28
Uniti de program ........................................................................................................ 32
Link-editarea ................................................................................................................. 33
Execuia programelor .................................................................................................... 34
Medii de programare i execuie ................................................................................... 35
Interpretarea .................................................................................................................. 35
4. Declaraii .................................................................................................................. 36
Rolul identificatorilor ntr-un program ......................................................................... 36
Semantica unei declaraii .............................................................................................. 37
Declaraii de constante .................................................................................................. 37
Declaraii de tipuri de date ............................................................................................ 40
Declaraii de variabile ................................................................................................... 47
5. Tipuridedate .......................................................................................................... 58
Tipuri fundamentale ...................................................................................................... 58
iruri de caractere ......................................................................................................... 60
Tipul pointer.................................................................................................................. 61
Tipuri procedurale ......................................................................................................... 63
Tipuri structurate ........................................................................................................... 64
Tipul tablou ................................................................................................................... 66
Tipul de date nregistrare .............................................................................................. 68
Tipuri definite de utilizator ........................................................................................... 70
6. Expresii..................................................................................................................... 71
Generaliti .................................................................................................................... 71
ProritateaiasociativitateaoperatorilornlimbajulC: ................................................ 73
Clase de operatori i de expresii (dup tipul rezultatului) ............................................ 75
Modaliti de evaluare a expresiilor .............................................................................. 80
7. Instruciuniicontrolulexecuiei .......................................................................... 84
Instruciunea de atribuire .............................................................................................. 84
Instruciunea compus .................................................................................................. 86
Instruciuni condiionale (de ramificare, de selectare) .................................................. 86
Instruciuni de ciclare .................................................................................................... 88
Instruciuni de transfer .................................................................................................. 89

4
Programarea structurat i cum s-a ajuns la ea ............................................................. 90
8. Proceduriitransmitereaparametrilor ................................................................ 92
Abstractizare i specificare ........................................................................................... 92
Proceduri ....................................................................................................................... 96
Evaluarea i transmiterea parametrilor ......................................................................... 98
Specificarea parametrilor unei proceduri ...................................................................... 99
Noiunea de efect secundar ........................................................................................... 99
Proceduri mutual recursive ......................................................................................... 100
9. ANEXE .................................................................................................................... 101
UniversitateadinOradea,Facultateadetiine,
DepartamentuldeMatematiciInformatic
SuportdecurspentrudisciplinaProgramareprocedural
Specializrile:InformaticiMatematicanulI,semestrulI
Lect.univ.dr.HoreaOros
5

1. Introducere
PP este o paradigm de programare bazat pe conceptul de apel de procedur.
Procedurile, numite i rutine, subrutine, metode sau funcii (a nu se confunda cu
funciile matematice, dar similare cu cele folosite n programarea funcional)
coninoseriedepaicomputaionalicaretrebuieparcuri.Oriceprocedurpoatefi
apelat oriunde n timpul execuiei unui program inclusiv din interiorul ei (apel
recursiv).
PPestedemulteorioalternativmultmaibundectprogramareasecvenialsau
programarea nestructurat n situaiile n care complexitatea problemei este
moderatinunecesitunefortdentreinereridicat.
BeneficiialePP:
Posibilitateadearefolosiacelaicodnlocuridiferitencadrulprogramului
fralcopia.
Controlul execuiei programului este mai simplu n comparaie cu folosirea
unorinstruciuniGOTOsauJUMP(instruciunicepottransformaunprogram
marencevacesenumetecodsubformdespaghete).
Abilitateadeafiputernicmodularistructurat.
Definiii
Limbajdeprogramare:notaiesistematicprincareestedescrisunprocesdecalcul.
Rolul unui LP este de a pune la dispoziia programatorilor construcii sintactice
pentru organizarea calculelor. Procesul de calcul este constituit dintro mulime de
pai pe care o main i poate executa pentru a rezolva o anumit problem, pai
care sunt exprimai n comenzi elementare pe care maina (calculatorul) tie s le
execute.Pentrudescriereaprocesuluidecalculestenecesarcunoatereasetuluide
comenzi(instruciuni)almainiilacarenereferim.
Limbaj main: limbajul nativ al unui computer, reprezint notaia la care
calculatorul rspunde n mod direct. Setul de comenzi elementare al unui
calculator este constituit din: operaii aritmetice i logice, operaii de intrareieire
i unele funcii speciale, numite funcii de control. Comenzile i instruciunile
limbajului main sunt scrise ntro form codificat, foarte compact, fapt ce
ngreuneazfoartemultnelegereatextuluisurs.Limbajulmainestefoartelegat
de arhitectura fizic a mainii, el fiind constituit din codificri binare a cror
semnificaieesteimposibildedescifratnmodrezonabildectreprogramator.
0000101011110000
0010111111111111
0010000000000101
Lectoruniv.HoreaOros

6
Limbajul de asamblare: face un pas nainte ntruct atribuie nume simbolice
(mnemonici) codificrilor operaiilor mainii, precum i locaiilor de memorie
asociate. Secvena de coduri binare de mai sus are, pe o anumit arhitectur,
echivalentulmnemonic:
LOAD I
ADD J
STOREK
Niciunadinceledouvariantenuestelafeldeclarisemnificativcaechivalentul
lor:
K:=I+J
Din acest motiv, limbajele main i cele de asamblare se numesc limbaje de nivel
sczut.
Aceste limbaje sunt foarte departe de limbajul natural, aa c sa cutat elaborarea
altor limbaje, mai apropiate de exprimarea natural. Rezultatul a fost crearea
limbajelor de nivel nalt (highlevel programming languages). Aceste limbaje
utilizeaz notaii mai puin primitive dect limbajele de asamblare, n care
exprimarea aciunilor de urmat devine uoar, clar i concis. Nivelul nalt are
semnificaiauneidistanrisuficientdemarifadeniveluldeexprimarealmainii.
Un limbaj de nivel nalt mrete considerabil numrul celor care vor programa
calculatoare. Proiectarea i implementarea limbajelor de programare este
activitatea capital de a crei calitate depinde lrgirea comunitii programatorilor
carespoatrealizaeficientdezvoltareaunoraplicaiidelarginteres.
Orice notaie utilizat care este diferit de limbajul main nu poate fi executat
direct, ea trebuind s fie tradus n limbajul main al calculatorului gazd.
Activitatea de traducere (numit generic translatare) este preluat de programe
specializate numite compilatore (dac textulsurs este scris ntrun limbaj denivel
nalt)sauasambloare(dactextulsursestescrisnlimbajdeasamblare).
Datorit interpunerii compilatoarelor i asambloarelor este evident c odat cu
creterea claritii i accesibilitii, limbajele de programare de nivel nalt aduc cu
ele i o scdere a performanei de execuie fa de variantele de program scrise
directnlimbajmain.Acestescderisemanifestpedouplanuri:
timpmaincerutdeprocesuldecompilare
codul rezultat n urma translatrii este de obicei mai lung i necesit mai
multtimpdeexecuiedectvariantacodificatdirectnlimbajmain.
Trecerea la utilizarea LP de nivel nalt a adus cu sine o caracteristic foarte
important a programelor scrise n astfel de limbaje i anume portabilitatea, adic
posibilitatea de a rula programele fr modificri pe arhitecturi de calcul diferite
(eventual modificrile sunt cu totul minore). Acest moment a fost foarte important

7
pentrudezvoltareauneicomunitideprogramatori,pentrurspndireasoftuluii
pentrucreareadebibliotecideprogramereutilizabile.
Paradigme de programare
Paradigm de programare: colecii individualizate de caracteristici de evaluare i
criterii de abstractizare care determin i difereniaz clasele de limbaje de
programare. Astfel de criterii sunt: structura programului, noiunea de stare a
execuiei,metodologiaprogramrii.
Programarenestructurat:foloseteGOTO
Programarestructurat:eliminGOTO(saureducefoartemultutilizareaGOTO)
Programarea procedural: este caracterizat prin faptul c un program este privit
caomulimeierarhicdeblocuriiproceduri.Exponent:ALGOL60
Programare funcional: un program este descris pe baza unor funcii de tip
matematic utilizate de obicei recursiv. Funciile sunt considerate obiecte cu
drepturi egale (first class citizens) n cadrul limbajului, adic la fel ca elementele
oricrui tip de dat ele pot constitui elementul de baz n structurarea unor date
(putem avea de exemplu tablouri de funcii), pot fi returnate ca rezultat al unor
funcii(funciacompuneredefunciireturneazoaltfuncie).Exponeni:Lisp(anii
60),Miranda(anii70),ML(anii80),Haskell(anii90).
Programare imperativ: (opusul este programare declarativ) este o paradigm de
programare care descrie procesul de calcul n termeni de stare a programului i
instruciuni care schimb starea programului. Programele imperative pot fi privite
ca o serie de comenzi pe care calculatorul le execut. Limbajele imperative indic
modulncarearelocprocesuldecalcul.Majoritatealimbajelordeprogramaresunt
limbajeimperative.(Fortran,Algol,C,Pascal,Ada)
Programare declarativ: este o abordare a programrii calculatoarelor ce implic
creareaunuisetdecondiiicedescriuspaiulsoluieidarlasinterpretareapailor
necesari pentru a ajunge la soluie unui interpretor nespecificat. Programarea
declarativ este o abordare diferit fa de programare imperativ tradiional din
Fortran,Pascal,Ccarenecesitcaprogramatorulsfurnizezeolistdeinstruciuni
ce se execut ntro ordine specificat. Soluiile declarative au dou faze
independente:declaraiaiinterpretarea.(Prolog,Haskell,Oz,SQL,WSDL)
Programare logic: un program este descris printrun set de relaii ntre obiecte
precumiderestriciicedefinesccadrulncarefuncioneazaceleobiecte.Execuia
nseamn aici activarea unui proces deductiv care va furniza concluzii posibile pe
bazadatelordeintrare.Exponent:Prolog.
Programare bazat pe obiecte i orientat pe obiecte: un program este constituit
dintro colecie de obiecte care interacioneaz. Exponeni: Simula, Smalltalk, C++,
Java,C#.
Programare concurent i distribuit: execuia unui program este constituit din
aciuni multiple posibil a fi executate n paralel pe una sau mai multe maini.
Execuia aciunilor poate fi independent sau aciunile pot depinde una de alta,

8
situaie n care este nevoie de primitive de sincronizare i comunicare. Exponeni:
CSP, extensii concurente ale limbajelor imperative (C, Pascal, FORTRAN), Linda,
Occam
Programare la nivelul bazelor de date: aciunile programului sunt dictate de
cerinele unei gestiuni corecte i consistente a bazelor de date asupra crora
acioneazprogramul.Exponent:SQL.
Paradigmele prezentate nu sunt mutual exclusive. Exist limbaje de programare
multiparadigm.
Generaii de limbaje
19541958Limbajeledeprogramaredeprimageneraie(FORTRANI,ALGOL58).
Acesteaaumerituldeafifcutpasuldecisivdelalimbajuldeasamblarelalimbajele
de nivel nalt. Rolul lor primordial a constat n promovarea i dezvoltarea
conceptelor ce stau la baza limbajelor de programare de nivel nalt precum i a
implementriilor.
19591961Limbajedegeneraiaadoua(ALGOL60,FORTRANII,Cobol,Lisp)
Sunt considerate limbaje stabile, durabile, care se utilizeaz intens i astzi. Chiar
dacALGOL60nuaatinsungradderspndiresuficientdemare,influenasaafost
imensndezvoltarealimbajelorPascal,PL/1,SimulaiAda.
19621971Limbajedegeneraiaatreia(PL/1,ALGOL68,Pascal,Simula)
Chiardacaureprezentatteoreticunpasnainte,succesullornusepoatecompara
nici pe departe cu cel al limbajelor de generaia a doua. ncercarea acestor limbaje
dealenlocuipeceledegeneraiaadouaafostsortiteecului,fcndulpeC.A.R.
Hoare s remarce ALGOL60 reprezint un pas nainte fa de succesorii(!) si.
Limbajul PL/1 a combinat elemente de FORTRAN, ALGOL i Cobol rezultnd un
limbaj puternic, dar mult prea complex, deosebit de dificil de nvat i de
implementat. ncercarea limbajului ALGOL68 de a generaliza limbajul ALGOL60 a
fost caracterizat drept elegant dar neacceptat practic de marea mas a
programatorilor. Limbajul Pascal, dei cu un enorm succes din punct de vedere
didactic, nu este considerat nici astzi suficient de robust pentru utilizarea la scar
industrial.
19721979Limbajedegeneraiaapatra(CLU,CSP,Ada,Smalltalk)
Au avut o rspndire i mai redus dect cele de generaia a treia, justificnd pe
bun dreptate denumirea acestei perioade drept gol de generaie (generation
gap).Aceastperioadafostnsoperioaddecercetareintensidereevaluarea
obiectivelor proiectrii limbajelor de programare. Criza software de la sfritul
anilor 60 a condus la o schimbare de optic n acest sens, accentul cznd pe
structurare.Lanivelmicroacestlucrusafcutprineliminareainstruciunilorgoto
inlocuirealor cu instruciuni detipwhile, iar la nivel macrosa pus mare accent
pe modularizarea programelor prin utilizarea intensiv de funcii i proceduri i
prinpromovareaconceptuluideabstractizareadatelor.

9
19801990Paradigmealelimbajelordeprogramare
Aceast perioad se caracterizeaz printro intens activitate de cercetare,
concentratnuattpestudiulidezvoltareaunorlimbajeparticulare,ctpestudiul
paradigmelor asociate claselor de limbaje. n acest sens se remarc clasele de
limbaje funcionale, logice, orientate obiect i distribuite, ele reprezentnd i cele
patruparadigmedeprogramarecelmaiintensstudiatelaoraactual.

10
Istoria i evoluia limbajelor de programare

Primullimbaj
Ada Lovelace scrie programe pentru proiectul motor diferenial al lui Charles
Babbage iar mai apoi pentru motorul analitic. n 1945, germanul K. Zuse,
inventatorul calculatorului Z3 a definit un limbaj evoluat pentru acest motor
(folosindtablouriinregistrri)
Asamblare
Asambloarele au aprut o dat cu primele calculatoare. Acestea asociaz un nume
simboliccoduluilanivelmain,deex:
Addbx,4
cmp[adr],3
jmpaddress
Programarea n limbaj de asamblare nu se mai practic pe scar larg, nici mcar
pentrurutinecetrebuiesrulezefoarterapid.
Autocoder1952
AlickEGlennie
ImplementatpentruprimadatpeMark1,iarmaiapoiipealtecalculatoare.
IPL1956
InformationProcessingLanguage
ANewell,HSimon,JCShaw
Limbajdeniveljospentruprocesarealistelor.Implementeazrecursivitatea
Fortran19541958
FORmulaTRANslator
JohnBackusialicercettoridelaIBM
Limbajdedicatcalculelormatematice

11
FortranII(1958)introducesubrutine,funcii,bucle,ostructurdecontrolprimitiv
detipFOR.Identificatoriisuntlimitailaasecaractere
Lisp19581960
LIStProcessing
MacCarthy
Limbaj funcional pentru procesarea listelor. Este recursiv, nu este iterativ. Nu
existdiferenntrecodidate.
Algol1960/AlgolW1966/Algol68
ALGOrithmicLanguage
Definitdeunconsoriuinternaionalformatdinspecialitininformatic
Primul limbaj universal independent de main. Introduce utilizarea gramaticilor
BNF(BackusNaurForm)pentruacreaunanalizorsintactic.Introduceblocurilede
instruciuni i variabilele locale n cadrul unui bloc. Recursivitatea a fost
implementat cu reticen pentru c a fost considerat inutil! Folosete tablouri
dinamice ceea ce nseamn c limbajele urmtoare (Pascal, C) au regresat folosind
tablouristaticepentruoperformanmaibun.
AreinstruciuneaIFTHENELSE,FOR,simbolul:=pentruatribuire(folositmaiapoi
nPascal),instruciuneaSWITCHcuGOTO,indicatoriBEGIN,ENDicicluWHILE.
Algol W proiectat de Niklaus Wirth n 1966 folosea RECORD (structuri de date
dinamice), CASE, transmiterea parametrilor prin valoare, precedena operatorilor.
n acelai an, Niklaus Wirth a creat Euler, un limbaj ntre Algol i Pascal. Algol 60
limbaj orientat spre calcule matematice. Pentru a ncerca s se obin obiectivul
iniialianumedeacreaunlimbajdeuzgeneral,sacreatncepndcu1964onou
versiune Algol X, numit mai trziu Algol 68. Algol 68 folosea =+ pentru a contopi
atribuireacuadunarea.IntroduceUNIONitipuriCAST.AreIFTHENESLEFI,CADE
GOTO,operatoridefiniideutilizator.Compilareaincrementalnuestepermis.
Cobol1960
COmmonBusinessOrientedLangage.
DefinitdeCODASYL,COnferenceonDAtaSYsystemsLanguages.

12
Basic1964
BeginnersAllpurposeSymbolicInstructionCode
JohnKemeny,ThomasKurtz
Proiectat n 1963, pentru a fi uor de nvat i a fost implementat n 1964. Prima
versiuneafostcompilat,dupcareadevenitinteractiviinterpretat.Fiecarelinie
areunnumripermitesaltullaliniecuinstruciuneaGOTO.
Bill Gates i Paul Allen au ctigat un concurs internaional prin proiectarea i
implementareaunuiBasicrapidicompact,primadatpeAltair(4kbdememorie)
imaiapoipealtemicrocomputere.
Microcomputerele au fost furnizate cu Basic n ROM pn la sfritul anilor 80. n
1977, Appel II se vindea cu Basic pentru ntregi. Mai apoi Applesoft Basic de la
Microsoft cu virgul flotant. Applesoft avea identificatori din dou litere.
SubprogrameleerauapelateprinGOSUBnumrlinie.
Primul PC de la IBM (1981) folosea sistemul de operare MSDOS de la Microsoft i
Basicinterpretat(Basica).n1982MicrosoftaprodusprimulBasiccompilat(Quick
Basic)
n acelai deceniu Pascal i C au nlocuit Basic. Microsoft folosete n continuare
Basic(VBA).
Logo66
WFuerzeig,SPapert,andothers
Folosit pentru ai nva pe copii programare. Asemntor cu Lisp i se bazeaz pe
micareauneibroateestoasepeecran.
Pascal1970
BlaisePascal,matematicianfrancez
NiklausWirth.

13
A fost proiectat pentru a simplifica crearea compilatoarelor i pentru ndruma
procesuldenvareaprogramriispreprogramareastructurat.UCSDPascaleste
prima versiune pentru microcomputere. Programele sunt compilate n Pcod, care
este portabil i interpretat (la fel ca Java mai trziu). Includea un mediu pentru
dezvoltare de aplicaii complet, un principiu folosit cu succes mai trziu n Turbo
Pascal.n1981,joculWizardryscrisnPascalaavutunsuccesfoartemarepeApple.
Turbo Pascal (proiectat de Anders Hejlsberg) a aprut n 1983. Era rapid, avea un
IDE complet aa c limbajul a avut un succes instantaneu i este folosit chiar i
astzi.StructuriledecontrolsuntasemntoarecuceledinC.
Smalltalk1972
AlanKay,SoftwareConceptGroup.
Limbajdeprogramareorientatobiectcareruleazntotdeaunancadrulunuimediu
grafic,cuferestre,mouseetc.
C1973
CestesuccesorulluiB,carelarndulluiestesuccesorulluiBCPL
DennisRitchie.
A fost destinat pentru programarea sistemului de operare UNIX, dar a devenit
repede un limbaj universal datorit portabilitii i vitezei. Permite compilare
incremental. n 1965, programatorii AT&T foloseau BCPL pentru a implementa
Unix. Nemulumii de limbaj, lau mbuntit i sa creat limbajul B iar mai apoi C.
EvoluiahardwareuluiadeterminatapariialimbajuluiC.BCPLiBfoloseauntregi
pentru pointeri, dar aceasta nu funciona pe calculatoarele noi. BCPL nu are tipuri
(lafelcaPHPsaualtelimbajescriptmoderne).Declaraiileinti,charbaufostcreate
nC.Ulteriorauaprutialtetipuri.Operatorul+=vinedinAlgolundeerascris=+.
nBCPL,unblocdeinstruciuniesteinclusntresimbolurile(*i*)iarcomentariile
ntre /* i */ iar subexpresiile ntre ( i ). Limbajul C a simplificat scrierea prin
folosirea acoldelor. ++ exista i n limbajul B. Cuvntul include venea din PL/1.
Preprocesorulafostimplementatn1973idinacelmomentlimbajulCafostfolosit
pentruscriereasistemuluideoperareUnix.Limbajulaevoluatpnn1980.
Sql1970+

14
StandardQueryLanguage
IBM
Limbajpentruinterogareabazelordedaterelaionale.
C++19811986
BjarneStroustrup.
Versiune a limbajului C orientat pe obiecte. Introduce suprancrcarea
operatorilor. Metodele pot fi inline. Comentarii // care vin din BCPL. Au fost
implementatemotenireaiabloanele(clasesaufunciigenerice).
Objective C, inventat de Brad Cox n 1984, este o alt versiune orientat obiect a
limbajuluiCinspiratdinSmalltalk.
Perl1987
PracticalExtractingandReportLangage.
LarryWall,lingivstaustralian
Destinat pentru nlocuirea limbajelor linie de comand Unix, Sh, Sed and Awk, a
pstrataceeaisintaxgreoaie.Folositnprincipalpentruadministrareasistemului
i scripturi CGI. Folosete liste i tablouri asociative. Exist structura de control
FOREACHcarepermiteparcurgereaunorliste.
Java1994
Java(coffee)
JamesGosling,SunMicrosistems
Proiectatn1991caunlimbajinteractivnumitOak.Lavremearespectivnuaavut
succes. n 1994 a fost rescris pentru Internet i redenumit Java. n 1995 se puteau
crea appleturi. n ianuarie 1996, Javasoft distribui JDK 1.0. Kitul pentru
dezvoltarea de aplicaii. Java este un limbaj clasic de programare procedural,
apropiat de C++. Se compileaz n bytecode ce poate rula pe orice calculator. Este
maisimpludectC++:fiecarefiierconineosingurclas,memoriaestegestionat
automat, nu exist pointeri, motenire multipl, suprancrcarea operatorilor dar
includemultitasking.SpredeosebiredeCiC++aredoartablouridinamice.

15
PHP1995
PersonalHomePagesHypertextProcessor
RasmusLerdorf
Limbaj script mutliplatform, ce se include n HTML. Asemntor cu C dar nu este
tipizat. Variabilele se prefixeaz cu $. Interpretorul prelucreaz pagina html ce
include instruciuni php i o transform ntro pagin html pur. Biblioteca de
funcii permite crearea de pagini web dinamice. Microsoft folosete ASP
(asemntorcuBasic)
UML1996
UnifiedModelingLanguage
Standard (Object Management Group) Grady Booch, Jim Rumbaugh, and Ivar
Jacobson
Uml reprezint reunirea a trei limbaje de modelare proiectate de cei trei autori.
Limbajulfoloseteonotaiegraficpentruaproiectasoftware.Sefacdiagramecare
exprim obiecte i interaciunile dintre acestea. Un model este realizat din
vizualizri i combinarea lor descriu un sistem complet. Modelul este abstract i
independentdedomeniu.
Este limbaj pentru specificarea, vizualizarea, construirea i documentarea
proiectelorsotwareintense.
C#2000
(Csharp),succesoralC++?
AndersHejlsberg/Microsoft.

16
Principalul limbaj din platforma .NET , pentru crearea de software care s
funcioneze prin Internet. La fel ca i Java, pstreaz sintaxa C (un limbaj de 30 de
ani!) i aduce mbuntiri: garbage collector, nu are pointeri, interfee, multi
tasking
C# se comileaz n limbaj intermediar MSIL (Microsoft Intermediate Language) i
folsoeteobibliotecmultilimbaj,CLR(CommonLanguageRuntime).Originalitatea
sistemului .NET este varietatea de limbaje ce pot fi compilate n MSIL i partajarea
claselor.
Altefacilitioferitedeacestlimbaj:
Structurilesuntspecialefiindtransmiseprinvaloare
Identificatoriisuntobiectecumetode
Atributele sunt obiecte descriptive ataate elementelor programului i folosite la
execuie
Proprieti(get/set)
Foreachpentruparcurgereaunorlistedeobiecte
Delegai(nlocuiescpointeriilafunciidinC)
mbuntirifadeJava:
Gestiuneaevenimentelorestembuntit
Suprancrcareaoperatoriloresteprezent
Accesmaisimplulasistemulnativ
Tendine
Limbajescript:NetRexx,Python,Ruby,Scriptol.
LimbajepentruInternet:Php,Asp,JavaScript
Limbajedemarcare:XML
Platforma .NET sau altele similare vor simplifica introducerea de cod n interiorul
datelor, dar XML poate fi o alternativ. C# va fi un lider pentru astfel de platforme
iar succesul su va fi asigurat de faptul c programatorii de C, C++ i Java l vor
adopta cu uurin. Datorit faptului c platforma .NET permite utilizarea oricrui
limbaj va fi posibil apariia unor limbaje noi mai expresive. Platforma .NET
folosete XML prin convertirea n obiecte. Viitorul este folosirea direct a XMLului
catipdedate.

17
2. Procesuldecreareasoftwareului
Introducere
Limbajele de programare sunt instrumente pentru scrierea de programe. Ele sunt
componente ale procesului de creare a softwareului i prin urmare proiectarea i
implementarea lor respect etapele componente ale acestui proces. Se poate
considera c realizarea unui nou limbaj este structural identic cu realizarea unei
aplicaii software complexe, ea trebuind s urmeze un anumit cadru general, ale
crui faze sunt bine definite, cadru n care este permis la fiecare pas revenirea n
fazaimediatanterioar.
ncontinuarevomprezentafazeleprocesuluidecreareasoftwareului.
Analiza i specificarea cerinelor. O aplicaie software este conceput pentru a
veni n sprijinul unui anumit grup de utilizatori poteniali. Cerinele acestora sunt
stabilitesubformaunuidocumentcaretrebuie sprecizezeceeace trebuie sfac
aplicaiarespectivinucum.Laelaborareadocumentuluiparticipattpotenialii
utilizatori, ct i specialitii n dezvoltarea de software. Acest document conine
specificaiiprivindmanualeleutilizator,studiidecostifezabilitate,cerineprivind
performaneleetc.
Proiectarea i specificarea softwareului. Plecnd de la cerinele specificate n
faza precedent, echipa care realizeaz aceast etap (proiectanii software)
realizeaz specificaiile de proiectare, care identific fiecare modul al sistemului,
precum i interferenele dintre module. Metodologia de proiectare utilizat n
aceast faz are o mare importan pentru alegerea limbajului de programare
utilizatnfazaimediaturmtoare.
Implementarea.Aceastfazestesingurancareesteutilizatexplicitunlimbajde
programare. Implementarea nseamn scrierea de uniti de program
corespunztoare modulelor descrise n specificaiile de proiectare i editarea
documentaieicorespunztoare.Rezultatulacestei faze esteun sistem implementat
idocumentatcomplet.
Certificarea.Scopulacesteietapeesteverificareacerinelorimpusenprimaetap
i se realizeaz de obicei prin testarea sistemului n raport cu fiecare cerin
specificat, utiliznduse o baterie de teste, adic un set de programe (cnd este
vorba de un limbaj de programare) sau un set de exemple (cnd este vorba de o
aplicaieoarecare)careacopertoatenecesitileimpuse.Dinpunctuldevedereal
testrii,nusepoatefaceodistincieclarntrefazele3i4.Astfel,estenormalcan
fazadeimplementaresserealizezetestarealaniveldemodul,efectuatdefiecare
programatoriparialtestareainterfeelorintermodule(testaredeintegrare),care
serealizeazprinlegareactorvadintremoduleleaplicaiei.nfazadecertificarese
realizeaz testarea sistemului, care verific sistemul n ansamblul su. Rezultatul
acestei faze este un sistem verificat i certificat complet, livrabil utilizatorilor. n

18
afaratestrilor propriuzise, tot naceast faz seincludtoateactivitile caresunt
legatedeverificareacorectitudiniiprogramelorscrise.
ntreinerea. Dup intrarea n exploatarea a aplicaiei, pot s apar necesitatea
unormodificri,provocatefiededetectareaunoreroricareauscpatdinfaza4,din
dorina de ai aduga noi specificaii (cerine). De obicei, costul ntreinerii unei
aplicaiintrececostultuturorcelorlaltefazeluatempreun.
ngeneral,oriceprodussoftwaretrebuiessatisfacurmtoarelecerine:
Sfiefiabil
Sfieuordentreinut
Sseexecuteeficient
Aspecte ale calitii software-ului

Toat lumea dorete ca programele s fie fiabile, rapide, uor de folosit, lizibile,
modulare,structurateetc.
Calitatea produselor program se definete ca o compunere a mai multor trsturi.
Existoseriedefactoriexterniifactoriinterni.
Factorii externi de calitatea sunt sesizai de cei care interacioneaz direct cu
produsulfinalicarecumprprodusul,contracteazdezvoltareaintreinerealui.
Factorii interni de calitate se pot detecta doar de ctre persoanele implicate n
procesuldedezvoltaredesoftware.
Factoriiexterni:
Corectitudinea: abilitatea produsului de a executa exact sarcinile sale, n
conformitatecucerineleispecificareasa.
Robusteea: este abilitatea sistemului de a funciona chiar i n condiii anormale.
Uneori se folosete termenul fiabilitate, care este un concept mai general i se
interpreteazcelmaibinecaacoperindattcorectitudineactirobusteea.
Extensibilitatea:esteuurinacucareproduselesoftwaresepotadaptalaschimbri
ale specificaiilor. Exist dou principii eseniale pentru mbuntirea
extensibilitii: simplitatea proiectului (o arhitectur simpl va fi ntotdeauna mai
uordeadaptatlamodificridectunacomplicat)idescentralizarea(cuctsunt
mai autonome modulele ntro arhitectur software, cu att va fi mai mic numrul
de consecine ale unei modificri simple; ea va trebui s afecteze doar modulul n
cauzsauunnumrmaimicdealtemodule).
Reutilizabilitatea:esteabilitateaproduselorsoftwaredeafireutilizate,nntregime
saupariallanoiaplicaii.
Compatibilitatea:esteuurinacucareproduselesoftwarepotficombinatentreele
(potinteraciona).
Eficiena:nseamnfolosirearaionalaresurselorhardware(procesoare,memorii,
dispozitivedecomunicare).

19
Portabilitatea: este uurina cu care produsele software se pot transfera n diverse
mediihardwareisoftware.
Verificabilitatea: este uurina de elaborare a procedurilor de acceptare (n
particular date de test) i a procedurilor de detectare i trasare (transformare n
erori)acderilor(failures)ntimpulfazelordevalidareiexploatare.
Integritatea: este abilitatea produselor software de ai proteja componentele
(programe,date,documente)fadeacceseimodificrineautorizate.
Uurinanutilizare:sereferlanvareautilizriisistemului,operarea,pregtirea
datelordeintrare,interpretarearezultatelorirecuperareadinsituaiideeroare.
Factorii interni de calitate sunt strns legai de natura intim a procesului de

elaborareaproduselorprogram.Aicicontribuie:metodeledeanaliziproiectarea
produselor program, facilitile oferite de limbajele de programare folosite la
implementareiaspecteleorganizatoricealeindustrieisoft.
Factoriiinterni:
Modularitatea: structural produsul program trebuie s fie alctuit din module,
urmrinduseprincipiuldescentralizrii.
Documentareacomplet:presupuneexistenauneidocumentaiiclarei aduslazi
pentrufiecarefazdincicluldeviaalprogramului.
Unlimbajdeprogramaretrebuiesposedeurmtoarelecaliti:
S permit o descriere ct mai natural a problemei care se rezolv, permind
programatorului s se concentreze asupra problemei i nu asupra detaliilor de
adresare,indexareetc.
S aib un grad de lizibilitate ct mai ridicat, adic un program s poat fi uor de
descifrat(sintacticisemantic)deoricinelconsult.
Spermitgestiuneaexcepiilor(depiriaritmetice,erorideintrareieireetc.)
Studiu de caz - Limbajul C
C este (dup cum admit Brian W. Kernighan i Dennis M. Ritchie, creatorii
limbajului) un limbaj relativ mic, dar un limbaj care se comport foarte bine (din
punctuldevederealadmiratoriloracestuilimbaj).Faptulclimbajulestemiciare
unsetlimitatdecaracteristiciimplicoseriedeavantaje:trebuienvatmaipuin;
nu exist un bagaj suplimentar n calea programatorilor, de care nu au nevoie.
Limbajul fiind mic implic i dezavantaje: din moment ce limbajul nu face totul
pentruprogramator,acestatrebuieslucrezemaimult.(Acestaspectesteprivitde
muli ca i un avantaj: tot ceea ce limbajul nu face pentru programator, nu este
impus,lsndlibertateaprogramatoruluideafaceacellucruaacumvrea.)
Cesteadeseadenumitlimbajdeasamblaredenivelnalt.Uniiconsideraceastao
insult, dar este un aspect intenionat i important al limbajului. Construciile
simple, exprimate n C, nu se extind n construcii de nivel main costisitoare (n
timp sau spaiu), n momentul cnd programul este compilat. Dac scriem un

20
program simplu i succint,e foarte probabil c va rezulta un program executabil n
limbaj main foarte eficient. Dac observai c programul executabil obinut nu
este eficient, motivul este probabil modul de realizare al programului i nu
compilatorul care ar fi fcut ceva, fr tirea programatorului, asupra cruia nu
avemcontrol.
Un limbaj de programare este o unealt, i nici o unealt nu poate realiza orice
sarcin fr un ajutor. Limbajul C nu are toate trsturile necesare de care avem
nevoie n programele noastre. Limbajul C impune un set mic de reguli
programatorilor. Unele sarcini obinuite, cum ar fi manipularea irurilor, alocarea
memorieiirealizareaoperailordeintrareiieire,suntexecutateprinapelulunor
funcii de bibliotec. Alte sarcini de care am avea nevoie n programe cum ar fi:
crearea de directoare, listarea coninutului acestora, interaciunea cu mouseul,
afiareaferestreloretc.,nusuntdefinitedelimbajulC.Acesteoperaiibinenelesc
pot fi fcute dintrun program C, dar ntrun mod specific mediului de programare
pe care l folosim (mediu pentru dezvoltarea de aplicaii, compilator, procesor,
sistemdeoperare),modcenuestedefinitdestandardulC.
Un alt aspect al limbajului C care trebuie punctat aici este c acest limbaj este unul
periculos, n sensul c limbajul nu ofer programatorului modaliti de protecie
mpotriva erorilor. Dac scriei un program care face (din cauza unei greeli) cu
totulaltcevadectaiintenionat(deexemplutergereadatelordepedisc),idac
compilatorulpoatecompila acelprogram, nuvei priminiciunmesajde avertizare
de genul: Vrei ntradevr s facei asta? sau Suntei sigur c vrei s facei
asta?.Cesteadeseacomparatcuuncuitfoartebineascuit:sepoaterezolvacuel
oproblemcupreciziechirurgical,darnacelaitimpvputeitiacueldegetulcu
o precizie chirurgical. Programatorul este cel care trebuie s utilizeze limbajul cu
grij.

21
3. Traducereaiexecuiaprogramelor
Unlimbajdeprogramareesteuninstrumentcucaresepoateexprimaunprocesde
calcul,rezultndceeacenumimprogramsursnlimbajuldeprogramarerespectiv.
Programul surs reprezint nivelul virtual al abstractizrii problemei de rezolvat.
Pentru ca maina (calculatorul) s poat rezolva problema, aceasta trebuie
exprimat n termenii limbajului mainii respective, adic trebuieatinsnivelulfizic
alabstractizrii,nivelcevafiatinsprinintermediulunuiprocesdetraducere.
Rezolvareauneiproblemecucalculatorulparcurgedoumarifaze:
formalizarea problemei i exprimarea ei ntrun limbaj de programare. n
termeniicicluluideviaaprogramuluirezultat,aicisuntcuprinseetapelede
definire, specificare, analiz, proiectare i implementare. Rezultatul obinut
esteprogramulsurs.naceastfazrolulfactoruluiumanestehotrtor.
traducereaprogramuluisursrezultatdinetapaprecedentntrunprogram
executabil pe calculator i execuia acestuia. Aceast faz este mult mai
automatizat dect prima, recurgnduse la programe de traducere din
limbajuldeprogramarenlimbajulmain.
Specificarea sintaxei unui limbaj de programare

La definirea unui nou limbaj de programare primele aspecte care se discut sunt
cele exterioare ale acestuia, aspectele ce in de sintaxa limbajului. n continuare
vom discuta despre setul de caractere al unui limbaj, despre modalitile de
descriere a lexicului i sintaxei i despre modul n care se realizeaz analiza
sintacticisemanticatextuluiunuiprogramscrisntrunlimbajoarecare.
Descrierea sintaxei i semanticii unui LP o vom face ntrun cadru mai larg fcnd
referirilafazeleprocesuluidetraducerealimbajului.
Setuldecaractere
Fiecare limbaj de programare este bazat pe un anumit alfabet de caractere.
Alfabetul fiecrui limbaj este folosit pentru a construi cuvinte sau simboluri, care
formeaz vocabularul sau lexicul limbajului. Majoritatea limbajelor de programare
ausetuldecaractereformatdin:literelealfabetuluienglez(dealaz26delitere),
cifrelearabe(09),caracterespeciale,acrorsemnificaieestelegatmaimultsau
maipuinderolullorndefiniialimbajului.
SeturiledecaracteremaicunoscuteifolositelaoraactualsuntASCII,ASCIIextins,
EBCDIC, Unicode. O caracteristic important a oricrui alfabet este posibilitatea
ordonriicaractereloracestuia.
Elementelelexicalealeunuilimbaj
Un program este format din atomi lexicali (tokens) i separatori. Un atom lexical
esteceamaimicunitatesintacticceareunnelesdesinestttorntruncontext
precizat.Analizalexicalesteaceafazaprocesuluideanalizaunuiprogramsurs

22
care are ca scop identificarea atomilor lexicali din care este compus programul
respectiv.
Exist urmtoarele categorii de tokeni: simboluri speciale, identificatori, etichete,
literali.
Doi tokeni succesivi trebuie separai de unul sau mai muli separatori. De obicei
separatoriinusuntconsideraitokeni,cutoateceipotfacepartedinconstituenii
unuiliteral.
Deexempluinstruciunea:
if(a>b)x=x+1elsey="Hello!";
conineurmtoriiatomilexicali:
identificatori:if,a,b,x,else,y
simbolurispeciale:(,),>,=,+
literali:1,"Hello!"
Att atomii lexicali ct i separatorii se construiesc din caracterele coninute n
alfabetullimbajului.
Exist dou categorii de separatori: separatorii uzuali, comentariile. Ambele

categoriisuntignoratenprocesuldeanalizlexical.
Separatoriiuzualiservesclaseparareaadoitokeniconsecutivi,fiindnumiinunele
limbaje spaiu alb (white space); n aceast categorie intr caracterele spaiu, tab,
linienou.
Comentariilenuausemnificaiepentruprocesuldecalculspecificatnprogram;ele
servescnumailaobunnelegereatextuluisursdectrecelcarelcitete.Exist
dou maniere de comentare a unui program: linie i text. n limbajul C, C++, C#
comentariul linie ncepe cu combinaia de caractere //, iar comentariul text ncepe
cucombinaia/*isetermincu*/.
Identificatori,cuvintecheieirezervate
Un identificator este o secven arbitrar de litere i cifre din alfabetul limbajului,
dincareprimulcaracterestelitersausemnuldesubliniere.Numruldecaractere
din secven poart numele de lungime a identificatorului. Unele limbaje stabilesc
limite superioare ale acestei lungimi altele las pe seama implementrii aceste
restricii.
Suntlimbajecarefacdistincientreliterelemariimici(suntcasesensitive):C,C++,
Java iar altele care nu fac aceast distincie: Pascal, Modula2, FOTRAN. n C
cuvintelerezervatesescriunumaiculiteremici(if,else,while,foretc.)
Existdoucategoriideidentificatori:
Predefinii: sunt precizai n definiia limbajului i ei se pot mpri n dou
categorii: cuvinte cheie i cuvinte rezervate. Cuvintele cheie au un neles
explicit ntrun context precizat. De ex. cuvintele DO, IF, CONTINUE au o
semnificaie foarte clar cnd sunt folosite ntrun text surs FOTRAN,
semnificaialorrezultnddincontextulncareapar.Elepotfifolositensi

23
ca nume devariabil,frnici unfel de restricie.n altelimbaje cumeste C
acest lucru nu este posibil. Evident, c o astfel de situaie nu este indicat
pentrucpoateducelaconfuziiingreuneaznelegereaprogramului.Spre
deosebire de cuvintele cheie, este interzis folosirea cuvintelor rezervate n
alt scop dect acela pentru care ele sunt definite. n tabelul de mai jos dm
toatecuvintelecheiedinlimbajulC.Avantajeleutilizriicuvintelorrezervate
sunt: programul devine mai uor de neles prin utilizarea lor, se mrete
viteza de compilare (la cutarea n tabela de simboluri, simplificnduse
analiza lexical, sintactic i semantic), este uurat depistarea erorilor.
Dac numrul de cuvinte rezervate al unui limbaj este mare, atunci el nui
maipstreazproprietilebenefice,devenindunbalast.Existenacuvintelor
rezervate nu d un certificat de calitate unui limbaj. n universul de azi al
limbajelor de programare, aceast mprire n cuvinte cheie/rezervate i n
identificatori/cuvinte(cheiesaurezervate)esterelativ.
Definiideutilizator:suntidentificatoricreaideutilizatorpentruafifolosii
ca nume de variabile, constante, proceduri, funcii, clase, obiecte, tipuri de
datedefinitedeutilizator,metode,proprieti,evenimente,delegaietc.
auto break case char const continue default do

double else enum extern float for goto if
int long register return short signed sizeof static
struct switch typedef union unsigned void volatile while
CuvintelecheieC
Simbolurispeciale
Lafelcaicuvintelerezervate,simbolurilespeciale(numiteuneoriioperatorisau
semne de punctuaie, delimitatori) au o semantic bine precizat. n unele limbaje
elesepotfolosidoarconformdefiniieilor,naltelesemanticasepoateextinde,prin
ceeacesenumetesuprancrcareaoperatorilor.
SimbolurilespecialenCsunt:
Operatorisausemnedepunctuaie:!%^&*()+={}|~[]\;:<>?,./
Operatori(fiecareconsideratunsingurtoken):>++<<>><=>===!=&&
||*=/=%=+==<<=>>=&=^=|=
Tokenifolosiidepreprocesor:#
Literali
Prin literal vom nelege o valoare constant de tip numeric sau caracter. Literalii,
numiidemulteoriiconstantesepotmprin:
Constantenumerice(ntregiireale)

24
Constantecaracter
Constanteirdecaractere
Trebuie fcut distincie ntre conceptul de constant (n sensul de literal) i
constantsimbolic.Deasemeneatrebuiefcutdistincientretermenuldeliterali
celdeidentificator.Termenulconsacratdeliteralpentruvalorileconstantearputea
proveni de la adlitteram, adic are semnificaia unei valori precizate explicit. O
definiie mai elaborat afirm c literalii exprim valori constante ale tipurilor de
baz(numericeicaracter).
Vom prezenta n continuare categoriile de literali din limbajul C (folosim notaia
BNF).
Literal::= constantntreag| constantcaracter| constantflotant| literal ir de

caractere
Constant ntreag: este format din iruri de cifre.Sunt recunoscute trei convenii
de reprezentare: zecimal (dac nu ncepe cu 0), octal (dac ncepe cu 0) i
hexazecimal (dac ncepe cu 0x sau 0X). Tipul constantelor ntregi depinde de
forma,valoareaisufixulacestora(i,I,u,U).
Constant caracter: este format din unul sau mai multe caractere incluse ntre
apostroafe. Pentru un caracter, tipul constantei este char, iar valoarea lui este
valoarea codului ASCII al caracterului; dac sunt mai multe caractere, tipul
constanteiesteint,iarvaloareaacesteiadepindedeimplementare.Existconstante
caracter predefinite, care se precizeaz cu ajutorul unor secvene escape (secvene
deevitareprecedatedecaracterulbackslash\):
CaracterASCII secvenaescape
NLnewline \n
HTtaborizontal \t
VTtabvertical \v
BSbcackspace \b
CRcarriagereturn \r
FFformfeed \f
BELbell \a
\ \\
? \?
\
nr.octal \ooo
nr.hexa \xhhh
Constantele reale: sunt compuse din: parte ntreag, marc zecimal, parte
fracionar, marc exponent (e sau E) i exponent ntreg cu semn. Tipul lor este
implicitdouble,carepoatefimodificatprintrunsufix(Fsauffloat,Lsaullong
double). Partea ntreag sau partea fracionar pot lipsi (dar nu ambele), la fel pot
lipsiimarcazecimalsaumarcaexponenial(nuambele).

25
Constanteleirdecaractere:suntformatedintrunulsaumaimultecaractereincluse
ntre ghilimele. Tipul lor este char[] i au clasa de memorie static. Reprezentarea
unuiirdecaracteresefacepen+1octei,ultimuloctetconinndcaracterulNULL
(cu codul ASCII 0). Constantele ir de caractere se mai numesc nullterminated
strings.
Sintaxaunuilimbajdeprogramare
La fel ca n orice limb, i n limbajele de programare, succesiunile de cuvinte
formeaz propoziii sau instruciuni. Prin sintaxa unui limbaj de programare se
nelege un ansamblu de reguli prin care se determin dac o anumit instruciune
estecorectalctuitsaunu.
Conceptuldesintaxaparesubdouforme:
Sintax abstract: identific rolul componentelor fiecrei construcii;
descrierile de limbaj i implementrile sunt organizate n jurul sintaxei
abstracte.
Sintaxa concret (lexical): prezint modul de scriere a construciilor
limbajului,coninnddetaliirelativlaplasareacuvintelorcheieiasemnelor
depunctuaie.
Spreexemplu,aceeaisintaxabstractstlabazasecveneideprogram:
WHILEx<>A[i]DO
i:=i1
END
ScrisnModula2,precumiaurmtoareisecveneC:
while(x!=A[i])i=i1;
Existdiversemoduriprincaresepoatedescriesintaxaunuilimbajdeprogramare:
BNF,grafeledesintax,gramaticiiautomateetc.
BNF (BackusNaur Form = notaia BackusNaur) a aprut n 1963 n cadrul

raportuluiALGOL60.
nraportulALGOL60instruciuneaforeradefinitnfelulurmtor:
<instr.for>::=<clauzfor>|<etichet>|<instr.for>
<clauzfor>::=for<variabil>:=<listfor>do
<listfor>::=<elementdelistfor>|<listfor>,<elementdelistfor>
<elementdelistfor>::=<expr.aritmetic>|
<expr.aritmetic>step<expr.aritmetic>
until<expr.aritmetic>|

26
<expr.aritmetic>while<expr.bool>
Simbolurile <, >, |, :: fac parte din mecanismul de descriere a limbajului, ele fiind
numitemetasimboluri.Simbolul::=nseamnsedefineteastfel.Cuvintelefor,do,
step, until, while, precum i caracterele {, :=, :, }, care apar n producii, se numesc
simboluriterminale,pecnd<instr.for>,<clauzfor>suntsimbolurineterminale.n
orice producie, la stnga metasimbolului ::= apare un neterminal, iar definiia
acestuiaesteolistdeneterminale,terminaleimetasimboluri.
Conform primei producii, instruciunea for are dou definiii alternative, separate
prin |. Aceast producie utilizeaz ideea definirii recursive n a doua alternativ,
deoarece <instr. for> este definit prin ea nsi. nelesul definiiei este c o
instruciune for poate s nu aib etichet sau poate s aib un umr variabil de
etichete,fiecareterminatprin:(doupuncte).
Neterminalul <clauza for> este definit astfel: ncepe cu simbolul terminal for, care
este cuvnt rezervat n ALGOL 60, urmat de o <variabil>, :=, o <list for> i
cuvntul rezervat do. Definiia neterminalului <lista for> utilizeaz de asemenea
recursivitatea (recursivitate la stnga), cu efectul c o <lista for> poate conine de
mai multe ori neterminalul <element de lista for>, folosind virgula ca separator.
Ultimaproducieexpliciteaztreimoduridealctuireaelementelorlisteifor.
Dea lungul timpului notaia BNF a suferit unele adugiri ajungnduse la ora
actuallautilizareauneiaanumitenotaiiBNFextinse.
Noileregulialeacesteinotaiisunt:
Toate unitile sintactice ale limbajului sunt cuprinse ntre ghilimele; de
exemplu,"<"desemneazsemnulmaimicinumetasimbolul<
Entitileopionalesuntcuprinsentreparantezeledrepte[i].
Orice expresie repetabil (cu semnificaia c poate apare de zero sau mai
multeori)estecuprinsntreaccolade
Parantezele rotunde se folosesc n situaiile n care se dorete exprimarea
unor grupri de aciuni: de exemplu (a | b) c desemneaz irul de
caractere"ab"sau"bc".
Gramatici
NoamChomskyadezvoltatteoriagramaticilor(1959).Cuajutorulacestorapoatefi
formalizatdefiniiaunuilimbaj,formalizareceseimpunepentruunstudiuintegrat
i complet al proiectrii i implementrii limbajelor. Limbajele independente de
context (generate de gramatici independente de context GIC) pot modela formal
limbajele de programare. BNF i gramaticile independente de context sunt
echivalentedinpunctuldevederealdescrieriiunuilimbajdeprogramare.
Grafeledesintax
O alt metod de descriere a sintaxei unui limbaj de programare utilizeaz grafele
de sintax, echivalente cu BNF (deci i cu GIC), dar mai sugestive. Regulile de

27
definireagrafelordesintaxaufostintrodusedeNiklausWirth(1976).Camodde
reprezentare,grafeledesintaxutilizeaz:
Cerculpentrureprezentareaunuisimbolterminal
Dreptunghiulpentrureprezentareaunuisimbolneterminal
Sgeatapentruareprezentadireciatransformrii
OproduciedeformaA::=a1a2ansetranscriedupcumurmeaz:
OproduciecumaimultealternativeA::=a
1
|a
2
||a
n
setranscrieastfel:
Oregulrecursiv{A::=a
1
}
setranscrie:
Un automat de acceptare (sau de recunoatere) este folosit pentru a rspunde la

ntrebarea:aparineunirxlimbajuluiLsaunu?
Automatul este definit ca o main cu operaii extrem de simple, care primete
iruldeanalizatpeunsuportoarecare(numitbanddeintrare),lparcurgefolosind
un cap de citire i rspunsul final este dat de starea n care rmne unitatea de
comand a automatului. Maina poate folosi o memorie auxiliar pentru pstrarea
unor informaii care so ajute n luarea de decizii la un moment dat. Funcionarea
unitii centrale (evoluia) este o secven de micri, o micare constnd dintro
modificare a configuraiei mainii. Prin configuraie se nelege ansamblul strilor
componenteloracesteia.
a
1

a
2

a
n

a
1
a
2
a
n
a
1


28
Modelul fizic descris mai sus este intuitiv, el stnd la baza modelului matematic al
automatului, model necesar pentru formalizarea funcionrii mainii i deci pentru
fundamentareaalgoritmilordeanalizimplementaicuajutorulacesteia.
Automateleseclasificndeterministeinedeterministe.Existoseriedetipuride
automate: automat finit determinist, automat finit nedeterminsit, automat push
down determinist, automat pushdown nedeterminist etc. Exist o relaie ntre
limbajeleacceptatedeautomateigramaticiledinierarhialuiChomsky.
Automatele de acceptare se folosesc n analizoarele lexicale i semantice ale
programelordetraducere.
Traducerea programelor
Programe traductor
Prin translator vom nelege un program ce traduce un program surs (PS), scris
ntrunanumitlimbajdeprogramare(LP)ntrunprogramechivalentexprimatntr
un alt limbaj, pe care l vom numi program destinaie (PD). Familia programelor
translatoare are ca reprezentani compilatoarele, asambloarele i interpretoarele.
Pentru un compilator, PD se numete program obiect sau cod obiect, fiind apropiat
de codul main, iar asamblorul este compilatorul unui limbaj de asamblare. n
ambele situaii, traducerea este urmat de obicei de editarea de legturi (link
editarea), nainte ca programul s poat fi executat. Linkeditarea este faza n care
se produce codul executabil prin legarea codului obiect (rezultat din traducere) cu
altemoduleobiect(rezultatedincompilrianterioaresauexistentenbiblioteci).O
alt modalitate de execuie a PS scrise n limbaje de nivel nalt este folosirea unui
interpretor, care este tot un translator ce realizeaz execuia instruciune cu
instruciuneaprogramuluisurs.
npracticsentlnescialtetipurideprogramtranslatoare:
Preprocesoarele sau macroprocesoarele: traduc PS din limbaje de nivel nalt n PD
scrisetotnlimbajedenivelnalt,compilabile.Deex.preprocesorulC.
Crosscompilatoarelesaucrossasambloarele:seexecutpeuncalculatorgazdi
genereaz cod obiect pentru o alt main obiect (de exemplu, maina gazd
minicalculator sau calculator mare, iar maina obiect este un microcalculator cu
memoriemic,pecarenusepoateimplementaprogramuldetraducere).
Generatoareledeprograme:pleacdelaunPSscrisntrunlimbajdespecificarei
genereazprogramesursscrisendiverselimbajedeprogramaredenivelnalt.
Schema general a unui compilator

Compilatorul este un program complex, a crui realizare presupune abordarea
sistematicaprocesuluidetraducere.nprocesuldecompilare,PSsuferunirde

29
transformrin cascad,dincence maiapropiate decodulobiect.Conceptual,un
compilatorrealizeazdoumariclasedeoperaii:
Analizatextuluisurs
Sintezacoduluiobiect
Acestedouoperaiisedescompunnsuboperaiispecializate,nlnuitentreelei
caracterizate prin funcii bine precizate. n figura de mai jos prezentm schematic
structuraunuicompilator.
Figur:Structuraunuicompilator
Analiza lexical realizeaz prima parcurgere a PS (considerat ca ir de caractere),

grupnd aceste caractere n subiruri, numite atomi lexicali: cuvinte cheie sau
rezervate,operatori,constante,identificatori,separatori.
Analiza sintactic depisteaz n irul atomilor lexicali structuri sintactice: expresii,
liste, instruciuni, proceduri, genernd arborele sintactic (arborele de derivare),
caredescrierelaiiledintreacestestructuri(deincluziune,deseparare).
Analiza semantic folosete arborele sintactic pentru extragerea de informaii
privind apariiile obiectelor purttoare de date din PS (tipuri de date, variabile,
proceduri, funcii) i pentru verificarea consistenei utilizrii lor. Pe msura
parcurgerii arborelui sintactic, se genereaz codul intermediar. Acesta este un i de
instruciunisimple,cuformatfix,ncare:codurileoperaiilorsuntasemntoarecu
codurilemaincorespunztoare,ordineaoperaiilorrespectordineaexecuiei,iar
operanziisuntreprezentaisubformavariabilelordinPSinusubformderegistre
sauadresedememorie.
Optimizarea codului intermediar are ca obiectiv eliminarea redundanelor, a
calculelorinutile,nscopulrealizriiuneiexecuiieficienteacoduluiobiect.Pentru
realizareaacestuiobiectivsencearc:
Realizareatuturorcalculelorposibilencdinfazadecompilare(deexemplu
nexpresiicuoperanziconstante)
Analiz
lexical
Analiz
sintactic
Analiz
semantic
Optimizare
de cod
Generare
de cod
ANALIZ SINTEZ
Program
surs
ir de atomi
lexicali
Arbore
sintactic
Cod
intermediar
Cod intermediar
optimizat
Tratarea erorilor Gestiunea tabelelor
Cod obiect

30
Eliminareasubexpresiilorcomune(prinevaluarealorosingurdat)
Factorizareainvariaiilordincicluri.
Generarea programului (codului) obiect const n alocarea de locaii de memorie i
registre ale unitii centrale pentru variabilele programului i nlocuirea codurilor
deoperaiidincodulintermediarcucelemain.Codulobiectrezultatpoatefi:
absolut(directexecutabil)
relocabil (care va face obiectul editrii de legturi, unde va fi legat de alte
moduleobiect,rezultatedincompilrianterioaresaudinbiblioteci);
n limbaj de asamblare, lucru ce asigur un efort mic de implementare a
generatoruluidecod.
naltlimbajdeprogramare,ncazulpreprocesoarelor.
Generareadecoddifernfunciedearhitecturamainii.
Cele cinci module de baz ale procesului de compilare sunt asistate de alte dou
componente ale compilatorului, ale cror servicii sunt utilizate pe tot parcursul
compilrii:modululdetratareaerorilorigestionarultabeleidesimboluri.
Modulul de tratare a erorilor este constituit dintro colecie de proceduri care sunt
activate ori de cte ori este detectat o eroare n timpul operaiilor de analiz. Ele
emitmesajedediagnosticrelativelaeroarearespectiviiaudeciziiprivindmodul
decontinuareatraducerii:
traducereasecontinucuignorareaelementuluiceconineeroarea;
sencearccorectareaerorii
seabandoneazprocesuldetraducere.
Dup momentul de analiz n care apar, erorile pot fi lexicale, sintactice sau
semantice. Un alt criteriu de clasificare a erorilor este gravitatea lor; distingem
avertismente (de obicei omisiuni de programare), erori care se pot corecta de
ctre un compilator mai inteligent i erori fatale, care provoac abandonarea
procesuluidecompilare.
Gestionarul tabelelor este o colecie de proceduri care realizeaz crearea i
actualizarea bazei de date a compilatorului, care conine dou categorii de
informaii:
proprii compilatorului (generate la implementare i constituite din
mecanismelededescriereaanalizeilexicale,sintacticeisemantice)
caracteristice programului surs (identificatori, constante, cuvinte cheie),
caredeobiceisememoreazntrotabeldesimboluri.
n faza de analiz lexical (de obicei) la ntlnirea unui nume nou, acesta este
introdusntabeladesimboluri,reinnduseadresaintrrii.Oridecteorinumele
estereferit,informaiaprezentntabelesteactualizatcuinformaiisauatribute
noi ale numelui respectiv, verificnduse totodat consistena utilizrii acestuia
(analiza semantic). La generare de cod, atributele numelui determin lungimea
zoneidememoriealocatacestuia.Atributelenumeluipotserviinfazadetratare
aerorilor.

31
Analiza
Faza de analiz cuprinde trei etape: analiza lexical, sintactic i semantic. Aceste
treietapesepotimplementaseparatsauglobal.
Analizalexical(scanningnengl.,analizorlexical=scanner)transformprogramul
surs (considerat ir de caractere) ntrun ir de uniti lexicale, numite atomi
lexicali sau particule lexicale (tokens n engl.). Clasele de atomi lexicali, considerate
ca mulimi finite, corespund identificatorilor, constantelor ntregi, constantelor
reale i operatorilor. Pe scurt, analizorul lexical realizeaz operaii de detectare,
clasificareitraducere:
detectarea n PS a subirurilor care respect regulile de formare a atomilor
lexicali;
clasificareaacestorsubiruri(identificareaclaseiacestora);
traducereasubirurilornatomilexicali;
memorareantabeladesimboluriaidentificatoriloriconstantelor.
Deobicei,analizalexicalesteconsideratcaoetapaanalizeisintactice.Analizorul
lexicalcontribuielacurareaPSdeoarecenumrulatomilorlexicaliestemaimic
dectnumruldecaracteredinPS,seeliminspaiilealbesi comentariile,sepoate
prelua n analiza lexical evaluarea unor construcii dificil de implementat n
analizorulsintactic,rezultatulfiindreducereacomplexitiianalizeisintactice.
Analizasintactic(parsingnengl.)esteunadinetapeleprincipalealeprocesuluide
traducere. Prin ea se realizeaz transformarea irului de intrare (format din atomi
lexicali)n:
descriereastructuralaacestuia,semanticechivalent(ncazulncareirul
deintrareestecorectsintactic)
mesajdeeroare(ncazcontrar).
Analiza semantic structura sintactic poate fi folosit pentru specificarea

semanticii unui limbaj. n general, semantica (nelesul) unei construcii poate fi
exprimatprinoricecantitatesaumulimedecantitiasociateaceleiconstrucii.O
astfel de cantitate asociat se numete atribut. Ca exemple de atribute putem
meniona:omulimedeiruridecaractere,ovaloare,untip,oconfiguraiespecific
de memorie etc. Aceast modalitate de abordare a semanticii se numete orientat
de sintax. Regulile care definesc atributele unei construcii se numesc reguli
semantice. O specificare de sintax mpreun cu regulile semantice asociate
realizeazodefiniieorientatdesintax.
De exemplu, dac dezvoltm un evaluator de expresii, semantica expresiei 2+3
poatefiexprimatprinvaloarea5.Dacdezvoltmuntranslatordinformainfixat
n form postfixat semantica expresiei 2+3 ar putea fi exprimat sub forma
tripletului(+23).

32
Conceputcaofinalizareaetapeideanalizatextuluisurs(pringenerareacodului
intermediar), analiza semantic completeaz structurile sintactice cu valorile
atributelor asociate fiecrei componente de structur. Cunoscnduse valorile
atributelor,serealizeaz:
validareasemanticaprogramuluisurs;
generareacoduluiintermediarechivalent;
naceastultimfazaanalizeisegenereazcodulintermediar.npractic,analiza
semanticsedesfoarnparalelcuanalizasintactic,princompletareaaciunilor
analizorului sintactic cu aciuni referitoarea la anumite structuri de date ce
reprezintatributealecomponentelorsintactice.
Uniti de program
Structurageneralaunuiprogramscrisntrunlimbajdeprogramareconvenional
(imperativ, dirijat de control) presupune existena unui program principal i
eventual a unuia sau mai multor subprograme (proceduri, funcii sau subrutine)
carecomunicntreelei/saucuprogramulprincipalprinintermediulparametrilor
i/sauaunorvariabileglobale.
Orice program sau subprogram surs, indiferent de limbajul n care este scris i
indiferent de sintaxa concret a acestuia este divizat n dou pri (nu neaprat
distincte din punct de vedere fizic): partea de declaraii i partea imperativ.
Declaraiile, denumite uneori i instruciuni neexecutabile sunt informaii
descriptiveadresatecompilatoruluicaredescriunprincipalatributealezonelorde
datecumarfitipul,dimensiuneadereprezentare,eventualvaloriiniialeetc.Partea
imperativ conine instruciunile ce se vor executa n cursul rulrii
(sub)programului.
Ideea reutilizrii codului precum i cea a reducerii dificultilor de proiectare i
ntreinere a programelor mari au condus n mod natural la modularizarea
dezvoltriiprogramelor.Corespunztor,carezultatalprocesuluideabstractizarei
factorizare, apar astfel la nivelul programelor, uniti de program distincte, numite
module, cu rol bine precizat i care aduc odat cu apariia lor numeroase avantaje.
Unuldincelemaiimportanteavantajeestecompilareaseparat.
n majoritatea cazurilor activitile efectuate de subprograme sunt independente.
Astfel, unul sau mai multe subprograme pot fi grupate n module, care, fiind la
rndullorindependentepotficompilateseparatunuldecellalt,adiclamomente
diferite n timp i combinate mai trziu de ctre editorul de legturi ntrun unic
programexecutabil.Caurmare,dacunmodulnecesitmodificriicelelaltenu,va
firecompilatdoarmodululmodificat,editoruldelegturirealizndapoicombinarea
codului obiect rezultat cu versiunile deja compilate ale celorlalte module. Se
economisete n acest fel un timp semnificativ de lucru, ideea compilrii separate
fiindextremdeutillantreinereabibliotecilormarideprograme.

33
LimbajulCpermitecompilareaseparat,lucruposibildatoritexisteneiatributului
clasdememorieexternpentruvariabileleC,ceeacepermiteexistenamodulelorn
limbajulC.Acestemodulepotcomunicaprinvariabileleexterne.
Prinmodulvomnelegeounitatesintacticcenglobeazproceduri,tipuridedate,
constanteivariabile.Dinpunctuldevederealutilizriisalemodulularedoumari
pri: interfaa i implementarea. Fiind proiectat de la nceput n ideea reutilizrii,
modululspecific,prininterfaasa,aceleentitiprincareelcomuniccuexteriorul
su (cu alte module sau programe). n partea de implementare a modulului se
definesc procedurile declarate n interfa i sunt precizate alte entiti locale
necesareimplementrii.
Informaia din interfa este necesar procesului de compilare: spre exemplu,
compilare unui modul A care are nevoie de servicii din modulul B va necesita
cunoaterea i includerea n codul obiect rezultat a informaiei din interfaa
modulului B (declaraii de tipuri, proceduri, variabile i constante), care va trebui
deci s fiecompilatnainte.Exempledemodule arfiunituriledinTurboPascal sau
fiiereleheaderifiiereledeimplementaredinC.
Link-editarea
Linkeditorul sau editorul de legturi este o component a mediului pentru
dezvoltarea de aplicaii care grupeaz unul sau mai multe module obiect, rezultate
din compilare sau asamblare, mpreun cu subprograme de servicii din diverse
biblioteci,ntrunprogramexecutabil.
ngeneral,unprogramexecutabilestecompusdinmaimultesegmente.Editorulde
legturioferposibilitateacadousaumaimultesegmentediferitealeunuiacelai
program s poat ocupa n execuie, la momente diferite de timp, aceeai zon de
memorie(procesnumitesegmentareoverlay),proprietatefoarteutilncontextul
rulrii de programe foarte mari care depesc capacitatea memoriei RAM
disponibile.
Pe de alt parte, linkeditarea ntro aceeai comand a mai multor fiiere obiect va
avea ca rezultat un singur fiier executabil ce va fi alocat ntro zon contigu de
memorie.Laacestnivel(aleditriilegturilor)arelocoprimajustare(relocare)a
adreselor din modulele obiect, ajustare care s reflecte raportarea tuturor acestora
lanceputulfiieruluiexecutabil.
Deoarece un program executabil poate fi ncrcat n majoritatea cazurilor la orice
adresdesegment,pentruoexecuiecorectestenecesarcalancrcaressefac
o relocare a majoritii referinelor din program. Relocarea este efectuat la
lansarea n execuie a programului de ctre o component a sistemului de operare
numitncrctordeprograme(loader)icarearenprincipiuurmtoarelesarcini:
citireaunuiprogramexecutabildepeunanumitsuport;
ncrcareaprogramuluirespectivnmemorie;
lansarealuinexecuie.

34
Execuia programelor
Dup linkeditare, programul executabil obinut se poate lansa n execuie. Exist
diferene n ceea ce privete execuia unui astfel de program, n funcie de
caracteristicile de utilizare ale sistemului de operare al calculatorului gazd i de
mediul de programare folosit pentru scrierea de programe. Pornind de la un text
(program) surs, programatorul are la dispoziie trei opiuni pentru a ajunge la
execuiaacestuia:
operare la nivelul liniei de comand: se introduc pe rnd comenzile de
compilare,linkeditareilansarenexecuie;
asistat de un mediu de programare: comenzile de mai sus sunt lansate i
executatedininteriorulunuiastfeldemediu;
sistembatch(prelucrarenloturi):scriereaunorfiieredecomenzicarevor
automatizanlnuireafazelordelapunctul1.
ntrun sistem de operare interactiv, utilizatorul comunic cu sistemul de operare
de la terminalul su propriu printrun limbaj de comenzi sau printro interfa
vizual.ncazulinterfeelorutilizatorvizuale,peecranulterminaluluisuntdesenate
elemente vizuale sugestive (iconuri). Exemple sugestive sunt Microsoft Windows
sauXWindows.Fiecareiconareasociatocomand,careesteactivatnmomentul
cnd utilizatorul acioneaz asupra iconului cu mouseul. Orice comand tastat
sau asociat unui icon este preluat de interpretorul de comenzi al sistemului de
operare,careotraduceioexecut(dacesteocomandcorect).
Unsistemdeoperareinteractivaredoumariclasedecomenzi:interne(engl.built
in) i externe. Comenzile interne sunt rezidente n nucleul sistemului de operare
respectiv, iar comenzile externe, dup cum le arat i numele, au corespondent n
fiiere executabile. ntre comenzile externe, un loc aparte revine comenzilor
utilizator, crora le corespund fiierele executabile proprii ale utilizatorului, fiiere
realizateprinprocesuldecompilarelinkeditare.Fiiereleexecutabilerealizatede
utilizator sunt noi comenzi care extind limbajul de comenzi al sistemului su de
calcul.Sistemuldeoperarealunuicalculatormodernestenacestsensunexemplu
adecvatdeextensibilitateasoftului.
Sistemele de operare moderne permit rularea concomitent (n paralel) a mai
multor programe proprietate numit multitasking. Aceste programe pot fi
independente sau nu i ocup zone de memorie distincte. Sistemele multitasking
sunt implementate n principal pe sisteme monoprocesor, ceea ce pune problema
alocrii timpului CPU aplicaiilor ce se ruleaz. Din acest punct de vedere
multitaskingul poate fi preemptiv sau cooperativ. n cazul multitaskingului
preemptiv sistemul de operare ia decizia ntreruperii aplicaiei curente (pe baza
unor algoritmi de planificare) indiferent de stadiul i dorina acesteia. Exemplu
clasicnacestsensnconstituiesistemuldeoperareUnix.Multitaskingulcooperativ

35
adopt varianta ca aplicaia curent s semnaleze faptul c poate fi ntrerupt.
SistemulWindowsaparineacesteiultimecategorii.
Medii de programare i execuie

Mediile de programare sunt componente complexe destinate activitii de
dezvoltare de programe. Relativ la un limbaj, un astfel de produs soft nglobeaz
urmtoarele subcomponente: editor de texte, compilator interactiv, compilator
serial, editor de legturi, interpretor pentru execuia rezultatului compilrii (numit
i mediu de execuie runtime environment), depanator simbolic, componente de
legturcumediulexterior(deregulcusistemuldeoperarecucarelucreaz).
Medii de programare mai cunoscute i mai rspndite sunt: Visual Studio de la
Microsoft,BuilderdelaBorland,Eclipseialtele.
Conceptul de program executabil a evoluat dea lungul timpului de la aplicaii
monolitsaajunslaaplicaiiintegrate,caresuntconstituitedinmoduleexecutabile
ce se ncarc dinamic n execuie, n funcie de nevoile curente. De exemplu, o
aplicaieWindowspoaterecurgelancrcareadinamic(laexecuie)aunorfuncii
din biblioteci cu legare dinamic (DLL Dynamic Link Librarie), lucru complet
transparentpentruutilizator.
Interpretarea
Esteoactivitateprincareseexecutpeuncalculator(realsauomainvirtual)un
program scris ntrun limbaj surs. Interpretorul este un program care execut pas
cu pas instruciunile descrise n limbajul respectiv. Viteza de interpretare a unui
program este mult mai mic dect execuia codului generat de ctre un compilator
pentru acelai program. Cu toate c aceast vitez este cam de 10 ori mai mic,
interpretarea este folosit pe scar larg datorit implementrii mult mai simple a
unuiinterpretordectaunuicompilator.Unaltavantajestefaptulcinterpretarea
asiguromultmaimareflexibilitateaexecuiei,nsensulposibilitiideefectuarea
mai multor verificri dinamice (la execuie), de urmrire a evoluiei valorilor
variabilelor n cursul etapelor de execuie, posibiliti de colaborare cu utilizatorul
ntimpulexecuieietc.

36
4. Declaraii
Rolul identificatorilor ntr-un program
Identificatoriiservesccanumepentrudiverseentitialeunuiprogram:
constantesimbolice
tipuridedate
variabile
subprograme
module
programe
cmpurinnregistrri
Daclimbajuldeprogramareoferunsistemdenotaiigeneralepentruexprimarea
unuiprocesdecalcul,iarunprogramsursesteconcretizareaunuiastfeldeproces
de calcul, identificatorii folosii de programator n respectivul program vor reflecta
particularitile algoritmului descris (constantele necesare, tipurile de date
utilizator introduse, variabilele care pstreaz date de intrare, rezultate
intermediareifinaleisubprogramelecarecorespundsubalgoritmiloretc.)
ntrun sens mai larg, identificatorii declarai i folosii de programator constituie
un sistem de notaii: odat declarat, identificatorul va referi unic o anume entitate
din program i simpla prezen a numelui su (nsoit eventual de alte elemente
suplimentare) va reprezenta pentru programul traductor o referire neambigu la
entitateancauz.
npridiferitealeaceluiaiprogramsurssaunmodulediferitecareconcurprin
compunerelaalctuireaunuiprogramexecutabilsepotfolosiidentificatoriidentici.
Rezolvarea eventualelor conflicte de nume care pot apare se face pe baza regulilor
devizibilitateanumelor.
Noiunea de domeniu de vizibilitate (engl. scope) a aprut odat cu limbajele cu
structur de bloc. Fiecare declarare a unui nume stabilete domeniul de vizibilitate
al numelui. Domeniul de vizibilitate ncepe de obicei imediat dup punctul de
declararealnumeluirespectivisencheielasfritulblocului,procedurii,fiierului
surs etc., dup caz. Un nume local, declarat n interiorul unui subprogram are
domeniuldevizibilitatetoatsecvenadedeclaraiiiinstruciunideduppunctul
de declarare i pn la sfritul subprogramului respectiv (inclusiv blocurile sau
subprogramelenglobatenelincarenusaredeclaratnumelerespectiv);pentru
numele globale declarate n corpul programului principal, domeniul de vizibilitate
ine de dup punctul de declarare pn la sfritul fiierului surs (cu respectarea
observaieianterioarenlegturcuredeclararea).
Definiia de mai sus se refer la domeniul de vizibilitate lexical. Din observaiile
fcute,rezult cacestdomeniunuesteneaprat continuu, c nelpotaparepete
albepentruunnume.

37
Universulunuilimbajdeprogramare(ULP)esteconstituitdinobiectelespecificepe
care limbajul le pune la dispoziia programatorului pentru modelarea problemelor
sale. Prin acesteobiecte, utilizatorul simuleaz comportamentulobiectelor sale sau
realizeaz noi obiecte, mai complexe, cu proprieti noi. Odat cu aceste obiecte,
care sunt specificate prin declaraii, limbajul pune la dispoziia programatorului
operaiiasupraacestora,pecarelenumimdeobiceiinstruciuni.
Semantica unei declaraii
Obiectele ULP sunt datele, fie elementare, fie structurate. Aceste date au anumite
caracteristici (nume, tip, valoare, modificabilitate) care sunt precizate prin
declaraii.
UneiconstantesimboliceiseasociazprintrodeclaraieunobiectdinULP,acelai
petotparcursulexecuieiprogramului.Ovariabilareasociatolocaiedememorie
care poate, la un moment dat, s conin un obiect dintro mulime de obiecte
(valori posibile) din ULP. Aceast mulime formeaz domeniul de definiie al
variabilei, fiind de fapt domeniul tipului variabilei, iar locaia de memorie este
neleasnsensuldepoziiadelacarencepealocareavariabileirespective.
Precizareatipuluipentruconstanteivariabilesefaceprindeclaraii.Informaiade
tipasociatunuiobiectserveteladeterminareagameideoperaiicaresepotface
cuacelobiect.
Limbajeledeprogramaremodernepermitdeclarareadenoitipuri,pebazatipurilor
dejacunoscute.Astfeldetipurisenumesctipuriderivateiseprecizeazcuajutorul
declaraiilor de tipuri. n cazul ideal, un tip de date definit de utilizator are acelai
statut ca i un tip de date predefinit: declararea i folosirea variabilelor, precum i
verificareaconsisteneiexpresiilorrespectivelortipurisefacenaceeaimanier.
Declaraii de constante
Spre deosebire de variabile, constantele simbolice (numite n continuare constante)
i pstreaz valoarea pe tot parcursul execuiei unui program. Utilizarea lor
permite o mai uoar scriere a programelor i le asigur acestora o mai mare
expresivitate.Deexemplu,esteconvenabilssescrie:
PI:=3.1415
ntrun program care face calcule trigonometrice i peste tot n program unde ar
trebuissescrieconstantareal3.1415sevapunePI.Rostulacestorconstanteeste
nunumaiuurinanexprimareinnelegereatextuluisurs,ciiasigurareaunei
maimariflexibilitiaprogramului.Deexemplu,dacnuestesuficientfolosirealui
PIcupatruzecimaleisedoretePIcu12zecimaleexacte,doarliniadeiniializare
aconstanteisevaschimba:
PI:=3.141592653595

38
iarreferirilelaPIdinprogramvornsemnafolosireanoiivaloripentruacestnumr
transcendent.
nmodnormal,nlocuireaconstanteisimbolicecuvaloareasaareloclacompilare.
Din punctul de vedere al unui limbaj de programare, o constant simbolic este un
cuplu format din nume i valoarea asociat. Nu toate limbajele de programare
suport constante (FORTRAN, PL/1, Basic, C nu posed acest obiect n universul
lor).Pentru limbajelece suportacestconcept(Pascal, C++,C#), sepot distingecel
puinurmtoareleclasededeciziecetrebuiediscutateiadoptatelaproiectare.
cumsefacedeclaraiadeconstant?
limbajul admite numai constante de tipuri simple sau este permis i
folosireaconstantelordetipuristructurate?
valoareaconstanteisedprintrunliteralsauprintroexpresieevaluabil(i
cnd:lacompilaresaulaexecuie)?
cnd se face substituirea numelui constantei cu valoarea asociat (la
compilaresaulaexecuie)?
admitelimbajulconstantepredefinite?
Limbajul C nu posed conceptul de constant simbolic. Folosirea constantelor se
simuleaz prin macrodefiniii, care sunt tratate de preprocesorul C. Din punctul
nostru de vedere, dezavantajul major al folosirii macrodefiniiilor este acela c
pentru ele nu sunt valabile regulile de vizibilitate ale numelor din C. Chiar dac se
pot simula constante prin macrodefiniii, numele acestora vor fi globale. De
exemplu,primadintremacrodefiniiile:
#defineTBLSIZE100
#defineTBLMAX(TBLSIZE1)
vaasociaidentificatoruluiTBLSIZEvaloarea100,iaradouamacrodefiniievaasocia
identificatoruluiTBLMAXvaloarea99.Dacacesteasuntsingurelemacrodefiniii,n
ntreg textul surs parcurs de preprocesor, apariiile acestor identificatori vor fi
nlocuite (textual) cu valorile asociate lor. Dac ns ntro funcie ulterioar ar
apreamacrodefinia
#defineTBLSIZE50
identificatorulTBLSIZEvaprimivaloarea50,cucaresevanlocuioriceapariiealui
din acel loc, nu numai din corpul funciei, ci i dup terminarea acesteia. Analog, la
determinareavaloriiluiTBLMAXsevafolosivaloareaactualaluiTBLSIZE.
Un alt dezavantaj al simulrii constantelor prin macrodefiniii este acela c nu se
poate declara tipul constantei i, dac parantezele nu sunt puse corect, pot apare
probleme legate de interpretarea macrodefiniiei. Mai mult expresiile de definire
trebuie evaluate la fiecare ntlnire a numelui macroului, nume care se pierde n

39
fazademacroexpandaredelacompilareinumaipoatefiregsitdedepanatoarele
simbolicesaudealteinstrumentefolositeladezvoltareadeprograme.
C++introduceconstantele(deoricetip),prindeclaraiideforma:
constintTBLSIZE=100;
constintTBLMAX=(TBLSIZE1);
Declaraia de constant este deci prefixat de cuvntul rezervat const. Ea conine

precizarea tipului, numelui i a valorii asociate constantei, printrun iniializator.
Tablourile, pointerii i referinele const au o interpretare special. Dac un tablou
este declarat const nseamn c fiecare element al acestuia este const, iar un
pointerconstnseamncvariabilareferitdeelesteconst.
n termenii limbajului C++, const nu nseamn nici alocat ntro zon de memorie
readonly i nici constant stabilit la compilare. Mecanismul const a fost
conceput pentru a preveni eventualele accidente (ca de exemplu modificarea
nedoritaunorvaloricareseconsiderconstante)inufraudele.
Proteciaoferitdeacestmecanismpoatefieludatprintroconversieexplicitsau
prinaliere.Deexemplu:
inti=1;//inuesteconst
constint*p=&i;//inusevaputeamodificaprinp
int*q=(int*)p;/*aliereacantitii*qcuiprinconversieexplicitdetipechivalentcuint*q=&p;
iniializareaint*q=parfiilegaldincauzaincompatibilitiicaracteristicilordetip;*/
voidf()
{
p;
i++; //ok:nuiesteconstcip
(*p); //eroare:*pesteconst
(*q)++;/*ok:qnuesteconst,decicantitateareferitadeaceastanuestesupusarestrictiilor
demoficare*/
}
voidg()
{
(*(int*)p)++//ok:conversieexplicita
}
Dac un specificator const sau volatile apare ntro declaraie, el va modifica

declaratorulcareurmeazimediatdupel.
constchar*step[3]={left,right,hop};
declaruntabloudepointerilairuridecaracterecaresuntconstante.Pointeriise
potmodifica;iruriledecaracterenusepotprinintermediulacestorpointeri.

40
step[2]=skip;//ok:semodificapointerlaconstchar
step[2][1]=i;/*eroare:nusepoatemodificasirdecaractereconstant*/
Dac se dorete declararea unui tablou de pointeri constani la iruri de caractere

constante,definiiarespectivsescrie:
constchar*conststep[3]={left,right,hop};
cazncarenusepotmodificaniciiruriledecaracterei nici pointerii (elementele

tabloului):
step[2]=skip;/*eroare:nusepoatemodificaunpointerconstant*/
step[2][1]=i;/*eroare:nusepoatemodificasirdecaractereconstant*/
Definiia limbajului nu specific constante predefinite. Pentru asigurarea

compatibilitii tipurilor numerice cu ANSI C, limitele (minim i maxim) ale
domeniilor acestor tipuri se gsesc (sub forma unor macrodefiniii) n fiierele
header<limits.h>i<float.h>.
Declaraii de tipuri de date
Tipul de date este un mecanism de clasificare a expresiilor care furnizeaz dou
informaii:
mulimeavalorilorposibilealeexpresieincauz(domeniultipului);
operaiilecesepotaplicarespectiveiexpresii;
Unul din principiile de baz ale proiectrii unui limbaj de programare este: orice
expresie trebuie s aib un tip unic determinat. Tipul asociat unei expresii ofer
programuluitraductorinformaianecesarpentruverificareautilizriirespectivei
expresiiipentrureprezentareaacesteianmemorie.
Sisteme de tipuri
Un sistem de tipuri pentru un limbaj de programare este o mulime de reguli prin
care unei expresii i se asociaz un tip al limbajului respectiv. Un sistem de tipuri
respinge o expresie dac nui poate asocia un tip. Respingerea expresiei are loc de
obicei la compilare (se emite un mesaj de eroarea corespunztor) sau, mai rar, la
execuie(programulterminndusecuuncoddeeroare).
Limbajele actuale impun declararea explicit a variabilelor, una dintre informaiile
debazprezentendeclaraiefiindtocmaitipulvariabilei.
Sarcinileprincipalealeunuisistemdetipurisunt:
1. declararea de tipuri de date utilizator (extinderea mulimii tipurilor
recunoscutedelimbaj),prinfolosireadeclaraiilordetip;
2. asociereadetipurilavariabile,realizateprindeclaraiiledevariabile;

41
3. verificareaconsisteneifolosiriiexpresiilor,careserealizeazprin:
a. determinarea tipului oricrei expresii (sau respingerea acesteia dac
nuisepoatedeterminatipul);
b. verificareaconsisteneiinstruciunilor(deatribuire,apeletc.)pebaza
regulilorprivind:
compatibilitateatipurilor;
egalitateatipurilor,includereatipurilor;
echivalenatipurilor;
concordana listelor de parametri (formali i actuali) n apelul de
subprograme.
Regulile unui sistem de tipuri precizeaz utilizarea adecvat a fiecrui operator n
limbaj. Verificarea tipurilor (engl. type checking) are ca scop garantarea folosirii
corecte a operaiilor ntrun program. Prin aceasta se previn erorile de execuie. O
eroaredeexecuieapareatuncicndooperaieseaplicincorect,deexemplucnd
un operand numr ntreg este considerat altceva (caracter, ir de caractere,
boolean). Mai precis, o eroare de tip (engl. type mismatch) apare cnd o funcie f
declaratcuunargumentformaldetipulScarentoarceunrezultatdetipulTeste
apelatcuunargumentactualdetipulAcarenuestedetipulS.Unprogramncare
nu apar erori de tip se numete sigur din punctul de vedere al tipurilor (engl. type
safe).
Verificarea tipului se poate face static sau dinamic. Verificarea static a tipurilor se
face n timpul procesului de traducere, iar verificarea dinamic de tip se face n
timpul execuiei, prin inserarea n programul executabil (la compilare i link
editare) a unor poriuni de cod care realizeaz acest lucru. Desigur, verificarea
dinamic nseamn costuri suplimentare de execuie (dimensiunea programului
executabil crete, la fel i timpul de execuie, o parte din el fiind dedicat
verificrilorspecifice),deciestepreferabilverificareastatic.Deobicei,verificarea
static nseamn numai verificare de tip, iar verificarea dinamic cuprinde att
verificarea de tip, ct i verificarea unor valori calculate n timpul execuiei (indici
detablou,mprirelazeroetc.).
Se numete expresie sigur (engl. safe expression) o expresie n a crei evaluare nu
apare o eroare de tip. Exist dou categorii de sisteme de tipuri: puternice i slabe
(engl. strong, respectiv weak type system). Un sistem puternic de tipuri este acela
care accept numai expresii sigure, iar un sistem slab de tipuri este unul care nu
esteputernic.
Unlimbajdeprogramaresenumeteputernictipizatdacelareunsistemdetipuri
puternic i slab tipizat n cazul cnd are un sistem slab de tipuri. O definiie
alternativ a conceptului de limbaj puternic tipizat este dat de urmtoarele trei
cerine:
1. fiecareexpresiesaibunsingurtip;
2. determinarea tipului s fie posibil n timpul procesului de traducere, din
sintaxalimbajului;

42
3. variabilelesfiememoratelaadresedistincte.
Oaltdefiniiepentrulimbajputernictipizatestedatdeurmtoarelecaracteristici:
1. fiecareobiectestecreatcuuntipspecificat;
2. fiecareobiectestefolositntromanierconsistentcutipulsu.
Limbajul puternic tipizat static este acela pentru care detectarea inconsistenei
folosiriiobiectelorsefacelacompilare.
Clasificarea tipurilor de date

Caracterul extensibil al unui limbaj de programare este dat ntro msur
hotrtoare de capacitatea acestuia de a permite definirea de noi tipuri de date.
Existdiversecriteriidupcaresepotclasificaacestetipuri:
niveluldeabstractizare;
prezenasauabsenanumeluitipului;
prezenan(sauabsenadin)definiialimbajului;
momentulverificriitipului;
caracteristiciletipurilor(domeniu,operaii).
ntrun limbaj de programare, tipurile pot fi considerate pe trei niveluri de
abstractizare:
nivelul main conine acele tipuri pe care maina le tie reprezenta i
pentrucareeadispunededispozitivecarepotefectuaoperaiicuele:tipurile
ntregi i reale, caracter i boolean; aceste tipuri se mai numesc i tipuri de
baz.
nivelul limbajului conine pe lng tipurile de baz, tipurile structurate:
tablouri, nregistrri, mulimi, liste etc. care se construiesc cu ajutorul
tipurilor mai simple; tipurile structurate sunt necesare pentru a manipula
structurile de date proprii unui anumit program i se definesc cu ajutorul
unorconstructoridetip.
nivelulutilizatorconinetipuriledefinitedeutilizator;acestetipuriadaug
cmpurilor de la tipurile structurate operaii, prin ncapsulare; programarea
bazat pe obiecte i programarea orientat pe obiecte recurg la astfel de
tipuri.
Pentru uurina exprimrii, un tip de date este notat cu un identificator, numit
numele tipului. Acest nume concentreaz n el toat informaia de declarare a
respectivuluitip(domeniulioperaiileasociate).Recurgerealaunastfeldesistem
de notare este benefic pentru claritatea textului surs, fiind proprie matematicii.
Oridecteoriprogramultraductorntlneteunnumedetipdedate,eltrebuies
dispundedeclaraiacompletanumeluidetiprespectiv.Existnsideclaraiin
care nu apare numele tipului,fiind prezent doar declararea acestuia. Prin urmare,
prezenasauabsenanumeluiesteunaltcriteriudeclasificareatipurilordedaten
tipuricunumeitipurianonime(frnume).
DeexemplunlimbajulCputemdeclarauntipstructurcunumeastfel:

43
structStudent
{
char*nume;
intvarsta;
};
dupcareputemdefiniovariabildetipStudentastfel:
structStudents;
Aceai secven de definire a tipului i variabilei se poate face mai compact cu

ajutorulunuitipanonim:
struct
{
char*nume;
intvarsta;
}s;
Dinpunctuldevederealdefiniieilimbajului,distingemdoucategoriidetipuri:
tipurifundamentale,careaucanumeidentificatoripredefinii;
tipuri derivate, care au numele (identificator) dat de utilizator ntro
declaraiececuprindeunconstructordetip.
Dinpunctuldevederealmomentuluiverificriitipului,distingemdoucategoriide
tipuripentruoexpresie:
tipstatic(verificatlacompilare);
tipdinamic(verificatlaexecuie).
Una din caracteristicile eseniale ale limbajelor de programare orientat pe obiecte
estelegareadinamicaprocedurilor,pebazatipuluidinamicalobiectelor.
Un alt criteriu de clasificare este natura comportamentului reprezentanilor
(obiectelor) unui anumit tip. O privire sumar asupra caracteristicilor instanelor
ducelaidentificareaurmtoarelorclasedetipuri:
simple sau scalare: ordinale (ntreg, boolean, caracter, enumerare,
subdomeniu)ireale;
irdecaractere;
structurate(tablou,nregistrare,mulime,fiier,clas,uniune);
pointer;
procedurale.
n limbajul C numele unui tip se d printrun numedetip, care este, din punct de
vedere sintactic, exact ca o declaraie pentru o variabil sau o funcie de acel tip,
numaicnuaparenumelevariabileisaufunciei.
Exemple:

44
Numedetip Declaraia Tipul
int inti
ntreg
int* int*pi
Pointerlantreg
int*[3] int*p[3]
Tabloude3pointerilantregi
int(*)[3] int(*p3i)[3]
Pointerlatabloude3ntregi
int*() int*f()
Funcie fr argumente care returneaz
pointerlantreg
int(*)(double) int(*pf)(double)
Pointer la funcie cu un argument de tip
doublecarereturneazntreg.
Existiposibilitateadeadaunnumeunuinumedetip,prinmecanismultypedef,a
cruisintaxgenericeste:
typedefdeclaraiedevariabil;
cunelesulcnumedetipesteidentificatorul(utilizator)coninutndeclaraiede
variabil.
Deexemplu:
typedefint*Tf();//numedetipesteTf
Tff;//declaraiedetipechivalentcudeclaraiadevariabil
//int*f();
typedefint(*Tpf)(double);//numedetipesteTpf
//declaraiedetipechivalentcudeclaraia
Tpfpf; //int(*pf)(double);
Notaia de declarare din C i din C++ oglindete sintaxa expresiilor bazat pe

precedena i asociativitatea operatorilor. Limbajele C i C++ exceleaz prin
multitudinea deoperatori (fiindlimbajeorientatepe expresii),pentru careordinea
de prioritate pare de multe ori nenatural; pentru a se obine prioritatea dorit
trebuie folosite parantezele. De exemplu, declararea tipului anonim pointer la un
tablou de 10 pointeri la funcii ce au argument int i ntorc un pointer la char (chiar
dac literar expresia este relativ rezonabil) este greu de exprimat n C++ i nu
avantajeazlizibilitatea(festedeclaratcaovariabildeacesttip):
char*(*(*f)[10])(int);
Tocmaideaceea,cndselucreazcutipurinetriviale,serecomandssefoloseasc
numedetip. Tipul mai sus exprimat se poate descrie suficient de clar folosind
notaiileoferitedenumeledetip,peetape,nfelulurmtor:

45
typedefchar*F(int);//Festetipulfunciilorceauargument
//intintorcpointerlachar
typedefF*A[10];//Aestetipultablouluide
//10pointerilafunciidetipulF
A*p;//pesteunpointerlatablouldetipAdinexpresiademaisus.
Echivalena i compatibilitatea de tip

Un pas important n dezvoltarea limbajelor de programare este apariia limbajelor
puternic tipizate, dotate cu mecanisme de declarare a tipurilor utilizator. Apariia
acestorsistemedetipuriaprodusnoiprobleme,legatedeegalitateatipurilor.
Se pune problema compatibilitii tipurilor, cu referire la regulile semantice care
determindacntrunanumitcontextestevalidsaunuunobiectdeunanumittip.
Prin context se poate nelege aici instruciunea de atribuire, expresia de indice la
tablouri, apelul unui subprogram, aplicarea unui anumit operator sau orice alt
instan a unui tip dat. Noiunea de instan a unui tip desemneaz variabile,
componentealeunorvariabile,constante,constante,expresii, funciisauparametri
formalidetipulrespectiv.
Echivalenatipurilorestepiatraunghiularaverificrilordetippecareleimplicun
sistemdetipuri.Gamaacestorverificriestedivers,depinznddetipulexpresiilor,
de contextul n care acestea apar i n primul rnd de accepiunea noiunii de
echivalen de tip implementat. Echivalena tipurilor poate fi tratat att la nivel
semantic(censeamn),ctilanivelsintactic(cumserealizeaz).
Din punct de vedere semantic, distingem dou abordri ale echivalenei de tip:
egalitatea i compatibilitatea tipurilor. Trebuie reinut c abordarea semantic a
noiuniideechivalendetipexprimideeadecomportamentidenticsaucompatibil
la aplicarea acelorai operaii, i nu ideea de reprezentri structurale identice. n
unele situaii este nevoie ca tipurile implicate n verificri s fie identice (egale),
alteori este nevoie doar de compatibilitatea acestora. Cerina de egalitate a dou
tipuri este mai tare dect cerina de compatibilitate a lor i este cerut n puine
situaii.Compatibilitateatipurilorncadrulprogramelorseverificlanivelurile:
atribuiri(compatibilitateadeatribuire);
expresiilor(compatibilitateadeexpresii);
tablourile(compatibilitateadetablou);
listelor de parametri formali i actuali (concordana listelor de parametri ai
parametriaiprocedurilorifunciilor);
Din punct de vedere sintactic, exist trei accepiuni ale echivalenei tipurilor:
structural, de nume i de declarare.Dou tipuri sunt echivalente structural dac i
numai dac componentele lor sunt aceleai din toate punctele de vedere.
Echivalena de nume statueaz c dou tipuri sunt echivalente dac i numai dac
ele au acelai nume. Echivalena de declarare are loc numai dac variabilele ale
cror tipuri sunt considerate echivalente apar sub aceeai declarare de tip. ntre

46
aceste echivalene de tip exist o relaie de incluziune, n sensul c echivalena de
numeoimplicipeceastructural,iarechivalenadedeclarareleimplicautomat
peamndoucelelalte.
Limbajul C folosete echivalena structural pentru toate tipurile. Motivul pentru
care sa prevzut n C echivalena structural este minimizarea problemelor de
ntreinere.
EchivalenadenumeestepiatraunghiularasistemuluidetipuriallimbajuluiC++.
Regulile de compatibilitate ale reprezentrii garanteaz folosirea conversiilor
explicitepentruaseobineserviciidenivelmaisczutcarenaltelimbajeseobin
prin echivalena structural. Sa preferat echivalena de nume n locul celei
structurale deoarece ea are un model mai simplu i mai clar. n definiia limbajului
C++, echivalena de nume nseamn regula definiie unice: orice funcie, variabil,
tip,constantetc.trebuiesaibosingurdefiniie:
Declaraiile:
structA{intx,y;};
structB{intx,y;};
vor defini dou tipuri A i B compatibile n C (structural) i incompatibile n C++

(dupnume).Maimult,declaraiile:
structA{intx,y;};//nfiierul1
structB{intx,y;};//nfiierul2
definesc dou tipuri diferite, ambele cu numele D (att n C ct i n C++). Dac

compilatorul face verificarea celor dou fiiere (uniti de traducere) 1 i 2, se
obineeroareadefiniiedubl.
Din punctul de vedere al implementrii, att n C ct i C++ garanteaz c structuri
similare (cum sunt A, B i D din exemplu anterior) au reprezentare identic n
memorie,decielesepotconvertiexplicitifolosidreptstructuricompatibile:
externf(structA*)
structA{intx,y;};
structB{intx,y;};
voidg(structA*pa,structB*pb)
{
f(pa);/*correct*/
f(pb); /* eroare C++: e necesar argument A* datorit echivalenei de nume, ns corect n C
conformechivaleneistructurale*/
pa=pb;/*eroareC++:trebuieA*;corectnC*/
pa=(structA*)pb;/*corect:conversieexplicit*/
pb>x=1;
if(pa>x!=pb>x)
error(implementaregresita);
}

47
Declaraii de variabile
Dac unei constante i se asociaz un obiect din ULP, acelai pe tot parcursul
execuieiprogramului,uneivariabileicorespundeolocaiedememoriecarepoate,
la un moment dat, sconinunobiect dintro mulime de obiecte (valori posibile)
dinULP.Aceastmulimeformeazdomeniuldedefiniiealvariabilei,iarlocaiade
memorie este neleas n sensul de poziia de la care ncepe alocarea variabilei
respective.
Crearea de variabile i lucrul cuacestea este caracteristica debaz a limbajelor de
programareimperative.
Denumirea de variabil are pentru limbajele de programare alt semnificaie dect
ceafolositnmatematic.Dacnsensmatematicovariabilesteonedeterminat
sauunparametrudintrunsistemformalcepoateluaoricevaloaredintromulime
cunoscut de valori (domeniul de definiie al variabilei), pentru ULP noiunea de
variabil este legat de localizarea acesteia n memoria calculatorului i de
modificabilitateaconinutuluilocaieirespective.
Elemente definitorii ale unei variabile

Din punct de vedere structural, o variabil este un cvadruplu format din nume, set
deatribute,referinivaloare.
Numele unei variabile este un identificator, creat n concordan cu regulile proprii

sintaxeifiecruilimbaj.Deexemplu,nCiC++sefolosesclitere,cifreicaracterul
underscorepentruacreaidentificatori.Conveniaestessefoloseascliteremici.
Setuldeatributealuneivariabilepoatefifixatlacompilaresaumodificatdinamic(la
execuie). Definirea atributelor se poate face declarativ sau implicit. Definirea
declarativ presupune folosirea unor instruciuni de declarare, iar definirea
implicit se poate realiza fie prin stabilirea unei convenii privitoare la numele
variabilei(cumsentmplnFORTRANundenumeledevariabilecarencepcuI,J,
K,L,M,Nseconsiderntregi,iarcelelalteseconsiderreale),fieprinatribuireade
valori, caz n care tipul variabilei se stabilete n funcie de valoarea atribuit
acesteia.
Sedistingtreiatributeeseniale:
domeniuldevizibilitateesteconsideratafiintervalul(deprogramsurs)n
care variabila respectiv este recunoscut, deci utilizabil. Noiunea de
domeniudevizibilitateestemailarg,deobiceitoatenumelefolositentrun
program (nu numai variabilele) au un domeniu de vizibilitate stabilit prin
reguli de vizibilitate specifice limbajului. Domeniul de vizibilitate ncepe de
obiceiimediatduppunctuldedeclararealnumeluirespectivisencheiela
sfritul blocului, procedurii, fiierului surs, dup caz. O variabil local,
declarat n interiorul unui subprogram are domeniul de vizibilitate toat

48
secvenadedeclaraiiiinstruciunideduppunctuldedeclarareipnla
sfritul subprogramului respectiv; pentru variabilele globale, declarate n
corpul programului principal, domeniul de vizibilitate ine de dup punctul
dedeclararepnlasfritulfiieruluisurs.
duratadeviaestedefinitcaintervalul(detimpdeexecuie)ncarezona
de memorie alocat variabilei respective este utilizat pentru aceast
variabil. Exist variabile locale, globale i dinamice:variabile locale, numite
ivariabileautomatice,declarateninteriorulblocurilorsausubprogramelor,
sunt alocate n stiv doar la activarea unitii respective de program, avnd
duratadeviaegalcuperioadactesteactivatbloculsausubprogramuln
careelesuntdeclarate;variabileleglobalesuntdeobiceialocatensegmentul
de date nc de la compilare, aa c au durata de via egal cu timpul de
execuie al programului; variabile dinamice au durata de via controlat de
utilizator: alocarea i dealocarea se face prin instruciuni specifice fiecrui
limbaj.
tipul variabilei poate fi precizat n modurile specifice anterior. Majoritatea
limbajelor de programare posed tipuri predefinite (tipuri numerice,
caracter, boolean), iar cele mai evoluate au, pe lng acestea, mecanisme de
definire a tipurilor utilizator (typedef, struct, union n C, class n C++), cu
ajutorulcroraprogramatorulpoateconstruipropriilesalestructuridedate.
Mecanismelededeclararedenoitipurisuntextinseprinceeacesenumete
abstractizare datelor i programarea orientat pe obiecte, n care accentul
este pus pe definirea operaiilor prevzute pentru un anumit tip de dat
definitdeutilizator.
Odat cu noiunea de tip apare problema definirii tipului, care se poate face static
(n timpul compilrii, pentru limbajele puternic tipizate), sau dinamic (n timpul
execuie, atunci cnd tipul exact al variabilei nu este cunoscut n momentul
compilrii). Tipul unei variabile determin domeniul de definiie al variabilei
respectiveigamadeoperaiipermisepentruvariabilarespectiv.
Referina este informaia adres, adic locul unde este memorat variabila.
Stabilireareferineiserealizeazprinceeacenumimalocareavariabileirespective.
Alocarea unei variabile se poate face static sau dinamic, n funcie de momentul n
careserealizeazacestlucru.Dacalocareasefacenfazadecompilareestevorba
de alocare static, iar dac alocarea se face la execuie este vorba de alocare
dinamic.
Douvariabilecareauaceeaireferinsenumescvariabilealiate,iaroperaiaprin
caresepoaterealizaacestlucrusenumetealiere(engl.aliasing).nCiC++alierea
sepoateobineprinmecanismulunion.
Valoareaasociatuneivariabilesepoateschimbantimpulexecuieiunuiprogram
dar,petoatduratadeviaavariabileirespective,nlocaiadememorieprecizat

49
prinreferinsevagsiovaloare.Mulimeavalorilorasociatevariabilelordintrun
program formeaz spaiul strilor sau mediul programului. Determinarea valorii
uneivariabilelaunmomentdatsefaceprinoperaiadederefereniere.Prinaceasta,
pe baza referinei se returneaz valoarea variabilei. n general operaia de
derefereniereesteimplicit,neexistndonotaieconsacratpentruea.
Celepatrucomponentealevariabileisepotreprezentaschematicastfel:
Referina, mpreun cu valoare formeaz un obiect. n cazul variabilelor aliate,

acestea vor avea aceeai referin, dar nu neaprat vor desemna acelai obiect,
deoarece, dac sunt de tipuri diferite, ele vor avea valori diferite (datorit, de
exemplu, diferitelor moduri de reprezentare intern ale acestora). Schematic, dou
variabilealiateXiYseprezintastfel:
Legarea variabilelor
Termenul de legare a variabilelor este folosit n mai mult accepiuni. Urmrind
structura unei variabile, prezentat n seciunea precedent, putem distinge dou
punctentrecareaparelegarea:ntrenumeisetuldeatributepedeoparteintre
perechea (nume, set de atribute) i referin pe de alt parte. Legarea variabilelor
poatefidiscutatidinpunctuldevederealprocesuluidecompilare.Exist,nacest
context,legareinterniexternacestuiproces.Daclegareainternavariabilelor
se face n interiorul procesului de compilare a textului surs, legarea extern este
sarcina editorului de legturi, care rezolv legarea unei variabile folosit ntrun
modul i declarat ntrun alt modul (modulele respective fiind supuse unor
compilri separate). n sfrit, termenul de legare a variabilelor are accepiuni
diferite n traducerea efectuat de compilatoare fa de cea efectuat cu
Set de atribute Nume Referin
valoare
X
Y
Atribute X
Atribute Y
valoare

50
interpretoare. n ultima situaie vorbim de o legare dinamic a variabilelor,
efectuatchiarntimpulexecuiei.
Din schemele de mai sus se observ c legarea variabilelor (engl. binding) implic
punerea n coresponden a variabilelor cu atributele acesteia. Momentul legrii
(engl.bindingtime)estemomentullacaredevincunoscuteatributeleuneivariabile.
Existdousituaiidistincte:
1. atributele se cunosc la compilare: se poate face n acest caz, tot la
compilare, toate verificrile necesare privind compatibilitatea i
corectitudinea utilizrii variabilei, prin urmare codul generat este mai
compact,permindoexecuieeficientaacestuia.
2. atributele se cunosc numai la execuie: rezult c n codul generat la
compilare vor trebui introduse i secvene care s realizeze verificrile de
corectitudineautilizriivariabilei,ceeaceconducelauncodmaimare,deci
mai ineficient. Pe de alt parte, acest lucru conduce, de aceast dat n sens
pozitiv,laomaimareflexibilitateaprogramelorscrise.
n funcie de momentul legrii, se disting dou clase de limbaje, cu repercusiuni n
ceea ce privete deciziile de implementare. n prima clas sunt acele limbaje care
permit legarea static, adic pentru care momentul legrii coincide cu momentul
compilrii.Pentruacestelimbaje(cuvariabilepentrucaremajoritateaatributelorse
cunosc la compilare) este caracteristic eficiena n execuie. A doua clas conine
acele limbaje pentru care legarea este dinamic, adic momentul legrii este
momentul legrii este momentul execuiei. Pentru acestea, soluia de
implementarea optim este cea interpretativ, cu alocarea dinamic a memoriei,
verificareadinamicacorectitudiniifolosiriivariabilelor,aexecuieioperaiiloretc.,
ceeaceconducelaflexibilitatenexecuie.
Decizia privind tipul programului traductor (compilator sau interpretor) depinde
de muli ali factori (resurse hardware, pre de cost, criteriul de eficien stabilit
pentru limbaj timp sau memorie, domeniul de aplicare etc.). De obicei limbajele
imperative posed compilatoare iar limbajele aplicative posed interpretoare.
Aceasta nu este o regul general, existnd compilatoare i pentru limbajele
aplicative.Deosebireantrelimbajelecompilateiceleinterpretatedevinemultmai
estompat n cazul limbajelor moderne. De exemplu, pentru un limbaj (cum este
Ada) care permite lucrul cu tablouri de dimensiuni cunoscute numai la execuie, la
compilaresevainserancodunapellarutinespecialecevorfiactivatelaexecuie.
Alte faciliti cum sunt alocarea dinamic a irurilor de caractere, procedurile
recursive, facilitile generice, lucrul cu variabilele dinamice accesate prin pointeri,
legareadinamicaprocedurilor,folosireabibliotecilorncrcatedinamic(DLL)ia
mediilor de execuie necesit de asemenea includerea n codul generat de
compilator a unor apeluri de rutine specifice, ceea ce transform codul obiect mai
degrab ntrun cod intermediar dect n cod main, apropiindul de ceea ce
realizeazuninterpretor.

51
Punctul de declarare a unei variabile poate fi definit att pentru limbajele cu
declaraii complet explicite, ct i pentru cele care permit i declaraii implicite de
variabile. n primul caz, orice variabil necesar trebuie n prealabil declarat
printroinstruciunededeclarare,iarpunctuldedeclarareseconsiderafiimediat
dupterminareadeclaraieinumeluivariabilei.naldoileacaz,punctuldedeclarare
este prima instruciune de atribuire care conine n membrul stng numele
variabilei. Punctul de declarare marcheaz nceputul domeniului de vizibilitate al
variabilei.
ntlnirea unei instruciuni de declarare nseamn pentru compilator legarea
numeluivariabileidesetuldeatribute.ntradevr,nmodnormaloinstruciunede
declararespecificdouinformaii:
numelevariabilei;
tipulacesteia.
Celelalte atribute ale variabilei se determin dup cum urmeaz. nceputul
domeniuluidevizibilitateestedefinitdepunctuldedeclarare,adicdeloculncare
apare respectiva declaraie n textul surs al programului, iar sfritul domeniului
estedeterminattotdepunctuldedeclarare,astfel:
a. Punctul de declarare este intern unui bloc sau subprogram: domeniul de
vizibilitateinepnlasfritulblocului(subprogramului),inclusivblocurile
(subprogramele) locale (dac nu exist redeclarri ale numelui n interiorul
acestora), situaie n care vor fi valabile redeclarrile aa numitele pete
albe hole in scope; respectiva variabil este deci local unitii n care a
aprutpunctuldedeclarare.
b. Punctuldedeclarareestenafaraoricruiblocsausubprogram:domeniulde
vizibilitate al variabilei este ine pn la sfritul fiierului surs respectiv,
variabilafiindglobalnfiierulceconinedeclaraia.
c. Punctul de declarare este n partea de interfa a unui modul: domeniul de
vizibilitate al variabilei este, pe de o parte cel stabilit la (b), variabila fiind
global modulului, iar pe de alt parte orice alt modul sau program care
specificexplicitfolosireamodululuidedeclarare.
d. Punctuldedeclarareestenparteadeimplementareaunuimodul:domeniul
de vizibilitate este cel stabilit la (b), cu precizarea c numele este invizibil
modulelor sau programelor care specific explicit folosirea modulului de
declarare,iarvariabilaestelocalmodulului.
Punctul de declarare determin indirect i durata de via a variabilelor. Acest
atributestenstrnslegturcuadouavariantdelegare,anumelegareaperechii
(nume, set de atribute) de referin, legare numit de obicei alocarea variabilei.
Astfel, variabilele globale (n program sau modul) sunt alocate la compilare n
segmentul de date, deci durata lor de via coincide cu durata de execuie a
programului,fiindalocatestatic,iarvariabilelelocalesuntalocateautomatdectre
mecanismul de execuie (bazat pe principiul stivei (ele se mai numesc i variabile
automatice). n cazul variabilelor globale, la ntlnirea instruciunii de declarare

52
compilatorulpoatealocansegmentuldedatespaiupentrurespectivavariabil(pe
baza informaiei de tip). Pentru variabilele locale compilatorul determin locul
variabileinnregistrareadeactivarearespectivuluiblocsausubprogram,carevafi
alocat automat n stiva de execuie cnd blocul sau subprogramul sunt activate,
respectivdealocat(totautomat)laterminareaexecuieilui.Prinurmare,duratade
via a unei variabile locale este definit de timpul de activare a blocului sau
subprogramuluidedeclarare.
Deobiceivariabileledinamicesuntanonime,iaraccesarealorsefaceprinvariabile
de tip pointer (a cror valoare reprezint adresa variabilei dinamice referite).
Declararea unei variabile pointer nu are efect dect asupra duratei de via a
variabileipointer(tratatlafelcaoricealtvariabil).Variabiladinamicreferitde
pointervaaveaduratadeviacontrolatdeutilizator,carepoatefolosiinstruciuni
specifice de alocare i dealocare. Variabilele dinamice se aloc n zona de memorie
dinamic(heap).
Prin urmare, variabilele au nc un atribut, care determin modul lor de alocare,
numit clas de memorie. Acest atribut este de obicei implicit (fiind determinat de
localizarea punctului de declarare). n limbajele C i C++ exist posibilitatea
declarriiexpliciteaclaseidememoriepentruoricevariabil.
Clase de memorie C
n limbajul C funciile nu se pot include unele n altele, deci nivelul de nglobare
static al tuturor funciilor este acelai. n C exist att instruciuni compuse, ct i
blocuri se permit definiri de obiecte n cadrul blocurilor. O alt caracteristic a
limbajului este compilarea separat, rezultnd segmente diferite care sunt legate
mpreundectreeditoruldelegturi.
Pentrudeterminareadomeniuluidevizibilitateiadurateideviapentruvariabile,
limbajul C introduce un nou atribut pentru acestea: clasa de memorie. Exist patru
astfel de clase, care se declar cu cuvintele rezervate: auto (declaraie implicit
pentruvariabileledeclarateninteriorulfunciilor),register,staticiextern(clasa
implicit pentru variabilele declarate n afara funciilor). Precizarea clasei de
memorieiatipuluivariabileisefacentrodeclaraiedeforma:
<nume_clas><tip><list_nume_variabile>;
unde:
<list_nume_variabile> conine identificatorii ce reprezint numele
variabilelor,separaiprinvirgule.
Variabilele auto sunt declarate n interiorul funciilor. O astfel de variabil este

activattatimpctesteactivunitateadeprogram(funciasaublocul)lanceputul
creia a fost declarat pierzndui valoarea la terminarea execuiei respectivei
uniti de program, la o nou apelare nemaifiind disponibil vechea ei valoare. n

53
afara unei declaraii de clas de memorie, toate variabilele se consider implicit n
clasaauto.
Variabilele register se constituie ntro subclas a clasei auto, declaraia register
anunnd compilatorul c aceste variabile vor fi utilizate foarte frecvent. Dac este
posibil,compilatorullevaalocacteunregistrumain,pentrumicorareatimpului
deacceslaacestevariabile(nacestcaznumaitrebuiefcutcalcululdeadresic,
ngeneral,regitriimainautimpideaccesmaimicidectmemoriaintern).Dac
se folosete un numr mare de variabile register, care depete numrul de
regitrii main disponibili, compilatorul va ncadra variabilele register rmas n
clasa auto (de aceea se spune c clasa register este o subclas a clasei auto). O alt
limitareautilizriiclaseiregisterestedatdecapacitateaunuiregistrumain,care
este n general doi sau patru octei, prin urmare numai variabile de tipurile ntreg,
caractersaupointerpotaparineacesteiclase.
O utilizare uzual a acestei clase de memorie este pentru memorarea ntrun
registruavariabileidecontrolpentruosecvenrepetitiv:
voidmain()
{
registerinti;
for(i=0;i<1000;i++)a[i]=i;
}
Variabilele static sunt de dou categorii: static interne i static externe. Nu este
necesarfolosireadecuvintecheierezervatenacestsens,ncadrareauneivariabile
static n categoria corect fcnduse n funcie de locul n care apare declaraia:
static interne dac se declar n interiorul unei funcii i static externe dac se
declarnafarafunciilor:
staticinta[20];//variabilaaestedetipstatic
Dacsedeclarnafarafunciilor,acelevariabilestaticevorfiaccesibilemaimultor
funcii.Domeniuldevizibilitatealuneiastfeldevariabileestedinloculdeclarriiei
i pn la sfritul modulului respectiv, deci domeniul de vizibilitate este limitat la
fiierul ce conine declaraia. Valoarea unei variabile statice poate fi modificat de
funciile care au acces la ea. n momentul n care un segment care conine o
declaraiedevariabilstaticdevineinactiv,variabilastaticrespectivivapierde
valoarea,lareactivareasegmentuluieaprimindvaloareainiialdeladeclarareaei
(cunoscutlacompilare).SepoateconsideracvariabilelestaticexternedinCsunt
similare variabilelor globale (declarate n programul principal), ele alocnduse la
compilarensegmentuldedate.
Dac se declar n interiorul unei funcii o variabil static va avea regim de
variabil local din punct de vedere al domeniului de vizibilitate, ns ea nu se va
aloca n stiv ci tot n segmentul de date globale, avnd astfel o proprietate

54
interesant: valoarea acesteia se va pstra ntre dou apeluri consecutive ale
aceleiaifuncii,iniializareaeifcndusedoarlaprimulapelalfunciei.
Pentrucomunicareantresegmentediferite,compilateseparat,n Csuntprevzute
variabile dinclasaextern. La felcavariabileledin clasa static,ele sunt declaraten
afara funciilor, iar domeniul de vizibilitate al unei variabile extern este de la locul
declarrii i pn la sfritul segmentului n care apare declararea. Spre deosebire
de variabilele static, care sunt locale unui segment, variabilele extern pot aparine
maimultorsegmente(rolullorfiindcomunicareantresegmente),aceeaivariabil
externavndacelainumenfiecaredintresegmentelencareesteutilizat.Sarcina
stabiliriilegturilornecesarepentruovariabildeclasexternrevineeditoruluide
legturi, o referire la ea n oricare dintre segmentele unde este declarat
traducnduseprinaceeaiinformaiedeadres.
FunciileCauimplicitclasadememorieextern,eleputndfiapelatedinoricepunct
alprogramului.Pentruafacecaofunciespoatfiapelatnumaidinsegmentuln
careeaestedefinit,isevaatribuiclasastatic.
Etape ale lucrului cu variabile

Din punctul de vedere al manipulrii, n viaa unei variabile se disting mai multe
momente,enumeratenceleceurmeaznordineafireascaapariieilor:
1. Declararea
2. Iniializarea
3. Folosirea
Declararea variabilelor se face implicit sau explicit. Declararea explicit este
realizat cu ajutorul instruciunilor de declarare, care comunic compilatorului
informaii privind numele variabilelor, atributele acestora i, eventual, valorile de
iniializare. Declararea implicit recurge la convenii privitoare fie la numele
variabilei,fielavaloareaacesteia.
Instruciunile de declarare trebuie s apar, n majoritatea limbajelor, n partea de
nceput (de declaraii) a blocurilor, subprogramelor sau modulelor. Excepie este
limbajulC++,carepermitedeclarareauneivariabileexactacoloundeestenevoiede
eaprimadat.
Declaraiile mai pot specifica tipul de legare a variabilei respective (intern sau
extern), modul de alocare a acesteia, modul de transmitere a parametrilor n
subprograme.
n limbajul C++ se definesc doi termeni: declarare i definire (prin definire se
nelege declarare i iniializare). n cazul definiiilor fr iniializator, variabilele
primesc valori implicite, echivalente lui 0 (0 pentru tipuri numerice, stringul vid
pentruiruridecaractere,valoareaNULLpentrupointeri).Odeclaraiearerolulde
a introduce unul sau mai multe nume (noi) ntrun program. Declaraia NU este i
definiiecnd:
Declarofunciefraispecificacorpul;

55
Coninespecificatorulexterninuareiniializareasaucorpdefuncie;
Declarunmembrustaticntrodeclaraiedeclas;
Esteodeclaraiedenumedeclas;
Esteodeclaraietypedef.
Urmtoareadeclaraieesteidefiniie:
inta;
pentru c are iniializarea implicit (cu 0), i declaraia este local unitii de
traducerencareeaapare,iarurmtoareaestenumaideclaraie:
externinta;//nfiierul2
deoarece variabila ntreag a se consider definit n alt unitate de traducere (de

exemplunfiierul1,undesefaceiniializareaei),iarnfiierul2estedoarfolosit.
Declaraiilepentruvariabilepotspecificaitipullegrii(internsauextern,maniera
de alocare specificat n C i C++ prin clasa de memorie). Declaraiile static
corespundlegriiinterne,iarceleexterncorespundlegriiexterne(lalinkeditare).
O declaraie sau definiie poate conine i calificatori (const sau volatile), care
definesc modificabilitatea obiectelor precizate. O particularitate a acestora este
modul de aplicare la pointeri: atributul const sau volatile prefixat cu operatorul de
derefereniere*seaplicpointeruluiinuobiectuluipunctatdeacesta.
Deexemplu,definiiile:
constci=10,*pc=&ci,*constcpc=pc;
inti,*p,*constcp=&i;
declar:
ciconstantntreag;
pcpointerlaconstantantreagci;
cpcpointerconstantlaconstantantreagci;
ivariabilntreag;
ppointerlantreg;
cppointerconstantlavariabilantregi;
Valorileluici,cpcicpnusepotmodificadupiniializare.Valoarealuipcsepoate
modifica,caiobiectulpointatdecp.Exempledeoperaiilegalesunt:
i=ci;
*cp=ci;
pc++;
pc=cpc;
pc=p;
iarcaexempledeoperaiiilegaleavem:

56
ci=1; //cinusepoatemodifica
ci++; //idem
*pc=2; //artrebuisasemodificeci
cp=&ci; //cpnusepoatemodifica
cpc++; //cpcnusepoatemodifica
p=pc; //arpermitemodificareulterioaraaluiciprinp
Exemple:
inti=1; //isepoatemodifica
constint*p=&i;//pointerlaobiectconstant
//pointerulsepoatemodifica,nuinsasi
//obiectulreferit
int*constvp=&i; //pointerconstantlaunobiect
//obiectulsepoatemodifica,
//nuinsasipointerulcarelrefera
constint*constcp=&i;//pointerconstantlaun
//obiectconstant
//niciobiectulnusepoatemodifica,
//nicipointerulcarelrefera.
voidf()
{
i++; //OK:inuesteconst
p; //OK:pnuesteconst
(*vp);//OK:*vpnuesteconst
cp++; //eroare:nusepoatemodificaunobiectconst
(*cp);//eroare:nusepoatemodificaunobiectconst
(*p)++;//eroare:nusepoatemodificaunobiectconst
vp++;//eroare:nusepoatemodificaunobiectconst
}
Variabilele pointer sunt iniializate implicit la NULL (echivalentul valorii 0 pentru

tipulpointer).
Iniializarea
Una dintre condiiile naturale pe care trebuie s le ndeplineasc un program este
stabilitatea sa, care se poate defini intuitiv astfel: cu aceleai date de intrare,
programul produce aceleai rezultate. Problema stabilitii este rezolvat n cazul
programelorsimple,careconindeclaraiidedate(variabile)deintrareirezultate:
variabilele de intrare se iniializeaz prin operaii de intrare (citire) i rezultate:
variabilele de intrare se iniializeaz prin operaii de intrare (citire), iar variabilele
rezultat(deieire)prinoperaiideatribuire.nschimb,dacnprogramsefolosesc
ivariabileauxiliare(necesarepentruomaibunstructuraprocesuluidecalcul),
nimeni nu mai garanteaz iniializarea acestora. Prin urmare, din definiia
stabilitii (dat mai sus) rezult o prim condiie de stabilitate: toate variabilele

57
auxiliare din program s fie iniializate cu aceleai valori, la fiecare execuie a
programuluicuacelaisetdedatedeintrare.
Iniializarea unei variabile se poate face n urma unei instruciuni de atribuire sau
prin instruciuni specifice. n ceea ce privete iniializarea unei variabile aceasta se
poate face n momentul alocrii ei (variabila primete o valoarea predefinit, n
funcie de tipul ei sau stabilit printro instruciune sau clauz) sau imediat dup
momentulalocrii(valoareavariabileiestenedefinitseconsidervaloareagsit
nlocaiadememoriedefinitdereferinaei,valoareanumitvaloarearezidual).
Limbajeledeprogramaremoderneacordoateniesporitiniializriivariabilelor.
De regul se aplic iniializarea implicit, elibernd programatorul de o activitate
suplimentar.
Referireavariabilelorsefaceprintroexpresiedeidentificarecarepoatefi:
identificator(numelevariabileirespective);
expresieindexat(cndvariabilaestedetiptablou);
expresie de selectare (dac variabila este component a unei date
structurate);
expresiedeindirectare(cndvariabilaestedetippointer);

58
5. Tipuridedate
Printipdedatesenelegeomulimedeobiectensoitdeomulimedeoperaiipe
mulimea acestor obiecte. Operaiile realizeaz crearea, construirea, distrugerea,
modificarea sau copierea instanelor (realizrilor) obiectelor. Operaiile definite pe
mulimea obiectelor reprezint un set minim de operaii primitive, cu ajutorul
crora, prin compunere, se pot descrie operaii mai complexe. Fiecare limbaj de
programare are stabilite, n momentul specificrii lui, tipurile de dat proprii,
numiteitipurifundamentale.
Tipuri fundamentale
Fiecare limbaj de programare i definete tipurile fundamentale, numite i tipuri
baz, care de obicei corespund tipurilor main. Pentru aceste tipuri, definiia
limbajuluiintroduceidentificatoripredefinii.
Dinpunctuldevederealcomportamentuluilor,tipurilefundamentalesepotmpri
n tipuri aritmetice, caracter i boolean. Despre precizarea detaliat a operatorilor
vomdiscutantrunaltcapitol.
Tipurile aritmetice (ntregi i reale) sunt apropiate de maina fizic. n general
exist mai muli reprezentani ai acestor tipuri, tipuri care difer unele de altele
prin: maniera i lungimea de reprezentare, prezena semnului etc. Operaiile de
baz sunt cele aritmetice (rezultnd expresii aritmetice) i de comparare (expresii
relaionale).
Domeniul tipului de dat boolean are numai dou valori: true i false. Exist cinci
operaii definite pe acest tip: and, or, not, imp (implicaia logic) i equiv
(echivalenalogic).Definireaoperaiilordemaisussepoatefaceastfel(utilizndu
seoinstruciuneifelseipresupunndcxiysuntvariabilebooleene):
xandy=ifxthenzelsefalse
xory=ifxthentrueelsey
notx=ifxthenfalseelsey
ximpy=ifxthenyelsetrue
xequivy=ifxthenyelsenoty
LimbajulCconsideroriceirbiiceconinnumai0cafalse,respectivtrueoriceir
debiintrecareesteunulnenul.
Operanzii de tip boolean se folosesc la formarea expresiilor logice, cu ajutorul
operatorilorlogici.
n C++ exist dou mari clase de tipuri fundamentale: aritmetice i void (cu
domeniuldevalorivid).Tipurilearitmeticesuntformatedintipurintregi(char,int
n toate variantele i enumerrile) i tipuri reale (flotante). Valorile minim i

59
maxim din domeniul fiecrui tip sunt precizate, pentru fiecare implementare, n
fiierulheader(antet)<limits.h>.
Tipulchararecadomeniusetuldecaracteredebazallimbajului.Fiecareinstan
a sa este memorat ntro variabil detip caracter, careare ca valoare codul ntreg
alcaracterului.Caracterelesepotdeclaracusemnsaufrsemn(declarareexplicit
signed sau unsigned); exist deci trei tipuri distincte: char, signed char i unsigned
char. Fiecare va ocupa acelai spaiu de memorie (determinat de operatorul
sizeof()).
Existtreitipurintregidistincte:int,shortilongint.Tipurilesignedchar,short,int
ilongaucorespondentuntipunsigned,careocupacelaispaiudememorie.
Tip sizeof (n
octei)
Aliniere (multiplu de, n
octei)
char 1 1
short 2 2
int 2sau4 2sau4
long 4sau8 4sau8
n C++ (ca i n C) nu este predefinit tipul boolean. Orice expresie cu valoarea

diferit de zero (sau diferit de echivalentul lui 0 n cazul domeniului oricrui alt
tip)esteconsiderattrue,iaroriceexpresiecuvaloarea0esteconsideratfalse.
Tipul enumerare este un tip ntreg distinct ce are constante cu nume. Numele su
devine un aa numit numeenumerare, care este cuvnt rezervat n domeniul de
vizibilitatepropriu.Identificatoriidintrolistenumeraresuntdeclaraiconstantei
pot apare oriunde pot apare constante. Dac nu apar enumeratori cu =, valorile
respectivelor constante ncep de la 0 i cresc cu 1, de la stnga la dreapta. Un
enumerator cu = va da identificatorului valoarea indicat, care rmne ca valoare
de start pentru urmtorii enumeratori. Valoarea unui enumerator trebuie s fie de
tipintsaudetipcesepoateconvertilaint.
Numeleenumeratorilortrebuies fiedistinctedeceleale variabilelorordinare sau
alealtorenumeratorinacelaidomeniudevizibilitate.Deexemplu:
enumculori=
{rosu,orange,galben,verde,albastru};
enumfruct=
{mar,para,orange,kiwi};//eroare:orangeesteredefinit
enumpasare=
{strut,
dodo,
lebada,
kiwi};//eroarekiwiesteredefinit
intlebada;//eroare:lebadaredefinit

60
Valorileenumeratorilornutrebuiesfiedistincte.Unenumeratoresteconsideratc
se definete dup ce sa citit numele (i eventual iniializatorul, dac exist). De
exemplu:
enum{a,b,c=0};
enum{d,e,f=e+2};
definetea,c,dcuvaloarea0,biecuvaloarea1ifcu3.
Fiecare enumerator definete un tip ntreg diferit de toate celelalte tipuri ntregi.
Tipulunuienumeratoresteenumerareasa.
Tipurile reale distincte sunt: float, double i long double. Caracteristicile lor sunt
precizatenfiierulantet<float.h>.
Tip sizeof (n
octei)
Aliniere (multiplu de, n
octei)
float 4 4
double 8 4sau8
long
double
12sau16 4,8sau16
Tipulvoidaredomeniulvalorilorvid.Estefolositpentruaprecizatipulrezultatului
ntors de funciile cu semantic de procedur. Nu se declar obiecte de tip void;
orice expresie se poate converti explicit la tipul void, iar rezultatul conversiei se
poatefolosinumaipepostde:instruciuneexpresie,operandstng,expresievirgul
saualtreileaoperanddinexpresiacondiionalconstruitcuoperatorul?:.
iruri de caractere
Tipulirdecaractere(numitistring)arecavaloareunirdecaractereculungimea
variabil (modificabil dinamic). Lungimea irului de caractere este numrul de
caractere coninut n el. Caracterele care pot constitui irul sunt, de obicei, cele din
setul de caractere acceptat de limbaj. Operaiile care se pot efectua cu iruri de
caracteresunt:construirea,inserareaunuiirdecaracterenaltul,extragereaunui
subir, tergerea unui subir, cutarea unui subir, concatenarea a dou iruri de
caractere.
Acest tip de date sa impus din cel puin dou motive: imposibilitatea accesrii
globale a unui tabloude caractere precum i rigiditatea utilizrii tablourilor statice
(de dimensiune fixat). Astfel, pentru tipul tablou sunt definite doar operaiile de
atribuire i test de egalitate; pentru tipul ir de caractere sunt necesare n plus
operaiiledeintrare/ieireicelespecificatemaisus.Prinacesteoperaii,lungimea
irului de caractere se poate modifica, prin urmare o reprezentare fix (pe numr
prestabilitdecaractere)nuesteadecvat.

61
nCsefoloseteurmtoareaconveniepentrureprezentareairurilordecaractere:
unirdencaracteresereprezintpen+1octei,numerotaidela0lan,astfel:
octetuli(dela0lan1)conineali+1leacaracterdinirulconsiderat
octetul n conine un caracter terminator de ir: caracterul NULL (\0) din
ASCII;rezultcacestcaracternupoatefacepartenCdintrunirdecaractere.
Includerea ntrun limbaj de programare a unor operaii specifice prelucrrii
irurilordecaracterepresupuneurmtoarele:
existenatipuluidedateirdecaractere(string);
prelungireautilizriioperatorilorrelaionalipeiruridecaractere;
stabilireauneireprezentripentruiruriledecaractere;
stabilireauneimulimiminimaledeoperaiipeiruridecaractere.
nC,C++ tipulir decaractere nuestepredefinit.Tratarea irurilor decaractere se
poatefacefolosinddeclaraiadetablou:
char[n](sauchar[])
Indiciiacestortablourincepcu0,iarreprezentareasefacenconveniaC.
Pentru a prelucra iruri de caractere folosim funcii din biblioteca standard C:
strcpy,strcmp,strstr,strchr,strlenetc.
Tipul pointer
Tipuldedatepointeraredomeniulformatdinadreselealtorentiti(reprezentabile
nmemorie)dintrunprogram.Lucrulcupointeripermitecreareaiutilizareaunor
structuridedatecomplexe,darfolosirealuingreuneaznelegereaunuiprogram,
putnd genera erori deosebit de greu de detectat. n general, adresa unei entiti
este caracterizat de dou informaii: adresa segmentului de memorie n care se
gseteentitateai deplasamentulacesteiansegment(distana fadenceputul
acestuia).
Exist dou tipuri de pointeri: cu tip i fr tip. Pointerii cu tip conin adrese de
entiti de acelai tip, fiind integrai n sistemele de tipuri. Pointerii fr tip refer
oriceentitatedememorie,indiferentdetipulacesteia.
Variabilele pointer constituie o alternativ de accesare a entitilor din memoria
unuiprogram,prinintermediulunuiaanumitmecanismdeindirectare.Unpointer
care nu refer nimic are valoarea echivalent cu 0 (pointer null); n caz contrar,
valoarea sa este adresa entitii respective, iar informaia de tip al pointerului
exprimitipulentitiireferitedepointer.
Uzual,odeclaraiedetippointerspecific,printrunconstructordetip:
numelenouluitippointer(opional);
numeletipuluireferitdepointer(obligatoriu).
ncazulcndentitateaesteovariabil,pointerularecavaloareadresaacesteiadin
memorie.ncazulvariabileloralocatenmemoriadinamic,acesteanuauunnume

62
explicit (se i numesc variabile anonime), ele putnduse referi numai prin
intermediul unui pointer asociat: alocarea i dealocarea lor se vor face cu operaii
specificedealocare,respectivdedealocare,aplicatepointerului.Operaiilespecifice
pentru pointeri sunt atribuirea i dereferenierea (indirectarea, referirea entitii
punctate de pointer). Unele limbaje posed i operaii aritmetice (adunare i
scdere)cuoperanzipointerii/sauntregi.
Pointerii asigur flexibilitatea n execuia unui program, ns trebuie gestionai cu
atenie. Programatorul controleaz durata de via a variabilelor i i gestioneaz
singur o anumit parte a memoriei calculatorului. Aceasta face parte din libertile
democratice pe care le are programatorul n lumea democrat a informaticii.
Practica a artat ns c nu sunt puine situaiile cnd libertile greit nelese se
ntorc mpotriva aceluia care beneficiaz de ele. Apare de multe ori problema
referinelorambigue,careapareatuncicndsefoloseteunpointeracruivaloare
refercevacenumaiestealocatnmemorie.
Osoluielagestionareamemorieidinamiceestegarbagecollectorcarecolecteaz
toatelocaiilecarenumaisuntreferiteileelibereaz.
Pointeriiauurmtoareleavantaje:
libertatea oferit programatorului n controlarea duratei de via a
variabilelor;
flexibilitatea sporit a programelor realizate, prin folosirea structurilor de
datedinamice;
actualizarea selectiv a structurilor complexe, fr recopierea ntregii
structuri;
compactitateacoduluiscrisprinfolosireapointerilorlafuncii.
n lipsa unei riguroase discipline n programare, utilizarea pointerilor poate fi un
comar,eroriletipicefiind:
ncercarea de a accesa o entitate printrun poitner nainte de iniializarea
pointeruluiceorefer,lucruceconducelaerorideexecuie;
ncercarea de a accesa o locaie dup ce aceasta a fost eliberat, lucru ce
conducelarezultateimprevizibilenexecuie.
C++motenetedelalimbajulCabilitideosebitendeclarareailucrulcutipurile
pointer.nplusfadeC,C++introduceitipulreferindesprecarenuvomdiscuta
aici.
Un tip pointer la tipul T se precizeaz printro declaraie T*. Uzual, stilul de
programare C nu recurge la nume proprii pentru tipurile de date pointer; sintaxa
limbajului este deosebit de flexibil n a permite declararea de tipuri pointer la
tipuri de date complexe. Prin urmare, astfel de tipuri de date pointer anonime se
folosescfrecventndeclaraiile(idefiniiile)devariabilesauparametriformali.Am
prezentatdejaexemplededeclaraiidevariabiledetippointer.
(Nusepotdeclarapointerilareferineipointerilairuridebii.)
Operaiileasupratipurilorpointersunt:

63
*(indirectarea)*parecarezultatobiectuldetipTreferitdepdacpestede
tipulpointerlaT.
& (adresa lui)&p are ca rezultat obiectuldetippointerlaT (T fiindtipul lui
p)carereferpep,decicualtecuvinte,adresaluip.
++,incrementareaidecrementareavalorilordetipadres.
Operaiidecomparare
Operatorii new i delete (doar n C++) pentru alocarea i eliberarea
variabilelordinamicereferitedepointeri.
Limbajul posed numai semantica apelului prin valoare pentru transmiterea

parametrilor actuali ai funciilor. Apelul prin referin se poate simula folosind
explicit pointerii. De multe ori este suficient prima metod de transmitere prin
valoare, mai ales pentru tipurile fundamentale ale limbajului. Ea poate deveni ns
neconvenabil pentru parametri de tipuri de date utilizator de dimensiune mare.
(Observaie: o inconsisten semantic a limbajului C este c tablourile se transmit
ntotdeauna prin referin) i devine un impediment serios n calea definirii unei
notaiiconvenionalepentrutipdedateutilizatordinC++.
Tipuri procedurale
Un tip procedural este un tip de date cu domeniul format din mulimea tuturor
procedurilorsaufunciilorcerespectunanumitablon,definitncadruldeclarrii
tipuluiproceduralncauz.
Uzual, o declaraie de tip procedural specific, printrun constructor de tip un aa
numitablon(pattern)ceconine:
Numelenouluitipprocedural(opional);
Tipul i numele (nume care sunt ns fr semnificaie n contextul
declarrii) eventualilor parametri formali ai procedurilor sau funciilor ce vor
respectaablonul;
Tipulrezultatuluintors(dacevorbadesprefuncii).
O variabil procedural are i ea un nume, un tip i o valoare. Tipul variabilei
conine informaia ce servete la verificarea consistenei folosirii ei (tipul
argumentelor i, eventual tipul rezultatului ntors), iar valoarea unei variabile
procedurale este de fapt adresa codului procedurii n cauz n cadrul programului
executabil.Valorilecesepotatribuincursulexecuieiunuiprogramuneivariabile
de tip procedural sunt (sintactic vorbind) numele procedurilor/funciilor ce sunt
declarate n acel program sau numele procedurilor/funciilor externe de tip
compatibilcu tipul procedural al variabilei care este iniializat. Aceste nume joac
aadar rolul unor constante relativ la tipul procedural respectiv. Invocarea unei
variabiledetipprocedural(folosindparametricorespunztori)arecaefectapelarea
procedurii/funcieireferitedeaceasta.

64
n limbajul C un nou tip se declar prin prefixarea unei declaraii de variabil cu
cuvntul rezervat typedef,numele variabileidevenindnume detip.Aadar,ncazul
definiriidetipurifuncionalevomaveaformageneral:
typedef<declaraie_de_funcie>
Exemple:
typedefvoidffp();//definiiedetip
ffppfp;//definiiedevariabil
typedefvoidfpr(floata,floatb,floatc);
typedeffloatfreal(floatx);
typedeffloatffunc(floatp1,floatp2,frealf);
n limbajul C numele unei funcii este evaluat n cadrul programelor la adresa de

nceput a funciei n cadrul codului compilat, deci variabila pfp de mai sus va
reprezenta o cantitate de tip adres compatibil cu orice valoare reprezentnd
numeleuneifunciifrparametriidetipvoid.
Adresa unei funcii se obine deci prin simpla specificare a numelui funciei fr
paranteze i aceast adres poate fi atribuit unui pointer de funcie cu rezultat i
parametricompatibili.Pointerulpoatefifolositapoipentruapelulfunciei:
intf(int,char);//declaraiafuncieif
int (*pf)(int,char);/* sedeclar pfca pointer la funciede dou argumente(int ichar) ce ntoarce
unntreg*/
inti,j;charc;
pf=f;//atribuiredeadrese
j=(*pf)(i,c);//apelulfuncieiffolosindpf
Limbajul C cere ca la apelul unei funcii chiar i fr parametri s fie utilizate

parantezelerotunde.Sepotscrieurmtoarelesecvene:
if(f1()!=f()){}//testasupravalorilorreturnate
sau
if(f1!=f){}//testasupravaloarilorprocedurale
Tipul ntors i tipurile argumentelor sunt considerate parte a tipului funciei;

argumentele implicite nu. Funciile nu pot ntoarce tablouri de funcii, dar pot
ntoarcepointerilaastfeldeobiecte.Nuexisttablouridefuncii,darexisttablouri
depointerilafuncii.
Tipuri structurate
Limbajele de programare dispun de modaliti de agregare a datelor care permit
apoi tratarea global a acestora. Este vorba n general de date care corespund
nivelului de abstractizare al limbajului, deci care nu au corespondent direct n

65
tipurile main. Pentru ca aceste date definite de utilizator conform nevoilor sale
concretespoatfiintegratenmecanismuldetipuriallimbajului,acestadinurm
puneladispoziiaprogramatoruluiconstructoriidetipuri.nparagrafeleprecedente
am discutat despre dou clase de tipuri construite prin asemenea constructori:
pointeriiitipurileprocedurale.
Spre deosebire de tipurile simple care sunt atomice, indivizibile, datele structurate
(compuse, agregate) se descompun n componente sau elemente, fiecare de un tip
precizat (simplu sau structurat). O dat structurat poate fi accesat fie ca ntreg
(global), fie pe componente. Structura unei date stabilete relaiile care exist ntre
componenteleacesteia.
Existpatrulegturistructuralefundamentale:
Mulime(niciolegturntrecomponente);
Liniar(legtur1:1);
Arbore(legtur1:n);
Graf(legturm:n)
Dinpunctuldevederealuniformitiistructurale,datelestructuratesempartn:
Omogene (toate componentele au acelai tip); tipurile de date aferente sunt
numitetablou(engl.array)imulime(engl.set);
Heterogene (elementele unei date au de obicei componente diferite de tip);
eleaparintipuluidedatenregistrare(engl.record).
Tablourile i nregistrrile au o structur liniar: exist o prim i o ultim
component, iar toate celelalte au fiecare att predecesor, ct i succesor. Prin
urmare, un element al tabloului sau un cmp al nregistrrilor se pot localiza. Un
tablou este un agregat de elemente de acelai tip, un element fiind localizat prin
poziia pe care o ocup n cadrul acestuia (indicele elementului de tablou) iar o
nregistrare este un agregat care grupeaz de obicei elemente de tipuri diferite
numite cmpuri i localizate prin numele lor. Mulimea este o structur amorf: ea
conine elemente de acelai tip, care ns nu pot fi localizate explicit, neexistnd
informaiadeapartenenaunuielementlaea.nlimbajulCnuexistsuportpentru
tipul mulime, exist ns alte limbaje cum este Pascal, n care se poate folosi tipul
mulime.
Pentru tipurile structurate, exist dou operaii de baz: construirea i selectarea
componentelor. Operaia de construire a unei variabile de tip structurat se face
dupregulilepropriifiecruilimbaj.Pentrutablouriinregistrriexistioperaia
deselectareauneicomponente,careesterealizatnmanierediferite.
ncazulunuitablou,selectareaunuielementsefacepebazauneiexpresiideindice,
ataat numelui variabilei tablou. Pe baza expresiei de indice i a informaiilor
despretablouseefectueazcalcululadreseielementuluincauz.Expresiadeindice
nu se poate evalua la compilare (ea conine de regul identificatorii), valoarea ei
fiindobinutlaexecuie.
Domeniul de vizibilitate al numelor cmpurilor unei nregistrri ncepe cu punctul
lor de declarare i se termin la sfritul declaraiei tipului nregistrare. Selectarea

66
unei componente (cmp) se face pe baza unei expresii de selectare, care conine
numele cmpului calificat cu numele variabilei nregistrare. n acest caz, adresa
relativacmpuluincauzsepoatedeterminalacompilare.
Tipul tablou
Elementeledefinitoriialetipuluidedatetablousunt:
Numele(opional)
Listadimensiunilor
Tipulelementuluidetablou
Domeniulpentrumulimeaindicilor
Numele unui tip tablou este un identificator, construit pe baza regulilor proprii
fiecrui limbaj. Lista dimensiunilor precizeaz numrul de dimensiuni al tabloului
respectiv, existnd restricii de la limbaj la limbaj privind numrul maxim de
dimensiuni permis. Tipul elementului de tablou definete natura acestui element,
preciznd reprezentarea lui, iar domeniul pentru mulimea indicilor este de obicei
detipsubdomeniu.
Criteriiledeclasificareatablourilorsunt:
Numruldedimensiuni
Tipulelementului(carepoateinduceoperaiispecifice)
Momentulalocrii
Posibilitatearedimensionrii
Dinpunctuldevederealnumruluidedimensiuni:
Tablourimonodimensionale(vectori)
Tablouribidimensionale(matrici)
Tablouritridimensionale
ngeneral,tablouriddimensionale
Din punctul de vedere al momentului alocrii, exist dou categorii de tablouri:
statice i dinamice. Tablourile statice se aloc la compilare (sau cel puin trebuie
cunoscute dimensiunile la compilare). Pentru tablourile dinamice, dimensiunile
acestora se determin abia la execuie. O categorie special de tablouri dinamice o
reprezinttablourileflexibile,caresepotredimensionantimpulexecuiei.
Referirealaunelementaltablouluisefaceprinprecizareanumeluitablouluiurmat
deoexpresiedeindice.Expresiadeindiceconine,nparantezerotundesaudrepte
(n C) valorile efective ale indicilor tabloului. Exist dou modaliti de referire:
punctualidesubtablouri.Ambelemodalitisebazeazpecalcululdeadres.
Calcululdeadresrealizeaz,pentruoexpresiedeindicedat,determinarealocaiei
de memorie (a adresei) ce conine elementul de tablou referit. Deoarece memoria
calculatoruluipoateficonsideratcatabloumonodimensionaldelocaiiadresabile,
problemacalcululuideadressereduceladeterminarea,pebazainformaieiasupra
indicilor i asupra tabloului n general, a unui numr ce reprezint adresa cutat.

67
Pentrufiecaretabloudeclarat,sememoreazndescriptoruldetablouurmtoarele
informaii:
numenumeletabloului
tiptipulelementuluidetablou
lunglungimeareprezentriiunuielementdetablou(nunitidealocare)
adrsadresadeundencepememorareatabloului
nrdnumruldedimensiunialtabloului
pentrufiecaredimensiune,limiteleli
i
ils
i
(1<=i<=nrd).
Sepresupunectablouluiisealoclocaiiconsecutivedememorie,decielocupo
zon compact. Fiecare element de tablou va ocupa, n zona respectiv, o locaie
unicdeterminat.Existdoumodalitidememorareaunuitablou:
pelinii(cndultimulindicevariazmairepede)
pecoloane(cndprimulindicevariazmairepede)
Notnd cu loc o funcie ce ntoarce adresa locaiei de memorie a unei referine de
tablou, pentru dou tablouri A(li:ls) i B(li
1
:ls
1
, li
2
:ls
2
), calculele de adres se scriu
astfel:
loc(A(i))=adrs+(ili)*lung
sau
loc(A(i))=adrsli*lung+i*lung
Memorareapelinii:
Toateelementeleliniiloranterioarelinieiiplusprimelej1elementealelinieii
loc(B(i,j))=adrs+(ili
1
)*(ls
2
li
2
+1)*lung+(jli
2
)*lung
sau
loc(B(i,j))=adrsli
1
*(ls
2
li
2
+1)*lungli
2
*lung+ (constant)
+j*lung+i*(ls
2
li
2
+1)*lung
Memorareapecoloane:
Toate elementele coloanelor anterioare coloanei j plus primele i1 elemente ale
coloaneij
loc(B(i,j))=adrs+(jli
2)*(ls1li1+1)*lung+(ili1)*lung
sau
loc(B(i,j))=adrsli2*(ls1li1+1)*lungli1*lung+ (constant)
+i*lung+j*(ls
1
li
1
+1)*lung
n expresiile de mai sus, ultimele relaii corespund unor calcule optime de adres,
pringruparealanceputatermenilorconstani(termeniicenuconinindiciiiijca
factori).
Elementelecetrebuietratatecndsediscutprezenatipuluitablounlimbajelede
programaresunt:

68
regulile sintactice de definire a tablourilor i de referire a elementelor
acestora;
familiadetipuridedatecepotficonsideratecaelementedetablou;
familiadetipuridedatecepotfiutilizatecaindicidetablou;
cndtrebuiecunoscutedomeniileindicilor:lacompilaresaulaexecuie;
numrul maxim de dimensiuni permis (care este legat de complexitatea
calcululuiadreseiunuielement);
posibilitatearefeririilasubtablourileunuitabloudat;
cumsefaceiniializareatabloului;
operaiilepredefinitepetablouri.
Tipul de date nregistrare

Elementeledefinitoriialeuneinregistrrisunt:
numeleitipulnregistrrii;
numruldecmpuri;
numeleitipulfiecruicmp.
nregistrareaesteomodalitatedeagregare(punerempreunaunordatedetipuri
n general diferite). Numele tipului de dat nregistrare este un identificator.
Numruldecmpuriestededusdinlistadedeclarareacmpurilor.Cmpurileunei
nregistrri se memoreaz n zone adiacente de memorie. Informaia de tip a
fiecrui cmp servete la stabilirea lungimii de reprezentare a acestuia, iar numele
cmpului se folosete pentru a accesa valoarea lui (prin operaia de selectare). De
obicei, sunt accesibile att data compus (nregistrarea), ct i componentele
(cmpurile)acesteia.
nCavemdoutipuridenregistrri:structurilecareauostructurfixiuniunile
unfeldenregistrarecustructurvariabil.
Elementelecetrebuieavutenvederecndsediscutdesprenregistrrisunt:
manieradedeclarare;
manieradeaccesareacmpuriloracestora;
iniializarea;
operaiilepermisepentruvariabileledetipnregistrare.
nregistrrile sunt precursorii claselor. Clasa este un concept fundamental n
programareaorientatpeobiecte.
LimbajulCnepermitedeclarareadetipurinregistrare(struct)iuniuni(union).
Sintaxapentrudeclarareauneistructurieste:
struct[nume]{[tipnume_var];

}[variabile];

69
Dei numele asociat structurii i variabilele de structur declarate sunt elemente
opionaletrebuiesaparmcarunadinceledou.
Exemplu:
struct{charnume[30];
intvarsta;floatgr;}cineva;
declarvariabilacinevacafiindostructurcegrupeaztreitipurideinformaii.
Pentru a se putea declara mai multe variabile de aceeai structur exist dou
posibiliti:
atribuireaunuinumepentruansamblulcmpurilorstructurii:
structpersoana{charnume[30];
intvarsta;floatgr;};
structpersoanacineva,altcineva[20];
structpersoanaNoi[],*Voi[];
definireaunuinumedetippentruspecificaiastructurii:
typedefstruct{charnume[30];
intvarsta;floatgr;}persoana;
persoanacineva,altcineva[20];
Operaiilepermiseasuprastructurilorsunt:
selectareaunuicmp(prinoperatorul.);
obinereaadreseiuneistructuri(prin&);
determinarealungimiiuneistructuri(prinsizeof);
atribuireauneistructuri(prin=).
Exemplu:
structpers{inta;charb;}p1,p2={2,b};//iniializare
p1=p2;//atribuiredestructuri
Notaiaps>campesteechivalentcu(*ps).camp.
Deexemplu:
struct
{
intx;
int*y
}*p;
declar p ca fiind pointer la o structur format din dou cmpuri: un ntreg i un

pointerlantreg.Atunci,inndcontideprioritateaoperatorilor,vomavea:
++p>xincrementeazpex,operatorul>avndprioritatemaimaredect++;
(++p)>x incrementeaz mai nti pe p i apoi acceseaz elementul x din
structuranoupointat;
(p++)>xseacceseazntixapoiseincrementeazp;

70
*p>yindicconinutuladreseipointatdey;
*p>y++acceseaznticeeacepointeazyiapoiincrementeazy;
(*p>y)++incrementeazceeacepointeazy;
*p++>yacceseazceeacepointeazyiapoiincrementeazpointerulp.
Uniunile permit utilizarea n comun a unei zone de memorie de ctre mai multe
obiecte(numitemembri)detipuridiferiteiaresintaxa:
unionnume_uniune{[tipnume_var]}[decl_variabile];
Exemplu:
unionamestec{inti;floatf;char*psir;}X;
semnificfaptulcvaribilaXpoateconinenaceeaiariedememoriefientreguli,
fierealulf,fiepointerulpsir.ConinutulzoneidememoriealocatpentruvaribilaX
(de lungime egal cu dimensiunea de reprezentare a celei mai lungi variante) va fi
interpretat fie ca ntreg, fie ca real, fie ca pointer la caracter, n funcie de cmpul
selectat.Coninuturilecmpurilorseacceseazcalastructuri:
X.int X.f X.psir
Avndnvederespaiulcomuntuturorvariantelor,atribuireaunuiadintrecmpuri
va afectaimplicit ivaloareacelorlalte. ntreagarspundere acontroluluiuniunilor
revine programatorului. O uniune este o structur n care toi membri au
deplasamentul zero, structura fiind suficient de mare pentru a putea pstra pe cel
maimaremembru.
Tipuri definite de utilizator
POO

71
6. Expresii
Expresiile sunt elementele de baz prin care se precizeaz calculele. Din punct de
vedere sintactic, expresia este o secven de operanzi i operatori, care exprim un
proces de calcul. O expresie poate avea o valoare, determinat prin procesul de
evaluare. n decursul evalurii exist posibilitatea modificrii i altor valori din
contextulevalurii,fenomenedenumiteefectesecundare(engl.sideeffects).
ncontinuarevomprezenta:
Notaiilefolositepentruexpresii;
Domeniuldevizibilitateaalnumelor;
Stabilireatipului(conversii);
Evaluareaexpresiilor.
Generaliti
Sintaxa unei expresii
O expresie este format din operanzi i operatori. ntre criteriile de clasificare a
expresiilorenumerm:
Numruldeoperanzi;
Poziiaoperatoruluinraportcuoperanzii;
Tipulrezultatului;
Semantic.
DefiniiaexpresieinC.
Operatori
nfunciedenumruldeoperanzi,expresiileseclasificn:
Expresiiunareunsinguroperand;
Expresiibinaredoioperanzi;
Narenoperanzi.
Numrul de operanzi necesar este o caracteristic a unui operator i se numete
aritatea respectivului operator. Exist operatori cu aritatea fixat i operatori care
au aritatea variabil. De exemplu, n Lisp, operatorul + poate avea unui, doi sau
maimulioperanzi.
Duppoziiaoperatorilornraportcuoperanzii,expresiileseclasificn:
Expresiiinfixoperatorulsepunentreoperanzi;
Expresiiprefixoperatorulsepunenainteaoperanzilor;
Expresiipostfixoperatorulsepunedupoperanzi.
Pentru cazul operatorilor binari, expresiile binare formate cu operatorul op i
operanziiE1iE2sescriuastfel:

72
Notaiainfix:E1opE2
Notaiaprefix:opE1E2
Notaiapostfix:E1E2op
De exemplu, dac operatorul op este cel de adunare, adic +, iar operanzii sunt
dou expresii simple (variabile), notate cu x i y, atunci expresia care denot suma
acestorasescrie:
Notaiainfix:x+y
Notaiaprefix:+xy
Notaiapostfix:xy+
Analog,oexpresiescrismatematicnforma(x+y)*zsevatranscrieastfel:
Notaiainfix:(x+y)*z
Notaiaprefix:*+xyz
Notaiapostfix:xy+z*
n notaiainfix (notaie uzual n matematic), un operand E se poateinclude ntre

paranteze, n forma (E) pentru claritatea exprimrii; valoarea lui nu se modific n
prezenaparantezelor.nnotaiaprefixipostfixnumaisuntnecesareparantezele,
deoareceoperanziifiecruioperatorsepotdeterminaframbiguiti.
Regulilenotaieiprefixsunt:
Pentrufiecareoperatorsecunoatearitatealui;
Notaiaprefixpentruoconstantsauvariabilesteconstantasauvariabilan
cauz;
Aplicarea operatorului binar op la subexpresiile E1 i E2 se scrie n notaia
prefixnformaopE1E2.
Aplicareaoperatoruluinar(dearitaten>=0)op
n
lasubexpresiileE1,E2,,En
sescriennotaieprefixcaop
n
E
1
E
2
E
n.
Dacsenlturprimaregulatuncicelelaltedouregulideconstruireaexpresiilor
se modific: este necesar prezena parantezelor pentru a delimita o expresie, deci
expresiileconstruitevoraveaforma:(opE1E2)respectiv(op
n
E1E2En).
Regulilenotaieiinfixsunt:
Pentrufiecareoperatorsecunoatearitatealui;
Notaia postfix pentru o constant sau variabil este constanta sau variabila
ncauz;
Aplicarea operatorului binar op la subexpresiile E1 i E2 se scrie n notaia
postfixnformaE1E2op.
Aplicareaoperatoruluinarar(dearitaten>=0)op
n
lasubexpresiileE
1
,E
2
,,
EnsescriennotaieprefixcaE1E2Enop
n

73
Precedena operatorilor
Rezolvareaambiguitilorncazulnotaieiinfixsefaceprindoureguli,privind:
Precedenaoperatorilor;
Asociativitateaoperatorilor(pentruoperatoriicuaceeaipreceden).
Acesteambiguitiapardeobiceilaexpresiilearitmetice,lacareoperatoriibinarise
grupeaz pe trei niveluri de preceden (prioritate), prezentai n continuare n
ordineadescresctoareaprioritii:
Operatorulridicarelaputere(^prezentnunelelimbaje);
Operatoriimultiplicativi(*,/i%)
Operatoriiaditivi(+i).
Fiecare categorie de operatori are preceden (prioritate) mai mare dect cei care
urmeazdupea.
Astfel,expresia:a+b*csevaevaluacaa+(b*c),iara*b+csevaevaluaca(a*b)
+c(parantezeleindicordineancareseefectueazaplicareaoperatorilor).
n exemplele de mai sus sa folosit numai precedena operatorilor. Dac ntro
expresieaparedemaimulteoriacelaioperatorsauoperatoricuaceeaiprioritate,
acioneazaldoileagrupderegulicarestabileteasociativitateaoperatorilor.Exist
doutipurideasociativitate:lastngailadreapta.
Unoperatoresteasociativlastngadacsubexpresiilecareconinapariiimultiple
aleluisegrupeazdelastngaladreapta.Astfel,sumaa+b+cesteinterpretatca
(a+b)+c,deciprimadatseefectueazsumaa+biarapoirezultatulsevaadunala
valoarealuic.
Unoperatoresteasociativladreaptadacsubexpresiilecareconinapariiimultiple
aleluisegrupeazdeladreaptalastnga.Astfel,expresiaa=b=cesteinterpretat
caa=(b=c).
Asociativitatea operatorilor se aplic doar n situaia cnd acetia au aceeai
prioritate.
Majoritatea limbajelor de programare posed astfel de reguli de preceden i
asociativitate.
LimbajeleCiC++posedceamaimarecoleciedeoperatori.
ProritateaiasociativitateaoperatorilornlimbajulC:
Operatorul Descriere Asociativitat
e
1. ()
[]
>
.
Apeldefuncie
Accesareelementtablou
Selectare membru structur prin
pointer
Selectaremembrustructurdirect
de la stnga
ladreapta
2.
Unari
!
~
++
Negarelogic
Complementpebii
Preincrementare sau
postincrementare
Predecrementare sau
postdecrementare
de la dreapta
lastnga

74
*
&
(tip)
sizeof
Plusunar
Minusunar
Indirectare
Adres
Cast
Returneazdimensiuneaoperandului
3.
Multiplicativi
*
/
%
nmulire
mprire
Rest
de la stnga
ladreapta
4.
Aditivi
+
Plusbinar
Minusbinar
de la stnga
ladreapta
5.
Deplasare
<<
>>
Deplasarelastnga
Deplasareladreapta
de la stnga
ladreapta
6.
Relaionali
<
<=
>
>=
Maimic
Maimicsauegal
Maimare
Maimaresauegal
de la stnga
ladreapta
7.
Egalitate
==
!=
Egal
Diferit
de la stnga
ladreapta
8. & Ipebii de la stnga
ladreapta
9. ^ XORpebii de la stnga
ladreapta
10. | SAUpebii de la stnga
ladreapta
11. && Ilogic de la stnga
ladreapta
12. || SAUlogic de la stnga
ladreapta
13.
Condiional
?: a?x:y(ifathenxelsey) de la dreapta
lastnga
14.
Atribuire
=+==
*=/= %= &=
^=|=
<<=>>=
de la dreapta
lastnga
15.Virgul , de la stg. la
dr.
Arborele unei expresii

O expresie este format din operatori i operanzi. Structura expresiei ilustreaz,
pentru fiecare operator, operanzii la care acesta se aplic. n exemplele anterioare
de expresii infix, structura expresiei sa precizat, pentru claritate, prin folosirea
parantezelor rotunde. Se observ c structura expresiei este independent de
manieraeidenotare(infix,prefixsaupostfix).
O manier alternativ de ilustrare a structurii unei expresii folosete arborii nari.
ntrun astfel de arbore, numit arbore sintactic al expresiei, nodurile reprezint

75
operatorii,iarsubarboriireprezintoperanzii.Constantele ivariabilele (expresiile
simple)suntfrunzele(nodurileterminale)aleunuiastfeldearbore.
Pentru un operator op
n
de aritate n>=0, expresiei construit cu el, care se scrie op
n
E1 E2En (n notaie prefix), respectiv E1 E2En op

n
(n notaie postfix) i va
corespundearborele:
De exemplu, pentru expresia (a + b) * (c * d * e 4 / f) arborele sintactic este un

arborebinar(toioperatoriiauaritatea2)deforma:
Arborii de sintax sunt abstraci, reprezentarea lor fiind aceeai, independent de

notaiafolositpentruexpresie.nfapt,denumireanotaiei(infix,prefixsaupostfix)
provinedelamanieradeparcurgere(vizitare)anodurilorarborelui:
Prefix(rccin,subarboridelastngaladreapta):*+ab**cde/4f
Afix (subarbore stng, rdcin, subarbore drept; numai pentru arbori
binari):a+b*c*d*e4/f
Postfix(subarboridelastngaladreapta,rdcin):ab+cd*e*4f/*
Clase de operatori i de expresii (dup tipul rezultatului)
n funcie de natura operaiilor pe care le semnific, operatorii se pot clasifica n
urmtoarelecategorii:
Aritmetici
Relaionali
Logici
Pemulimi
Peiruridecaractere

76
Peiruridebii
Pepointeri
Operatoruldedeterminareadomeniuluidevizibilitate(engl.scoperesolution
operator)
Conversieexplicit
Atribuire
Condiional
Operatorulvirgul.
Tipul expresiei se stabilete pe baza tipurilor operanzilor i operatorilor ce
formeazexpresia.
Operatori aritmetici
Operatorii aritmetici se folosesc la construirea expresiilor aritmetice. Operanzii
unor asemenea expresii trebuie s fie de tipuri numerice, iar rezultatul evalurii
expresieiestetotdetipnumeric.Fiecarelimbajposedpropriileregulideefectuare
acalculeloridestabilireatipuluirezultatului.
Operatori relaionali
Operatorii relaionali se aplic unor operanzi de tipuri variate, producnd un
rezultatBoolean.nCnuexisttipulboolean.Oricevaloarentreagdiferitdezero
este tratat ca true i valoarea ntreag zero este tratat ca false. Operatorii
relaionalisunt:<,>,<=,>=,==(egalitate),!=(inegalitate).
Operatori logici
Operatorii logici au de regul operanzi de tip boolean i ntorc un rezultat de tip
boolean.
Operatorii logici n C sunt: && (i logic), || (sau logic), ! (negaie logic operator
unar).Opereazasupraunorntregiiarrezultatulestezero(false)sauunu(true).
Operatori pe mulimi
Operatorii pe mulimi au operanzi de tip mulime i ntorc un rezultat de tip
mulime.Acetioperatoriexistdoarnlimbajelecesuporttipulmulime.Limbajul
Cnusuportacesttipdedate.

77
Operatori pe iruri de caractere
Limbajeledeprogramarecareautipuldedateirdecaractere(string)furnizeazi
operatori pentru lucrul cu iruri de caractere (de exemplu operatorul + pentru
concatenareaadouiruri)
n limbajul C nu exist de date special pentru iruri de caractere, oferinduse n
schimb posibilitatea folosirii tablourilor unidimensionale de caractere pentru
memorarea irurilor. Din aceast cauz nu sunt disponibili nici operatori pentru
iruri. Biblioteca standard C conine un set de funcii dedicate operaiilor cu iruri,
declarate n fiierul <string.h>. strcpy (pentru copiere de iruri), strcat (pentru
concatenaredeiruri),strcmp(pentrucomparareaadouiruri)etc.
Operatori pe iruri de bii

Acetia sunt operatori care lucreaz la nivel de reprezentare pe bii, aplicnd
operaiilelogicecunoscutebiilorcorespunztori(capoziiencadrulreprezentrii)
ai operanzilor. Valorile biilor (0 i 1) se consider la aplicarea operaiilor drept
valorideadevr.
Acest tip de operatori este specific mai degrab limbajelor de asamblare dect
limbajelor de nivel nalt, ns datorit orientrii anumitor limbaje spre aplicaii de
sistem(nspecialCiC++)eleaufostprevzutecuacestgendeoperaiicarepermit
accesullamemorielaniveldebit.
LimbajeleCiC++dispunde:
1. operatori de deplasare a coninutului unei locaii de memorie spre stnga
(<<) i spre dreapta (>>). Astfel, a << b, unde a i b sunt expresii ntregi,
iar b are o valoare ntreag nenegativ, are ca rezultat valoarea obinut
dupdeplasareareprezentriivaloriiacubbiisprestnga.Biiieliberaila
dreapta se completeaz cu zero. Dac tipul este unsigned, deplasarea la
stnga este echivalent cu o nmulire cu 2 la puterea b, urmat de o
trunchierelanumruldebiiaitipului.Prina>>bserealizeazdeplasareala
dreapta.Aici rezultatuloperaieidifernfunciede tipulvalorii (maiprecis
de semnul acesteia): pentru valori unsigned codul binar este deplasat spre
dreapta cu b poziii i se insereaz ntotdeauna la stnga bii cu valoarea 0.
Rezultatulestedefaptparteantreagampririila2laputereab;pentru
valori signed nu se introduc automat zerouri la stnga ci se multiplic bitul
cel mai semnificativ (bitul de semn). Operaia se numete deplasare
aritmeticspredreaptaiarecaefectconservareasemnului.
2. operatoribooleenipebii(&Ibitcubit,|SAUbitcubit,^SAUEXCLUSIV
bit cu bit, ~ negare bit cu bit). Aceti operatori efectueaz operaiile
specificate asupra unor expresii ntregi. Prin a & b se obine o secven de
biideaceeailungimecuaoperanzilor,ncareunbitarevaloarea1daccei
doibiicorespunztoridinaibsunt1,iarevaloare0ncazcontrar.Prina
|bfiecarebitalrezultatuluiarevaloarea0dacbiiicorespunztoridinaib

78
sunt 0, i are valoarea 1 n caz contrar. Operatorul unar ~ aplicat unei
expresii a, schimb n reprezentarea valorii lui a fiecare bit 0 n 1 i fiecare
bit 1 n 0. Din punct de vedere al operrii practice este bine de reinut c
operaiileprezentatesuntutilepentruurmtoarelesituaii:
& permite izolarea valorii unui anumit bit sau forarea unor bii la valoarea
zero.
| permiteforareaunorbiilavaloarea1.
^ permitecomplementareavaloriiunorbiifrativaloarealor.
~ realizeazcomplementareatuturorbiilorvaloriiargumentului.
n general, pentru realizarea unor astfel de scopuri se folosete ca un al doilea
operandomasc(aceastafiindoconfiguraiedebiialeasdeprogramatorntrun
modadecvat).
Conversie explicit i implicit

nCiC++estecelmaibineilustratconceptuldeconversie.
n unele situaii, este nevoie de conversia explicit a valorii unui anumit tip la
valoarea altui tip. O conversie explicit de tip produce o valoare a unui tip pe baza
valoriialtuitip.Astfel:
floatr=float(1);
efectueaz conversia ntregului 1 n valoarea n virgul flotant 1.0f nainte de a se

efectua operaia de atribuire. Rezultatul unei conversii de tip nu este o lvaloarea,
decinupoatefiatribuit(cuexcepiatipuluireferin).
Exist dou notaii pentru conversia explicit de tip: notaia C tradiional, numit
cast, de ex. (double)a i notaia funcional double(a). Ultima nu se poate folosi
pentru tipuri care nu au nume simplu. Astfel, pentru a converti o valoare la un tip
pointeranonim,sevafolosinotaiacast:
char*p=(char*)0777;
sausepoatedefiniunnounumedetipiatuncisepoatefolosinotaiafuncional:
typedefchar*Pchar;
char*p=Pcahr(0777);
O conversie de tip trebuie evitat dac nu este necesar. Programele care folosesc
conversii explicite de tip sunt mai greu de neles dect programele care evit
conversiile prin recurgerea la tipuri pentru a reprezenta concepte de nivel nalt.
Corectitudinea conversiilor explicite de tip depinde n mod critic de modul n care
programatorulnelegemanierancareobiectelediferitesunt gestionatedelimbaj,
precumidedetaliiledeimplementareacompilatorului.Deexemplu:

79
inti=1;
char*pc="asdf";
int*pi=&i;
i=(int)pc;
pc=(char*)i;//pcipoateschimbavaloarea.
//peunelemainisizeof(int)estemaimicdectsizeof(char*)
pi=(int*)pc;
pc=(char*)pi;//pcipoateschimbavaloarea.
//peunelemainiunchar*sereprezintaltfeldectunint*
Peunelemaininuvorfiprobleme,nspealtelepotaparerezultatedezastruoase.
n cel mai bun caz, acest cod este portabil. De obicei este normal (i sigur) s se
presupun c pointerii la diferite structuri au aceeai reprezentare. Mai mult, orice
pointer se poate atribui (fr conversie explicit de tip) la un void*, iar un void* se
poateconvertiexplicitlaunpointerdeoricetip.
Conversiaimplicitaparecelpuinnurmtoarelesituaii:
laoperaiadeatribuire;
laapelulunuisubprogram,ncadrulprocesuluideevaluareaaparametrilor;
laevaluareauneiexpresiimixte.
Operatorul condiional
Limbajele C i C++ dispun de un operator condiional (?:) care se poate utiliza n
cazurilecndinstruciuniledeexecutatsuntexpresii.Sintaxageneraleste:
expr_logic?expr_adev:expr_fals
echivalentsemanticcu:
if(expr_logic)expr_adev;elseexpr_fals;
Expresia expr_logic trebuie s fie de tip aritmetic sau pointer. Dac evaluarea ei
furnizeazovaloareadiferitdezero,rezultatulexpresieicondiionaleestevaloarea
expresiei expr_adev, n caz contrar fiind valoarea expresiei expr_fals. Eventualele
efecte secundare introduse de evaluarea expresiei expr_logic au loc nainte de
evaluarealuiepxr_adevsauexpr_fals.
Determinarea maximului a dou valoria a i b se poate face prin expresia
codiional:
max=(a>b)?a:b;

80
Operatorul virgul
nCiC++virgulaesteconsideratoperatorcuurmtoareasemnificaie:osecven
deexpresiideforma
epxr1,expr2,,exprN
reprezinteansioexpresiencareseevalueazsuccesiv,delastngaladreapta
expresiile. Valoarea final atribuit expresiei secven este cea a expresei exprN.
Expresiile componente trebuie s fie atribuiri, incrementri sau decrementri, n
afardeexprNcarepoatefioarecare,deoareceaceastadvaloareantregiisecvene.
Efectele primelor N1 expresii sunt de fapt efectele secundare ale unei astfel de
expresiisecveniale.Deexemplu,dupefectuareaatribuiriidemaijos:
intx=6,y=7,z,w;
w=(z=y+x,y=yx,x=x*yz,x+y+z);
vomobine
x=7;y=1;z=13;w=7;
n listele de parametri actuali sau de iniializatori, operatorul virgul trebuie s

apar n cadrul unei expresii secveniale cuprins ntre paranteze. De exemplu,
apelul
f(a,(b=3,b+4),c);
aretreiparametriactuali,aldoileaavndvaloarea7.
Modaliti de evaluare a expresiilor
Determinareavaloriiuneiexpresiisenumeteevaluare.Ocondiienecesarpentru
evaluare, din punct de vedere matematic, este c ea trebuie s produc o valoare,
dar nu trebuie s altereze mediul. Acest lucru poart numele de transparen
referenial. Denumirea vine de la faptul c orice referire de variabil sau funcie
trebuiesfietransparent,adicefecteleartrebuisfiedoarceleevidentepentruo
accesare, adic ntoarcerea unei valori. Din pcate n lumea limbajelor de
programareimperativelucrurilenustauchiaraa.Dacexpresiaconineunapelde
funcie sau operatori care afecteaz valoarea unor operanzi nainte sau dup
evaluare (cum ar fi de exemplu ++ i din C), exist posibilitatea ca evaluarea
expresieisducilamodificareamediului.Oastfeldemodificaresenumeteefect
secundar(engl.sideeffect)
n general pentru o expresie de forma: operand1 op operand2, evaluarea ei
presupuneevaluareacelordoioperanziiapoiaplicareaoperatoruluiop.

81
Evaluarea expresiilor aritmetice mixte
n expresiile aritmetice mixte, operanzii sunt att numere ntregi ct i numere
reale. Datorit heterogenitii operanzilor, exist mai multe variante de evaluare a
acestorexpresii,careconduc,ngeneral,larezultatediferitepentruaceeaiexpresie
iaceleaivalorialeoperanzilor.Prezentmdoudintreacestea:
1. Stabilirea unor reguli clare privind tipul rezultatului unei operaii n funcie
de tipul operanzilor (n acest caz tipul rezultatului va fi decis la execuia
ultimei operaii aferent evalurii expresiei), conversiile fcnduse
(eventual)laterminareaevaluriisubexpresiilor.
2. Stabilirea prealabil a tipului rezultatului i apoi conversia automat a
tuturoroperanzilordealttiplatipulexpresiei,indiferentdacprinconversie
lungimea de reprezentare se mrete sau se micoreaz (n acest caz
stabilirea tipului rezultatului poate fi impus de programator sau se poate
faceprinexaminareaexpresieideevaluat).
O modalitate de evitare a posibilelor erori de calcul (care sunt de fapt provocate
numai de necunoaterea conveniilor stabilite) este aceea prin care sunt permise
numai conversiile implicite care nu afecteaz modificarea valorii variabilei (n
sensulpierderiideinformaie),aanumiteleconversiiprinlrgirea(engl.widening)
domeniului(delantreglarealsaudublprecizie,delarealdublprecizie),lrgirea
semnificndaicimrireaspaiuluidereprezentareavariabileirespective.Totodat,
conversiile care implic pierderea de informaie (n sensul c dimensiunea de
reprezentare a destinaiei este mai mic dect a sursei; conversiile respective se
numesc conversii prin ngustare, engl. narrowing) nu sunt permise implicit, ci doar
prinutilizareaunorfunciispecifice.
Compararea expresiilor de tip pointer

Dou expresii de tip pointer sunt egale dac au ca valoare o aceeai adres de
memorieisuntdiferitencazcontrar.
Evaluarea expresiilor logice

ncazulexpresiilorbooleene(logice),nspecialpentrucazurilecndoperatoruleste
andsauor,esteposibilcasnusecunoascconcomitentvalorileambiloroperanzi.
Deexemplu,expresia:
x!=0||y/x>5
dac x este diferit de zero atunci rezultatul ei este true, indiferent ce valoare de
adevraraveasubexpresiay/x>5.Iarncazulexpresiei:
x!=0&&y/x>5

82
dac x este zero atunci rezultatul ei este false, dar dac se ncearc i evaluarea
subexpresiei y/x>5, ctul y/x este nedefinit, prin urmare nu se poate face aceast
evaluare.Dinexempluprezentatrezultposibilitateaevaluriiscurtcircuitncazul
expresiilorlogice,cuefectebeneficeattpentrutimpuldeexecuie(seeliminunele
operaii inutile) ct i pentru fiabilitatea programului (se evit unele situaii de
excepie).Evaluareascurtcircuitsepoatedefiniprindoureguli:
1. fiinddatexpresiae:=xandy,dacx=false,atuncie:=false
2. fiinddatexpresiae:=xory,dacx=true,atuncie:=true
n C++, expresiile care conin operatorii relaionali <, >, <=, >= folosesc
asociativitatealastnga.Definiiaexpresieirelaionaleeste:
expresierelaional::=
expresiededeplasare
expresierelaional>expresiededeplasare
expresierelaional<expresiededeplasare
expresierelaional<=expresiededeplasare
expresierelaional>=expresiededeplasare
Operanzii trebuie s fie de tip aritmetic sau pointer. Operatorii <, >, <=, >= produc
rezultatul 0 dac relaia specificat se evalueaz la false i 1 dac se evalueaz la
true.Tipulrezultatuluiesteint.
Pentru operanzii aritmetici se efectueaz conversiile aritmetice uzuale, iar pentru
operanziipointerseefectueazconversiidepointer.Deaicirezultc:
Oricepointersepoatecomparacuoexpresieconstantceseevalueazla0.
Orice pointer se poate compara cu un pointer de tipul void* (n acest caz se
faceprimadatconversialavoid*).
Pointerii la obiecte sau funcii cu acelai tip (dup efectuarea conversiilor de
pointeri) se pot compara: rezultatul depinde de poziiile relative ale obiectelor sau
funciilorpunctatedepointerinspaiuladreselor.
Reguliledecomparareapointerilorsunt:
1. doipointerilaacelaiobiectsuntegalidinpunctuldevederealcomparrii;
2. cnd doi pointeri puncteaz spre membri nonstatici ai aceluiai obiect, pot
existaurmtoarelesituaii:
a. Dac cei doi membri sunt separai de o etichet de specificator de
acces i dac clasa obiectelor nu este uniune, atunci pointerul la
ultimul membru declarat (dintre cei doi membri referii) este mai
maredinpunctuldevederealcomparrii.
b. Dac cei doi membri sunt separai de o etichet de specificator de
acces,rezultatulestenedefinit;
c. Dacpointeriipuncteazspremembriaiaceleiaiuniuni,eisuntegali
dinpunctuldevederealcomparrii.

83
3. dacdoipointeripuncteazspreelementeleaceluiaitablou,sauunuldintre
ei puncteaz spre sfritul tabloului, pointerul spre obiectul cu indicele mai
mareestemaimaredectcellalt.
4. celelaltecomparridepointerisuntdependentedeimplementare.
nceeacepriveteexpresiilecareconinoperatorilogici,operanziinutrebuiesfie
de acelai tip, dar trebuie s fie de tip aritmetic sau pointer. Rezultatul este de tip
int.toateefectelesecundareprovocatedeprimaexpresieaulocnaintedeevaluarea
celeideadoua.

84
7. Instruciuniicontrolulexecuiei
Diferiteleoperaiicetrebuieexecutatedeunanumitprogramscrisntrunlimbajde
programare (imperativ) oarecare sunt date sub forma unor instruciuni sau
comenzi. n afara instruciunilor, un program surs mai poate conine declaraii i
eventual,directivedecompilare.nfunciedesemanticalor,instruciunilepotfi:
deatribuire;
deintrareieire;
decontrol.
Instruciunile de intrareieire sunt instruciunile de transfer ntre memorie i
dispozitiveleperiferice.ngeneral,existunniveldevirtualizare,nsensulcnuse
realizeaz operaiile de intrareieire direct pe suport, ci pe fiiere. Aceste operaii
suntdependentedemain.
Instruciunile de control: execuia unui program scris ntrun limbaj de programare
imperativ nu este altceva dect un ir de transformri ale valorilor unor locaii de
memorie. Aceast execuie este controlat de mecanisme ale cror rol este de a
determina ordinea de execuie a instruciunilor dintrun program. Aceste
mecanisme se numesc instruciuni de control i, mpreun cu instruciunile de
atribuire,vomdiscutadespreelencontinuare.
Putemclasificainstruciuniledecontrolastfel:
instruciunicondiionale;
instruciunideciclare;
instruciunidelucrucusubprograme(realizeazdoulucruri:declarareade
subprogrameiapelareasubprogramelorinclusivrevenireadinacestapel);
instruciunidetransfer(salt)
Din punctul de vedere al structurrii lor, instruciunile sunt simple i compuse. O
instruciune simpl realizeaz o aciune bine precizat semantic, iar o instruciune
compus este format din mai multe instruciuni simple, grupate mpreun prin
folosirea de obicei a unor cuvinte cheie cu rol de delimitatori (begin end n unele
limabje).
Instruciunea de atribuire
Instruciuneadeatribuireareformageneral:
expridopatrexpr
unde:
exprid esteoexpresiedeidentificare;
opatr esteoperatoruldeatribuire;
expr esteoexpresie.

85
De obicei, ntro instruciune de atribuire, numele unei variabile are dubl
identitate: valoare stng (lvaloare engl. leftvalue), cu semnificaie de referin
(adresa zonei de memorie asociat variabilei) i valoare dreapta, rvaloare, cu
semnificaiedevaloare(valoareamemoratnzonarespectivdememorie).
Deexempluninstruciunea
x=x+1;
se face apel la lvaloarea lui x n stnga operatorului = i la rvaloarea lui x n

dreaptaoperatorului=.
n limbajele actuale exist operatori prefix care produc adresa unei variabile
(operatorul@nPascal)sautipuri(tipulreferinnC++).Deexemplu:
inti;
i=5;
int&ri=i;//inC++
ri=7;
Aici valoarea variabilei i se poatemodifica att obinuit (prima instruciune), ct i

prinintermediulreferineiri.Variabileiiiafostasociatvariabiledetipreferinri
aa c oricare din numele i sau rivor denota acelai obiect, deci modificareafcut
nultimalinievaafectavaloareavariabileii.
intv1,v2;/*v1iv2suntdetipint*/
int*pv1,*pv2,*pv3;/*pv1,pv2ipv3suntdetippointerlaint*/
/*situaiainiial*/
v1=5;/*Iniializarealuiv1*/
v2=15;/*Iniializarealuiv2*/
pv1 = (int*)malloc(sizeof(int)); /*alocare dinamic de memorie pentru un ntreg, i iniializarea lui
pv1cuadresaacesteimemorii*/
/*1.iniializareavariabilelordinamice*/
*pv1=v1;/*zonadememoriepointatdepv1esteiniializatatribuiredevalori*/
pv2=&v2;/*iniializareapointeruluipv2atribuiredepointeri*/
pv3=pv1;/*atribuiredepointeri,salvarenecesarpentrudealocareazoneidememoriealocatmai
sus*/
/*2.atribuiredepointeri*/
pv1=pv2;/*pv1vaaveaaceaivaloarecaipv2deci*pv1i*pv2desemneazacelaiobiect,aiciv2
*/
/*3.atribuiredevalori*pv1=*pv2*/
pv1=pv3;/*refacereavariabileidinamicepv1atribuiredepointeri*/
*pv1=*pv2;/**pv1i*pv2auaceeaivaloarefrcapv1ipv2sfieegale*/
/*4.atribuireindirectv1=v2prin*pv1=*pv2*/
pv1=&v1;/*pv1conineadresaluiv1*/

86
*pv1=*pv2;/*similarcuv1=v2*/
free(pv3);/*dealocareavariabileidinamicepv3*/
Aadar trebuie fcut distincia ntre atribuirea de valori i atribuirea de adrese.

Pentruascoatenevidensemanticadiferitacelordoutipurideatribuire,unele
limbaje prevd operatori distinci pentru aceste operaii. Dac p i q sunt pointeri
atuncinCiC++
p=qnseamnatribuiredepointeri;
*p=*qnseamnatribuiredevalori;
p>cmp este sintaxa pentru selectarea componentei unei structuri (dac p
estepointerlaostructur).
Instruciunea compus
Instruciuneacompusspecificfaptulcinstruciunilecareocompunseexecutn
aceeai ordine n care apar. Instruciunile componente sunt tratate ca o singur
instruciune, lucru esenial n contextele n care sintaxa limbajului cere o singur
instruciune.
Termenul de instruciune compus este similar, n unele limbaje, celui de bloc.
Deosebirea dintre cele dou noiuni este urmtoarea: instruciunea compus nu
conine declaraii, pe cnd blocul poate conine declaraii. Un bloc poate fi
considerat ca unitatea de vizibilitate (declaraiile ce apar n el definesc domenii de
vizibilitatepentrunumelecareaparnele).
nC,C++,termenii deinstruciunecompusibloc suntidentici. Motivulesteacela
c orice declaraie este considerat instruciune. Delimitatorii folosii pentru
marcarea nceputului i sfritului blocului sunt acoladele, iar instruciunile se
termincupunctivirgul,inclusivultima.
Existlimbajedeprogramarecareposedattblocurictiinstruciunicompusei,
de asemenea, exist limbaje care nu posed instruciuni compuse: Fortran, Basic i
ngenerallimbajelefrstructurdebloc.
Instruciuni condiionale (de ramificare, de selectare)
Instruciunile condiionale (de selectare sau de ramificare) au ca scop alegerea
unuiadintremaimultefluxuridecontrolalprelucrrii(alternativedecontinuarea
execuiei)posibilelaunmomentdat.
Primainstruciunecondiionalesteif:
SintaxainstruciuniiifnlimbajulCeste:
if(expresie)
instruciune1;
[else
instruciune2;]

87
undeexpresie trebuies fie de tip aritmetic sau pointer.Dacexpresie se evalueaz
la o valoare diferit de zero atunci se execut instruciune1, altfel se execut
instruciune2.Parteaelseesteopional.
n limbajele de programare n care exist tipul de date boolean, expresie trebuie s
fieoexpresielogicacreivaloareestetruesaufalse.
A doua instruciune condiional este instruciunea de selectare, instruciune care
este o soluie mai elegant pentru situaiile de programare n care se folosesc
instruciuni ifelseif n cascad. Rolul semantic al instruciunii de selectare este
alegereauneialternativedintromulimedevariantereciprocexclusive.Eapoatefi
simulat printro cascad de instruciuni ifelse, dar avantajul ei const ntro
expresivitatesporitaexprimrii.Deducereaalternativeicareseexecutsefacepe
baza unei expresii numite selector, iar valorile luate n considerare se numesc
etichete case. Cnd se discut despre instruciunea de selectare trebuie avute n
vedereurmtoareleaspecte:
tipulexpresieiselectoare;
tipuletichetelorcase;
esteposibilexistenaetichetelorreciprocneexclusive;
eticheteleacopertoatmulimeavalorilorexpresieiselectoare.
posibilitateaexprimrilorninteriorulsauexteriorulcorpuluiinstruciunii.
InstruciuneadeselectareanlimbajeleCiC++esteinstruciuneaswitch.Expresia
selectoaretrebuiesfiedetipntregsaudetipclaspentrucareexistoconversie
neambigu la tip aritmetic sau pointer. Orice instruciune din corpul lui switch
poatefietichetatcuunasaumaimulteetichetecasedeforma:
caseexpresieconstant:
unde expresieconstant se convertete la tipul expresiei selectoare. ntro

instruciuneswitchnupotexista douconstante casecuaceeaivaloare.Corpul lui
switchpoatesconinicelmultoetichetdeforma:
default:
La execuia instruciunii switch, se evalueaz expresia selectoare i se face

comparaiacufiecareconstantcase.Dacunadintreconstantelecaseesteegalcu
valoareexpresiei,setransfercontrolullainstruciuneacuetichetacaserespectiv.
Dacvaloarenucorespundeniciuneiadintreconstantelecaseidacexisteticheta
default,setransfercontrolullainstruciuneacuaceastetichet,iardacnuexist
default,nuseexecutniciunadininstruciuniledincorpulluiswitch.
Etichetele case i default nu altereaz fluxul de control, care continu n corpul lui
switch. Pentru a prsi corpul lui switch, se folosete instruciunea break. De obicei
instruciunile care fac obiectul lui switch sunt instruciuni compuse, dar nu este
obligatoriuacestlucru.

88
Instruciuniledincorpulluiswitchpotfiideclaraiidartotuinuesteindicatsse
facastfeldedeclaraii.
Instruciuni de ciclare
Instruciuniledeciclare(repetitive,iterative)realizeazspecificareaunorprocesede
calcul iterative. Aceste procese pot fi cu numr cunoscut de pai sau cu numr
necunoscut de pai (iteraii). Secvena de instruciuni care specific procesul de
calculiterativsenumetecorpalacestuia(corpulciclului).
Nu se tie dinainte de cte ori se repet execuia unui proces iterativ cu numr
necunoscut de pai. La un moment dat decizia privind reluarea execuiei corpului
ciclului (continuarea cu o nou iteraie) se face prin testarea valorii unei anumite
expresii. Din punctul de vedere al locului unde se face aceast testare, se disting
douclasedeastfeldeprocese,cutestiniialicutestfinal.
Specificarea formal a unui proces de calcul iterativ se poate face folosind
delimitatori,caremarcheazcorpulacestuia.Continuarea(repetarea)procesuluide
calcul estedecis de valoarea de adevr a unei condiii de terminare, care estedat
explicit sub forma unei expresii booleene. Dup momentul n care se evalueaz
expresiasedistingdouconstrucii:cutestiniialicutestfinal.Atuncicndtestul
este la finalul ciclului corpul se execut cel puin o dat indiferent de valoarea de
adevracondiieideterminare.
InstruciuniledeciclarenCiC++suntwhile,doifor.Sintaxaloreste:
instruciunedeciclare::=
while(expresie)instruciune;
doinstruciunewhile(expresie);
for(instruciuneiniializarefor;expresie;expresie)
instruciune;
instruciuneiniializarefor::=
instruciuneexpresie
instruciunedeclaraie
Corpuluneiinstruciunideciclarenupoatefiodeclaraie.
La instruciunea while corpul se execut repetat pn cnd valoarea lui expresie
devine0.Testulsefacenaintedefiecareexecuieacorpului.Expresietrebuiesfie
detiparitmeticsaupointer.
Lainstruciuneadocorpulseexecutrepetatpncndvaloarealuiexpresiedevine
0. Testul se face dup fiecare execuie a corpului. Expresie trebuie s fie de tip
aritmeticsaupointer.
Instruciuneaforaresintaxa:
for(instruciuneiniializarefor;expr1;expr2)
instruciune;

89
iesteechivalentcu:
instruciuneiniializarefor;
while(expr1){
instruciune;
expr2;
}
cu excepia faptului c ntlnirea unei instruciuni continue n instruciune va

provoca evaluarea lui expr2 nainte de evaluarea lui expr1. Prin urmare, prima
instruciune nseamn iniializarea ciclului, expr1 este condiia de continuare a
ciclrii,testatnaintafiecreiiteraii(seterminciclareacndexpr1devine0),iar
expr2 specific de obicei o aciune care modific ceva (de obicei incrementarea
variabilei de ciclare care se face dup fiecare iteraie). Expr1 trebuie s fi de tip
aritmetic.
Attexpr1ctiexpr2suntopionale.Daclipseteexpr1,seobineoconstrucie
echivalentcuwhile(1)
for(;;)//cicluinfinit
Instruciuni de transfer
Instruciunile de transfer (salt) ntrerup execuia secvenial (instruciune cu
instruciune) a unei secvene de program, permind continuarea execuiei
programului dintrun loc precizat. Forma general a instruciunii de salt este goto
etichet. Unde etichet este un identificator care apare naintea unei instruciuni,
instruciunecucaresevacontinuaexecuiaprogramului.Nuvomintrandetaliin
legturcuaceastinstruciunentructnuesterecomandatafifolosit.
n 1968, Dijkstra a publicat n Communication of ACM, articolul GO TO statement
considered harmful n care discuta problema proastei utilizri a acestei
instruciuni, rezultnd programe greu de neles i nefiabile. Acest articol a
declanat o serie de discuii care au durat ani ntregi, discuii privind utilitatea sau
inutilitatea acestei instruciuni (condiiile n care se poate renuna la GOTO;
transformarea programelor cu instruciuni GOTO n programe echivalente fr
GOTO; eficiena algoritmilor fr GOTO). Dup un timp discuiile sau potolit i
GOTO a rmas ca instruciune n limbajele de programare imperative moderne. Au
aprut i construcii auxiliare (break, continue, exit) care servesc la o mai bun
structurareaunuiprogramilaomaiuoarnelegerealui.
Majoritatea limbajelor moderne pstreaz instruciunea de salt necondiionat doar
dinmotivedecompatibilitatecuversiunileanterioare.
nCinstruciuniledesaltsunt:goto,break,continueireturn.Sintaxaloreste:
instruciunedesalt::=
break;
continue;

90
returnexpresieopt;
gotoidentificator;
Instruciunea break poate s apar numai n corpul unei instruciuni de ciclare sau
ntro instruciune switch; ea are ca efect terminarea celei mai interioare
instruciuni de ciclare sau switch, iar controlul este transferat la instruciunea care
urmeazinstruciuniideterminareaciclului(dacexist).
Instruciuneacontinuepoatesaparnumaincorpuluneiinstruciunideciclarei
are ca efect transferarea controlului la poriunea de continuare a celei mai
interioare instruciuni de ciclare, adic la sfritul ciclului, unde se face testul de
continuareaciclrii.
O funcie red controlul apelatorului ei la ntlnirea instruciunii return.
Instruciunea return fr argumente se poate folosi numai n funcii ce ntorc tipul
void.
Formareturnexpresiesepoatefolosinumainfunciilecarentorcovaloare(detip
diferit de void); valoarea expresiei este ntoars n apelatorul funciei. Dac este
nevoie,expresiantoarseste convertit,lafelcala iniializare, la tipulrezultatului
ntors de funcie. ntlnirea sfritului unei funcii este echivalent cu return fr
valoare,lucruilegalncazulfunciilorcentorcovaloare.
Programarea structurat i cum s-a ajuns la ea

Odat cu introducerea limbajului ALGOL60 programatorii au observat c
programarea n acest limbaj necesit n mod natural utilizarea de mult mai puine
oriainstruciuniigotodectceraltelimbajenuz(deex.FOTRAN).Saobservatde
asemeneacprogrameleastfelrezultateerauimultmailizibiledectechivalentul
lorcugoto.
Aceste observaii iau fcut pe civa cercettori de renume (Peter Naur, Edser
DijkstraiPeterLandin)sexperimentezelanivelulanilor19661968programarea
frutilizareadeinstruciunigoto.Concluziaafostcinstruciunilegotoartrebuie
eliminate total din practica programrii. Dijkstra sublinia faptul c dificultatea
nelegerii programelor care fac uz excesiv de instruciuni goto provine din marea
diferen dintre structura static a unui program (aa cum apare textul surs n
pagin) i structura dinamic a calculelor asociate (evoluia n timp a execuiei).
Ideea sugerat poate fi exprimat sub forma aa numitului principiu al structurrii,
carespunec:
Structura static a unui program trebuie s corespund la nivel simplu cu
structuradinamicacalculelorcorespunztoare.
nurmasemnaluluidealarmtrasdeDijkstrasaudezvoltatnoilimbaje,metodei
tehnici grupate sub titulatura de programare structurat, stil de programare care
prinnoiletipuridestructuridecontrolintroduse(for,repeatuntil,whiledo)numai
necesitaufolosireadeinstruciunigotoipermiteaurespectareaacestuiprincipiual
structurrii (ordinea static a instruciunilor programului era aceeai cu cea de la

91
execuie). Respectarea unei discipline de programare i folosirea riguroas a
structurilor de calcul introduse au dus la posibilitatea elaborrii de algoritmi uor
deurmrit,clariicoreci.
Un rezultat foarte important pentru ajungerea la programarea structurat la
constituitarticolulluiBohmiJacopini,careaudemonstratcoricealgoritmpoate
ficompusdinnumaitreistructuridecalcul:
structurasecvenial;
structuraalterntiv;
structurarepetitiv.
Programare structurat a fost caracterizat ca fiind: programare fr goto,
programare de tip topdown i o manier de a organiza i codifica programe astfel
nct ele s fie uor de neles i de modificat, scopul ei fiind de a controla
complexitateaprinteorieidisciplin.
Knuth consider programarea structurat ca un mijloc de a face programele mai
uordecitit.
La nivel micro, programarea structurat se poate ntlni la nivelul elaborrii unui
(sub)algoritm,undeseimpuneclaritate,ordineiscriereirespectareastructurilor
decalculdemaisusncadrulfiecruimodulnparte.Lanivelmacroeasemanifest
la nivelul ntregului produs program, prin practicarea proiectrii topdown, a
programelormodulareiaaltormetodedeprogramareceimpunordinenntreaga
activitate. De asemenea, este necesar existena unei structuri clare a ntregii
aplicaii,precizatprintrodiagramdestructur.
n ceea ce privete claritatea unui algoritm sau a unui program, indentarea
(paragrafarea) precum i inserarea de comentarii reprezint tehnici de lucru ce
nsoescdeobiceiavantajeledejamenionatealeprogramriistructurate.
Chiar dac majoritatea limbajelor imperative actuale dispun de instruciunea goto,
necesitateafolosiriieiadisprut,iarprogramatoriiauacumamaibunnelegerea
modului n care trebuie utilizat o instruciune de acest tip precum i asupra
situaieincareoastfeldeutilizareesteadecvat.

92
8. Proceduriitransmitereaparametrilor
Abstractizare i specificare
Practica a demonstrat viabilitatea principiului machiavelic divide et impera. n
proiectarea aplicaiilor pe calculator, acest principiu se regsete sub termenul de
descompunere a unei probleme, prin care senelege factorizarea ein subprobleme
disjuncte,cuurmtoareleproprieti:
1. fiecare subproblem este situat la acelai nivel de detaliere; ea poate fi
tratatulteriorcaoproblemdistinct;
2. fiecaresubproblemsepoaterezolvaindependent;
3. soluiile subproblemelor se pot combina pentru a obine soluia problemei
iniiale.
Descompunerea unei probleme este strns legat de termenul de abstractizare. n
general,procesul deabstractizare este privitcao aplicareauneifuncii (ngeneral
neinjectiv), numit funcie de abstractizare, prin care se neglijeaz unele
informaii, considerate nesemnificative, pstrnduse doar acelea considerate
eseniale din punctul de vedere al contextului aplicaiei. Ideea de baz a
abstractizriiesteaceeaclucruridiferite(nstotuinrudite)sepottrataidentic.
Ca metod de proiectare a programelor, abstractizarea se poate realiza prin
parametrizaresauprinspecificare.
Abstractizarea prin parametrizare presupune identificarea, pentru o problem
dat, a intrrilor i ieirilor acesteia, care vor constitui parametrii formali ai
problemei respective. Se poate discuta ce pot fi parametrii unei probleme: numai
date(adicrealizrialeunortipuridedatcunoscute)sauitipuridedat.
Abstractizarea prin specificare se realizeaz prin asocierea unei specificri la
fiecaresubproblemcaretrebuierezolvat,considernduseapoicoricecererede
rezolvare a subproblemei se bazeaz pe aceast specificare, mai mult dect pe un
algoritm de rezolvare a ei. Realizarea specificrii se face printrun cuplu de
aseriuni,acrorfolosiresebazeazpedoureguli.Aseriunile:
a. necesit (precondiia) ce specific proprietile ce trebuie satisfcute
cndsedoreterezolvareasubproblemeirespective;
b. realizeaz (postcondiia) ce specific proprietile presupuse a fi
ndeplinitelaterminarearezolvriiproblemei.
Regulilespecificriiafirmc:
a. duprezolvareauneisubproblemesepoatepresupunecpostcondiiaeste
adevrat
b. sepotadmitenumaiaceleproprieticarederivdinpostcondiie.
Prima regul statueaz c utilizatorul nu trebuie s se gndeasc la algoritmul de
rezolvare a subproblemei, adic el trebuie s fac abstracie de detalii, iar a doua
afirm c rezolvarea subproblemei ofer rezultate ce satisfac postcondiia,

93
subproblema fiind o abstractizare ce reprezint mulimea calculelor necesare
realizrii postcondiiei. Astfel, o subproblem poate fi neleas ntrun sens mai
larg,caonouoperaiepemulimeadatelorcesatisfacprecondiia.
Sepoatevorbideabstractizareladouniveluri:proceduraliprintipuriabstracte
dedate.
Abstractizarea procedural este o abstractizare de tip operaional prin care se
realizeazonouoperaie,utilizabildupdefinireaei.Eapermiteadugareadenoi
operaii(extinderea)unuilimbajdeprogramare(consideratcamainvirtual).
Abstractizarea prin tipuri de date abstracte presupune definirea de noi clase
(structuri)dedateidefinireadeoperaiipeacesteobiecte,carerealizeazcrearea,
actualizarea sau distrugerea acestor obiecte sau ofer informaii asupra
comportamentului acestora. Acest nivel de abstractizare utilizeaz abstractizarea
procedural.
Abstractizarea prin proceduri combin metodele abstractizrii prin

parametrizare cu cele ale abstractizrii prin specificare. Procedura este o unitate
sintacticisemanticcaredescrietransformareaargumentelorfurnizatelaintrare
nargumentedeieire.Dinpunctdevederesemantic,procedurasepoateidentifica
ntro oarecare msur cu subproblema. Ea se poate considera abstract ca o
aplicaiepemulimeaargumentelordeintrare,cuvalorinmulimearezultatelor,cu
eventualamodificareaintrrilor.
Abstractizare prin proceduri trebuie s satisfac trei cerine: minimalitate,
generalitate i simplitate. Minimalitatea este caracterizat prin faptul c,
comportamentul unei proceduri trebuie precizat numai n limitele realmente
necesare.ngeneral,caracterulminimalaluneiproceduriimplicnedeterminismul
(soluii multiple), care de obicei se rezolv la nivelul implementrii, obinnduse
unicitatea soluiei. Generalitatea se obine prin utilizarea parametrilor n locul
variabilelor sau al ipotezelor specifice. Simplitatea nseamn c procedura trebuie
s aib un scop bine definit i uor de explicat, care s nu depind de contextul n
care este utilizat. Se afirm c o procedur este bine gndit atunci cnd se poate
descrie scopul ei prin numele acesteia (adic se folosesc ct mai puine cuvinte
pentru a explica menirea ei). Simplitatea implic, de obicei, ca o procedur s aib
uncoddeimplementareredus(deordinulzecilordeliniisurs).
Abstractizarea prin parametrizare servete la identificarea datelor utilizate. Ea este
definit cu ajutorul parametrilor formali. Ori de cte ori se apeleaz o procedur,
parametrii de apel (efectivi) trebuie n general s corespund ca numr i
semnificaie cu cei formali. Distingem deja dou momente deosebite din viaa unei
proceduri: proiectarea i utilizarea ei. Lista de parametri, stabilit la proiectarea
unei proceduri,realizeazinterfaa cualteproceduri, conferindui n acelaitimpo
mai mare generalitate (aplicabilitatea n mai multe situaii, prin setarea
corespunztoare a parametrilor efectivi), cu efect n realizarea de aplicaii
compacte,maiuordescrisidentreinut.

94
Abstractizarea prin specificare presupune concentrarea asupra comportamentului
procedurilor scrise, cu neglijarea detaliilor de implementare, altfel spus trebuie
gndit ce trebuie s fac procedura, i nu cum trebuie s fac. Pentru o aceeai
specificare se pot realiza mai multe implementri, diferite ntre ele (n limbaje
diferite,cualgoritmidiferii).Laschimbareaimplementrii,programeleapelantenu
vor trebui modificate dac specificarea procedurii nu se schimb. Abstractizarea
prinspecificareoferometoddeproiectareaprogramelorcearedouproprieti
importante:localizareimodificabilitate.
Localizarea nseamn c implementarea unei abstractizri se poate face
independent de implementarea altora. Avantajele oferite de aceast proprietate
sunt: posibilitatea lucrului n echip (proceduri diferite pot fi implementate de
persoanediferite)icreterealizibilitii(lanelegereascopuluiuneiprocedurinu
este necesar cunoaterea algoritmilor folosii pentru alte proceduri apelate de ea,
cidoarasemanticiiacestora).
Modificabilitatea nseamn limitarea efectelor unei modificri. Dac implementarea
unei proceduri se modific fr ca s se modifice i specificarea acesteia, atunci
apelul respectivei proceduri nu se modific, deci efectul modificrii unei proceduri
se reduce numai la implementarea ei. Aceast proprietate ofer i o metod de
controlaperformaneiprogramelor,careconstn:
1. se realizeaz specificarea corect i complet a tuturor procedurilor unui
programiseimplementeazceimaisimplialgoritmi;
2. se execut programul, detectnduse locurile nguste (engl. bottlenecks),
adicaceleproceduricareconsummajoritateatimpuluideexecuie;
3. se rescrie codul pentru procedurile respective, folosinduse algoritmi mai
performani.
Proiectarea unei proceduri presupune dou etape distincte: specificarea i
implementarea. Specificarea unei proceduri definete ce au n comun diversele
implementrialeacesteia.Implementrileuneiprocedurisuntechivalentesemantic
dac reprezint aceeai abstractizare; ele pot diferi din punctul de vedere al
algoritmilorfolosii.Ocondiienecesarceseimpuneimplementriiestecaaceasta
srealizezecomportamentuldefinitprinspecificare.Deasemenea,estededoritcao
implementare s fie ct mai inteligibil, ct mai lizibil. ntre tehnicile de sporire a
lizibilitiiuneiimplementrimenionm:
1. utilizareanotaiilordelaspecificareaunorparametri;
2. utilizareacomentariilor(attpentruprecizareaalgoritmuluiutilizat,ctin
codulpropriuzis);
3. folosirea indentrii, aezarea n pagin ce faciliteaz nelegerea structurii
codului.
Specificarea abstractizrii prin proceduri: abstractizarea trebuie realizat prin

definiii precise. Ea se definete cu ajutorul specificaiilor scrise ntrun limbaj de
specificare. Acest limbaj poate fi forma, specificaiile avnd un sens precis, riguros

95
matematic, sau informal, cnd specificaiile au un caracter descriptiv, suferind n
precizieirigoare,darfiinduordeneles.
Specificareauneiproceduriconineantetulacesteia(parteasintacticaspecificrii)
idescriereaaciunii(parteasemantic).Antetulconine:numeleproceduriiilista
de argumentelor (parametrilor), caracteriznd numele, tipul i ordinea acestora.
Descriereaaciuniiproceduriisefaceprinaseriunile:
necesit(condiiilesaurestriciiledeutilizare;
modific(parametriideintrarecaresemodific);
realizeaz(comportamentulprocedurii).
Din punctul de vedere al modului n care furnizeaz rezultatul aciunii lor,
procedurile sunt de tip subrutin sau funcie. Procedurile de tip subrutin i
materializeaz efectulnmodificarea parametrilor deieire (eventual iaunora de
intrare), pe cnd funciile furnizeaz un rezultat de un tip precizat, determinat de
parametri.
Schemadespecificareauneiprocedurieste:
nume=proc(listaargumentelor)[returns(rezultat)]
necesitseprecizeaztoaterestriciiledeutilizareaprocedurii.
modificseprecizeazargumentelecaresemodific.
realizeazdescriecomportamentulprocedurii.
Dmncontinuarectevaexempledespecificareaprocedurilor.
concat=proc(a,b:string)returns(ab:string)
realizeaz la terminarea execuiei, ab este un nou ir de caractere ce conine
caractereledinirula(nordineaapariiei),urmatedeceledinirulb.
elim_dubl=proc(a:array[int])
modifica
realizeaz suprimareaapariiei multiple aleelementelordina. Indiceleinferior al
lui a rmne acelai, dar ordinea elementelor i numrul de elemente din a se pot
modifica.
caut=proc(a:array[int],x:int)returns(i:int)
necesitatableordonatcresctor
realizeazdacexistunindiceipentrucarex=a[i],rezultatulestei,altfelivafi
unntregcuvaloareamaimaredectindicelesuperioralluia.
Dinpunctuldevederealspecificriilor,procedurilepotfitotale(lipseteaseriunea
necesit), deci nu exist restricii de utilizare a lor, sau pariale (este prezent
aseriunea necesit). Termenii total sau parial trebuie considerai n raport cu
domeniuldedefiniiealprocedurii:oprocedurtotalestedefinitpetotdomeniul
su(consideratcaproduscartezianaldomeniilortipurilordedatceformeazlista

96
deparametri,nordineaspecificriiacestora),pecndlaunaparialdomeniuleste
restrns n conformitate cu cerinele impuse de aseriunea necesit. Pentru
exemplele de mai sus, concat i elim_dubl sunt proceduri totale, iar caut este
parial.
Proceduri
Procedurapoatefiprivitcaomodalitatedeaajungedelaoinformaiedeintrarela
o informaie de ieire. Specificarea unei proceduri trebuie s stabileasc relaiile
ntre mulimea datelor de intrare i cea a rezultatelor de la ieire, dar (conform
principiuluicutieinegre)nutrebuiesdeainformaiiasupramoduluincaresunt
obinute ieirile. Primul lucru care ne intereseaz la o procedur este ceea CE face
aceastainuCUMface.
Funcional,oprocedurpoateficonsideratcaonouoperaiedefinitdeutilizator
prinintermediuloperaiilorprimitivealeunuilimbajdeprogramare.
Conceptual,oprocedurestecompusdinpatruelemente:
numeleprocedurii;
olistdedefinireaparametrilor;
corpulprocedurii;
mediulprocedurii.
Sintaxa unei proceduri se refer la modul concret de specificare a celor patru
constitueni.Ingeneral,eaaratastfel:
ProcedureNUME(listdeparametri)
Declaraii
Corpulprocedurii
EndNUME.
Evident c de la un limbaj la altul exist unele deosebiri n ceea ce privete sintaxa

procedurilor.nlimbajulC,putemdefinidoarfuncii.
Oprocedurncepedeobiceiprintruncuvntcheie(procedure)caredeclartextul
care va urma ca fiind o procedur. Dup cuvntul cheie urmeaz numele acesteia,
dup care, n parantez, urmeazo list de identificatori, numii parametri formali.
Aceti identificatori sunt nume care joac rolul argumentelor reale din momentul
apelului (nu sunt variabile). Este nevoie de acetia pentru a putea descrie
procedura. Variabilele i expresiile ce vor fi preluate de procedur pentru a nlocui
parametrii formali se numesc parametri actuali. Exist o coresponden direct
ntre parametrii formali i cei actuali, bazat de regul pe ordinea n care acetia
apar n list.
Orientarea n limbajele de programare moderne este de a da ct mai mult
informaie la definire, n cadrul listei parametrilor formali. Astfel, lrginduse puin
noiunea de list de parametri, vorbim despre specificarea parametrilor, care poate
coninepelngnumeleparametrilor,tipulacestora,precumimodalitateancare
vorfifolosiilaexecuie.

97
Decelemaimulteoridefinireauneiproceduridelimiteazidomeniulunorobiecte
din program. Declaraiile descriu atributele variabilelor, constantelor, etichetelor,
toate acestea fiind locale procedurii despre care vorbim. Corpul procedurii const
dintro instruciune (simpl sau compus) care controleaz procesul de calcul. De
asemenea, o procedur poate referi variabile globale ei care provin dintrun bloc
exterior. Mediul procedurii const din acele variabile care sunt definite n afara
corpului procedurii, dar care pot fi utilizate i eventual modificate la execuie prin
intermediulinstruciunilorprocedurii.
nprincipal,procedurilesempartndoucategorii:subrutineifuncii.
Osubrutinesteprocedurcarendeplinetesarcinafieprinatribuirearezultatelor
unuia sau mai multor parametri, fie prin modificarea mediului procedurii, fie prin
amndouacestemetode.Caracteristicsubrutineiestefaptulcapelulacesteiaeste
interpretatcaoinstruciune.
Ofuncieesteoprocedurcareestecaracterizatdefurnizareauneivalori.Astfelse
permite ca apelul unei funcii s fie componenta unei expresii. n multe limbaje de
programare o funcie poate s modifice valoare unei variabile din mediu, aceasta
fiind una din caracteristicile principale ale programrii imperative i implicit
deosebirea major ntre noiunea de funcie matematic (care nu permite astfel de
modificri i pe care se bazeaz programarea funcional) i cea de funcie din
informatic.
O modalitatea de stabilire a valorii unei funcii este atribuirea valorii numelui
funciei,construciecevafitratatcaivariabillocal(nPascal,ALGOL,FOTRAN
).Pedealtparte,altelimbaje(cumesteC)cercavaloareadetransmissfieplasat
imediatdupoinstruciunereturn.
Laexaminareauneiproceduridistingemtreiclasedenume:
numeleparametrilorformali;
numelevariabilelorlocale;
numelevariabilelorglobale.
Relativlaacestecategoriiilamodulncareseraporteazoprocedurlaacestea,se
ridic problema evalurii parametrilor actuali i a modului de punere n
corespondenaacestoracuceiformali.
Scopulfinalalcreriiproceduriloresteutilizarealor,etapcareaparelamomentul
execuiei,icuprindetreifaze:
1. CALLmomentulapelului.Setransmitecontroluldelaprogramulapelantla
procedur
2. ENTRYcuprindeaciunileceaulocnmomentulintrriinprocedur.
3. RETURN cuprinde aciunile ce se execut la trecerea controlului de la
procedurlaprogramulapelant.

98
Evaluarea i transmiterea parametrilor
Evaluarea parametrilor este procesul n care fiecare parametru actual este asociat
cu parametrul formal corespunztor. Prin transmitere a parametrilor nelegem
modalitatea prin care valoarea evaluat a parametrilor actuali este transferat
procedurii. Exist mai multe metode de transmitere a parametrilor, ns n cele ce
urmeaz ne vom limita la dou dintre acestea care au fost cele mai utilizate dea
lungultimpuluincadrullimbajelordeprogramare:
1. n cazul apelului prin valoare parametrului actual este copiat ntro nou
locaie de memorie, care este pus apoi n legtur cu parametrul formal,
care acioneaz n continuare ca variabil local pentru unitatea apelat.
Aceast metod este maniera implicit de tratare a evalurii i transmiterii
parametrilornmultelimbaje(Pascal,C).Trsturaprincipalaapeluluiprin
valoareestecparametrulactualdevinepentruprocedurovaloarecepoate
fi numai utilizat (readonly), iar eventualele modificri ale coninutului
parametrilor nu vor influena programul din afara procedurii. Aceasta,
deoarece se lucreaz de fapt cu copia argumentului, ceea ce poate fi un
dezavantaj n cazul obiectelor structurate (tablouri, structuri voluminoase
etc.), consumnduse mult timp i spaiu de memorie cu aceast copiere.
Apelulprinvaloarenupermiteniciunfluxdeinformaienapoispreapelant,
atribuirileparametrilorneafectndunitateaapelant.
2. n cazul apelului prin referin, dac parametrul actual este o locaie ce
desemneaz o variabil cu nume, aceast locaie este legat direct cu
parametrul formal corespunztor, ceea ce face ca s se lucreze direct cu
valoarea iniial din memorie. Acest lucru permite ca eventualele modificri
ce se fac asupra acestor variabile s fie recunoscute i n afara procedurii.
LimbajulCnudispunedeunmecanismsintacticdeimpunereaapeluluiprin
referin,acestaputndfinssimulatdectreprogramatorprinintermediul
variabilelor de tip pointer. Principalul avantaj al acestui mod de apel este
eficiena.
Mai jos dm un exemplu n C de apel prin valoare, apel n urma cruia valorile
variabileloraibdinprogramulprincipalnusevormodifica.
#include<stdio.h>
voidswap(inta,intb)
{
intt;
t=a;a=b;b=t;
}
voidmain()
{
inta=1,b=2;
printf(%d%d,a,b);/*sevaafisa12*/
swap(a,b);
printf(%d%d,a,b);/*sevaafisatot12*/

99
}
Pentrucavalorilecelor douvariabiles semodificetrebuies folosim apelul prin

referinceeacenCsesimuleazcuvariabiledetippointer:
#include<stdio.h>
voidswap(int*a,int*b)
{
intt;
t=*a;*a=*b;*b=t;
}
voidmain()
{
inta=1,b=2;
swap(&a,&b);/*Functieiisetransmitadreseleluiasib*/
}
Specificarea parametrilor unei proceduri

n cadrul limbajelor de programare moderne, orientarea actual este de a cere
programatorilor s furnizeze ct mai multe informaii despre parametrii formali
utilizai n descrierea unei proceduri (tipul acestora). Astfel, se permite un grad
sporit de eficien a verificrii corespondenelor ntre parametrii formali i cei
actuali.
Un alt nivel de specificare se refer la modul n care vor fi folosii parametrii. n
general se permite compilatorului o oarecare libertate n alegerea metodei de
evaluareitransmitereaparametrilor.
Parametriiuneiprocedurisepotaflanunadinurmtoareletreiipostaze:
1. parametrul aduce o valoare n procedur, fiind numai citit (i folosit) ns
nuiatribuit(modificat),iarvaloareasanuestetransmislaieire.Spunem
nacestcazcparametrulestedetipIN.
2. parametrul transmite valoarea sa n exteriorul procedurii, valoarea fiind
atribuit parametrului pe parcursul execuiei procedurii, dar nefiind adus
cu o valoare iniial din exterior. n acest caz spunem c parametrul este de
tipOUT.
3. parametrulesteaduscuovaloareiniial,esteapoimodificatitransmisca
parametrudeieire.SpunemcparametrulestedetipINOUT.
Noiunea de efect secundar
Unadinproblemelecareseridicesteceaaefectuluipecarelpoateaveaofuncie
asupra diverselor valori din program. Funciile pot modifica n corpul lor de
instruciuni valorile unuia sau mai multor parametri transmii, precum i valorile

100
unor variabile globale. Aceste modificri asociate calculului valorii funciei se
numescefectesecundare.
Astfel de efecte pot crea anumite probleme. De exemplu, n cadrul evalurii unei
expresii unde apare o astfel de funcie ce produce efecte secundare nu se va ti
precis ce valori vor avea alte variabile din expresie nainte i dup evaluarea
funciei.
Proceduri mutual recursive
O alt problem care a trebuit s fie rezolvat a fost problema procedurilor mutual
recursive. Acestea sunt proceduri care se apeleaz reciproc. Problema care apare
este imposibilitatea respectrii principiului definirii unui obiect naintea utilizrii
lui, deoarece oricare din cele dou proceduri sar defini prima, ea va conine n
corpul ei un apel al celeilalte proceduri, care nu este nc definit. Rezolvarea
impasului const n posibilitatea declarrii unei funcii printrun antet specific,
reprezentnd semnalarea faptului c definirea va urma utilizrii. n limbajul C
problema se rezolv prin mecanismul de declarare a funciilor nainte de utilizarea
lor. Declaraia unei funcii informeaz compilatorul de prezena acelei funcii.
Declaraia (prototipul sau semntura) unei funcii const din numele funciei, lista
de argumente (sunt importante doar tipurile argumentelor numele lor fiind
opionale)itipuldedatentorsdefuncie(tipuldereturn).

101
9. ANEXE
Codspaghetti
Cod sub form de spaghete este un termen peiorativ
pentru un cod surs complex cu o structur de control
nclcit,cefolosetemulteinstruciuniGOTO,excepii,fire
deexecuieialteelementederamificarenestructurate.Un
termen sinonim dar mai puin folosit este cod cangur
pentrucsuntmultesalturincadrullui.
MaijosdmunexemplutrivialdecodscrisnlimbajulBASICcepoateficonsiderat
subformdespaghete.Programulafieaznumereledela1la10iptratullorpe
ecran.Codulnutrebuiesfiealiniat(indentat).Liniileprogramuluisuntnumerotate
i instruciunile GOTO se bazeaz pe aceste numere de linii. Controlului execuiei
programuluisaredelaozonlaaltantrunmodnufoarteprevizibil.nprogramele
adevrateastfeldesecvenedecodsuntmultmaicomplexeipotducelacreterea
foartemareacosturilordentreinerealeunuiprogram.
10dimi
20i=0
30i=i+1
40ifi<>10thengoto90
50ifi=10thengoto70
60goto30
70print"Terminat."
80end
90printi&"lapatrat="&i*i
100goto30
Aceeaisecvendecoddarscrisntrunstildeprogramarestructurat(nlimbajul
C):
inti;
for(i=1;i<=10;i++)
printf(%dlapatrat%d,i,i*i);
printf(Terminat.);
intpatrat(inti)
{
returni*i;
}
i n acest program se fac salturi de la o zon la alta dar aceste salturi sunt
predictibileiformaledeoarecefolosireainstruciuniiforiafunciilorsuntmetode

102
standarddeacontrolaexecuiaunuiprogram.Acesteprogramestefoartescurt,dar
programele reale au foarte multe linii de cod i sunt dificil de ntreinut dac sunt
scrisesubformdespaghete.
Teoremadestructur
n mai 1966, Bhm i Jacopini au publicat un articol n Communications of the
ACM n care au artat c orice program care conine instruciuni GOTO poate fi
transformat ntrun program fr instruciuni GOTO care s conin doar
instruciuni de selecie (IF THEN ELSE) i instruciuni repetitive (WHILE condiie
DO xyz), eventual cu cod duplicat i/sau cu adugarea de variabile booleene
suplimentare (indicatori true/false). Ulterior sa demonstrat c instruciunea de
selecie poate fi i ea eliminat i c orice program se poate scrie doar cu
instruciunirepetitiveicuadugareadealtevariabilebooleene.
Faptul c un astfel de minimalism este posibil nu nseamn c este i indicat.
Teoretic, calculatoarele au nevoie doar de o singur instruciune main (operaie)
pentru a funciona i anume: scade un numr dintraltul i ramific dac rezultatul
este negativ. n realitate, calculatoarele au zeci sau poate chiar sute de instruciuni
main.
CeeaceaudemonstratBhmiJacopiniafostctoateprogramelepotfiscrisefr
instruciuni GOTO. Ali cercettori au demonstrat c structurile de control cu o
singurintrareiosingurieiresuntmultmaisimpludenelespentrucacestea
potfifolositeoriundecaosingurinstruciunefrainfluenacontrolulexecuiei.

Programare Procedurala

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Programare Procedurala

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSITATEADINORADEA FACULTATEADETIINE

Istoria i evoluia limbajelor de programare

Aspecte ale calitii software-ului

Factorii interni de calitate sunt strns legai de natura intim a procesului de

Specificarea sintaxei unui limbaj de programare

Exist dou categorii de separatori: separatorii uzuali, comentariile. Ambele

auto break case char const continue default do

Literal::= constantntreag| constantcaracter| constantflotant| literal ir de

BNF (BackusNaur Form = notaia BackusNaur) a aprut n 1963 n cadrul

Un automat de acceptare (sau de recunoatere) este folosit pentru a rspunde la

Schema general a unui compilator

Analiza lexical realizeaz prima parcurgere a PS (considerat ca ir de caractere),

Analiza semantic structura sintactic poate fi folosit pentru specificarea

Medii de programare i execuie

Declaraia de constant este deci prefixat de cuvntul rezervat const. Ea conine

Dac un specificator const sau volatile apare ntro declaraie, el va modifica

Dac se dorete declararea unui tablou de pointeri constani la iruri de caractere

cazncarenusepotmodificaniciiruriledecaracterei nici pointerii (elementele

Definiia limbajului nu specific constante predefinite. Pentru asigurarea

Clasificarea tipurilor de date

Aceai secven de definire a tipului i variabilei se poate face mai compact cu

Notaia de declarare din C i din C++ oglindete sintaxa expresiilor bazat pe

Echivalena i compatibilitatea de tip

vor defini dou tipuri A i B compatibile n C (structural) i incompatibile n C++

definesc dou tipuri diferite, ambele cu numele D (att n C ct i n C++). Dac

Elemente definitorii ale unei variabile

Numele unei variabile este un identificator, creat n concordan cu regulile proprii

Referina, mpreun cu valoare formeaz un obiect. n cazul variabilelor aliate,

Variabilele auto sunt declarate n interiorul funciilor. O astfel de variabil este

Etape ale lucrului cu variabile

deoarece variabila ntreag a se consider definit n alt unitate de traducere (de

Variabilele pointer sunt iniializate implicit la NULL (echivalentul valorii 0 pentru

n C++ (ca i n C) nu este predefinit tipul boolean. Orice expresie cu valoarea

Limbajul posed numai semantica apelului prin valoare pentru transmiterea

n limbajul C numele unei funcii este evaluat n cadrul programelor la adresa de

Limbajul C cere ca la apelul unei funcii chiar i fr parametri s fie utilizate

Tipul ntors i tipurile argumentelor sunt considerate parte a tipului funciei;

Tipul de date nregistrare

declar p ca fiind pointer la o structur format din dou cmpuri: un ntreg i un

X.int X.f X.psir

n notaiainfix (notaie uzual n matematic), un operand E se poateinclude ntre

Arborele unei expresii

E1 E2En (n notaie prefix), respectiv E1 E2En op

De exemplu, pentru expresia (a + b) * (c * d * e 4 / f) arborele sintactic este un

Arborii de sintax sunt abstraci, reprezentarea lor fiind aceeai, independent de

Operatori pe iruri de bii

Conversie explicit i implicit

efectueaz conversia ntregului 1 n valoarea n virgul flotant 1.0f nainte de a se

n listele de parametri actuali sau de iniializatori, operatorul virgul trebuie s

Compararea expresiilor de tip pointer

Evaluarea expresiilor logice

se face apel la lvaloarea lui x n stnga operatorului = i la rvaloarea lui x n

Aici valoarea variabilei i se poatemodifica att obinuit (prima instruciune), ct i

Aadar trebuie fcut distincia ntre atribuirea de valori i atribuirea de adrese.

unde expresieconstant se convertete la tipul expresiei selectoare. ntro

La execuia instruciunii switch, se evalueaz expresia selectoare i se face

cu excepia faptului c ntlnirea unei instruciuni continue n instruciune va

Programarea structurat i cum s-a ajuns la ea

Abstractizarea prin proceduri combin metodele abstractizrii prin

Specificarea abstractizrii prin proceduri: abstractizarea trebuie realizat prin

Evident c de la un limbaj la altul exist unele deosebiri n ceea ce privete sintaxa

Pentrucavalorilecelor douvariabiles semodificetrebuies folosim apelul prin

Specificarea parametrilor unei proceduri