Programare orientată pe obiecte (POO)

Introducere în conceptele fundamentale ale programării orientate pe obiecte în C++.

Clase și obiecte: tipul și instanțele lui

O clasă este un tip de date definit de programator care grupează împreună datele (atribute, câmpuri) și funcțiile care le prelucrează (metode). Un obiect este o instanță a clasei — o variabilă concretă de acel tip, cu valori proprii ale atributelor.

Distincția clasă/obiect e prima grilă de teorie: clasa e șablonul (definirea tipului, o singură dată), obiectele sunt exemplarele (oricâte, fiecare cu propriile date). Din clasa Elev se pot crea obiectele e1, e2, e3 — fiecare cu nume și medie proprii, dar cu aceleași metode.

În C++, membrii unei clase au modificatori de acces:

• private — accesibili doar din interiorul clasei (din metodele ei); este nivelul implicit pentru `class`;
• public — accesibili de oriunde există obiectul;
• protected — ca private, dar accesibili și claselor derivate.

Detaliul de sintaxă care se punctează: la `struct` accesul implicit este public, la `class` este private — singura diferență dintre ele în C++.

Accesul la membri se face cu operatorul punct pentru obiecte (`e1.afisare()`) și cu săgeată pentru pointeri la obiecte (`p->afisare()`). Metodele pot fi definite în interiorul clasei sau în exterior, cu operatorul de rezoluție: `void Elev::afisare() { … }` — sintaxa `Clasa::metoda` spune compilatorului cărui tip îi aparține funcția.

Constructori și destructori: viața unui obiect

Constructorul este metoda specială apelată automat la crearea obiectului, cu rolul de a-i inițializa atributele. Reguli de sintaxă cerute la examen:

• are același nume cu clasa și nu are tip de retur (nici măcar void);
• poate fi supraîncărcat: o clasă poate avea mai mulți constructori cu liste de parametri diferite;
• constructorul implicit (fără parametri) este generat automat de compilator doar dacă programatorul nu a definit niciun constructor; în momentul în care definești un constructor cu parametri, cel implicit dispare, iar declarația `Elev e;` devine eroare de compilare — capcană clasică de subiect.

Constructorul de copiere se apelează când un obiect nou se creează din alt obiect (inițializare, transmitere prin valoare ca parametru). Implicit copiază membru cu membru — suficient până când clasa deține resurse alocate dinamic, caz în care copia superficială face ca două obiecte să partajeze aceeași memorie.

Destructorul — `~Elev()` — se apelează automat la distrugerea obiectului (ieșirea din domeniul de vizibilitate sau delete). Este unic (nu se supraîncarcă), nu are parametri și nici tip de retur; rolul lui tipic este eliberarea resurselor alocate de constructor.

Ordinea care apare în grile de urmărire a execuției: obiectele locale se distrug în ordinea inversă creării lor; la o clasă derivată se apelează întâi constructorul bazei, apoi al derivatei, iar destructorii — exact invers.

Încapsularea: date private, interfață publică

Încapsularea este principiul POO care leagă datele de metodele care le prelucrează și ascunde reprezentarea internă a obiectului de exterior. Practic:

• atributele se declară private;
• exteriorul lucrează doar prin metode publice — interfața clasei;
• accesul controlat se oferă prin metode de tip getter (returnează valoarea unui atribut) și setter (modifică valoarea, cu validare).

De ce nu sunt atributele pur și simplu publice — argumentul care se cere la teorie: cu date publice, orice cod poate scrie `elev.medie = 47;` și nimic nu împiedică starea invalidă. Cu atribut privat și setter, clasa validează (media rămâne între 1 și 10) și își poate schimba reprezentarea internă fără să strice codul care o folosește. Încapsularea reduce astfel cuplajul și face programele mari întreținabile.

Excepția controlată de la regulă: o funcție sau o clasă declarată friend primește acces la membrii privați ai clasei. Se folosește rar și justificat (tipic la supraîncărcarea operatorilor << și >> pentru fluxuri); abuzul de friend subminează exact protecția pe care o oferă încapsularea — nuanță care apare în întrebările de tip adevărat/fals.

Confuzia frecventă: încapsularea nu înseamnă doar „a pune datele într-o clasă”, ci a le ascunde (information hiding); o clasă cu toate atributele publice folosește sintaxa claselor, dar încalcă principiul.

Moștenirea: reutilizare prin relația este-un

