Klasa 3 · rozdział 4

Dziedziczenie i polimorfizm

Wspólny wzór w bazie, szczegóły w pochodnych. Potem jeden wskaźnik do bazy woła właściwą metodę — to polimorfizm. Visual Studio 2026.

Po tym rozdziale powinieneś umieć

  • wskazać klasę bazową i pochodną i wyjaśnić po co wspólna baza;
  • zbudować hierarchię z protected i konstruktorem bazy;
  • zadeklarować virtual i pokazać różne zachowanie pochodnych;
  • użyć wskaźnika lub referencji do bazy (wiążanie dynamiczne);
  • zdefiniować klasę abstrakcyjną (czysta funkcja wirtualna);
  • odróżnić przeciążenie od funkcji wirtualnej.

1. Dziedziczenie

Kilka klas dzieli ten sam kawałek: pojazd i samochód mają prędkość i „jedź”. Kopiowanie pól do każdej klasy to ten sam błąd, co trzy kopie wzoru w main. Klasa bazowa trzyma wspólny wzór. Pochodna dopisuje to, czego baza nie ma, i korzysta z publicznych (oraz protected) składowych bazy.

Zapis class Samochod : public Pojazd znaczy: samochód jest pojazdem (relacja is-a). Obiekt pochodnej ma wszystko z bazy plus swoje pola. To nie jest friend i nie jest zagnieżdżeniem „samochód zawiera pojazd” — zawiera prędkość, bo jest pojazdem.

class Pojazd {
protected:
    int predkosc;
public:
    Pojazd(int p) : predkosc(p) {}
    void jedz() { predkosc += 10; }
    int getPredkosc() const { return predkosc; }
};
class Samochod : public Pojazd {
    int drzwi;
public:
    Samochod(int p, int d) : Pojazd(p), drzwi(d) {}
    int getDrzwi() const { return drzwi; }
};

int main() {
    Samochod s(50, 4);
    s.jedz();                          // metoda z bazy
    cout << s.getPredkosc() << " " << s.getDrzwi();   // 60 4
}

main woła jedz na samochodzie, choć metoda siedzi w Pojazd. Pochodna nie widzi pól private bazy — tylko public i protected. Gdyby predkosc było private, Samochod musiałby iść przez gettery/settery.

Dziedzicz zachowanie, nie „żeby było” Nauczyciel jest pracownikiem — OK. Koło dziedziczące po Punkt, bo „ma środek” — słabe: koło ma punkt, nie jest punktem. Wtedy pole, nie baza.

2. Hierarchia, protected, konstruktor bazy

Hierarchia na sali: jedna baza i co najmniej jedna pochodna (częściej dwie: Konto → Ror i Oszczednosci, albo Pracownik → Nauczyciel). Wspólne idzie w górę. Specyfika — w dół.

Konstruktor pochodnej musi zainicjować bazę na liście: : Pojazd(p) albo : Pracownik(imie). Baza powstaje pierwsza, potem pola pochodnej, potem ciało konstruktora pochodnej. Destruktory lecą odwrotnie.

class Pracownik {
protected:
    string imie;
public:
    Pracownik(const string& i) : imie(i) {}
    string getImie() const { return imie; }
};
class Nauczyciel : public Pracownik {
    string przedmiot;
public:
    Nauczyciel(const string& i, const string& p)
        : Pracownik(i), przedmiot(p) {}
    void przedstaw() const {
        cout << imie << " uczy " << przedmiot;
    }
};

Nauczyciel n("Anna", "PO");
n.przedstaw();                 // Anna uczy PO
// n.imie = "X";  — błąd: protected, main nie widzi

przedstaw czyta imie, bo pochodna widzi protected. main — nie. Stąd tabela:

W klasie W pochodnej W main
private tak nie nie
protected tak tak nie
public tak tak tak

Atrybuty i tak zwykle zostawiasz private + gettery. protected wtedy, gdy pochodna naprawdę ma prawo ruszać stan bazy (np. predkosc += 10 w metodzie samochodu).

Bez wywołania bazy Jeśli baza nie ma konstruktora domyślnego, a pochodna nie woła : Baza(...), program się nie skompiluje. Kompilator nie zgadnie, jakie imię dać pracownikowi.

3. Polimorfizm i virtual

