Clase de bază în C++

Class: Un tip de dată definit de programator de descrie caracteristicile unui obiect, ca de exemplu o mașină ce are
diferite atribute, gen marca, culoarea, anul fabricației, etc. și asigură și niște funcții precum mersul înainte, viraje,
mersul cu spatele, semnalizarea, etc.
O clasă grupează la un loc date (atribute) și comportamente (metode) ce prelucrează datele din clasă alături de altele.
O clasă are următoarele proprietăți:- abstractizare;- încapsulare;- moștenire;- polimorfism;
De multe ori clasa este definită întrun fișier header (.h) și apoi implementarea metodelor se pun întrun fișier .cpp
separat.
În cazul unei clase modificatorii de acces definesc cine poate accesa atributele / metodele din clasă. Avem trei tipuri:
- public: poate fi accesat de oriunde
- private: poate fi accesat doar în interiorul clasei
- protected: poate fi accesat doar în interiorul clasei și din clasele ce moștenes caceastă clasă ( clase derivate )
Evident că cine are acces la codul sursă poate modifica orice în acesta, dar dacă avem un dll compilat sau altceva
compilat, în acele fișiere nu se poate modifica nimic și membrii vor rămâne cu nivelul de acces/protecție stabilite.
În mod implicit datele din clasă se consideră private. De obicei atributele (reprezentarea) se declară private și se
folosesc funcții (getter/setter) pentru accesa atributele.
Clasele se definesc în mod asemănător cu struct-ul, sub forma:
class nume{
// zona în care se declară eventual definesc membrii privați
public: //zona în care se declară eventual definesc membrii publici;
private: //zona în care se declară eventual definesc membrii publici;
protected: // zona în care se declară eventual definesc membrii protejați;
}[opțional obiecte]; /dacă nu declar nici un obiect este obligatorie utilizarea ; după } .
Nu este obligatorie specificarea tuturor celor trei zone ci doar a celor necesare. În mod normal, ceva trebuie să fie
public, în caz contrar clasa nefiind utilizabilă.
De exemplu:
Class Rational{
public:
int getNumarator() {return a;}//1
int getNumitor() {return b;}
void scrie();
private:
int a,b;};
Se pot defini metode direct în momentul declarării unei clase, așa-numitele metode inline. Putem folosi
metode inline doar pentru metode simple (fără cicluri) deoarece compilatorul inserează (inline) corpul
metodei în fiecare loc unde se apelează metoda.
Pentru metodele din interiorul unei clase datele se comportă ca variabile globale, neffind necesară
parametrizarea lor. Ca și în cazul structului, nu există nici o legătură între date ale clasei și variabile de un
anumit tip de dată declarate la fel, acestea putând coexista.
De exemplu, dacă declarăm int a; nu e nici o legătură implicită între această variabilă și câmpul a tot de tip
int din clasa Rational.
Putem accesa un câmp (atribut) al unei clase folosind pointerul this . Util dacă avem mai avem variabile cu
același nume în metodă (parametru, variabilă locală). Întotdeauna this este pointer la instanța curentă. Avem
acces la acest pointer în toate metodele clasei, toate metodele membre din clasă au acces la this, al lor. Dacă
avem 3 variabile de tipul unei clase, fiecare are propriul this .
De exemplu metoda //1 putea fi scrisă și:
int getNumarator () {return this->a; }
Este foarte util acest pointer ntr-un caz precum:
void initRational (int a, int b) {this->a=a; this->b=b; }// ne ajută să deosebim câmpurile a și b de parametrii
formali ce au același nume, caâmpurile fiind cele cu this.
Metodele care se definesc în afara clasei, de multe ori în alt fișier se definesc scriind:
nume_clasa::metoda([parametrii fromali]){}
Prin urmare se folosește operatorul :: pentru a indica apartenența metodei la clasă. De exemplu pentru a
defini metoda scrie din clasa Rational avem:
void Rational::scrie(){cout<<a<<”/“<<b;}
Dacă nu am folosi doar numele scrie am avea o funcție normală fără parametrii formali și am avea nevoie de niște
variabile globale a și b care să poată fi afișate, acestea neavând nici o legătură directă cu clasa.
Pentru a putea folosi clasele, trebuie să le dinim mai întâi și apoi să declarăm variabile simple, vectori, pointeri etc. la
acestea. Când definim o clasă ne putem imagina că am definit un nou tip de dată care conține și funcții pe lângă
informații și că va trebui apoi să declarăm variabile de acel tip( instanțe ale clasei ) pentru a putea utiliza efectiv clasa.
Declararea unor variabile de tipul unei clase ( instanțe ale clasei ) se face în mod identic cu declararea de variabile.
Constructori
Este o metodă specială folosită pentru inițializarea membrilor clasei și acesta se apelează automat când se creează
instanțe noi (se declara o variabilă locală, se creează un obiect folosind new, etc.) Numele coincide cu numele clasei,
și nu are tip returnat. Se creează un obiect nou fără a se apela (implicit sau explicit) constructorul. Se consideră că
orice clasă are cel puțin un constructor (dacă nu se declară unu există un constructor implicit).

