Curs 3

Partea I-a : Introducere in POO .......................................................................................................................... 1

1. Scurt istoric ................................................................................................................................................ 1
1.1. Limbajul C ........................................................................................................................................... 1
1.2. Limbajul C++ ....................................................................................................................................... 2
2. Programare structurat versus POO .......................................................................................................... 3
2.1. Programe i modele ............................................................................................................................ 3
2.2. Programarea structurat .................................................................................................................... 4
2.3. Programarea orientat-obiect ............................................................................................................ 5
2.4. Exemplu de programare procedural versus POO .............................................................................. 7
2.5. Definiia POO ...................................................................................................................................... 9
2.6. Rezolvarea problemelor cu POO ....................................................................................................... 10

Partea I-a : Introducere in POO

1. Scurt istoric
1.1. Limbajul C
Limbajul de programare C este fundamentul lui C++, i de fapt C-ul este baza a multor
limbaje moderne, cum ar fi Java, JavaScript, Pearl, PHP, Python i multe altele. Desigur C++ este
descendenul direct al limbajului C i chiar include ntregul limbaj C. De aceea a nva C ar fi un
prim pas ajuttor pentru a nva C++.
Dezvoltat de ctre Dennis Ritchie i Brian Kerningham la Bell Labs in 1969, C-ul a fost
destinat ca o alternativ pentru limbajul de asamblare pentru a crea sisteme de operare, utilitare i alte
coduri la nivel de sistem. C-ul este un limbaj mic, cu doar 32 de cuvinte-cheie. Nu este ceea ce am
numi azi un limbaj de nivel nalt, dimpotriv, este mic, eficient, rapid i puternic.
Dac privim la nivelurile de tehnologie ale unui computer ca la o stiv, C-ul este n mod
curent folosit pentru a scrie cod la toate nivelurile, dar cel mai frecvent e utilizat pentru nivelurile
joase (Fig.1). Aproape tot ce este firmware, aproape toate sistemele de operare moderne i o parte
nsemnat a softurilor de aplicaii sunt scrise n C.

Fig.1

De ce oare s fie C-ul aa de rspndit?

1) Codul sistemelor scris n C tinde s fie mic i foarte rapid. Un program bine scris n C poate
genera un cod-obiect care este aproape la fel de mic i de rapid ca i codul scris n limbaj de
asamblare.

2) Codul scris n C este extrem de portabil. C-ul a fost iniial destinat pentru a scrie sisteme de
operare. De exemplu sistemul de operare Unix a fost scris n C i el funcioneaz pe foarte
multe procesoare diferite i configuraii hardware diverse. Practic acest sistem de operare se
compileaz i se execut pe o mare diversitate de maini de calcul, arhitecturi i procesoare,
fr nicio modificare sau, pe alocuri, cu foarte puine modificri ale codului-surs. Acest
lucru este valabil i pentru aplicaiile scrise n C.
3) Limbajul n sine este relativ mic i simplu, dar foarte puternic. Simplitatea lui ns e
amgitoare. El i ofer un acces att de mare la maina de calcul nct se poate spune c e
foarte flxibil, bogat i puternic.
C-ul este un limbaj de nivel sczut. Acest lucru nseamn c el se apropie foarte mult de
maina de calcul. Nu are foarte multe funcionaliti dar se compileaz ntr-un cod rapid i
eficient. De aceea i acum, dup mai bine de 40 de ani, oamenii continua s foloseasc C.
C-ul este un limbaj imperativ. Acest lucru nseamn c pentru a scrie codul se utilizeaz
instruciuni. Subrutinele se numesc funcii i argumentele acestora se transmit totdeauna prin
valoare.
C-ul este un limbaj procedural structurat orientat pe blocuri. Acest lucru nseamn c tot
codul este scris n blocuri i blocurile sunt structurate pentru a mri claritatea programelor.
C-ul este un limbaj puternic tipizat. Acest lucru nseamn c fiecare variabil trebuie s aib
un anumit tip declarat. Declaraiile de tip sunt analizate n timpul compilrii i nu se pot
modifica pe parcursul duratei de via a variabilelor respective. Avantajul unui limbaj puternic
tipizat este faptul c performana este mult mbuntit n comparaie cu limbaje similare de
programare tipizate dinamic. ntr-un sistem tipizat dinamic puterea de procesare n timpul
execuiei este utilizat pentru a determina tipul unei variabile i pentru a creea copii de lucru
cu structurile de date adecvate pentru fiecare variabil i apoi se repet aceste aciuni cnd
variabila se modific. Prin determinarea tipului variabilei la compilare toate aceste aciuni
enunate mai sus sunt eliminate.

