Programowanie Obiektowe

Materiały pomocnicze do wykładu. 
Wyłącznie do użytku wewnętrznego!!!!!

Dr inż. Zbigniew Świerczyński

Dziedziczenie

Istota dziedziczenia. 

Dostęp do składników

Dziedziczenie wielopokoleniowe i wielobazowe

Dziedziczenie wirtualne

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

3

Czym jest klasa i obiekt w PO?

Niezmiernie ważne jest, aby wiedzieć, że:
• Klasa jest opisem cech i zachowań obiektów, 

opisem tego, jak powinien wyglądać obiekt, 
który będzie reprezentantem tej klasy (jej 
instancją). Klasa jest pojęciem, którego 
egzemplarzem jest obiekt.

• Klasa nie jest zbiorem istniejących obiektów 

o podobnych własnościach (atrybutach) i 
identycznych zachowaniach i nie jest też 
definicją takiego zbioru.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

4

Istota dziedziczenia

• Dziedziczenie to technika pozwalająca na 

definiowane nowej klasy z wykorzystaniem 
klasy już wcześniej istniejącej, bez zmiany tej 
ostatniej. 

 

Nowa Klasa 

Stara Klasa 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

5

Istota dziedziczenia c.d.

 

s a m o c h ó d  

o s o b o w y  

V W  

c ię ż a r o w y  

J a g u a r  

P o r s c h e  

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

6

Istota dziedziczenia c.d.

• Pies domowy:

• Istota żywa
• Ograniczony wzrost
• Zdolny do samodzielnego poruszania się
• Stałocieplny
• Potrafi  ssać
• Samice mają gruczoły mlekowe
• Psowaty  wygląd
• Drapieżny

 

zw ierzę 

ssa k 

p ies 

Pies domowy – drapieżny ssak z rodziny
psowatych, udomowiony przez człowieka 
potomek wilka szarego.

• Pies domowy: ssak

• Psowaty wygląd
• Drapieżny

• Ssak: zwierzę

• Stałocieplny
• Potrafi  ssać
• Samice mają gruczoły mlekowe

 

ko ń  

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

7

Dziedziczenie - przykład

• Przykład:

– Golf i lepszy Golf

 

Golf 

GolfKlasyS 

GolfKlasyS 

Golf 

class TCGolf {

public:

int Zbiornik;
void WlaczSilnik() {} ;

};
class TCGolfKlasyS

: public TCGolf

