Lidsky řečeno
Dědičnost je jako rodina nástrojů. Základní „nástroj“ umí obecné věci (má rukojeť). Šroubovák a kladivo od něj dědí rukojeť a přidávají svou specialitu. Polymorfismus je, když řekneš „použij nástroj“ a nezáleží ti, který přesně v ruce držíš: šroubovák zašroubuje, kladivo přibije. Každý to udělá po svém.
Obtížnost: 4 z 5.
Odvozená třída
Odvozená třída převezme členy základní třídy a přidá nebo změní své. Zápis: class Dog : public Animal.
#include <iostream>
#include <string>
class Animal {
public:
std::string name() const { return "animal"; }
};
class Dog : public Animal {
public:
std::string bark() const { return "woof"; }
};
int main() {
Dog d;
std::cout << d.name() << " " << d.bark() << "\n";
}animal woofDog zdědil name() z Animal a přidal bark(). Slovo public před jménem základní třídy znamená, že pes je zvíře (veřejná dědičnost). Dědí se vztah „je“ (pes je zvíře). Vztah „má“ (auto má motor) se píše jako člen, ne jako dědění.
Přístup protected v základní třídě znamená: dostupné v odvozených třídách, ne zvenku.
Virtuální metody a polymorfismus
Když pracuješ s odvozeným objektem přes ukazatel nebo referenci na základní třídu, vybírá se verze metody podle toho, zda je metoda virtual:
- bez
virtual: vybere se podle typu ukazatele (rozhodne se při překladu), - s
virtual: vybere se podle skutečného typu objektu (rozhodne se za běhu).
#include <iostream>
struct Base {
void hi() const { std::cout << "Base hi\n"; }
virtual void who() const { std::cout << "Base who\n"; }
virtual ~Base() = default;
};
struct Derived : Base {
void hi() const { std::cout << "Derived hi\n"; }
void who() const override { std::cout << "Derived who\n"; }
};
int main() {
Derived d;
Base* p = &d;
p->hi();
p->who();
}Base hi
Derived whop je typu Base*, takže nevirtuální hi() je z Base. Virtuální who() se rozhodne za běhu podle skutečného objektu (Derived), proto se vypíše Derived who. Klíčové slovo override v odvozené třídě říká překladači „tohle má přepisovat virtuální metodu“. Když se podpis neshoduje (třeba zapomeneš const), překladač ohlásí chybu místo tichého vytvoření nové metody.
Která verze se zavolá?
Abstraktní třída
Metoda s = 0 je čistě virtuální (nemá tělo). Třída s aspoň jednou takovou metodou je abstraktní: nejde vytvořit její objekt, slouží jen jako rozhraní.
#include <iostream>
class Shape {
public:
virtual double area() const = 0;
virtual ~Shape() = default;
};
class Square : public Shape {
public:
Square(double s) : s_(s) {}
double area() const override { return s_ * s_; }
private:
double s_;
};
class Rect : public Shape {
public:
Rect(double w, double h) : w_(w), h_(h) {}
double area() const override { return w_ * h_; }
private:
double w_, h_;
};
int main() {
Square sq(3);
Rect rc(2, 5);
const Shape* shapes[2] = {&sq, &rc};
double total = 0;
for (const Shape* s : shapes) total += s->area();
std::cout << total << "\n";
}19Čtverec o straně 3 má plochu 9, obdélník 2 x 5 má 10, součet je 19. Cyklus vůbec neřeší, o jaký tvar jde: volá area() a správná verze se vybere za běhu. To je polymorfismus v praxi. Zápis Shape s; by se nepřeložil, protože Shape je abstraktní.
Plochy tvarů
Úskalí: slicing
Když odvozený objekt předáš hodnotou jako základní třídu, zkopíruje se jen jeho „základní část“. Odvozená část se uřízne (anglicky slicing) a virtuální volání pak vybere základní verzi.
#include <iostream>
#include <string>
struct Animal {
virtual std::string sound() const { return "..."; }
virtual ~Animal() = default;
};
struct Cat : Animal {
std::string sound() const override { return "meow"; }
};
void byValue(Animal a) { std::cout << a.sound() << "\n"; }
void byRef(const Animal& a) { std::cout << a.sound() << "\n"; }
int main() {
Cat c;
byValue(c);
byRef(c);
}...
meowbyValue dostane kopii typu Animal, takže Cat zmizelo a vypíše se .... byRef pracuje s původním objektem, proto meow. Pravidlo: polymorfní objekty předávej referencí nebo ukazatelem, nikdy hodnotou.
Konstruktory a destruktory v hierarchii
Konstruktory se volají od základu k odvozené třídě, destruktory opačně.
#include <iostream>
struct A {
A() { std::cout << "A "; }
virtual ~A() { std::cout << "~A "; }
};
struct B : A {
B() { std::cout << "B "; }
~B() override { std::cout << "~B "; }
};
int main() {
{
B b;
}
std::cout << "\n";
}A B ~B ~A Nejdřív vznikne základní část (A), potom odvozená (B). Při zániku se nejdřív zničí B, potom A. Destruktor základní třídy musí být virtuální, jinak by delete přes Base* zavolal jen základní destruktor a odvozená část by se neuklidila (nedefinované chování).
Pořadí konstruktorů
Vyber správně
Spoj pojem s významem
Ke každému pojmu najdi význam.
Dědičnost, nebo složení?
Roztřiď vztahy podle toho, jak je správně modelovat.
Proč má mít polymorfní základní třída virtuální destruktor?
Bez virtuálního destruktoru je delete base_ptr pro objekt odvozené třídy nedefinované chování.
Co udělá override, když metoda v odvozené třídě nemá const, ale základní ano?
To je právě smysl override: zachytí překlep nebo chybějící const, kdy by jinak vznikla jen nová, neviditelná metoda.
Co vypíše byValue(c) z příkladu se slicingem, když c je Cat?
Hodnotou se předá jen Animal část, Cat zmizelo, volá se základní sound().
Který zápis se nepřeloží, pokud je Shape abstraktní?
Objekt abstraktní třídy nejde vytvořit, ukazatele a reference na ni jsou v pořádku.
Pod kapotou · Jak funguje virtual: vtable
Překladač pro třídu s virtuálními metodami vyrobí tabulku ukazatelů na funkce (vtable) a každý objekt dostane skrytý ukazatel na ni. Volání virtuální metody je nepřímý skok přes tabulku, jen o málo dražší než obyčejné volání, ale zabrání inline optimalizaci, pokud překladač nepozná skutečný typ. Klíčové slovo final zakáže dalšímu odvozování nebo přepsání metody a umožní překladači volání zrychlit. C++ umožňuje i vícenásobnou dědičnost, která vede k problému „diamantu“ (společný předek se zdědí dvakrát), řeší se virtual dědičností. V praxi se mnohé polymorfní návrhy dnes řeší i bez dědění: std::variant a std::visit (C++17), nebo šablonami a koncepty (C++20). Pro vlastnictví polymorfních objektů používej std::unique_ptr<Base>.