1.2. Limbajul C++

C++, numit la nceput "C with classes" a fost dezvoltat n 1979-1980 de ctre danezul Bjarne
Stroustrup. Acesta a dus la mbunatatirea C-ului prin adugarea unor noi faciliti, printre care cea
mai important a fost lucrul cu clase i obiecte, deci paradigma de programare orientat pe obiecte
(POO).
Totui, mult nainte deja, n anii '60, n sprjinul aplicaiilor destinate inteligenei artificiale, au
aprut limbaje care presupun faptul c e nevoie de obiecte care s nu fie simple elemente pasive
asupra crora se fac anumite prelucrri, ci, dimpotriv, c menirea acestor obiecte const n a realiza
prelucrrile asupra lor nile. De aici a pornit ideea de a grupa structurile de date cu operaiile care
prelucreaz respectivele date. Astfel s-a nscut noiunea de obiect sau clas. Proiectarea de programe
utiliznd clase se numete programare orientat pe obiecte (POO). Primele limbaje orientate pe
obiecte au fost SIMULA (1965) si SIMULA-2 (1967). In anii '70 a aprut i celebrul limbaj
SMALLTALK. Cel mai mare dezavantaj al lor a fost faptul c au aprut ca limbaje de sine stttoare,
avnd o rspndire relativ redus. Din acest motiv, puini programatori erau dispui n acea vreme s
renune la limbajele consacrate doar pentru a lucra obiectual.
n vara 1983, C-with-classes a ptruns i n lumea academic i a instituiilor de cercetare.
Astfel, acest limbaj a putut s evolueze datorit experienei acumulate de ctre utilizatorii si.
2

Succesul extraordinar pe care l are limbajul C++ a fost asigurat de faptul c s-a folosit de cel mai
popular limbaj al momentului, C.
C++ este un limbaj de uz general foarte puternic i flexibil, care permite programarea n mai
multe paradigme, cum ar fi paradigma orientat-obiect, cea procedural, funcional i programare
generic. Aa cum s-a mai spus, C++ extinde limbajul C, adugnd multe facilitate puternice, dar
meninnd n acelai timp eficiena i utilitatea C-ului. Aceasta l face s fie i astzi, dup mai bine
de 30 de ani, unul din cele mai rspndite limbaje de programare din lume.
Dac privim la nivelurile de tehnologie ale unui computer ca la o stiv, C++ este folosit
pentru a scrie cod la toate nivelurile cu excepia firmware-ului, avnd cea mai larg utilizare la
nivelul aplicaiilor (Fig.2).

Fig. 2

Astzi un numr mare de aplicaii pe scar medie i larg sunt scrise n C++. Lista unor astfel
de aplicaii este foarte vast, i include Microsoft Office, Adobe Photoshop, Illustrater, FireFox,
Google Chrome, sisteme de aprovizionare, service i eviden a plilor pentru telefonie i internet,
chiar i site-uri web renumite, ca Amazon, Facebook i Google sunt scrise integral n C++ sau au
resurse back-end semnificative scrise n C++. Sisteme de operare cum ar fi toate versiunile de
Windows ncepnd cu 1.0, pri din Unix care nu sunt scrise n C, pri mari din OS10 (alte pri
fiind n Objective C, care e la rndul su bazat pe C). De fapt majoritatea celorlalte limbaje de
programare, cum ar fi Java, PHP, Python i Pearl sunt scrise n C sau C++.

2. Programare structurat versus POO

2.1. Programe i modele
Aproape toate programele modeleaz o problem din lumea real.
Un model este o reprezentare simplificat sau o abstraciune a unui sistem.
Modelul evideniaz doar caracteristicile importante ntr-un anumit context ale sistemului
reprezentat. De exemplu, o main de jucrie prezint anumite detalii exterioare cum ar fi carcasa i
roile, dar nu include componente ca: motorul, rezervorul etc.
ntr-un program, elementele cu ajutorul crora realizm modelarea sunt:
structurile de date i
secvenele de instruciuni sau operaiile.
n funcie de limbajul de programare utilizat, construciile care redau structurile de date i
operaiile sunt mai mult sau mai puin expresive, adic mai mult sau mai puin apropiate de obiectele
ce formeaz domeniul problemei de rezolvat.
La nivelul cel mai de jos, din acest punct de vedere, se situeaz limbajele-main i apoi
limbajele de asamblare, care dispun de structuri de date i operaii primitive cu care nu se pot modela
probleme complexe.
3

