UNIVERSITATEA TITU MAIORESCU DIN BUCURE TI FACULTATEA DE INFORMATIC

Programarea orientat pe obiecte n limbajul C++

-suport curs pentru forma de nvatamnt ID -

Lector univ. drd. Dsclescu Ana Cristina

- 2010 -

Cuprins
Cap. 1 Introducere in programarea orientata pe obiecte ..................................................................3 1.2 Concepte ale programrii orientate pe obiecte.......................................................................5 1.3 Elemente introductive ale programrii orientate pe obiecte n limbajul C++ ......................7 1.4 Tipuri de date .........................................................................................................................9 1.5 Operatori specifici C++........................................................................................................17 Cap.2 Clase si Obiecte .................................................................................................................21 2.1 Definirea unei clase..............................................................................................................23 2.2 Constructori si destructor .....................................................................................................25 2.3 Tablouri de obiecte...............................................................................................................31 2.4 Funcii i clase friend ...........................................................................................................32 2.5 Funcii inline .......................................................................................................................33 2.6 Date si functii statice ............................................................................................................34 Capitolul 3 .Mostenire....................................................................................................................41 3.1 Relatia de mostenire. Clase de baz si clase derivate ..........................................................41 3.2 Constructori i destructori n clasele derivate ......................................................................44 3.3 Controlul accesului la membrii clasei de baz .....................................................................45 3.4 Mostenirea multipla..............................................................................................................47 3.4 Clase de baz virtuale...........................................................................................................50 3.6 Funcii virtuale i polimorfism.............................................................................................51 3.7 Clase abstracte......................................................................................................................54 3.8 Polimorfism..........................................................................................................................56 Cap. 4 Facilitti ale limbajului C++...............................................................................................64 4.1 Supraincarcarea operatorilor ................................................................................................64 4.2 Funcii operator membre ale claselor ...................................................................................64 4. 3 Template-uri ........................................................................................................................68 4.4 Stream-uri de I/E ..................................................................................................................69 4.5 Funcii de I/O pentru tipurile predefinite .............................................................................69 Funcii de I/O pentru tipuri definite de utilizator .......................................................................71 4. 6 Procesarea fisierelor ............................................................................................................72 Teste recapitulative: .......................................................................................................................76

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, reflectnd trecerea 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 singur persoan, intr n categoria sistemelor complexe, cu o mare diversitate de aplicaii. Situaiile reale i experiene ale psihologilor au relevat limitele capacitii umane n perceperea sistemelor complexe, adic imposibilitatea unei persoane de a percepe i controla simultan un numr mare de entiti de informaie. De aceea, este esenial descompunerea i organizarea sistemelor 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 evoluia sistemelor de calcul. Programarea procedural este prima modalitate de programare care a fost i este nc frecvent folosit. n programarea procedural accentul se pune pe descompunerea programului n proceduri (funcii) care sunt apelate n ordinea de desfurare a algoritmului. Limbajele care suport aceast tehnic de programare prevd posibiliti de transfer a argumentelor ctre funcii i de returnare a valorilor rezultate. Limbajul Fortran a fost primul limbaj de programare procedural. Au urmat Algol60, Algol68, Pascal, iar C este unul din ultimele invenii n acest domeniu. Programarea modular. n cursul evoluiei programrii procedurale, accentul n proiectarea programelor s-a deplasat de la proiectarea procedurilor ctre organizarea datelor, aceast deplasare reflectnd creterea dimensiunilor programelor. O mulime de proceduri corelate, mpreun cu datele pe care le manevreaz, sunt organizate ca un modul. Tehnica de programare modular decide descompunerea unui program n module, care ncorporeaz o parte din datele programului i funciile care le manevreaz. Aceast tehnic este cunoscut ca tehnic de ascundere 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 de ascundere a unor informaii definite ntr-un modul, fa de celelalte module. Gruparea de date i proceduri n module nu implic i o asociere strict ntre 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 modeleaz problema ce trebuie rezolvat. n programarea orientat pe obiecte (POO) un program are rolul de a simula strile si activittile obiectelor lumii reale. Pe lng structuri de date (care descriu strile obiectelor, atributele acestora) trebuie incluse si metodele asociate obiectelor, adic acele functii care modific atributele 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 care nu afecteaza problema pe care o rezolvam asfel, datele cu care se lucreaza, operatiile , tin de specificul fiecarei probleme tratate. Acest proces de grupare a datelor si metodelor de prelucrare specifice rezolvarii unei probleme se numeste abstractizare. n cazul dezvoltrii unui produs software, abstractizarea se poate defini ca fiind o structurare a unei probleme n entitti bine precizate prin definirea datelor si a operatiilor asociate. Aceste entitti combin date si operatii care sunt necuplate ntre ele. Procedurile si functiile au fost primele 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 si functiilor ce sunt relationate. n continuare, tipurile de date abstracte au realizat un pas important ctre dezvoltarea unui software de calitate si au permis trecerea la abordarea orientat pe obiecte a 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 TDA care este vizibil din exterior. Conceptul de tip de date abstract presupune existenta unui mecanism de separare a specificatiei de implementare. Aceasta nseamn c un utilizator al unui TDA 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 n interfat; 4. axiomele si preconditiile definesc domeniul deaplicatie al tipului.

De exemplu, dorim sa construim TDA persona. Sa presupunem ca realizam o aplicatie necesara pentru realizarea recesamnatului populatiei, atunci datele care interseaza pentru tipul persoana sunt : nume, prenume, loc_nastere, adresa etc. Daca aplicatia presupune, in schimb, gestiunea intretinerii pentru o asociatie de locatari, atunci pentru tipul persoana sunt necesare si date cum ar fi : spatiul_locuit, nr_persoane etc. Deci, prin procesul de abstarctizare, separam datele care intereseaza de cele care nu fac obiectul aplicatiei. Construim, ulterior, un tip abstract de date care inglobeaza o structura de date impreuna ca operatii aupra datelor ( ex: calculul intretinerii pentru o persoana, nr_persoane pe fiecare judet etc.). Exemplu: TDA_persona nume prenume spatiu_locuit

structura de date

calcul intretinere; - operatii asupra datelor Programarea orientat pe obiecte este programarea cu tipuri de date abstracte, care combin functionalittile 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 cadrul limbajelor moderne de programare. Astfel, limbajele orientate pe obiecte au noi structuri care mbunttesc 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 realizeaz anumite actiuni si stiu cum s execute aceste actiuni. Inteligenta unui obiect reprezint o form de abstractizare prin faptul c presupune c un obiect poate executa o actiune si ascunde detaliile referitoare 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 software reutilizabil care modeleaz elemente din lumea real. Pentru tipul de date abstract persoana definit mai sus un exemplu de obiect poate fi definit astfel :

Popescu Ion, 34, 56 m2 . Clasele Clasele desemneaz o colecie de obiecte (de natur material sau spiritual) care au n comun faptul c pot fi caracterizate similar din punct de vedere informaional i comportamental. Este evident faptul c identificarea unei clase este n mod normal, rezultatul unui demers cognitiv care presupune caracterizarea unui obiect prin nsuirile lui (informaionale i comportamentale) care i definesc apartenena la o anumit clas de obiecte. Aadar, conceptul de clas adun laolalt datele i metodele de prelucrare a acestora. O clasa reprezinta de fapt o implemntare a tipului abstract de date. O declarare a unei clase definete un tip nou care reunete date i funcii. Acest tip nou poate fi folosit pentru a declara obiecte 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 unui obiect s aplice o anumit actiune numit metod este similar apelului de procedur din limbajele de programare procedural. n programarea orientat pe obiecte se consider c obiectele sunt autonome si pot comunica ntre ele prin interschimb de mesaje. Obiectele reactioneaz atunci cnd primesc mesaje, aplicnd o anumit metod, de exemplu. Ele pot refuza executarea metodei respective dac, de exemplu, obiectului care este apelat nu i se permite s execute 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 dou nivele de abordare. @ Ca metod de concepie, ncapsularea se refer la capacitatea de a separa aspectele externe ale unui obiect (interfaa), accesibile altor obiecte, de aspectele implementaionale, interne obiectului, care sunt ascunse fa de celelalte obiecte. Utilizatorul unui obiect poate accesa doar anumite metode ale acestuia, numite publice, n timp ce atributele i celelalte metode i rmn inaccesibile (acestea se numesc private). ncapsularea este foarte important atunci cnd dorim s schimbm implementarea anumitor metode (cu scopul de a optimiza un algoritm sau de a elimina posibile erori). ncapsularea ne va mpiedica s modificm toate caracteristicile obiectului iar aplicaiile care utilizeaz obiectul nu vor avea de suferit deoarece protocolul de comunicaie al obiectului motenit de la interfaa clasei (rezultatul ncapsulrii ca metod de concepie) nu s-a schimbat.

@Ca implementare, la nivelul unui limbaj de programare, ncapsularea este asigurat de exigenele sintactice specifice. Mostenirea Mecanismul derivarii permite crearea facila de noi clasa, care preiau caracteristicile unor clase de baza, deja definite. Derivarea are ca obiectiv reutilizarea soft-ului, prin folosirea uneor functii deja scrise pentru clasele existente si eliminarea redundantei descrierilor, in cazul claselor care au elemente 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. n cazul n care mai multe clase mostenesc atributele si comportamentele unei clase de baz, pot apare situatii n care comportamentul unei clase derivate ar trebui s fie diferit de cel al clasei de baz 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 si FisierBitmap care mostenesc toate atributele si comportamentele clasei Fisier cu exceptia comportamentului Tiprire. Un mesaj care va activa comportamentul Tiprire al unui obiect al clasei Fisier poate determina afisarea 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, n timp ce dac va fi trimis unui obiect al clasei FisierBitmap va determina executia unui program de afisare grafic.

1.3

Elemente introductive ale programrii orientate pe obiecte n limbajul 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 att pentru calculatoare personale ct i pentru cele mai dezvoltate sisteme i staii de lucru. Limbajul C++ este o versiune extins a limbajului C elaborata de ctre B. Stroustrup n anul 1980 n laboratoarele Bell din Murray Hill, New Jersey. Extensiile dezvoltate de Stroustrup pentru limbajul C++ permit programarea orientat pe obiecte, pstrnd eficiena, flexibilitatea i concepia 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 general programarea orientat pe obiecte: dezvoltarea i administrarea programelor foarte mari. Chiar dac superioritatea limbajului C++ este evident n cazul dezvoltrii programelor foarte mari, nu exist limitri n a fi folosit n orice fel de aplicaie, deoarece C++ este un limbaj tot att de eficient ca i limbajul C.

De la apariia sa, C++ a trecut prin trei revizii, n 1985, 1989 i ultima, prilejuit de definirea standardului ANSI pentru acest limbaj. O prim versiune a standardului a fost publicat n anul 1994, iar urmtoarea versiune este nc n 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 baz n programarea C++, att cele care sunt preluate din limbajul C ct i cele nou introduse. Multe dintre ele sunt reluate i dezvoltate pe parcursul seciunilor urmtoare. Operatii de intrare/iesire. Stream-uri Cel mai scurt program C++ este:
main(){ }

Acesta definete o funcie numit main (), care nu primete nici un argument, nu execut nimic i nu returneaz nici o valoare. Dac se dorete ca programul s scrie un mesaj la consol (de tipul Primul program in C++!), pe lng utilizarea funciei obinuite din limbajul C (funcia printf()), n C++ se poate utiliza i o funcie de scriere la ieirea standard (cout). Aceast funcie este funcia operator de scriere << care este definit n fiierul antet iostream.h. Un astfel de program este urmtorul:
#include <iostream.h> void main(){ cout << Primul program in C++!<< endl; }

Prima operaie de scriere afieaz la consol irul, Primul program in C++!, iar urmtoarea (endl) introduce caracterul de linie nou. Operaia de citire de la tastatur poate fi realizat n C++ printr-o instruciune care folosete funcia operator de citire >>. De exemplu, n instruciunile care urmeaz se citete de la tastatur un numr ntreg:
int i; cin >> i;

