47233482 Programare Orientata Pe Obiecte C Dascalescu Ana Cristina

5/28/2018 47233482 Programare Orientata Pe Obiecte C Dascalescu Ana Cristina

http:///reader/full/47233482-programare-orientata-pe-obiecte-c-dascalescu-ana-cr

UNIVERSITATEA TITU MAIORESCU DIN BUCURE TI

FACULTATEA DE INFORMATIC

Programarea orientatpe obiecte n limbajul C++

-suport cur s pentr u forma de nvatamnt ID -

Lector univ. drd. Dsclescu Ana Cristina

- 2010 -

1



Cuprins

Cap. 1 Introducere in programarea orientata pe obiecte ..................................................................31.2 Concepte ale programrii orientate pe obiecte.......................................................................51.3 Elemente introductive ale programrii orientate pe obiecte n limbajul C++......................7

1.4 Tipuri de date .........................................................................................................................91.5 Operatori specifici C++........................................................................................................17

Cap.2 Clase si Obiecte .................................................................................................................212.1 Definirea unei clase..............................................................................................................232.2 Constructori si destructor .....................................................................................................252.3 Tablouri de obiecte...............................................................................................................312.4 Funcii i clase friend ...........................................................................................................322.5 Funcii inline .......................................................................................................................332.6 Date si functii statice............................................................................................................34

Capitolul 3 .Mostenire....................................................................................................................413.1 Relatia de mostenire. Clase de baz si clase derivate ..........................................................41

3.2 Constructori i destructori n clasele derivate ......................................................................443.3 Controlul accesului la membrii clasei de baz .....................................................................453.4 Mostenirea multipla..............................................................................................................473.4 Clase de baz virtuale...........................................................................................................503.6 Funcii virtuale i polimorfism.............................................................................................513.7 Clase abstracte......................................................................................................................543.8 Polimorfism..........................................................................................................................56

Cap. 4 Facilitti ale limbajului C++...............................................................................................644.1 Supraincarcarea operatorilor ................................................................................................644.2 Funcii operator membre ale claselor...................................................................................644. 3 Template-uri........................................................................................................................68

4.4 Stream-uri de I/E ..................................................................................................................694.5 Funcii de I/O pentru tipurile predefinite .............................................................................69Funcii de I/O pentru tipuri definite de utilizator .......................................................................714. 6 Procesarea fisierelor ............................................................................................................72

Teste recapitulative: .......................................................................................................................76

2



Cap. 1 Introducere in programarea orientata pe obiecte

Obiective:

Conceptul programre orientata pe obiecte; Paralela ntre programarea procedural si cea orientat pe obiecte; Tipuri de date abstracte. Abstractizare; Concepte de baz ale programrii orientate pe obiecte; Scurta incursiuni n programarea orientat pe obiecte prin intermediul limbajului C++.

Modalitile (tehnicile, paradigmele) de programare au evoluat de-a lungul anilor, reflectndtrecerea de la programe de dimensiuni reduse, la programe i aplicaii de dimensiuni foarte mari,pentru coordonarea crora sunt necesare tehnici evoluate.Software-ul de dimensiuni mari, care nu poate fi realizat de o singurpersoan, intrn categoriasistemelor complexe, cu o mare diversitate de aplicaii.

Situaiile reale i experiene ale psihologilor au relevat limitele capacitii umane n percepereasistemelor complexe, adic imposibilitatea unei persoane de a percepe i controla simultan unnumr mare de entiti de informaie. De aceea, este esenial descompunerea i organizareasistemelor complexe, pentru a fi percepute, proiectate sau conduse.

Modul n care este abordat programarea, din punct de vedere al descompunerii programelor,definete mai multe tehnici de programare , care s-au dezvoltat i au evoluat odat cu evoluiasistemelor de calcul.

Programarea proceduraleste prima modalitate de programare care a fost i este ncfrecventfolosit. n programarea procedural accentul se pune pe descompunerea programului nproceduri (funcii) care sunt apelate n ordinea de desfurare a algoritmului. Limbajele caresuportaceasttehnicde programare prevd posibiliti de transfer a argumentelor ctre funciii de returnare a valorilor rezultate. Limbajul Fortran a fost primul limbaj de programareprocedural. Au urmat Algol60, Algol68, Pascal, iar C este unul din ultimele inven ii n acestdomeniu.

Programarea modular. n cursul evoluiei programrii procedurale, accentul n proiectareaprogramelor s-a deplasat de la proiectarea procedurilor ctre organizarea datelor, aceastdeplasare reflectnd creterea dimensiunilor programelor. O mulime de proceduri corelate,mpreuncu datele pe care le manevreaz, sunt organizate ca un modul. Tehnica de programaremodulardecide descompunerea unui program n module, care ncorporeazo parte din dateleprogramului i funciile care le manevreaz. Aceast tehnic este cunoscut ca tehnic deascundere a datelor (data-hiding). n programarea modular stilul de programare este n

3



continuare procedural, iar datele i procedurile sunt grupate n module, existnd posibilitatea deascundere a unor informaii definite ntr-un modul, fade celelalte module. Gruparea de date iproceduri n module nu implici o asociere strictntre acestea.

Programarea orientat pe obiecte apeleaza la o modalitate nou de gndire a unei probleme.

Spre deosebire de programarea procedural care se concentreaz pe structuri de date si algoritmi,programarea orientat pe obiecte se concentreaz pe definirea de obiecte care modeleazproblema ce trebuie rezolvat.n programarea orientat pe obiecte (POO) un program are rolul de a simula strile si activittileobiectelor lumii reale. Pe lng structuri de date (care descriu strile obiectelor, atributeleacestora) trebuie incluse si metodele asociate obiectelor, adic acele functii care modificatributele obiectelor si care descriu comportamentul lor.

1.1 Abstractizarea datelor. Tipuri de date abstracte

Primul pas pe care il facem cand scriem un program care sa realizeze diferite operatii, este sa

gasim un model care simplifica realitatea, prin separearea detaliilor care interreseaza, de cele carenu afecteaza problema pe care o rezolvam asfel, datele cu care se lucreaza, operatiile , tin despecificul fiecarei probleme tratate.Acest proces de grupare a datelor si metodelor de prelucrare specifice rezolvarii unei probleme senumeste abstractizare.

n cazul dezvoltrii unui produs software, abstractizarea se poate defini ca fiind o structurare aunei probleme n entitti bine precizate prin definirea datelor si a operatiilor asociate. Acesteentitti combin date si operatii care sunt necuplate ntre ele. Procedurile si functiile au fostprimele dou mecanisme de abstractizare larg rspndite n limbajele de programare.

Procedura a reprezentat si prima modalitate de ascundere a informatiei (interfata cu procedura).Modulele au reprezentat urmtorul mecanism de abstractizare prin gruparea procedurilor sifunctiilor ce sunt relationate. n continuare, tipurile de date abstracte au realizat un pas importantctre dezvoltarea unui software de calitate si au permis trecerea la abordarea orientat pe obiectea problemelor.

Un tip de date abstract (TDA)const dintr-o structur de date abstract si o multime de operatii.Interfata unui TDA este definit de multimea de operatii si reprezint acea portiune a unui TDAcare este vizibil din exterior. Conceptul de tip de date abstract presupune existenta unuimecanism de separare a specificatiei de implementare. Aceasta nseamn c un utilizator al unuiTDA trebuie s cunoasc doar modul de utilizare al

tipului de date, nu si detaliile de implementare.Un tip de date abstract (TDA) este caracterizat de urmtoarele proprietti:1. export un tip;2. export o multime de operatii (furniznd interfata TDA);3. singurul mecanism de acces la structura de date a tipului este furnizat de operatiile definite ninterfat;4. axiomele si preconditiile definesc domeniul deaplicatie al tipului.

4



De exemplu, dorim sa construim TDA persona. Sa presupunem ca realizam o aplicatie necesarapentru realizarea recesamnatului populatiei, atunci datele care interseaza pentru tipul persoanasunt : nume, prenume, loc_nastere, adresa etc. Daca aplicatia presupune, in schimb, gestiuneaintretinerii pentru o asociatie de locatari, atunci pentru tipul persoana sunt necesare si date cum arfi : spatiul_locuit, nr_persoane etc.

Deci, prin procesul de abstarctizare, separam datele care intereseaza de cele care nu fac obiectulaplicatiei. Construim, ulterior, un tip abstract de date care inglobeaza o structura de dateimpreuna ca operatii aupra datelor ( ex: calculul intretinerii pentru o persoana, nr_persoane pefiecare judet etc.).

Exemplu: TDA_personanume structura de dateprenumespatiu_locuit

calcul intretinere; - operatii asupra datelor

Programarea orientat pe obiecte este programarea cu tipuri de date abstracte, care combinfunctionalittile acestora pentru rezolvarea problemelor. n programarea orientat pe obiecte,TDA-urile sunt numite clase.

1.2 Concepte ale programrii orientate pe obiecte

Conceptele programrii orientate pe obiecte au aprut din dezvoltrile realizate n cadrullimbajelor moderne de programare. Astfel, limbajele orientate pe obiecte au noi structuri carembunttesc ntretinerea programului si fac ca portiuni mari de program s fie reutilizabile,conducnd astfel la scderea costului de dezvoltare a produselor software.

Cele sase concepte de baz ce caracterizeaz programarea orientat pe obiecte sunt : Obiectele; Clasele; Mesajele Incapsularea; Mostenirea Polimorfismul.

Obiectele

Un obiect poate fi considerat ca fiind o entitate care ncorporeaz att structuri de date (denumite

atribute) ct si comportament (actiuni). Obiectele sunt inteligente prin faptul c realizeazanumite actiuni si stiu cum s execute aceste actiuni. Inteligenta unui obiect reprezint o formde abstractizare prin faptul c presupune c un obiect poate executa o actiune si ascunde detaliilereferitoare la modul n care se va realiza efectiv actiunea. Obiectele pot fi de tipuri diferite:entitti fizice, algoritmi, relatii sau subsisteme. Practic, obiectele sunt componente de softwarereutilizabil care modeleaz elemente din lumea real.

