LUCRAREA NR.

CLASE ŞI OBIECTE

Clasele reprezintă principalul instrument pentru programarea orientată spre obiect din C++. O
clasă este foarte asemănătoare unei structuri prin faptul că grupează membrii ce corespund
datelor uni obiect, precum şi funcţii (numite metode) care operează asupra datelor. Un obiect este
un lucru, precum un telefon, o carte sau un fisier. O clasă C++ permite programelor să definească
atributele obiectului (caracteristicile sale). Gruparea într-o singură variabilă a datelor şi codului
unui obiect duce la simplificarea programării şi creşterea reutilizabiltăţii codului (capacitatea de a
folosi acelaşi cod într-un alt program).
• Pentru definirea unei clase, programul trebuie, să precizeze numele clasei, membrii de date
ai clasei şi funcţiile clasei (metode).
• Definiţia unei clase oferă un şablon pe baza căruia programele pot crea obiecte de tipul
acelei clase, destul de similar cu modul în care programele creează variabile de tip int,
char,etc.
• Atribuirea în programe a valorilor pentru membrii de date ai claselor se face prin
intermediul operatorului punct
• Invocarea de către program a funcţiilor membru ale unei clase (metode) se face prin
intermediul operatorului punct.

Asemenea unei structuri, o clasă în C++ trebuie să aibă un nume unic, urmat de o acoladă
deschisă, unul sau mai mulţi membrii şi o acoladă inchisă.

class nume_clasa{
int data_membru // Data membru
void afiseaza_membru(int); //Functie membru
}

După ce se defineşte clasa, se pot defini variabilele de tipul acelei clase (numite obiecte) :

Nume_clasa obiect_unu, obiect_doi, obiect_trei;

Programul următor prezintă un exemplu simplu de clasă:

#include <iostream.h>
#include <stdlib.h>
#include <string.h>
class zi_din_an
{
public:
int zi;
int luna;
int an;
void afisare(void) {
cout << "luna=" << luna;
cout << "ziua=" << zi;
cout << "an=" << an << endl;

};
};
 void main(void)
{
zi_din_an azi, zi_nastere;

cout << "Dati data de azi (zi luna, ex: 22 03 2007):\n";

cin >> azi.zi >> azi.luna >> azi.an;
cout << "Dati ziua de nastere:\n";
cin >> zi_nastere.zi >> zi_nastere.luna >> zi_nastere.an ;

cout << "Azi suntem in ";

azi.afisare();
cout << "Ziua dvs de nastere este ";
zi_nastere.afisare();
if (azi.zi==zi_nastere.zi
&& azi.luna==zi_nastere.luna
&& azi.an==zi_nastere.an)
cout << "La multi ani !\n";
else
cout << "O zi buna !\n";
return;

system("pause");
}

Următoarea definire ilustrează o clasă simplă numită Carte, clasă utilizată de program
pentru a afişa informaţii despre o carte:

#include <iostream.h>
#include <string.h>
#include <stdlib.h>

class Carte
{
public:
char titlu[256];
char autor[64];
float pret;
void arata_titlu(void)
{ cout<<titlu<<'\n';
}
float da_pret(void)
{ return(pret);
};
};
void main(void)
{
Carte volum;
strcpy(volum.titlu, "Print si cersetor");
strcpy(volum.autor, "Mark Twain");
volum.pret=150;
volum.arata_titlu();
cout<<"Pretul cartii este:"<<volum.da_pret()<<'\n';
system ("pause");
}
 Definiţia următoare creează o clasă angajat care conţine definiţiile variabilelor de date şi ale
metodelor :

#include <iostream.h>
#include <string.h>
#include <stdlib.h>

class angajat {
public:
char nume[64];
long angajat_id;
float salariu;
void afiseaza_angajat (void)
{
cout<< "Nume: " << nume << endl;
cout<< "Id: " << angajat_id << endl;
cout<< "Salariu: " << salariu << endl;
};
};

void main(void)
{
angajat muncitor, sef;
strcpy(muncitor.nume, "Popescu Ion");
muncitor.angajat_id = 1234;
muncitor.salariu = 450;
strcpy(sef.nume, "Ionescu Costel");
sef.angajat_id = 1;
sef.salariu = 1550;
muncitor.afiseaza_angajat();
sef.afiseaza_angajat();
system ("pause");
}

În exemplele prezentate se remarcă utilizarea etichetei public în cadrul definiţiei clasei.

Membrii claselor pot fi privaţi sau publici ceea ce determină modul în care programele pot accesa
respectivii membrii. În exemplele de mai sus toţi membrii sînt publici, ceea ce înseasmnă că
programul poate accesa orice membru prin intermediul operatorului punct.

Datele publice şi private

Aşa cum s-a văzut, programele pot accesa membrii publici din cadrul oricărei funcţii. Pe de
altă aparte membrii privaţi pot fi accesaţi de programe numai cu ajutorul funcţiilor clasei. Membrii
privaţi permit unei clase să ascundă acele informaţii ale clasei pe care programul nu are voie să le
cunoască sau să le accseze direct.
Clasele care folosesc membrii privaţi oferă funcţii de interfaţă care accesează acei membri
privaţi.

Următoarele exemple ilustrează utilizarea datelor publice şi private:

