Sunteți pe pagina 1din 3

PROGRAMAREA ORIENTATĂ PE OBIECTE - Laborator 

Lucrarea de laborator 3.
Crearea claselor şi lucrul cu obiecte în C++

Organizarea programelor sub forma unor înlănţuiri de clase reprezintă următorul pas după ce s-a
deprins lucrul cu funcţiile şi construcţia structurilor de date. Pentru cine este obişnuit cu acestea,
definirea şi lucrul cu clase li se va părea ca şi cum ar avea o structură de date (struct) căreia i s-au
asociat o serie de funcţii. Dar asemănările din păcate se opresc aici, deşi imaginea simplificatoare este
în mare parte valabilă. Odată cu avantajele utilizării claselor apar şi unele restricţii. Funcţiile definite în
clasă (care poartă numele de funcţii membre ale clasei) au acces preferenţial asupra datelor definite în
interiorul clasei şi uneori pot fi chiar singurele funcţii ce au acces la aceste date. Pe de altă parte datele
din clasă sunt de cele mai multe ori inaccesibile din afară, doar funcţiile membre le pot citi şi modifica.
Important de reţinut sunt avantajele pe care le aduce folosirea claselor :
Încapsularea, Polimorfismul şi Moştenirea.
Încapsularea înseamnă că datele clasei nu sunt accesibile din afară ci mai întotdeauna sunt
accesate prin medierea funcţiilor membre (nu înseamnă că nu se pot accesa datele ci doar că clasele au
fost concepute să funcţioneze astfel).
Polimorfismul înseamnă că putem defini o funcţie de mai multe ori, astfel încât să accepte
diferite combinaţii de parametri şi să realizeze aceeaşi sarcină folosind parametri diferiţi dar specificaţi
(funcţia va avea acelaşi nume dar va diferi numărul şi tipul parametrilor la fiecare declarare).
Moştenirea presupune că caracteristicile unei clase – datele şi funcţiile – sunt puse la dispoziţia
sau mai degrabă devin baza pe care se construieşte altă clasă. Astfel clasa nou creată – clasa derivată –
va moşteni elementele clasei de bază. Se pot crea clase prin moşteniri succesive, sau prin moştenirea
mai multor clase deodată. Clasa derivată va putea defini noi funcţii şi date în completarea celor
moştenite.

Definirea unei clase se face astfel:

class nume_clasa{
tip1 data1;
tip2 data1[10];

tipn datan;
specificator1:
nume_clasa(…);
~nume_clasa(…);
tip1 functie1(…);
specificator2:
tip2 functie2(…);

tipn functien(…):
} [obiect1],[obiect2…];
PROGRAMAREA ORIENTATĂ PE OBIECTE - Laborator 

Aceasta este structura generală de definire a unei clase. Se observă cuvântul cheie class de la
început, acesta se va regăsi în toate definiţiile de clase.
Specificator1…n sunt specificatori de acces care stabilesc accesul la membrii clasei cei care se
găsesc după el fiind afectaţi, până ce apare un nou specificator de acces.
nume_clasa(…) este o funcţie constructor a clasei, se apelează automat când se declară un
obiect de clasa respectivă.
~nume_clasa(…) este o funcţie destructor a clasei, se apelează când s-a terminat lucrul cu
obiectul definit, pentru a elibera memoria.
Tipk functiek(…) este o funcţie membră a clasei.
După ce s-a definit clasa trebuie definite şi funcţiile membre. În general pentru definirea unei
funcţii membre a clasei, în afara acesteia se foloseşte operatorul de specificare a domeniului (sau
operator de rezoluţie) :: . Exemplu:

tipk nume_clasa::functiek(…)
{
// scriem continutul functiei
return tipk;
}

În definiţia clasei observăm că opţional se pot defini variabile de tipul clasei numite obiecte.
Pentru a accesa membrii clasei atunci când avem declarat un obiect vom folosi operatorul de selecţie ‘.’
(punct) atunci când lucrăm cu obiectul sau operatorul de selecţie indirectă -> (minus, mai mare) atunci
când lucrăm cu pointer spre obiect. Astfel:

nume_clasa obiect1,obiect2,* obiect3; // definire obiecte


