Avansat · POO în C++ · Lecția 4
Moștenire și polimorfism: virtual, clase abstracte, vtable, override, destructor virtual
90 minavansat / pregătire pentru facultate și industrie
Înainte de lecția asta: POO.1 Clase de la zero: constructori, liste de inițializare, destructor, RAII, this, const, static, POO.2 Copiere și mutare: constructorul de copiere, operatorul =, semantica mutării, regula lui 0/3/5, XI.21 Programare orientată pe obiecte în C++: clase și obiecte
Ce vei ști după lecție
- Construiești ierarhii de clase cu moștenire publică și explici ordinea constructorilor și destructorilor.
- Folosești funcții virtuale, override și final pentru polimorfism la rulare.
- Scrii clase abstracte (interfețe) cu funcții pur virtuale.
- Explici de ce destructorul unei baze polimorfice trebuie să fie virtual și ce este object slicing.
- Înțelegi mecanismul vtable și costul unui apel virtual.
POO în C++Lecția 4 din 10 · mai sunt 6Urmează: POO.5 · Proiectarea claselor: compunere vs moștenire, principiile SOLID și injectarea dependențelorVezi toate lecțiile
Cuprins
- Moștenirea: relația „este un”
- Construcție și distrugere într-o ierarhie
- Funcții virtuale: polimorfism la rulare
- Clase abstracte și interfețe
- Destructorul virtual
- Cum funcționează: vtable și vptr
- Object slicing și dynamic_cast
- Moștenire multiplă (pe scurt)
- Greșeli frecvente
- Exersează pe hârtie
- Mini-grile
- Mai departe (pentru cine vrea mai mult)
- Rezumat
- Citește și exersează în plus
- Răspunsuri
Fișiere PDF și de lucru
- Lecția în PDF
versiunea de printat
1. Moștenirea: relația „este un”
O clasă derivată preia datele și metodele unei clase de bază și adaugă sau modifică ce are nevoie. Relația trebuie să fie „este un”: un câine este un animal, un cerc este o formă. Dacă relația este „are un” (o mașină are un motor), folosești compunere (un membru), nu moștenire (lecția oop-05).
class Animal { /* ... */ };
class Caine : public Animal { /* ce are în plus un câine */ };Specificatorii de acces
| În bază | Din clasa derivată | Din afară (cu moștenire public) |
|---|---|---|
public |
da | da |
protected |
da | nu |
private |
nu | nu |
Moștenirea public păstrează interfața: tot ce era public în bază rămâne public. Moștenirile protected și private ascund interfața bazei și se folosesc rar (pentru „implementat cu ajutorul lui”, unde de obicei compunerea este mai clară).
Sfat
Folosește protected cu măsură: datele protected pot fi stricate de orice clasă derivată, deci invariantul bazei nu mai este apărat. De multe ori e mai bine ca datele să rămână private, iar baza să ofere metode protected pentru derivate.
2. Construcție și distrugere într-o ierarhie
Un obiect Caine conține o parte de Animal. La construire, întâi se construiește partea de bază (prin constructorul ales în lista de inițializare), apoi membrii derivatei, apoi corpul constructorului derivatei. La distrugere, ordinea este inversă.
#include <iostream>
#include <string>
using namespace std;
class Animal
{
protected:
string nume; // vizibil în clasele derivate, nu și din afară
public:
explicit Animal(string n) : nume(n) { cout << "Animal(" << nume << ")\n"; }
virtual ~Animal() { cout << "~Animal(" << nume << ")\n"; }
virtual string sunet() const { return "..."; }
string prezentare() const { return nume + " face " + sunet(); } // apel virtual din bază
};
class Caine : public Animal
{
int varsta;
public:
Caine(string n, int v) : Animal(n), varsta(v) { cout << "Caine(" << nume << ")\n"; }
~Caine() override { cout << "~Caine(" << nume << ")\n"; }
string sunet() const override { return "ham"; }
};
void prinValoare(Animal a) { cout << "prin valoare: " << a.sunet() << '\n'; }
void prinReferinta(const Animal &a) { cout << "prin referinta: " << a.sunet() << '\n'; }
int main()
{
Caine c("Rex", 3);
cout << c.prezentare() << '\n';
prinReferinta(c);
prinValoare(c); // slicing: se copiază doar partea de Animal
Animal *p = new Caine("Lord", 5);
delete p; // destructor virtual: întâi ~Caine, apoi ~Animal
return 0;
}| Linie | Afișare | Explicație |
|---|---|---|
Caine c("Rex", 3); |
Animal(Rex), Caine(Rex) | întâi baza, apoi derivata |
c.prezentare() |
Rex face ham | prezentare este din Animal, dar sunet() e virtual: se alege versiunea lui Caine |
prinReferinta(c) |
prin referinta: ham | referința la bază păstrează tipul real |
prinValoare(c) |
prin valoare: ..., ~Animal(Rex) | slicing: parametrul este un Animal nou, copiat doar din partea de bază; moare la ieșirea din funcție |
new Caine("Lord", 5) și delete p |
Animal(Lord), Caine(Lord), ~Caine(Lord), ~Animal(Lord) | destructorul virtual distruge corect prin pointerul la bază |
sfârșitul lui main |
~Caine(Rex), ~Animal(Rex) | ordine inversă construirii |
3. Funcții virtuale: polimorfism la rulare
Fără virtual, funcția apelată se alege după tipul declarat al variabilei (la compilare). Cu virtual, se alege după tipul real al obiectului (la rulare), atunci când apelul se face printr-un pointer sau o referință la bază. Aceasta se numește polimorfism dinamic (sau legare târzie, late binding).
| Apel | sunet() fără virtual |
sunet() cu virtual |
|---|---|---|
Caine c; c.sunet(); |
ham | ham |
Animal &r = c; r.sunet(); |
... | ham |
Animal *p = &c; p->sunet(); |
... | ham |
Animal a = c; a.sunet(); (copie) |
... | ... (slicing) |
override și final
override(după semnătură) cere compilatorului să verifice că funcția chiar suprascrie o funcție virtuală din bază. Dacă greșești semnătura (de exemplu, uițiconst), primești eroare, în loc de o funcție nouă, nevirtuală, care nu este niciodată apelată prin bază.finalinterzice suprascrierea mai departe (la o funcție) sau derivarea (la o clasă:class Cerc final : public Forma).
Atenție — greșeli frecvente
Suprascriere (override) ≠ supraîncărcare (overload). Suprascrierea înlocuiește o funcție virtuală din bază, cu aceeași semnătură. Supraîncărcarea înseamnă mai multe funcții cu același nume și parametri diferiți. Dacă în derivată declari sunet(int), aceasta ascunde toate sunet din bază (name hiding): c.sunet() nu se mai compilează fără using Animal::sunet;.
4. Clase abstracte și interfețe
O funcție pur virtuală (= 0) nu are implementare în bază: spune doar „orice derivată trebuie să aibă această funcție”. O clasă cu cel puțin o funcție pur virtuală este abstractă: nu se pot crea obiecte din ea, doar pointeri și referințe. O clasă abstractă fără date, doar cu funcții pur virtuale, joacă rolul unei interfețe.
#include <iostream>
#include <iomanip>
#include <memory>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
class Forma // clasă abstractă: interfața comună
{
public:
virtual double arie() const = 0; // pur virtuală: fiecare formă o definește
virtual double perimetru() const = 0;
virtual string nume() const = 0;
virtual ~Forma() = default; // destructor virtual: obligatoriu într-o bază polimorfică
};
class Cerc : public Forma
{
double r;
public:
explicit Cerc(double raza) : r(raza) {}
double arie() const override { return M_PI * r * r; }
double perimetru() const override { return 2 * M_PI * r; }
string nume() const override { return "cerc"; }
};
class Dreptunghi : public Forma
{
double a, b;
public:
Dreptunghi(double x, double y) : a(x), b(y) {}
double arie() const override { return a * b; }
double perimetru() const override { return 2 * (a + b); }
string nume() const override { return "dreptunghi"; }
};
class Triunghi : public Forma
{
double a, b, c;
public:
Triunghi(double x, double y, double z) : a(x), b(y), c(z) {}
double perimetru() const override { return a + b + c; }
double arie() const override // formula lui Heron
{
double s = perimetru() / 2;
return sqrt(s * (s - a) * (s - b) * (s - c));
}
string nume() const override { return "triunghi"; }
};
int main()
{
int n;
cin >> n;
vector<unique_ptr<Forma>> forme; // pointeri la bază: pot arăta spre orice formă
for (int i = 0; i < n; i++)
{
char tip;
cin >> tip;
if (tip == 'C') { double r; cin >> r; forme.push_back(make_unique<Cerc>(r)); }
else if (tip == 'D') { double a, b; cin >> a >> b; forme.push_back(make_unique<Dreptunghi>(a, b)); }
else { double a, b, c; cin >> a >> b >> c; forme.push_back(make_unique<Triunghi>(a, b, c)); }
}
cout << fixed << setprecision(2);
double total = 0;
const Forma *maxim = nullptr;
for (const auto &f : forme)
{
cout << f->nume() << ' ' << f->arie() << '\n'; // apel virtual: se alege funcția clasei reale
total += f->arie();
if (!maxim || f->arie() > maxim->arie()) maxim = f.get();
}
cout << "total " << total << '\n';
if (maxim) cout << "cea mai mare: " << maxim->nume() << '\n';
return 0;
}De ce așa?
De ce vector<unique_ptr<Forma>> și nu vector<Forma>? Un vector<Forma> nici nu se compilează (clasa este abstractă), iar un vector de obiecte de bază ar face slicing. Polimorfismul funcționează doar prin pointeri sau referințe; unique_ptr (lecția oop-07) este pointerul care face singur delete, deci nu pierdem memorie. Beneficiul: bucla din main nu știe ce forme există. Dacă adaugi Hexagon, nu modifici nimic din bucla de calcul: doar scrii clasa nouă (principiul deschis/închis, lecția oop-05).
5. Destructorul virtual
Dacă ștergi un obiect derivat printr-un pointer la bază (Animal *p = new Caine(...); delete p;) și destructorul bazei nu este virtual, se apelează doar ~Animal(): partea de Caine nu este distrusă, iar standardul spune că este comportament nedefinit. Regula:
Important
Orice clasă de bază cu funcții virtuale trebuie să aibă destructorul virtual (sau protected și nevirtual, dacă nu vrei ștergere prin bază). Cel mai simplu: virtual ~Baza() = default;.
6. Cum funcționează: vtable și vptr
Compilatorul construiește, pentru fiecare clasă cu funcții virtuale, o tabelă de funcții virtuale (vtable): adresele versiunilor care se folosesc pentru acea clasă. Fiecare obiect primește un pointer ascuns, vptr, către tabela clasei sale. Un apel p->arie() devine: citește vptr din obiect → citește adresa din tabelă → sare acolo.
| Aspect | Cost |
|---|---|
| memorie | un pointer (8 octeți) în fiecare obiect + o tabelă pe clasă |
| timp | două citiri din memorie în plus pe apel; funcția nu mai poate fi făcută inline |
| când contează | în bucle de milioane de apeluri pe obiecte mici (atunci se folosesc șabloane, oop-06) |
De știut
În constructorul și destructorul bazei, obiectul „este” încă (sau din nou) doar de tipul bazei: un apel virtual de acolo nu ajunge la versiunea derivatei. Nu apela funcții virtuale din constructori.
7. Object slicing și dynamic_cast
Slicing: când copiezi un obiect derivat într-o variabilă de tipul bazei (Animal a = c;, sau parametru prin valoare), se copiază doar partea de bază; datele și comportamentul derivatei se pierd. Evitare: transmite prin const Baza& sau prin pointer.
dynamic_cast verifică la rulare dacă un pointer la bază arată de fapt spre un anumit tip derivat:
if (auto c = dynamic_cast<Cerc*>(f)) cout << "este cerc"; // nullptr dacă nu este CercDacă ai nevoie des de dynamic_cast, de obicei înseamnă că o funcție virtuală lipsește din interfață.
8. Moștenire multiplă (pe scurt)
C++ permite mai multe clase de bază: class Amfibian : public Masina, public Barca. Problema clasică este diamantul: dacă Masina și Barca moștenesc amândouă din Vehicul, un Amfibian are două părți de Vehicul. Soluția este moștenirea virtuală (class Masina : virtual public Vehicul). În practică, moștenirea multiplă se folosește aproape exclusiv pentru interfețe (clase fără date): class Fisier : public Citibil, public Scriibil.
9. Greșeli frecvente
| Greșeala | Ce se întâmplă | Corect |
|---|---|---|
| destructor nevirtual într-o bază polimorfică | delete prin bază: comportament nedefinit, scurgeri |
virtual ~Baza() = default; |
lipsește override, semnătură ușor diferită |
funcție nouă, nevirtuală, niciodată apelată prin bază | scrie mereu override |
obiecte derivate într-un vector<Baza> |
slicing | vector<unique_ptr<Baza>> |
parametru Baza prin valoare |
slicing | const Baza& |
| apel virtual în constructor | se apelează versiunea bazei | evită; folosește o funcție de inițializare separată |
protected pentru toate datele |
derivatele pot strica invariantul | date private, metode protected |
| moștenire pentru reutilizare de cod fără „este un” | ierarhii fragile | compunere (oop-05) |
| supraîncărcare în derivată ascunde bază | c.f() nu se compilează |
using Baza::f; |
10. Exersează pe hârtie
1. În ce ordine se apelează constructorii și destructorii pentru class A {…}; class B : public A {…}; class C : public B {…}; la C x;?
2. Fără virtual, ce afișează Animal *p = new Caine("Rex", 3); cout << p->sunet();? Dar cu virtual?
3. Care este diferența dintre o funcție virtuală și una pur virtuală? Se poate crea un obiect Forma?
4. O clasă derivată scrie double arie() override { … } (fără const), iar baza are virtual double arie() const = 0;. Ce se întâmplă?
5. Explică de ce delete p (cu Animal *p = new Caine…) este periculos dacă ~Animal() nu este virtual.
6. Ce afișează prinValoare(c) pentru un Caine și de ce apare ~Animal(Rex) imediat după?
7. Câți octeți în plus are un obiect cu funcții virtuale, pe un sistem de 64 de biți? De ce?
8. Adaugă clasa Patrat în ierarhie. Ar fi mai bine să derive din Dreptunghi sau direct din Forma? (Gândește-te la o metodă setLatime a dreptunghiului.)
9. Ce este problema diamantului și cum se rezolvă?
10. Când folosești final pe o clasă?
11. Mini-grile
1. Polimorfismul dinamic funcționează când apelul se face prin: a) obiect copiat b) pointer sau referință la bază, cu funcție virtuală c) funcție statică d) orice variabilă
2. O clasă cu o funcție virtual void f() = 0; este:
a) abstractă b) finală c) statică d) template
3. override ajută pentru că:
a) face funcția mai rapidă b) compilatorul verifică faptul că funcția suprascrie una virtuală din bază c) face funcția statică d) interzice moștenirea
4. Object slicing apare când:
a) folosești pointeri b) folosești override c) clasa e abstractă d) copiezi un obiect derivat într-o variabilă de tipul bazei
12. Mai departe (pentru cine vrea mai mult)
- NVI (Non-Virtual Interface): metode publice nevirtuale care apelează metode private virtuale.
- CRTP: polimorfism la compilare, fără vtable (lecția oop-06).
std::variant+std::visit: alternativă la ierarhii pentru un set închis de tipuri.- Principiul substituției Liskov (lecția oop-05): derivata trebuie să poată înlocui baza fără surprize.
- Type erasure (
std::function): polimorfism fără moștenire publică.
Rezumat
- Moștenirea publică modelează „este un”; baza se construiește prima și se distruge ultima.
virtual+ pointer/referință la bază ⇒ se apelează funcția tipului real (legare la rulare).- Scrie mereu
override;finaloprește suprascrierea/derivarea. = 0face funcția pur virtuală și clasa abstractă; interfață = clasă abstractă fără date.- Baza polimorfică are destructor virtual; altfel
deleteprin bază este nedefinit. - Slicing: copierea în tipul bazei pierde derivata; colecții de obiecte polimorfice =
vector<unique_ptr<Baza>>. - Mecanism: vptr în obiect + vtable pe clasă; cost mic, dar real.
Citește și exersează în plus
- learncpp.com — Virtual functions and polymorphism · learncpp.com
capitolul despre funcții virtuale, pas cu pas (engleză)
https://www.learncpp.com/cpp-tutorial/virtual-functions/
- cppreference — virtual function specifier · en.cppreference.com
reguli exacte, override și final (engleză)
https://en.cppreference.com/w/cpp/language/virtual
- C++ Core Guidelines — Class hierarchies · isocpp.github.io
când și cum folosești ierarhiile (engleză)
https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Sh-domain
Te-ai blocat la lecția asta?
Scrie-mi ce nu iese și vedem împreună de unde se blochează.
Răspunsuri
Exersează pe hârtie
1. Construire: A(), B(), C(). Distrugere: ~C(), ~B(), ~A().
2. Fără virtual: ... (versiunea din Animal, după tipul pointerului). Cu virtual: ham.
3. Una virtuală are implementare în bază, care poate fi suprascrisă; una pur virtuală (= 0) nu are implementare și trebuie suprascrisă. Nu: Forma este abstractă, nu se pot crea obiecte din ea.
4. Eroare de compilare: cu override, compilatorul vede că nu există o funcție virtuală arie() non-const în bază. (Fără override, ar fi fost o funcție nouă, iar Dreptunghi ar fi rămas abstractă.)
5. Se apelează doar ~Animal(); standardul spune că este comportament nedefinit. Practic, destructorul lui Caine nu rulează, iar resursele lui (memorie, fișiere) nu sunt eliberate.
6. „prin valoare: ...” : parametrul este un Animal nou, construit prin copiere doar din partea de bază (slicing), deci sunet() din Animal. La ieșirea din funcție parametrul moare: ~Animal(Rex).
7. 8 octeți (pointerul vptr), plus eventual umplutură pentru aliniere. Obiectul trebuie să știe ce tabelă de funcții virtuale folosește.
8. Direct din Forma. Un pătrat derivat din dreptunghi încalcă principiul substituției: codul care face d.setLatime(5) și se așteaptă ca înălțimea să rămână aceeași ar fi surprins de un pătrat care își schimbă ambele laturi.
9. Când o clasă moștenește din două clase care au aceeași bază, conține două copii ale bazei (ambiguitate). Se rezolvă cu moștenire virtuală (: virtual public Baza), care păstrează o singură copie.
10. Când clasa nu este gândită pentru a fi extinsă (de exemplu, invariantul ar putea fi stricat de o derivată), sau ca să permiți compilatorului să elimine apelurile virtuale (devirtualizare).
Mini-grile
1. b). 2. a) abstractă. 3. b). 4. d).