Pentru tipul de date abstractpersoanadefinit mai sus un exemplu de obiect poate fi definit astfel :

5



Popescu Ion, 34, 56 m2.

Clasele

Clasele desemneazo colecie de obiecte (de naturmaterialsau spiritual) care au n comun

faptul cpot fi caracterizate similardin punct de vedere informaional i comportamental.

Este evident faptul cidentificarea unei clase este n mod normal, rezultatul unui demers cognitivcare presupune caracterizarea unui obiect prin nsuirile lui (informaionale i comportamentale)care i definesc apartenena la o anumit clas de obiecte. Aadar, conceptul de clas adunlaolaltdatele i metodele de prelucrare a acestora.

O clasa reprezinta de fapt o implemntare a tipului abstract de date. O declarare a unei clasedefinete un tip nou care reunete date i funcii. Acest tip nou poate fi folosit pentru a declaraobiecte de acest tip, deci un obiect este un exemplar (o instan) a unei clase.

Mesajele

Obiectele pot comunica ntre ele prin intermediul mesajelor. Trimiterea unui mesaj care cere unuiobiect s aplice o anumit actiune numit metod este similar apelului de procedur dinlimbajele de programare procedural. n programarea orientat pe obiecte se consider cobiectele sunt autonome si pot comunica ntre ele prin interschimb de mesaje. Obiectelereactioneaz atunci cnd primesc mesaje, aplicnd o anumit metod, de exemplu. Ele pot refuzaexecutarea metodei respective dac, de exemplu, obiectului care este apelat nu i se permite sexecute metoda cerut.

Un mesaj este o cerere adresat unui obiect pentru a invoca una din metodele sale. Astfel, un

mesaj contine numele metodei si argumentele metodei.

Exemplul : calculul intretinerii pentru obiectul Popescu Ion.

Incapsularea

nelegerea acestui principiu presupune dounivele de abordare.

Ca metodde concepie, ncapsularea se referla capacitatea de a separa aspectele externe aleunui obiect (interfaa), accesibile altor obiecte, de aspectele implementaionale, interneobiectului, care sunt ascunse fade celelalte obiecte. Utilizatorul unui obiect poate accesa doaranumite metode ale acestuia, numite publice, n timp ce atributele i celelalte metode i rmninaccesibile (acestea se numesc private).ncapsularea este foarte important atunci cnd dorim s schimbm implementarea anumitormetode (cu scopul de a optimiza un algoritm sau de a elimina posibile erori).ncapsularea ne va mpiedica s modificm toate caracteristicile obiectului iar aplicaiile careutilizeaz obiectul nu vor avea de suferit deoarece protocolul de comunicaie al obiectuluimotenit de la interfaa clasei (rezultatul ncapsulrii ca metodde concepie) nu s-a schimbat.

6



Ca implementare, la nivelul unui limbaj de programare, ncapsularea este asigurat deexigenele sintactice specifice.

Mostenirea

Mecanismul derivarii permite crearea facila de noi clasa, care preiau caracteristicile unor clase debaza, deja definite. Derivarea are ca obiectiv reutilizarea soft-ului, prin folosirea uneor functiideja scrise pentru clasele existente si eliminarea redundantei descrierilor, in cazul claselor care auelemente comune, functii sau date. Acest concept este prezentat in detaliu in moulul 3.

Polimorfismul

Termenul polimorfism se refer la comportamente alternative ntre clase derivate nrudite. ncazul n care mai multe clase mostenesc atributele si comportamentele unei clase de baz, potapare situatii n care comportamentul unei clase derivate ar trebui s fie diferit de cel al clasei debaz sau de cel al clasei derivate de tip frate (de pe acelasi nivel). Aceasta nseamn c un mesaj

poate avea efecte diferite n functie de clasa obiectului care primeste mesajul.De exemplu sa considerm trei clase: clasa de baz Fisier si clasele derivate FisierASCII siFisierBitmap care mostenesc toate atributele si comportamentele clasei Fisier cu exceptiacomportamentului Tiprire.Un mesaj care va activa comportamentul Tiprire al unui obiect al clasei Fisier poate determinaafisarea atributelor mrime fisier, tip fisier si data/ora crerii/ultimei modificri a fisierului.Acelasi mesaj trimis unui obiect al clasei FisierASCII va determina afisarea textului din fisier, ntimp ce dac va fi trimis unui obiect al clasei FisierBitmap va determina executia unui programde afisare grafic.

1.3 Elemente introductive ale programrii orientate pe obiecte nlimbajul C++

Limbajul C++ este unul dintre cele mai utilizate limbaje de programare orientate pe obiecte;compilatoare, biblioteci i instrumente de dezvoltare a programelor C++ sunt disponibile attpentru calculatoare personale ct i pentru cele mai dezvoltate sisteme i staii de lucru.

Limbajul C++ este o versiune extinsa limbajului C elaborata de ctre B. Stroustrup n anul 1980n laboratoarele Bell din Murray Hill, New Jersey. Extensiile dezvoltate de Stroustrup pentrulimbajul C++ permit programarea orientat pe obiecte, pstrnd eficiena, flexibilitatea iconcepia de baz a limbajului C. Numele iniial a fost C cu clase, numele de C++ fiindu-i

atribuit n anul 1983.

Scopul pentru care a fost creat C++ este acelai cu scopul pentru care este abordat n generalprogramarea orientat pe obiecte: dezvoltarea i administrarea programelor foarte mari. Chiardacsuperioritatea limbajului C++ este evidentn cazul dezvoltrii programelor foarte mari, nuexist limitri n a fi folosit n orice fel de aplica ie, deoarece C++ este un limbaj tot att deeficient ca i limbajul C.

7



De la apariia sa, C++ a trecut prin trei revizii, n 1985, 1989 i ultima, prilejuitde definireastandardului ANSI pentru acest limbaj. O primversiune a standardului a fost publicatn anul1994, iar urmtoarea versiune este ncn lucru.n general, limbajul C++ prevede mai multe faciliti i mai puine restricii dect limbajul C,astfel nct majoritatea construciilor din C sunt legale i au aceeai semnificaie i n C++.

n acest capitol sunt prezentate unitar i concis conceptele de bazn programarea C++, att celecare sunt preluate din limbajul C ct i cele nou introduse. Multe dintre ele sunt reluate idezvoltate pe parcursul seciunilor urmtoare.

Operatii de intrare/iesire. Stream-uri

Cel mai scurt program C++ este:

main(){ }

Acesta definete o funcie numitmain (), care nu primete nici un argument, nu executnimic inu returneaznici o valoare.

Dacse dorete ca programul sscrie un mesaj la consol(de tipul Primul program in C++!), pelngutilizarea funciei obinuite din limbajul C (funcia printf()), n C++ se poate utiliza i ofuncie de scriere la ieirea standard (cout). Aceast funcie este funcia operator de scriere > i;

Desigur, funcia scanf() de citire de la tastaturdin limbajul C poate fi n continuare folosit, darpe parcursul exemplificrilor se vor folosi mai mult aceste funcii C++ de citire i de scriere la

consol.

Programul P1.1 prezint un exemplu de utilizare a operatiilor de intrare/iesire n limbajul C++.

// fisierul sursa P1_1.cpp#include void main(){

8



int a, b;float m;cout > a;cout > b;

m = (float) (a+b)/2;cout > b;m = (float) (a+b)/2;cout var_1 >> var_2 >> >> var_n;

Se citesc de la dispozitivul de intrare valorile variabilelor var_1, var_2, , var_n.

Sintaxa operatiei de iesire (scriere, afisare):

cout



short int 2 octeiint 2 sau 4 octeilong 4 sau 8 octei

Tipuri de numere flotante, pentru definirea numerelor reale (reprezentate ca numere cu

virgulflotant):float 4 octeidouble 8 octeilong double 12 sau 16 octei

Aceste tipuri sunt denumite mpreun tipuri aritmetice. Pentru tipurile ntreg, existvariante de declaraie cu semn (signed) i frsemn (unsigned).

Tipul caracter, pentru definirea caracterelorchar 1 octet

Tipul void specifico mulime vidde valori. Nu se poate declara un obiect cu acest tip,

dar acest tip poate fi utilizat n conversii de pointeri i ca tip de returnare al unei funciiPe langa tipurile de date fundamentale enumerate, se pot defini conceptual un numr infinit detipuri derivate pornind de la tipurile fundamentale. Tipurile derivate sunt:

tablouri de obiecte, pointeri la obiecte, referine, funcii, constante simbolice, clase, structuri, uniuni,

pointeri la membrii claselor.n continuare se vor prezenta primele cinci tipuri derivate, iar celelate vor fi introduse peparcursul seciuniunilor urmtoare. Ca terminologie, clasele (mpreuncu structurile i uniunile)sunt denumite tipuri definite de utilizator (user-defined types), iar celelate tipuri sunt denumitetipuri predefinite (built-in types).

Tablouri de obiecte

Un tablou (array) de obiecte poate fi construit din obiecte dintr-un tip fundamental (cu excep iatipului void), din pointeri, din enumeraii sau din alte tablouri. n traducere, pentru array se maintlnesc termenii vector i matrice. n acest text sunt folosii termenii tablou (pentru arraymultidimensional) i vector (pentru array unidimensional).

Declaraia: T D[expresie]introduce un tablou de obiecte de tipul T, cu numele D i cu un numrde elemente al tabloului dat de valoarea expresiei, care trebuie sfie de tip constant ntreg. Pentruvaloarea N a acestei expresii, tabloul are N elemente, numerotate de la 0 la N-1.

