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

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

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 char *Autor ; void WyswietlAutora ( ) { cout << Autor ; } } ; class Czasopismo : public Publikacja // klasa pochodna char *Cykl ; void WyswietlCykl ( ) { cout << Cykl ; }

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

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   public private protected  class Elektrownia // klasa bazowa { private: char *Wlasciciel ; protected: int Moc ; public: char *Nazwa ; } ;

class Wodna : public Elektrownia // klasa pochodna char *Rzeka ; protected: char *Spiętrzenie ; } ; class Weglowa : public Elektrownia // klasa pochodna char *RodzajWegla ; 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 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 : virtual public Zwierzeta { .............. } ; class Morskie : virtual public 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ą 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 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 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 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 MocSilnika; }; class Osobowe : public Samochody int LiczbaPasazerow; class Ciezarowe : public Samochody double Ladownosc;

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 klasy bazowej wybierana jest odpowiednia wersja   class Figura { public: virtual double Powierzchnia ( ) { } };

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

Figura *wskFig;   wskFig = new Kolo; 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 char Autor[32]; { Wydawnictwo::Wyswietl( ); cout << "Autor : " << Autor << endl; } };

class Czasopismo : public Wydawnictwo 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; /* 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   ·      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; }; class Kolo : public Figura double Promien; virtual double Powierzchnia ( ) { return 3.1415 * Promien * Promien; } Figura figa; // błąd Figura *wskFig; // poprawnie wskFig = new Figura; // błąd wskFig = new Kolo; // 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 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 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 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 ; }

·      sygnalizacja wywołania funkcji try { blok } int i; double Z, X; ......... try { Z = F1 ( i, X ); } // char Bufor [1024]; ............ // przyjęcie komunikatu { 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 funkcji jest poszukiwana kolejno w funkcjach poprzedzających –     gdy nie ma odpowiedniej sekcji wyjątek obsługuje środowisko wykonawcze lub system operacyjny Pomiary