Desigur, funcia scanf() de citire de la tastatur din limbajul C poate fi n continuare folosit, dar pe 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 <iostream.h> void main() {

int a, b; float m; cout << "\n cin >> a; cout << "\n cin >> b; m = (float) cout << "\n }

Introduceti un numar intreg a = "; Introduceti un numar intreg b = "; (a+b)/2; Media aritmetica este " << m;

Programul P1.1 citeste dou numere ntregi, a si b si calculeaz media lor aritmetic, m, pe care o afiseaz pe ecran. Citirea celor dou numere se poate realiza si cu o singur operatie de citire asa cum se observ n programul P1.1_v2
// fisierul sursa P1_1_v2.cpp #include <iostream.h> void main() { int a, b; float m; cout << "\n Introduceti doua numere intregi: "; cin >> a >> b; m = (float) (a+b)/2; cout << "\n Media aritmetica este " << m; }

Sintaxa operatiei de intrare (citire):

cin >> 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 << expr_1 << expr_2 << << expr_p;

Se afiseaz pe dispozitivul de iesire valorile expresiilor expr_1, expr_2, , expr_p. Expresiile pot fi, de exemplu, expresii aritmetice, variabile sau pot contine text, care este marcat ntre ghilimele (). Textul poate contine secvente de tipul \n (trecere la linie nou), \t (afisarea se face la dreapta n pozitia dat de tab), \a (avertizare sonor) etc.

1.4 Tipuri de date

n C++ sunt definite urmtoarele tipuri fundamentale: Tipuri de ntreg, pentru definirea numerelor ntregi de diferite dimensiuni (ca numr de octei ocupai n memorie): 9

short int 2 octei int 2 sau 4 octei long 4 sau 8 octei Tipuri de numere flotante, pentru definirea numerelor reale (reprezentate ca numere cu virgul flotant): float 4 octei double 8 octei long double 12 sau 16 octei Aceste tipuri sunt denumite mpreun tipuri aritmetice. Pentru tipurile ntreg, exist variante de declaraie cu semn (signed) i fr semn (unsigned). Tipul caracter, pentru definirea caracterelor char 1 octet Tipul void specific o mulime vid de 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 funcii Pe langa tipurile de date fundamentale enumerate, se pot defini conceptual un numr infinit de tipuri 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 pe parcursul seciuniunilor urmtoare. Ca terminologie, clasele (mpreun cu structurile i uniunile) sunt denumite tipuri definite de utilizator (user-defined types), iar celelate tipuri sunt denumite tipuri predefinite (built-in types). Tablouri de obiecte Un tablou (array) de obiecte poate fi construit din obiecte dintr-un tip fundamental (cu excepia tipului void), din pointeri, din enumeraii sau din alte tablouri. n traducere, pentru array se mai ntlnesc termenii vector i matrice. n acest text sunt folosii termenii tablou (pentru array multidimensional) i vector (pentru array unidimensional). Declaraia: T D[expresie] introduce un tablou de obiecte de tipul T, cu numele D i cu un numr de elemente al tabloului dat de valoarea expresiei, care trebuie s fie de tip constant ntreg. Pentru valoarea 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

T D[dim1][dim2]; i reprezint dim1 tablouri unidimensionale, fiecare de dimensiune dim2. Elementele tabloului bidimensional se memoreaz cu 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 de dimensiuni care depinde de implementare. Pointeri Pentru majoritatea tipurilor T, T* este un tip denumit pointer la T, adic o variabil de tipul T* memoreaz adresa unui obiect de tipul T. Operaia fundamental asupra unui pointer este operaia de derefereniere (dereferencing), adic accesarea obiectului a crui adres o reprezint pointerul respectiv. Operatorul de derefereniere este operatorul unar *. De exemplu: char c1 = a; // variabila c1 char* p1 = &c1; // p memoreaz adresa lui c1 char c2 = *p1; // dereferentiere, c2 = a; Operatorul & este operatorul adres, care se utilizeaz pentru 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 consider un vector de caractere 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, folosind operaia de incrementare a pointerului i operaia de derefereniere pentru a testa valoarea caracterului. O alt implementare posibil a 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 tablou poate fi folosit ca un pointer la primul element al tabloului. De exemplu, se poate scrie:
char alpha[] = abcdef;

11

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

Rezultatul aplicrii operatorilor aritmetici +, -, ++, -- asupra pointerilor depinde de tipul obiectului indicat. Atunci cnd se aplic un operator aritmetic unui pointer p de tip T*, se consider c p indic un element al unui tablou de obiecte de tip T; p+1 va indica urmtorul element al tabloului, iar p-1 va indica elementul precedent al tabloului. Acest lucru nseamn c valoarea 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 principal a referinelor se face pentru specificarea argumentelor i a valorilor returnate de funcii, n general, i pentru suprancrcarea operatorilor n special. Notaia X& nseamn referin la un obiect de tipul X. De exemplu: int i = 1; int& r = i; // r i i se refer la aceeai entitate int x = r; // x = 1 r++; // i = 2; Implementarea obinuit a unei referine se face printr-un pointer constant care este derefereniat de fiecare dat cnd este utilizat. Aa cum se poate observa, pentru definirea unei referine se folosete operatorul adres &, dar difer tipul construciei n care este folosit. De exemplu:
int a = 5; int* pi = &a; // & calculeaz adresa; // pi este adresa lui a int& r = a; // & introduce o referinta; // r este o referin (alt nume) pt. a

O referin este utilizat ca argument pentru o funcie care poate s modifice valoarea acestui argument. De exemplu: void incr(int& x) {x++;} void f(){ int i = 1; incr(i); // i = 2; } O alt utilizare important a referinelor este pentru definirea funciilor care pot fi folosite att ca membru drept ct i ca membru stng al unei expresii de asignare. De exemplu:
#include <iostream.h> int& fr(int v[], int i){ return v[i]; } void main(){

12

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

La execuia acestui program se obine mesajul: 1 2 7 4 Deoarece valoarea returnat de funcie este referina (numele) unui element al vectorului, acesta poate fi modificat prin folosirea funciei fr() ca membru stng al egalitii. Funcii Funciile sunt tipuri derivate i reprezint una din cele mai importante caracteristici ale limbajelor C i C++. Forma general de definire a unei funcii este:
tip_returnat nume_func(tip1 arg1,tip2 arg2,,tipn argn) { //corpul functiei }

Funcia cu numele nume_func returneaz o valoare de tip tip_returnat i are un numr n de argumente formale declarate ca tip i nume n lista de argumente formale. Argumentele formale din declaraia unei funcii se mai numesc i parametrii funciei. Dac o funcie nu are argumente, atunci lista din parantezele rotunde este vid. Notaia din C: f(void) este redundant. O funcie este un nume global, dac nu este declarat de tip static. O funcie declarat static are domeniul de vizibilitate restrns la fiierul n care a fost definit. Corpul funciei este propriu ei i nu poate fi accesat din afara acesteia (nici printr-o instruciune goto). Corpul unei funcii este o instruciune compus, adic o succesiune de instruciuni i declaraii incluse ntre acolade. n corpul funciei se pot defini variabile, care sunt locale i se memoreaz n segmentul de stiv al programului. Dac nu sunt declarate static, variabilele locale se creaz la fiecare apel al funciei i se distrug atunci cnd este prsit blocul n care au fost definite. Nu se pot defini funcii n interiorul unei funcii. Argumentele formale ale unei funcii sunt considerate variabile locale ale funciei, ca orice alt variabil definit n funcia respectiv. Dac o funcie nu are de returnat nici o valoare, atunci tip_returnat din declaraia funciei este tipul void i nu este necesar o instruciune de returnare (return) n funcie. n toate celelalte cazuri, n corpul funciei trebuie s fie prevzut returnarea unei variabile de tipul tip_returnat, folosind instruciunea return. Dac n definiie nu este prevzut un tip_returnat, se consider implicit returnarea unei valori de tip ntreg. Prototipurile funciilor. Pentru apelul unei funcii este necesar cunoaterea definiiei sau a prototipului acesteia. Prototipul unei funcii este de forma:
tip_returnat nume_func(tip1 arg1,., tipn argn);

Numele argumentelor formale sunt opionale n prototipul unei funcii. Prototipurile permit compilatorului s verifice tipurile argumentelor de apel i s semnaleze eroare la conversii

13

ilegale. Spre deosebire de limbajul C, unde este admis i simpla declaraie a numelui funciei (fr tipurile argumentelor de apel), utilizarea prototipurilor este obligatorie n C++. De exemplu:
double f2(int, double); // prototip functie f2 double f3(int a, double f){ // definitie functie f3 /*..*/ double t = f/a; return t; } void fp(){ double r1 = f1(7, 8.9); // eroare, // identificator nedeclarat double r2 = f2(7, 8.9); // corect, fol. prototipul char 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 declarat prin prototip n domeniul funciei apelante fp() i o eroare datorat apelului 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 i argumente reale sau efective) iniializeaz argumentele formale din declaraia funciei, n ordinea din declaraie. Argumentele unei funcii se pot transfera n dou moduri: apelul prin valoare i apelul prin referin. n apelul prin valoare se copiaz valoarea argumentului real n argumentul formal corespunztor al funciei. n acest caz, modificrile efectuate asupra argumentului funciei nu modific argumentul real. n apelul prin referin este accesat direct variabila din argumentul real transmis funciei, care poate fi deci modificat. Ca exemplificare, se definete o funcie swap() care realizeaz intershimbul ntre valorile a dou variabile. Dac nu se folosesc referine, argumentele de apel ale funciei trebuie s fie pointeri la variabilele respective. Pointerii, ca argumente de apel, nu vor fi modificai, dar variabilele indicate de acetia pot fi modificate. Funcia swap() cu argumente pointeri arat astfel: void swap(int* x, int* y){ int t;

14

t = *x; // dereferentiere *x = *y; *y = t; } Aceeai funcie swap(), folosind argumente de tip referin, arat astfel: 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, referina folosete adresa variabilei pentru a o putea modifica (deci un pointer). Dar, n cazul referinelor, 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 de dimensiuni mari i copierea lor n argumentele formale (plasate n segmentul de stiv al programului) ar fi foarte ineficient. Argumente implicite ale funciilor. Se ntmpl frecvent ca o funcie s aib un numr mai mare de argumente dect sunt necesare n cazurile simple dar frecvente de apel. Dac nu este necesar s fie transmis ntotdeauna valoarea real a unui argument i acesta poate lua, de cele mai multe ori, o valoare implicit, atunci n declaraia funciei se prevede o expresie de iniializare a acestui argument, iar din apel poate s lipseasc valoarea 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 1999 setdata(21,7); // 21 7 1999 setdata(20,1,2000); // 21 1 2000 }

Numai argumentele de la sfritul listei pot fi argumente implicite. De exemplu, este eronat urmtoarea 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 fi modificat n cursul programului. n C++ exist trei modaliti de a defini constante simbolice: Orice valoare, de orice tip care poate primi un nume, poate fi folosit ca o constant simbolic prin adugarea cuvntului-cheie const n declaraia acesteia. Orice nume de funcie sau de tablou este o constant simbolic. O enumeraie definete o mulime de constante ntregi. De exemplu, urmtoarele declaraii introduc constante simbolice prin folosirea cuvntului-cheie const:
const int val = 100; const double d[] = {1.2, 2.8, 9.5};

Deoarece constantele nu pot fi modificate, ele trebuie s fie iniializate n declaraie. ncercarea de modificare ulterioar este detectat ca eroare n timpul compilrii:
val++; // eroare d = 200; // eroare

Cuvntul-cheie const modific tipul obiectului, restricionnd modul n care acesta poate fi folosit. Un aspect interesant i intens folosit n programare, este acela de a declara pointeri la constante. Atunci cnd se folosete un pointer, sunt implicate dou obiecte: pointerul nsui i obiectul ctre care indic pointerul. Prin prefixarea declaraiei unui pointer cu cuvntul const, obiectul indicat este fcut constant, nu pointerul nsui. De exemplu:
const char* pc = abcd;// pc este pointer la o constant pc[2] = m; // eroare, nu se poate modifica // obiectul constant pc = ghij; // corect, este modificat // valoarea pointerului pc++; // corect Pentru ca pointerul nsui s fie constant, se folosete operatorul *const: char *const cp = abcd;// cp este pointer constant; cp[2] = m; // corect, modifica valoarea cp++; // eroare, pointer constant

16

Posibilitatea de declarare a pointerilor la constante este folosit n special pentru transmiterea argumentelor funciilor. Prin declararea unui argument de tip pointer la constant, este interzis modificarea de ctre funcie a obiectului indicat. De exemplu:
char* strcpy(char* d, const char* s);

n aceast funcie irul s nu poate fi modificat. n mod asemntor, specificatorul const care nsoete un argument tip referin la apelul unei funcii, mpiedic modificarea acestuia de ctre funcia respectiv.

1.5 Operatori specifici C++

Majoritatea operatorilor C++ sunt preluai din limbajul C, cu aceeai sintax i reguli de operare. n plus fa de operatorii C, n C++ mai sunt introdui urmtorii operatori: operatorul de rezoluie (::) operatorii de alocare-eliberare dinamic a memoriei new i delete. Operatorul de rezoluie Operatorul de rezoluie (::) este folosit pentru modificarea domeniului de vizibilitate al unui nume. Pentru acest operator (scope resolution operator), n traduceri se mai ntlnesc termenii de operator de domeniu sau operator de acces. Operatorul de rezoluie permite folosirea unui identificator ntr-un bloc n care el nu este vizibil. Dac operatorul de rezoluie nu este precedat de nici un nume de clas, atunci este accesat numele global care urmeaz acestui operator. De exemplu: int g = 10; int f(){ int g = 20; // return ::g; } void main(){ cout << f() << endl; // afiseaza 10 } n acest exemplu operatorul de rezoluie a fost folosit pentru a accesa variabila global g, ascuns de variabila local cu acelai nume din funcie. Deoarece utilizarea cea mai extins a operatorului de rezoluie este legat de utilizarea claselor, el va fi reluat pe parcursul seciunilor urmtoare. Operatorii new i delete n limbajul C se pot aloca dinamic zone n memoria liber (heap) folosind funcii de bibliotec (de exemplu, malloc(), calloc(), realloc()) i se pot elibera folosind funcia free(). La aceste posibiliti, care se pstreaz n continuare n C++, se adaug operatorii de alocare i eliberare dinamic a memoriei, new i delete. Aceti operatori unari prezint avantaje substaniale fa de funciile de alocare din C i de aceea sunt n mod evident preferai n programele scrise n C++. 17

Pentru alocarea unei singure date (obiect), operatorul new are urmtoarea form general:
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, iar initializare este o expresie care depinde de tipul datei i permite iniializarea zonei de memorie alocate. Dac alocarea 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 memorie alocat. Operatorul delete elibereaz o zon din 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 alocat anterior printr-un operator new. Operatorul delete trebuie s fie folosit doar cu un pointer valid, alocat numai cu new i care nu a fost modificat sau nu a mai fost eliberat zona de memorie mai nainte (cu un alt operator delete sau prin apelul unei funcii free()). Folosirea operatorului delete cu un pointer invalid este o operaie cu rezultat nedefinit, cel mai adesea producnd erori de execuie grave. Cea de-a doua form a operatorului delete[] se folosete pentru eliberarea unei zone de memorie ocupat de un vector de date. Pentru tipurile de date predefinite ale limbajului, se poate folosi i prima form pentru eliberarea unui vector, dar, n cazul obiectelor de tipuri definite de utilizator, acest lucru nu mai este valabil. Aceast situaie va fi detaliat n 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 legtur cu cele dou metode de alocare dinamic, prin operatorii new-delete i prin funciile de bibliotec malloc-free, fr s fie o regul precis, se recomand evitarea combinrii lor, deoarece nu exist garania compatibilitii ntre ele.

18

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 s contin 3 instructiuni de afisare cout. (c) Comentariile dintr-un program C++ determin afisarea textului aflat dup // pe ecran la executia programului. (d) n limbajul C++ toate variabilele locale trebuie declarate la nceputul functiei de care apartin.
1.2 Descriei pe scurt diferena dintre funciile care returneaz valoare i cele care returneaz referin.

1.3 Presupunnd c variabilele a si b au valorile 3, respectiv 4, s se precizeze ce anume se va afisa pe ecran ca urmare a executiei urmtoarelor instructiuni: (a) cout << a+b; (b) cout << a=; (c) cout << a= << a; (d) cin >> a >> b; (e) // cout << a+b= << a+b; (f) cout << \n\t; (g) cout << a*b << = << b*a; (h) cout << a; (i) s = a+b; 1.4 Care sunt principalele diferente ntre programarea orientat pe obiecte si programarea procedural? 1.5 Care sunt principalele mecanisme de abstractizare? 1.6 Cum se numesc TDA-urile n programarea orientat pe obiecte? 1.7 Care sunt elementele principale ale unui TDA? 1.8 De ce sunt considerate a fi inteligente obiectele? 1.9 Dati exemple de clase si obiecte ale acestora. 1.10 Obiectele pot comunica ntre ele? Justificati rspunsul. 1.11 Care din urmtoarele concepte sunt concepte de baz ale programrii orientate pe obiecte? (a) obiect (b) mostenire (c) metod 19

(d) ncapsulare (e) modul (f) procedur (g) polimorfism (h) stream (i) cout 1.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 mod similar cu definitia TDA STIVA. 1.14 S se scrie declaraiile pentru urmtoarele tipuri de variabile: pointer la un caracter, un vector de 10 valori ntregi, pointer la un vector de 10 valori ntregi, un pointer la un pointer la un caracter. 1. 15 S se scrie un program care tiprete dimensiunea tipurilor fundamentale de date. Se va folosi 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 si atribuire); 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, tablouri de obiecte, pointeri la metode)

Un tip de date ntr-un limbaj de programare este o reprezentare a unui concept. De exemplu, tipul float din C++, mpreun cu operaiile definite asupra acestuia (+, -, *, etc.) reprezint o versiune a conceptului matematic de numere reale. Pentru alte concepte, care nu au o reprezentare direct prin tipurile predefinite ale limbajului, se pot defini noi tipuri de date care s specifice aceste concepte. O clas este un tip de date definit de utilizator. O declarare a unei clase definete un tip nou care reunete date i funcii. Acest tip nou poate fi folosit pentru a declara obiecte de acest tip, deci un obiect este un exemplar (o instan) a unei clase. Definitie. O clas este implementarea unui TDA. Ea defineste atribute si metode care implementeaz structuri de date si operatii ale TDA-ului. Definitie. Un obiect este o instant a unei clase. El este unic identificat de numele lui si defineste o stare care este reprezentat de valorile atributelor, la un moment dat. Starea unui obiect se schimb n raport cu metodele care i sunt aplicate. Definitie. Comportamentul unui obiect este definit de multimea metodelor care i pot fi aplicate. Definitie. O metod este o functie asociat unei clase. Un obiect apeleaz (invoc) o metod drept reactie la primirea unui mesaj.

21

Primul pas pentru gruparea datelor si metodelor de prelucrare, l-au reprezentat stucturile; ele permiteau declararea unor ansambluri eterogene de date ce erau manipulate unitar. Consideram structura angajat care 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 p1 angajat tablouangajat[10]; // un tablou cu zece elemente de tip angajat angajat *a2; // un pointer catre o structura de tip angajat a2 angajat &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 ->. 9 Operatorul . acceseaz o structur sau un membru al unei clase prin numele variabilei pentru obiect sau printr-o referint la obiect. 9 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. Functia afisare( ) are rolul de a afisa datele unui angajat. Programul realizeaz constructia tipului de data abstract angajat prinn definirea unei structuri , setarea valorilor pentru cmpurile structurilor (membrii structurilor) si afisarea acestora.
// fisierul sursa P2_1.c #include <stdio.h> #include <conio.h> #include <string.h> // definitia structurii angajat struct angajat { char num[20]; int varsta; float salariul; } a1 = {"Pop", 28,1530}; // definitia functiei de afisare a datelor unei angajat void 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 datele membru) si comportament (reprezentat de functiile membru, numite si metode). Practic, o clas ncapsuleaz o multime de valori si o multime de operatii. Sintaxa definirii unei clase:
class <nume_clas> { private: // membrii privati public: // membrii publici protected: // membrii protejati };

Cuvntul-cheie class introduce declaraia clasei (a tipului de date) cu numele nume_clasa. Dac este urmat de corpul clasei (cuprins ntre acolade), aceast declaraie este totodat o definiie. Dac declaraia conine numai cuvntul-cheie class i numele clasei, atunci aceasta este doar o declaraie de nume de clas. Corpul clasei conine definiii de date membre ale clasei i definiii sau declaraii de funcii membre ale clasei, desprite printr-unul sau mai muli specificatori de acces. Un specificator_acces poate fi unul din cuvintele-cheie din C++:
public private protected

Specificatorii private i protected asigur o protecie de acces la datele sau funciile membre ale clasei respective, iar specificatorul public permite accesul la acestea i din afara clasei. Efectul unui specificator de acces dureaz pn la urmtorul specificator de acces. Implicit, dac nu se declar nici un specificator de acces, datele sau funciile membre sunt de tip private. De aceea, toate datele sau funciile declarate de la nceputul blocului clasei pn la primul specificator de acces sunt de tip private. ntr-o declaraie de clas se poate schimba specificatorul de acces ori de cte ori se dorete: unele declaraii sunt trecute public, dup care se poate reveni la declaraii private, etc. Diferena ntre tipurile de acces private i protected const n modul n care sunt motenite drepturile de acces n clase derivate.

23

Definirea obiectelor Dup definirea unei clase C, aceasta poate fi utilizat ca tip n definirea obiectelor, tablourilor de obiecte si a pointerilor, astfel:
C C C C o1, // obiect de tip C Tablou[20], // tablou de obiecte de tip C *ptrC, // pointer la un obiect de tip C &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 ale clasei. 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 membru private nu pot fi accesate dect n cadrul metodelor clasei respective. Programul 2.2 implementeaz tipul de date angajat sub forma unei clase C++. Clasa angajat cuprinde datele membre: varsta, salariul, nume si functii membre: init() pentru initializarea datelor membre, functiia membra de acces spune_varsta(), functia afisare() pentru afisarea datelor membre.
class angajat { private: int varsta; protected float 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<<nume: <<nume<<endl; cout<<varsta: <<varsta<<endl; cout<<salariul: <<salariul; } } void main() { angajat a; a.init(); // apelul functiei membre init() pentru obiectul a

24

cout<<a.spune_varsta();//apelul functiei membre soune_varsta() pentru obiectul a }

Dupa rolul pe care il joaca in cadrul clasei, functiile membre ale unei clase se impart in patru categorii: 9 constructori, responsabili cu crearea obiectelor; 9 destructor, reponsabil cu distrugere obiectelor si eliberarea memoriei ocupate de acesta; 9 functii de acces, care mediaza legatura obiectului cu exteriorul; 9 metode, functii care introduc operatiile si prelucraile specifice obiectului.

2.2 Constructori si destructor

Utilizarea unor funcii membre ale unei clase, aa cum este funcia init() din clasa angajat, pentru iniializarea obiectelor este neelegant i permite strecurarea unor erori de programare. Deoarece nu exist nici o constrngere din partea limbajului ca un obiect s fie iniializat (de exemplu, nu apare nici o eroare de compilare dac nu este apelat funcia init() pentru un obiect din clasa angajat), programatorul poate s uite s apeleze funcia de iniializare sau s o apeleze de mai multe ori. n cazul simplu al clasei prezentate ca exemplu pn acum, acest lucru poate produce doar erori care se evideniaz uor. n schimb, pentru alte clase, erorile de iniializare pot fi dezastruoase sau mai greu de identificat. Din aceast cauz, limbajul C++ prevede o modalitate elegant i unitar pentru iniializarea obiectelor de tipuri definite de utilizator, prin intermediul unor funcii speciale numite funcii constructor (sau, mai scurt, constructori). Constroctorul este o functie membra speciala care este apelata automat atunci cand este creat un obiect. El poarta numele clasei si nu are nuci un tip la intoarcere, deoarece este apelat automat. Principalele motivatii pentru care se utilizeaza constructorii sunt: - complexiatatea structurii obiectelor date de de existenta variabilelor si functiilor, de existenta sectiunii privata, publica si protejata, face dificila initializarea directa a obictelor; - exista situatii in care doar unele date membre trebuie intializate, altele sunt incarcate in urma apelarii unor metode; - datele de obicei sunt declarate in sectiunea private si deci nu pot fi accesate din exterior ci prin intermediul metodelor. O clasa poate mentiona mai multi construcori, prin supraincarcare, folosirea unuia dintre ei la declararea unei variabile de clasa data, fiind dedusa in functie de numarul si tipul parametrilor de apel. Vom redefinii calsa angajat pentru care vom defini doi constructori asfel:
class angajat {int varsta; float salariul; char nume[20]; public: angajat() { strcpy(nume,Noname); varsta=0;salariul=0}

25

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 angajat s-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 cu argumente. Constructorii definiti mai sus se pot apela asfel: angajat a1 // aplelul constructorului implicit angajat a2(Pop,28,1200) //apelul constructorului cu argumente. Daca clasa nu mentioneaza nici un constructor, atunci se defineste automat de catre compilator un constructor care este utilizat pentru generarea de obiecte ale casei respective. In multe aplicatii este recomandat ca o clasa sa mentoineze mai multi constructori deoarece modurile 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 Complex care descrie un numar cpmplex. Clasa contine datele membre partea reala a numarului complex re, partea imaginara a numarului complex im. Sunt definiti trei constructori Complex(), Complex (double v), Complex ( double x, double y) precum si o functie membra care permite afisarea datelor unui numar complex.
#include <iostream.h> class Complex{ double re; double im; public: Complex(){cout << "Constructor fara argumente\n"; re = 0; im = 0; } Complex(double v){cout << "Constructor cu 1 arg\n"); re = v; im = v; } Complex(double x, double y){

26

cout << "Constructor cu 2 arg\n"; re = x; im = y; } void afisare() {cout<<partea reala<<re<<endl; Cout<<partea imaginara<<im; }; void main (){ Complex c1; Complex c2(2); Complex c3(3,5); }

La execuia funciei main(), sunt afisate urmtoarele mesaje:

Constructor fara argumente Constructor cu 1 arg Constructor cu 2 arg

n fiecare dintre aceste situaii a fost creat un obiect de tip Complex, c1, c2, c3 i de fiecare dat a fost apelat constructorul care are acelai numr i tip de argumente cu cele de apel. Dintre modurile de intializare amintite mai sus, un rol important o are intializarea unui obiect prin copierea datelor unui alt obiect de acelai tip. Aceast operaie este posibil prin intermediul unui constructor mai special al clasei, numit constructor de copiere. Forma general a constructorului de copiere al unei clase X este:
X::X(X& r){ } // initializare obiect folosind referina r

Constructorul primete ca argument o referin r la un obiect din clasa X i iniializeaz obiectul nou creat folosind datele coninute n obiectul referin r. Pentru crearea unui obiect printr-un constructor de copiere, argumentul transmis trebuie s fie o referin la un obiect din aceeai clas. De exemplu, pentru obiecte de tip Complex:
void main(){ Complex c1(2,3); // Constructor initializare Complex c2(c1); // Constructor copiere Complex c3 = c2; // Constructor copiere c3.afisare(); // afiseaza 2 3 }

La crearea primului obiect c1 este apelat constructorul de iniializare cu dou argumente al clasei Complex. Cel de-al doilea obiect c2 este creat prin apelul constructorului de copiere al clasei Complex, avnd ca argument referina la obiectul c1. Este posibil i declaraia de forma Complex c3 = c2; a unui obiect prin care se apeleaz, de asemenea, constructorul de copiere.

27

Constructorul de copiere poate fi definit de programator; dac nu este definit un constructor de copiere al clasei, compilatorul genereaz un constructor de copiere care copiaz datele membru cu membru din obiectul referin n obiectul nou creat. Aceast modalitate de copiere mai este denumit copie 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 arat astfel:
Complex(Complex &r) { cout << Constructor copiere\n; re = r.re; im = r.im; }

Importanta constructorului de copiere este subliniata de situatia in care datele membre ale unei clase sunt alocate dinamic. Constructorul de copiere generat implicit de compilator copiaz doar datele membre declarate n clas (membru cu membru) i nu tie s aloce date dinamice pentru obiectul nou creat. Folosind un astfel de constructor, se ajunge la situaia c dou obiecte, cel nou creat i obiectul referin, s conin pointeri cu aceeai valoare, care indic spre aceeai zon din memorie. O astfel se situaie este o surs puternic de erori de execuie subtile i greu de depistat. Exemplificam acest caz definind clasa angajat asfel:
class angajat {float salariul; public: char *nume; angajat(char *n,int s) {int nr=strlen(n); nume=new char[nr];// alocare dinamica pentru sirul nume strcpy(nume,n); salariul=s; } int spune_salariul(){return salariul;} } void main() { angajat a1(Popescu,35); angajat a2=a1; strcpy(a2.nume,Ion); cout<<a1.nume<< <<a1.salariul<<endl; cout<<a2.nume<< <<a2.salariul; }

Dupa rularea programului se va afisa:

Ion Ion

35 35

La construirea obiectului a2 s-a aplelat constructorul de copiere implicit care a copiat membrul nume al obiectului a1, dar nu a realizat alocarea dinamica. Asfel, obiectele a1 si a2 folosesc aceeasi zona de memorie alocata pentru campul nume. 28

Se observa asfel, necesiatea de a introduce in clasa amgajat un constructor de copiere care sa aloce explitit memorie , dupa care sa faca copierea continutului zonei de memorie a obiectului sursa 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<<a1.nume<< <<a1.salariul<<endl; cout<<a2.nume<< <<a2.salariul; } Rezultatul afisat prin rularea aceeluiasi program este: Popescu Ion

35 35

In concluzie, pentru un obiect cu un membru pointer spre o zona alocata dinamic progrmatorul va furniza un contructor de copiere care sa aloce memorie pentru noul obiect. Multe clase definite ntr-un program necesit o operaie care efectueza tergerea complet a obiectelor. O astfel de operaie este efectuat de o funcie membr a clasei, numit funcie destructor. Cand este declarat explicit in cadrul calsei, destructorul porta numele clasei, precedat de semnul ~ (de ex. ~angajat()). Destructorul, spre deosebire de constructor, este unic si nu are parametrii de apel. Dac programatorul nu defineste un destructor explicit, compilatorul C++ va genera unul implicit. Destructorul generat de compilator apeleaz destructorii pentru variabilele membru ale clasei. Membrii unei clase sunt ntotdeauna distrusi n ordinea invers celei n care au fost creati.

29

#include <iostream.h> class Complex { double re; double im; public: Complex(double x, double y){ cout << "Constructor cu 2 arg\n"; re = x; im = y; } ~Complex(){cout << "Destructor"; } Void main() { Complex z(3,4); }

Rezultatul afisat dupa rularea programului este:

Constructor cu 2 arg Destructor Se observa in programul anterior ca nu s-a realizat un apel explicit al destructorului. Acesta a fost apelat automat la sfarsitul programului. Destructorii sunt apelai implicit si in alte situaii, cum ar fi: atunci cnd un obiect local sau temporar iese din domeniul de definiie; la apelul operatorului delete, pentru obiectele alocate dinamic.

Pointerul this Fiecare obiect al unei clase are acces la propria adres prin intermediul unui pointer numit this. Acest pointer este utilizat n mod implicit pentru referirea att la membrii date ct si la functiile membru ale unui obiect. El poate fi utilizat si explicit cand se doreste folosirea adresei obiectului. Adresa obiectului, desi este transparenta pentru utilizator, exista memorata intr-un pointer numit this. Ca expemplul vom defini, in programul 2.3, o clasa care va contine o metoda ce utilizeza pointerul this.
class C { int x; public: C(int a){ x=a;} void afisare(){ cout<<this->x;} } void main() {C ob(7); ob.afisare; }

30

2.3 Tablouri de obiecte

n limbajul C++ implementarea tablourilor de obiecte se poate realiza cu conditia respectrii urmtoarei 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() {cout<<Numele: cin>>nume; cout>>salariul: cin>>salariul; cout<<varsta cin>>varsta; } void afisare() {cout<<nume: <<nume<<endl; cout<<varsta: <<varsta<<endl; cout<<salariul: <<salariul; } } void main() { angajat tab[20]; // tablou static sau automatic int i, n; cout<<"\n Cate obiecte doriti sa creati?"; cin>>n; // initializeaza n obiecte for (i=0;i<n;i++)

31

tab[i].seteaza_valori(); // afiseaza cele n obiecte for (i=0;i<n;i++) tab[i].afisare(); }

2.4 Funcii i clase friend

Este cunscut deja faptul ca aceesul la mebrii unei clase declarati in sectiunile private si protected este restrictionat. Acestea pot fi utilizate doar de functiile membre ale clasei. Accesul la membrii unei clase poate fi ingadiut, totusi si unor functii externe clasei sau apartinand altor clase. Astfel de functii se numesc functii prietene clasei respective (functii friend) si sunt declarate astfel cu ajutorul specificatorului friend. Functiile friend raman externe, nefiind legate de clasa si cu atat mai putin de un obiect anume. Pentru a avea acces la datele unui obiect, functia friend trebuie sa primeasca drept parametru de intrare referinta la obiectul respectiv. Declararea unei funcii f() de tip friend se realizeaza in interiorul clasei iar funcia nsi se definete n alt parte n program astfel:
class C{ //.. friend tip_returnat f(lista_argumente); }; .. tip_returnat f(lista_argumente){ // corpul functiei } Programul P2.5 prezint un exemplu de declarare si utilizare a unei functii friend a clasei Nr_Complex, modulul(), care calculeaz modulul unui numar complex.

// fisierul sursa P2_5.cpp #include <iostream.h> #include <math.h> class Complex { double re, im; public: Complex(double x, double y) { real = x; imag = y; } friend double modul(Complex &); };
double abs(Nr_Complex& z) { return sqrt(z.real*z.real+z.imag*z.imag); }

32

void main() { Complex Z=Complex(3,4); cout<<"\n Modulul lui numarului complex z este "<< modul(Z); }

Trebuie subliniat faptul ca utilizarea functiilor friend trebuie fcut cu mare grij ntruct acestea ncalc principiul ncapsulrii, respectiv, ascunderea informatiei, principiu fundamental n POO. Avantajul principal al declarrii unei functii friend este accesul rapid pe care aceasta l are direct la membrii privati ai clasei cu care este prieten.

2.5 Funcii inline

n programare aplelul functiilor poate produce un cost ridicat de execuie, datorit operaiilor necesare pentru rezervarea spaiului n stiv, pentru transferul argumentelor i returnarea unei valori. Pentru a reduce timpul de executii C++ pune la dispozitie functii inline. n general, o funcie declarat inline se schimb la compilare cu corpul ei, i se spune c apelul funciei se realizeaz prin expandare. n felul acesta se elimin operaiile suplimentare de apel i revenire din funcie. Dezavantajul funciilor inline este acela c produc creterea dimensiunilor programului compilat, de aceea se recomand a fi utilizate pentru funcii de dimensiuni mici (maximum 3-4 instruciuni). n plus, mai exist i unele restricii privind funciile inline: ele nu pot fi declarate funcii externe, deci nu pot fi utilizate dect n modulul de program n care au fost definite i nu pot conine instruciuni ciclice (while, for, do-while). n cazul claselor, functiile membru care sunt definite n interiorul clasei devin n mod implicit inline. n cazul n care le definim n afara clasei si vrem s fie inline trebuie s utilizm sintaxa declarrii unei functii inline. Sintaxa declarrii unei functii inline:
inline <tip> <nume_functie>([<lp>])

unde <tip> reprezint tipul ntors de functie, iar <lp> lista de parametri. Programul P2.6 prezint un exemplu de definire si utilizare a unei functii inline pentru calculul ariei unui patrat cu latura data, arie_patrat() .

// fisierul sursa P2_6.cpp #include <iostream.h> inline double arie_patrat(double a) { return a*a; }

33

void main() { double x; cout<<"\n Latura patratului:"; cin>>x; cout<<"\n Aria patratului este "<<arie_patrat(x); }

2.6 Date si functii statice

Implicit membrii de date sunt alocati pe obiecte. De exemplul fiecare angajat al unei firme are propiul sau nume, cnp etc. Exista, insa unele propietati care sunt impartite de catre toate obiectele unei clase, cum ar fi de exemplul, pentru clasa angajat, numarul total de angajati ai unei firme, salariul mediu al firmei etc. O varinata posibila ar fi stocarea acestor informatii intr-o variabila globala uzuala. De exemplu, am putea utiliza o variabila de tip intreg pentru a pastra numarul de obiecte angajat. Problema acestei solutii este ca variabilele globale sunt declarate in afara clasei; pentru putea fi aduse in interiorul calsei aceste variabile trebuie sa fie declarate de tip static. Datele statice nu se regasesc in fiecare set de valori ale clasei, ci intr-un singur exemplar, pentru toate obiectele clasei. Datele ce apar in toate obiectele se aloca de catre un constructor , dar cum un membru static nu face parte din nici un obiect, nu se aloca prin constructor. Asfel, la definirea clasei, o data statica nu se considera definita, ci doar declarata, urmand a avea o definitie externa clasei. Legatura cu declaratia din interiorul clasei se face prin operatorul de rezolutie :: precedat de numele clasei din care face parte precum si de tipul variabilei statice, asfel:
class angajat { //... Static int total_ang; //... } int angajat::total_ang=0;;

Variabila total_ang va fi unica pentru toti angajatii. Se poate observa ca o data cu definirea varbilei statice s-a realizat si intializarea acesteia. Functiile membre statice efectueaza prelucrari care nu sunt individualizate pe obiecte, ci prelucrari care au loc la nivelul clasei. Functiile statice nu apartin unui obiect anume si deci nu beneficiaza de referinta implicita a obiectului asociat (pointerul this). Daca functia membra statica opereaza pe o data nestatica a clasei, obiectul trebuie transmis explicit ca parametru , in timp ce cu datele membre statice , lucreaza in mod direct. Programul 2.7 redefineste clasa angajat, prin adaugarea datelor membre statice total_ang si total_b care vor retine numarul total de angajati si numarul total de barbati. Clasa va contine si trei functii membre statice care vor returna valorile retinute in cele doua date statice.

34

// fisierul sursa P2.7.cpp class 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() {cout<<Numele: cin>>nume; cout>>salariul: cin>>salariul; cout<<varsta cin>>varsta; } 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<<nume: <<nume<<endl; cout<<varsta: <<varsta<<endl; cout<<salariul: <<salariul; } } int angajat::total_ang=0; int angajat::total_b=0; void main() { angajat tab[20]; int i, n; cout<<"\n Cate obiecte doriti sa creati?"; cin>>n; for (i=0;i<n;i++) {tab[i].seteaza_valori(); angajat::numara_total_b(&tab[i]); }

35

cout<<firma are un total de angajati<<angajat::spune_total_ang; cout<<din care<<angajat::spune_total_b<< sunt barbati; }

In programul de mai sus se remarca faptul ca intretinerea variabilei total_ang cade in sarcina constructorilor si a destructorului, care incrementeaza sau decrementreaza acesta variabila. De asemenea, functia membra statica numara_total_b() primeste ca parametru referinta la un obiect de tip angajat pentru ca utilizeaza data membra gen care nu este statica. ntruct variabilele membru statice nu apartin unui obiect anume, ele pot fi accesate si prin prefixarea numelui clasei de operatorul ::.

36

Teste de autocontrol 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 la datele sale neasigurnd consistenta acestora. (d) Structurile C nu pot fi afisate ca o singur entitate si nu pot fi comparate dect membru cu membru. 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 destructor 2.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 drept exemplu 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 clasei cu 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 tablourilor de 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 (functii membru). (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 din care 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 va conine atia constructori ct sunt necesari pentru urmtoarele definiii de obiecte:
Date Date Date Date d1(15, 3, 99); // zi, lun, an d2(20, 4); // zi, lun, an curent d3(18); // zi, lun curent, an curent d4; // zi curent,lun curent, an curent

2.9 Construiti clasa student care 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 global numbers memoreaz numrul obiectelor n via la un moment dat:
#include <iostream.h> int numbers = 0; class Item { public: Item(){ // constructorul creste cu 1 nr obiectelor numbers++; cout << "Nr. obiecte " << numbers << endl; } ~Item() { // destructorul descreste cu 1 nr ob. numbers--; cout << "Nr. obiecte " << numbers << endl; } }; void main() { Item ob1, ob2, ob3; { // se deschide un nou bloc Item ob4, ob5; } Item *pob6 = new Item[3]; delete [] pob6; }

Care sunt mesajele care apar la consol la execuia acestui program? S se explice evoluia numrului de obiecte n via n cursul execuiei.

38

2.11 Construiti clasa credite care contine datele membre private val_credit, nr_cont, si date membre 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 clasa pacient care contine datele private: vrsta, profesie, salariul i data membra public nume. Realizai: a). un tablou de 10 obiecte de tipul clasei definit anterior; b). funcii membre de acces la datele private ale clasei; c). numarul pacientilor care au varsta peste media vrstelor utiliznd o funcie membr static; d). realizai o funcie operator pentru a calcula suma veniturilor pentru pacienii cu acelai nume 2. 13 Realizai clasa fractie care cuprinde datele membre private :numitor, numarator. 1. realizai funcii de acces la datele membre ale clasei definit anterior; 2. realizai funcii membre pentru a calcula suma si inmultirea a doua fractii, utlizand functii operator; 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 execut fiecare constructor n programul de mai jos i n ce ordine.
#include <iostream.h> 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<<ob.f(ob); return 0; }

2.15 Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, altfel, spunei de ce nu este corect. #include <iostream.h>
class cls1 { int x; public: cls1(){ x=13; } int g(){ static int i; i++; return (i+x); } }; class cls2 { int x; public: cls2(){ x=27; } cls1& f(){ static cls1 ob; return ob; } };

39

int main() { cls2 ob; cout<<ob.f().g(); return 0; }

2.16 Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, altfel, spunei de ce nu este corect. #include <iostream.h>
class cls1 { protected: int x; public: cls1(int i=10) { x=i; } int get_x() { return x;} }; class cls2: cls1 { public: cls2(int i):cls1(i) {} }; int main() { cls d(37); cout<<d.get_x(); return 0; }

40

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 prin adugarea unor funcionaliti claselor deja existente, fr s fie necesar reprogramarea sau recompilarea acestora. Clasele derivate exprim relaii ierarhice ntre conceptele pe care acestea le reprezint i asigur o interfa comun pentru mai multe clase diferite. De exemplu, entitile cerc, triunghi, dreptunghi, sunt corelate ntre ele prin aceea c toate sunt forme geometrice, deci ele au n comun conceptul de form geometric. Pentru a reprezenta un cerc, un triunghi sau un dreptunghi, ntr-un program, trebuie ca aceste clase, care reprezint fiecare form geometric n parte, s aib n comun clasa care reprezint n general o form geometric. Mostenirea reprezint o form de implementare a reutilizrii codului. Ea apare n urma crerii de noi clase prin operatia de derivare. Derivarea reprezint definirea unei noi clase prin extinderea uneia sau a mai multor clase existente. 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 numeste mostenire singular. Limbajul C++ accept existenta mai multor clase de baz. O clas derivat mosteneste toti membrii tuturor claselor sale de baz. Adic, clasa derivat contine toate variabilele membru continute n clasele de baz si suport toate operatiile furnizate de clasele de baz. O clas derivat poate fi la rndul ei clas de baz pentru noi clase. Astfel se poate genera o ierarhie de clase (graf de mostenire). Sintaxa declarrii unei clase derivate dintr-o clas de baz :
class <clasa_derivat> : public <clasa_de_baz> { // membrii clasei derivate };

Mostenirea sau relatia de derivare este indicat n antetul clasei derivate prin cuvntul cheie public prefixat de caracterul : si urmat de numele clasei de baz. n cadrul relatiei de mostenire poate apare n clasa de baz o sectiune protejat, marcat prin cuvntul cheie protected, care permite accesul claselor derivate din ea la datele si functiile membru 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 si protejate 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 consider un program P3.1 care descrie organizarea personalului unei instituii fr folosirea claselor derivate. O clas numit Angajat deine date i funcii referitoare la un angajat al instituiei:
class Angajat{ char *nume; float salariu; public: Angajat(); Angajat(char *n, float sal); Angajat(Angajat& r); void display(); }; Angajat::display(){ cout << nume << << salariu << endl; }

Diferite categorii de angajai necesit date suplimentare fa de cele definite n clasa Angajat, corespunztoare postului pe care l dein. De exemplu, un aministrator este un angajat (deci sunt necesare toate datele care descriu aceast calitate) dar mai sunt necesare i alte informaii, de exemplu precizare seciei pe care o conduce. De aceea, clasa Administator trebuie s includ un obiect de tipul Angajat, la care adaug alte date:
class Administrator{ Angajat ang; int sectie; public: void display(); }

Posibilitatea de a include ntr-o clas date descrise ntr-o alt clas are n limbajele orientate pe obiecte un suport mai eficient i mai simplu de utilizat dect includerea unui obiect din tipul dorit: derivarea claselor, care motenesc (date i funcii membre) de la clasa de baz. Un administrator este un angajat, de aceea clasa Administrator se poate construi prin derivare din clasa Angajat astfel:

42

class Administrator : public Angajat { int sectie; public: void display(); } In clasa Administrtrator nu se pot aceesa datele private din clasa Angajat, chiar data tipul mostenerii este public. Asa cu s-a subliniat inainte, datele private ale clasei de baza nu pot fi utilizate de catre clasa derivata. Metoda cea mai adecvat de acces la membrii private clasei de baz din clasa derivat este prin utilizarea funciilor membre publice ale clasei de baz. De exemplu, nu se poate implementa funcia display() din clasa Administrator prin accesarea membrilor private ai clasei Angajat: void Administrator::display(){ cout << nume << << salariu << endl; // eroare cout << sectie << endl; } n schimb, se poate folosi funcia membr public display() a clasei Angajat: void Administrator::display(){ Angajat::display(); cout << sectie << endl; }

Redefinirea funciei display() n clasa derivat ascunde funcia cu acelai nume din clasa de baz, de aceea este necesar calificarea funciei cu numele clasei de baz folosind operatorul de rezoluie: Angajat::display(). Din clasa derivat (n funcii membre ale acesteia sau pentru obiecte din clasa derivat) este accesat membrul redefinit n clasa derivat. Se spune c membrul din clasa de baz este ascuns (hidden) de membrul redefinit n clasa derivat. Un membru ascuns din clasa de baz poate fi totui accesat dac se folosete operatorul de rezoluie (::) pentru clasa de baz. De exemplu:
class Base { public: int a, b; } class Derived { public: int b, c; // b este redefinit }; void fb() { Derived d; d.a = 1; // a din Base d.Base::b = 2; // b din Base d.b = 3; // b din Derived d.c = 4; // c din Derived }

43

3.2 Constructori i destructori n clasele derivate

Constructorii i destructorii sunt funcii membre care nu se motenesc. La crearea unei instane a unei 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 baz este cea din lista claselor de baz din declaraia clasei derivate. Constructorii nu se pot redefini pentru c ei, n mod obligatoriu, au nume diferite (numele clasei respective). La distrugerea unui obiect al unei clase derivate se apeleaz implicit destructorii n ordine invers: mai nti destructorul clasei derivate, apoi destructorii claselor de baz, n ordinea invers celei din lista din declaraie. La instanierea unui obiect al unei clase derivate, dintre argumentele care se transmit constructorului acesteia o parte sunt utilizate pentru iniializarea datelor membre ale clasei derivate, iar alt parte sunt transmise constructorilor claselor de baz. Argumentele necesare pentru iniializarea claselor de baz sunt plasate n definiia (nu n declaraia) constructorului clasei derivate. Un exemplu simplu, n care constructorul clasei derivate D transfer constructorului clasei de baz B un numr de k argumente arat astfel:
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: <construct_cls_derivata>(<L1>) : <construct_cls_baza>(<L2>) { // corpul constructorului clasei derivate }

<L1> reprezint lista de argumente ale constructorului clasei derivate, iar <L2> lista de argumente ale constructorului clasei de baz. Lista <L1> include lista <L2>. Observatii: Constructorii si destructorul clasei de baz nu se mostenesc.

44

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

3.3 Controlul accesului la membrii clasei de baz

Accesul la membrii clasei de baz motenii n clasa derivat este controlat de specificatorul de acces (public, protected, private) din declaraia clasei derivate. O regul general este c, indiferent de specificatorul de acces declarat la derivare, datele de tip private n clasa de baz nu pot fi accesate dintr-o clas derivat. O alt regul general este c, prin derivare, nu se modific tipul datelor n clasa de baz. Un membru protected ntr-o clas se comport ca un membru private, adic poate fi accesat numai de membrii acelei clase i de funciile de tip friend ale clasei. Diferena ntre tipul private i tipul protected apare n mecanismul de derivare: un membru protected al unei clase motenit ca public ntr-o clas derivat devine tot protected n clasa derivat, adic poate fi accesat numai de funciile membre i friend ale clasei derivate i poate fi transmis mai departe, la o nou derivare, ca tip protected. Motenirea de tip public a clasei de baz Dac specificatorul de acces din declaraia unei clase derivate este public, atunci: Datele de tip public ale clasei de baz sunt 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 baz sunt 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 membrii clasei de baz din clasa derivat atunci cnd specificatorul de acces este public.
class Base { inta; protected: int b; public: int c; void seta(int x){a = x; cout << "seta din baza\n";} void setb(int y){b = y; cout << "setb din baza\n";} void setc(int z){c = z; cout << "setc din baza\n";} }; class Derived : public Base { int d; public: void seta(int x) { a = x; // eroare, a este private } void setb(int y) {

45

b = y; cout << "setb din derivata\n"; } void setc(int z) { c = z; cout << "setc din derivata\n"; } }; void fb(){ Derived obd; obd.a = 1; // eroare, a este private in baza obd.seta(2); // corect, se apeleaz baza::seta obd.b = 3; // eroare, b este protected obd.Base::setb(5);// corect, Base::setb este public obd.setb(4); // corect, Derived::setb este public obd.c = 6; // corect, c este public obd.Base::setc(7);// corect, Base::setc este public obd.setc(8); // corect, Derived::setc este public }

Dac se comenteaz liniile de program care provoac erori i se execut funcia fb(), se obin urmtoarele mesaje la consol:
seta setb setb setc setc din din din din din baza baza derivata baza derivata

Motenirea de tip protected a clasei de baz Dac specificatorul de acces din declaraia clasei derivate este protected, atunci toi membrii de tip public i protected din clasa de baz devin membri protected n clasa derivat. Bineneles, membrii de tip private n clasa de baz nu pot fi accesai din clasa derivat. Se reiau clasele din exemplul precedent cu motenire protected:
class Derived : protected Base { // acelasi corp al clasei };

n aceast situaie, n funcia fb() sunt anunate ca erori de compilare toate apelurile de funcii ale clasei de baz pentru un obiect derivat, precum i accesul la variabila c a clasei de baz:
void fb(){ Derived obd; obd.a = 1; // eroare, a este private in baza obd.seta(2); // eroare, Base::seta()este protected obd.b = 3; // eroare, b este protected

46

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

Dac se comenteaz toate liniile din funcia fb() care produc erori, la execuia acesteia se afieaz urmtoarele rezultate:
setb din derivata setc din derivata

Din acest exemplu reiese pregnant faptul c n motenirea protected a unei clase de baz nu mai pot fi accesai din afara clasei derivate nici unul dintre membrii clasei de baz. Motenirea de tip private a clasei de baz Dac specificatorul de acces din declaraia clasei derivate este private, atunci toi membrii de tip public i protected din clasa de baz devin membri de tip private n clasa derivat i pot fi accesai numai din funciile membre i friend ale clasei derivate. Din nou trebuie reamintit c membrii de tip private n clasa de baz nu pot fi accesai din clasa derivat. Din punct de vedere al clasei derivate, motenirea de tip private este echivalent cu motenirea de tip protected. ntradevr, dac modificm 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 motenirea protected. Ceea ce difereniaz motenirea de tip private fa de motenirea de tip protected este modul cum vor fi trasmii mai departe, ntr-o nou derivare, membrii clasei de baz. Toi membrii clasei de baz fiind motenii de tip private, o nou clas derivat (care motenete indirect clasa de baz) nu va mai putea accesa nici unul din 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

Student

Angajat

Elev

Medic

Profesor

47

Fig. 3.4 Ierarhie de clase

Clasa de baz a ierarhiei de clase este clasa Persoana. Din aceast clas sunt derivate direct clasele Elev, Student si Salariat. La rndul ei clasa Salariat este clas de baz pentru clasele Medic si Profesor. Programul P3.3 prezint un exemplu de implementare a claselor Persoana, Salariat, Arhitect, Inginer si Medic. // fisierul sursa p3_5.cpp #include <iostream.h> #include <string.h> #include <assert.h> // 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 << "\n Nume: "<< nume << " Prenume: " << pren; } // definitia clasei Salariat derivata din clasa Persoana class Salariat : public Persoana { float salariu; public: Salariat(char *n, char *p, float s=0); void seteazaSalariu(float s); void afisare(); }; 48

Salariat::Salariat(char* n, char* p, float S) :Persoana(n, p) { seteazaSalariu(s); } void Salariat::seteazaSalariu(float S) { salariu = s; } void Salariat::afisare() { cout << "\n Salariat:"; Persoana::afisare(); cout << "\n Salariu:" << salariu; } // definitia clasei Inginer derivata din clasa Salariat class Inginer : public Salariat { char* domeniu; public: Inginer(char* n, char* p, float s, char* d); void seteazaDomeniu(char *d); void afisare(); }; Inginer::Inginer(char* n, char* p, float s, char * d) :Salariat(n, p, s) { domeniu = new char[strlen(d)+1]; strcpy(domeniu, d); } void Inginer::seteazaDomeniu(char* d) { strcpy(domeniu, d); } void Inginer::afisare() { cout << "\n Inginer "; Salariat::afisare(); cout << "\n\t Domeniu de lucru este " << domeniu; } class Profesor : public Salariat { char* tip; public: Profesor(char* n, char* p, float s, char* t); void seteazaTip(char *t); void afisare(); }; Profesor::Profesor(char* n, char* p, float s, char* t) :Salariat(n, p, s) {

49

tip = new char[strlen(t)+1]; strcpy(tip_inginer, t); } void Profesor::seteazaTip(char* t) { strcpy(tip_inginer, T); } void Profesor::afisare() { cout << "\n Profesor "; Salariat::afisare(); cout << "\n\t Tip profesor " << tip; } void main() { Persoana P1=Persoana("Popescu", "Ana"); Salariat S1=Salariat("Ion", "Alexandru", 2300); Inginer I1=Inginer("Syan", "Maria", 3400, "inginer civile"); Profesor PR1=Inginer("Pop", "Cristi", 2200, "informatica"); P1.afisare(); S1.afisare(); I1.afisare(); PR1.afisare(); } Mostenirea utilizat este cea public. Functia afisare() a fost redefinit n toate clasele derivate, ea apelnd varianta din clasa imediat urmtoare pe nivelul superior din ierarhia de clase. De exemplu, functia afisare() din clasa Salariat apeleaz functia afisare() din clasa Persoana astfel, Persoana::afisare();

Functia afisare() din clasele Inginer si Profesor apeleaz functia afisare() din clasa Salariat: Salariat::afisare();

3.4 Clase de baz virtuale

ntr-o motenire multipl este posibil ca o clas s fie motenit indirect de mai multe ori, prin intermediul unor clase care motenesc, fiecare n parte, clasa de baz. De exemplu:
class class class class L A B D { : : : public: int x;}; public L { /* */}; public L { /* */}; public A, public B { /* */};

Acest motenire se poate reprezenta printr-un graf aciclic direcionat care indic relaiile dintre subobiectele unui obiect din clasa D. Din graful de reprezentare a motenirilor, se poate observa faptul c baza L este replicat n clasa D.

50

Un obiect din clasa D va conine membrii clasei L de dou ori, o dat prin clasa A (A::L) i o dat prin 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 a clasei 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 A ob.B::x = 3; // corect, x din B

- crearea unei singure copii a clasei de baz n clasa derivat. Pentru aceasta este necesar ca acea clas care ar putea produce copii multiple prin motenire indirect (clasa L, n exemplul de mai sus) s fie declarat clas de baz de tip virtual n clasele care o introduc n clasa cu motenire multip. De exemplu:
class class class class L A B D { : : : public: int x; }; virtual public L { /* */ }; virtual public L { /* */ }; public A, public B { /* */ };

O clas de baz virtual este motenit o singur dat i creeaz o singur copie 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 virtual este o funcie care este declarat de tip virtual n clasa de baz i redefinit ntro clas derivat. Redefinirea unei funcii virtuale ntr-o clas derivat domin definiia funciei n

51

clasa de baz. Funcia declarat virtual n clasa de baz acioneaz ca o descriere generic prin care se definete interfaa comun, iar funciile redefinite n clasele derivate precizeaz aciunile specifice 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 membr a unui obiect dat cu numele lui, funciile virtuale se comport normal, ca funcii redefinite. n limbajele de programare, un obiect polimorfic este o entitate, ca de exemplu, o variabil sau argumentul unei functii, creia i se permite s pstreze valori de tipuri diferite n timpul executiei programului. Functiile polimorfice sunt acele functii care au argumente polimorfice. n limbajele de programare orientate pe obiecte, polimorfismul mpreun cu legarea dinamic reprezint una din 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 <tip_functie> <nume_functie> ([<lp>]); <tip_functie> reprezint tipul ntors de functie, <lp> este

Cnd un pointer al clasei de baz puncteaz la o functie virtual din clasa derivat si aceasta este apelat prin intermediul acestui pointer, compilatorul determin care versiune a functiei trebuie apelat, tinnd cont de tipul obiectului la care puncteaz acel pointer. Astfel, tipul obiectului la care puncteaz determin versiunea functiei virtuale care va fi executat. In programul P3.4 se consider o clas de baz B i dou clase derivate D1 i D2. n clasa de baz sunt definite dou funcii: funcia normal f()i funcia virtual g(). n fiecare din clasele derivate se redefinesc cele dou funcii f() i g(). n funcia main() se creeaz trei obiecte: un obiect din clasa de baz B indicat prin pointerul B* pb i dou obiecte din clasele derivate D1 i D2. Fiecare dintre obiectele derivate poate fi indicat printr-un pointer la clasa derivat respectiv (D1* pd1, respectiv D2* pd2), precum i printr-un pointer la baz corespunztor (B* pb1 = pd1, respectiv B* pb2 = pd2).
class B { public: void f() { cout << "f() din B\n"; } virtual void g(){ cout << "g() din B\n"; } }; class D1:public B { public: void f() { cout << "f() din D1\n"; } void g() { cout << "g() din D1\n"; } }; class D2:public B { public: void f() { cout << "f() din D2\n"; }

52

void g() { cout << "g() din D2\n"; } }; void fv1 { B* pb = new B; D1* pd1 = new D1; D2* pd2 = new D2; B* pb1 = pd1; B* pb2 = pd2; // f() este functie normala,g() este functie virtuala // Obiect B, pointer B* pb->f(); // f() din B pb->g(); // g() din B // Obiecte D1, D2 , pointeri D1*, D2* pd1->f(); // f() din D1 pd2->f(); // f() din D2 pd1->g(); // g() din D1 pd2->g(); // g() din D2 // Obiecte D1, D2 , pointeri B*, B* pb1->f(); // f() din B pb2->f(); // f() din B pb1->g(); // g() din D1 pb2->g(); // g() din D2 delete pb; delete pd1; delete pd2; };

n primele situaii, cnd pointerul este pointer la tipul obiectului, nu se manifest nici o deosebire ntre comportarea unei funcii virtuale fa de comportarea unei funcii normale: se selecteaz funcia corespunztoare tipului pointerului i obiectului. Diferena de comportare se manifest n ultima situaie, atunci cnd este apelat o funcie pentru un obiect de tip clas derivat printr-un pointer la o clas de baz a acesteia. Pentru funcia normal f() se selecteaz varianta depinznd de tipul pointerului. Pentru funcia virtual g() se selecteaz varianta n funcie de tipul obiectului, chiar dac este accesat prin pointer de tip baz. Polimorfismul, adic apelul unei funcii dintr-o clas derivat prin pointer de tip clas de baz, este posibil numai prin utilizarea pointerilor la obiecte. Obiectele nsele determin varianta funciei apelate, deci nu se pot selecta alte funcii dect cele ale obiectului de tipul respectiv. De exemplu, pentru aceleai clase definite ca mai sus, se consider funcia fv2():
void fv2(){ B obB; D1 obD1; D2 obD2; obB.f(); // f() din B obB.g(); // g() din B obD1.f(); // f() din D1 obD1.g(); // g() din D1

53

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

Observati Constructorii nu pot fi functii virtuale. n schimb, destructorii pot fi functii virtuale. Functiile inline nu pot fi virtuale. Functiile virtuale sunt ntotdeauna functii membru nestatice ale unei clase.

3.7

Clase abstracte

De cele mai multe ori, o funcie declarat de tip virtual n clasa de baz nu definete o aciune semnificativ i este neaprat necesar ca ea s fie redefinit n fiecare din clasele derivate. Pentru ca programatorul s fie obligat s redefineasc o funcie virtual n toate clasele derivate n care este folosit aceast funcie, se declar funcia respectiv virtual pur. O funcie virtual pur este o funcie care nu are definiie n clasa de baz, iar declaraia ei arat n felul urmtor: virtual tip_returnat nume_functie(lista_argumente) = 0; O clas care conine cel puin o funcie virtual pur se numete clas abstract. Deoarece o clas abstract conine una sau mai multe funcii pentru care nu exist definiii, nu pot fi create instane din acea clas, dar pot fi creai pointeri i referine la astfel de clase abstracte. O clas abstract este folosit n general ca o clas fundamental, din care se construiesc alte clase prin derivare. Orice clas derivat dintr-o clas abstract este, la rndul ei clas abstract (i deci nu se pot crea instane ale acesteia) dac nu se redefinesc toate funciile virtuale pure motenite. Dac o clas redefinete toate funciile virtuale pure ale claselor ei de baz, devine clas normal i pot fi create instane ale acesteia. Exemplul urmtor (5.6) evideniaz caracteristicile claselor abstracte i ale funciilor virtuale pure. Programul P3.5 se realizeaza conversia unor date dintr-o valoare de intrare ntr-o valoare de ieire; de exemplu, din grade Farenheit n grade Celsius, din inch n centimetri, etc.
class Convert{ protected: double x; // valoare intrare double 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 Celsius class FC: public Convert{ public: FC(double i):Convert(i){} void conv(){y = (x-32)/1.8;}

54

}; // clasa IC de conversie inch in centimetri class IC: public Convert{ public: IC(double i):Convert(i){} void conv(){y = 2.54*x;} }

void main (){ Convert* p = 0; // pointer la baza cout<<"Introduceti valoarea si tipul conversiei: "; double v; char ch; cin >> 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 << p->getx() << "---> " << p->gety()<< endl; delete p; } }

Clasa de baz abstract Convert este folosit pentru crearea prin derivare a unei clase specifice fiecrui tip de conversie de date dorit. Aceast clas definete datele comune, necesare oricrui tip de conversie preconizat, de la o valoare de intrare x la o valoare de ieire y. Funcia de conversie conv() nu se poate defini n clasa de baz, ea fiind specific fiecrui tip de conversie n parte; de aceea funcia conv() se declar funcie virtual pur i trebuie s fie redefinit n fiecare clas derivat. n funcia main() se execut o conversie a unei valori introduse de la consol, folosind un tip de conversie (o clas derivat) care se selecteaz pe baza unui caracter introdus la consol. Acesta este un exemplu n care este destul de pregnant necesitatea funciilor virtuale: deoarece nu se cunoate n momentul compilrii tipul de conversie care se va efectua, se folosete un pointer la clasa de baz pentru orice operaie (crearea unui obiect de conversie nou, apelul funciei conv(), afiarea rezultatelor, distrugerea obiectului la terminarea programului). Singura difereniere care permite selecia corect a funciilor, este tipul obiectului creat, care depinde de tipul conversiei cerute de la consol.

55

3.8

Polimorfism

Polimorfismul permite unei entitti (de exemplu, variabil, functie, obiect) s aib o varietate de reprezentri. El este furnizat att la momentul compilrii (legare timpurie), prin folosirea operatorilor 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 continutul ei la un moment dat. Aceast abilitate a variabilei se numeste polimorfism, iar variabila se numeste variabil polimorfic. n limbajul C++ variabilele polimorfice apar doar prin utilizarea pointerilor sau referintelor. n cazul n care un pointer al clasei de baz puncteaz ctre o functie virtual, programul va determina la momentul executiei la care tip de obiect puncteaza pointerul si apoi va selecta versiunea corespunztoare functiei redefinite. Programul P4.4 defineste clasa de baz Persoana si dou clase derivate, Student si Salariat. Clasa de baz Persoana este o clas abstract avnd declarat o functie virtual pur, venit(), definit n clasele derivate. De asemenea, clasa Persoana mai contine o alt functie virtual, afisare(), care este redefinit n clasele derivate. n programul principal sunt create dou obiecte S1 si T1 din clasele Student si respectiv Salariat. Pentru fiecare din cele dou obiecte se execut o secvent de patru instructiuni: primele dou instructiuni ilustreaz legarea static, prin apelul celor dou functii afisare() si venit(), corespunztoare obiectului referit prin nume; ultimele dou instructiuni ilustreaz legarea dinamic apelnd cele dou functii afisare() si venit() prin intermediul a dou functii, Ref_Pointer(.), Ref_Referinta(.), care utilizeaz un pointer, respectiv o referint ctre clasa de baz Persoana. Aceste ultime dou instructiuni genereaz un comportament polimorfic, la momentul executiei programului. // fisierul sursa p4_4.cpp #include <iostream.h> #include <string.h> #include <assert.h> // clasa de baza Persoana, clasa abstracta class Persoana { char* prenume; char* nume; public: Persoana(char*, char*); ~Persoana(); char* preiaPrenume(); char* preiaNume(); // functie virtuala pura virtual 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 << prenume << " " << nume << "\n"; } // definim clasa Student derivata din clasa Persoana class Student : public Persoana { double bursa; double media; public: Student(char*, char*, double = 0.0, double = 0.0); void seteazaBursa(double); void seteazaMedia(double); virtual double venit(); virtual void afisare(); }; Student::Student(char* P, char* N, double B, double M) :Persoana(P,N) { M>=8.50?seteazaBursa(B):seteazaBursa(0.0); seteazaMedia(M); } void Student::seteazaBursa(double B) { bursa = B>0?B:0; } void Student::seteazaMedia(double M) { media = M>0?M:0.0; } double Student::venit() { return bursa;

57

} void Student::afisare() { cout << "\n Student:"; Persoana::afisare(); cout << "\t Media = " << media << "\n"; } // definim clasa Salariat derivata din clasa Persoana class Salariat:public Persoana { double salariu; double venit_ora; int nr_ore; public: Salariat(char*, char*, double = 0.0, double = 0.0, int = 0); void seteazaSalariu(double); void seteazaVenitOra(double); void seteazaNrOre(int); virtual double venit(); virtual void afisare(); }; Salariat::Salariat(char* P,char* N,double S,double V,int nr) :Persoana(P, N) { seteazaSalariu(S); seteazaVenitOra(V); seteazaNrOre(nr); } void Salariat::seteazaSalariu(double S) { salariu = S>0 ? S : 0; } void Salariat::seteazaVenitOra(double V) { venit_ora = V>0.0 ? V : 0.0; } void Salariat::seteazaNrOre(int nr) { nr_ore = nr>0 ? nr : 0; } double Salariat::venit() { return salariu + nr_ore*venit_ora; } void Salariat::afisare() { cout << "\n Salariat:"; Persoana::afisare(); } // functie care apeleaza functiile virtuale prin legare

58

// dinamica, in cazul unui pointer al clasei de baza // referire prin pointer void Ref_Pointer(Persoana *Ptr) { Ptr->afisare(); cout << " venit (lei) " << Ptr->venit(); } // functie care apeleaza functiile virtuale prin legare // dinamica, in cazul unei referinte la clasa de baza // referire prin referinta void Ref_Referinta(Persoana &Ptr) { Ptr.afisare(); cout << " venit (lei) " << Ptr.venit(); } void main() { Student S1("Alexandra", "Stoica", 1500000, 10); cout << "\n Legare statica:\n"; S1.afisare(); cout << " venit (lei) "<<S1.venit(); cout << "\n Legare dinamica:\n"; Ref_Pointer(&S1); Ref_Referinta(S1); Salariat T1("Silvan", "Manole", 50000000, 100000, 30); cout << "\n Legare statica:\n"; T1.afisare(); cout<<" venit (lei) "<<T1.venit(); cout << "\n Legare dinamica: \n"; Ref_Pointer(&T1); Ref_Referinta(T1); } Observatii Principiul care st la baza polimorfismului este o singur interfat, metode multiple. Practic, polimorfismul reprezint abilitatea obiectelor din clase diferite ale unei ierarhii de clase de a rspunde diferit la acelasi mesaj (adic,la apelul unei functii membru). Implementarea polimorfismului este realizat prin intermediul functiilor virtuale. n cazul n care o functie membru ne-virtual este definit ntr-o clas de baz si redefinit ntr-o clas derivat, comportamentul este ne-polimorfic. Astfel, dac functia membru este apelat printr-un pointer al clasei de baz la obiectul clasei derivate, se utilizeaz versiunea clasei de baz. Dac functia membru este apelat printr-un pointer al clasei derivate, se utilizeaz versiunea clasei derivate.

59

Teste de autocontrol
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 n cazul claselor derivate dintr-o clas de baz. Ordinea de apelare este urmtoarea: (a) constructorul clasei derivate constructorul clasei de baz destructorul clasei derivate destructorul clasei de baz (b) constructorul clasei de baz constructorul clasei derivate destructorul clasei derivate destructorul clasei de baz (c) constructorul clasei derivate constructorul clasei de baz destructorul clasei de baz destructorul clasei derivate (d) constructorul clasei de baz constructorul clasei derivate destructorul 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. Care este 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 programul principal se vor crea dou obiecte ob1 al clasei Aparat si ob2 al clasei Radio si se vor apela functiile de afisare. 3.18 Redefiniti functia de afisare a clasei Aparat n clasa Radio si rescrieti programul de la exercitiul 3.17. 3.19 Rescrieti programul de la exercitiul T3.2 realiznd suprancrcarea constructorului clasei derivate 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 motenit clasa 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 <iostream.h>

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<<d.u; cout<<d.x; cout<<d.y; cout<<d.z; cout<<d.t; return 0; }
3. 23 Spunei dac programul de mai jos este corect. n caz afirmativ, precizai exact constructorii care se execut i n ce ordine. n caz negativ spunei de ce nu este corect. #include<iostream.h>

class cls1 { public: int x; cls1(int i=13) { x=i; } }; class cls2: virtual public { public: cls2(int i=15) { class cls3: virtual public { public: cls3(int i=17) {

cls1 x=i; } }; cls1 x=i; } }; 62

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<<ob2.y; return 0; } 3.24 Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect. #include <iostream.h> class B { int a; public: B(int i=0) { a=i; } int get_a(){ return a; } }; class D: private B { public: D(int x=0): B(x) {} int get_a() { return B::get_a(); } }; int main() { D d(-89); cout<<d.get_a(); return 0; }

63

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 sunt definite seturi de operatori care permit operaii de baz executate ntr-un mod convenabil. Dar, dup cum este cunoscut, n limbaj sunt definite prea puine tipuri de date ca date fundamentale, iar pentru reprezentarea altor tipuri care sunt necesare n diferite domenii (cum ar fi aritmetica numerelor complexe, algebra matricilor, etc.), se definesc clase care conin funcii ce pot opera asupra acestor tipuri. Limbajul C++ nu permite crearea de noi operatori, n schimb permite redefinirea majorittii operatorilor existenti astfel nct atunci cnd acesti operatori sunt aplicati obiectelor unor clase s aib semnificatia corespunztoare noilor tipuri de date. Principalele avantaje ale redefinirii operatorilor sunt claritatea si usurinta cu care se exprim anumite operatii specifice unei clase. Solutia alternativ ar fi definirea unor functii si apelul functiilor n cadrul unor expresii. Funciile operator pentru o anumit clas pot s fie sau nu funcii membre ale clasei. Dac nu sunt funcii membre ele sunt, totui, funcii friend ale clasei i trebuie s aib ca argument cel puin un obiect din clasa respectiv sau o referin la aceasta.

Funcii operator membre ale claselor

Forma general pentru funciile operator membre ale clasei este urmtoarea:
tip_returnat operator # (lista_argumente){ // operaii } Semnul # reprezint oricare dintre operanzii care pot fi suprancrcai.

Programul P 4.1 prezinta clasa Point care descrie un vector ntr-un plan bidimensional prin dou numere de tip float, x i y. Valorile x i y reprezint coordonatele punctului de

64

extremitate al vectorului. Pentru aceast clas se pot defini mai multe operaii cu vectori, ca de exemplu: Suma a doi vectori Diferena a doi vectori Produsul scalar a doi vectori Multiplicarea unui vector cu o constant (scalare)

Aceste operaii se pot implementa prin suprancrcarea corespunztoare a operatorilor. Pentru nceput se vor defini funciile operator+() i operator() pentru calculul sumei, respectiv a diferenei a doi vectori.
class Point{ float x; float y; public: Point(){ x = 0; y = 0; } Point(double a, double b){ x = a; y = b; } void Display() { cout << x << " " << y << endl; } Point operator+(Point op2); // suma a doi vectori Point operator-(Point op2); // diferena a doi vect double operator*(Point op2);// produs scalar Point& operator*(double v); // multipl. cu o const. }; Point Point::operator+(Point op2){ point temp; temp.x = x + op2.x; temp.y = y + op2.y; return temp; } Point Point::operator-(Point op2){ point temp; temp.x = x + op2.x; temp.y = y + op2.y; return temp; } double Point::operator*(Point op2){ return x*op2.y + y*op2.x; }

65

Point& Point::operator*(double x *=v; y *=v; return *this; } void f1(){ Punct pct1(10,20); Punct pct2(30,40); Punct pct3; pct1.Display(); pct2.Display(); pct3 = pct1 + pct2; pct3.Display(); pct3 = pct2 pct1; pct3.Display(); }

v){

// afiseaza 10 20 // afiseaza 30 40 // afiseaza 40 60 // afiseaza 20 20

Funcia operator+() are un singur argument, chiar dac ea suprancarc un operator binar pentru ca argumentul transmis funciei este operandul din dreapta operaiei, iar operandul din stnga este chiar obiectul pentru care se apeleaz funcia operator. Pentru acelai operator se pot defini mai multe funcii suprancrcate, cu condiia ca selecia uneia dintre ele n funcie de numrul i tipul argumentelor s nu fie ambigu. n clasa Point s-a suprancrcat operatorul * cu dou funcii: prima pentru calculul produsului scalar a doi vectori, cealalt pentru multiplicarea vectorului cu o constant. n implementarea prezentat, funcia operator+() creaz un obiect temporar, care este distrus dup returnare. n acest fel, ea nu modific nici unul dintre operanzi, aa cum nici operatorul + pentru tipurile predefinite nu modific operanzii. n general, un operator binar poate fi suprancrcat fie printr-o funcie membr nestatic cu un argument, fie printr-o funcie nemembr cu dou argumente. Un operator unar poate fi suprancrcat fie printr-o funcie membr nestatic fr nici un argument, fie printr-o funcie nemembr cu un argument. La suprancrcarea operatorilor de incrementare sau decrementare (++, --) se poate diferenia un operator prefix de un operator postfix folosind dou versiuni ale funciei operator. n continuare sunt prezentate cteva funcii operator ale clasei Point pentru operatori unari.
class Point{ // public: Point operator!(); Point operator++(); Point operator(); Point operator++(int x); Point operator(int x); };

66

Point operator!(){ x = -x; y = -y; return *this; } Point Point::operator++(){ x++; y++; return *this; } Point Point::operator--(){ x--; y--; return *this; } Point Point::operator ++(int x){ ++x; ++y; return *this; } Point Point::operator --(int x){ --x; --y; return *this; }

Dac ++ precede operandul, este apelat funcia operator++(); dac ++ urmeaz operandului, atunci este apelat funcia operator++(int x), iar x are valoarea 0. La suprancrcarea unui operator folosind o funcie care nu este membr a clasei este necesar s fie transmii toi operanzii necesari, deoarece nu mai exist un obiect al crui pointer (this) s fie transferat implicit funciei. Din aceast cauz, funciile operator binar necesit dou argumente de tip clas sau referin la clas, iar funciile operator unar necesit un argument de tip clas sau referin la clas. n cazul operatorilor binari, primul argument transmis este operandul stnga, iar al doilea argument este operandul dreapta In programul P4.2 o parte din funciile operator ale clasei Point sunt implementate ca funcii friend ale clasei.
class Point { int x; int y; public: //. friend Point operator+(Point op1, Point op2); friend Point operator-(Point op1, Point op2);

67

Point operator+(Point op1, Point op2){ Point temp; temp.x = op1.x + op2.x; temp.y = op1.y + op2.y; return temp; } Point operator-(Point op1, Point op2){ Point temp; temp.x = op1.x - op2.x; temp.y = op1.y - op2.y; return temp; } void f2(){ Punct pct1(10,20); Punct pct2(30,40); Punct pct3; pct1.Display(); pct2.Display(); pct3 = pct1 + pct2; pct3.Display(); pct3 = pct2 pct1; }

// afiseaza 10 20 // afiseaza 30 40 // afiseaza 40 60

Observatii Dac functia operator este implementat ca o functie membru, operandul cel mai din stnga (eventual, unicul operand) trebuie s fie un obiect al clasei sau o referint ctre un obiect al clasei. Implementarea sub form de functie nemembru este indicat n cazul n care cel mai din stnga operand este un obiect al unei clase diferite sau al unui tip predefinit. O functie operator ne-membru trebuie declarat functie friend dac functia respectiv trebuie s acceseze direct membrii privati sau protejati ai clasei respective.

4. 2 Template-uri
O alt facilitate important a limbajului C++ este dat de posibilitatea definirii unor sabloane numite template-uri. Un template reprezint o modalitate de parametrizare a unei clase sau a unei functii prin utilizarea unui tip n acelasi mod n care parametrii unei functii furnizeaz o modalitate de a defini un algoritm abstract fr identificarea valorilor specifice. O clas template specific modul n care pot fi construite clase individuale, difereniate prin tipul sau tipurile de date asupra crore se opereaz. Sintaxa definirii unui template: template <class <parametru> > class <nume_clas> 68

{ // definitia clasei sablon }; Programul P4.3 prezint un exemplu de definire a unei functii template, afisare_vector(.). Aplicarea functiei template celor trei variabile T1, T2 si respectiv T3 va determina afisarea unui vector de numere ntregi, a unui vector de numere reale, respectiv a unui vector de caractere.

// fisierul sursa P4.3.cpp #include <iostream.h> template <class T> void afisare_vector(const T *t, const int nr) { for (int i=0;i<nr;i++) cout<<t[i]<<" "; } void main() { const int nr1 = 5, nr2 = 7, nr3 = 4; int T1[nr1] = {1,2,3,4,5}; double T2[nr2] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7}; char T3[nr3] = "Ana"; cout<<"\n Vectorul contine: "; // functia template pentru vector de numere intregi afisare_vector(T1, nr1); cout<<"\n Vectorul contine: "; // functia template pentru vector de numere reale afisare_vector(T2, nr2); cout<<"\n Vectorul contine: "; // functia template pentru vector de caractere afisare_vector(T3, nr3); } Observatie Template-urile furnizeaz o alt form de polimorfism.

4.3 Stream-uri de I/E

Bibliotecile standard ale limbajului C++ furnizeaz un set extins de facilitti pentru operatii de intrare/iesire (I/E). Dac o functie de I/E este definit corespunztor unui anumit tip de date, ea va putea fi apelat pentru a lucra cu acel tip de date. Se pot specifica att tipuri standard, ct si tipuri definite de utilizatori. Funcii de I/O pentru tipurile predefinite Operaiile de I/O din C++ se efectueaz folosind funciile operator de inserie << i operator de extragere >>.

69

Funciile de operare asupra streamurilor specific modul n care se execut conversia ntre un ir de caractere din stream i o variabil de un anumit tip. Aceste funcii operator sunt definite n clasa ostream, respectiv istream, pentru toate tipurile predefinite ale limbajului, iar pentru tipurile definite de utilizator ele pot fi suprancrcate. Funcia de citire de la consol a unei secvene de numere ntregi separate prin spaii albe (whitespace adic unul din caracterele blanc, tab, newline, carriage return, formfeed) poate arta asfel:
void main(){ int size = 10; int array[10]; for(int i=0;i<size;i++){ if (cin >> array[i]) cout << array[i] << " "; else { cout << "eroare non-int"; break; } } }

O intrare diferit de ntreg va cauza eroare n operaia de citire i deci oprirea buclei for. De exemplu, din intrarea: 1 2 3 4.7 5 6 7 8 9 0 11 se va citi primele patru numere, dup care apare eroare n operaia de intrare, citirea numerelor ntregi se ntrerupe i pe ecran apare mesajul: 1 2 3 4 eroare non-int Caracterul punct este lsat n streamul de intrare, ca urmtor caracter de citit. O alt soluie pentru citirea unei secvene de intrare este prin folosirea uneia din funciile get() definite n clasa iostream astfel:
class iostream : public virtual ios { // istream& get(char& c); istream& get(char* p, int n, char ch=\n); };

Aceste funcii treateaz spaiile albe la fel ca pe toate celelalte caractere. Funcia get(char& c) citete un singur caracter n argumentul c. De exemplu, o funcie fg() de copiere caracter cu caracter de la intrare (streamul cin) la ieire (streamul cout) poate arta astfel:
void stream(){ char c; while(cin.get(c)) cout << c;

70

i funcia operator >> () are un echivalent ca funcie de scriere la consol fr suprancrcarea operatorului >>, numit funcia put(), astfel nct funcia fg() se poate rescrie astfel:
void stream(){ char c; while(cin.get(c)) cout.put(c); }

Funcii de I/O pentru tipuri definite de utilizator Funciile de I/O pentru tipuri definite de utilizator se obin prin suprancrcarea operatorilor de inserie i de extragere, care au urmtoarea form general:
ostream& operator<<(ostream& os,tip_clasa nume){ // corpul functiei return os; } istream& operator<<(istream& is,tip_clasa& nume){ // corpul functiei return is; }

Primul argument al funciei este o referin la streamul de ieire, respectiv de intrare. Pentru funcia operator de extragere << al doilea argument este dat printr-o referin la obiectul care trebuie s fie extras din stream; n aceast referin sunt nscrise datele extrase din streamul de intrare. Pentru funcia operator de inserie >> al doilea argument este dat prin tipul i numele obiectului care trebuie s fie inserat, sau printr-o referin la acesta. Funciile operator de inserie i extracie returneaz o referin la streamul pentru care au fost apelate, astfel nct o alt operaie de I/O poate fi adugat acestuia. Funciile operator << sau >> nu sunt membre ale clasei pentru care au fost definite, dar pot (i este recomandabil) s fie declarate funcii friend n clasa respectiv. In programul P 4.4 se defineste clasa Complex care cuprinde functiile operator << si >>.
class Complex { double x, y; public: Complex(){x = 0; y = 0} Complex(double r, double i){ x = r; y = i; } .. friend ostrem& operator << (ostrem& os,Complex z);

71

friend istream& operator >>(istream& is,Complex& z); }; ostream& operator<<(ostream& os, Complex& z){ os << ( << z.x << ,<< z.y << ); return os; } istream& operator>>(istream& is, Complex z){ is >> z.x >> z.y; return is; } void main(){ Complex z; cout << "Introduceti x, y :"; cin >> z; cout << "z = " << z << '\n'; cin.get(); int size = 10;

Execuia acestei funcii produce urmtoarele mesaje la consol:

Introduceti x, y: 1.3 4.5 z = (1.3,4.5) Introduceti un sir:123456 123456

4. 4 Procesarea fisierelor
Procesarea fisierelor n limbajul C++ necesit includerea fisierelor antet <iostream.h> si <fstream.h>. Fisierul antet <fstream.h> cuprinde definitiile claselor streamului: ifstream (pentru intrrile dintr-un fisier operatii de citire din fisier), ofstream (pentru iesirile ctre un fisier operatii de scriere n fisier) si fstream (pentru intrrile/iesirile de la/ctre un fisier). Pentru utilizarea unui fiier pe disc acesta trebuie s fie asociat unui stream. Pentru aceasta se creaz mai nti un stream, iar apelul funciei open() a streamului execut asocierea acestuia cu un fiier ale crui caracteristici se transmit ca argumente ale funciei open(). Funcia open() este funcie membr a fiecreia dintre cele trei clase stream (ifstream, ofstream i fstream) Implicit, fiierele se deschid n mod text. Valoarea ios::binary determin deschiderea n mod binar a fiierului. Pentru nchiderea unui fiier se apeleaz funcia close(), care funcie membr a claselor stream (ifstream, ofstream i fstream). Pentru scrierea i citirea dintr-un fiier de tip text se folosesc funciile operator << i >> ale streamului asociat acelui fiier. Aceste funcii operator suprancrcate pentru un anumit tip de date pot fi folosite fr nici o modificare att pentru a scrie sau citi de la consol ct i pentru a scrie sau citi dintr-un fiier pe disc. 72

Programul P4.5 creaz un fiier de inventariere inventar.txt care conine numele articolului, preul unitar, numrul de buci i valoarea total.
void finv(){ ofstream output("inventar.txt"); if (!output) cout << "Nu se poate deschide fisierul inventar.txt\n"; char buffer[80]; double pret,total; int buc; while(1){ cout << "\nArticol: "; cin.get(buffer,80); if (buffer[0] == 0) break; cout << "Pret unitar: "; cin >> pret; cout << "Nr. bucati: "; cin >> buc; cin.get(); total = buc*pret; output << buffer << endl; output << pret<< endl; output << buc << endl; output << total << endl; } output.close(); }

La citirea dintr-un fiier de tip text de pe disk folosind operatorul >> apar, la fel ca la citirea de la consol, anumite modificri de caractere. Pentru a evita astfel de modificri se folosesc funciile de I/O binare care vor fi prezentate n seciunea urmtoare.

73

Teste de autocontrol 4.1 Care este rolul redefinirii operatorilor n limbajul C++? 4.2 Care dintre afirmatiile urmtoare sunt adevrate? (a) Precedenta unui operator poate fi modificat prin redefinire. (b) Aritatea unui operator nu poate fi modificat prin redefinire. (c) Asociativitatea unui operator poate fi modificata prin redefinire. (d) Semnificatia modului n care lucreaz un operator asupra obiectelor de tipuri predefinite nu poate fi schimbat prin redefinire. 4.3 Care sunt clasele predefinite, dedicate procesrii fisierelor C++? 4.4 S se citeasc un fiier care conine numere flotante, s se construiasc numere complexe din perechi de cte dou numere flotante i s se afieze la consol numerele complexe. 4.4 Pentru clasa String s se defineasc urmtoarele operaii de comparaie folosind funcii operator friend: int operator ==( const String& s1, const String& s2 ); int operator ==( const String& s1, const char* s2 ); int operator ==( const char* s1, const String& s2 ); int operator !=( const String& s1, const String& s2 ); 4.5 Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect. #include<iostream.h> class B { protected: int x; B(int i=10) { x=i; } public: virtual B operator+(B ob) { B y(x+ob.x); return y;} }; class D: public B { public: D(int i=10) { x=i; } void operator=(B p) { x=p.x; } B operator+(B ob) { B y(x+ob.x+1); return y; } void afisare(){ cout<<x; } }; int main() { D p1(-59),p2(32),*p3=new D; *p3=p1+p2; p3->afisare(); return 0; }

74

4.6 Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect. #include<iostream.h> class cls { public: int sa; cls(int s=0) { sa=s; } operator int() { return sa; } int f(int c) { return (sa*(1+c/100)); } }; int main() { cls p(37); cout<<p.f(p); return 0; } 4.7 Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect. #include<iostream.h> class B { public: int x; B(int i=0) { x=i; } virtual B aduna(B ob) { return(x+ob.x); } B minus() { return(1-x); } void afisare(){ cout<<x; } }; class D: public B { public: D(int i=0) { x=i; } B aduna(B ob) { return(x+ob.x+1); } }; int main() { B *p1, *p2; p1=new D(138); p2=new B(-37); *p2=p2->aduna(*p1); *p1=p2->minus(); p1->afisare(); return 0; }

75

Teste recapitulative:
Specificai varianta corect : 1. Clasa
class c { float a; void afisisare(); }

are membrii: a). publici; c). protected; 2. Fie secvena:

b). privai d). date private i metode pubice.

class c {....}; void main() { c e /* instructiuni */ }

n acest caz: a). c este un obiect i e este clas; b). c este o instana a clasei i e este un obiect; c). c este o clasa i e este un obiect; d). descrierea este eronat deoarece se folosete acelai identificator pentru clas i obiect. 3. Avnd declaraia:
class persoana { char nume[20]; int varsta; public: persoana(); int spune_varsta() { return varsta;} }; void main() {persoana p; cout<<p.nume<<p.varsta; }

n acest caz : a). programul afiseaz numele i vrsta unei persoane; b). nu este permis afisarea datelor unei persoane; c). descriere eronat pentru c funcia membra nu este utilizat; d). afiseaz doar vrsta unei persoane. 4. Fie clasa :
class c { int a,b; public: float c (int, int) int det_a {return a;} c (); }

Declaraia float c(int, int) ar putea corespunde unui constructor al clasei? 76

a). da, fiind o supraincarcare a celui existent; b). nu., deoarece creaz ambiguitate; c). nu, deoarece constructorul nu are tip returnat; d). nu, deoarece nu este de tip friend. 5. Fie declaraia :
class c1 {int a ;} class c2 :public c1 { public : int b ; void scrie_a() {cout<<a ;} } void main () { c2 ob ; ob.scie_a () ; }

Selectai afirmaia corect : a). funcia scrie_a() nu are drept de acces asupra unui membru privat; b). programul afiseaz valoare lui a; c). derivarea public este incorect relaizat; d). prin derivare public, accesul la membrii moteniti devine public. 6. Fie declaraia
class c1{/* instructiuni */} class c2:public c1 {/* .*/}

