Ministerul Educaţiei al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul ISA

Raport
Lucrare de Laborator Nr. 2
LA DISCIPLINA “PROGRAMAREA ORIENTATĂ PE OBIECT”

Tema : Încapsularea ca principiu al POO.

Încapsularea prin intermediul claselor.

A efectuat : st. Gr.

A verificat: asistent universitare

Scrob Sergiu
 Chişinău 2018

1. Obiective
- Formarea unei imagini generale, preliminare, despre programarea orientată pe obiecte (POO) şi
deprinderea cu noile facilitaţi oferite de limbajul C++.
- Studierea principalelor concepte (caracteristici) ale POO: abstractizarea, incap.....
- crearea unei aplicaţii de tip consolă în limbajul de programare
C++. Să se ofere răspuns la lista de întrebari adresate mai jos. Studentul trebuie să realizeze un
raport de tip document (doc sau docx) care să includă pagina de titlu, tema, sarcina si obiectivele
lucrării, lista de întrebarile şi răspunsuri, codul sursă a aplicaţiei, rezultate - imagini screenshot a
aplicatiei, concluzie personală referitor la această lucrare

2. Sarcina lucrării
Aplicaţia 1
Să se dezvolte aplicaţia de la laboratorul 1 care respecta încapsularea ca principiu POO.

Aplicaţia 2
Să se scrie o aplicaţie care implementează o stivă cu ajutorul unui tablou. Se vor implementa
funcţiile de adăugare în stivă, scoatere din stivă, afişare a stivei (toate elementele). Sa se utilizeze obiecte de
tipul clasei utilizate în Aplicatia 1 ca elemente, pentru a fi adaugate în stivă.

3. Teoria
În C++ încapsularea este îndeplinită prin două aspecte:

1. folosirea claselor pentru unirea structurile de date şi a funcţiilor destinate manipulării lor;
2. folosirea secţiunilor private şi publice, care fac posibilă separarea mecanismului intern de
interfaţa clasei;
O clasă reprezintă un tip de date definit de utilizator, care se comportă întocmai ca un tip predefinit
de date. Pe lângă variabilele folosite pentru descrierea datelor, se descriu şi metodele (funcţiile) folosite
pentru manipularea lor.
Instanţa unei clase reprezintă un obiect - este o variabilă declarată ca fiind de tipul clasei definite.
Variabilele declarate în cadrul unei clase se numesc variabile membru, iar funcţiile declarate în
cadrul unei clase se numesc metode sau functii membru. Metodele pot accesa toate variabilele declarate în
cadrul clasei, private sau publice.
Membrii unei clase reprezintă totalitatea metodelor şi a variabilelor membre ale clasei.

Sintaxa declarării unei clase este următoarea:

specificator_clasa Nume_clasa
{
[ [ private : ] lista_membri_1]
[ [ public : ] lista_membri_2]
};

Specificatorul de clasă specificator_clasa poate fi:

 - class;
