Lekcja 27LEKCJA 27
Dziedziczenie wielobazowe
Z poprzedniej lekcji wiesz, że możesz na podstawie jednej klasy tworzyć inne
klasy dziedziczące cechy klasy wyjściowej. Okazuje się, że C++ pozwala tworzyć
klasę na podstawie więcej niż jednej klasy bazowej. Jeśli nowa klasa dziedziczy
cechy kilku klas bazowych, to mamy do czynienia z dziedziczeniem wielobazowym.
Jak dowiesz się z tej lekcji, C++ daje pełną obsługę dziedziczenia
wielobazowego. Pod koniec tej lekcji będziesz rozumiał następujące zagadnienia
podstawowe:
Gdy tworzysz nową klasę jako pochodną wielu klas bazowych, to korzystasz z
dziedziczenia wielobazowego.
W dziedziczeniu wielobazowym klasa pochodna ma atrybuty wielu klas bazowych.
Gdy tworzysz klasę pochodną przy użyciu dziedziczenia wielobazowego, to jej
konstruktor musi wywoływać konstruktory wszystkich klas bazowych.
Gdy tworzysz klasę pochodną na podstawie klasy pochodnej, to powstaje łańcuch
dziedziczenia.
Dziedziczenie wielobazowe jest bardzo silnym narzędziem programowania
obiektowego. Poświęć nieco czasu na przećwiczenie programów, które przedstawimy
podczas tej lekcji. Jak zobaczysz, tworzenie nowej klasy na podstawie klasy
istniejącej pozwoli Ci zaoszczędzić dużo pracy programistycznej.


Prosty przykład
Załóżmy, że masz następującą klasę monitor_komputera:
class monitor_komputera {
public:
monitor_komputera (char *, long, int, int);
void inf_o_monitorze (void);
private:
char typ[32];
long kolory;
int rozdzielczosc_x;
int rozdzielczosc_y;
};

Analogicznie załóżmy, że masz następującą klasę plyta_glowna:
class plyta_glowna {
public:
plyta_glowna (int, int, int);
void inf_o_plycie_glownej (void);
private:
int procesor;
int szybkosc;
int RAM;
};

Na podstawie tych dwóch klas możesz w następujący sposób utworzyć klasę pochodną
komputer:
class komputer : public monitor_komputera, public plyta_glowna {
public:
komputer (char *, int, float, char *, long, int, int, int, int, int);
void inf_o_komputerze (void);
private:
char nazwa[64];
int dysk_twardy;
float stacja_dyskietek;
};

Jak widzimy, definicja klasy pochodne podaje nazwy klas bazowych za dwukropkiem
po nazwie klasy komputer:
class komputer : public monitor_komputera, public plyta_glowna


Przedstawiony poniżej program KOMPUTER.CPP na podstawie klas bazowych
monitor_komputera i plyta_glowna tworzy klasę pochodną komputer:
#include
#include

class monitor_komputera {
public:
monitor_komputera (char *, long, int, int);
void inf_o_monitorze (void);
private:
char typ[32];
long kolory;
int rozdzielczosc_x;
int rozdzielczosc_y;
};

monitor_komputera::monitor_komputera (char *typ, long kolory,
int roz_x, int roz_y)
{
strcpy (monitor_komputera::typ, typ);
monitor_komputera::kolory = kolory;
monitor_komputera::rozdzielczosc_x = roz_x;
monitor_komputera::rozdzielczosc_y = roz_y;
}

void monitor_komputera::inf_o_monitorze (void)
{
cout << "Typ: " << typ << endl;
cout << "Kolory: " << kolory << endl;
cout << "Rozdzielczość: " << rozdzielczosc_x << " na " <<
rozdzielczosc_y << endl;
}

class plyta_glowna {
public:
plyta_glowna (int, int, int);
void inf_o_plycie_glownej (void);
private:
int procesor;
int szybkosc;
int RAM;
};

plyta_glowna::plyta_glowna (int procesor, int szybkosc, int RAM)
{
plyta_glowna::procesor = procesor;
plyta_glowna::szybkosc = szybkosc;
plyta_glowna::RAM = RAM;
}

void plyta_glowna::inf_o_płycie_glownej (void)
{
cout << "Procesor: " << procesor << endl;
cout << "Szybkość: " << szybkosc << "MHz" << endl;
cout << "RAM: " << RAM << " MB" << endl;
}

class komputer : public monitor_komputera, public plyta_glowna {
public:
komputer (char *, int, float, char *, long, int, int, int, int, int);
void inf_o_komputerze (void);
private:
char nazwa[64];
int dysk_twardy;
float stacja_dyskietek;
};

komputer::komputer (char *nazwa, int dysk_twardy, float stacja_dyskietek,
char *ekran, long kolory, int roz_x, int roz_y,
int procesor, int szybkosc, int RAM) :
monitor_komputera (ekran, kolory, roz_x, roz_y),
plyta_glowna (procesor, szybkosc, RAM)
{
strcpy (komputer::nazwa, nazwa);
komputer::dysk_twardy = dysk_twardy;
komputer::stacja_dyskietek = stacja_dyskietek;
}