Atunci clasa c2 faa de clasa c1 este: a). derivat; b). de baz; c). friend 7. In secvena urmatoare:

d). virtual.

class cls { public:static int s;}; int cls::s=0; int main(){int i=7;cls::s=i;cout<<cls::s;}

Utilizarea lui s este: a). ilegal, deoarece nu exist nici un obiect creat; b). ilegal, deoarece variabilele statice pot fi doar private; c). ilegal, deoarece s este dublu definit, n clas i n afara ei; d). corect, deoarece membrii statici exist nainte de a se crea obiecte din clasa. 8. Secvena urmatoare:
class persoana { int varsta, salariul; friend ostream & operator<<(ostream &out,persoana p) {out<<p.varsta<< <<p.salariul; return out;} public: persoana(int v){varsta=v;salariul=0;} persoana(){varsta=0;salariul=0;} } int main() {persoana p(1);cout<<p;}

Afiseaz: a). afiseaz 1 0;

b). afiseaz 0 0

77

c). afiseaz 1 1;

d). afiseaz 0 1.

9. Secvena urmatoare:
class vector{int*pe,nr_c; public: operator int(){return nr_c;} vector(int n){ pe=new int[n];nr_c=n; while(n--) pe[n]=n;} void f(int i){cout<<i<<endl;} int main() {vector x(10); f(x)} Afiseaz:

a). 10 b). 9 c). numerele de la 1 la 10 d). numerele de la 0 la 10. Secventa urmatoare:

