Cuprins

1.

Clase. ncapsularea sau abstractizarea datelor................................................................................. 1

2.

Obiecte instaniate din aceeai clas ................................................................................................ 4

3.

Referine ............................................................................................................................................ 5

4.

Exerciii.............................................................................................................................................. 6

1. Clase. ncapsularea sau abstractizarea datelor

O clas este o extindere a conceptului de structur din C standard. O prim extindere a
structurii a fost realizat n C++. Dac structura din C standard poate conine doar date, structura din
C++ poate conine att date ct i funcii, accesul la ele nefiind restricionat. Pasul urmtor n
extinderea structurii a fost restricionarea accesului la o parte din membrii acesteia. n mod implicit ns,
toi membrii unei structuri din C++ sunt publici, deci cu acces nerestricionat. Extinderea structurii din
C++, adic clasa, are n mod implicit toi membrii privai.
De regul, ntr-o clas se grupeaz i se protejeaz datele i funciile care prelucreaz aceste
date, n scopul rezolvrii unei anumite probleme. Deci clasa poate fi considerat un model de
organizare i prelucrare a datelor, numit i tip abstract de date (Abstract Data Types). Rezervnd
memorie pentru un set de date al unei clase, grupndu-le sub un nume i eventual iniializndu-le cu
valori concrete, vom obine o instaniere a clasei, numit obiect sau instan. Numele obiectului este o
variabil. Datele i funciile declarate n interiorul clasei se numesc membrii clasei. Datele membre ale
unei clase se mai numesc i cmpuri. Funciile membre se mai numesc i metode. Clasele sunt declarate
cu ajutorul cuvntului cheie class, folosind urmtoarea sintax:
class NumeClasa {
private:
[tip1] membruPrivat1;
[tip2] membruPrivat2;
...
public:
[tip1] membruPublic1;
[tip2] membruPublic2;
...
};

Obiectele sunt declarate ca orice fel de variabile:

NumeClasa numeObiect1, numeObiect2, ...;

Modul de acces poate fi definit prin unul din cuvintele cheie public, private sau
protected. Acesta indic dreptul de acces la membrii definii dup el.

Membrii declarai cu private sunt accesibili doar membrilor din cadrul aceleiai clase. Membrii
declarai cu public sunt accesibili att membrilor din cadrul aceleiai clase ct i membrilor altor clase,
de oriunde, din interiorul sau din afara acelor clase. Membrii declarai cu protected sunt accesibili
att membrilor aceleiai clase ct i membrilor claselor derivate din ea.
n mod implicit, toi membrii unei clase au modul de acces private.
De exemplu:
class Dreptunghi {
int lungime, latime;
public:
void setLungime (int);
void setLatime (int);
int arie (void);
};

Exemplul declar o clas (adic un tip de dat abstract) numit Dreptunghi. Aceasta conine
cinci membri: dou cmpuri de tip int (lungime i latime) cu modul de acces privat i trei metode cu
modul de acces public: setLungime(int), setLatime(int) i arie(). Pentru moment am inclus
doar declaraia acestor metode, nu i definiia lor.
Pentru a declara un obiect (o variabil) cu numele dr, vom folosi urmtoarea instruciune:
Dreptunghi dr;

unde Dreptunghi reprezint numele clasei, iar dr obiectul instaniat. Prin aceast instruciune,
se aloc obiectului dr o zon de memorie corespunztoare membrilor de tip dat (cmpuri) de lungime
2 * sizeof(int) = 8 octei, cmpurile nefiind iniializate.
n afara clasei, cu ajutorul acestui obiect putem accesa membrii publici, folosind urmtoarea
sintax:
numeObiect.numeMembru;

Accesul la membrii unei clase este foarte asemntor cu accesul datelor dintr-o structur. De
exemplu:
dr.setLatime(10);
dr.setLungime(20);
valArie = dr.arie();

