Declararea claselor

Clasele sunt o extindere a conceptului de structură de date, conținând, pe lângă datele propriu-zise și funcții de acces la acestea, încorporate în structură. Când o astfel de structură capătă valori, adică este instanțiată, se realizează un obiect.

Definirea unei clase se face urmărind sintaxa:

```
class id_clasa

{
specificator_acces1: membru 1;
specificator_acces2: membru 2;
…
}

lista_obiecte;

```

Corpul acestei declarări poate conține fie date, fie declarări de funcții și, opțional, specificatori de acces. Desigur, id\_clasa trebuie să respecte regulile de formare a identificatorilor, iar lista\_obiecte este o lista opțională de obiecte declarate în această clasă.

Declararea este foarte asemănătoare cu cea a structurilor, având în plus, după cum spuneam, funcții de acces la date și, opțional identificatori de acces. Aceștia sunt cuvinte cheie și anume: private, public sau protected, având semnificațiile următoare:

• membrii private ai unei clase sunt accesibili doar prin intermediul altor membri ai clasei, sau prin intermediul “prietenilor”, adică ai obiectelor friend

• membrii protected sunt accesibili membrilor clasei, obiectelor friend sau claselor derivate

• membrii public sunt accesibili oriunde sunt vizibile obiectele clasei sunt vizibile

În mod implicit, membrii unei clase sunt declarați private. Pentru a stabili alt tip de acces, acest lucru trebuie precizat explicit.

Să analizăm exemplul umător:

```
class dreptunghi {

int latime, lungime;
public:
void citire(int, int);
int arie(void);
}d;

```

Clasa are numele dreptunghi, iar obiectul declarat prin intermediul ei, d. Practic, putem spune că astfel am creat un tip de date, dreptunghi și o variabilă, d, de tip dreptunghi. Clasa dreptunghi conține patru membri. Două date membru de tip int, latime și lungime, cu acces privat și două funcții membru, declarate public, citire, respectiv arie.  În urma acestor declarări, membrii publici pot fi accesați precum orice variabilă sau funcție. Specificarea accesului la membri se face cu ajutorul operatorului ‘.’, plasat între numele obiectului și membru, precum în exemplul:

```
d.citire(5,7) ;

a=d.arie();

```

Membrii lățime și lungime, declarați private, nu pot fi accesați din afara clasei, fiind necesară, astfel, utilizarea unor funcții membru.

În cele ce urmează, dezvoltăm exemplul anterior, într-un program complet, ce include și definiții pentru funcțiile citește, respectiv arie.

```
#include<iostream.h>
using namespace std;
class dreptunghi

{
int latime, lungime;
public:
      void citire(int, int);
      int arie(void); };

void dreptunghi::citire(int l, int L){
                 latime=l;
                 lungime=L;}

int dreptunghi::arie(){
               return latime*lungime;}

int main(){
dreptunghi d;
int a, b;
cin>>a>>b;
d.citeste(a,b);
cout<<”Aria este:”<<d.arie();
return 0;
}

```

Observăm, în exemplu, operatorul ‘::’, numit operator de rezoluție, folosit pentru definirea funcțiilor membru ale clasei dreptunghi, în afara clasei. Acesta precizează cărei clase îi aparține o anumită funcție, pentru a nu fi tratate ca simple funcții. Trebuie precizat, de asemenea, că dacă o funcție membru este protejată, atunci ea poate fi apelată numai prin intermediul unei funcții membru a tipului.

Funcțiile membru pot fi declarate în interiorul clasei, urmând a fi definite, ulterior, în afara acestora, sau pot fi  definite complet în interiorul clasei. În acest caz, sunt tratate ca funcții inline de către compilator. Nu există diferențe majore, între cele două maniere, doar o compilare mai eficientă în cazul celor inline.

Această manieră de a include într-o singură structură date și funcții de prelucrare definește conceptul de încapsulare.