Dziedziczenie

Przykład 1

Zawartość pliku klasy.h:

1. class zwierze{

public:

2. void spij();

zwierze();

virtual ~zwierze();

private:

3. int waga;

int wiek;

};

4. class pies:public zwierze

{

public:

5. void szczekaj();

void aport();

pies();

virtual ~pies();

};

1: tworzymy klasę zwierze;

2: deklaracja metod klasy;

3: deklaracja atrybutów;

4: tworzymy nowa klasę pies; klasa ta ma te same funkcje interfejsu co klasa zwierze;

5: dodajemy nowe metody interfejsu.

Zawartość pliku klasy.cpp:

#include "klasy.h"

#include <iostream.h>

zwierze::zwierze()

{}

zwierze::~zwierze()

{}

void zwierze::osa()

{

cout << "Zzzzzzzzzzz... Zzzzzzzzz...\n" << endl;

}

pies::pies()

{}

pies::~pies()

{}

void pies::aport()

{

cout << "Pies pobiegl po patyk...\n" << endl;

}

void pies::szczekaj()

{

cout << "hal hal !\n" << endl;

}

Zawartość pliku dziedziczenie.cpp:

#include <iostream.h>

1. #include "klasy.h"

void main ()

{

int wybor;

2. pies burek;

cout << "Co ma zrobic pies ?\n";

cout << "1. Spac\n2. Aportowac\n”

<< ”3. Szczekac\n4. Koniec\n\n";

do{

cout << "Twoj wybor: ";

cin >> wybor;

3. switch(wybor)

{

case 1:burek.spij();break;

case 2:burek.aport();break;

case 3:burek.szczekaj();break;

}

}while(wybor != 4);

}

1: dołączamy plik z deklaracja klas zwierze, pies;

2: deklaracja obiektu klasy pies;

3: w zależności od wyboru użytkownika burek (obiekt klasy pies) będzie wykonywał odpowiednie metody.

Wynik wykonania:

Co ma zrobic pies ?

1. Spac

2. Aportowac

3. Szczekac

4. Koniec

Twoj wybor: 1

Zzzzzzzzzzz... Zzzzzzzzz...

Twoj wybor: 2

Pies pobiegl po patyk...

Twoj wybor: 3

hal hal !

Twoj wybor: 4

Przykład 2

Zawartość pliku klasy.h:

class wrona

{

public:

void krzycz();

void lataj();

wrona();

virtual ~wrona();

};

1. class wrobel: public wrona{

public:

void krzycz();

wrobel();

virtual ~wrobel();

};

1: klasa wrobel dziedziczy po klasie wrona metody lataj() i krzycz();

Zawartość pliku klasy.cpp:

#include „klasy.h”

#include <iostream.h>

wrona::wrona()

{}

wrona::~wrona()

{}

1. void wrona::lataj()

{

cout << "fru fru...";

}

2. void wrona::krzycz()

{

cout << "krak krak...";

}

wrobel::wrobel()

{}

wrobel::~wrobel()

{}

3. void wrobel::krzycz()

{

cout << "cwir cwir...";

}

1. definicja metody lataj() klasy wrona;

2. definicja metody krzycz() klasy wrona;

3. nowa definicja metody krzycz() w klasie wrobel, która przesłania metodę krzycz() z klasy bazowej wrona.

Zawartość pliku dziedziczenie.cpp:

#include "iostream.h"

#include "klasy.h"

void main ()

{

wrona zosia;

wrobel cwirek;

cout << "Gdy wrona leci to jest: ";

zosia.lataj();

cout << "\ni gdy wrobel leci to jest: ";

cwirek.lataj();

cout << "\n\nLecz gdy wrona krzyczy to slychac: ";

zosia.krzycz();

cout << "\na gdy wrobel krzyczy to slychac: ";

cwirek.krzycz();

}

Wynik wykonania:

Gdy wrona leci to jest: fru fru...

i gdy wrobel leci to jest: fru fru...

Lecz gdy wrona krzyczy to slychac: krak krak...

a gdy wrobel krzyczy to slychac: cwir cwir...

Przykład 3

Plik Ksiazka.h