Masz tablicę figur: koło, prostokąt, koło. Chcesz w pętli wypisać pola — bez if (toKoło) przy każdym elemencie. Polimorfizm znaczy: to samo wywołanie f->pole(), a zachowanie zależy od rzeczywistego typu obiektu na stercie.

Dwa warunki: metoda w bazie oznaczona virtual oraz wywołanie przez wskaźnik albo referencję do bazy (nie przez zmienną „gołego” typu bazy z kopią). Wybór metody następuje w czasie działania — wiązanie dynamiczne.

class Figura {
public:
    virtual double pole() const { return 0; }
    virtual ~Figura() {}
};
class Kolo : public Figura {
    double r;
public:
    Kolo(double rr) : r(rr) {}
    double pole() const { return 3.14 * r * r; }
};
class Prostokat : public Figura {
    double a, b;
public:
    Prostokat(double aa, double bb) : a(aa), b(bb) {}
    double pole() const { return a * b; }
};

int main() {
    Figura* t[2];
    t[0] = new Kolo(2);
    t[1] = new Prostokat(3, 4);
    cout << t[0]->pole() << " " << t[1]->pole();   // 12.56 12
    delete t[0];
    delete t[1];
}

Typ zmiennej t[0] to Figura*, ale obiekt to koło — woła się Kolo::pole. Drugi element: Prostokat::pole.

Bez virtual Usuń słowo virtual z bazy i odpal ten sam main. Dostaniesz 0 0 — kompilator patrzy na typ wskaźnika (Figura*) i woła Figura::pole. To wiązanie statyczne. virtual jest więc nie ozdobą, tylko przełącznikiem polimorfizmu.

Wirtualny destruktor w bazie: gdy robisz delete na Figura*, ma się wywołać destruktor prawdziwej klasy (koła, prostokąta), nie tylko bazy. Nawet gdy destruktory są puste — dopisz virtual ~Figura() {}.

4. Klasa abstrakcyjna

Figura::pole zwracające 0 jest oszustwem: figury „w ogóle” nie mają pola. Pole mają koło i prostokąt. Baza ma tylko powiedzieć: każda figura umie pole — bez udawania wzoru.

Czysta funkcja wirtualna: virtual double pole() const = 0;. Klasa, która ma choć jedną taką metodę, jest abstrakcyjna: nie utworzysz Figura f; ani new Figura. Pochodna staje się konkretna dopiero gdy zaimplementuje wszystkie czyste metody.

class Figura {
public:
    virtual double pole() const = 0;
    virtual ~Figura() {}
};
class Kolo : public Figura {
    double r;
public:
    Kolo(double rr) : r(rr) {}
    double pole() const { return 3.14 * r * r; }
};

// Figura f;          — błąd kompilacji
Figura* f = new Kolo(2);   // OK: wskaźnik na bazę, obiekt pochodnej
cout << f->pole();         // 12.56
delete f;

Wskaźnik (albo referencja) na klasę abstrakcyjną jest legalny — wskazuje konkretną pochodną. Jeśli Kolo zapomni pole, samo stanie się abstrakcyjne i też nie utworzysz jego obiektu. Kompilator pilnuje kontraktu: „umiesz pole albo nie istniejesz jako figura”.

Po co baza, skoro nie ma obiektu Figury Żeby pętla i funkcje przyjmowały Figura* i nie znały koła ani prostokąta z imienia. Nowa figura = nowa pochodna, main z pętlą zostaje.

5. Przeciążenie a funkcje wirtualne

Oba mechanizmy „wybierają funkcję”, ale w innym momencie i według innego klucza. Da się je mieć w jednej hierarchii naraz — wtedy tym bardziej trzeba umieć je nazwać.

Przeciążenie Wirtualna (polimorfizm)
Kiedy Ta sama nazwa, inne parametry, zwykle jedna klasa Ta sama sygnatura w bazie i pochodnej
Wybór Przy kompilacji (typy argumentów) W czasie działania (prawdziwy typ obiektu)
Słowo — virtual / override
class Konto {
protected:
    double saldo;
public:
    Konto(double s) : saldo(s) {}
    void wplata(double kwota) { saldo += kwota; }
    void wplata(int grosze) { saldo += grosze / 100.0; }  // przeciążenie
    virtual string opis() const { return "konto"; }
};
class Oszczednosci : public Konto {
public:
    Oszczednosci(double s) : Konto(s) {}
    string opis() const { return "oszczędności"; }       // virtual
};