- struct;
- union;
- Numele clasei (Nume_clasa) poate fi orice nume, în afara cuvintelor rezervate limbajului C+
+. Se recomandă folosirea de nume cât mai sugestive pentru clasele folosite, precum şi ca denumirea
claselor să înceapă cu literă mare. (ex: class Elevi)
-
- Folosind specificatorii de clasă “struct” sau “union” se descriu structuri de date care au
aceleaşi
- proprietăţi ca şi în limbajul C (neobiectual), cu câteva modificări :
- - se pot ataşa funcţii membru;
- pot fi compuse din trei secţiuni - privată, publică şi protejată (folosind specificatorii de
acces private, public şi protected);
-
- Diferenţa principală între specificatorii “class”, “struct” şi “union” este următoarea: pentru o
clasă declarată folosind specificatorul “class”, datele membre sunt considerate implicit de tip private, până
la prima folosire a unuia din specificatorii de acces public sau protected. Pentru o clasă declarată folosind
specificatorul “struct” sau “union”, datele membre sunt implicit de tip public, până la prima folosire a unuia
din specificatorii private sau protected. Specificatorul protected se foloseşte doar dacă este folosită
moştenirea.
-
- Descrierea propriu-zisă a clasei constă din cele doua liste de membrii, prefixate de cuvintele
-cheie “private” şi/sau “public”.
- Membrii aparţinând secţiunii “public” pot fi accesaţi din orice punct al domeniului de
existenţă al respectivei clase, iar cei care aparţin secţiunii “private” (atât date cât şi funcţii) nu pot fi
accesaţi decât de către metodele clasei respective. Utilizatorul clasei nu va avea acces la ei decât prin
intermediul metodelor declarate în secţiunea public (metodelor publice).
-
- Definirea metodelor care aparţin unei clase se face prefixând numele metodei cu numele
clasei, urmat de “::”. Simbolul “::” se numeşte “scope acces operator” (operator de rezoluţie sau operator
de acces) şi este utilizat în operaţii de modificare a domeniului de vizibilitate.
-
- Exemplu:
-
-- class Stiva
- {
- int varf;
- int st[30];
- public:
- void init (void);
- …
- };
-
-- void Stiva :: init (void)
-- {
- - …
- }
-
-
- În stânga lui “::” nu poate fi decât un nume de clasa sau nimic, în cel de-al doilea caz
prefixarea
- variabilei folosindu-se pentru accesarea unei variabile globale (vezi laboratorul 1).
- În lipsa numelui clasei în faţa funcţiei membru nu s-ar putea face distincţia între metode care
poartă nume identice şi aparţin de clase diferite.
-
Exemplu:
class Stiva
{
public:
void init (void);
…
};
class Elevi
{
public:
void init (void);
…
};
void Stiva :: init (void) // metoda clasei Stiva
{
…
}
void Elevi :: init (void) // metoda clasei Elevi
{
…
}
-
- Accesarea membrilor unui obiect se face folosind operatorul “.” Dacă obiectul este accesat
indirect,
- prin intermediul unui pointer, se foloseste operatorul "->"
- După cum s-a mai spus, variabilele membru private nu pot fi accesate decât de metode
care aparţin clasei respective.

4. Întrebări
1. Ce este încapsularea?

Încapsularea este proprietatea unei clase de a schimba drepturile de acces la proprietățile și

metodele sale.

2. Ce este o clasa?

Clasa este o colecție de obiecte cu aceeași structură și același comportament.

3. Ce este un obiect?

Este o structură de date care are anumite proprietăți și metode.

4. Ce este o funcţie membra?

Funcție membră este o acțiune pe care o poate face obiectul.

5. Care este diferenţa între clase şi structuri?

Clasa este o colecție de obiecte, structura este o grupare de variabile.

6. Pentru ce este utilizat "scope acces operator"?

Pentru a restriction accesul la metode/proprietăți.

 7. Variabilele membru private pot fi accesate şi în afara clasei respective?

Direct – nu. Pentru a fi accesate, este nevoie de a define metode publice ce vor putea accesa
acestea.

5. Cod sursă
Aplicația 1:

#include <iostream>
#include <typeinfo>
using namespace std;

class Time {
private:
int ore,minute, secunde;

public :
Time () {}

Time (int h, int m, int s) {

ore = h;
minute = m;
secunde = s;
}

void SetOre (int x) {

if (x >= 0 && x <= 24)
ore = x;
else
ore = x%24;
}

void SetMinute (int x) {

if (x >= 0 && x <= 60)
minute = x;
else
minute = x % 60;
}

void SetSecunde (int x) {

if (x >= 0 && x <= 60)
secunde = x;
else
secunde = x % 60;
}

int GetOre () {
return ore;
}

int GetMinute () {
return minute;
}
 int GetSecunde () {
return secunde;
}

void Afisare () {
cout << "Ora " << ore << " si " << minute << " minute" << " si " << secunde << "
secunde;\n";
}
};

