Elemente de programare orientată pe obiecte (OOP)

Introducerea paradigmei orientate pe obiecte și a conceptelor de bază ale acesteia.

De la proceduri la obiecte: clase și instanțe

Programarea procedurală ține datele într-o parte (variabile, structuri) și prelucrările în alta (funcții). Când programul crește, nimic nu garantează că datele sunt folosite corect: orice funcție poate modifica orice câmp. Programarea orientată pe obiecte rezolvă exact această problemă — leagă datele de operațiile permise asupra lor.

O clasă este un tip de date definit de utilizator: un șablon care descrie ce atribute (date membru) și ce metode (funcții membru) au entitățile de acel fel. Un obiect este o instanță a clasei — o variabilă concretă, cu propriul set de valori pentru atribute.

Confuzia numărul unu la examen: clasa nu este obiect. Clasa e planul de arhitectură, obiectul e casa construită după plan. Definirea clasei nu alocă memorie pentru atribute; alocarea are loc la crearea fiecărui obiect. Din aceeași clasă pot exista mii de obiecte, fiecare cu valori diferite, dar toate cu același cod al metodelor.

În C++ clasa se declară cu class, iar structura cu struct. Diferența dintre ele este una singură și e întrebare sigură: accesul implicit al membrilor este private la class și public la struct. În rest sunt identice — struct poate avea metode, constructori, moștenire.

Fiecare metodă nestatică primește automat pointerul ascuns this, care indică obiectul asupra căruia a fost apelată metoda; de aceea aceeași metodă lucrează pe datele obiectului curent, fără să primească explicit obiectul ca parametru.

Cele patru principii ale paradigmei, în forma cerută la BAC: abstractizarea (reținem doar ce e esențial pentru problemă), încapsularea, moștenirea și polimorfismul.

Încapsularea și modificatorii de acces

Încapsularea înseamnă ascunderea reprezentării interne a unui obiect și expunerea unei interfețe controlate. Practic: atributele se declară private, iar accesul la ele se face doar prin metode publice.

Modificatorii de acces, exact cu efectul lor:

• private — membrul e vizibil doar în interiorul clasei (și pentru funcțiile/clasele declarate friend). Este accesul implicit la class.
• protected — vizibil în clasa proprie și în clasele derivate, dar nu din afară. Există tocmai pentru moștenire.
• public — vizibil de oriunde; formează interfața clasei.

Metodele care doar citesc o valoare privată se numesc accesori (getteri), cele care o modifică mutatori (setteri). Rostul lor nu e birocratic: setterul poate valida datele (o notă între 1 și 10, o vârstă pozitivă), lucru imposibil dacă atributul ar fi public și oricine i-ar putea atribui orice.

O metodă care nu modifică starea obiectului se marchează cu const după lista de parametri — un obiect declarat const poate apela doar astfel de metode.

Membrii static aparțin clasei, nu obiectului: există într-un singur exemplar, comun tuturor instanțelor (tipic: un contor de obiecte create). O metodă statică nu are pointerul this și de aceea nu poate accesa atribute nestatice — capcană frecventă la itemii de teorie.

Greșeala clasică: a crede că private înseamnă „privat pentru fiecare obiect”. Nu — accesul este la nivel de clasă. O metodă a clasei poate citi membrii privați ai oricărui obiect din aceeași clasă primit ca parametru, nu doar ai lui this.

Constructori și destructori

Constructorul este metoda apelată automat la crearea unui obiect. Semne distinctive cerute la examen: are exact numele clasei, nu are tip returnat (nici măcar void) și nu se apelează explicit ca o metodă obișnuită.

Tipuri de constructori:

• implicit (fără parametri) — dacă programatorul nu scrie niciun constructor, compilatorul îl generează. Important: din momentul în care ai scris măcar un constructor cu parametri, cel implicit nu mai este generat, iar o declarație de forma unui obiect fără argumente dă eroare de compilare.
• parametrizat — inițializează atributele cu valori primite; se poate supraîncărca (mai mulți constructori cu semnături diferite).
• de copiere — primește ca parametru o referință constantă la un obiect din aceeași clasă și construiește o copie. Se apelează la inițializarea unui obiect din altul și la transmiterea/returnarea prin valoare. Dacă obiectul conține pointeri și memorie alocată dinamic, copierea implicită (superficială) duplică doar adresa, iar la eliberare aceeași zonă se șterge de două ori — de aceea se scrie un constructor de copiere profundă.