#include <iostream.h>
#include <string.h>
class Carte
 {
private:
char editura[256];
void arata_editura(void)
{ cout<<editura<<’\n’;}
public:
char titlu[256];
char autor[64];
float pret;
void arata_titlu(void)
{ cout<<titlu<<’\n’;}
float da_pret(void)
{ return(pret);};
void arata_carte(void)
{ arata_titlu();
arata_editura();};
void atrib_editura(char *nume)
{
strcpy(editura,nume);
};
};
void main(void){
Carte volum;
strcpy(vloum.titlu, "Print si cersetor");
strcpy(volum.autor, "Mark Twain");
volum.pret=100000;
volum.atrib_editura("Teora");
volum.arata_carte;
}
După cum se observă, metoda publică atrib_editura iniţializează membrul privat editura.
Dacă programul ar încerca să acceseze direct membrul editura, compilatorul ar fi generat o eroare.
În mod similar, programul utilizează metoda publică arată_carte, care la rãndul ei invocă metoda
privată arata_editura. Din nou, programul nu poate accesa direct o metodă privată.
Una din cele mai dificile probleme pe care le întâmpină programatorii neexperimentaţi în
programarea orientată pe obiecte este determinarea acelor membrii ai fiecărei clase pe care trebuie
să íi ascundă şi pe care trebuie să îi facă publici. Ca regulă generală, cu cât un program ştie mai
puţin despre clase, cu atât mai bine. În concluzie, este indicată utilizarea datelor şi metodelor
private cât mai des posibil.

Definirea funcţiilor claselor în interiorul şi în afara

C++ permite definirea metodelor în interiorul şi în exteriorul declaraţiei claselor. Decizia
care este luată în legătură cu plasarea definirii metodelor afectează codul pe care compilatorul îl
creează pentru program. Atunci cãnd o metodă este definită în cadrul clasei, compilatorul va trata
fiecare referinţă la metodă ca un apel la o funcţie inline plasãnd instrucţiunile corespunzătoare
funcţiei în codul obiect la fiecare referinţă la metodă. Utilizãnd codul inline se pot îmbunătăţi
performanţele programului dar totodată se măreşte şi dimensiunea acestuia. De aceea este indicat
să nu se ceară compilatorului generarea de cod inline decãt atunci când o clasă conţine o operaţie
comună şi de mici dimensiuni.
În exemplul următor metodele clasei sunt definite în exteriorul clasei.

#include <iostream.h>
#include <string.h>
#include <stdlib.h>
class Carte
{
private:
char editura[256];
void arata_editura(void);
public:
char titlu[256];
char autor[64];
float pret;
void arata_titlu(void);
float da_pret(void);
void arata_carte(void);
void atrib_editura(char *nume);
};
void Carte::arata_titlu(void)
{ cout<<titlu<<'\n';}
float Carte::da_pret(void)
{ return(pret);};
void Carte::arata_carte(void)
{ arata_titlu();
arata_editura();};
void Carte::atrib_editura(char *nume)
{
strcpy(editura,nume);
};

void Carte::arata_editura(void)
{ cout<<editura<<'\n';}
void main(void)

{
Carte volum;
strcpy(volum.titlu, "Print si cersetor");
strcpy(volum.autor, "Mark Twain");
volum.pret=150;
volum.atrib_editura("Teora");
volum.arata_carte();
system ("pause");
}

Un alt exemplu pentru definirea funcţiei în exteriorul clasei :

#include <iostream.h>
#include <string.h>
#include <stdlib.h>

class angajat {
public:
char nume[64];
long angajat_id;
float salariu;
void afiseaza_angajat(void);
};

void angajat::afiseaza_angajat(void)
 {
cout<< "Nume: " << nume << endl;
cout<< "Id: " << angajat_id << endl;
cout<< "Salariu: " << salariu << endl;
};

void main(void)
{
angajat muncitor, sef;
strcpy(muncitor.nume, "Popescu Ion");
muncitor.angajat_id = 1234;
muncitor.salariu = 450;
strcpy(sef.nume, "Ionescu Costel");
sef.angajat_id = 1;
sef.salariu = 1550;

muncitor.afiseaza_angajat();
sef.afiseaza_angajat();
system ("pause");
}

După cum se observă în exemplele de mai sus s-a folosit operatorul de rezoluţie globală (::)
pentru a specfifica numele funcţiei.
Deoarece clase diferite ar putea folosi funcţii cu acelaţi nume, este necesară precedarea
numelor de funcţii declarate în exteriorul claselor cu numele clasei, urmat de operatorul de
rezoluţie globală (::).
Un termen des utilizat în programarea orientată pe obiecte este termenul de încapsulare. în
cel mai simplu sens, încapsularea este combinarea de date şi metode într-o singură, structură de
date. Încapsularea defineşte, de asemenea, modalitatea în care obiectele însele şi restul
programului se pot referi la datele obiectului. Gruparea împreună a datelor obiectelor şi împărţirea
datelor în secţiuni publice şi private protejează datele faţă de utilizarea lor eronată în programe. În
C++, clasele reprezintă instrumentul fundamental de încapsulare.

Modul de lucru

1. Se vor edita şi rula programele din cadrul lucrării.

2. Să se realizeze un program ce foloseşte o clasă film cu următorii membrii: nume, actor
principal, actor secundar, o metodă pentru iniţializare a datelor, o metodă care prezintă
numele filmului şi actorii principali şi secundari. Programul va crea trei obiecte aparţinãnd
clasei film, le va iniţializa şi va afişa titlurile filmelor şi numele actorilor.
3. Să se realizeze un program pentru calculul valorii unui polinom într-un punct. Pentru
aceasta se va utiliza o clasă în care coeficienţii polinomului sunt de tip privat, o funcţie
pentru iniţalizarea valorilor coeficienţilor şi o funcţie pentru calculul valorii polinomului
într-un punct dat.
4. Să se realizeze un program care calculează data zilei de mäine cunoscänd data zilei de
astăzi folosind pentru aceasta o structură de tipul clasă.
5. Utilizänd o clasă pentru gruparea datelor şi metodelor, să se realizeze un program pentru
rezolvarea unei ecuaţii de gradul I şi un program pentru rezolvarea unei ecuaţii de gradul al
II-lea.