2.2. Programarea structurat

Limbajele de nivel nalt aa-numite structurate (de genul Basic, Pascal si C) aduc o cretere
substanial a nivelului de abstractizare mai ales n exprimarea operaiilor. Acestea sunt redate cu
ajutorul structurilor de control (structuri liniare, alternative i repetitive), iar "crmizile" din care
este construit un program sunt subprogramele (funciile i procedurile). Structurile de date oferite de
aceste limbaje rmn ns destul de srace pentru a acoperi complexitatea problemelor de rezolvat.
Limbajele structurate au inspirat metodele procedurale folosite la dezvoltarea produselor
software; ele se caracterizeaz prin:

Un program conceput conform unei metode procedurale pune accentul pe algoritmii care
transform datele iniiale ale unei probleme n rezultate.
Algoritmii sunt structurai n subprograme crora li se furnizeaz date sub form de
parametri sau care acceseaz datele respective prin intermediul unui fond global comun
(fig.3).

Fig. 3

Programarea structurat (oferit de C spre exemplu) oferea dou mari avantaje:

1.) Modularizarea ceea ce nseamn descompunerea unei probleme complexe n
subprobleme pn se obin probleme foarte simple i relativ independente . Pentru fiecare
problem simpl se scrie apoi un modul de program corespunztor, i el simplu. Fiecare
modul de program execut un grup de prelucrri independente de grupurile de prelucrri
ale celorlaltor module. La nevoie modulele comunic ntre ele prin interfee constituite
din seturi de parametri. Relativa independen a modulelor permite efectuarea operaiilor
specifice de implementare, testare, depanare i modificare n mod independent de
celelalte module.
2.) Structurarea datelor i a prelucrrii lor: Datele se grupeaz n colecii organizate dup
reguli potrivite, astfel rezultnd structuri de date. Prelucrrile datelor se pot organiza
conform a cel puin trei structuri fundamentale: structura liniar (secvenial), structura
alternativ i structura repetitiv.
Totui, programarea structurat a fost o etap ce a trebuit s fie depit, deoarece este
deficitar n ceea ce privete posibilitatea reutilizrii programelor, a scalabilitii i extinderii unor
module de program, atribute de nenlocuit n realizarea aplicaiilor complexe. Principala deficien
a programrii structurate const n tratarea separat a algoritmilor i a structurilor de date ce se
4

prelucreaz. De obicei, n natur, o entitate este caracterizata att printr-o structur, ct i printr-un
anume comportament. n mod normal, obiectele evolueaz n timp, adeseori modificndu-i structura
i funcionalitatea.

2.3. Programarea orientat-obiect

Limbajele de programare orientate pe obiecte (LPOO) aduc o nou viziune asupra
dezvoltrii programelor, urmrind s acopere "slbiciunile" limbajelor structurate privind structurile
de date. Mai precis, programatorului i se d posibilitatea de a-i construi propriile tipuri de date,
dotate cu operaiile necesare, care s "mimeze" ct mai fidel entitile din domeniul problemei de
rezolvat.
Cu toate c avantajele programrii orientate pe obiecte (POO) vor deveni tot mai clare pe
msur ce parcurgei acest curs de POO, ar fi poate util n acest punct s marcm o paralel ntre
POO i lumea nconjurtoare.
Obiectele sunt cheia nelegerii tehnologiei OO. Privind n jur vei vedea o sumedenie de
obiecte care v nconjoar n lumea real: pisica, patul, telefonul, bicicleta etc.
Obiectele din lumea real au dou caracteristici: Toate au nite atribute de stare i unele
comportamente/operaii. Spre exemplu pisicile au atribute de stare (nume, culoare, ras) i
comportamente (mieunat, zgriat, mncat). Bicicletele de asemenea au atribute de stare (viteza
curent, cadena de pedalare) i operaii (schimbarea de vitez, schimbarea cadenei, frnare).
Identificarea atributelor i operaiilor/comportamentelor pentru obiectele din lumea real este un bun
nceput pentru a ne obinui cu gndirea n termenii POO.
Luai-v un minut chiar acum pentru a studia obiectele din lumea real din imediata voastr
apropiere. Pentru fiecare obiect pe care l vedei punei-v dou ntrebri: "n ce stri posibile poate fi
acest obiect?" i "Ce comportamente/operaii posibile poate avea acest obiect?". Astfel vei observa
c obiectele din lumea real variaz n ceea ce privete complexitatea lor; lampa de birou ar putea
avea doar dou posibile stri (oprit i pornit) i dou posibile operaii (pornire, oprire), ns un
radio ar putea avea mai multe atribute de stare (pornit, oprit, volumul curent, postul curent) i operaii
(pornire, oprire, mrire volum, micorare volum, cutare post etc). Vei putea observa de asemenea
c unele obiecte vor conine, la rndul lor, alte obiecte. Toate aceste observaii din lumea real se
regsesc transpuse n lumea POO.
Un program dezvoltat cu ajutorul tehnologiei obiectuale are drept unitate de constructie nu
subprogramul, ci obiectul (fig.4).