Inițializarea se poate face și prin lista de inițializare, scrisă după două puncte, înaintea corpului constructorului — obligatorie pentru membrii constanți și pentru referințe.

Destructorul are numele clasei precedat de tilda, nu are parametri și nu returnează nimic. Rezultă direct: destructorul nu poate fi supraîncărcat — există unul singur. Se apelează automat la ieșirea obiectului din domeniul de vizibilitate sau la delete, iar rolul lui este eliberarea resurselor (memorie dinamică, fișiere).

Ordinea în ierarhii: la construire se execută întâi constructorul clasei de bază, apoi al celei derivate; la distrugere ordinea este exact inversă.

Moștenirea și polimorfismul

Moștenirea permite definirea unei clase derivate pornind de la o clasă de bază, preluându-i membrii și adăugând sau redefinind ce e specific. Relația se citește „este un”: un Elev este o Persoană.

Ce nu se moștenește, listă cerută la teorie: constructorii, destructorul, operatorul de atribuire și relațiile de friend. Membrii private ai bazei sunt moșteniți, dar nu sunt accesibili direct în derivată — se ajunge la ei doar prin metodele publice sau protected ale bazei. Aici se nasc cele mai multe confuzii: „moștenit” nu e sinonim cu „accesibil”.

Tipul moștenirii schimbă accesul în derivată: la moștenire public, membrii publici rămân publici și cei protected rămân protected; la protected ambele categorii devin protected; la private totul devine private. În C++ moștenirea implicită la class este private, la struct este public.

Polimorfismul înseamnă că același apel se comportă diferit în funcție de tipul real al obiectului. Se distinge:

• polimorfism la compilare (static) — supraîncărcarea funcțiilor și a operatorilor; alegerea se face de compilator, după semnătură;
• polimorfism la execuție (dinamic) — obținut prin funcții virtuale. Dacă o metodă din bază e declarată virtual și e redefinită (suprascrisă) în derivată, atunci un apel prin pointer sau referință la clasa de bază execută versiunea din clasa reală a obiectului, decisă la rulare (legare tardivă).

O metodă pur virtuală (declarată egală cu zero) face clasa abstractă: o clasă abstractă nu poate fi instanțiată, poate fi doar bază pentru altele.

Regulă de siguranță întrebată des: dacă o clasă are funcții virtuale, destructorul trebuie declarat virtual; altfel, la ștergerea prin pointer de bază, destructorul derivatei nu se mai execută și resursele rămân nealiberate.

Supraîncărcarea metodelor și a operatorilor

Supraîncărcarea (overloading) înseamnă mai multe funcții cu același nume, dar cu semnături diferite — număr diferit de parametri sau tipuri diferite. Compilatorul alege varianta potrivită după argumentele apelului.

Capcana clasică: tipul returnat nu face parte din semnătură. Două funcții care diferă doar prin ce returnează nu sunt supraîncărcare validă, ci eroare de compilare. La fel, combinarea neatentă a supraîncărcării cu parametri impliciți poate crea apeluri ambigue.

Nu confunda supraîncărcarea cu suprascrierea (overriding): prima presupune același nume și semnături diferite, în aceeași clasă, rezolvată la compilare; a doua presupune aceeași semnătură, în clasa derivată față de bază, și devine polimorfică la execuție dacă metoda e virtuală.

Supraîncărcarea operatorilor dă operatorilor obișnuiți un înțeles pentru tipurile proprii: adunarea a doi vectori, compararea a două fracții, afișarea unui obiect. Se folosește cuvântul cheie operator urmat de simbolul dorit. Operatorul poate fi definit:

• ca metodă membru — operandul din stânga este obiectul curent, deci operatorul primește cu un parametru mai puțin decât aritatea sa;
• ca funcție externă, de regulă friend — necesară când operandul stâng nu este obiect al clasei, cazul tipic fiind operatorul de inserare în flux pentru afișare.

Restricții de reținut, pentru că apar la itemii de teorie: nu se pot crea operatori noi, nu se pot schimba aritatea, precedența și asociativitatea, iar operatorii de acces la membru prin punct, de rezoluție a domeniului, operatorul condițional ternar și sizeof nu pot fi supraîncărcați. Cel puțin un operand trebuie să fie de tip definit de utilizator — nu poți redefini adunarea a două numere întregi.

Test — 6 întrebări ca la examen