Laboratorul nr.

10
Clase i obiecte
Limbajul C++ pune la dispoziia programatorului posibilitatea programrii obiectuale (OOPObject Oriented Programming). Domeniul programrii orientate spre obiecte este deosebit de larg, unificnd dou componente de baz: datele aplicaiei i codul necesar tratrii acestora. Se ofer facilitatea definirii unor tipuri de date proprii i a operatorilor destinai manipulrii lor, acestea comportndu-se asemntor datelor standard i a operatorilor standard. Avantajele OOP se pot descrie prin urmtoarele concepte: - INCAPSULAREA prin care se obine contopirea datelor cu codul n cadrul aa numitelor clase. Se asigur o bun modularizare i localizare a eventualelor erori, precum i o bun protecie a datelor prin accesul controlat ctre acestea. - MOTENIREA care permite ca, pornind de la o clas definit, cu anumite proprieti, care constituie clasa de baz, s se creeze seturi de clase asemntoare care completeaz proprietile clasei de baz cu noi proprieti. - POLIMORFISMUL ntr-o ierarhie de clase obinute prin motenire, o metod poate avea forme diferite de la o clas la alta, utilizndu-se supradefinirea acestora. Clasa este un tip de date definit de utilizator care asociaz unei structuri de date un set de funcii:

Clasa = Date + Operaii (metode)

Conceptele de domeniu i durat de via, variabile locale i globale, variabile statice, automatice i dinamice se aplic i obiectelor. C++ se distinge de limbajele POO pure prin faptul c permite controlul accesului att la datele membre, ct i la funciile membre unei clase. n acest scop se folosesc specificatorii de control al accesului : private, protected i public. Efectul acestor specificatori asupra accesului unui membru este: public : membrul poate fi accesat de orice funcie din domeniul de declaraie a clasei; private: membrul este accesibil numai funciilor membre i prietene clasei; protected: membrul este accesibil att funciilor membre i prietene clasei, ct i funciilor membre i prietene claselor derivate din clasa respectiv. O funcie membr a unei clase are acces la toate datele membre ale oricrui obiect din clasa respectiv, indiferent de specificatorul de acces. n C++ se pot declara mai multe categorii de clase folosind cuvintele cheie: struct, union, respectiv class. Variabilele de acest tip se numesc obiecte struct, union, respectiv class. Tipurile class sunt mai frecvent utilizate, ele corespunznd mai fidel conceptului OOP.

Tipul class
Sintaxa general de declarare a unui tip de date class este similar cu a tipului struct: class <nume_clasa> <: lista_clase_baza> {<lista_membri>} <lista_variabile>; unde: nume_clasa este un identificator care desemneaz numele tipului clas declarat, care trebuie s fie unic n domeniul n care este valabil declaraia; lista_clase_baza este lista claselor din care este derivat clasa declarat (dac este cazul); lista_membri reprezint secvena cu declaraii de datele membre i declaraii sau definiii de funcii Pag. 1/7

Programare C/C++ - Laborator nr. 10 membre; datele membre pot fi de orice tip, mai puin tipul clas declarat, dar se admit pointeri ctre acesta; folosirea specificatorilor auto, extern, register nu este permis. lista_variabile este lista variabilelor de tip nume_clasa. Observaii: La declararea unei clase este obligatoriu s existe cel puin una dintre nume_clasa i lista_variabile. De regul se specific nume_clasa, fapt ce permite declararea ulterioar de obiecte din tipul clas declarat. Membrii unei clase au implicit atributul de acces private n cadrul declaraiei clasei pot s apar specificatorii de acces de oricte ori i n orice ordine, toi membrii declarai dup un specificator avnd accesul controlat de acesta. Funciile membre unei clase definite n declaraia acestei sunt implicit din categoria inline. Pentru definiiile de funcii aflate n afara declaraiei clasei este necesar s se specifice numele clasei urmat de operatorul de rezoluie (::) alturat numelui funciei. Funciile membre unei clase pot fi supradefinite i pot avea parametri implicii. Pentru apelul funciilor membre publice i referirea datelor membre publice ale unui obiect, se folosesc operatorii de selecie (.) i (->), ca n cazul structurilor i uniunilor.

Un exemplu de clas l poate constitui clasa Punct care are ca date membre doi membri de tip int, x i y, ce primesc ca valori, valorile coordonatelor unui punct. De asemenea, clasa include ca funcii membre o funcie de iniializare ce stabilete valorile coordonatelor iniiale ale punctului, init(), dou funcii ce permit citirea valorilor coordonatelor, getx(), respectiv gety(), funcia de modificare a coordonatelor punctului, move() i funcia de afiare, afisare(), ce afieaz proprietile punctului. #include<iostream.h> class Punct{ private: int x, y; public: void init(int initx=0, int inity=0) {x = initx; y = inity; } int getx(){ return x; } int gety(){ return y; } void move(int dx, int dy);