Fig. 4.
5

Un obiect nglobeaz date i operaii i reprezint o abstraciune a unei entiti din

lumea real.
Obiectele componente interacioneaz, iar rezultatul acestei interaciuni o reprezint
transformarea datelor de intrare n date de ieire, adic rezolvarea problemei.
Folosind tehnologia obiectual, abstractizarea (nelegnd prin aceasta tranziia de la entitile
domeniului problemei de rezolvat la programul care o modeleaza) este mai direct, mai natural.
Motivul st n faptul c noi, oamenii, percepem lumea nconjurtoare n termeni de obiecte fizice i
concepte mentale care se mic, se transform, interacioneaz unele cu altele, determinnd n felul
acesta modificri ale mediului nconjurtor.
Un obiect din lumea real are cteva caracteristici importante, i anume:
este perceput prin intermediul comportamentului si insuirilor sale exterioare; de exemplu,
vedem c o pisic merge, fr s tim (i fr s ne intereseze chiar) care sunt mecanismele
interioare care determin mersul. Cu alte cuvinte, obiectul are o fa exterioar (interfa
public) pe care o arat altor obiecte, precum i o reprezentare (stare) intern care imprim
comportarea exterioar;
are granie distinct conturate, care l delimiteaz de celelalte obiecte i este autodeterminat:
pastrnd exemplul cu pisica, pentru a vedea c ea merge, nu avem nevoie s vedem un alt
obiect suplimentar; spunem c obiectul are identitate distinct;
n cazul programrii procedurale abstractizarea presupune realizarea unui set de algoritmi
(subprograme) care s modeleze transformrile din lumea real, folosind pentru reprezentarea unor
entiti complexe structuri de date primitive.
n cazul programrii obiectuale, abstractizarea presupune definirea unor structuri de date
complexe dotate cu un comportament exterior i cu o stare intern, care se suprapun peste obiectele
din lumea real.
ntr-un program dezvoltat n manier obiectual NU mai avem date globale (sau n orice caz,
foarte puine). Datele sunt repartizate i nglobate n obiecte. Putem spune c metoda obiectual de
dezvoltare conduce la o mai bun respectare a unor principii ale ingineriei software cum ar fi:
localizarea i modularizarea: codul surs corespunztor unui obiect poate fi scris i
actualizat independent de alte obiecte;
ascunderea informaiei: un obiect are, dup cum vom vedea n curnd, o interfa public pe
care celelalte obiecte o pot utiliza n vederea comunicrii. Dar, pe lng interfaa public, un
obiect poate include date i operaii private, "ascunse" fa de alte obiecte, i care pot fi
modificate oricnd, fr a afecta restul obiectelor.
reutilizarea codului: multe clase de obiecte pot fi definite pe baza altor clase deja existente,
prelundu-se automat (prin motenire) coninutul acestora din urm;
Trecand la un limbaj de programare orientat pe obiecte nu nseamna c "aruncm" principiile
programrii structurate. Operaiile nglobate n obiecte nu sunt altceva dect un fel de subprograme
(chiar dac au alt nume) care vor fi dezvoltate utiliznd structurile de control cunoscute de la
limbajele structurate.
ntr-o exprimare plastic:
Diferena esenial ntre limbajele procedurale i cele obiectuale este aceea c limbajele
procedurale au un caracter imperativ, fiind axate pe "verbe" (subprograme), n timp ce
6