class vector{int*pe,nr_c; public: operator int(){return nr_c;} vector(int n){ pe=new int[n];nr_c=n; while(n--) pe[n]=n;} void f(int i){cout<<i<<endl;} int main() {vector x(10); f(x)}

Afiseaza: a). 10 b). 9 c). numerele de la 1 la 10 d). numerele de la 0 la 9 11. Secvena urmatoare afiseaz:
class persoana {int varsta; public: persoana(int v=18){varsta=18;} operator int(){return varsta;} persoana& operator++() {varsta++;return *this;} persoana operator ++(int) {persoana aux=*this;varsta++;return aux;} int main(){ persoana p(20); int x=p++,y=++p; cout<< x<< y ;}

Afiseaza : a).20 20; b).20 21 ; c).21 22; d).20 22. 78

12 . Fie secvena :
class c { int a; public: c(); c(const c&); void operator=(c&);} int main() { c a; //instructiuni; c b=a;}

Linia c b=a; determin: a). execuia constructorului de copiere; b). execuia metodei prin care se supraincarc operatorul =; c). execuia att a constructorului de copiere, ct i a metodei operator =; d). execuia contructorului implicit 13. Se considera urmatoarea secventa de program:
class complex { double real; double imag; public: complex(double x=1.0, double y=20.0){real=x; imag=y;} complex( const complex &u) { real=u.real; imag=u.imag; } .............. }