// se specific accesul private la membrii clasei // date membre ale clasei // se specific acces public la membrii clasei // funcie de iniializare, funcie membr cu // parametri implicii

// funcie inline, returneaz valoarea membrului x // funcie inline, returneaz valoarea membrului y // funcie membr cu parametri, definit n afara // declaraiei clasei void afisare() // funcie de afiare a valorilor membrilor, funcie inline { cout<<\nx=<<x<<\tz=<<y;} }; void Punct::move(int dx, int dy) { x+=dx; y+=dy; } // definirea funciei move(), membr a clasei Punct

Pag. 2/7

Programare C/C++ - Laborator nr. 10 void main() { Punct Punct1; int x1, y1; cout<<"\n Introduceti coordonata x= "; cin>>x1; cout<<" Introduceti coordonata y= "; cin>>y1; Punct1.init(x1, y1); cout<<"\n x este = "<<Punct1.getx(); cout<<"\n y este = "<< Punct1.gety(); Punct1.move(10, 20); cout<<"\n x este = "<<Punct1.getx(); cout<<"\n y este = "<< Punct1.gety(); Punct Punct2; Punct2.init(); Punct2.afisare(); Punct *p_Punct3; p_Punct3 = &Punct2; p_Punct3 -> move ( 5, 12); p_Punct3 -> afisare(); } Obiectele declarate de tip Punct, cum ar fi Punct1, Punct2, sunt structuri de date alctuite din doi membri int x i respectiv y, care pot fi controlai cu funciile asociate care asigur atribuirea de valori, afiarea, modificarea acestora (init(), afisare(), getx(), gety(), move()). Accesul la membrii privai x i y nu se poate face din afara clasei, ci doar prin funciile membre. Punct1.x = 15; // eroare, membrul Punct1.x este privat Punct2.y = Punct1.x; // eroare Punct1.x, Punct2.y sunt membri privai // se declar un obiect de tip Punct, Punct1

// iniializarea obiectului Punct1 cu valorile x1, // respectiv y1 // afiarea coordonatei x // afiarea coordonatei y // modificarea coordonatelor obiectului Punct1 // afiarea coordonatei x // afiarea coordonatei y // se declar un obiect de tip Punct, Punct2 // membrii x i y preiau valorile implicite ale // parametrilor, deci x=y=0 // afiarea caracteristicilor obiectului Punct2 // se declar un obiect pointer la Punct // apelul funciilor membre se face folosind // operatorul de selecie ->

Operatorul de atribuire ( = ) poate fi folosit pentru obiecte din acelai tip class, determinnd copierea datelor membru cu membru, ca n cazul structurilor din C. Punct2=Punct1; //membrul x al obiectului Punct2 primete valoarea // membrului x al obiectului Punct1 membrul y al // obiectului Punct2 primete valoarea membrului y al // obiectului Punct1

Punct2.afisare(); Se pot folosi operatorii new i delete pentru crearea/distrugerea de obiecte de tip class. Punct * p_Punct4=new Punct; p_Punct4 -> init(5,7); p_Punct4-> move(2, 2); p_Punct4-> afisare(); delete p_Punct4; Pag. 3/7

Programare C/C++ - Laborator nr. 10 Autoreferina. Cuvntul cheie this n definiiile funciilor membre sunt necesare referiri la datele membre ale clasei respective. Acest lucru se poate face fr a specifica un obiect anume. La apelarea unei funcii membre, identitatea obiectului asupra cruia se acioneaz este cunoscut datorit transferului unui parametru implicit care reprezint adresa obiectului. Dac n definiia unei funcii este necesar utilizarea adresei obiectului, acest lucru se realizeaz cu cuvntul cheie this, asociat unui pointer ctre obiectul pentru care s-a apelat funcia. Clasa Punct definit anterior se poate completa cu funcia membr cu prototipul : void adresa(); definit astfel: void Punct::adresa() { cout<<\n Adresa obiectului Punct este: cout<< this; } Funcia main() se poate completa cu urmtoarele linii de program: Punct1.adresa(); Punct2.adresa(); p_Punct3->adresa();