limbajele obiectuale au un caracter mai declarativ i sunt concentrate n jurul

"substantivelor" (datele).
innd cont de cele afirmate pna aici, putem formula principiul dup care realizm
transpunerea enunului unei probleme ntr-un LPOO:

identificm obiectele ce populeaz spaiul programului, prin evidenierea substantivelor din

enunul problemei;
pentru fiecare obiect identificm datele i operaiile, prin evidenierea adjectivelor i
verbelor ce caracterizeaz substantivul respectiv.

n ultimii ani, POO a devenit foarte rspndit, mai ales datorit avantajelor sale, care ajut
dezvoltrii proiectelor actuale, ce devin din ce n ce mai complexe. Acest stil de programare duce la
mprirea aplicaiilor n mai multe module, astfel nct cel ce dezvolt un modul nu trebuie s
cunoasc detaliile de implementare a altor module. Domeniul n care acest stil de programare s-a
dovedit cel mai util este dezvoltarea interfeelor utilizator i a aplicaiilor bazate pe acestea.
Limbaje OO utilizate astzi pe scar larg sunt foarte multe la numr, ncepnd cu C++,
Objective-C, C#, Visual Basic.NET, VBScript, F#, Visual FoxPro, Visual Prolog, Java, Perl ncepnd
cu versiunea 5, PHP5, Python, ABAP .a.

2.4. Exemplu de programare procedural versus POO

n cele ce urmeaz vom prezenta un exemplu de problem modelat n manier procedural i
n manier obiectual, pentru a vedea mai bine diferenele ntre cele dou viziuni.
Problema se refer la crearea i utilizarea unei stive de numere ntregi. Dup cum probabil
stii, o stiv este o colecie cu structur liniar, n/din care se pot introduce/extrage elemente pe la un
singur capt, considerat a fi vrful stivei (cellalt capt este baza). Operaiile asupra stivei au
denumiri consacrate n literatur, i anume: introducerea elementelor este numit push, iar extragerea
- pop; n plus, exist o operaie de consultare a valorii din vrful stivei, numit top.
Pentru a nu v solicita atenia cu detalii sintactico-semantice specifice unui anumit limbaj de
programare, vom considera c dispunem de un fel de pseudo-cod pentru ambele maniere de
modelare. Convenim ca pentru reprezentarea stivei s folosim un tablou cu elemente ntregi, cruia i
se asociaz un indicator de stiv reprezentnd indicele ultimului element ocupat n tablou. De
asemenea, vom folosi o variabil necesar memorrii dimensiunii totale a tabloului.
-- Stiva in varianta procedurala --

-- Stiva in varianta obiectuala --

subprogram initStiva(unTab, dimTab,

indTab){
*aloca spatiu in unTab pentru dimTab
elemente
indTab = -1;
-- se considera ca indicele primului
element din tablou este 0 -}