void komputer::inf_o_komputerze (void)
{
cout << "Typ:" << nazwa << endl;
cout << "Dysk twardy: " << dysk_twardy << "MB" << endl;
cout << "Stacja dyskietek: " << stacja_dyskietek << "MB" << endl;
inf_o_plycie_glownej();
inf_o_monitorze();
}

void main(void)
{
komputer komputerek ("Compaq", 212, 1.44, "VGA", 16000000, 640, 480,
486, 66, 8);

komputerek.inf_o_komputerze();
}

Jeśli przyjrzysz się konstruktorowi klasy komputer, to zauważysz, że wywołuje on
konstruktory klas monitor_komputera i plyta_glowna:
komputer::komputer (char *nazwa, int dysk_twardy, float stacja_dyskietek,
char *ekran, long kolory, int roz_x, int roz_y,
int procesor, int szybkosc, int RAM) :
monitor_komputera (ekran, kolory, roz_x, roz_y),
plyta_glowna (procesor, szybkosc, RAM)



Budowanie łańcucha dziedziczenia
Gdy programując w C++ przy użyciu dziedziczenia tworzysz klasę pochodną, to może
się zdarzyć tak, że jej klasa bazowa sama jest pochodną innej klasy bazowej. Na
przykład, załóżmy, że chcesz utworzyć klasę stacja_robocza na podstawie klasy
komputer w następujący sposób:
class stacja_robocza : public komputer {
public:
stacja_robocza (char *system_operacyjny, char *nazwa,
int dysk_twardy, float stacja_dyskietek,
char *ekran, long kolory, int roz_x, int roz_y,
int procesor, int szybkosc, int RAM)
void inf_o_stacji_roboczej (void);
private:
char system_operacyjny[64];
};

Konstruktor klasy stacja_robocza po prosty wywołuje konstruktor klasy komputer,
który z kolei wywołuje konstruktory klas monitor_komputera i plyta_glowna:
stacja_robocza::stacja_robocza (system_operacyjny, nazwa,
dysk_twardy, stacja_dyskietek,
ekran, kolory, roz_x, roz_y,
procesor, szybkosc, RAM):
komputer (nazwa, dysk_twardy, stacja_dyskietek,
ekran, kolory, roz_x, roz_y,
procesor, szybkosc, RAM) :
{
strcpy (stacja_robocza::system_operacyjny, system_operacyjny);
}

W tym przykładzie użyliśmy klasy komputer jako klasy bazowej. Ale jak wiesz,
klasa komputer jest pochodną klas monitor_komputera i plyta_glowna. W rezultacie
klasa stacja_robocza dziedziczy cechy wszystkich trzech klas. Jak widać na
rysunku 10, podczas tworzenia kolejnych klas pochodnych powstaje łańcuch klas.
Gdy zaczniesz pisać programy szeroko korzystające z dziedziczenia, to łańcuchy
dziedziczenia staną się długie, a jednocześnie liczby dziedziczonych składowych
duże.
Rysunek 10.
Tworzenie łańcucha dziedziczenia




Zapamiętaj
Dziedziczenie wielobazowe to możliwość tworzenia klasy pochodnej na podstawie
dwóch lub więcej klas bazowych. Gdy korzystasz z dziedziczenia wielobazowego, to
klasa pochodna dziedziczy cechy (składowe) istniejących klas bazowych. Dzięki
dziedziczeniu wielobazowemu w C++ masz ogromne możliwości programowania
obiektowego. Podczas lekcji 28 nauczysz się, w jaki sposób dawać dostęp do
prywatnych składowych klasy innym klasom lub funkcjom innych klas, które
będziemy nazywać zaprzyjaźnionymi. Przy użyciu klas i funkcji zaprzyjaźnionych
możesz udostępniać wybranym funkcjom składowe klasy jednocześnie zabezpieczając
je przed dostępem z pozostałych miejsc programu. Zanim jednak przejdziemy do
następnej lekcji upewnij się, że opanowałeś już te zagadnienia podstawowe:
Dziedziczenie wielobazowe polega na tym, że klasa pochodna może dziedziczyć
cechy dwóch lub więcej klas bazowych.
Aby utworzyć klasę pochodną na podstawie dwóch lub więcej klas bazowych,
podajesz nazwy tych klas bazowych oddzielone przecinkami za nazwą klasy
pochodnej i dwukropkiem, np. kotkrolik : public kot, public krolik.
W konstruktorze klasy pochodnej musisz wywoływać konstruktory wszystkich klas
bazowych z odpowiednimi parametrami.
Gdy tworzysz klasy pochodne, to może się zdarzyć tak, że klasa bazowa, z
której korzystasz, jest w rzeczywistości pochodną innej klasy bazowej. W ten
sposób w programie powstaje łańcuch dziedziczenia. Gdy wywołujesz konstruktor
nowej klasy pochodnej, to wywoływane są również konstruktory kolejnych klas w
łańcuchu dziedziczenia.



WsteczSpis treściDalej