Singurii membri ai obiectului dr pe care nu-i putem accesa n corpul programului nostru, din
afara clasei, sunt lungime i latime, deoarece au accesul privat.
n continuare, vom completa clasa Dreptunghi cu definiia metodelor membre:
// exemplu de clasa
#include <conio.h>
#include <iostream>
using namespace std;
class Dreptunghi {
int lungime, latime;
public:
// metode definite in corpului clasei
void setLungime (int L)

{
lungime = L;
}
void setLatime (int l)
{
latime = l;
}
int arie (void);
};
/* metoda care urmeaza este definita in afara corpului clasei */
int Dreptunghi::arie (void)
{
return lungime * latime;
}
int main()
{
Dreptunghi dr;
dr.setLatime(10);
dr.setLungime(20);
cout << "arie: " << dr.arie() << endl;
_getch();
return 0;

}
Ieire
arie: 200
n afara corpului clasei, n definirea metodei arie(), se observ utilizarea unui operator nou,
numit operator de rezoluie, fiind simbolizat prin dou perechi de dou puncte ( :: ). Acest operator
arat domeniul (n cazul de fa clasa), cruia i aparine metoda. Menionm c este obligatorie
utilizarea operatorului de rezoluie pentru definirea unei metode n afara clasei. Declaraia (prototipul)
metodei definite n afara clasei, trebuie s fie n mod obligatoriu n corpul clasei.
Remarcm definiiile metodelor setLungime(int) i setLatime(int)care au fost incluse
direct n corpul clasei Dreptunghi, datorit faptului c acestea sunt foarte simple.
Membrii lungime i latime au modul de acces privat. Declarandu-i privai, interzicem
accesarea lor direct de ctre orice funcie din afara clasei. Iniializarea cmpurilor din interiorul
obiectului este posibil, deoarece am definit metodele membru setLungime(int) i
setLatime(int), care seteaz valorile cmpurilor lungime i latime. Datorit lor, n restul
programului, nu este necesar (dar nici posibil) s se acceseze direct cmpurile clasei.
Observaie
n cadrul exerciiilor ce vor fi rezolvate la laboratorul de POO, toate declaraiile de clase se vor
face n fiierele antet (header), la fel ca i declaraiile de alte tipuri. Tot aici vom declara i eventualele
funcii globale. Definiia metodelor se va face n fiierul (fiierele) .cpp asociate antetului.

Posibilitatea de a ascunde utilizatorului unei clase detaliile ei de realizare, se numete

ncapsulare sau abstractizare a datelor. Utilizatorului i este oferit doar un set de membri publici,
suficieni pentru a utiliza clasa. Aceti membri publici constituie interfaa clasei. Membrii inaccesibili din
exterior sunt declarai privai sau protejai i realizeaz implementarea clasei.
ncapsularea sau abstractizarea datelor este unul dintre cele trei principii de baz ale
programrii orientate pe obiecte. Celelalte dou principii: motenirea i polimorfismul, le vom studia n
laboratoarele urmtoare (6 i 7).

2. Obiecte instaniate din aceeai clas

Putem avea mai multe obiecte instaniate din aceeai clas. Dezvoltnd exemplul anterior,
putem declara al doilea obiect drept de tip Dreptunghi:
// exemplu: o clasa, doua obiecte
#include <conio.h>
#include <iostream>
using namespace std;
class Dreptunghi {
int lungime, latime;
public:
void setLungime (int L) {lungime = L;}
void setLatime (int l){ latime = l;}
int arie (void);
};
int Dreptunghi::arie (void)
{
return lungime * latime;
}
int main()
{
Dreptunghi dr;
dr.setLatime(10); dr.setLungime(20);
Dreptunghi drept;
drept.setLatime(5); drept.setLungime(6);
cout <<"arie obiect dr: "
<< dr.arie() << endl;
cout <<"arie obiect drept: "
<< drept.arie() << endl;
_getch();
return 0;
}

Ieire
arie obiect dr: 200
arie obiect drept: 30
n acest caz, avem dou instane de tip Dreptunghi: dr i drept. Fiecare obiect are propriile
valori pentru cmpuri i poate accesa metodele clasei. Se explic astfel de ce rezultatele sunt diferite,
dei este apelat aceeai metod: arie().

3. Referine
n C++ o funcie poate primi parametri n dou feluri prin valoare sau prin referin.
Transmiterea parametrilor prin valoare este cea obinuit, cunoscut pn acum din limbajul C. Un
parametru transmis prin valoare, dac este modificat n funcie, nu i va pstra valoarea modificat n
funcia apelant. De exemplu, n programul de mai jos, funcia schimba() este greit i nu va avea nici
un efect asupra parametrilor primii:
/*exemplu eronat cu transmiterea parametrilor prin valoare */
#include<conio.h>
#include<iostream>
using namespace std;
void schimba(int a, int b) {
int aux = a;
a = b;
b = aux;
}
int main() {
int a = 2, b = 3;
cout << a << " " << b << endl;
schimba(a,b);//a si b raman neschimbate
cout << a << " " << b << endl;
_getch();
return 0;
}

Ieire:
2 3
2 3

ns n limbajul C++, putem s transmitem parametrii prin referin. n acest caz, modificrile
efectuate n funcie, asupra parametrilor, vor rmne i n funcia apelant. Pentru a transmite un
parametru prin referin, n declaraia funciei vom pune operatorul & n faa numelui parametrului. De
exemplu, funcia schimba() cu parametri referin va fi declarat astfel:
void schimba(int &a, int &b);