clasa Stiva{
*fie tab un tablou cu elemente de tip
int
*fie dimTab o variabila de tip int
*fie indTab o variabila de tip int
operatia initStiva(nrElem){
*aloca spatiu in tab pentru nrElem
elemente
dimTab = nrElem;
indTab = -1;
-- se considera ca indicele
primului element din tablou este 0

subprogram push(unTab, dimTab, spTab,

elem){
if (indTab < dimTab-1){
spTab = spTab + 1;

unTab[indTab] = elem;

--

}
else

}
*semnaleaza eroare - depasire
capacitate stiva

operatia push(elem){
if (indTab < dimTab-1){
indTab = indTab + 1;
tab[indTab] = elem;
}
else
*semnaleaza eroare depasire capacitate stiva
}

}
subprogram int pop(unTab, dimTab, indTab){
if (indTab >= 0){
indTab = indTab - 1;
return unTab[indTab+1];
}
else
*semnaleaza eroare - stiva
vida
}

operatia int pop( ){

if (indTab >= 0){
indTab = indTab - 1;
return tab[indTab+1];
}
else
*semnaleaza eroare - stiva
vida
}

subprogram int top(unTab, dimTab, indTab){

if (indTab >= 0)
return unTab[indTab];
else
*semnaleaza eroare - stiva
vida
}
subprogram client( ){
*fie tab1, tab2, tab3 numele unor
tablouri cu elemente de tip int
*fie dim1, dim2, dim3 variabile care
memoreaza dimensiunile tablourilor
*fie ind1, ind2, ind3 variabile cu
rol de indicatori de stiva
dim1 = 10;
dim2 = 5;
dim3 = 6;
-- se initializeaza stivele -call initStiva(tab1, dim1, ind1);
call initStiva(tab2, dim2, ind2);
call initStiva(tab3, dim3, ind3);

operatia int top( ){

if (indTab >= 0)
return tab[indTab];
else
*semnaleaza eroare - stiva
vida
}
}
} -- end clasa Stiva -clasa Client( ){
operatia prelucrareStiva( ){
*creaza obiectele s1, s2 si s3 de
tip Stiva
-- se initializeaza stivele -call s1.initStiva(10);
call s2.initStiva(5);
call s3.initStiva(6);

-- se introduc elemente in stive -call push(tab1, dim1, ind1, 17);

call push(tab1, dim1, ind1, 100);
call push(tab2, dim2, ind2, 26);
call push(tab2, dim2, ind2, 15);

-- se introduc elemente in stive call s1.push(17);

call s1.push(100);
call s2.push(26);
call s2.push(15);

-- se extrag elemente din stive -e1 = call pop(tab1, dim1, ind1);

e2 = call pop(tab2, dim2, ind2);
-- se consulta valorile din varful
stivelor -x1 = call top(tab1, dim1, sp1);
x2 = call top(tab2, dim2, sp2);

-- se extrag elemente din stive --

...

-- se consulta valorile din varful

stivelor -x1 = call s1.top( );
x2 = call s2.top( );
...

e1 = call s1.pop( );
e2 = call s2.pop( );

}
} -- end clasa Client --

Comparnd cele dou secvene de mai sus, un prim aspect care trebuie remarcat este faptul c
n varianta procedural am definit un set de operaii reprezentate ca subprograme, care primesc ca
parametri stivele asupra crora lucreaz, n timp ce n varianta obiectual, operaiile sunt nglobate n
interiorul unui obiect reprezentnd stiva. Pot s am oricte obiecte de acest fel, fiecare din ele va avea
setul su propriu de operaii care vor lucra asupra datelor interne ale obiectului. Din acest motiv
operaiile nu necesit atia parametri, ca n varianta procedural. Cu alte cuvinte: n varianta
procedural operaiile (subprogramele) sunt deintoarele datelor asupra crora lucreaz, n timp
ce n varianta obiectual datele (obiectele) sunt cele care posed operaiile.
O alta observaie important este faptul c simbolul Stiva definit ca o clas este de fapt un tip
definit de utilizator. Ca orice tip, el poate fi folosit pentru a declara variabile asupra crora se vor
aplica operaii recunoscute de tipul respectiv.
Pentru a nelege mai bine, s ne gndim ce este un tip dintr-un limbaj de programare:
Un tip este o mulime de valori dotat cu un anumit set de operaii.
n majoritatea limbajelor procedurale suntem obinuii s lucrm cu aa-numitele
tipuri predefinite sau primitive. Spre exemplu, tipul int din limbajul C desemneaz mulimea
numerelor ntregi reprezentabile pe 2 octei. Setul de operaii cu care este dotat acest tip cuprinde,
printre altele, cele patru operaii aritmetice.
De multe ori tipurile predefinite sunt prea srace pentru a permite modelarea unor entiti
complexe din lumea real. De aceea, este necesar ca programatorul s aib libertatea de a-i crea
propriile tipuri (mpreuna cu operaiile aferente) pe care apoi s le foloseasca la fel cum folosete
tipurile predefinite. Limbajele de programare obiectuale au fost concepute tocmai n acest sens.
Tot pe marginea celor dou exemple prezentate, ar trebui spus c n varianta obiectual
programatorul este ajutat s evite o serie ntreag de erori, datorit ncapsulrii datelor i operaiilor
caracteristice unei abstraciuni (n cazul nostru stiva) n interiorul unui obiect. Spre exemplu, n
varianta procedural, programatorul poate la un moment dat s modifice accidental, printr-o atribuire
simpl, valoarea lui ind1, dnd astfel peste cap stiva respectiv. n cealalt variant, aa cum vom
vedea pe parcurs, datele din interiorul unui obiect pot fi declarate ca ascunse fa de exteriorul
obiectului, astfel nct modificarea indicatorului de stiv s nu se poat face dect via
operaiile push i pop, adic ntr-un mod controlat.