Precizati n care situatie se creaza un obiect anonim: a) complex z1(3.42, -12.9); b) complex z2=z1; c) complex z3(z1); d) complex z1= complex(45.0,0.9); e) complex z(23.25); 14. Se considera urmatoarea secventa de program:
class complex { double real; double imag; public: complex(double x=10.0, double y=10.0){real=x; imag=y;} complex(const complex &u) { real=u.real; imag=u.imag; } .............. }

Precizati n care situatie se realizeaza o copiere a unui obiect n alt obiect: 79

a) complex z1(3.42, -12.9); b) complex z2=z1; c) complex z3(1.0,-1.0); d) complex z(10.7,0.8); e) complex z(23.25); 15. Se considera urmatoarea secventa de program:
class complex { double real; double imag; public: complex(double x=-11.0, double y=-56.90){real=x; imag=y;} complex( const complex &u) { real=u.real; imag=u.imag; } .............. }

Precizai in care situatie se creaza un obiect anonim: a) complex z1(3.42, -12.9); b) complex z1= complex(0.0,0.9); c) complex z2=z1; d) complex z3(z1); e) complex z(23.25); 16. Se considera urmatoarea secventa de program:
class complex { double re; double im; public: complex(double x=-11.0, double y=-56.90){re=x; im=y;} complex( const complex &u) { real=u.re; imag=u.im; } ............ }