Un tablou bidimensional se poate construi printr-o declaraie de forma:

10



11

T D[dim1][dim2];

i reprezint dim1 tablouri unidimensionale, fiecare de dimensiune dim2. Elementele tablouluibidimensional se memoreazcu valori succesive pentru indicele din dreapta astfel:

D[0][0], D[0][1], D[0][dim2-1],

D[1][0], D[1][1], D[1][dim2-1],.D[dim1-1][0], D[dim1-1][1], D[dim1-1][dim2-1].

ntr-un mod asemntor se pot construi tablouri multidimensionale, cu o limitare a numrului dedimensiuni care depinde de implementare.

Pointeri

Pentru majoritatea tipurilor T, T* este un tip denumit pointer la T, adico variabilde tipul T*memoreazadresa unui obiect de tipul T.

Operaia fundamentalasupra unui pointer este operaia de derefereniere (dereferencing), adicaccesarea obiectului a crui adreso reprezintpointerul respectiv. Operatorul de derefereniereeste operatorul unar*.De exemplu:

char c1 = a; // variabila c1char* p1 = &c1; // p memoreazadresa lui c1char c2 = *p1; // dereferentiere, c2 = a;

Operatorul &este operatorul adres, care se utilizeazpentru a obine adresa unei variabile.Tipul void* este folosit pentru a indica adresa unui obiect de tip necunoscut.

Asupra pointerilor sunt admise unele operaii aritmetice. De exemplu, se considerun vector decaractere dintre care ultimul este caracterul 0 (se mai numete ir de caractere terminat cu nul).

Pentru calculul numrului de caractere se pot folosi operaii cu pointeri astfel:int strlen(char* p){int i = 0;while (*p++) i++;return i;}

Funcia strlen() returneaz numrul de caractere ale irului, fr caracterul terminal 0, folosindoperaia de incrementare a pointerului i operaia de derefereniere pentru a testa valoareacaracterului. O altimplementare posibila funciei este urmtoarea:

int strlen(char* p){char* q = p;

while (*q++);return q-p-1;}

n C++, ca i n limbajul C, pointerii i tablourile sunt puternic corelate. Un nume al unui tabloupoate fi folosit ca un pointer la primul element al tabloului. De exemplu, se poate scrie:

char alpha[] = abcdef;



char* p = alpha;char* q = &alpha[0]; // p = q

Rezultatul aplicrii operatorilor aritmetici +, -, ++, -- asupra pointerilor depinde de tipulobiectului indicat. Atunci cnd se aplic un operator aritmetic unui pointer p de tip T*, seconsider c p indic un element al unui tablou de obiecte de tip T; p+1 va indica urmtorulelement al tabloului, iar p-1 va indica elementul precedent al tabloului. Acest lucru nseamncvaloarea lui p+1 este cu sizeof(T) octei mai mare dect valoarea lui p.

Referine

O referin(reference) este un nume alternativ al unui obiect. Utilizarea principala referinelorse face pentru specificarea argumentelor i a valorilor returnate de funcii, n general, i pentrusuprancrcarea operatorilor n special. Notaia X& nseamnreferinla un obiect de tipul X. Deexemplu:

int i = 1;int& r = i; // r i i se referla aceeai entitate

int x = r; // x = 1r++; // i = 2;

Implementarea obinuita unei referine se face printr-un pointer constant care este derefereniatde fiecare datcnd este utilizat.

Aa cum se poate observa, pentru definirea unei referine se folosete operatorul adres&, dardifertipul construciei n care este folosit. De exemplu:

int a = 5;int* pi = &a; // & calculeazadresa;

// pi este adresa lui aint& r = a; // & introduce o referinta;// r este o referin(alt nume) pt. a

O referineste utilizatca argument pentru o funcie care poate smodifice valoarea acestuiargument. De exemplu:

void incr(int& x) {x++;}void f(){int i = 1;incr(i); // i = 2;}

O altutilizare importanta referinelor este pentru definirea funciilor care pot fi folosite att camembru drept ct i ca membru stng al unei expresii de asignare. De exemplu:

#include int& fr(int v[], int i){return v[i];}void main(){

12



int x[] = {1,2,3,4};fr(x,2) = 7;cout



ilegale. Spre deosebire de limbajul C, unde este admisi simpla declaraie a numelui funciei(frtipurile argumentelor de apel), utilizarea prototipurilor este obligatorie n C++. De exemplu:

double f2(int, double); // prototip functie f2double f3(int a, double f){ // definitie functie f3/*..*/double t = f/a;return t;}void fp(){double r1 = f1(7, 8.9); // eroare,// identificator nedeclaratdouble r2 = f2(7, 8.9); // corect, fol. prototipulchar str[] = "abcde";double r3 = f3(7, str); // eroare de tip argument}double f1(int a, double f) {

/*..*/double t = a + f;return t;}double f2(int a, double f) { // definiie funcie f2()/*...*/double t = a*f;return t;}

La compilare apare o eroare datorit apelului funciei f1(), care nu este definit, nici declaratprin prototip n domeniul funciei apelante fp() i o eroare datoratapelului funciei f3() cu un

argument (argumentul al doilea) care nu poate fi convertit la tipul argumentului formal.

Transferul argumentelor funciilor. La apelul unei funcii, argumentele de apel (se mai numesc iargumente reale sau efective) iniializeaz argumentele formaledin declaraia funciei, n ordinea din declaraie. Argumentele unei funcii se pot transfera n doumoduri: apelul prin valoare i apelul prin referin.

n apelul prin valoare se copiazvaloarea argumentului real n argumentul formal corespunztoral funciei. n acest caz, modificrile efectuate asupra argumentului funciei nu modificargumentul real.

n apelul prin referineste accesatdirect variabila din argumentul real transmis funciei, carepoate fi deci modificat. Ca exemplificare, se definete o funcie swap() care realizeazintershimbul ntre valorile a douvariabile. Dacnu se folosesc referine, argumentele de apel alefunciei trebuie sfie pointeri la variabilele respective. Pointerii, ca argumente de apel, nu vor fimodificai, dar variabilele indicate de acetia pot fi modificate. Funcia swap() cu argumentepointeri aratastfel:

void swap(int* x, int* y){int t;

14



t = *x; // dereferentiere*x = *y;*y = t;}

Aceeai funcie swap(), folosind argumente de tip referin, aratastfel:void swap(int& x, int& y){int t;t = x;x = y;y = t;}

Se poate observa perfecta simetrie ntre cele dou implementri i c, n mod evident, referinafolosete adresa variabilei pentru a o putea modifica (deci un pointer). Dar, n cazul referin elor,pointerul i defererenierea sunt ascunse, programatorul nu trebuie s le prevad explicit,programul rezultat este mai concis i mai clar.

Referinele sunt deosebit de utile n apelul funciilor ale cror argumente sunt obiecte dedimensiuni mari i copierea lor n argumentele formale (plasate n segmentul de stiv alprogramului) ar fi foarte ineficient.

Argumente implicite ale funciilor. Se ntmplfrecvent ca o funcie saibun numr mai marede argumente dect sunt necesare n cazurile simple dar frecvente de apel. Dacnu este necesarsfie transmisntotdeauna valoarea reala unui argument i acesta poate lua, de cele mai multeori, o valoare implicit, atunci n declaraia funciei se prevede o expresie de iniializare a acestuiargument, iar din apel poate slipseascvaloarea argumentului corespunztor.

De exemplu, o funcie pentru stabilirea datei calendaristice, care prevede valori implicite pentru

argumentelelunaian:

struct data{int zi;int luna;int an;} g_data;

void setdata(int zi, int luna=9, int an =1999){g_data.zi = zi;g_data.luna = luna;g_data.an = an;}

void main(){setdata(15); // 15 9 1999setdata(21,7); // 21 7 1999setdata(20,1,2000); // 21 1 2000}

Numai argumentele de la sfritul listei pot fi argumente implicite. De exemplu, este eronaturmtoarea declaraie:

15



void setdata(int zi, int luna=9, int an); // eroare

Constante simbolice

O constant simbolic (sau constant cu nume) este un nume a crui valoare nu poate fimodificatn cursul programului. n C++ existtrei modaliti de a defini constante simbolice:

Orice valoare, de orice tip care poate primi un nume, poate fi folosit ca o constantsimbolicprin adugarea cuvntului-cheie const n declaraia acesteia.

Orice nume de funcie sau de tablou este o constantsimbolic. O enumeraie definete o mulime de constante ntregi.

De exemplu, urmtoarele declaraii introduc constante simbolice prin folosirea cuvntului-cheieconst:

const int val = 100;

const double d[] = {1.2, 2.8, 9.5};

Deoarece constantele nu pot fi modificate, ele trebuie sfie iniializate n declaraie. ncercareade modificare ulterioareste detectatca eroare n timpul compilrii:

val++; // eroared = 200; // eroare

Cuvntul-cheie const modific tipul obiectului, restricionnd modul n care acesta poate fifolosit.

Un aspect interesant i intens folosit n programare, este acela de a declara pointeri la constante.Atunci cnd se folosete un pointer, sunt implicate douobiecte: pointerul nsui i obiectul ctrecare indicpointerul.

Prin prefixarea declaraiei unui pointer cu cuvntul const, obiectul indicat este fcut constant, nupointerul nsui. De exemplu:

const char* pc = abcd;// pc este pointer la o constantpc[2] = m; // eroare, nu se poate modifica// obiectul constant

pc = ghij; // corect, este modificat// valoarea pointerului

pc++; // corectPentru ca pointerul nsui sfie constant, se folosete operatorul *const:char *const cp = abcd;// cp este pointer constant;cp[2] = m; // corect, modifica valoareacp++; // eroare, pointer constant

16



Posibilitatea de declarare a pointerilor la constante este folosit n special pentru transmitereaargumentelor funciilor. Prin declararea unui argument de tip pointer la constant, este interzismodificarea de ctre funcie a obiectului indicat. De exemplu:

char* strcpy(char* d, const char* s);

n aceastfuncie irul s nu poate fi modificat.

n mod asemntor, specificatorul const care nsoete un argument tip referin la apelul uneifuncii, mpiedicmodificarea acestuia de ctre funcia respectiv.

1.5 Operatori specifici C++

Majoritatea operatorilor C++ sunt preluai din limbajul C, cu aceeai sintaxi reguli de operare.n plus fade operatorii C, n C++ mai sunt introdui urmtorii operatori:

operatorul de rezoluie (::)

operatorii de alocare-eliberare dinamica memoriei new i delete.

Operatorul de rezoluie

Operatorul de rezoluie (::) este folosit pentru modificarea domeniului de vizibilitate al unuinume. Pentru acest operator (scope resolution operator), n traduceri se mai ntlnesc termenii deoperator de domeniu sau operator de acces. Operatorul de rezoluie permite folosirea unuiidentificator ntr-un bloc n care el nu este vizibil. Dacoperatorul de rezoluie nu este precedatde nici un nume de clas, atunci este accesat numele global care urmeaz acestui operator. Deexemplu:

int g = 10;

int f(){int g = 20;//return ::g;}void main(){cout



18

Pentru alocarea unei singure date (obiect), operatorul new are urmtoarea formgeneral:

tip_data* p = new tip_data(initializare);unde tip_data este un tip de date predefinit sau definit de utilizator (clas), p este pointerul

(adresa de nceput) a zonei alocate n memoria liber, returnat la execuia operatorului new, iarinitializare este o expresie care depinde de tipul datei i permite iniializarea zonei de memoriealocate. Dacalocarea nu este posibil, pointerul returnat este NULL.

Forma de utilizare a operatorului new pentru alocarea unui vector de date (tablou unidimensional)de dimensiune dim, este urmtoarea:

tip_data* p = new tip_data[dim];

La alocarea unui vector nu se poate transmite o expresie de iniializare a zonei de memoriealocat.Operatorul delete elibereazo zondin memoria heap. El poate avea una din urmtoarele forme:

delete p; delete []p;Prima form se utilizeaz pentru eliberarea unei zone de memorie ocupat de o singur dat(obiect), nu de un vector. Pointerul p trebuie s fie un pointer la o zon de memorie alocatanterior printr-un operator new. Operatorul delete trebuie sfie folosit doar cu un pointer valid,alocat numai cu new i care nu a fost modificat sau nu a mai fost eliberatzona de memorie mainainte (cu un alt operator delete sau prin apelul unei func ii free()). Folosirea operatorului deletecu un pointer invalid este o operaie cu rezultat nedefinit, cel mai adesea producnd erori deexecuie grave.

Cea de-a doua forma operatorului delete[] se folosete pentru eliberarea unei zone de memorieocupatde un vector de date. Pentru tipurile de date predefinite ale limbajului, se poate folosi i

prima formpentru eliberarea unui vector, dar, n cazul obiectelor de tipuri definite de utilizator,acest lucru nu mai este valabil. Aceastsituaie va fi detaliatn seciunea urmtoare.Cteva exemple de utilizare a operatorilor new i delete:

int *pi = new int(3); // alocare int i iniializare

double *pd = new double; // alocare double neinitializat

char *pc1 = new char[12]; // vector de 12 caractere

char *pc2 = new char[20]; // vector de 20 caractere

delete pi;

deletepd

delete pc1; //corect, char e tip predefinit

delete []pc2; // corect, elibereaza vector

n legturcu cele doumetode de alocare dinamic, prin operatorii new-delete i prin funciilede bibliotec malloc-free, fr s fie o regul precis, se recomand evitarea combinrii lor,deoarece nu existgarania compatibilitii ntre ele.



Teste de autocontrol

1.1 Care din afirmatiile urmtoare sunt adevrate si care sunt

false? Justificati rspunsul n cazul afirmatiilor care sunt false.(a) Toate variabilele trebuie declarate nainte de a fi utilizate.(b) Un program C++ care afiseaz trei linii pe ecran trebuie scontin 3 instructiuni de afisare cout.(c) Comentariile dintr-un program C++ determin afisareatextului aflat dup // pe ecran la executia programului.(d) n limbajul C++ toate variabilele locale trebuie declarate lanceputul functiei de care apartin.

1.2 Descriei pe scurt diferena dintre funciile care returneaz valoare i cele care returneazreferin.

1.3 Presupunnd c variabilele a si b au valorile 3, respectiv 4, s se precizeze ce anume se vaafisa pe ecran ca urmare a executiei urmtoarelor instructiuni:

(a) cout b;(e) // cout



(d) ncapsulare(e) modul(f) procedur(g) polimorfism(h) stream

(i) cout1.12 Definiti tipul de date abstract (TDA).

1.13 Definiti urmtoarele tipuri de date abstracte:(a) LISTA (b) COADA

Se vor specifica: structura de date, operatorii de baz si cei suplimentari si axiomele n modsimilar cu definitia TDA STIVA.

1.14 Sse scrie declaraiile pentru urmtoarele tipuri de variabile: pointer la un caracter, unvector de 10 valori ntregi, pointer la un vector de 10 valori ntregi, un pointer la un pointer la uncaracter.

1. 15 Sse scrie un program care tiprete dimensiunea tipurilor fundamentale de date. Se vafolosi operatorul sizeof.

20



Cap.2 Clase si Obiecte

Obiective

Definirea notiunilor de clas, obiect, atribut, metod; ntelegerea notiunilor de instant, instantiere, constructor, destructor; nsusirea modului n care se realizeaz accesarea membrilor unei clase; Definirea constructorilor unei clase (implicit, cu parametri, de copiere, de convertire siatribuire); Definirea destructorului unei clase; Definirea si utilizarea claselor compuse si a obiectelor compuse;

Pointerului this; Particularitti ale limbajului C++ (functii friend, functii inline, membrii statici, tablouride obiecte, pointeri la metode)

Un tip de date ntr-un limbaj de programare este o reprezentare a unui concept. De exemplu, tipulfloat din C++, mpreuncu operaiile definite asupra acestuia (+, -, *, etc.) reprezinto versiune aconceptului matematic de numere reale. Pentru alte concepte, care nu au o reprezentare directprin tipurile predefinite ale limbajului, se pot defini noi tipuri de date care s specifice acesteconcepte.

O claseste un tip de date definit de utilizator. O declarare a unei clase definete un tip nou carereunete date i funcii. Acest tip nou poate fi folosit pentru a declara obiecte de acest tip, deci unobiect este un exemplar (o instan) a unei clase.

Definitie. O clas este implementarea unui TDA. Ea defineste atribute si metode careimplementeaz structuri de date si operatii ale TDA-ului.

Definitie. Un obiecteste o instant a unei clase. El este unic identificat de numele lui si definesteo stare care este reprezentat de valorile atributelor, la un moment dat. Starea unui obiect seschimb n raport cu metodele care i sunt aplicate.

Definitie. Comportamentul unui obiect este definit de multimea metodelor care i pot fiaplicate.

Definitie. O metod este o functie asociat unei clase. Un obiect apeleaz (invoc) o metoddrept reactie la primirea unui mesaj.

21



Primul pas pentru gruparea datelor si metodelor de prelucrare, l-au reprezentat stucturile; elepermiteau declararea unor ansambluri eterogene de date ce erau manipulate unitar.

Consideram structura angajatcare curinde urmatoarele date: nume, varsta, salariul.

struct angajat{char nume[20];int varsta;float salariul;

}

Declaratii de variabile:angajat a1; // o structura de tip angajat p1angajat tablouangajat[10]; //un tablou cu zece elemente de tip angajatangajat *a2; // un pointer catre o structura de tip angajat a2angajat&a3=a1; // o referinta catre o structura de tip angajat a3

Membrii unei structuri sau ai unei clase sunt accesati cu ajutorul operatorilor de acces: operatorul., respectiv, operatorul ->. Operatorul . acceseaz o structur sau un membru al unei clase prin numele variabilei

pentru obiect sau printr-o referint la obiect. Operatorul -> acceseaz un membru al unei structuri sau clase printr-un pointer la

obiect (a2 = &a1)

Programul P2.1 implementeaz tipul de date angajat cu ajutorul unei unei structuri C. Functiaafisare( )are rolul de a afisa datele unui angajat. Programul realizeaz constructia tipului de dataabstract angajat prinn definirea unei structuri , setarea valorilor pentru cmpurile structurilor(membrii structurilor) si afisarea acestora.

// fisierul sursa P2_1.c#include #include #include

// definitia structurii angajatstruct angajat {char num[20];int varsta;

float salariul;} a1 = {"Pop", 28,1530};

// definitia functiei de afisare a datelor unei angajatvoid afisare(struct angajat a){

printf("\n Nume \t Varsta \t Salariul");printf("%s\t%i\t%d",a.nume,a.varsta,a.salariul);}void main()

22



{struct angajat a2;strcpy(a2.nume, "Ion");a2.varsta = a1.varsta; a2.salariul = 1600;

printf("\n Angajat nr 1 \n");afisare(a1);

printf("\n Angajat nr 2 \n");afisare(a2);getch();}

2.1 Definirea unei clase

Clasele permit programatorului s modeleze obiectele care au atribute (reprezentate de datelemembru) si comportament (reprezentat de functiile membru, numite si metode). Practic, o clasncapsuleaz o multime de valori si o multime de operatii.Sintaxa definirii unei clase:

class {

private:// membrii privati

public:// membrii publici

protected:// membrii protejati};

Cuvntul-cheie class introduce declaraia clasei (a tipului de date) cu numele nume_clasa. Daceste urmatde corpul clasei (cuprins ntre acolade), aceast declaraie este totodato definiie.Dacdeclaraia conine numai cuvntul-cheie classi numele clasei, atunci aceasta este doar odeclaraie de nume de clas.Corpul clasei conine definiii de date membre ale clasei i definiii sau declaraii de funciimembre ale clasei, desprite printr-unul sau mai muli specificatori de acces. Unspecificator_acces poate fi unul din cuvintele-cheie din C++:

public private protected

Specificatoriiprivateiprotectedasiguro protecie de acces la datele sau funciile membre aleclasei respective, iar specificatorul public permite accesul la acestea i din afara clasei. Efectulunui specificator de acces dureazpn la urmtorul specificator de acces. Implicit, dacnu sedeclarnici un specificator de acces, datele sau funciile membre sunt de tip private. De aceea,toate datele sau funciile declarate de la nceputul blocului clasei pnla primul specificator deacces sunt de tip private. ntr-o declaraie de classe poate schimba specificatorul de acces ori decte ori se dorete: unele declaraii sunt trecute public, dup care se poate reveni la declaraiiprivate, etc. Diferena ntre tipurile de acces private i protected const n modul n care suntmotenite drepturile de acces n clase derivate.

23



Definirea obiectelor

Dup definirea unei clase C, aceasta poate fi utilizat ca tip n definirea obiectelor, tablourilor deobiecte si a pointerilor, astfel:

C o1, // obiect de tip CC Tablou[20], // tablou de obiecte de tip CC *ptrC, // pointer la un obiect de tip CC &tC = o1; // referinta la un obiect de tip C

Numele unei clase devine specificator de tip si se pot defini, teoretic, o infinitate de obiecte aleclasei.

Accesarea membrilor unei clase

Membrii publici ai unei clase pot fi accesati cu ajutorul operatorilor . si ->, dup cum

obiectul de care apartin este desemnat prin nume sau printr-un pointer. Variabilele membruprivate nu pot fi accesate dect n cadrul metodelor clasei respective.

Programul 2.2 implementeaz tipul de date angajat sub forma unei clase C++. Clasa angajatcuprinde datele membre: varsta, salariul, nume si functii membre: init() pentru initializareadatelor membre, functiia membra de acces spune_varsta(), functia afisare() pentru afisareadatelor membre.

class angajat{

private:

int varsta;protectedfloat salariul;

public:char nume[20];void init ( char n[]=Anonim, int v=0, float s=0)

{strcpy(nume,n);varsta=v;salariul=s;

}int spune_varsta() { return varsta};void afisare()

{cout



cout



angajat(char *n, int v, float s)

{strcpy(nume,n);varsta=v;salariul=s;}char *spune_nume(){return nume;}int spune_varsta(){return varsta;}}

Se observa ca in clasa angajats-au definit doi constructori:- unul care nu are nici un parametru, angajat() care intilaizaza datele membre cu

valori constante; constructorul fara parametrii se numeste constructor impicit;- al doilea constructor primeste trei parametri si are ca scop initializarea datelor

membre din variabile elemntare; un asfel de constructor se numeste constructor cuargumente.

-Constructorii definiti mai sus se pot apela asfel:

angajat a1 // aplelulconstructorului implicitangajat a2(Pop,28,1200) //apelul constructorului cu argumente.

Daca clasa nu mentioneaza nici un constructor, atunci se defineste automat de catre compilatorun constructor care este utilizat pentru generarea de obiecte ale casei respective.

In multe aplicatii este recomandat ca o clasa sa mentoineze mai multi constructori deoarecemodurile de intializare a datelor membre sun diverse:

- initializarea membrilor cu constante;- intializarea din datele elementare;- initializarea prin citire de la tastatura;- initializarea prin citire din fisier;- initializarea din datele unui obiect existent.

Observatie. Pentru un obiect este selectat un singur constructor care este apleat o singura data.

Programul 2.2 impementeaza clasa Complexcare descrie un numar cpmplex. Clasa contine datelemembre partea reala a numarului complex re, partea imaginara a numarului complex im. Suntdefiniti trei constructori Complex(), Complex (double v), Complex ( double x, double y)precum sio functie membra care permite afisarea datelor unui numar complex.

#include class Complex{double re;double im;

public:

Complex(){cout



cout



Constructorul de copiere poate fi definit de programator; dacnu este definit un constructor decopiere al clasei, compilatorul genereazun constructor de copiere care copiazdatele membrucu membru din obiectul referin n obiectul nou creat. Aceastmodalitate de copiere mai estedenumitcopie la nivel de bii (bitwise copy) sau copie membru cu membru.Pentru clasa Complex, constructorul de copiere generat implicit de compilator sau definit de

programator aratastfel:Complex(Complex &r){cout



Se observa asfel, necesiatea de a introduce in clasa amgajat un constructor de copiere care saaloce explitit memorie , dupa care sa faca copierea continutului zonei de memorie a obiectuluisursa la destinatie:

class angajat{float salariul;

public:char *nume;angajat(char *n,int s){int nr=strlen(n);nume=new char[nr];strcpy(nume,n);salariul=s;}angajat(angajat &a){

int nr= strlen(a.nume)

strcpy(nume,p.nume);varsra=a.varsta;}

int spune_salariul(){return salariul;}}

void main(){ angajat a1(Popescu,35);angajat a2=a1;strcpy(a2.nume,Ion);cout



#include class Complex{

double re;double im;

public:Complex(double x, double y){cout



2.3 Tablouri de obiecte

n limbajul C++ implementarea tablourilor de obiecte se poate realiza cu conditia respectriiurmtoarei restrictii: clasa care include obiectul trebuie s contin un constructor implicit.Aceast restrictie se datoreaz imposibilittii de a furniza argumentele necesare constructorilor.

Programul P2.4 defineste un tablou de obiecte de tip angajat.

// fisierul sursa P24.cpp

class angajat{

private:int varsta;float salariul;

public:

char nume[20];angajat(){strcpy(nume,Anonim);varsta=0;salariul=0;

}angajat( char n[]=Anonim, int v=0, float s=0)

{strcpy(nume,n);varsta=v;salariul=s;

}void seteaza_valori()

{coutnume;cout>>salariul:cin>>salariul;coutvarsta;

}void afisare()

{cout



tab[i].seteaza_valori();// afiseaza cele n obiectefor (i=0;i



void main(){

Complex Z=Complex(3,4);cout



void main(){double x;coutx;

cout



// fisierul sursa P2.7.cppclass angajat

{private:

int varsta;float salariul;char gen;static int total_ang;

static int total_b;

public:char nume[20];angajat()

{strcpy(nume,Anonim);varsta=0;salariul=0;

total_ang++;

}~angajat(){total_ang--;}void seteaza_valori()

{coutnume;cout>>salariul:cin>>salariul;coutvarsta;

}static int spune_total_ang(){return total_ang;}static int spune_total_b(){return total_b;}

static int numara_total_b(angajat *ang){if(ang->gen==B) total_b++;}

void afisare(){cout



cout




2.1 Care este valoarea de adevr a afirmatiilor urmtoare:(a) O clas C++ si o structur C definesc acelasi concept, de TDA.(b) O clas C++ ncorporeaz att date ct si operatii asociate datelor, n timp ce o structur C

defineste doar datele, operatiile nefiind legate direct de datele structurii.(c) O clas C++ ascunde datele n zona privat, n timp ce structura C permite accesul direct ladatele sale neasigurnd consistenta acestora.(d) Structurile C nu pot fi afisate ca o singur entitate si nu pot fi comparate dect membru cumembru.

2.2 Care este numrul maxim de constructori si destructori care se pot defini ntr-o clas?Selectati rspunsul corect.(a) un constructor si un destructor(b) un constructor si mai multi destructori(c) 10 constructori si un destructor

(d) o infinitate de constructori (teoretic) si un singur destructor2.3 Considerm clasa Carte definit astfel:

class Carte {char* titlu;int an_aparitie;char* editura;char* ISBN;public:Carte();Carte(char* T, int A, char* Ed, char* Nr);Carte(char* T, char* Ed);Carte(char* T, int A);

~Carte();void afisare_date();};

si obiectele ob1, ob2, ob3, ob4 definite astfel:Carte ob1=Carte(Compilatoare, 2000, Teora, 052-1432);Carte ob2=Carte(Limbajul Java, Editura Tehnica);Carte ob3=Carte(Programare logica, 2000);Carte ob4;(a) Explicati cum va diferentia compilatorul cei trei constructori cu parametri, lund dreptexemplu obiectele ob1, ob2 si ob3.(b) Ce constructor va aplica compilatorul pentru crearea obiectului ob4?

2.4 Care este rolul functiilor inline?

2.5 Care este valoarea de adevr a urmtoarelor afirmatii?(a) Functiile friend se pot declara numai n sectiunea privat a clasei cu care sunt prietene.(b) Utilizarea functiilor friend ncalc principiul ncapsulrii, principiu fundamental n POO.(c) Avantajul principal al utilizrii functiilor friend este accesul rapid la membrii privati ai claseicu care sunt prietene.(d) Relatia de prietenie este simetric si tranzitiv.

37



2.6 Explicati de ce este necesar definirea unui constructor implicit n cazul utilizrii tablourilorde obiecte n limbajul C++?

2.7 Care este valoarea de adevr a afirmatiilor urmtoare:

(a) Membrii statici ai unei clase pot fi att variabile (date membru) ct si metode (functiimembru).(b) Cuvntul cheie static desemneaz o proprietate a clasei si nu a unui obiect specific clasei.(c) Domeniul de valabilitate al membrilor statici este tot programul n care este definit clasa dincare fac parte.(d) n limbajul C++ datele statice trebuie initializate o singur dat.

2.8 S se defineasc o clas Date pentru memorarea datei sub forma (zi, lun, an). Clasa vaconine atia constructori ct sunt necesari pentru urmtoarele definiii de obiecte:

Date d1(15, 3, 99); // zi, lun, anDate d2(20, 4); // zi, lun, an curentDate d3(18); // zi, luncurent, an curent

Date d4; // zi curent,luncurent, an curent

2.9 Construiti clasastudentcare contine datele membre: nume, prenume, nr_matricol, an, grupa.a). Introduceti in clasa cel putin doi constructori.b). Realizati un tablou de obiecte de tipul clasei student;c). Afisati numarul studentilor din grupa 201, utilizand date si functii membre statice;

2.10 Se consider urmtorul program n care o variabil globalnumbersmemoreaz numrulobiectelor n via la un moment dat:

#include int numbers = 0;

class Item {public:Item(){ // constructorul creste cu 1 nr obiectelornumbers++;cout



2.11 Construiti clasa credite care contine datele membre private val_credit, nr_cont, si datemembre publice nume, tip_credit.a). Introduceti in clasa cel putin doi constructori pentru intializarea obectelor din clasa credite.b). Realizati un tablou cu 20 obiecte din clasa credite.c). Realizati functii de acces la datele membre private.

d). Afisati numarul creditelor de tip ipotecar, utilizand date si functii membre.2. 12 Definii clasapacientcare contine datele private: vrsta, profesie, salariul i data membrapublicnume.Realizai:a). un tablou de 10 obiecte de tipul clasei definitanterior;b). funcii membre de acces la datele private ale clasei;c). numarul pacientilor care au varsta peste media vrstelor utiliznd o funcie membrstatic;d). realizai o funcie operator pentru a calcula suma veniturilor pentru pacienii cu acelai nume

2. 13 Realizai clasafractiecare cuprinde datele membre private :numitor, numarator.

1.

realizai funcii de acces la datele membre ale clasei definitanterior;2. realizai funcii membre pentru a calcula suma si inmultirea a doua fractii, utlizand functiioperator;

3. construii un tablou cu 10 obiecte de tipul definit anterior;4. realizai ordonarea fraciilor in ordine crescatoare dupa numitor.

2.14 Spunei de cte ori se executfiecare constructor n programul de mai jos i n ce ordine.

#include class cls1{ protected: int x;

public: cls1(){ x=13; } };class cls2: public cls1{ int y;public: cls2(){ y=15; }int f(cls2 ob) { return (ob.x+ob.y); } };int main(){ cls2 ob; cout



int main(){ cls2 ob;cout



Capitolul 3 .Mostenire

Obiective

Definirea notiunilor de clas de baz, clas derivat, ierarhie de clase, mostenire nsusirea modalittii de creare de noi clase pornind de la clase existente ntelegerea rolului membrilor protejati ai unei clase nsusirea mecanismului de redefinire a membrilor unei clase ntr-o clas derivat

3.1 Relatia de mostenire. Clase de baz si clase derivate

Derivarea permite definirea ntr-un mod simplu, eficient i flexibil a unor clase noi prinadugarea unor funcionaliti claselor deja existente, fr s fie necesar reprogramarea saurecompilarea acestora. Clasele derivate exprimrelaii ierarhice ntre conceptele pe care acestea

le reprezinti asiguro interfacomunpentru mai multe clase diferite. De exemplu, entitilecerc, triunghi, dreptunghi, sunt corelate ntre ele prin aceea ctoate sunt forme geometrice, deciele au n comun conceptul de formgeometric. Pentru a reprezenta un cerc, un triunghi sau undreptunghi, ntr-un program, trebuie ca aceste clase, care reprezintfiecare formgeometricnparte, saibn comun clasa care reprezintn general o formgeometric.

Mostenireareprezint o form de implementare a reutilizrii codului. Ea apare n urma crerii denoi clase prin operatia de derivare.

Derivarea reprezint definirea unei noi clase prin extinderea uneia sau a mai multor claseexistente. Noua clas se numeste clas derivat, iar clasele existente din care a fost derivat se

numesc clase de baz. n cazul n care exist o singur clas de baz, mostenirea se numestemostenire singular. Limbajul C++ accept existenta mai multor clase de baz.

O clas derivat mosteneste toti membrii tuturor claselor sale de baz. Adic, clasa derivatcontine toate variabilele membru continute n clasele de baz si suport toate operatiile furnizatede clasele de baz.O clas derivat poate fi la rndul ei clas de baz pentru noi clase. Astfel sepoate genera o ierarhie de clase (graf de mostenire).

Sintaxa declarrii unei clase derivate dintr-o clas de baz :

class : public

{ // membrii clasei derivate};

Mostenirea sau relatia de derivare este indicat n antetul clasei derivate prin cuvntul cheiepublicprefixat de caracterul : si urmat de numele clasei de baz.n cadrul relatiei de mostenire poate apare n clasa de baz o sectiune protejat, marcat princuvntul cheie protected, care permite accesul claselor derivate din ea la datele si functiilemembru din sectiunea respectiv.

41



Observatii O clas derivat nu poate accesa direct membrii privati ai clasei sale de baz. Dac s-ar

permite asa ceva s-ar nclca unul din principiile fundamentale ale POO (ncapsularea). O clas derivat poate accesa membrii privati doar prin intermediul functiilor publice siprotejate ale clasei de baz.

O clas derivat poate accesa membrii publici si protejati ai clasei de baz Relatia de mostenire este tranzitiv. Functiile friend nu se mostenesc.

Se considerun program P3.1 care descrie organizarea personalului unei instituii frfolosireaclaselor derivate. O clas numit Angajat deine date i funcii referitoare la un angajat alinstituiei:

class Angajat{char *nume;float salariu;

public:Angajat();Angajat(char *n, float sal);Angajat(Angajat& r);void display();};

Angajat::display(){cout



class Administrator : public Angajat {

int sectie;public:void display();}

In clasa Administrtrator nu se pot aceesa datele private din clasa Angajat, chiar data tipulmostenerii este public. Asa cu s-a subliniat inainte, datele private ale clasei de baza nu pot fiutilizate de catre clasa derivata.Metoda cea mai adecvatde acces la membrii private clasei de bazdin clasa derivateste prinutilizarea funciilor membre publice ale clasei de baz. De exemplu, nu se poate implementafuncia display() din clasaAdministratorprin accesarea membrilor private ai claseiAngajat:

void Administrator::display(){

cout



3.2 Constructori i destructori n clasele derivate

Constructorii i destructorii sunt funcii membre care nu se motenesc. La crearea unei instane aunei clase derivate (obiect) se apeleaz implicit mai nti constructorii claselor de baz i apoi

constructorul clasei derivate. Ordinea n care sunt apelai constructorii claselor de bazeste ceadin lista claselor de bazdin declaraia clasei derivate. Constructorii nu se pot redefini pentru cei, n mod obligatoriu, au nume diferite (numele clasei respective).La distrugerea unui obiect al unei clase derivate se apeleaz implicit destructorii n ordineinvers: mai nti destructorul clasei derivate, apoi destructorii claselor de baz, n ordineainverscelei din lista din declaraie.La instanierea unui obiect al unei clase derivate, dintre argumentele care se transmitconstructorului acesteia o parte sunt utilizate pentru iniializarea datelor membre ale claseiderivate, iar alt parte sunt transmise constructorilor claselor de baz. Argumentele necesarepentru iniializarea claselor de baz sunt plasate n definiia (nu n declaraia) constructoruluiclasei derivate.

Un exemplu simplu, n care constructorul clasei derivate D transfer constructorului clasei debazB un numr de k argumente aratastfel:

class B{//.

public:B(tip1 arg1,,tipk argk);};class D:public B {//.

public:

D(tip1 arg1, ,tipk argk,,tipn argn);};D::D(tip1 arg1, ,tipk argk, .,tipn argn):B(arg1, arg2, ,argk);{

// initialzare date membre clasa derivata}

Sintaxa general pentru transmiterea de argumente din clasa derivat ctre clasa de baz:

() : (){

// corpul constructorului clasei derivate}

reprezint lista de argumente ale constructorului clasei derivate, iar lista deargumente ale constructorului clasei de baz. Lista include lista .

Observatii: Constructorii si destructorul clasei de baz nu se mostenesc.

44



45

Constructorul clasei de baz se va executa naintea constructorului clasei derivate, iardestructorul clasei derivate se va executa naintea destructorului clasei de baz.

3.3 Controlul accesului la membrii clasei de baz

Accesul la membrii clasei de bazmotenii n clasa derivateste controlat de specificatorul deacces (public, protected, private) din declaraia clasei derivate.

O regulgeneraleste c, indiferent de specificatorul de acces declarat la derivare, datele de tipprivate n clasa de baznu pot fi accesate dintr-o clasderivat. O altregulgeneraleste c,prin derivare, nu se modifictipul datelor n clasa de baz.

Un membru protected ntr-o clas se comport ca un membru private, adic poate fi accesatnumai de membrii acelei clase i de funciile de tip friend ale clasei. Diferena ntre tipul privatei tipul protected apare n mecanismul de derivare: un membru protected al unei clase motenitca public ntr-o clasderivatdevine tot protected n clasa derivat, adicpoate fi accesat numai

de funciile membre i friend ale clasei derivate i poate fi transmis mai departe, la o nouderivare, ca tip protected.

Motenirea de tip public a clasei de baz

Dacspecificatorul de acces din declaraia unei clase derivate este public, atunci: Datele de tip public ale clasei de bazsunt motenite ca date de tip public n clasa derivat

i deci pot fi accesate din orice punct al domeniului de definiie al clasei derivate. Datele de tip protected n clasa de bazsunt motenite protected n clasa derivat, deci pot

fi accesate numai de funciile membre i friend ale clasei derivate.

n programul urmator P3.2 sunt prezentate i comentate cteva din situaiile de acces la membriiclasei de bazdin clasa derivatatunci cnd specificatorul de acces este public.

class Base {inta;

protected:int b;

public:int c;void seta(int x){a = x; cout



b = y;cout



obd.Base::setb(5); // eroare, Base::setb este prot.obd.setb(4); // corect, Derived::setb este publicobd.c = 6; // eroare, c este protectedobd.Base::setc(7); // eroare, Base::setc este prot.obd.setc(8); // corect, Derived::setc este public}

Dacse comenteaztoate liniile din funcia fb() care produc erori, la execuia acesteia se afieazurmtoarele rezultate:

setb din derivatasetc din derivata

Din acest exemplu reiese pregnant faptul cn motenirea protected a unei clase de baznu maipot fi accesai din afara clasei derivate nici unul dintre membrii clasei de baz.

Motenirea de tip private a clasei de baz

Dacspecificatorul de acces din declaraia clasei derivate esteprivate, atunci toi membrii de tippublic i protected din clasa de baz devin membri de tip private n clasa derivat i pot fiaccesai numai din funciile membre i friend ale clasei derivate. Din nou trebuie reamintit cmembrii de tip private n clasa de baznu pot fi accesai din clasa derivat. Din punct de vedereal clasei derivate, motenirea de tip private este echivalentcu motenirea de tip protected. ntr-adevr, dacmodificm clasa derivata din Exemplul 5.2 astfel:

class Derived : private Base {// acelasi corp al clasei};

mesajele de erori de compilare i de execuie ale funciei fb() sunt aceleai ca i n motenireaprotected.Ceea ce difereniazmotenirea de tip private fade motenirea de tip protected este modul cumvor fi trasmii mai departe, ntr-o nouderivare, membrii clasei de baz. Toi membrii clasei debaz fiind motenii de tip private,o nouclasderivat(care motenete indirect clasa de baz) nu va mai putea accesa nici unuldin membrii clasei de baz.

3.4 Mostenirea multipla

Relatia de derivare conduce la generarea unor ierarhii de clase. n astfel de ierarhii poate apare

att mostenirea singular ct si cea multipl.Un exemplu de ierarhie de clasa este reprezentat in figura 3.4

Persoana

ElevStudent Angajat

Profesor 47

Medic



Fig. 3.4 Ierarhie de clase

Clasa de baz a ierarhiei de clase este clasaPersoana. Din aceast clas sunt derivate directclaseleElev, Studentsi Salariat. La rndul ei clasa Salariateste clas de baz pentru claseleMedicsiProfesor.

Programul P3.3 prezint un exemplu de implementare a claselorPersoana, Salariat,Arhitect,InginersiMedic.

// fisierul sursa p3_5.cpp#include #include #include

// definitia clasei de baza Persoana

class Persoana {char* nume;char* pren;

public:Persoana(char*, char*);~Persoana();void afisare();};

Persoana::Persoana(char* N, char* P){nume = new char[strlen(N)+1];strcpy(nume, N);

pren = new char[strlen(P)+1];strcpy(pren, P);}Persoana::~Persoana(){delete nume;delete pren;}void Persoana::afisare(){cout



Salariat::Salariat(char* n, char* p, float S):Persoana(n, p){seteazaSalariu(s);}void Salariat::seteazaSalariu(float S)

{salariu = s;}void Salariat::afisare(){cout



tip = new char[strlen(t)+1];strcpy(tip_inginer, t);}void Profesor::seteazaTip(char* t){strcpy(tip_inginer, T);

}void Profesor::afisare(){cout



Un obiect din clasa D va conine membrii clasei L de douori, o datprin clasa A (A::L) i odatprin clasa B (B::L). In acest caz ser creaza o ambiguitate in situatia urmatoare :

D ob;

ob.x = 2; // eroare D::x este ambiguu; poate fi n baza L a clasei A sau n baza L aclasei B

Aceste ambiguitati se pot elimina prin urmatoarele doua metode:- prin calificarea variabilei cu domeniul clasei creia i aparine:

ob.A::x = 2; // corect, x din Aob.B::x = 3; // corect, x din B

- crearea unei singure copii a clasei de bazn clasa derivat. Pentru aceasta este necesar ca aceaclascare ar putea produce copii multiple prin motenire indirect(clasa L, n exemplul de maisus) sfie declaratclasde bazde tip virtualn clasele care o introduc n clasa cu moteniremultip. De exemplu:

class L { public: int x; };class A : virtual public L { /* */ };class B : virtual public L { /* */ };class D : public A, public B { /* */ };

O clasde bazvirtualeste motenito singurdati creeazo singurcopie n clasa derivat.Graful de reprezentare a motenirilor din aceste declaraile de mai sus poate fi ilustrat asfel:

3.6 Funcii virtuale i polimorfism

O funcie virtualeste o funcie care este declaratde tip virtual n clasa de bazi redefinitntr-o clasderivat. Redefinirea unei funcii virtuale ntr-o clasderivatdomin definiia funciei n

51



clasa de baz. Funcia declaratvirtual n clasa de bazacioneazca o descriere genericprincare se definete interfaa comun, iar funciile redefinite n clasele derivate precizeazaciunilespecifice fiecrei clase derivate.

Mecanismul de virtualitate asigur selecia funciei redefinite n clasa derivat numai la apelul

funciei pentru un obiect cunoscut printr-un pointer. n apelul ca funcie membra unui obiect datcu numele lui, funciile virtuale se comportnormal, ca funcii redefinite.

n limbajele de programare, un obiect polimorfic este o entitate, ca de exemplu, o variabil sauargumentul unei functii, creia i se permite s pstreze valori de tipuri diferite n timpul executieiprogramului. Functiile polimorfice sunt acele functii care au argumente polimorfice. n limbajelede programare orientate pe obiecte, polimorfismul mpreun cu legarea dinamic reprezint unadin caracteristicile extrem de utile care conduc la cresterea calittii programelor.

Implementarea obiectelor polimorfice se realizeaz prin intermediul functiilor virtuale.

Sintaxa declarrii unei functii virtuale:

virtual ([]); reprezint tipul ntors de functie, este

Cnd un pointer al clasei de baz puncteaz la o functie virtual din clasa derivat si aceasta esteapelat prin intermediul acestui pointer, compilatorul determin care versiune a functiei trebuieapelat, tinnd cont de tipul obiectului la care puncteaz acel pointer. Astfel, tipul obiectului lacare puncteaz determin versiunea functiei virtuale care va fi executat.

In programul P3.4 se considero clasde bazB i douclase derivate D1 i D2. n clasa de

baz sunt definite dou funcii: funcia normal f()i funcia virtual g(). n fiecare din claselederivate se redefinesc cele dou funcii f() i g(). n funcia main() se creeaz trei obiecte: unobiect din clasa de bazB indicat prin pointerul B* pb i douobiecte din clasele derivate D1 iD2. Fiecare dintre obiectele derivate poate fi indicat printr-un pointer la clasa derivatrespectiv(D1* pd1, respectiv D2* pd2), precum i printr-un pointer la bazcorespunztor (B* pb1 = pd1,respectiv B* pb2 = pd2).

class B {public:void f() { cout



void g() { cout f(); // f() din Bpb->g(); // g() din B

// Obiecte D1, D2 , pointeri D1*, D2*pd1->f(); // f() din D1pd2->f(); // f() din D2pd1->g(); // g() din D1pd2->g(); // g() din D2

// Obiecte D1, D2 , pointeri B*, B*pb1->f(); // f() din Bpb2->f(); // f() din Bpb1->g(); // g() din D1pb2->g(); // g() din D2delete pb;delete pd1;delete pd2;};

n primele situaii, cnd pointerul este pointer la tipul obiectului, nu se manifestnici o deosebirentre comportarea unei funcii virtuale fa de comportarea unei funcii normale: se selecteazfuncia corespunztoare tipului pointerului i obiectului.Diferena de comportare se manifestn ultima situaie, atunci cnd este apelato funcie pentruun obiect de tip clas derivat printr-un pointer la o clas de baz a acesteia. Pentru funcianormal f() se selecteazvarianta depinznd de tipul pointerului. Pentru funcia virtualg() seselecteazvarianta n funcie de tipul obiectului, chiar daceste accesat prin pointer de tip baz.

Polimorfismul, adicapelul unei funcii dintr-o clasderivatprin pointer de tip clasde baz,este posibil numai prin utilizarea pointerilor la obiecte. Obiectele nsele determin variantafunciei apelate, deci nu se pot selecta alte funcii dect cele ale obiectului de tipul respectiv. Deexemplu, pentru aceleai clase definite ca mai sus, se considerfuncia fv2():

void fv2(){B obB;D1 obD1;D2 obD2;obB.f(); // f() din BobB.g(); // g() din BobD1.f(); // f() din D1obD1.g(); // g() din D1

53



obD2.f(); // f() din D2obD2.g(); // g() din D2}

Observati Constructorii nu pot fi functii virtuale. n schimb, destructoriipot fi functii virtuale.

Functiile inline nu pot fi virtuale.

Functiile virtuale sunt ntotdeauna functii membru nestaticeale unei clase.

3.7 Clase abstracte

De cele mai multe ori, o funcie declaratde tip virtual n clasa de baznu definete o aciunesemnificativi este neaprat necesar ca ea sfie redefinitn fiecare din clasele derivate. Pentruca programatorul sfie obligat sredefineasco funcie virtualn toate clasele derivate n careeste folosit aceast funcie, se declar funcia respectivvirtualpur. O funcie virtualpureste o funcie care nu are definiie n clasa de baz, iar declaraia ei aratn felul urmtor:

virtual tip_returnat nume_functie(lista_argumente) = 0;O clascare conine cel puin o funcie virtualpurse numete clasabstract. Deoarece o clasabstractconine una sau mai multe funcii pentru care nu existdefiniii, nu pot fi create instanedin acea clas, dar pot fi creai pointeri i referine la astfel de clase abstracte. O clasabstracteste folositn general ca o clasfundamental, din care se construiesc alte clase prin derivare.

Orice clasderivatdintr-o clasabstracteste, la rndul ei clasabstract(i deci nu se pot creainstane ale acesteia) dacnu se redefinesc toate funciile virtuale pure motenite. Daco clasredefinete toate funciile virtuale pure ale claselor ei de baz, devine clas normal i pot ficreate instane ale acesteia.Exemplul urmtor (5.6) evideniaz caracteristicile claselor abstracte i ale funciilor virtualepure.

Programul P3.5 se realizeaza conversia unor date dintr-o valoare de intrare ntr-o valoare deieire; de exemplu, din grade Farenheit n grade Celsius, din inch n centimetri, etc.

class Convert{protected:double x; // valoare intraredouble y; // valoare iesire

public:Convert(double i){x = i;}

double getx(){return x;}double gety(){return y;}virtual void conv() = 0;};// clasa FC de conversie grade Farenheit in grade Celsiusclass FC: public Convert{

public:FC(double i):Convert(i){}void conv(){y = (x-32)/1.8;}

54



};// clasa IC de conversie inch in centimetriclass IC: public Convert{

public:IC(double i):Convert(i){}void conv(){y = 2.54*x;}}

void main (){

Convert* p = 0; // pointer la bazacout v >> ch;switch (ch){

case 'i': //conversie inch -> cm (clasa IC)

p = new IC(v);break;

case 'f': //conv. Farenheit -> Celsius (clasa FC)p = new FC(v);break;}if (p){

p->conv();cout getx()



3.8 Polimorfism

Polimorfismulpermite unei entitti (de exemplu, variabil, functie, obiect) s aib o varietate dereprezentri. El este furnizat att la momentul compilrii (legare timpurie), prin folosireaoperatorilor si a functiilor redefinite, ct si la momentul executiei (legare trzie), prin utilizarea

functiilor virtuale.Conceptul de legare dinamic permite unei variabile s aib tipuri diferite n functie de continutulei la un moment dat. Aceast abilitate a variabilei se numeste polimorfism, iar variabila senumeste variabil polimorfic.n limbajul C++ variabilele polimorfice apar doar prin utilizarea pointerilor sau referintelor. ncazul n care un pointer al clasei de baz puncteaz ctre o functie virtual, programul vadetermina la momentul executiei la care tip de obiect puncteaza pointerul si apoi va selectaversiunea corespunztoare functiei redefinite.

Programul P4.4 defineste clasa de bazPersoanasi dou clase derivate, Student si Salariat. Clasade bazPersoanaeste o clas abstract avnd declarat o functie virtual pur, venit(), definit n

clasele derivate. De asemenea, clasaPersoanamai contine o alt functie virtual, afisare(), careeste redefinit n clasele derivate. n programul principal sunt create dou obiecte S1 si T1dinclasele Studentsi respectiv Salariat. Pentru fiecare din cele dou obiecte se execut o secvent depatru instructiuni: primele dou instructiuni ilustreaz legarea static, prin apelul celor doufunctii afisare()si venit(), corespunztoare obiectului referit prin nume; ultimele dou instructiuniilustreaz legarea dinamic apelnd cele dou functii afisare()si venit()prin intermediul a doufunctii, Ref_Pointer(.), Ref_Referinta(.), care utilizeaz un pointer, respectiv o referint ctreclasa de bazPersoana.Aceste ultime dou instructiuni genereaz un comportament polimorfic, la momentul executieiprogramului.

// fisierul sursa p4_4.cpp#include #include #include // clasa de baza Persoana, clasa abstractaclass Persoana {char* prenume;char* nume;

public:Persoana(char*, char*);~Persoana();char* preiaPrenume();

char* preiaNume();// functie virtuala puravirtual double venit() = 0;virtual void afisare();};Persoana::Persoana(char* P, char* N){

prenume = new char[strlen(P)+1];

56



strcpy(prenume, P);nume = new char[strlen(N)+1];strcpy(nume, N);}Persoana::~Persoana(){

delete prenume;delete nume;}char* Persoana::preiaPrenume(){return prenume;}char* Persoana::preiaNume(){return nume;}

void Persoana::afisare(){cout



}void Student::afisare(){cout



// dinamica, in cazul unui pointer al clasei de baza// referire prin pointervoid Ref_Pointer(Persoana *Ptr){Ptr->afisare();cout




3.1 Definiti relatia de derivare.

3.2 Definiti mostenirea.

3.3 Dac din clasa X se genereaz o clas Z cum se numesc cele dou clase?(a) X clas derivat, Z clas de baz(b) X superclas, Z subclas(c) X clas copil, Z clas printe(d) X clas de baz, Z clas derivat

3.4 Care dintre afirmatiile urmtoare sunt adevrate si care sunt false?(a) Obiectele unei clase derivate au acces la membrii privati ai clasei sale de baz.

(b) Relatia de mostenire este tranzitiv.(c) Functiile friend ale clasei de baz se mostenesc de ctre clasa derivat.(d) Constructorul si destructorul clasei de baz se mostenesc n clasa derivat.

3.5 Selectati rspunsul corect referitor la ordinea de apelare a constructorilor si a destructorilor ncazul claselor derivate dintr-o clas de baz.Ordinea de apelare este urmtoarea:

(a) constructorul clasei derivate constructorul clasei de baz destructorul clasei derivatedestructorul clasei de baz(b) constructorul clasei de baz constructorul clasei derivate destructorul clasei derivatedestructorul clasei de baz

(c) constructorul clasei derivate constructorul clasei de baz destructorul clasei de bazdestructorul clasei derivate(d) constructorul clasei de baz constructorul clasei derivatedestructorul clasei de baz

3.6 Care este avantajul principal oferit de mecanismul mostenirii?

3.7 Utilizarea mostenirii si a polimorfismului permite eliminarea unei anumite instructiuni. Careeste aceast instructiune n limbajul C++?

3.8 Cum este specificat o functie virtual pur?

3.9 Cum se numeste o clas care contine una sau mai multe functii virtuale pure?

3.10 Dac apelul unei functii este rezolvat la momentul executiei legarea este(a) static(b) timpurie(c) nul(d) dinamic

60



3.11 Care dintre afirmatiile urmtoare sunt adevrate?(a) Constructorii pot fi functii virtuale.(b) Destructorul poate fi functie virtual.(c) Orice functie membru static este functie virtual.(d) Functiile inline nu pot fi functii virtuale.

3.12 Care este diferenta ntre o functie virtual si o functie virtual pur?3.13 Ce se ntelege prin polimorfism pur? Comparati cu notiunea de suprancrcare.

3.14 Cum pot fi definite variabilele polimorfice n limbajul C++?

3.15 Explicati pe scurt notiunea de polimorfism n cazul programrii orientate pe obiecte.

3.16 Care este rolul claselor abstracte?

3.17 Scrieti un program care defineste clasa de baz Aparat si clasa derivat Radio. Printre

functiile membru includeti si o functie de afisare a datelor membru ale clasei. n programulprincipal se vor crea dou obiecte ob1 al clasei Aparat si ob2 al clasei Radio si se vor apelafunctiile de afisare.

3.18 Redefiniti functia de afisare a clasei Aparat n clasa Radio si rescrieti programul de laexercitiul 3.17.

3.19 Rescrieti programul de la exercitiul T3.2 realiznd suprancrcarea constructorului claseiderivate Radio.

3.20 Care sunt erorile din urmtoarea secvent de program?//

class A {int a,b;public:A(int , int, double);void afisare();// protected:double t;};// class B::public A {

double w;public:B(int, int, double);void afisare();void setValori(int x, int y, double z){ a=x; b=y; t=z;}};//

61



3.21 Fiind date urmtoarele tipuri de clase:

class B { /* instructiuni */ };

class D1: virtual B { /* instructiuni */ };class D2: virtual B { /* instructiuni */ };class D3: B { /* instructiuni */ };class D4: private B { /* instructiuni */ };class D5: virtual public B { /* instructiuni */ };class M1: D1, public D2, D3, private D4, virtual D5{ /* instructiuni */ };class M2: D1, D2, virtual D3, virtual D4, virtual D5{ /* instructiuni */ };

spunei de cte ori este motenitclasa B n clasa M1. Dar n clasa M2 ? Justificai.

3.22 Spunei care dintre declaraiile funciei main() sunt corecte n programul de mai jos. Justificai.

#include class B1 { public: int x; };class B2 { int y; };class B3 { public: int z; };class B4 { public: int t; };class D: private B1, protected B2, public B3, B4{ int u; };int main()

{ D d;cout



class cls4: public cls1{ public: cls4(int i=19) { x=i; } };class cls5: public cls2, public cls3, public cls4{ public: int y;cls5(int i,int j):cls4(i),cls2(j){ y=i+j; }cls5(cls5& ob) ){ y=-ob.y; }};int main(){ cls5 ob1(-9,3), ob2=ob1;cout



Cap. 4 Facilitti ale limbajului C++

Obiective Redefinirea operatorilor Definirea template-urilor nsusirea modului de lucru cu fisiere n limbajul C++

4.1 Supraincarcarea operatorilor

Limbajul C++ permite programatorului s defineasc diverse operatii cu obiecte ale claselor,

utiliznd simbolurile operatorilor standard. Pentru tipurile fundamentale ale limbajului suntdefinite seturi de operatori care permit operaii de bazexecutate ntr-un mod c

47233482 Programare Orientata Pe Obiecte C Dascalescu Ana Cristina

Documents

Transcript of 47233482 Programare Orientata Pe Obiecte C Dascalescu Ana Cristina