class Ksiazka

{

public:

char tytul [100];

char nazwisko_autora [20];

float cena;

public:

void wypisz();

Ksiazka(); //deklaracja konstruktora bezparametrowego

Ksiazka(char* i, char* n, float w);

//deklaracja konstruktora przeciązonego

~Ksiazka(); //deklaracja destruktora

int sprawdz_cene(float c);

//deklaracja metody sprawdzającej cene ksiazki

};

Plik Ksiazka.cpp

#include <iostream.h>

#include <string.h>

#include "Ksiazka.h"

Ksiazka::Ksiazka()

{ strcpy(tytul, "");

strcpy(nazwisko_autora, "");

cena=0;

cout << "Pracuje konstruktor domyslny klasy Ksiazka"

<< endl;

}

Ksiazka::Ksiazka(char* i, char* n, float w)

{ strcpy(tytul, i);

strcpy(nazwisko_autora, n);

cena=w;

cout << "Pracuje konstruktor przeciazony klasy Ksiazka"

<< endl;

}

Ksiazka::~Ksiazka()

{ cout << "Pracuje destruktor klasy Ksiazka" << endl;

}

int Ksiazka::sprawdz_cene(float c)

{ if (cena == c) return 1;

else return 0;

}

void Ksiazka::wypisz()

{ cout << "Tytul ksiazki: " << tytul << endl;

cout << "Nazwisko autora: " << nazwisko_autora<<endl;

cout << "Cena: " << cena << endl;

}

Plik Poezja.h

class Poezja :private Ksiazka

{

private: int rok_wydania;

public:

void wypisz();

Poezja(char* i, char* n, float w, int r);

~Poezja();

};

Plik Poezja.cpp

Poezja::Poezja(char* i, char* n, float w, int r):Ksiazka(i, n, w), rok_wydania(r)

{ rok_wydania = r;

cout << "Pracuje konstruktor przeciazony klasy Poezja"

<< endl;

}

Poezja::~Poezja()

{ cout<<"Pracuje destruktor klasy Poezja"<<endl;

}

void Poezja::wypisz()

{ Ksiazka::wypisz();

cout << "Rok wydania " << rok_wydania << endl;

}

Plik Glowny.cpp

#include <iostream.h>

#include "Ksiazka.h"

#include "Poezja.h"

void main(void)

{

float n_cena;

cout << "***********Ksiazka z ekonomii " << endl;

Ksiazka ekonomia;

ekonomia.wypisz();

cout << endl << "***********Ksiazka z informatyki "

<< endl;

Ksiazka informatyka("Programowanie w C++", "Grebosz", 200);

informatyka.wypisz();

cout << endl

<<"Podaj cene ksiazki z informatyki do sprawdzenia: ";

cin>>n_cena;

cout<<"Cena ksiazki z informatyki";

if(informatyka.sprawdz_cene(n_cena))

cout<<" jest taka sama" << endl;

else

cout<<" nie jest taka sama" << endl;

cout <<endl<< "***********Poezja " << endl;

Poezja Wiersze("Poematy", "Tuwim", 45, 1999);

Wiersze.wypisz();

cout << endl;

}

Wynik wykonania:

***********Ksiazka z ekonomii

Pracuje konstruktor domyslny klasy Ksiazka

Tytul ksiazki:

Nazwisko autora:

Cena: 0

***********Ksiazka z informatyki

Pracuje konstruktor przeciazony klasy Ksiazka

Tytul ksiazki: Programowanie w C++

Nazwisko autora: Grebosz

Cena: 200

Podaj cene ksiazki z informatyki do sprawdzenia: 200

Cena ksiazki z informatyki jest taka sama

***********Poezja

Pracuje konstruktor przeciazony klasy Ksiazka

Pracuje konstruktor przeciazony klasy Poezja

Tytul ksiazki: Poematy

Nazwisko autora: Tuwim

Cena: 45

Rok wydania 1999

Pracuje destruktor klasy Poezja

Pracuje destruktor klasy Ksiazka

Pracuje destruktor klasy Ksiazka

Pracuje destruktor klasy Ksiazka

7

---