Principii de programare orientată pe obiecte

Programarea orientată pe obiecte grupează datele și operațiile relevante în clase. Încapsularea protejează modul intern de reprezentare printr-o interfață clară; moștenirea permite unei clase să extindă alta; polimorfismul permite apelarea aceleiași operații printr-o interfață comună cu comportamente potrivite obiectelor concrete. Aceste instrumente se folosesc când simplifică modelul, nu pentru a multiplica artificial clasele.

Programarea orientată pe obiecte se sprijină pe trei principii. Încapsularea păstrează datele private și le expune doar prin metode public, ca regulile interne să nu poată fi încălcate din exterior. Moștenirea permite unei clase derivate să preia membrii clasei de bază și să-i extindă sau să-i specializeze. Polimorfismul permite apelarea aceleiași operații printr-o interfață comună, cu comportament potrivit obiectului concret. În C++, o metodă virtual permite apelarea implementării clasei concrete prin pointer la clasa de bază; o metodă = 0 face clasa abstractă, deci nu poate fi instanțiată direct. Constructorul inițializează obiectul. Aceste instrumente se folosesc când simplifică modelul, nu pentru a multiplica artificial clasele.

Exemplul 1 — polimorfism.

#include <iostream>
using namespace std;
class Forma {
public:
    virtual double arie() const = 0;
    virtual ~Forma() = default;
};
class Patrat : public Forma {
private: double latura;
public: explicit Patrat(double l): latura(l) {}
    double arie() const override { return latura*latura; }
};
class Cerc : public Forma {
private: double raza;
public: explicit Cerc(double r): raza(r) {}
    double arie() const override { return 3.14*raza*raza; }
};
int main() {
    Patrat p(3); Cerc c(2);
    Forma* forme[2]={&p,&c};
    for(int i=0;i<2;++i) cout << forme[i]->arie() << " ";
}

Rezultatul este 9 12.56. Atributul latura este accesibil numai prin metodele clasei, ceea ce arată încapsularea; Patrat și Cerc moștenesc Forma și răspund diferit la același apel arie(), pentru că funcția este virtuală: se alege implementarea tipului real al obiectului, nu a tipului pointerului.

Exemplul 2 — încapsularea unei reguli. Soldul unui cont nu poate deveni negativ, iar singura cale de modificare este metoda retrage, care verifică regula:

#include <iostream>
using namespace std;
class Cont {
    double sold;
public:
    explicit Cont(double s) : sold(s) {}
    bool retrage(double s) {
        if (s > sold) return false;
        sold -= s;
        return true;
    }
    double getSold() const { return sold; }
};
int main() {
    Cont c(100);
    cout << c.retrage(30) << " " << c.retrage(100) << " " << c.getSold();
}

Se afișează 1 0 70. Prima retragere reușește și soldul devine 70. A doua cere 100, mai mult decât soldul, deci este respinsă și soldul rămâne 70. O instrucțiune c.sold = -5; din afara clasei nu se compilează, deoarece membrul este privat.

Exemplul 3 — moștenirea și ordinea constructorilor. La crearea unui obiect al clasei derivate se execută întâi constructorul clasei de bază, apoi cel al clasei derivate; destructorii se execută în ordine inversă. Destructorul clasei de bază trebuie să fie virtual pentru ca ștergerea prin pointer la bază să elibereze obiectul complet:

#include <iostream>
using namespace std;
struct A {
    A() { cout << "A "; }
    virtual ~A() { cout << "~A "; }
};
struct B : A {
    B() { cout << "B "; }
    ~B() override { cout << "~B "; }
};
int main() {
    A* p = new B;
    delete p;
}

Se afișează A B ~B ~A : baza se construiește prima și se distruge ultima, iar ~B se apelează prin pointerul A* doar fiindcă ~A este virtual.

Exemplul 4 — metoda fără virtual. Fără cuvântul virtual, alegerea metodei se face după tipul pointerului, nu după tipul obiectului.

#include <iostream>
using namespace std;
struct Animal {
    void sunet() { cout << "? "; }
};
struct Caine : Animal {
    void sunet() { cout << "ham "; }
};
int main() {
    Caine c;
    Animal* p = &c;
    p->sunet();
    c.sunet();
}

Se afișează ? ham : apelul prin p, de tip Animal*, execută metoda din Animal, iar apelul direct pe c execută metoda din Caine. Dacă în Animal metoda ar fi declarată virtual void sunet(), ambele apeluri ar afișa ham, fiindcă s-ar alege implementarea tipului real al obiectului.

Exemplul 5 — „este un” și „are un”. Moștenirea se folosește când clasa derivată este un caz particular al bazei: un Cerc este o Forma, un Student este o Persoana. Când un obiect doar conține altul, nu se moștenește, ci se păstrează ca membru: o Masina are un Motor, deci clasa Masina conține un câmp de tip Motor. Testul este propoziția „X este un Y”: dacă nu are sens, relația corectă este de conținere.

Exemplul 6 — clasa abstractă nu se instanțiază. Clasa Forma din primul exemplu are metoda pură arie() = 0, deci instrucțiunea Forma f; nu se compilează: nu există o implementare pentru arie. Un obiect se creează numai dintr-o clasă derivată care definește metoda pură, de pildă Patrat p(3);. Pointerul Forma* q = &p; este însă permis, pentru că indică un obiect concret, iar q->arie() dă $9$.

Greșeli frecvente

• Greșit: moștenirea înseamnă copiere manuală a întregului cod al clasei de bază.
  Corect: clasa derivată reutilizează și poate specializa comportamentul.
• Greșit: orice atribut al unui obiect trebuie accesat direct din afară.
  Corect: o interfață de metode poate proteja regulile interne.
• Greșit: același nume de metodă obligă toate clasele la același calcul.
  Corect: implementările pot diferi.

Înainte și după