DZIEDZICZENIE klasy bazowe i klasy pochodne Publikacja Wywietl

DZIEDZICZENIE · klasy bazowe i klasy pochodne Publikacja Wyświetl. Tytuł( ) Tytuł Cena Książka Wyświetl. Autora( ) Autor Czasopismo Wyświetl. Cykl( ) Cykl. Wydawania

· obiekty klas pochodnych Potop : Książka Wyświetl. Tytuł( ) Wyświetl. Autora( ) Tytuł Cena Autor Wprost : Czasopismo Wyświetl. Tytuł( ) Wyświetl. Cykl( ) Tytuł Cena Cykl

class id_klasy_pochodnej tryb_dziedziczenia { ciało_klasy_pochodnej }; : id_klasy_bazowej

· dziedziczenie pojedyncze class { Publikacja public: char // klasa bazowa *Tytul ; float Cena ; void Zmiana. Ceny ( float { Cena = Nowa. Cena ; } void Wyswietl. Tytul ( ) { cout << Tytul ; } } ; Nowa. Cena )

class { Ksiazka : public Publikacja // klasa pochodna public: char *Autor ; void Wyswietl. Autora ( ) { cout << Autor ; } } ; class { } ; Czasopismo : public Publikacja // klasa pochodna public: char *Cykl ; void Wyswietl. Cykl ( ) { cout << Cykl ; }

· class { dziedziczenie wielokrotne Samolot // klasa bazowa public: char int *Rodzaj. Napedu ; Zasieg ; } ; class { }; Transport // klasa bazowa public: int Liczba. Pasazerow ; int Ladownosc ;

class Samolot. Pasazerski : public Samolot, public Transport // klasa pochodna { char *Linia. Lotnicza ; }; Rodzaj. Napedu odziedziczone z klasy Samolot, Zasieg odziedziczone z klasy bazowej Samolot, Liczba. Pasazerow odziedziczone z klasy bazowej Transport, Ladownosc odziedziczone z klasy bazowej Transport, Linia. Lotnicza składowa specyficzna klasy Samolot. Pasazerski

· prywatne i powszechne klasy bazowe public private protected class Elektrownia // klasa bazowa { private: char *Wlasciciel ; protected: int Moc ; public: char *Nazwa ; } ;

class { Wodna : public Elektrownia // klasa pochodna public: char *Rzeka ; protected: char *Spiętrzenie ; } ; class { } ; Weglowa : public Elektrownia // klasa pochodna public: char *Rodzaj. Wegla ; protected: int Emisja. CO 2 ;

tryb dziedziczenia bazowa public protected private protected private --- --- pochodna

· zmiana charakteru dziedziczonych składowych class Klasa. Bazowa { public: int Atrybut. Czwarty ; Atrybut. Piaty ; }; class Klasa. Pochodna : protected Klasa. Bazowa { public: Klasa. Bazowa : : Atrybut. Czwarty ; }; /* składowa Atrybut. Czwarty odziedziczona z klasy bazowej zostanie dołączona do sekcji public zamiast do sekcji protected */ /* składowa Atrybut. Piaty zostanie dołączona do sekcji protected */

· wirtualne klasy bazowe (w grafach dziedziczenia) class Zwierzeta { public: char } ; class *Nazwa. Gatunkowa ; Ssaki : virtual public Zwierzeta {. . . } ; class Morskie : virtual public Zwierzeta {. . . } ; class Orka : public Ssaki, public Morskie {. . . } ; /* składowa Nazwa. Gatunkowa zostanie odziedziczona tylko 1 raz */

· tworzenie obiektów klas pochodnych: Elektrownia E 1; // bazowa Wodna EWo 1; // pochodna Weglowa EWe 1; // pochodna · konstruktory są wykonywane począwszy od szczytu hierarchii

a) bezargumentowe konstruktory klas bazowych class Ptaki { public: char Gromada[6]; bool Wedrowny; Ptaki( ) { strcpy(Gromada, "Aves"); Wedrowny = false; } };

class Wroblowce : public Ptaki { public: char Rzad[14]; Wroblowce ( ) { strcpy(Rzad, "Passeriformes"); } }; class Pokrzewka : public Wroblowce { public: char Rodzina[10], Gatunek[32]; Pokrzewka (char* gatunek) { strcpy (Rodzina, "Sylviidae"); strcpy (Gatunek, gatunek); Wedrowny = true; } }; Pokrzewka Piegza ("Sylvia curruca"); Kon. Baz

b) konstruktory klas bazowych z argumentami class Pojazdy. Kolowe { public: int Liczba. Kol; Pojazdy. Kolowe ( int ile ) { Liczba. Kol = ile; } };

class Pojazdy. Spalinowe : public Pojazdy. Kolowe { public: double Moc. Silnika; Pojazdy. Spalinowe(int kola, int moc): Pojazdy. Kolowe( kola ) { Moc. Silnika = moc; } };

class Samochody. Osobowe : public Pojazdy. Spalinowe { public: int Liczba. Pasazerow; Samochody. Osobowe(int kola, double moc, int pasazerowie) : Pojazdy. Spalinowe ( kola, moc ) { Liczba. Pasazerow = pasazerowie; } }; Samochody. Osobowe auto 1(4, 75, 5); Kon. Arg

· odwołania do składowych klas pochodnych – ogólnie tak jak do składowych zwykłych klas – dziedziczenie składowych o takich samych identyfikatorach class B 1 { public: char* Nazwa; }; class B 2 : public B 1 { public: char* Nazwa; }; class P 1 : public B 2 {. . . }; P 1 obiekt; obiekt. Nazwa; obiekt. B 1: : Nazwa; // błąd, niejednoznaczne // poprawnie obiekt. B 2: : Nazwa; // poprawnie

· funkcje zaprzyjaźnione: w funkcji zaprzyjaźnionej z klasą bazową nie można odwoływać się do składowych prywatnych i chronionych klasy pochodnej · konwersja obiektów klas bazowych i klas pochodnych – wskaźnik obiektu klasy bazowej można zastąpić wskaźnikiem obiektu klasy pochodnej (dziedziczenie powszechne, klasa bazowa bez składowych prywatnych)

class Samochody { public: int Moc. Silnika; }; class Osobowe : public Samochody { public: int Liczba. Pasazerow; }; class Ciezarowe : public Samochody { public: double Ladownosc; };

Samochody *wsk. Sam; wsk. Sam = new Osobowe; wsk. Sam = new Ciezarowe; wsk. Sam->Moc. Silnika; // poprawnie wsk. Sam->Ladownosc; // błąd ((Ciezarowe*)wsk. Sam)->Ladownosc; //poprawnie

· funkcje wirtualne Samochody* Ewidencja[1000]; // osobowe i ciężarowe // w dowolnej kolejności class Samochody { public: int Moc. Silnika; bool Osobowy; // identyfikacja }; if (Ewidencja[i]->Osobowy) ((Osobowy*)Ewidencja[i]-> Liczba. Pasazerow; else ((Ciezarowy*)Ewidencja[i]-> Ladownosc; /* żmudne */

· funkcja wirtualna : – zdefiniowana w klasie bazowej – redefiniowana w klasach pochodnych – przy wywołaniu poprzez wskaźnik klasy bazowej wybierana jest odpowiednia wersja class Figura { public: virtual double Powierzchnia ( ) { } };

class Kolo : public Figura { public: double Promien; virtual double Powierzchnia ( ) { return 3. 1415 * Promien; } }; class Prostokat : public Figura { public: double Bok. A, Bok. B; virtual double Powierzchnia ( ) { }; return Bok. A * Bok. B; }

Figura *wsk. Fig; wsk. Fig = new Kolo; wsk. Fig -> Powierzchnia( ); // πr 2 wsk. Fig = new Prostokat; wsk. Fig -> Powierzchnia( ); // ab

– wywoływanie funkcji wirtualnej z klasy bazowej class Wydawnictwo { public: char Nazwa[32]; virtual void Wyswietl( ) {cout << "Tytuł : " << Nazwa << endl; } }; class Ksiazka : public Wydawnictwo { public: char Autor[32]; virtual void Wyswietl( ) { Wydawnictwo: : Wyswietl( ); cout << "Autor : " << Autor << endl; } };

class Czasopismo : public Wydawnictwo { public: char Cykl[32]; virtual void Wyswietl ( ) { Wydawnictwo: : Wyswietl( ); cout << "Cykl : " << Cykl << endl; } }; Wydawnictwo * wsk. Wyd; wsk. Wyd = new Ksiazka; wsk. Wyd->Wyswietl( ); /* Tytuł : xxxxxx Autor : zzzzzz wsk. Wyd = new Czasopismo; wsk. Wyd->Wyswietl( ); /* Tytuł : yyyyyy Cykl : cccccc */ */

– przeciążenie funkcji wirtualnej nie jest konieczne we wszystkich klasach hierarchii klas – jeżeli w klasie nie ma redefinicji funkcji wirtualnej, to wykona się funkcja z najbliższej klasy poprzedniej w hierarchii, w której funkcja ta jest przeciążona Elek · klasy abstrakcyjne – nie zawierają składowych prywatnych – nie zawierają definicji funkcji wirtualnych (a tylko ich deklaracje) – nie tworzy się obiektów tych klas

class Figura { public: virtual double Powierzchnia ( ) = 0; }; class Kolo : public Figura { public: double Promien; virtual double Powierzchnia ( ) { return 3. 1415 * Promien; } }; Figura figa; // błąd Figura *wsk. Fig; // poprawnie wsk. Fig = new Figura; // błąd Figury wsk. Fig = new Kolo; // poprawnie Pojazdy

Obsługa Wyjątków · błędy czasu kompilacji · błędy czasu wykonania – błędy wykrywane sprzętowo – błędy wykrywane przez oprogramowanie występujące w funkcjach, sposoby obsługi: – wyróżniona wartość funkcji (0, -1) – globalna zmienna biblioteki – dodatkowy argument funkcji: zmienna, wskaźnik funkcji √

· · obsługa wyjątków w C++ – zgłoszenie wyjątku – sygnalizacja wywołania niebezpiecznej funkcji – sekcje obsługi wyjątków zgłoszenie wyjątku throw wyrażenie throw 12 ; // wyjątek typu int throw 1. 5 ; // wyjątek typu double throw "Błąd. "; // wyjątek typu char* // class Opis. Bledu ; throw Opis. Bledu ( ); // wyjątek typu // Opis. Błędu

/* F 1 = sqrt (( A + 3 * k ) / ( A - k – 1 )) */ double F 1 ( int k, double A ) { double L = A + 3 * k, M = A - k - 1 ; if ( M == 0 ) { throw 0; return 0; } if ( L / M < 0 ) { throw -1. 0; return 0; } return sqrt( L / M ); }

class Blad. Komunikatu { public: char Suma. Kontrolna ; int Liczba. Znakow ; Blad. Komunikatu ( char Suma, int Dlug) { Suma. Kontrolna = Suma; Liczba. Znakow = Dlug; } } ;

void Testuj. Komunikat ( char* Bufor ) { if ( Komunikat. Poprawny (Bufor) ) return ; else { Blad. Komunikatu *p. Opis. Bledu = new Blad. Komunikatu ( Suma. Kontrolna( Bufor ), Długosc. Komunikatu( Bufor ) ); throw p. Opis. Bledu ; return ; } }

· sygnalizacja wywołania funkcji try { blok } int i; double Z, X; . . try { Z = F 1 ( i, X ); // } char Bufor [1024]; . . . // przyjęcie komunikatu try { Testuj. Komunikat ( Bufor ); }

· sekcje obsługi wyjątków catch ( deklaracja_wyjątku) { blok } try { . . } catch ( typ 1 ) { . . } catch ( typ 2 ) { . . // tylko po try . . . . }

– typy wyjątków : a. . b. identyfikator typu lub identyfikator klasy c. deklaracja argumentu ad a) dla wszystkich wyjątków try { Z = F 1 ( i, X ); } catch (. . . ) { cout << " Oj źle! "; . . }

ad b) zgodnie z typem wartości podanej w zgłoszeniu wyjątku try { Z = F 1 ( i, X ); } catch ( int ) { cout << " Dzielenie przez zero! "; . . } catch ( double ) { cout << " Pierwiastek z ujemnej! "; . . }

ad c) według typu z przekazaniem wartości double Kwadrat. Elementu ( double Tablica [ ], int Rozmiar, int Indeks ) { if ( Indeks >= Rozmiar ) { throw Indeks ; // typ int return 0; } if ( Tablica [ Indeks ] > MAKSYMALNY ) { throw Tablica [ Indeks ] ; // typ double return 0 ; } return Tablica [ Indeks ] * Tablica [ Indeks ] ; }

try { X = Kwadrat. Elementu ( Wektor, Długosc, Pozycja ); } catch ( int Indeks ) { cout << ”n Indeks o wartości ” << Indeks << ” przekracza rozmiar wektora. ” ; } catch ( double Element ) { cout << ”n Podniesienie wartości ” << Element << ” do kwadratu ” ”spowoduje przekroczenie zakresu liczb” ” typu double. ” ; }

try { Testuj. Komunikat ( Bufor ) ; catch ( Blad. Komunikatu } *p. Opis. Bledu ) { cout << ”n Odebrano bledny ” ” komunikat o dlugosci : ” << p. Opis. Bledu -> Liczba. Znakow ; << ”n Bledna suma kontrolna : ” << p. Opis. Bledu -> Suma. Kontrolna ; delete p. Opis. Bledu ; }

· hierarchia wyjątków Funkcja. Pierwsza Funkcja. Druga . . . Funkcja. Nta // wszystkie funkcje wywołane przez try – sekcja obsługi wyjątku zgłoszonego w i-tej funkcji jest poszukiwana kolejno w funkcjach poprzedzających – gdy nie ma odpowiedniej sekcji wyjątek obsługuje środowisko wykonawcze lub system operacyjny Pomiary