0 bodů

C++ · 30 min

Dědičnost a polymorfismus

Odvozená třída, virtual a override, abstraktní třídy a virtuální destruktor. Rozdíl mezi statickým a dynamickým výběrem metody a past slicingu.

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.

cpp
#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";
}
text
animal woof

Dog 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).
cpp
#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();
}
text
Base hi
Derived who

p 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.

Doplň

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í.

cpp
#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";
}
text
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í.

Doplň

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.

cpp
#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);
}
text
...
meow

byValue 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ě.

cpp
#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";
}
text
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í).

Doplň

Pořadí konstruktorů

Vyber

Vyber správně

Spoj dvojice

Spoj pojem s významem

Ke každému pojmu najdi význam.

Roztřiď

Dědičnost, nebo složení?

Roztřiď vztahy podle toho, jak je správně modelovat.

Kvíz

Proč má mít polymorfní základní třída virtuální destruktor?

Kvíz

Co udělá override, když metoda v odvozené třídě nemá const, ale základní ano?

Kvíz

Co vypíše byValue(c) z příkladu se slicingem, když c je Cat?

Kvíz

Který zápis se nepřeloží, pokud je Shape abstraktní?

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>.

Kartičky

Kartičky: dědičnost