Precizati n situatie se utilizeaza constructorul de copiere: a) complex z1(3.4, -12.9); b) complex z3(0.0,-10.9); c) complex z2(0.0,1.0); d) complex z3(z1); e) complex z(2.25); 17. Se considera urmatoarea secventa de program:
class complex { double real;

80

double imag; public: complex(double x=-11.0, double y=-56.90){real=x; imag=y;} complex( const complex &u) { real=u.real; imag=u.imag; } ..............

} Precizati situatia n care nu era necesara folosirea unui constructor cu parametri care iau valori n mod implicit: a) complex z2(3.42,-12.9); b) complex z3(z2); c) complex z=z2; d) complex z4(z); e) complex z5=z4; 18. Se da secventa de program:
class A { int a[3]; public: A(int i, int j, int k){a[0]=i; a[1]=j; a[2]=k;} int &operator[](int i){return a[i];} }; void main(void) { A ob(1,2,3); cout << ob[1]; ob[1]=25; cout<<ob[1]; }

Ce se poate afirma despre operator[]()? a) produce suprancarcarea unei functii; b) produce suprancarcarea unui operator unar; c) suprancarca operatorul []; d) este o functie membru oarecare a clasei A care nu produce suprancarcarea unui operator; e) reprezinta un operator ternar; 19. Suprancarcarea unor operatori se poate realiza prin functii operator sau functii friend. Diferenta ntre aceste doua posibilitati consta n: a) lista de parametri; b) obiect returnat; c) precedent a operatorilor; d) n-aritatea operatorului; e) alte situatii. 20. In secventa de program:
................. int k=100;

