Universitatea Din Bucuresti Facultatea de Matematica si Informatica Specializare: Tehnologia Informatiei

Proiect

Profesori Coordonator: Prep Univ Drd Dragan Mihaita Conf dr !ramatovici "adu

Studenti: Popescu Mihai #le$andru %aduva %alentin

BUC &'(& Universitatea Din Bucuresti Facultatea de Matematica si Informatica Specializare: Tehnologia Informatiei

Programare orientata pe obiecte

Profesori Coordonator: Prep Univ Drd Dragan Mihaita Conf dr !ramatovici "adu

Studenti: Popescu Mihai #le$andru %aduva %alentin

&

BUC &'(&

Cuprins
Cuprins Introducere Cerinta "eprezentare grafica Metoda de rezolvare Cod sursa Screenshot Bi/liografie ) * + , (' &. )'

Introducere
Programarea orientat0 pe o/iecte 1Programare 2rientat0 2/iectual3 este unul din cei mai importani pai f0cui 4n evoluia lim/a5elor de programare spre o mai puternic0 a/stractizare 4n implementarea programelor 6a a ap0rut din necesitatea e$prim0rii pro/lemei 4ntr7un mod mai natural fiinei umane #stfel unitaile care alc0tuiesc un program se apropie mai mult de modul nostru de a g8ndi dec8t modul de lucru al calculatorului P8n0 la apariia program0rii orientate pe o/iect programele erau implementate 4n lim/a5e de programare procedurale 1C9 Pascal3 sau 4n lim/a5e care nici m0car nu ofereau o modalitate de grupare a instruciunilor 4n unit0i logice 1funcii9 proceduri3 cum este cazul lim/a5ului de asam/lare 1assem/ler3 #ltfel spus o pro/lem0 preluat0 din natur0 tre/uia fragmentat0 4n repetate r8nduri astfel 4nc8t s0 se identifice elementele distincte9 implementa/ile 4ntr7un lim/a5 de programare 2 mare pro/lem0 a program0rii procedurale era separarea datelor de unit0ile care prelucrau datele1su/rutinele39 ceea ce f0cea foarte dificil0 e$tinderea i 4ntreinerea unui program #stfel s7a pus pro/lema ca aceste dou0 entit0i1date i su/rutine3 s0 fie grupate 4ntr7un anumit mod9 astfel 4nc8t su/rutinele s0 :tie: 4n permanen0 ce date prelucreaz0 i9 mai mult dec0t at8t9 ele s0 formeze un modul9 adic0 o unitate care separ0 implementarea de interfa09 ceea ce implic0 posi/ilitatea refolosirii codului # ap0rut astfel conceptul de clas0 Clasa realizeaz09 4n spe09 ceea ce am v0zut mai 4nainte: grupeaz0 datele i unit0ile de prelucrare a acestora 4ntr7un modul9 unindu7le astfel 4ntr7o entitate mult mai natural0 Dei tehnica se numete :Programare 2rientat0 2/iectual:9 conceptul de /az0 al ei este Clasa Clasa9 pe l8ng0 faptul c0 a/stractizeaz0 foarte mult analiza;sinteza pro/lemei9 are proprietatea de generalitate9 ea desemn8nd o mulime de o/iecte care 4mpart o serie de propriet0i

Cerinta
S0 se defineasc0 o clas0 generic0 pentru ansam/le9 reprezentate ca vectori9 av8nd cei de un tip neprecizat9 prev0zut cu o ordine total0 1si cu operatorii relaionali9 operatorii de ordine fiind corespunz0tori respectivei ordini totale39 cu supra4nc0rcarea operatorilor indicai mai 5os <9 <<9 = 9 =<9 >9 >< 1operatorii de ordine 4ntorc ( sau ' conform ordon0rii le$icografice a irurilor ordonate care rezult0 din operanzi3? @ se supra4ncarc0 in ) moduri: a3 primul operand cheie9 al doilea ansam/lu? /3 primul operand ansam/lu9 al doilea operand cheie? c3 am/ii operanzi ansam/le? rezultatul operaiilor a3 /3 este ansam/lul o/inut prin inserarea cheii 4n ansam/lu? rezultatul operaiei c3 este ansam/lul o/inut prin inserarea in primul ansam/lu a cheilor ansam/lului al doilea9 e$trase prin decapit0ri succesive? 7 se supra4ncarca in & moduri: a3 primul operand ansam/lu9 al doilea operand cheie? /3 am/ii operanzi ansam/le? rezultatul operaiei a3 este ansam/lul o/inut prin tergerea unei apariii a cheii din ansam/lu9 dac0 e$ist0 1aceasta revine la reasam/larea elementelor r0mase dup0 tergerea cheii din vectorul care reprezint0 ansam/lul3? rezultatul operaiei /3 este ansam/lul o/inut prin tergerea din primul ar/ore a cheilor ar/orelui al doilea9 e$trase prin decapit0ri succesive

Reprezentare grafica
33 15 6 8 2 4 1 6 )) 15 8 2 1 4