Dac efectum aceast modificare n exemplul de mai sus, rezultatul va fi:

2 3
3 2

Putem utiliza o astfel de funcie ntr-un algoritm de sortare, n locul funciei cu pointeri
cunoscute din semestrul trecut, de la Programarea Calculatoarelor:

void schimba(int *pa, int *pb) {

int aux = *pa;
*pa = *pb;
*pb = aux;
}

Referina se definete ca un nume alternativ pentru variabil.

De asemenea, este posibil s returnm o variabil prin referin. n acest caz, nu se mai face
copierea variabilei din stiva funciei apelate n stiva funciei apelante.
De exemplu:
int& max(int& a, int& b) {
return a > b ? a : b;
}

Referinele au un rol important n implementarea claselor. Vom reveni la ele n laboratoarele

ulterioare.

4. Exerciii
1. S se scrie o clas Punct care reprezint un punct din plan. Clasa va conine:

cmpurile private x, y n dubl precizie;

metodele setX(), setY() care seteaz valorile celor dou cmpuri;

metodele getX(), getY();

metoda void afis() care afieaz coordonatele punctului.

n main(), s se testeze clasa Punct cu toate metodele ei

prin definirea i afiarea coordonatelor a trei puncte.
2. S se implementeze clasa Multime, care s pstreze o mulime de ntregi. Clasa trebuie s aib
urmtoarele metode publice:
void init() care iniializeaz cmpurile private ale mulimii;

void adauga(int)care adaug un element n mulime. n cazul n care elementul deja

exist, mulimea rmne nemodificat;

void extrage(int) care extrage un element din mulime. n cazul n care elementul
nu este prezent, mulimea rmne neschimbat;

void afisare() care afieaz mulimea.

Folosii urmtorul program pentru a testa mulimea:
int main() {
Multime m;
m.init();
m.adauga(4);
m.adauga(3);
m.afisare();

m.extrage(4);
m.afisare();
m.adauga(9);
m.adauga(2);
m.afisare();
_getch();
return 0;
}

Indicaie: folosii un vector pentru a stoca elementele.

3. S se scrie o clas Data care s reprezinte o dat calendaristic. Clasa va conine urmtorii membri:
cmpurile zi, luna, an ntregi, privai;
metoda setValori(int z, int l, int a) care s seteze valorile celor trei cmpuri;
metoda afisare() care afieaz data la consol.
Putei aduga i ali membri dac este cazul.
Pe baza clasei Data s se implementeze cerinele de mai jos:
3.1
S se scrie un program care s citeasc i s afieze
un vector de n date.
3.2
S se adauge metoda int maiMare(Data data2),
care realizeaz compararea dintre dou date. n aceast metod sunt accesibile dou obiecte de tip
Data. Unul este obiectul curent, iar cellalt parametrul data2. Metoda returneaz 1 dac data curent
(din obiectul curent) este mai mare dect data2 i 0, n caz contrar.
S se determine data cea mai mare din vector. Pentru
compararea datelor se va folosi metoda maiMare .
3.3
S se adauge metoda afisareLunga() care afieaz
data n formatul 29 august 2008. S se afieze datele citite n ambele formate: normal (zz.ll.aaaa) i
lung.
S se adauge metoda ziDinSaptamana() care s
returneze ziua din sptamn pentru obiectul curent de tip Data. De exemplu, pentru luni va returna 1,
iar pentru duminic 7. Pentru simplitate, pentru orice an, s se considere zilele din sptmn la fel ca
pentru anul 2008, tiind c acest an ncepe mari.
De exemplu, pentru datele:
03.09.2008
21.10.2008

Metoda ziDinSaptamana() va returna:

3
2

S se adauge metoda afisareCompleta() care

afieaz data n urmtorul format:

3 septembrie 2008, miercuri

Metoda va folosi ziDinSaptamana(). S se afieze datele citite n toate cele trei formate.
3.4
S se adauge metoda int diff(Data data2) care
returneaz diferena n zile dintre data curent i data pstrat n parametrul data2. Aceast diferen
poate fi un numr negativ, 0, sau un numr pozitiv. Pentru simplitate putei considera toi anii nebiseci.
S se sorteze datele n ordine cresctoare i s se
afieze diferenele dintre oricare dou date consecutive.
De exemplu, pentru datele citite:
03.09.2007
03.09.2008
21.10.2008

Rezultatul va fi:
3 septembrie 2007, miercuri
peste 365 zile
3 septembrie 2008, miercuri
peste 48 zile
21 octombrie 2008, marti