81

void fct() { int k; ........... k++; ........... } void gct() { int k=2; ........... ::k++; // (?) ........... }

In instructiunea marcata cu (?), k este o variabila: a) externa; b) statica; c) registru; d) globala; e) automatica; 21. Se considera secventa de program:
class B1 { class D1:public B1,public B2 { public: public: B1(){cout<<"(1)\n";} D1(){cout<<"(7)\n";} ~B1(){cout<<"(2)\n";} ~D1(){cout<<"(8)\n";} }; }; class B2 { class D2:public D1,public B3 { public: public: B2(){cout<<"(3)\n";} D2(){cout<<"(9)\n";} ~B2(){cout<<"(4)\n";} ~D2(){cout<<"(10)\n";} }; }; class B3 { public: B3(){cout<<"(5)\n";} ~B3(){cout<<"(6)\n";} }; void main(){ D1 ob1; D2 ob2; }

Care mesaj se va scrie? a) (1),(3),(7),(3),(5),(7),(9),(10),(6),(8),(4),(2),(2),(3),(2),(2); b) (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(9),(7),(2),(3),(2),(2); c) (1),(3),(7),(1),(3),(7),(5),(9),(10),(6),(8),(4),(2),(8),(4),(2); d) (1),(3),(5),(7),(9),(2),(4),(6),(6),(8),(8),(10),(2),(2),(4),(2); e) (1),(3),(7),(1),(3),(7),(9),(5),(10),(6),(4),(8),(2),(8),(4),(2); 22. Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect. #include <iostream.h>
template <class tip> class cls { tip z;

82

public: cls(tip i) { z=i; } tip operator-(cls); }; template <class tip> tip cls<tip>::operator-(cls<tip> a) { return z-a.z; } template <class tip> tip dif(tip x, tip y) { return x-y; } int dif(int x, int y) { return x>=y?x-y:y-x; } int main() { cls<int> i=3; cls<float> j=4; cout<<dif(i,j); return 0; }