Moștenirea permite definirea unei clase derivate care preia atributele și metodele unei clase de bază și adaugă sau modifică propriile componente: `class Elev : public Persoana { … }`. Relația modelată este este-un: orice Elev este o Persoana.

Ce se moștenește și ce nu — puncte de teorie:

• se moștenesc atributele și metodele bazei; membrii private ai bazei există în obiectul derivat, dar nu sunt accesibili direct din metodele derivatei — pentru acces din derivate există protected;
• nu se moștenesc constructorii și destructorul: derivata își definește propriii constructori, care apelează constructorul bazei (implicit sau explicit, în lista de inițializare).

Ordinea apelurilor, iar și iar cerută în grile: la crearea unui obiect derivat se execută întâi constructorul bazei, apoi al derivatei; la distrugere, întâi destructorul derivatei, apoi al bazei — construcția de la fundație în sus, demolarea de sus în jos.

Derivata poate redefini (suprascrie) o metodă a bazei: aceeași signatură, comportament nou. Nu confunda cu supraîncărcarea: supraîncărcarea = aceeași clasă, același nume, parametri diferiți; redefinirea = clase diferite (bază/derivată), aceeași signatură. Această pereche de definiții e una dintre cele mai frecvente întrebări-capcană de teorie.

Moștenirea poate fi și multiplă în C++ (o derivată cu mai multe baze), menționată la nivel de existență în programă.

Polimorfismul: funcții virtuale și clase abstracte

Polimorfismul înseamnă că același apel de metodă are comportamente diferite în funcție de tipul real al obiectului. În C++, polimorfismul la execuție cere două ingrediente:

• apelul se face printr-un pointer sau o referință la clasa de bază;
• metoda este declarată virtual în clasa de bază.

Cu `virtual void afisare();` în Persoana și un pointer `Persoana* p = new Elev;`, apelul `p->afisare()` execută varianta din Elev — decizia se ia la execuție (legare dinamică/târzie), după tipul obiectului real. Fără virtual, se execută varianta din Persoana — decizia se ia la compilare (legare statică), după tipul pointerului. Exact acest contrast, cu și fără virtual, este grila standard de polimorfism.

O funcție virtuală pură se declară cu `= 0`: `virtual double arie() = 0;`. Clasa care conține cel puțin o funcție virtuală pură devine clasă abstractă:

• nu se pot crea obiecte din ea;
• servește ca interfață: derivatele sunt obligate să implementeze funcțiile pure ca să devină instanțiabile;
• se pot declara pointeri și referințe la clasa abstractă — tocmai prin ei se folosește polimorfismul (un vector de `Figura*` care ține Cerc, Patrat, Triunghi și apelează `arie()` pentru fiecare).

De reținut și distincția de vocabular: supraîncărcarea funcțiilor este uneori numită polimorfism static (la compilare), iar funcțiile virtuale dau polimorfismul dinamic (la execuție) — cel vizat de obicei de întrebări.

Supraîncărcarea operatorilor și template-uri

Supraîncărcarea operatorilor permite ca operatorii limbajului (+, -, ==, <<) să capete sens pentru tipuri definite de utilizator, prin funcții cu numele operator urmat de simbol: `Fractie operator+(Fractie a, Fractie b)`. Reguli care se cer la teorie:

• nu se pot crea operatori noi (nu există operator #) și nu se pot supraîncărca operatorii pentru tipurile predefinite (nu poți schimba + între int-uri);
• precedența și asociativitatea operatorului rămân cele din limbaj — supraîncărcarea schimbă doar semnificația, nu prioritatea;
• operatorul poate fi metodă a clasei (operandul stâng este obiectul curent) sau funcție externă, adesea friend — obligatoriu externă la `<<` pe flux, unde operandul stâng este ostream, nu obiectul clasei.

Template-urile (șabloanele) rezolvă altă problemă: același algoritm scris o singură dată pentru orice tip de date. `template <typename T> T maxim(T a, T b)` funcționează pentru int, double, string; compilatorul generează la compilare câte o versiune concretă pentru fiecare tip folosit. Există și clase template — exemplul omniprezent: containerele STL (`vector<int>`, `stack<char>`).

Distincție finală care închide capitolul și prinde multe grile: template-ul este polimorfism la compilare (codul se generează per tip, fără cost la execuție), funcțiile virtuale sunt polimorfism la execuție (o singură funcție, alegerea variantei se face dinamic). Ambele înseamnă „un nume, mai multe comportamente”, dar mecanismele și momentul deciziei diferă fundamental.

Test — 6 întrebări ca la examen