Dupa o prima decapitare 9 radacina1))3 este eliminata 9 ar/orele urmand sa fie rearan5at9 iar elemenul cel mai de 5os9din dreapta devine radacina #cum ( se compara cu fii sai 9 cel mai mare ocupandu7i pozitia In cazul nostru (+ este cel mai mare dintre fii 15 1 6 8 2 4 6 8 1 2 15 15 4

Dupa interschim/area dintre (+ si ( urmeaza o noua verificare si pe pozitia lui ( va a5unge cel mai mare dintre fii 2 8 6 1 4 6 2 1 8 4

8 8 6 2 1 4 2 , 6

1 4

6 1 2 4 1 2

6 6 4

1 2 4 2

4 1

1 2

2 2 1 1

Metoda de rezolvare
Ca metoda de rezolvare a pro/lemei s7a ales urmatoarea varianta: S7a creat o clasa generica pentru ma$7ansam/le in care se pot adauga si sterge chei sau alte ansam/le #daugarea unei chei se face la sfarsitul ansam/lului9 dupa care aceasta este comparata cu radacina si mutata in locul acesteia pana cand se gaseste o radacina fata de care nu este mai mare Stergerea unei chei se realizeaza prin inlocuirea cheii de sters cu radacina care9 la randul ei este inlocuita cu radacina mai mare In locul primei radacini din ansam/lu se muta ultima cheie9 aceasta fiind pe urma co/orata prin comparatii cu cel mai mare dintre fii S7au definit operatorii =9 B9 >9 C relationali prin intermediul carora putem compara doua ansam/le #cestia creeaza cate un vector ordonat crescator din fiecare ansam/lu si determina ordinea le$icografica a celor doi vectori %ectorii sunt formati prin decapitari succesive ale ansam/lelor Decapitarea este efectuata prin returnarea cheii din radacina si inlocuirea acesteia in ansam/lu cu ultima cheie9 urmata de co/orare asa cum am descris mai sus Pentru adaugarea cheilor intr7un ansam/lu se foloseste operatorul @ in urmatoarele ) moduri: ( #nsam/lu @ cheie Implementat ca functie mem/ra a clasei ansam/lu9 acest operator creeaza o copie a ansam/lului in care adauga cheia primita ca parametru si o returneaza la final & Cheie @ ansam/lu Implementat ca functie glo/ala9 apeleaza operatorul de mai sus cu parametrii inversati ) #nsam/lu @ ansam/lu Implementat ca functie mem/ra9 apeleaza prima supraincarcare pentru fiecare cheie din ansam/lul primit ca parametru Pentru stergerea cheilor dintr7un ansam/lu se foloseste operatorul D in urmatoarele & moduri9 am/ele fiind implementate ca functii mem/re: ( & #nsam/lu D cheie #nsam/lu D ansam/lu

Clasa ansam/lu dispune de & constructori de initializare9 un constructor de copiere si un destructor

Cei doi constructori de initializare sunt folositi in interiorul metodelor9 dar pot fi folositi si in afara Unul dintre cei doi constructori de initializare poate fi apelat fara niciun parametru9 el avand un singur paramentru implicit Constructorul de copiere aloca spatiu si copiaza elementele din ansam/lul primit ca parametru Destructorul eli/ereaza memoria alocata dinamic pentru vectorul de elemente

Cod sursa
Einclude =iostream h> ;FDirectiva de procesor Determina includerea in fisierul sursa a fisierului header cu numele iostream h care permite realizarea afisarii in consolaF; Edefine D6F#UGTHG6I!TJ ' ;F Definirea valorii default pentru lungimea vectorului de elemente cand nu se da e$plicit o valoare catre constructorF; int i? ;;declararea contorului de tip integer template=class tip> class ansam/lu ;; declararea clasei generice ansam/lu K tip Fv? ;; se foloseste un tip primit ca parametru pentru vectorul de chei int length? ;; declararea varia/ilei ce reprezinta lungimea vectorului tip decapitate13? ;;functia care decapiteaza ansam/lul si returneaza radacina pu/lic: ansam/lu1int n<D6F#UGTHG6I!TJ3? ;;constructor caruia i se poate specifica lungimea vectorului ansam/lu1int n9 tip cheiLM3?;;constructor caruie i se specifica numarul de elemente si vectorul de chei ansam/lu1const ansam/lu=tip> NcopO3?;;constructorul de copiere Pansam/lu13?;;destructor ansam/lu=tip> operator@1const tip Ncheie3?;;operatorul @ cu mem/rul stang ansam/lu si mem/rul drept cheie ansam/lu=tip> operator@1ansam/lu=tip> ans3?;;operatorul @ cu am/ii operanzi ansam/le ansam/lu=tip> Noperator<1const ansam/lu=tip> Nans3?;;operatorul de atri/uire /ool operator<<1const ansam/lu=tip> Nans3?;;operatorul << /ool operator=1ansam/lu=tip> ans3?;;operatorul = /ool operator=<1ansam/lu=tip> ans3?;;operatorul =< /ool operator>1ansam/lu=tip> ans3?;;operatorul > /ool operator><1ansam/lu=tip> ans3?;;operatorul>< ansam/lu=tip> operator71const tip Ncheie3?;;operatorul D cu mem/rul stang ansam/lu si mem/rul drept cheie

('

ansam/lu=tip> operator71const ansam/lu=tip> Nans3?;;operatorul D cu am/ii operanzi ansam/le void print13 Kfor 1i<'? i=length?i@@3 cout==vLiM==: :? cout==endl?Q ;;functie de afisare int getHlength13 Kreturn length?Q;;functie care returneaza lungimea vectorului Q? template=class tip> tip ansam/lu=tip>::decapitate13 tip retHvalue < vL'M? length77? vL'M<vLlengthM? i<'? ;; mutam radacina in pozitia corespunzatoare Rhile1i=length;&3 K int left<&Fi@(9 right<&Fi@&9 ma$Hi? ;;left;right retin indicii fiilor din stanga respectiv dreapta 9 iar ma$Hi retine indicele celui mai mare dintre ei tip man? ;; o varia/ila care a5uta la manevrarea cheilor if 1vLleftM>vLrightM3 ;; selectam cel mai mare dintre fii ma$Hi<left? else ma$Hi<right? if 1vLiM=vLma$HiM3 K man < vLiM? vLiM<vLma$HiM? vLma$HiM<man? i<ma$Hi? Q else /reaS? /ucla Rhile Q
((

;; salvam valoarea ce tre/uie returnata ;; se micsoreaza vecortul ;; punem in radacina ultimul element

;;daca radacina este mai mica decat cel mai mare fiu ;; interschim/am cele doua chei

;; mergem pe pozitia pe care am mutat radacina

;; daca cheia este pe pozitia corespunzatoare9 iesim din

tip FtempHv < neR tipLlengthM? element ce nu mai era folosit for 1int 5<'?5=length?5@@3 noul vector tempHvL5M<vL5M? deleteLM v? ansam/lu v < tempHv? return retHvalue? decapitare Q

;; realocam vectorul pentru a scapa de ultimul ;; copiem elementele ramase dupa decapitare in

;; eli/eram memoria alocata vectorului din ;; asociem pointerului v adresa noului vector ;; returnam cheia care a fost o/tinuta prin

template=class tip> ansam/lu=tip>::ansam/lu1int n3 K v<neR tipLnM? length<n? Q ;; un constructor care preia elementele vectorului primit ca parametru template=class tip> ansam/lu=tip>::ansam/lu1int n9 tip cheiLM3 K length<n? if 1Tlength3 Kv<'? return?Q v<neR tipLnM? for 1i<'? i=n?i@@3 vLiM<cheiLiM? Q ;; constructorul de copiere template=class tip> ansam/lu=tip>::ansam/lu1const ansam/lu=tip> NcopO3 K v<neR tipLcopO lengthM? length<copO length?
(&

;; alocam spatiu pentru elementele ansam/lului ;; sta/ilim numarul de elemente in ansam/lu

for 1i<'?i=length?i@@3 vLiM<'?;; initializam elementele cu '

;; sta/ilim numarul de elemente ;; daca lungimea este '9 nu alocam spatiu

for 1i<'? i=length?i@@3 vLiM<copO vLiM? Q template=class tip> ansam/lu=tip>::Pansam/lu13 K deleteLM v? Q ;; nu avem nevoie sa fie functie prietena9 o folosim doar pt inversarea operanzilor template=class tip> ansam/lu=tip> operator@1tip cheie9 ansam/lu=tip> Nans3 K return ans operator@1cheie3? indiferent de ordinea operanzior Q template=class tip> ansam/lu=tip> ansam/lu=tip>::operator@1const tip Ncheie3 K tip Ftemp < neR tipLthis7>length@(M? elementele de5a e$istente @ noul element for 1i<'?i=this7>length?i@@3 ansam/lu tempLiM<this7>vLiM? tempLthis7>lengthM < cheie? int S<this7>length? Rhile 1S>'3 K int parent < 1S7(3;&? if 1tempLSM>tempLparentM3 K tip man < tempLSM? tempLSM<tempLparentM? tempLparentM<man? S<parent? Q
()

;; folosim aceeasi procedura

;; facem un vector in care sa incapa ;; copiem elementele de5a e$istente in

;; punem pe ultima pozitie noul element ;; aducem noul element pe pozitia corespunzatoare

else /reaS? Q ;; cre0m un nou ansam/lu de lungime length@( ansam/lu=tip> Fnou < neR ansam/lu=tip>1this7>length@(3? ;; asociem pointerului catre vectorul de elemente adresa vectorului alocat anterior nou7>v < temp? return Fnou? Q template=class tip> ansam/lu=tip> ansam/lu=tip>::operator@1ansam/lu=tip> ans3 K int t? ;; folosim o copie a o/iectului pentru care este apelat operatorul ansam/lu=tip> #ScopO1this7>length9 this7>v3? int ansHlength < ans length? ;; salvam lungimea ansam/lului primit ca parametru deoarece il vom decapita for 1t<'?t=ansHlength?t@@3 K tip head < ans decapitate13? parametru #ScopO < #ScopO operator@1head3?;; adaugam radacina sa in copia facuta anterior Q return #ScopO? Q template=class tip> ansam/lu=tip> Nansam/lu=tip>::operator<1const ansam/lu=tip> Nans3 K if 1NansT<this3 K deleteLM this7>v? ;; stergem elementele operandului stang ;; realocam vectorul
(*

;; returnam noul ansam/lu cu datele o/tinute pana acum

;; decapitam ansam/lul primit ca

;; returnam copia

;; ne asiguram ca operandul din stanga si cel din dreapta sunt

diferiti deoarece altfel vom sterge vectorul de elemente din am/ele

this7>v < neR tipLans lengthM?

this7>length < ans length? drept for 1i<'?i=this7>length?i@@3 this7>vLiM<ans vLiM? Q return Fthis?;; returnam operandul stang Q

;; introducem elementele operandului

template=class tip> /ool ansam/lu=tip>::operator<<1const ansam/lu=tip> Nans3 K if 1this7>lengthT<ans length3 elemente return false? for 1i<'?i=this7>length?i@@3 if 1this7>vLiMT<ans vLiM3 return false? return true? Q template=class tip> /ool ansam/lu=tip>::operator=1ansam/lu=tip> ans3 K ansam/lu=tip> copie < Fthis? primit prin valoare si de5a este o copie ;; salvam lungimile inainte de decapitare int v(Hlength < copie length9 v&Hlength < ans length? ;; alocam doi vectori in care vom plasa elementele ansam/lelor in ordine crescatoare tip Fv( < neR tipLcopie lengthM9Fv& < neR tipLans lengthM? for 1i<copie length7(?i><'?i773 coada la cap v(LiM < copie decapitate13? for 1i<ans length7(?i><'?i773 v&LiM < ans decapitate13? for 1i<'?i=11v(Hlength=v&Hlength3Uv(Hlength:v&Hlength3?i@@3 parcurgem vectorii pana la lungimea celui mai mic dintre ei
(+

;; testam daca ansam/lele au acelasi numar de

;; testam daca elementele coincid

;; facem o copie operandului stang9 celalalt este

;; decapitam ansam/lul si plasam elementele de la

if 1v(LiM=v&LiM3 return true? else if 1v(LiM>v&LiM3 return false? return false? Q template=class tip> /ool ansam/lu=tip>::operator=<1ansam/lu=tip> ans3 K ansam/lu=tip> copie < Fthis? int v(Hlength < copie length9 v&Hlength < ans length? tip Fv( < neR tipLcopie lengthM9Fv& < neR tipLans lengthM? for 1i<copie length7(?i><'?i773 v(LiM < copie decapitate13? for 1i<ans length7(?i><'?i773 v&LiM < ans decapitate13? for 1i<'?i=11v(Hlength=v&Hlength3Uv(Hlength:v&Hlength3?i@@3 if 1v(LiM=v&LiM3 return true? else if 1v(LiM>v&LiM3 return false? if 1v(Hlength<<v&Hlength3 return true? else return false? Q template=class tip> /ool ansam/lu=tip>::operator>1ansam/lu=tip> ans3 K ansam/lu=tip> copie < Fthis? int v(Hlength < copie length9 v&Hlength < ans length? tip Fv( < neR tipLcopie lengthM9Fv& < neR tipLans lengthM? for 1i<copie length7(?i><'?i773 v(LiM < copie decapitate13?
(,

for 1i<ans length7(?i><'?i773 v&LiM < ans decapitate13? for 1i<'?i=11v(Hlength=v&Hlength3Uv(Hlength:v&Hlength3?i@@3 if 1v(LiM>v&LiM3 return true? else if 1v(LiM=v&LiM3 return false? return false? Q template=class tip> /ool ansam/lu=tip>::operator><1ansam/lu=tip> ans3 K ansam/lu=tip> copie < Fthis? int v(Hlength < copie length9 v&Hlength < ans length? tip Fv( < neR tipLcopie lengthM9Fv& < neR tipLans lengthM? for 1i<copie length7(?i><'?i773 v(LiM < copie decapitate13? for 1i<ans length7(?i><'?i773 v&LiM < ans decapitate13? for 1i<'?i=11v(Hlength=v&Hlength3Uv(Hlength:v&Hlength3?i@@3 if 1v(LiM>v&LiM3 return true? else if 1v(LiM=v&LiM3 return false? if 1v(Hlength<<v&Hlength3 return true? else return false? Q template=class tip> ansam/lu=tip> ansam/lu=tip>::operator71const tip Ncheie3 K ansam/lu=tip> Fcopie < neR ansam/lu=tip>1this7>length9 this7>v3? int l9m?
(A

for 1l<'?l=copie7>length?l@@3 ;; cautam cheia ce tre/uie stearsa if 1copie7>vLlM<<cheie3 K m<l? Rhile 1m>'3 K int parent < 1m7(3;&9 left < &Fm@(9 right < &Fm@&? copie7>vLmM<copie7>vLparentM? m<parent? Q copie7>length77? element din ansam/lu int h<'? Rhile1h=copie7>length;&3 ;; mutam radacina in pozitia corespunzatoare K int left<&Fh@(9 right<&Fh@&9 ma$Hh? tip man? if 1copie7>vLleftM>copie7>vLrightM3 ma$Hh<left? else ma$Hh<right? if 1copie7>vLhM=copie7>vLma$HhM3 K man < copie7>vLhM? copie7>vLhM<copie7>vLma$HhM? copie7>vLma$HhM<man? h<ma$Hh? Q else /reaS? Q Q return Fcopie? ;; returnam copia
(-

;; mutam radacinile in 5os in locul cheii sterse

;; se micsoreaza vectorul

copie7>vL'M<copie7>vLcopie7>lengthM? ;; punem in radacina ultimul

Q template=class tip> ansam/lu=tip> ansam/lu=tip>::operator71const ansam/lu=tip> Nans3 K ansam/lu=tip> Fcopie < neR ansam/lu=tip>1this7>length9 this7>v3? ;; apelam cealalta supraincarcare a operatorului D pentru fiecare cheie din ansam/lul primit ca parametru for 1int g<'?g=ans length?g@@3 Fcopie < copie7>operator71ans vLgM3? return Fcopie? Q int main13 K cout==:Program testare clasa ansam/leVn:? ansam/lu=int> as(9 as&9 as)? ;; declaram ) ansam/le cu care sa lucram ansam/lu=int> FpoHas(9 FpoHas&9 FpoHas)?;; mai declaram ) pointeri pentru a simplifica structurile de decizie care interpreteaza datele introduse de utilizator int opt9 opt&9 opt)9 opt*? do K relationali cout==endl? cout==:Meniu:Vn:? cout==:(3 #daugare in ansam/luVn:? cout==:&3 #fisare ansam/luVn:? cout==:)3 #tri/uire ansam/luVn:? cout==:*3 Scoatere din ansam/luVn:? cout==:+3 Testare operatori relationaliVn:? cout==:'3 IesireVn:? cout==:2ptiunea: :? cin>>opt? sRitch 1opt3 K
(.

;; stocam optiunile alese de utilizator

;; afisam un meniu din care utilizatorul poate adauga elemente in oricare dintre

ansam/le9 copia ansam/lele intre ele9 sterge elemente din ansam/le si testa operatorii

case &: cout==endl? cout==:(3 #nsam/lul (Vn:? cout==:&3 #nsam/lul &Vn:? cout==:)3 #nsam/lul )Vn:? cout==:2ptiunea: :? cin>>opt&? sRitch 1opt&3 K case (: cout==endl? if 1as( getHlength133 as( print13? else cout==:#nsam/lul are nu are elementeVn:? /reaS? case &: cout==endl? if 1as& getHlength133 as& print13? else cout==:#nsam/lul are nu are elementeVn:? /reaS? case ): cout==endl? if 1as& getHlength133 as) print13? else cout==:#nsam/lul are nu are elementeVn:? /reaS? Q /reaS? case (: cout==endl? cout==:(3 CheieVn:? cout==:&3 #nsam/luVn:? cout==:2ptiunea: :? cin>>opt&? sRitch1opt&3 K case (: int cheie?
&'

cout==endl? cout==:Introduceti cheia: :? cin>>cheie? cout==endl? cout==:Introduceti in ansam/lul:Vn:? cout==:(3 #nsam/lul (Vn:? cout==:&3 #nsam/lul &Vn:? cout==:)3 #nsam/lul )Vn:? cout==:2ptiunea: :? cin>>opt)? sRitch1opt)3 K case (: as( < as( @ cheie? /reaS? case &: as& < as& @ cheie? /reaS? case ): as) < as) @ cheie? /reaS? Q /reaS? case &: cout==endl? cout==:(3 #nsam/lul (Vn:? cout==:&3 #nsam/lul &Vn:? cout==:)3 #nsam/lul )Vn:? int oHas(9 oHas&9 oHas)? cout==:#nsam/lul: :? cin>>oHas(? cout==:Plus ansam/lul: :? cin>>oHas&? cout==:In ansam/lul: :? cin>>oHas)? sRitch 1oHas(3 K case (: poHas( < Nas(?
&(

/reaS? case &: poHas( < Nas&? /reaS? case ): poHas( < Nas)? /reaS? Q sRitch 1oHas&3 K case (: poHas& < Nas(? /reaS? case &: poHas& < Nas&? /reaS? case ): poHas& < Nas)? /reaS? Q sRitch 1oHas)3 K case (: poHas) < Nas(? /reaS? case &: poHas) < Nas&? /reaS? case ): poHas) < Nas)? /reaS? Q FpoHas) < FpoHas( @ FpoHas&? /reaS?
&&

Q /reaS? case ): cout==endl? cout==:(3 #nsam/lul (Vn:? cout==:&3 #nsam/lul &Vn:? cout==:)3 #nsam/lul )Vn:? cout==endl? cout==:#tri/uie ansam/lul: :? cin>>opt&? cout==:#nsam/lului: :? cin>>opt)? sRitch 1opt&3 K case (: poHas( < Nas(? /reaS? case &: poHas( < Nas&? /reaS? case ): poHas( < Nas)? /reaS? Q sRitch 1opt)3 K case (: poHas& < Nas(? /reaS? case &: poHas& < Nas&? /reaS? case ): poHas& < Nas)? /reaS? Q
&)

FpoHas& < FpoHas(? /reaS? case *: cout==endl? cout==:(3 CheieVn:? cout==:&3 #nsam/luVn:? cout==:2ptiunea: :? cin>>opt&? sRitch1opt&3 K case (: int cheie? cout==endl? cout==:Introduceti cheia: :? cin>>cheie? cout==:Din ansam/lul:Vn:? cout==:(3 #nsam/lul (Vn:? cout==:&3 #nsam/lul &Vn:? cout==:)3 #nsam/lul )Vn:? cout==:2ptiunea: :? cin>>opt)? sRitch1opt)3 K case (: as( < as( 7 cheie? /reaS? case &: as& < as& 7 cheie? /reaS? case ): as) < as) 7 cheie? /reaS? Q /reaS? case &: cout==endl? cout==:(3 #nsam/lul (Vn:?
&*

cout==:&3 #nsam/lul &Vn:? cout==:)3 #nsam/lul )Vn:? int oHas(9 oHas&9 oHas)? cout==:#nsam/lul: :? cin>>oHas(? cout==:Minus ansam/lul: :? cin>>oHas&? cout==:In ansam/lul: :? cin>>oHas)? sRitch 1oHas(3 K case (: poHas( < Nas(? /reaS? case &: poHas( < Nas&? /reaS? case ): poHas( < Nas)? /reaS? Q sRitch 1oHas&3 K case (: poHas& < Nas(? /reaS? case &: poHas& < Nas&? /reaS? case ): poHas& < Nas)? /reaS? Q sRitch 1oHas)3 K case (: poHas) < Nas(?
&+

/reaS? case &: poHas) < Nas&? /reaS? case ): poHas) < Nas)? /reaS? Q FpoHas) < FpoHas( 7 FpoHas&? /reaS? Q /reaS? case +: cout==endl? cout==:(3 #nsam/lul (Vn:? cout==:&3 #nsam/lul &Vn:? cout==:)3 #nsam/lul )Vn:? cout==:#nsam/lul: :? cin>>opt&? cout==:#nsam/lul: :? cin>>opt)? sRitch 1opt&3 K case (: poHas( < Nas(? /reaS? case &: poHas( < Nas&? /reaS? case ): poHas( < Nas)? /reaS? Q sRitch 1opt)3 K case (:
&,

poHas& < Nas(? /reaS? case &: poHas& < Nas&? /reaS? case ): poHas& < Nas)? /reaS? Q cout==endl? cout==:(3 6galitateVn:? cout==:&3 Mai micVn:? cout==:)3 mai mic sau egalVn:? cout==:*3 Mai mareVn:? cout==:+3 Mai mare sau egalVn:? cout==:2ptiunea: :? cin>>opt*? cout==endl? sRitch 1opt*3 K case (: cout==11FpoHas(<<FpoHas&3U:adevarat:::fals:3==endl? /reaS? case &: cout==11FpoHas(=FpoHas&3U:adevarat:::fals:3==endl? /reaS? case ): cout==11FpoHas(=<FpoHas&3U:adevarat:::fals:3==endl? /reaS? case *: cout==11FpoHas(>FpoHas&3U:adevarat:::fals:3==endl? /reaS? case +: cout==11FpoHas(><FpoHas&3U:adevarat:::fals:3==endl? /reaS?
&A

Q FpoHas& < FpoHas(? /reaS? Q Q Rhile 1optT<'3? return '? Q

&-

Screenshot

&.

Bibliografie
Curs Programare 2rientata pe 2/iecte anul I semestrul II Ga/orator Programare 2rientata pe 2/iecte anul I semestrul II Curs Structuri de Date si #lgoritmi anul I semestrul I Jer/ert Schildt WC@@ manual completX RRR cplusplus com

)'