Constructori i destructori Pentru crearea, iniializarea, copierea i distrugerea obiectelor, se folosesc funcii membre speciale, numite constructori i destructori. Constructorul se apeleaz automat la crearea fiecrui obiect al clasei, indiferent dac este static, automatic sau dinamic (creat cu operatorul new), inclusiv pentru obiecte temporare. Destructorul se apeleaz automat la eliminarea unui obiect, la ncheierea timpului de via sau, n cazul obiectelor dinamice, cu operatorul delete. Constructorii i destructorii se deosebesc de celelalte funcii membre prin cteva caracteristici specifice: numele funciilor constructor sau destructor este identic cu numele clasei creia i aparin; numele destructorului este precedat de caracterul tilde (~); la declararea i definirea funciilor constructor sau destructor nu se specific nici un tip de rezultat (nici tipul void); nu pot fi motenii, dar pot fi apelai de clasele derivate; nu se pot utiliza pointeri ctre funciile constructor sau destructor; constructorii pot avea parametri, inclusiv parametri implicii i se pot supradefini; destructorul nu poate avea parametri i este unic pentru o clas. Constructorul fr parametri se numete constructor implicit. Dac o clas nu are constructor i destructori definii, compilatorul genereaz automat un constructor implicit, respectiv un destructor implicit, care sunt funcii publice. Constructorii pot fi publici sau privai, dar, de regul, se declar cu acces public. Dac se declar constructorul private, nu se pot crea obiecte de acel tip. Acest lucru poate avea sens dac respectiva clas este destinat a folosi exclusiv ca i clas de baz pentru o ierarhie de clase derivate. Crearea, iniializarea i eliminarea obiectelor Se consider iniial clasa Punct definit anterior. Pentru a asigura iniializarea automat a obiectelor de tip Punct de la declarare, se pot defini constructori care s preia operaiile efectuate de Pag. 4/7

Programare C/C++ - Laborator nr. 10 funcia init(). Clasa Punct poate fi definit astfel: class Punct{ private: int x, y; public: Punct(int initx=0, int inity=0) { cout<<\nConstructor Punct\n; x=initx; y=inity;} ~Punct() { cout<<\nDestructor Punct\n; } int getx(){return x;} int gety(){return y;} void move(int dx, int dy); void afisare() {cout<<\nx=<<x<<\tz=<<y;} }; void Punct::move(int dx, int dy) { x+=dx; y+=dy; }

// constructor cu parametri implicii

// destructor

Pentru vizualizarea apelului funciei constructor s-a inclus afiarea unui mesaj. Clasa nu are nevoie de destructor, el ns a fost definit formal pentru a permite vizualizarea momentului n care se elimin obiectele de tip Punct. Se poate defini urmtorul program de testare: Punct Punct1(10, 5); // se declar obiectul Punct1, global, pentru care se preiau // valorile x=10 , y=5

void main() { cout <<\nIncepe functia main(); Punct1.afisare(); cout << \Sfarsit functia main(); } In urma execuiei programului, se afieaz: Constructor Punct Incepe functia main() x=10 y=5 Sfarsit functia main() Destructor Punct Se observ c obiectul global Punct1 se creeaz nainte de a ncepe execuia funciei main() i se elimin dup terminarea execuiei acesteia. n momentul declarrii obiectului Punct1 se apeleaz constructorul cu parametrii efectivi specificai. O declaraie de forma: Punct Punct2 ; Pag. 5/7

Programare C/C++ - Laborator nr. 10 are ca efect apelul constructorului cu valorile implicite ale parametrilor, deci membrii obiectului Punct2 vor prelua valorile x=0, y=0. class Punct{ private: int x, y; public: Punct() { cout<<\nConstructor implicit\n; x=0; y=0; } Punct(int initx, int inity) { cout<<\nConstructor cu parametri\n; x=initx; y=inity; } ~Punct() { cout<<\nDestructor Punct\n; } int getx(){ return x; } int gety(){ return y; } void move(int dx, int dy); void afisare() {cout<<\nx=<<x<<\tz=<<y;} };

// constructor implicit

// constructor cu parametri

// destructor

Clasa Punct a fost definit cu supradefinirea constructorilor. In momentul crerii unui obiect Punct fr specificarea parametrilor, se apeleaz constructorul implicit, altfel se apeleaz constructorul cu parametri. Destructorul este unic. void main() { Punct Punct1, Punct2(10, 20); Punct1.afisare(); Punct2.afisare(); } Programul afieaz: Constructor implicit Constructor cu parametri x=0 y=0 x=10 y=20 Destructor Punct Destructor Punct

Constructor de copiere La crearea unui obiect, acesta poate prelua valorile corespunztoare ale unui obiect deja existent, prin apelul unui constructor special, numit constructor de copiere. Pag. 6/7

Programare C/C++ - Laborator nr. 10 Declaraia constructorului de copiere pentru o clas este un constructor cu un parametru unic de tip referin la obiecte de tipul clasei ce se definete: nume_clasa( nume_clasa &); n absena definirii explicite a constructorului de copiere n cadrul clasei, compilatorul genereaz automat un constructor de copiere care iniializeaz datele membre ale obiectului nou creat cu valorile corespunztoare ale obiectului specificat. Punct P1(10, 15); Punct P2(P1); P2.afisare(); n declaraia clasei Punct se poate aduga constructorul de copiere care va avea prototipul: Punct (Punct &); i se definete: Punct::Punct(Punct &P) { cout<< \n Constructor de copiere; x=P.x; y=P.y; } Se pot crea obiecte copie a unor obiecte existente folosind declaraii similare exemplului anterior: Punct P2(P1);

// se genereaz un constructor de copiere implicit care va face // atribuirile P2.x=P1.x, P2.y=P1.y

Pag. 7/7