{

public:

int Klimatyzacja;
void WlaczSilnik() {} ;

};
//////////////////////////////////////
int main(int argc, char *argv[])
{

TCGolf Golf;
TCGolfKlasyS GolfKlasyS;

Golf.Zbiornik=20;
GolfKlasyS.Zbiornik=30;//pole odz.
GolfKlasyS.Klimatyzacja=18;

return 0;

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

8

Składniki odziedziczone

• Do odziedziczonych 

składników 
zdefiniowanych w 
klasie TCGolf
możemy odnosić się 
tak, jak do składników 
zdefiniowanych w 
klasie 

TCGolfKlasyS

class TCGolf {

public:

int Zbiornik;
void WlaczSilnik() {} ;

};
class TCGolfKlasyS: public TCGolf {

public:

int Klimatyzacja;
void WlaczSilnik() {} ;

};
//////////////////////////////////////
int main(int argc, char *argv[])
{

TCGolf Golf;
TCGolfKlasyS GolfKlasyS;

Golf.Zbiornik=20;

GolfKlasyS.Zbiornik

=30; //pole

// odziedziczone

GolfKlasyS.Klimatyzacja=18;

return 0;

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

9

• Nazewnictwo:

– Klasa podstawowa, 
– Klasa pochodna, 

Klasa pochodna i podstawowa -
nazewnictwo i oznaczenia

 

Golf 

GolfKlasyS 

GolfKlasyS 

Golf 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

10

Klasa pochodna i podstawowa

• W klasie pochodnej 

możemy:

– zdefiniować nowe, 

dodatkowe składowe

– zdefiniować składowe, 

które już istnieją w 
klasie podstawowej

class TCGolf {

public:

int Zbiornik;
void WlaczSilnik() {};

};
class TCGolfKlasyS: public TCGolf {

public:

int Klimatyzacja;
void WlaczSilnik() {};

};
//////////////////////////////////////
int main(int argc, char *argv[])
{

TCGolf Golf;
TCGolfKlasyS GolfKlasyS;

Golf.Zbiornik=20;
GolfKlasyS.Zbiornik=30;//pole odz.
GolfKlasyS.Klimatyzacja=18;

return 0;

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

11

Przesłanianie

• W tym drugim przypadku mamy do czynienia z 

zasłanianiem (przesłanianiem) składników 
klasy podstawowej. 

• Występuje ono jeśli oba składniki mają tą samą 

nazwę i w przypadku funkcji taką samą listę 
argumentów (to nie jest przeciążanie/ 
przeładowanie). 

class TCGolf {

public:

void WlaczSilnik() {};

};
class TCGolfKlasyS: public TCGolf {

public:

void WlaczSilnik() {};

};

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

12

Przesłanianie c.d.

• Wskutek dziedziczenia mamy do czynienia 

z jakby zagnieżdżaniem się zakresów.

• Poniższy zapis spowoduje wywołanie elementu 

z klasy pochodnej

{ // zakres klasy podstawowej

int x;

//składnik przesłaniany

int k;
{// zakres klasy pochodnej

int x;

//składnik przesłaniający

int m;

}

}

int main(int argc, char *argv[])
{
...

GolfKlasyS.WlaczSilnik();

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

13

Dostęp do przesłoniętej składowej

• Jeśli zależy nam na

wywołaniu elementu
klasy podstawowej, 
to musimy użyć
operatora zakresu
(kwalifikatora 
zakresu) czyli 
nazwy 
kwalifikowanej

int main(int argc, char *argv[])
{
...

// Własna

GolfKlasyS.WlaczSilnik(); 

// Odziedziczona

GolfKlasyS.

TCGolf::

WlaczSilnik(); 

...
}

//-----------------------------------------

//wewnątrz klasy pochodnej
skladnik(); // z klasy pochodnej

przodek::

skladnik(); // z klasy podstawowej

// na zewnątrz
obiekt.skladnik(); // z klasy pochodnej
obiekt.

przodek::

skladnik();//z klasy podst.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

14

Dostęp do składników klasy

• Tworząc klasę decydujemy o tym:

– które składowe dostępne są na zewnątrz klasy 

(public) a które nie (private i protected)

– które składowe chcemy przekazać klasie 

dziedziczącej (public i protected) a które nie 
(private)

• Tworząc klasę pochodną dodatkowo 

decydujemy poprzez specyfikator dostępu w 
jakim obszarze umieścić dziedziczone składowe

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

15

Jak dziedziczone są składowe?

//Klasa podstawowa
class TCKlasaA {
public:

// dostępne dla wszystkich, nawet dla zewnętrznych

int PubA;

private:

// dostępne dla elementów klasy i zaprzyjaźnionych

int PrivA;

protected:

// dostępne dla elementów klasy i potomków

int ProtA;

};
//***********************************************************
//Klasa pochodna - dziedziczenie publiczne
class TCKlasaB:

public

TCKlasaA {

public:

int PubB;

// int PubA; // !!! To będzie odziedziczone z klasy TCKlasaA 

private:

int PrivB;

protected:

int ProtB;

// int ProtA; // !!! To będzie odziedziczone z klasy TCKlasaA

};
//Klasa pochodna - dziedziczenie prywatne
class TCKlasaC:

private

TCKlasaA { .... };

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

16

Jak dziedziczone są składowe?

• Składowe prywatne też są dziedziczone, ale nie ma do 

nich bezpośredniego dostępu w klasie pochodnej

. 

 

Dziedziczenie 

private 

public 

protected 

private 

 

public 

protected 

private 

private 

z klasy bazowej 

Klasa podstawowa 

Klasa pochodna 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

17

Domyślny specyfikator dostępu

• Do  składowych prywatnych klasy podstawowej 

można dostać się poprzez publiczną funkcję z 
tej kasy. Funkcja ta będzie dostępna w klasie 
pochodnej. 

• Brak specyfikatora dostępu powoduje 

przyjęcie domyślnego specyfikatora, którym 
jest private

class przodek { ... };

class

dziedzic: przodek

{ ... }; // 

Brak

class

dziedzic:

private

przodek

{ ... };

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

18

Udostępnianie wybiórcze

• Udostępnianie wybiórcze

można zastosować przy 

dziedziczeniu

private

lub

protected

, 

• Jest to zastosowanie 

dziedziczenia publicznego 

(public) w stosunku do 

wybranych składowych.

• Robimy to przy pomocy 

deklaracji dostępu: 

KlasaPodst::Skladnik

class TCKlasaA {

public:

int poleAPubl;

protected:

int metodaAProt(int aArg);

private:

int poleAPriv;

};

class TCKlasaB: private TCKlasaA {

public:

int poleBPubl;
TCKlasaA::poleAPubl;

// deklaracja dostępu

protected:

int poleBProt;
TCKlasaA::metodaAProt;

// deklaracja dostępu

private:

int poleBPriv;

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

19

Deklaracja dostępu - uwagi

– Umieszczona jest w klasie pochodnej
– Nie pisze się typów a jedynie nazwę (tak samo z 

funkcjami)

– Sposób ten ma pewne mankamenty np. brak 

rozróżnienia nazw przeciążonych.

– Może ona tylko powtórzyć dostęp a nie zmienić

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

20

Co nie jest dziedziczone?

1. Konstruktory

2. Operator przypisania (operator=) 

3. Destruktor

4. Przyjaźń

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

21

Dziedziczenie wielo-pokoleniowe

• Dla klasy C:

– Klasa B jest klasą podstawową lub 

podstawową bezpośrednio

– Klasa A jest klasą podstawową

pośrednio lub bazową

• Lista pochodzenia jest listą klas 

podstawowych bezpośrednich

• W takiej strukturze łatwo można 

zauważyć co robi dziedziczenie 

prywatne

 

Blok A

Blok B

Blok C

class A { ... };
class B: public A {...};
class C: public B {...};

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

22

Co nam daje dziedziczenie?

 

s a m o c h ó d  

o s o b o w y  

V W  

c i ę ż a r o w y  

J a g u a r  

P o r s c h e  

• oszczędność pracy (aby użyć klasy do stworzenia nowej, nawet 

nie musimy wiedzieć jak ona dokładnie działa);

• budowanie hierarchii (odwzorowywanie struktury rzeczywistych 

obiektów);

• klasy ogólne (takie, które służyć mają wyłącznie do 

dziedziczenia);

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

23

Jak inicjalizować klasy pochodne?

• Wiemy, że konstruktory nie są dziedziczone;
• Jak powinniśmy inicjować składniki, które 

odziedziczyliśmy, zwłaszcza jeśli jest ich bardzo dużo 
i nie wszystkie nas interesują?

• Co  jeśli jednym z elementów klasy jest obiekt jakiejś

innej klasy niezwiązanej ściśle z tą klasą?

• Odnośnie części dziedziczonej można powiedzieć, że 

stanowi ona w pewnym sensie obiekt klasy 
podstawowej i tak też jest traktowana.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

24

W jakiej kolejności wywoływać się
będą konstruktory?

• Ogólnie: 

Klasa wywoła najpierw swoich przodków, potem gości 

a dopiero na samym końcu siebie.

• Konstruktory mogą inicjalizować komponenty swych 

klas poprzez listę inicjalizacyjną.

• Konstruktory klas pochodnych mogą na tej liście 

umieszczać również konstruktory klasy podstawowej 

(tylko bezpośredniej). 

– Jeśli nic nie wyspecyfikujemy na liście to:

• jeśli jest konstruktor domniemany (nie wymagający parametrów), to 

on się wykona 

• jeśli nie ma konstruktora domniemanego a jest inny, to kompilator 

pokaże błąd.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

25

W jakiej kolejności wywoływane są
konstruktory? Przykład

 

p o j a z d  

s a m o c h ó d  

s i l n i k  

M e r c e d e s  

k l i m a t y z a c j a  

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

26

W jakiej kolejności wywoływane są
konstruktory? Przykład c.d.

class TCSilnik {

int     typ;
TCSilnik(int n): typ(n) { };

~TCSilnik(){ };

}; 
class TCKlimatyzacja {

TCKlimatyzacja (){ };

~TCKlimatyzacja (){ };

}; 
class TCPojazd {

TCPojazd(){ } ;

~ TCPojazd(){ } ;

};
class TCSamochod: public TCPojazd {

TCSilnik  Silnik;
TCSamochod (int typ): Silnik(typ), TCPojazd() { } ;

~ TCSamochod (){ } ;

};
class TCMercedes: public TCSamochod {

TCKlimatyzacja

Klimatyzacja;

TCMercedes(int typ): Klimatyzacja(), TCSamochod(typ) { };

~ TCMercedes(){ } ;

};

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

27

Zasada:

1. najpierw wywołany będzie konstruktor klasy 

podstawowej

2. następnie konstruktory gości (w kolejności 

występowania na liście)

3. w dalszej kolejności wszystkie pozostałe inicjalizacje 

z listy

4. w końcu konstruktor bieżącej klasy

•

Destrukcja obiektu dokonuje się w odwrotnej 
kolejności do jego konstrukcji. 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

28

Przypisanie i inicjalizacja obiektów 
klas pochodnych

• Jest to trochę skomplikowane, ponieważ wiadomo, że 

nie jest dziedziczony konstruktor kopiujący (żaden nie 
jest dziedziczony) ani też operator przypisania.

• Praca polegająca na przypisaniu (lub inicjalizacji) 

składa się z dwóch części:

– przypisanie (lub inicjalizacja) dla części odziedziczonej
– przypisanie (lub inicjalizacja) dla części nowej (pochodnej)

• Klasa pochodna może mieć zdefiniowane konstruktor 

kopiujący i/lub operator przypisania, które prace te 
wykonają. 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

29

Brak zdefiniowanego operatora 
przypisania

• Jeśli jednak w klasie pochodnej nie będzie 

zdefiniowanego operatora przypisania, 

– wtedy kompilator automatycznie wygeneruje 

operator: 

klasa & klasa::operator=(klasa &);

przypisujący „składnik po składniku” korzystając 

dla części dziedziczonej z operatora klasy 

podstawowej 

• jeśli operator klasy podstawowej jest prywatny, wtedy nie 

będzie generował tego operatora dla klasy pochodnej

• jeśli klasa ma jakiś składnik const lub będący 

referencją wtedy operator nie będzie wygenerowany

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

30

Brak zdefiniowanego konstruktora 
kopiującego

• Jeśli w klasie pochodnej nie będzie 

zdefiniowanego konstruktora kopiującego, 

– wtedy kompilator automatycznie wygeneruje 

konstruktor: 

klasa::klasa(klasa &);

kopiujący „składnik po składniku” korzystając dla 

części dziedziczonej z konstruktora kopiującego 

klasy podstawowej

• jeśli konstruktor kopiujący klasy podstawowej jest 

prywatny, wtedy nie będzie generował tego konstruktora 

dla klasy pochodnej

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

31

Samodzielna inicjalizacja

• Napisanie samodzielne w klasie pochodnej 

konstruktora kopiującego oraz operatora przypisania

nie powinno nastręczać trudności, ponieważ

wykorzystuje się przy tym poznaną już wiedzę. Pewien 

drobny problem może stanowić wywołanie operatora 

przypisania z klasy bazowej na rzecz obiektu klasy 

pochodnej. Jeden ze sposobów polega na jawnym 

wywołaniu czyli:

(*this).przodek::operator=(wzor);

gdzie wzor to zmienna zawierająca wzorcowe wartości 

określona jako: potomek &wzor;

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

32

Dziedziczenie wielokrotne
(wielobazowe)

• Dziedziczenie wielokrotne uzyskuje się

umieszczając na liście dziedziczenia 
(pochodzenia) więcej niż jedną klasę
podstawową.

 

samochód 

łódka 

amfibia 

class samochod { ... };
class lodka { ... };
class amfibia

: public samochod, public lodka

{ ... };

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

33

O czym trzeba pamiętać?

• Przy dziedziczeniu wielobazowym należy 

pamiętać, że:

– każda klasa może pojawić się na liście tylko raz
– definicja klasy umieszczonej na liście musi być już

wcześniej znana

– na  liście przed każdą nazwą klasy musi wystąpić

określenie sposobu dziedziczenia

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

34

Przykład

class samochod
{
protected :

int  a ;

public:

samochod(int arg) : a(arg) {

cout << "Konstruktor samochodu\n" ;

} ;

} ;
/////////////////////////////////////////////////////////
class lodka {
protected :

int b ;

public:

lodka(int x) : b(x) {

cout << "Konstruktor lodki \n" ;

}

} ;
/////////////////////////////////////////////////////////
class amfibia :

public samochod, public lodka

//

{
public :

amfibia() :  samochod(1991) , lodka(4) {

cout << "Konstruktor amfibii \n" ;

}
void pisz_skladniki()  {

cout << "Oto odziedziczone skladniki\na = "

<< a << "\t b = " << b << endl ;

}

} ;
/*******************************************************/
main()
{ amfibia  aaa ;

aaa.pisz_skladniki();

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

35

Wieloznaczność

Jak temu zaradzić (2 sposoby):

• pisać nazwy kwalifikowane: 

samochod::x lub lodka::x

• zdefiniować składnik (w amfibii) o tej samej nazwie 

int amfibia ::x() { return samochod::x; }

 

samochód  (a, 

x

) 

łódka

(b, 

x

) 

amfibia 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

36

Wieloznaczność - poszlaki

• Zapis: ojciec::x, 

wskazuje gałąź poszukiwań.

 

ojciec 

matka 

(

x

) 

dziecko 

dziadek 

(

x

) 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

37

Konwersje standardowe przy 
dziedziczeniu

• Wskaźnik (referencja) do obiektu klasy 

pochodnej może być niejawnie przekształcony 
na wskaźnik (referencję) dostępnej 
jednoznacznie klasy podstawowej.

• Dotyczy to wskaźników i referencji a nie 

obiektów

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

38

Konwersje standardowe - Przykład

class samochod { // klasa podstawowa
public:

int zbiornik;

} ;
/////////////////////////////////////////////////////////
class VW: public samochod {// klasa pochodna

//...

} ;
/////////////////////////////////////////////////////////
void StacjaBenzynowa(samochod &klient) 
{

klient.zbiornik = 50;

}
/*******************************************************/
main()
{
samochod jakisSamochod;
VW VWMoj

StacjaBenzynowa(jakisSamochod);
StacjaBenzynowa(VWMoj); // niejawna konwersja
StacjaBenzynowa((samochod &)VWMoj); // jawna konwersja

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

39

Co jest możliwe a co nie?

 

pochodna obj 

podstawowa obj 

pochodna *wsk 

podstawowa *wsk 

pochodna **wskwsk 

podstawowa **wskwsk 

pochodna *tabWsk[] 

podstawowa *tabWsk[] 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

40

Wirtualne klasy podstawowe

• Często mówi się „wirtualna klasa podstawowa”, 

ale to tylko dziedziczenie jest wirtualne

 

B 

C 

D 

A 

A 

 

B 

C 

D 

A 

class A {...};
class B: public virtual A {...}; 
class C: public virtual A {...};
class D: public B, public C {...};

class B: private virtual A {...}; 
class C: public virtual A {...};

class A {...};
class B: public A {...}; 
class C: public A {...};
class D: public B, public C {...};

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

41

Wirtualne klasy podstawowe

• Wystarczy, że jedno dziedziczenie jest 

publiczne aby klasa A była dostępna publicznie

• Ciekawe jest w jaki sposób wywoływane są

konstruktory klas dziedziczonych wirtualnie

class A {...};
class B: private virtual A {...}; 
class C: public virtual A {...};
class D: public B, public C {...};

Funkcje wirtualne

Polimorfizm

Funkcje czysto wirtualne. Klasy abstrakcyjne

Wirtualny destruktor

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

43

Wprowadzenie

• Kilka klas ma jednego przodka:

– Janek, Kasia i Fiona mają tego samego ojca
– Mercedes, Fiat i Volvo są to samochody
– Trąbka, bęben i fortepian to instrumenty 

 

trąbka 

fortepian 

bęben 

instrument 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

44

Przykład

class instrument { // Klasa podstawowa
public:

void virtual wydaj_dzwiek() {

cout << "Nieokreslony brzdek !\n" ;

}

};
/////////////////////////////////////////////////////////
class trabka : public instrument {
public:

void wydaj_dzwiek()

{

cout << "Tra-ta-ta !\n" ;

}
// ...

}  ;
/////////////////////////////////////////////////////////
class beben: public instrument {
public:

void wydaj_dzwiek() {

cout << "Bum-bum-bum !\n" ;

}
// ...

}  ;
/////////////////////////////////////////////////////////
class fortepian : public instrument {
public:

void wydaj_dzwiek() {

cout << "Pilm-plim-plim !\n" ;

}
// ...

}  ;
/////////////////////////////////////////////////////////

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

45

Przykład c.d.

void muzyk(instrument & powierzony_instrument) {

powierzony_instrument.wydaj_dzwiek(); }

/*******************************************************/
main()
{ // 

Obiekty

instrument jakis_instrument ;
trabka      zlota_trabka ;
fortepian   steinway_giseli ;
beben       moj_werbel ;

jakis_instrument.wydaj_dzwiek();
zlota_trabka.wydaj_dzwiek();
steinway_giseli.wydaj_dzwiek();
moj_werbel.wydaj_dzwiek();

instrument *wskinstr ;

// ustawianie wskaźnika 

wskinstr = & jakis_instrument ;
wskinstr-> wydaj_dzwiek() ;
wskinstr = &zlota_trabka ;
wskinstr-> wydaj_dzwiek() ;
wskinstr = &steinway_giseli ;
wskinstr-> wydaj_dzwiek() ;
wskinstr = &moj_werbel ;
wskinstr-> wydaj_dzwiek() ;

// poprzez referencję

muzyk(jakis_instrument);
muzyk(zlota_trabka);
muzyk(steinway_giseli) ;
muzyk(moj_werbel) ;

}

Tra-ta-ta

Tra-ta-ta

Bum-bum-bum

Pilm-plim-plim

Pilm-plim-plim

Bum-bum-bum

Nieokreślony brzdęk

Nieokreślony brzdęk

Tra-ta-ta

Bum-bum-bum

Pilm-plim-plim

Nieokreślony brzdęk

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

46

Wielopostaciowość 

• Dzięki funkcji wirtualnej (modyfikacji w deklaracji 

funkcji słowem virtual)

• instrukcja zapisana jako 

Referencja.wydaj_dźwięk();

• interpretowana jest w trakcie działania programu jako:

Referencja.instrument::wydaj_dźwięk();
Referencja.trabka::wydaj_dźwięk();
Referencja.fortepian::wydaj_dźwięk();

• Identyczny efekt osiągamy dla wskaźników

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

47

Polimorfizm

• Taka wielość form określana jest mianem 

polimorfizm czyli inaczej wielopostaciowość. 
Ale to nie funkcja wirtualna jest polimorficzna 
tylko takie jej wywołanie wykazuje 
polimorfizm lub zachowuje się polimorficznie.

• Dzieje się to kosztem rozmiaru wynikowego 

programu oraz jego szybkości.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

48

Polimorfizm c.d.

• Wczesne i późne wiązanie

– Wczesne wiązanie to wiązanie na etapie kompilacji
– Późne wiązanie to wiązanie na etapie wykonywania

• Polimorfizm nie jest 

przeciążeniem/przeładowaniem 

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

49

Funkcja wirtualna

• Funkcja składowa jest wirtualna wtedy, gdy w 

definicji klasy przy jej deklaracji stoi słowo virtual, 

lub gdy w jednej z klas podstawowych tej klasy 

identyczna funkcja zadeklarowana jest jako virtual.

• Klasa pochodna nie musi definiować swojej wersji 

funkcji wirtualnej. 

• Funkcja wirtualna 

– nie  może być static.
– Może być zaprzyjaźniona z jakąś inną klasą, ale nie będzie 

dla niej wirtualną

– Może być inline (ale czasem będzie to ignorowane)

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

50

Klasy abstrakcyjne

• To klasa, która nie reprezentuje żadnego 

konkretnego obiektu i służy tylko do 

dziedziczenia

• Skoro klasa abstrakcyjna nie reprezentuje 

żadnego obiektu, więc nie będziemy tworzyć na 

jej podstawie żadnego obiektu. Jeśli klasa ta 

zawiera funkcję wirtualną to funkcja ta nie 

będzie realizowana i można ją zdefiniować

następująco

Typ virtual funkcja() = 0 ;

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

51

Funkcja czysto wirtualna

• Funkcję taką nazywamy czysto wirtualną (ang. pure 

virtual). Oznacza to, że tej wersji funkcji wirtualnej nie 
ma się nigdy wykonywać. 

• Zdefiniowanie w jakieś klasie funkcji czysto wirtualnej

powoduje, że kompilator nie pozwoli na stworzenie 
obiektu tej klasy. Klasa ta jest abstrakcyjna nie tylko 
dla nas ale i dla kompilatora.

• Brak definicji funkcji w klasie pochodnej powoduje 

odziedziczenie funkcji czysto wirtualnej ze wszystkimi 
tego skutkami (brak możliwości tworzenia obiektów).

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

52

Wirtualny destruktor

• Mimo  iż wyda się to dziwne, to jednak

wirtualność destruktora jest możliwa

• Można uzasadnić to tym, że 

– w klasie jest tylko jeden  
– nigdy nie ma parametrów 
– można przyjąć, że nazwa się zawsze „destruktor” 

• Wirtualność destruktora jest wyjątkiem.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

53

Po co wirtualny destruktor?

• Wprowadzenie funkcji wirtualnych oznacza, że chce się 

korzystać polimorfizmu 

• Polimorfizm to możliwość odnoszenia się do obiektów klas 

pochodnych poprzez wskaźnik (lub referencję) do klasy 
bazowej.

• Poza wywołaniem metody wirtualnej często zachodzi też 

potrzeba zniszczenia takiego obiektu (wskazywanego przez 
wskaźnik do klasy bazowej).

• Jeśli mówimy „umyj ten pojazd” mając na myśli konkretny 

obiekt (np. Volvo), to możemy też powiedzieć „zniszcz ten 
pojazd” i to też odnosi się do tego konkretnego, który 
wskazujemy.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

54

Po co wirtualny destruktor? Przykład

• Przy tworzeniu różnych 

obiektów wywoływane 

są różne konstruktory

• Różne obiekty 

wskazywane są przez 

taki sam wskaźnik

• Wywołanie różnych 

funkcji przez taki sam 

wskaźnik

• Wywołanie różnych 

destruktorów przez taki 

sam wskaźnik 

main()
{
//Jednakowe wskaźniki ale 
// różne  konstruktory

instrum *pierwszy = new skrzypce; 
instrum *drugi    = new gitara;   //
instrum *trzeci   = new gwizdek ;

//Różne funkcje

pierwszy->wydaj_dzwiek() ; 
drugi   ->wydaj_dzwiek() ;
trzeci  ->wydaj_dzwiek() ;

//Jednakowe wskaźniki ale 
//muszą być różne destruktory

delete pierwszy ; 
delete drugi ;    
delete trzeci ;

}

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

55

Jak uzyskać wirtualny destruktor?

• Tę sprawę załatwia postawienie słowa virtual przed 

nazwą destruktora

• Dzięki temu destruktor będzie wywoływany 

inteligentnie, co spowoduje, że niszczony będzie 
właściwy obiekt w całości (a nie tylko jego część 
odpowiadająca klasie podstawowej).

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

56

Zasada

•

Jeśli klasa deklaruje jedną ze swych 
funkcji jako virtual, 
wówczas jej destruktor deklarujemy 
również jako virtual.

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

57

Wirtualny destruktor - przykład

class instrum {
public :

void virtual wydaj_dzwiek()      {

cout << "cisza" ;

}

virtual ~instrum() { // ----wirtualny destruktor 

cout << "Destruktor instrumentu \n" ;

}

} ;
/////////////////////////////////////////////////////////
class skrzypce : public instrum {                         //

char *nazwa ;

public :

skrzypce(char *firma) {// - konstruktor------------

nazwa = new char[strlen(firma) + 1] ;         //
strcpy(nazwa, firma) ;

}
~skrzypce() { //- destruktor (wirtualny) -------------

cout << "Destruktor skrzypiec + " ;
delete nazwa ;                              //

}
// ----------------------------
void wydaj_dzwiek()
{

cout << "tirli-tirli ("

<< nazwa << ")\n" ;

}

} ;

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

58

Wirtualny destruktor - przykład

class gwizdek :public instrum {                         //
public :

void wydaj_dzwiek()     {

cout << "fiu-fiu \n" ;

}

} ;
/////////////////////////////////////////////////////////
class gitara : public instrum {

char *nazwa ;

public :

gitara(char *firma) {// - konstruktor-----------------

nazwa = new char[strlen(firma) + 1] ;       //
strcpy(nazwa, firma) ;

}
~gitara() { //- destruktor (wirtualny) ---------------

cout << "Destruktor gitary + " ;
delete nazwa ;                                //

}
// --------------------------
void wydaj_dzwiek()
{

cout << "brzdek-brzdek   ("

<< nazwa << ")\n" ;

}

} ;

K

ATEDRA 

M

ETROLOGII 

E

LEKTRONICZNEJ

I F

OTONICZNEJ

opracowanie Zbigniew Świerczyński

59

Wirtualny destruktor - przykład

main()
{

cout << "Definiujemy w zapasie pamięci\n"

"trzy instrumenty orkiestry\n  " ;

instrum *pierwszy = new skrzypce("Stradivarius") ;
instrum *drugi    = new gitara("Ramirez") ;
instrum *trzeci   = new gwizdek ;                 //

cout << "Gramy polimorficznie ! \n" ;

pierwszy->wydaj_dzwiek() ;                         //
drugi   ->wydaj_dzwiek() ;
trzeci  ->wydaj_dzwiek() ;

cout << "\nKoncert sie skonczyl, "

"likwidujemy instrumenty\n\n" ;

delete pierwszy ;                                   //
delete drugi ;
delete trzeci ;

}
/*******************************************************/