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
protectedi konstruktorem bazy; - zadeklarować
virtuali 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.
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).
: 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.
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”.
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*.
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ę
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. |