Într-o clasă putem avea mai mulți constructori, dar tipul, numărul și poziția parametrilor acestora trebuie să fie
diferită. Atributele clasei se pot inițializa (member initialization list) adăugând o listă înainte de corpul metodei
(expresia intre “:” si “{” începutul corpului constructorului.
Varianta cu lista de inițializare are câteva beneficii:
poate fi mai eficient (inițializează direct atributul loc de default constructor apoi copiere)
poate fi singu ra modalitate de inițializare (ex atribut referința sau const)
Acest lucru nu este obligatoriu, putându-se folosi și inițializîri obișnuite, ca în exemplele:
class Rational{
public:
Rational();
Rational(int a, int b);
int getNumarator() {return a;}//1
int getNumitor() {return b;}
void scrie();
private:
int a,b;};
Rational::Rational(){a=0;this->b=1;}
Rational::Rational(int a, int b):a{a},b{b}{}
sau, mai clar pentru a doua variantã implementarea:
Rational::Rational(int a, int b){this->a=a;this->b=b;}
Având în vedere că un constructor se apelează automat în momentul în care declarăm o instanță a clasei,
aceștia ar trebui să fie publici pentru a se putea apela și a evita erori. În momentul în care declarăm ceva de
tipul clasei, C++ alege automat constructorul considerat cel mai potrivit pentru declararea făcută, dacă avem
mai mulți constructori. De exemplu, dacă avem declarațiile:
Rational a, b(20,10),c;
În cazul lui a și c se va folosi constructorul fără parametrii, ar în cazul lui b cel cu parametrii.
Destructor
Orice instanță a unei clase are un unic destructor. Numele acestuia este ~clasa() și nu are parametrii, nu
returneză nimic. De obicei eliberează memoria alocată de o anumită instanță a clasei( variabilă de tipul
clasei ).
Supraîncărcarea operatorilor
C++ permite definirea semantici pentru operatori asupra tipurilor definite de utilizator.Lista operatorilor pe
care putem sa definim:+, -,*, /, +=, --=, *=, /=, %, %=, ++, – –, =, = =, <<, >>, <=, >=, !, !=, &&, ||, <<=,
>>=, &, ^,|, &=, ^=, |=, ~, [] , () , ->*, ->, new , new[] , delete, delete[] . Trebuie respectată aritatea
operatorilor( dacă un operator are 2 operanzi trebuie să rămână așa, dacă are un operand trebuie să rămână
așa, etc. ) Se pot implica atât doi operatori de tipul unor clase cât și un operator de un tip simplu de dată.
using namespace std;
#include<iostream>
class Rational{
public:
Rational();
Rational(int a, int b);
int getNumarator() {return a;}
int getNumitor() {return b;}
void scrie();
Rational operator +(Rational c);
Rational operator +(int x);
Rational operator -(int x);
private:
 int a,b;};

Rational Rational::operator +(Rational c)

{ Rational s;// declaram o variabila pentru suma ce se va initializa automat cu 0/1 datorita constructorului
implementat
s.a=this->a*c.b+this->b*c.a;
s.b=this->b*c.b;
return s;}

Rational Rational::operator +(int x)

{ Rational s;// declaram o variabila pentru suma ce se va initializa automat cu 0/1 datorita constructorului
implementat
s.a=this->a+x*this->b;
s.b=this->b;
return s;}

Rational Rational::operator -(int x)

{ Rational d;// declaram o variabila pentru diferent ce se va initializa automat cu 0/1 datorita constructorului
implementat
d.a=this->a-x*this->b;
d.b=this->b;
return d;}

Rational::Rational(){this->a=0;this->b=1;}

Rational::Rational(int a, int b){this->a=a;this->b=b;}

int main()
{ Rational x(3,4),y(2,3);
x=x+2;
cout<<x.getNumarator()<<" "<<x.getNumitor();// nu putem afisa direct campurile deoarece ele sunt private
x=x-2;
cout<<endl<<x.getNumarator()<<" "<<x.getNumitor();
x=x+y;
cout<<endl<<x.getNumarator()<<" "<<x.getNumitor();
return 0;}

Aplicații
1. Să se scrie o clasă ce implementează următoarele metode: citire vector de la tastatură (constructor), afişare
vector, sortare crescătoare vector, determinarea minimului, determinarea maximului, determinarea
numărului de elemente din vector, adăugare element la sfârşitul tabloului, extragere element de la începutul
tabloului.
Utilizaând clasa anterioaraă, citiți 2 vectori, și apoi adăugați la sfârșitul vectorului ce are cea mai mică
valoare din cei doi vectori, toate elementele din celălalt vector, ordonate în ordine crescătoare. Afișați
vectorul rezultat. Dacă ambele au același cel mai mic element, atunci luați în considerare vectorul ce reține
cel mai mare element din cei doi vectori pentru a adăuga la sârșitul acestuia. Dacă ambii vectori rețin și
același maxim, atunci luați în considerare vectorul cu cele mai multe elemente pentru a adăuga la sârșitul
acestuia. Dacă ambii vecori au și același număr de elemente, adăugați al doilea vector, ordonat în prealabil,
la sfârșitul primului.
2. Creați o clasă denumită carte, în care să rețineți titlul cărții, numele autorului(șiruri de acaractere) și anul
apariției, număr de exemplare vândute(valori întregi). Dotați clasa cu un constructor ce citește datele de la
tastatură și unul ce inițializează câmpurile prin atribuiri de valori primite ca parametrii. De asemenea dotați
clasa cu câte o funcție ce permite creșterea numărului de exemplare vândute, una ce premite scăderea
numărului de exemplare vândute, una ce returnează anul apariției, una ce returnează numele autorului,
respectiv una pentru titlul cărții.
Generați un vector cu elemente de tipul clasei și apoi implementați un program cu următoarele opțiuni:
a. Creșterea cu o valoare a numărului de exemplare vândute dintr-o carte identificată prin titlul și an al
apariției.
b. Scăderea cu o valoare a numărului de exemplare vândute dintr-o carte identificată prin titlul și an al
apariției.
c. Afișarea tutror cărților scrise de un autor citit de la tasatură.
d.Afișarea tutror cărților al căror titlul începe cu o anumită literă citită de la tastatură
e. Terminare program
3. Creați o clasă matrice cu un constructor ce permite citirea elementelor unei matrice de la tastatură. Dotați
clasa cu operatori redefiniți pentru determinarea sumei a două matrice(operatorul + ), diferenței a două
matrice(operatorul - ), produsului a două matrice(operatorul * ).
4. Definiți o clasă dreptunghi ce are funcții pentru citirea celor două laturi de la tastatură, inițializarea cu
anumite valori, operator+ pentru calcularea sumei ariilor a două dreptunghiuri, operator – pentru calcularea
diferenței ariei a două dreptunghiuri. Scrieți un program ce utilizează două instanțe ale clasei, le calculează
suma, diferența prima-a doua și le afișează.
5. Creați o clasă nrcomplex cu un constructor ce permite citirea elementelor unui număr complex de la
tastatură. Dotați clasa cu operatori redefiniți pentru determinarea sumei a două astfel de numere(operatorul +
), diferenței a două astfel de numere (operatorul - ), produsului a două astfel de numere (operatorul * ) ,
câtului a două astfel de numere (operatorul / ).
6. Creați o clasă ceas cu trei constructori:
- Unul care primește ora și minutele ca doi parametrii
- Altul care citește ora, respective minutele de la tastatură
- Al treilea care primește ca și parametru numele unui fișier și preia de acolo ora, respective minutele
Redefiniți operatorul + astfel încât acesta să poată arăta noua oră după adăugarea unui număr de minute
(atenție la trecerea peste 60 de minute sau 24 de ore).
Redefiniți operatorul – astfel încât acesta să afișeze numărul de minute între două “ceasuri”.
Implemntați o funcție care să permită afișarea orei unei instanțe a clasei.