obiect1.functiek(…);
obiect2.functiek(…);
obiect3->functiek(…); // având un pointer spre un obiect
Specificatorii de acces tipici sunt:
• private (setat implicit pentru toţi membrii unei clase);
• public;
• protected.
Primii doi în special public sunt cei mai utilizaţi. Private interzice accesul oricărui nemembru al
clasei. Public permite accesul oricui la membrii clasei. Protected specifică că membrii declaraţi
protected în clasa de bază vor putea fi accesaţi în cazul unei moşteniri fără specificatori de către clasa
derivată. Pentru a avea acces fără protected la membrii clasei de bază la moştenire clasa tată va fi
moştenită de clasa fiu în mod public.
Pentru a specifica că o nouă clasă moşteneşte pe altele vom folosi structura:

class clasa_nouă(derivată):[specificator1] clasa_de_bază1[,[specificator 2] clasa_de_bază2,…]


{
//noi elemente specifice clasa_derivată
};

Astfel o clasa_derivată poate moşteni una sau mai multe clasa_de_bază, moştenirea fiind filtrată
prin specificatorii de acces ce precedă clasa_de_bază moştenită. (Este bine ca aceşti specificatori să fie
– public - pentru ca accesul clasei derivate (fiu) să fie permis la toţi membrii clasei de bază (tată)
PROGRAMAREA ORIENTATĂ PE OBIECTE - Laborator 

indiferent de specificatorii din aceasta clasa de_bază (tata), aceasta deoarece specificatorul implicit este
private în cazul unei moşteniri fără precizarea specificatorului).
La apelarea unei funcţii membre, aceasta este informată asupra identităţii obiectului asupra
căruia va acţiona prin transferul unui parametru implicit care este adresa obiectului.
De exemplu, în cazul apelului:
ob.verificare(i); funcţia verificare() primeşte şi adresa obiectului ob, în afară de valoarea i. De
asemenea există cazuri în care adresa obiectului este necesar să fie utilizată în definiţia funcţiei. Acest
lucru este realizat în C++ de cuvântul cheie this, asociat unui pointer către obiectul pentru care s-a
apelat funcţia. Cuvântul this are sens şi poate apare numai în definiţia unor funcţii membre.
Pentru a ne referi la un membru al clasei din interiorul unei funcţii membru vom folosi apelare:
this->membru=.

Exerciţiul 1.
Realizati un program utilizând clase de obiecte, ce permite calculul salariului net a unui angajat.
Se va defini o clasă salariu având salariu de bază, numărul de ore suplimentare lucrate si tariful orar
pentru orele suplimentare. Clasa va avea o funcţie de introducere date şi funcţii de calcul şi afişare
salariu net. Salariul net va fi 70% din salariul brut ce se va calcula ca suma dintre salariul de bază şi
valoarea orelor suplimentare.

Exerciţiu 2.
Definiţi o clasa cu numele persoana, cu următoarele date: nume, prenume, adresa (strada-
nr),vârstă, cnp. Definiţi o funcţie constructor şi una destructor.
Definiţi funcţiile introduce_nume, introduce_adresa, introduce_varsta , introduce_cnp care să
citească de la tastatura datele respective. Definiţi alte funcţii care sa afişeze aceste date, separat pentru
fiecare dată în parte şi toate la un loc. Nu folosiţi deocamdată nici un specificator de acces. Încercaţi să
afisaţi numele unei persoane prin accesarea directă a datei respective. Se poate?. Ce trebuie schimbat
dacă nu?. La fel încercaţi să folosiţi o funcţie membră a clasei fără a avea un specificator de acces în
clasă. Cum trebuie modificat programul pentru ca accesul la datele membre să fie interzis şi accesul la
funcţii membre permis?

Exerciţiul 3.

Definiţi o clasă angajat prin moştenirea (derivarea) clasei persoana, care să aibă suplimentar
următoarele date: nume_firma, salariu_net, data_angajarii (de tip char în format zz-ll-aaaa). Creaţi şi
pentru aceasta clasă funcţii de citire a datelor noi, de afişare a datelor noi, de transfer de date. Faceţi
moştenirea fără precizarea unui specificator de acces. Vă este permis accesul direct la numele persoanei
din clasa angajat ? Ce trebuie modificat ? Scrieţi o funcţie externă claselor pentru a afişa informaţii
despre angajat. Aveţi acces la membrii clasei?