2.5. Definiia POO

Programarea orientat pe obiecte este o metoda de implementare n care programele
sunt organizate ca ansamble de obiecte ce interacioneaz unele cu altele, fiecare obiect
reprezentnd instana unei clase; fiecare clas aparine unei ierarhii n cadrul creia
clasele sunt legate prin relaii de motenire.
Aceasta definiie cuprinde trei pri importante, i anume:
obiectele i nu algoritmii sunt blocurile logice fundamentale;
9

fiecare obiect este o instan a unei clase. Clasa este o descriere a unei mulimi de obiecte
caracterizate prin structur i comportament similare, iar prin instan nelegem o
valoare particular din mulimea respectiv
clasele sunt legate ntre ele prin relaii de motenire.

Un limbaj de programare care ofer suport pentru utilizarea claselor i a obiectelor, dar care
nu are implementat mecanismul relaiilor de motenire ntre clase este un limbaj de programare bazat
pe obiecte. Programarea bazat pe clase i pe obiecte, care nu face uz de relaia de motenire se mai
numete programare cu tipuri de date abstracte.

2.6. Rezolvarea problemelor cu POO

Pentru a rezolva cu ajutorul POO probleme ce implic sisteme nu foarte complexe, trebuie s
tii cel puin dou lucruri:
1) n primul rnd, desigur, trebuie s nvai sintaxa specific limbajelor de programare.
Aceasta nu nseamn s nvai pe de rost sintaxe, atta timp ct dispunei de resurse i
documentaii web n cantitate mai mult dect suficient. Dar, fr o cunoatere bun a
structurilor i mecanismelor puse la dispoziie de limbajul de programare, nu vei putea
realiza o soluie pentru problema propus.
2) Pe lng sintaxa limbajului va trebui s v nsuii pentru fiecare limbaj conceptele de
ncapsulare, motenire i polimorfism, deoarece aceste trei concepte reprezint baza
oricrui limbaj orientat-obiect. Modul cum funcioneaz fiecare concept variaz ntr-o
msur mai mica sau mai mare de la limbaj la limbaj. De exemplu, C++ permite
motenire multipl, ceea ce d programatorului anumite liberti, dar crete riscul de a
scrie cod eronat. Pe de alt parte Java interzice motenirea multipl n sensul permis de
ctre C++, permite ns unei clase s moteneasc de la oricte interfee. Tot la fel,
specificatorii de acces, care permit ncapsularea informaiei ntr-o clas cu diferite
niveluri de acces, funcioneaz uor diferit n C++ fa de Java. n plus, Java are
conceptul de package care are legtur cu controlul accesului - un concept care nu exist
n C++. Polimorfismul permite unui tip dintr-o subclas s fie tratat ca un tip de
superclas. Cu toate c funcioneaz n esen la fel n toate limbajele OO, modul n care
polimorfismul este invocat poate duce la constrngeri importante asupra programrii. n
C++ de exemplu, polimorfismul poate fi invocat numai prin pointeri, un fapt care poate
avea o mare semnificaie asupra modului cum se poate referi un obiect ntr-un program.
Pentru sisteme complexe intervine i un al treilea lucru important, i anume:
3) Cunoaterea unui "meta-limbaj", cum ar fi Unified Modeling Language (UML), care
permite reprezentarea vizual a proiectrii la nivel conceptual, i respectiv nvarea
abloanelor de design (design patterns), acestea fiind soluii template pentru o mulime de
subprobleme posibil de nfruntat pe parcursul dezvoltrii unui program OO.
Pentru acest curs vom dezvolta primele dou puncte de mai sus (punctul 3, UML, depete
cadrul acestui curs) utiliznd limbajul C++. Am ales acest limbaj deoarece C++ este, ntr-un fel, baza
pe care au fost construite multe din celelalte limbaje OO, dup cum s-a artat la nceputul acestui
capitol. Pentru nceput, vom trece sumar n revist fundamentele limbajului C++, structurile de
control i tipurile de date compuse, pentru ca apoi s dezvoltm capitolele legate strict de conceptele
de POO.

10