Konto* k = new Oszczednosci(100);
k->wplata(50.0);     // wersja double — decyzja przy kompilacji
k->wplata(250);      // wersja int — też przy kompilacji
cout << k->opis();   // "oszczędności" — decyzja w trakcie działania
delete k;

wplata(50.0) i wplata(250) różnią się typem argumentu — przeciążenie. opis() ma tę samą sygnaturę w bazie i pochodnej — virtual. Gdyby opis nie było wirtualne, k->opis() wypisałoby "konto", bo kompilator patrzy na typ Konto*.

override W pochodnej możesz dopisać string opis() const override. Kompilator sprawdzi, czy w bazie naprawdę jest taka wirtualna metoda. Literówka w nazwie przestaje cicho tworzyć nową, zwykłą funkcję.

Ćwiczenia do samodzielnego wykonania

Folder: Dokumenty\cwiczenia-po\klasa-3\rozdzial-04.

Ćwiczenie 1. Wskaż w kodzie łatwe

Przepisz Pojazd / Samochod. W komentarzach: baza, pochodna, co dziedziczy main może wołać.

Ćwiczenie 2. Prosta pochodna łatwe

Pracownik (imię) i Nauczyciel (przedmiot). Konstruktor bazy z listy pochodnej. Utwórz obiekt, wypisz imię metodą z bazy.

Ćwiczenie 3. protected łatwe

Pochodna zmienia protected pole bazy w swojej metodzie. Pokaż (komentarzem albo niedziałającą linią), że main tego pola nie ruszy.

Ćwiczenie 4. Hierarchia dwupoziomowa średnie

Baza + dwie pochodne (np. Konto → Oszczednosci i Ror). Wspólne: saldo, wpłata. Różne: jedna metoda specyficzna.

Ćwiczenie 5. virtual pole średnie

Figura z virtual pole(), Prostokat i Kolo. W main dwa obiekty, wypisz pola. Potem to samo przez Figura*.

Ćwiczenie 6. Abstrakcja średnie

Zamień pole w bazie na = 0. Spróbuj utworzyć Figura f; — zapisz komunikat kompilatora, zostaw tylko pochodne.

Ćwiczenie 7. Przeciążenie vs virtual trudne

W jednej hierarchii: (1) dwie metody ustaw o różnych parametrach (przeciążenie); (2) virtual opis() w bazie i pochodnych. W 4–6 zdaniach: który wybór kiedy.

Ćwiczenie 8. Mini-hierarchia trudne

Zaplanuj na kartce i zaimplementuj: hermetyzacja, jedna baza abstrakcyjna albo z virtual, dwie pochodne, we/wy w main, wywołanie przez wskaźnik na bazę. Temat: figury, konta albo pojazdy. Uzasadnij, które metody są virtual.

Sprawdź się

1. Dziedziczenie służy przede wszystkim do:
2. protected widzi:
3. Wiązanie dynamiczne wymaga:
4. Klasa z czystą funkcją wirtualną:
5. Przeciążenie a virtual:

Wymagania na ocenę

Ocena wyższa zawiera wymagania na oceny niższe. Dotyczy dziedziczenia i polimorfizmu.

Ocena Uczeń
2 Charakteryzuje dziedziczenie, hermetyzację i polimorfizm. Wskazuje bazę i pochodną w gotowym kodzie.
3 Definiuje bazę i pochodną. Korzysta z dziedziczonych składowych publicznych. Wyjaśnia, po co wspólna baza.
4 Buduje hierarchię, wydziela składowe, stosuje protected i konstruktor bazy, metodę virtual z różnym zachowaniem pochodnych.
5 Wskaźnik lub referencja do bazy. Klasa abstrakcyjna. Rozróżnia przeciążenie i virtual. Planuje aplikację z hermetyzacją, dziedziczeniem i polimorfizmem.
6 Projektuje hierarchię do zagadnienia. Wyjaśnia rolę klasy abstrakcyjnej. Uzasadnia, które metody są wirtualne i gdzie jest wiązanie dynamiczne.

Lista „już umiem”