DZIEDZICZENIE · klasy bazowe i klasy pochodne

Publikacja WyświetlTytuł( ) Tytuł Cena Książka WyświetlAutora( ) Autor Czasopismo WyświetlCykl( ) CyklWydawania DZIEDZICZENIE ·klasy bazowe i klasy pochodne

Potop : Książka Wprost : Czasopismo WyświetlTytuł( ) WyświetlAutora( ) Tytuł Cena Autor WyświetlTytuł( ) WyświetlCykl( ) Tytuł Cena Cykl ·obiekty klas pochodnych

class id_klasy_pochodnej : tryb_dziedziczenia id_klasy_bazowej { ciało_klasy_pochodnej };

·dziedziczenie pojedyncze class Publikacja // klasa bazowa { public: char *Tytul ; float Cena ; void ZmianaCeny ( float NowaCena ) { Cena = NowaCena ; } void WyswietlTytul ( ) { cout << Tytul ; } } ;

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

·dziedziczenie wielokrotne class Samolot // klasa bazowa { public: char *RodzajNapedu ; int Zasieg ; } ; class Transport // klasa bazowa { public: int LiczbaPasazerow ; intLadownosc ; } ;

class SamolotPasazerski :public Samolot, public Transport // klasa pochodna { char *LiniaLotnicza ; } ; RodzajNapedu odziedziczone z klasy Samolot, Zasieg odziedziczone z klasy bazowej Samolot, LiczbaPasazerow odziedziczone z klasy bazowej Transport, Ladownosc odziedziczone z klasy bazowej Transport, LiniaLotnicza składowa specyficzna klasy SamolotPasazerski

·prywatne i powszechne klasy bazowe publicprivateprotected classElektrownia// 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 *RodzajWegla ; protected: int EmisjaCO2 ; } ;

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

·zmiana charakteru dziedziczonych składowych class KlasaBazowa {public: int AtrybutCzwarty ; int AtrybutPiaty ; }; class KlasaPochodna :protected KlasaBazowa { public: KlasaBazowa :: AtrybutCzwarty ; }; /* składowa AtrybutCzwarty odziedziczona z klasy bazowej zostanie dołączona do sekcji public zamiast do sekcji protected */ /* składowa AtrybutPiaty zostanie dołączona do sekcji protected */

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

·tworzenie obiektów klas pochodnych: Elektrownia E1; // bazowa Wodna EWo1; // pochodna Weglowa EWe1; // pochodna ·konstruktory są wykonywanepocząwszyod szczytu hierarchii

a)bezargumentowekonstruktory 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"); KonBaz

b)konstruktory klas bazowych z argumentami class PojazdyKolowe { public: int LiczbaKol; PojazdyKolowe ( int ile ) { LiczbaKol = ile; } };

class PojazdySpalinowe : public PojazdyKolowe { public: double MocSilnika; PojazdySpalinowe(int kola, int moc): PojazdyKolowe( kola ) { MocSilnika = moc; } };

class SamochodyOsobowe : public PojazdySpalinowe {public: int LiczbaPasazerow; SamochodyOsobowe(int kola, double moc, int pasazerowie) : PojazdySpalinowe ( kola, moc ) { LiczbaPasazerow = pasazerowie; } }; SamochodyOsobowe auto1(4, 75, 5); KonArg

·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 B1 { public: char* Nazwa; }; class B2 : public B1 { public: char* Nazwa; }; class P1 : public B2 { ...... }; P1 obiekt; obiekt.Nazwa; // błąd, niejednoznaczne obiekt.B1::Nazwa; // poprawnie obiekt.B2::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 bazowychi 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 MocSilnika; }; class Osobowe : public Samochody { public: int LiczbaPasazerow; }; class Ciezarowe : public Samochody { public: doubleLadownosc; };

Samochody *wskSam; wskSam = new Osobowe; wskSam = new Ciezarowe; wskSam->MocSilnika; // poprawnie wskSam->Ladownosc; // błąd ((Ciezarowe*)wskSam)->Ladownosc; //poprawnie

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

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

classKolo : public Figura { public: double Promien; virtual double Powierzchnia ( ) { return 3.1415 * Promien * Promien; } }; class Prostokat : public Figura { public: double BokA, BokB; virtual double Powierzchnia ( ) { return BokA * BokB; } };

Figura *wskFig; wskFig = newKolo; wskFig->Powierzchnia( ); // πr2 wskFig = new Prostokat; wskFig->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 * wskWyd; wskWyd = new Ksiazka; wskWyd->Wyswietl( ); /* Tytuł : xxxxxx Autor : zzzzzz */ wskWyd = new Czasopismo; wskWyd->Wyswietl( ); /* Tytuł : yyyyyy Cykl : cccccc */

– przeciążenie funkcji wirtualnej nie jest koniecznewe 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 ·klasy abstrakcyjne – nie zawierają składowych prywatnych – nie zawierają definicji funkcji wirtualnych (a tylko ich deklaracje) – nie tworzy się obiektów tych klas Elek

class Figura { public: virtual double Powierzchnia ( ) = 0; }; classKolo : public Figura {public: double Promien; virtual double Powierzchnia ( ) { return 3.1415 * Promien * Promien; } }; Figura figa; // błąd Figura *wskFig; // poprawnie wskFig = new Figura; // błąd wskFig = newKolo; // poprawnie Figury Pojazdy

Obsługa Wyjątków ·błędy czasu kompilacji ·błędy czasu wykonania – błędy wykrywane sprzętowo – błędy wykrywane przez oprogramowaniewystę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 throwwyrażenie throw 12 ; // wyjątek typu int throw 1.5 ; // wyjątek typu double throw "Błąd."; // wyjątek typu char* // class OpisBledu ; throw OpisBledu ( );// wyjątek typu // OpisBłędu

/*F1 = sqrt (( A + 3 * k ) / ( A - k – 1 ))*/ double F1 ( 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 BladKomunikatu { public: char SumaKontrolna ; int LiczbaZnakow ; BladKomunikatu ( char Suma, int Dlug) { SumaKontrolna = Suma; LiczbaZnakow = Dlug; } } ;

void TestujKomunikat ( char* Bufor ) { if ( KomunikatPoprawny (Bufor) ) return ; else { BladKomunikatu *pOpisBledu = new BladKomunikatu ( SumaKontrolna( Bufor ), DługoscKomunikatu( Bufor ) ); throw pOpisBledu ; return ; } }

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

·sekcje obsługi wyjątków catch ( deklaracja_wyjątku) { blok } try { .......... } catch ( typ1 ) { .......... } catch ( typ2 ) // 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 = F1 ( i, X ); } catch (...) { cout << " Oj źle! "; ................... }

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

ad c) według typu z przekazaniem wartości double KwadratElementu ( 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 = KwadratElementu ( 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 { TestujKomunikat ( Bufor ) ; } catch ( BladKomunikatu *pOpisBledu ) { cout << ”\n Odebrano bledny ”” komunikat o dlugosci : ” << pOpisBledu -> LiczbaZnakow ; cout << ”\n Bledna suma kontrolna : ” << pOpisBledu -> SumaKontrolna ; delete pOpisBledu ; }

·hierarchia wyjątków FunkcjaPierwsza  FunkcjaDruga ......  FunkcjaNta // wszystkie funkcje wywołane przez try – sekcja obsługi wyjątku zgłoszonego w i-tej funkcjijest poszukiwana kolejnow funkcjach poprzedzających – gdy nie ma odpowiedniej sekcji wyjątek obsługuje środowisko wykonawcze lub system operacyjny Pomiary

DZIEDZICZENIE · klasy bazowe i klasy pochodne