23. Descriei pe scurt cum putei prelua o dat prin incluziune i a doua oar prin motenire o clas numar ntr-o clas lista care descrie liste nevide de dimensiune variabil de elemente de tip numar. 24. Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect.
#include<iostream.h> class cls { static int x; public: cls(int i=25) { x=i; } friend int& f(cls); }; int cls::x=-13; int& f(cls c) { return c.x; } int main() { cls d(15); cout<<f(d); return 0; }

25. Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect.
#include<iostream.h> class cls { int v,nr; public: cls(int i) { nr=i; v=new int[i]; } friend int& operator[](int); friend ostream& operator<<(ostream&,cls); }; int& operator[](cls& x, int i) { return x.v[i]; } ostream& operator<<(ostream& o, cls x) { for(int i=0;i<x.nr;i++) cout<<x.v[i]<< ; return o; } int main() { cls x(10);

83

x[5]=7; cout<<x; return 0; }

26. Descriei pe scurt metoda de identificare a tipului n timpul rulrii (RTTI). 27. Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect.
#include<iostream.h> class cls { static int i; int j; public: cls(int x=7) { j=x; } static int imp(int k){ cls a; return i+k+a.j; } }; int cls::i; int main() { int k=5; cout<<cls::imp(k); return 0; }

28. Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect. #include<iostream.h>
class cls { int x; public: cls(int i=32) { x=i; } int f() const; }; int cls::f() const { return x++; } void main() { const cls d(-15); cout<<d.f(); }

29. Spunei dac o variabil constant poate fi transmis ca parametru al unei funcii i dac da, n ce situaii. Justificai. 30. Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz pentru o valoare ntreag citit egal cu 7, n caz negativ spunei de ce nu este corect.
#include <iostream.h> float f(float f) { if (f) throw f; return f/2; } int main() { int x; try { cout<<Da-mi un numar intreg: ; cin>>x; if (x) f(x); else throw x;

84

cout<<Numarul <<x<< e bun!<<endl; } catch (int i) { cout<<Numarul <<i<< nu e bun!<<endl; } return 0; }

31. Spuneti dac programul de mai jos este corect. n caz afirmativ, spunei ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class B { int x; public: B(int i=2):x(i){} int get_x() const { return x; } }; class D: public B { int *y; public: D(int i=2):B(i){ y=new int[i]; for(int j=0; j<i; j++) y[j]=1; } D(D& a){ y=new int[a.get_x()]; for(int i=0;i<a.get_x();i++) y[i]=a[i]; } int& operator[](int i) { return y[i]; } }; ostream& operator<<(ostream& o, const D& a) { for(int i=0;i<a.get_x();i++) o<<a[i]; return o; } int main() { D ob(5); cout<<ob; return 0; }

32. Descrieti trei metode de proiectare diferite prin care elementele unei clase se pot regsi n dublu exemplar, sub diverse forme, n definitia altei clase. 33. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spunei de ce nu este corect.
#include<iostream.h> class B { int x; public: B(int i=10) { x=i; } int get_x() { return x; } }; class D: public B { public: D(int i):B(i) {} D operator+(const D& a) {return x+a.x; } }; int main() { D ob1(7), ob2(-12); cout<<(ob1+ob2).get_x(); return 0; }

34. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class B { public: int x; B(int i=16) { x=i; }

85

B f(B ob) { return x+ob.x; } }; class D: public B { public: D(int i=25) { x=i; } B f(B ob) { return x+ob.x+1; } void afisare(){ cout<<x; } }; int main() { B *p1=new D, *p2=new B, *p3=new B(p1->f(*p2)); cout<<p3->x; return 0; }

35. Spuneti ce este obiectul implicit al unei metode si descrieti pe scurt propriettile pe care le cunoasteti despre acesta. 36. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class cls { int *v,nr; public: cls(int i) { nr=i; v=new int[i]; for (int j=1; j<nr; j++) v[j]=0; } int size() { return nr; } int& operator[](int i) { return *(v+i); } }; int main() { cls x(10); x[4]=-15; for (int i=0; i<x.size(); i++) cout<<x[i]; return 0; }

37. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class cls { int x; public: cls(int i=-20) { x=i; } const int& f(){ return x; } }; int main() { cls a(14); int b=a.f()++; cout<<b; return 0; }

38. Descriei pe scurt mostenirea virtual si scopul n care este folosit. 39. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class B { static int x; int i; public: B() { x++; i=1; } ~B() { x--; }

86

static int get_x() { return x; } int get_i() { return i; } }; int B::x; class D: public B { public: D() { x++; } ~D() { x--; } }; int f(B *q) { return (q->get_i())+1; } int main() { B *p=new B; cout<<f(p); delete p; p=new D; cout<<f(p); delete p; cout<<D::get_x(); return 0; }

40. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class B { int x; public: B(int i=17) { x=i; } int get_x() { return x; } operator int() { return x; } }; class D: public B { public: D(int i=-16):B(i) {} }; int main() { D a; cout<<27+a; return 0; }

41. Enumerai 3 metode de implementare a polimorfismului de compilare. 42. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class cls { static int x; public: cls (int i=1) { x=i; } cls f(cls a) { return x+a.x; } static int g() { return f()/2; } }; int cls::x=7; int main() { cls ob; cout<<cls::g(); return 0; }

87

43. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class cls { int *v,nr; public: cls(int i=0) { nr=i; v=new int[i]; for (int j=0; j<size(); j++) v[j]=3*j; } ~cls() { delete[] v; } int size() { return nr; } int& operator[](int i) { return v[i]; } cls operator+(cls); }; cls cls::operator+(cls y) { cls x(size()); for (int i=0; i<size(); i++) x[i]=v[i]+y[i]; return x; } int main() { cls x(10), y=x, z; x[3]=y[6]=-15; z=x+y; for (int i=0; i<x.size(); i++) cout<<z[i]; return 0; }

44. Descrieti pe scurt mecanismul de tratare a exceptiilor. 45. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include<iostream.h> class B { int i; public: B() { i=1; } int get_i() { return i; } }; class D: public B { int j; public: D() { j=2; } int get_j() {return j; } }; int main() { B *p; int x=0; if (x) p=new B; else p=new D; if (typeid(p).name()=="D*") cout<<((D*)p)->get_j(); return 0; }

46. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include <iostream.h> class cls { int x;

88

public: cls(int i) { x=i; } int set_x(int i) { int y=x; x=i; return y; } int get_x(){ return x; } }; int main() { cls *p=new cls[10]; int i=0; for(;i<10;i++) p[i].set_x(i); for(i=0;i<10;i++) cout<<p[i].get_x(i); return 0; }

47. Descrieti pe scurt diferenta dintre un pointer si o referint. 48. Spuneti dac programul de mai jos este corect. n caz afirmativ, spuneti ce afiseaz, n caz negativ spuneti de ce nu este corect.
#include <iostream.h> template<class T> int f(T x, T y) { return x+y; } int f(int x, int y) { return x-y; } int main() { int a=5; float b=8.6; cout<<f(a,b); return 0; }

49. Spunei pe scurt prin ce se caracterizeaz un cmp static al unei clase. 50 . Spunei dac programul de mai jos este corect. n caz afirmativ, spunei ce afieaz, n caz negativ spunei de ce nu este corect. #include<iostream.h>
class cls1 { public: int cls1() { a=7; class cls2 { public: int cls2(int i) { cls2(cls1& x) int main() { cls1 x; cout<<x.a; cls2 y(x); cout<<y.b; return 0; } a; } }; b; b=i; } { b=x.a; } };

89

Bibliografie 1. Oprea M., Programare orientat pe obiecte - Exemple n limbajul C++, Editura Matrix Rom. 2. Dr. Kris Jamasa, Totul despre C si C++, Editura Teora. 3. Ion Smeureanu , Programare orientat pe obiecte in Limbajul C++, Editura CISON, Bucuresti 2005. 4.Liviu Negrescu, Limbajul C++, Editura ALBASTRA , Cluj 2000. 5.Luminita Duta, Programarea calculatoarelor in limbajul C++ , Editura Cetatea de Scaun 2006.

90