main () {
Time *t1;
t1 = new Time(0, 0, 0);
int in;

//////////////////////////////////////////////////////////
do {//setam Ora
cout << "Dati ora:";
cin >> in;

if (cin.fail()) {
cout << "Valoarea data este incorecta!" << endl;
cin.clear();
cin.ignore(512, '\n');
continue;
}

break;
} while (true);

t1->SetOre(in);

//////////////////////////////////////////////////////////
do {//setam Minutele
cout << "Dati minute:";
cin >> in;

if (cin.fail()) {
cout << "Valoarea data este incorecta!" << endl;
cin.clear();
cin.ignore(512, '\n');
continue;
}

break;
} while (true);

t1->SetMinute(in);

//////////////////////////////////////////////////////////
do {//setam Secundele
cout << "Dati secundele:";
cin >> in;
 if (cin.fail()) {
cout << "Valoarea data este incorecta!" << endl;
cin.clear();
cin.ignore(512, '\n');
continue;
}

break;
} while (true);

t1->SetSecunde(in);
//////////////////////////////////////////////////////////

t1->Afisare();//afisam datele

return 0;
}

Aplicația 2:

#include <iostream>
#include <typeinfo>
#include <string.h>
#include <stack>

using namespace std;

class Time {
private:
int ore, minute, secunde;

public :
Time () {}

Time (int h, int m, int s) {

ore = h;
minute = m;
secunde = s;
}

void SetOre (int x) {

if (x >= 0 && x <= 24)
ore = x;
}

void SetMinute (int x) {

if (x >= 0 && x <= 60)
minute = x;
}

void SetSecunde (int x) {

if (x >= 0 && x <= 60)
secunde = x;
}
 int GetOre () {
return ore;
}

int GetMinute () {
return minute;
}

int GetSecunde () {
return secunde;
}

void Afisare () {
cout << "Ora " << ore << " si " << minute << " minute" << " si " << secunde << "
secunde;\n";
}
};

void AfisareStiva (stack <Time *> stiva) {

stack <Time *> temp = stiva;

while (!temp.empty()) {
Time* t = temp.top();
temp.pop();

t->Afisare();
}

cout << '\n';

}

main () {
int n;
cout<<"Dati numarul de obiecte:";
cin>>n;

stack <Time *> stiva;

for (int i=0; i<n; i++) {

int in;
Time *t1 = new Time();
cout << endl << "Dati datele obiectului "<< i + 1 <<" a clasei Time:\n";
//////////////////////////////////////////////////////////
do {//setam Ora
cout << "Dati ora:";
cin >> in;

if (cin.fail()) {
cout << "Valoarea data este incorecta!" << endl;
cin.clear();
cin.ignore(512, '\n');
continue;
}
 break;
} while (true);

t1->SetOre(in);

//////////////////////////////////////////////////////////
do {//setam Minutele
cout << "Dati minute:";
cin >> in;

if (cin.fail()) {
cout << "Valoarea data este incorecta!" << endl;
cin.clear();
cin.ignore(512, '\n');
continue;
}

break;
} while (true);

t1->SetMinute(in);

do {//setam Secundele
cout << "Dati secundele:";
cin >> in;

if (cin.fail()) {
cout << "Valoarea data este incorecta!" << endl;
cin.clear();
cin.ignore(512, '\n');
continue;
}

break;
} while (true);

t1->SetSecunde(in);
stiva.push(t1);
}

cout << "\nStiva initiala:\n";

AfisareStiva(stiva);

do {//facem eliminarea
cout << "\nDoriti sa eliminati ultimul element(d/n):";
char chr[1];
cin >> chr;
if (strcmp(chr, "d") == 0) {
stiva.pop();
cout << "\nStiva dupa eliminare ultimului element intrat:" << endl;
AfisareStiva(stiva);
}
else
 break;
} while (true);

return 0;
}

6. Rezultate (imagini)
Aplicația 1:

Aplicația 2:
7. Concluzie
În urma efectuarii acestui laborator, am conceput mai bine câteva principii de baza a POO.
Am conceput mai bine noțiunea de clase, metode, proprietăți, constructori. Am lucrat cu pointerii și cu
obiectele. Am instanțiat obiete ale clasei definite. Am lucrat cu incapsularea, atribuind modificatori de
acces proprietăților și metodelor clasei. Am lucrat cu structuri dinamice de date, folosindule ca container
pentru obiecte. Toate aceastea vor servi ca bază în lucrul ulterior cu clasele în C++.