Relacje między klasami - dziedziczenie
Dziedziczenie (ang. inheritance) - jest to ustanowienie związku pomiędzy klasami, polegającego na przejmowaniu właściwości jednej klasy (tzw. klasy podstawowej, bazowej, ang. base class) przez inną klasę (tzw. klasę pochodną. ang. derived class).
Jeżeli zdefiniujemy taki związek, to automatycznie obiekty klasy pochodnej zawierają:
składowe odziedziczone z klasy bazowej (określone w definicji klasy bazowej)
składowe własne klasy pochodnej (określone w definicji klasy pochodnej)
Można powiedzieć, że obiekty klasy pochodnej są szczególnymi przypadkami obiektów innej klasy.
Dziedziczenie określa się w definicji klasy pochodnej:
Klasa pochodna może dziedziczyć z więcej niż jedna klasy bazowej.
Jeśli klasa dziedziczy tylko atrybuty jednej klasy, mówimy o dziedziczeniu pojedynczym.
Jeśli klasa dziedziczy atrybuty dwóch lub więcej innych klas, mówmy o dziedziczeniu wielokrotnym (wielobazowym,
Przykład: punkt i jego specjalizacja - punkt kolorowy.
Dziedziczenie opisuje relację "jest": punkt kolorowy jest punktem
// klasa bazowa
class Punkt {
private:
int x;
int y;
public:
void inicjalizuj(int, int);
void przesun(int,int);
void drukuj () ;
} ;
// klasa pochodna
class Punktkol : public Punkt
{ short kolor ; // nowa składowa
public :
void koloruj(short); // nowa funkcja
} ;
w main() :
Punktkol a;
// można się odwoływać zarówno do składowych klasy Punkt
// (publicznych) jak i klasy Punktkol (również publicznych)
a.inicjalizuj(1,1); // przypisanie wartości współrzędnych punktu:
// funkcja klasy bazowej
a.koloruj(2); // przypisanie koloru:
// funkcja klasy pochodnej
a.drukuj(); // drukowanie współrzędnych
// funkcja klasy bazowej
Dziedziczenie nie zmienia zasad dostępu do składowych klasy bazowej: funkcje klasy pochodnej nie mają dostępu do składowych prywatnych klasy bazowej.
W klasie pochodnej określany jest tryb dziedziczenia, który określa zasady dostępu do składowych funkcji bazowej dla obiektów i funkcji zaprzyjaźnionych klasy pochodnej. Tryb public (publiczny) oznacza, że składowe publiczne klasy bazowej będą również składowymi publicznymi klasy pochodnej.
Dostęp do składowych klasy bazowej w klasie pochodnej
Jeśli składowe w klasie bazowej są zadeklarowane jako prywatne, klasa pochodna je dziedziczy ale nie ma do nich bezpośredniego dostępu.
Przykład: współrzędne punktu zdefiniowane w klasie bazowej są prywatne, klasa pochodna nie ma zatem dostępu do współrzędnych punktu, może jedynie korzystać z tych zmiennych za pomocą publicznych funkcji dostępu przewidzianych w klasie bazowej
class Punkt {
private :
int x;
int y;
public :
void inicjalizuj(int, int);
void przesun(int, int);
void drukuj ();
} ;
void Punkt::inicjalizuj(int xx, int yy)
{ x = xx ; y = yy; }
void Punkt::przesun(int dx, int dy)
{ x = x + dx ; y = y + dy ; }
void Punkt::drukuj ()
{ cout << "Moje wspolrzedne " << x << " " << y << endl ; }
/////////////////////////////////////////////////////////////////
class Punktkol : public Punkt // Punktkol jest klasą pochodną Punkt
{ short kolor;
public :
void koloruj (short kk) { kolor = kk ; }
void drukujkol();
void inicjalizujkol(int xx, int yy, int kk);
} ;
void Punktkol::drukujkol ()
{
drukuj(); // na rzecz którego obiektu jest ta funkcja wywołana?
cout << "i moj kolor " << kolor << "\n" ;
}
void Punktkol::inicjalizujkol (int xx, int yy, short kk)
{
inicjalizuj(xx,yy);
kolor=kk ;
}
W main():
Punktkol p ;
p.inicjalizujkol (1,1,3) ; // składowa klasy Punktkol
p.drukuj () ; // składowa klasy Punkt
p.przesun (2,4) ; // składowa klasy Punkt
p.koloruj (2) ; // składowa klasy Punktkol
p.drukujkol() ; // składowa klasy Punktkol
Nadpisywanie funkcji składowych w klasie pochodnej
Przykład: Funkcje drukuj() w klasie Punkt i drukujkol() w klasie Punktkol mają podobne działanie (wyświetlenie wartości składowych klasy). Czy możliwe jest nadanie im tej samej nazwy?
#include <iostream>
class Punkt
{
private :
int x ;
int y ;
public :
void inicjalizuj(int, int) ;
void przesun(int, int) ;
void drukuj () ;
} ;
void Punkt::inicjalizuj(int xx, int yy)
{
x = xx ; y = yy ;
}
void Punkt::przesun(int dx, int dy)
{
x = x + dx ; y = y + dy ;
}
void Punkt::drukuj ()
{
cout << "Moje wspolrzedne " << x << " " << y << "\n" ;
}
/////////////////////////////////////////////////////////////////
class Punktkol : public Punkt // Punktkol jest pochodną Punkt
{ short kolor ;
public :
void koloruj (short kk) { kolor = kk ; }
void drukuj(); // ponowna definicja drukuj()
void inicjalizuj(int, int, short); // ponowna definicja inicjalizuj()
};
void Punktkol::inicjalizuj(int xx, int yy, short kk)
{
Punkt::inicjalizuj(xx,yy); // funkcja inicjalizuj() klasy Punkt
kolor=kk;
}
void Punktkol::drukuj ()
{
Punkt::drukuj();
cout << "i moj kolor " << kolor << "\n" ;
}
W main():
Punktkol p ;
p.inicjalizuj (1,1,3) ;
p.drukuj () ; // funkcja drukuj() klasy Punktkol
p.Punkt::drukuj(); // funkcja drukuj() klasy Punkt
p.koloruj (2) ;
p.drukuj() ; // funkcja drukuj() klasy Punktkol
Nadpisywanie i przeciążanie
Funkcja nadpisana w klasie pochodnej zakrywa wszystkie funkcje o tej samej nazwie w klasie bazowej.
Przykład:
class A
{
...
public:
void f(int);
void f(char);
void g(int);
void g(char);
};
class B : public A
{
...
public:
void f(int);
void f(float);
};
W main() :
int n;
float x;
char c;
B b;
b.f(n); // wywołana funkcja B::f(int)
b.f(x); // wywołana funkcja B::f(float)
b.f(c); // wywołana funkcja B::f(int) - konwersja char na int
b.g(n); // wywołana funkcja A::g(int)
b.g(x); // błąd: niejednoznaczność A::g(int) czy A::g(char)
b.g(c); // wywołana funkcja A::g(char)
Wywoływanie konstruktorów i destruktorów
Brak dziedziczenia:
Jeśli istnieje przynajmniej jeden konstruktor użytkownika, do utworzenia obiektu wywołany zostanie konstruktor wybrany na podstawie argumentów dostarczonych w deklaracji obiektu. Jeśli nie zostanie znaleziony konstruktor o odpowiednim zestawie argumentów, obiekt nie będzie mógł być utworzony i wygenerowany zostanie błąd kompilacji.
Jeśli nie istnieje żaden konstruktor użytkownika, kompilator wygeneruje własny konstruktor i utworzy obiekt. W tym przypadku nie można jednak przesłać do konstruktora informacji o wartościach początkowych składowych obiektu.
Jeśli istnieje destruktor użytkownika, zostanie on wywołany przed usunięciem obiektu.
Istnieje klasa bazowa i klasa pochodna
Klasa bazowa i pochodna mają osobne konstruktory i destruktory.
Jeśli klasa bazowa posiada konstruktor, to musi on być wykonany przed konstruktorem klasy pochodnej.
Destruktory są wykonywane w odwrotnej kolejności: najpierw wywoływany jest destruktor klasy pochodnej, a potem destruktor klasy bazowej.
Załóżmy, że mamy dwie klasy:
Jeśli klasa bazowa nie zawiera konstruktora z parametrami, klasa pochodna nie musi wykonywać żadnych specjalnych działań.
Jeśli jednak konstruktor klasy bazowej wymaga przekazania mu argumentów, to klasa pochodna musi mu ich dostarczyć.
Pytanie: Co będzie w przypadku, gdy:
klasa bazowa nie ma konstruktora, klasa pochodna ma taki konstruktor
klasa bazowa ma konstruktor, klasa pochodna nie ma konstruktora (rozważyć dwa przypadki: klasa bazowa ma konstruktor bez parametrów, klasa bazowa ma konstruktor z parametrami).
Przykład
W klasie może określić następujące poziomy dostępu.
Przykład: zmieńmy typ współrzędnych punktu w klasie Punkt na chronione. Jak będzie można to wykorzystać?
Zasada 1: Klasa pochodna ma dostęp tylko do składowych publicznych i chronionych klasy bazowej.
Zasada 2: W klasie pochodnej można określić sposób przekazywania odziedziczonych składowych do kolejnych klas tworzonych jako klasy pochodne klasy pochodnej.
Składnia deklaracji klasy pochodnej ma zatem postać:
Możliwe są trzy przypadki::
Publiczne i chronione składowe klasy bazowej stają się odpowiednio publicznymi i chronionymi składowymi klasy pochodnej.
Publiczne i chronione składowe klasy bazowej stają się składowymi prywatnymi klasy pochodnej. Oznacza to, że funkcje składowe klasy pochodnej mają dostęp do składowych publicznych i chronionych klasy bazowej, nie mają zaś takiego dostępu użytkownicy klasy pochodnej.
Publiczne i chronione składowe klasy bazowej stają się składowymi chronionymi klasy pochodnej.
W każdym z tych przypadków, składowe prywatne klasy bazowej pozostają składowymi prywatnymi klasy bazowej i nie są dostępne w klasie pochodnej.
Pominięcie trybu dziedziczenia jeśli klasa jest klasą właściwą oznacza tryb private, zaś jeśli jest strukturą tryb public .
Najczęściej stosowany jest tryb publiczny.
Zastosowanie trybu prywatnego:
wszystkie funkcje z klasy bazowej zostały przedefiniowane w klasie pochodnej, nie ma po co zezwalać użytkownikom klasy pochodnej na korzystanie z funkcji klasy bazowej
Zasada: obiekt klasy pochodnej może „zastąpić” obiekt klasy bazowej. Czyli wszędzie tam, gdzie oczekuje się obiektu klasy bazowej, może być użyty obiekt klasy pochodnej. Stwierdzenie odwrotne nie jest prawdziwe.
Uwaga: zasada ta obwiązuje dla dziedziczenia publicznego.
Techniczna realizacja - zachodzi niejawna konwersja:
obiektu klasy pochodnej na obiekt klasy bazowej
wskaźnika (lub referencji) do klasy pochodnej na wskaźnik (lub referencję) do klasy bazowej.
Która funkcja drukuj() (funkcja Punkt::drukuj() czy Punktkol::drukuj() ) będzie użyta w instrukcji:
Załóżmy, że zmienne klasy Punktkol są publiczne. Czy za pomocą wskaźnika wsk_a mielibyśmy teraz dostęp do koloru?
Przykład:
Co wydrukuje następujący program:
Przykład
Konstruktory nie są dziedziczone.
Dla składowych własnych klasy B zastosowany zostanie konstruktor domyślny (kopiowanie płytkie), dla części pochodzącej z klasy A - konstruktor klasy A (zdefiniowany lub w przypadku jego braku domyślny).
Zastosowany zostanie konstruktor kopiujący klasy B. Konstruktor ten jest w całości odpowiedzialny za obiekt, zarówno za własne składowe jak i za składowe odziedziczone. Konstruktor klasy A nie zostanie w tym wypadku automatycznie wywołany.
Jeśli chcemy użyć konstruktora kopiującego klasy A należy go wywołać jawnie. Składnia konstruktora kopiującego w tym przypadku będzie następująca:
Przykład:
Operator przypisania nie jest dziedziczony. Patrz jednak przypadek 1.
Dla składowych własnych klasy B zastosowany zostanie domyślny operator przypisania, dla części pochodzącej z klasy A - konstruktor klasy A (zdefiniowany lub w przypadku jego braku domyślny).
Zastosowany zostanie przeciążony operator przypisania klasy B. Operator ten jest w całości odpowiedzialny za obiekt, zarówno za własne składowe jak i za składowe odziedziczone. Operator klasy A nie zostanie w tym wypadku automatycznie wywołany.
Aby operator przypisania w klasie pochodnej działał prawidłowo, trzeba powiedzieć jawnie co należy zrobić ze składowymi z klasy bazowej.
Prawidłowe przeciążenie operatora = w klasie pochodnej Punktkol:
Wiązanie statyczne, wczesne (ang. static binding, early binding) oznacza powiązanie obiektu z wywoływanymi funkcjami w czasie kompilacji. Takie wiązanie jest stosowane do wszystkich zwykłych funkcji.
Zaleta: efektywność.
Wada: brak elastyczności.
Wiązanie dynamiczne, późne (ang. dynamic binding, late binding) oznacza powiązanie obiektu z wywoływanymi funkcjami dopiero podczas działania programu. Uzyskuje się je za pomocą funkcji wirtualnych i klas pochodnych.
Zaleta: elastyczność.
Wada: wolniejsze działanie programu.
Jeżeli funkcja ma być funkcją wirtualną, poprzedza się jej deklarację w klasie bazowej słowem kluczowym virtual.
Jeśli w czasie kompilacji napotkana zostanie instrukcja wsk->drukuj(), kompilator nie przepisze funkcji w oparciu o typ wskaźnika wsk. Wybór funkcji zostanie dokonany dopiero w oparciu o typ obiektu, na który będzie wskazywał wskaźnik podczas wykonywania programu.
Funkcja zdefiniowana jako wirtualna będzie dowiązywana dynamicznie zarówno w klasie w której została zdefiniowana, jak i we wszystkich klasach pochodnych, w których została ponownie zdefiniowana.
Ponowna definicja funkcji wirtualnej w klasie pochodnej nie jest niezbędna. Jeśli nie zostanie ponownie zdefiniowana, używana jest funkcja z klasy, z której klasa pochodna dziedziczy.
Przykład:
Przykład (niepoprawny):
Podczas wywoływania funkcji wirtualnej w stosunku do obiektu klasy pochodnej, w której ta funkcja nie została ponownie zdefiniowana, stosowana jest wersja z klasy bazowej.
Istnieją jednak klasy, w których funkcje wirtualne nie wykonują żadnego pożytecznego działania. Często funkcje takie MUSZĄ być przykryte, gdyż w przeciwnym wypadku istnienie takich klas traci sens.
Można wymusić na klasie pochodnej przykrycie wszystkich niezbędnych funkcji za pomocą zastosowania tzw. czystych funkcji wirtualnych (ang. pure virtual function).
Czysta funkcja wirtualna to funkcja, która jest zadeklarowana w klasie bazowej, ale nie jest w niej zdefiniowana.
Klasa, w której zdefiniowano co najmniej jedną czystą funkcję wirtualną, nazywa się klasą abstrakcyjną (ang. abstract class). Ma ona ważną cechę: nie można tworzyć obiektów tej klasy. Używa się jej jedynie jako klasy bazowej do tworzenia klas pochodnych.
Przykład:
class A { ... public: A(); ~A(); ... }; |
class B : public A { ... public: B(); ~B(); ... }; |
W main() tworzymy obiekt:
B obiekt;
Aby taki obiekt był utworzony, najpierw musi być utworzony obiekt klasy A (wywołanie konstruktora A), który następnie jest uzupełniany o składowe właściwe dla obiektu B (wywołanie konstruktora B).
Podczas usuwania obiektu, postępowanie jest odwrotne: najpierw jest wywoływany destruktor obiektu B, a dopiero potem destruktor obiektu A.
Taki schemat postępowania jest realizowany automatycznie przez kompilator C++.
Przekazywanie argumentów konstruktorowi klasy bazowej
#include <iostream>
class Punkt {
int x, y ;
public :
Punkt (int xx=0, int yy=0)
{ x = xx ; y =yy ; }
...
} ;
class Punktkol : public Punkt {
short kolor ;
public :
Punktkol (int, int, short) ;
...
} ;
// Punktkol ma przesłać otrzymane wartości do Punkt
Punktkol::Punktkol (int xx=0, int yy=0, short kk=1) : Punkt (xx, yy)
{ kolor = kk ; }
W main() :
Punktkol a(1,5,3) ; // wywołanie konstruktora Punkt z 1 i 5,
// następnie wywołanie konstruktora Punktkol z 1,5 i 3
Punktkol b (2,3) ; // wywołanie konstruktora Punkt z 2 i 3
// następnie wywołanie konstruktora Punktkol z 1,5 i 1
Punktkol c (12) ; // wywołanie konstruktora Punkt z 1 i 0,
// następnie wywołanie konstruktora Punktkol z 1,0 i 1
#include <iostream.h>
// klasa bazowa
class Prostokat {
protected:
double dlugosc;
double szerokosc;
double powierzchnia;
public:
Figura(double d=0, double s=0)
{ dlugosc=d; szerokosc=s;
powierzchnia=dlugosc*szerokosc; }
void DrukujPow();
};
// klasa pochodna
class Prostopadloscian : public Prostokat {
protected :
double glebokosc;
double pojemnosc;
public:
Prostopadloscian (double z=0, double x=0, double y=0) : Prostokat(x,y)
{ glebokosc = z;
pojemnosc=glebokosc*dlugosc*szerokosc; }
void DrukujPoj();
};
void Prostokat::DrukujPow(void)
{ cout << "Powierzchnia wynosi : "<<powierzchnia<<endl; }
void Prostopadloscian::DrukujPoj()
{ cout << "Pojemnosc wynosi : "<<pojemnosc<<endl; }
int main(){
int x,y,z;
cout << "Podaj dlugosc: ";
cin >> x;
cout << "Podaj szerokosc: ";
cin >> y;
cout << "Podaj glebokosc: ";
cin >> z;
Prostopadloscian a(z,x,y); // utwórz prostopadłościan a
a.DrukujPoj(); // drukuj pojmność prostopadłościana a
return 0;
}
Nadzorowanie dostępu do składowych klasy
class X {
private:
// część prywatna: nie podlega dziedziczeniu
// dostęp mają tylko funkcje składowy klasy bazowej
// i funkcje z nią zaprzyjaźnione
...
protected:
// część chroniona: dziedziczona przez klasy pochodne
// dostęp mają:
// funkcje składowe klasy bazowej i funkcje z nią zaprzyjaźnione
// funkcje klasy pochodnej i funkcje zaprzyjaźnione z klasą pochodną
// brak dostępu dla pozostałych funkcji
...
public:
// część publiczna: dziedziczona przez klasy pochodne
// dostęp mają wszystkie funkcje programu
...
};
Pytanie: Jakie są zalety składowych chronionych? Jakie niebezpieczeństwa niesie ze sobą stosowanie składowych chronionych?
// Wersja 1: współrzędne punktu są prywatne
class Punkt {
private :
int x, y ;
public :
void Punkt(int,int);
void drukuj () ;
...
} ;
void Punkt::drukuj ()
{
cout << "Moje wspolrzedne " << x << " " << y << "\n" ;
}
/////////////////////////////////////////////////////////////////
class Punktkol : public Punkt // Punktkol jest pochodną Punkt
{ short kolor ;
public :
void drukuj();
...
};
void Punktkol::drukuj ()
{
Punkt::drukuj();
cout << "i moj kolor " << kolor << "\n" ;
}
// Wersja 2: współrzędne punktu są chronione
class Punkt {
protected :
int x, y;
public :
void Punkt(int,int);
void drukuj () ;
...
} ;
void Punkt::drukuj ()
{
cout << "Moje wspolrzedne " << x << " " << y << "\n" ;
}
/////////////////////////////////////////////////////////////////
class Punktkol : public Punkt // Punktkol jest pochodną Punkt
{ short kolor ;
public :
void drukuj();
...
};
void Punktkol::drukuj ()
{
cout << "Moje wspolrzedne " << x << " " << y << "\n" ;
cout << "i moj kolor " << kolor << "\n" ;
}
Sterowanie dostępem do składowych klasy
class nazwa_klasy_pochodnej : tryb_dziedziczenia nazwa_klasy_bazowej
{
ciało klasy_pochodnej
};
class XX : public X
{ ... };
class XX : private X
{ ... };
class XX : protected X
{ ... };
Przykłady zastosowań trybu dziedziczenia
Kompatybilność klasy bazowej i klasy pochodnej
Konwersja typu pochodnego na typ bazowy
class Punkt
{ ... };
class Punktkol : public Punkt
{ ... };
Punkt a;
Punktkol b;
a=b; // obcięcie do tego, co należy do klasy Punkt
// jeśli istnieje przeciążony operator =, to zostanie użyty,
// w przeciwnym wypadku zostanie użyty operator domyślny
Konwersja wskaźników
class Punkt
{ ... };
class Punktkol : public Punkt
{ ... };
Punkt a, *wsk_a=&a;
Punktkol b, *wsk_b=&b;
wsk_a=wsk_b; // dokonywana jest konwersja
Ograniczenia
class Punkt
{
void drukuj();
...
};
class Punktkol : public Punkt
{
void drukuj();
...
};
Punkt a(1,1), *wsk_a=&a;
Punktkol b(2,2,0), *wsk_b=&b;
Co będzie jeśli wykonamy podstawienie:
wsk_a=wsk_b;
wsk_a->drukuj();
Decyzję podejmuje kompilator w momencie kompilacji. Jest to tzw. wiązanie statyczne (ang. early binding, static binding). Dla kompilatora ważny jest typ zmiennej.
#include <iostream>
class Punkt
{ protected :
int x, y ;
public :
Punkt (int xx=0, int yy=0) { x=xx ; y=yy ; }
void drukuj ()
{ cout << "Jestem zwyklym punktem \n" ;
cout << " oto moje wspolrzedne : " << x << " " << y << "\n" ;
}
} ;
class Punktkol : public Punkt
{
short kolor ;
public :
Punktkol (int xx=0, int yy=0, short kk=1) : Punkt (xx, yy)
{ kolor = kk ;
}
void drukuj ()
{ cout << "Jestem punktem kolorowym \n" ;
cout << " oto moje wspolrzedne : " << x << " " << y ;
cout << " i moj kolor : " << kolor << "\n" ;
}
} ;
main()
{ Punkt p(1,2) ; Punkt * wsk = &p ;
Punktkol pk (5,6,1) ; Punktkol * wsk_k = &pk ;
wsk->drukuj () ; wsk_k->drukuj () ;
cout << "-----------------\n" ;
wsk = wsk_k ;
wsk->drukuj () ;
}
#include <iostream>
#include <string.h>
class A {
char nazwisko[30];
public:
void wpisz_nazw(char *s) {strcpy(nazwisko,s); }
void drukuj_nazw() {cout << nazwisko << " ";}
};
class B : public A {
char telefon[20];
public:
void wpisz_tel(char *numer) {
strcpy(telefon, numer);
}
void drukuj_tel() {cout << telefon << " ";}
};
int main()
{
A *wsk_a;
A obiekt_A;
B *wsk_b;
B obiekt_B;
wsk_a=&obiekt_A;
wsk_a->wpisz_nazw("Adam Kowalski");
wsk_a=&obiekt_B;
wsk_a->wpisz_nazw("Piotr Nowak");
// sprawdzenie, czy poprawnie wpisano nazwiska
obiekt_A.drukuj_nazw();
obiekt_B.drukuj_nazw();
cout << endl;
wsk_b=&obiekt_B;
wsk_b->wpisz_tel("612-23-56");
wsk_a->drukuj_nazw();
wsk_b->drukuj_tel();
return 0;
}
Konstruktor kopiujący i dziedziczenie
Przypadek 1: klasa pochodna nie ma konstruktora kopiującego.
Przypadek 2: klasa pochodna ma konstruktor kopiujący.
B (B & x) : A(x)
{
// tutaj kopiowanie tylko części obiektu x z klasy B
...
}
#include <iostream>
class Punkt
{
int x, y ;
public :
Punkt (int xx=0, int yy=0) // zwykły konstruktor
{ x = xx ; y = yy ;
cout << "++ Konstruktor Punkt " << x << " " << y << "\n" ;
}
Punkt (Punkt & p) // konstruktor kopiujący
{ x = p.x ; y = p.y ;
cout << " Konstruktor kopiujacy Punkt " << x << " " << y << "\n" ;
}
} ;
class Punktkol : public Punkt
{
char kolor ;
public :
// zwykły konstruktor
Punktkol (int xx=0, int yy=0, int kk=1) : Punkt (xx, yy)
{ kolor = kk ;
cout << "++ Konstruktor Punktkol " << int(kolor) << "\n" ;
}
// konstruktor kopiujący
Punktkol (Punktkol & p) : Punkt (p)
{ kolor = p.kolor ;
cout << " Konstruktor kopiujacy Punktkol " << int(kolor) << "\n" ;
}
};
Jakie konstruktory i w jakiej kolejności zostaną użyte w następującym programie?
void fun (Punktkol pc)
{
cout << "*** Jestem w funkcji fun ***\n" ;
}
main()
{
void fun (Punktkol) ;
Punktkol a (2,3,4) ;
fun (a) ;
}
Operator przypisania = i dziedziczenie
Przypadek 1: klasa pochodna nie ma przeciążonego operatora =
Przypadek 2: klasa pochodna ma przeciążony operator =
Przykład (działanie niepoprawne): obydwie klasy mają przeciążone operatory =, ale w funkcji operator= klasy pochodnej nie uwzględniono składowych odziedziczonych z klasy bazowej
class Punkt
{
protected :
int x, y ;
public :
Punkt (int xx=0, int yy=0)
{ x=xx ; y=yy ;}
Punkt & operator = (Punkt & a) // przeciążony operator =
{ x = a.x ; y = a.y ;
return * this ;
}
} ;
class Punktkol : public Punkt
{
protected :
int kolor ;
public :
Punktkol (int xx=0, int yy=0, int kk=1) : Punkt (xx, yy) { kolor=kk ; }
Punktkol & operator = (Punktkol & b) // przeciążony operator =
{ kolor = b.kolor ;
return * this ;
}
void drukuj ()
{ cout << "Punktkol : " << x << " " << y << " " << kolor << endl ;
}
} ;
Co wydrukuj następujący program i dlaczego?
#include <iostream>
main()
{ Punktkol p(1,3,0) , q(2,4,1) ;
cout << "p = " ; p.drukuj () ;
cout << "q przed = " ; q.drukuj () ;
q = p ;
cout << "q po = " ; q.drukuj () ;
}
Punktkol & operator = (Punktkol & b)
{
Punkt * wsk1, * wsk2 ;
wsk1 = this ; // konswersja wskaźnika do klasy Punktkol
// na wskaźnik do klasy Punkt
wsk2 = &b ;
* wsk1 = * wsk2; // przypisanie składowych odziedziczonych z klasy Punkt
kolor = b.kolor ; // przypisanie składowych własnych klasy Punktkol
return * this ;
}
Funkcje wirtualne
class Punkt
{
...
// wybór wersji funkcji drukuj() będzie dokonany
// dopiero w momencie użycia
virtual void drukuj ();
...
} ;
Przykład:
class Punkt
{
protected :
int x, y ;
public :
Punkt (int xx=0, int yy=0) { x=xx ; y=yy ; }
// funkcja wirtualna
virtual void drukuj ()
{ cout << "Jestem punktem \n" ;
cout << " oto moje współrzędne : " << x << " " << y << endl ;
}
} ;
class Punktkol : public Punkt
{
short kolor ;
public :
Punktkol (int xx=0, int yy=0, short kk=1) : Punkt (xx, yy)
{ kolor = kk ; }
void drukuj ()
{ cout << "Jestem punktem kolorowym \n" ;
cout << " oto moje współrzędne : " << x << " " << y ;
cout << " i mój kolor : " << kolor << "\n" ;
}
} ;
W main() :
Punkt p(1,3) ; Punkt * wsk = &p ;
Punktkol pk (8,6,2) ; Punktkol * wsk_k = &pk ;
wsk = wsk_k ;
wsk->drukuj (); // będzie użyta funkcja Punktkol::drukuj()
wsk_k->drukuj (); // będzie użyta funkcja Punktkol::drukuj()
#include <iostream>
class Figura {
protected:
double x,y;
public:
void wpiszWymiary (double i, double j=0)
{ x=i; y=j; }
virtual void obliczPow()
{ cout << "Nie potrafie obliczyc powierzchni\n"; }
};
class Trojkat : public Figura {
public:
void obliczPow()
{ cout << "Trojkat o wysokosci " << x << " i podstawie " << y;
cout << " ma pole powierzchni " << 0.5*x*y << endl;
}
};
class Prostokat : public Figura {
public:
void obliczPow()
{ cout << "Prostokat o wymiarach " << x << " na " << y ;
cout << " ma pole powierzchni " << x*y << endl;
}
};
class Kolo : public Figura {
public:
void obliczPow()
{ cout << "Kolo o promieniu " << x ;
cout << " ma pole powierzchni " << 3.14*x*x << endl;
}
};
int main()
{
Figura *fig;
Trojkat t;
Prostokat p;
Kolo k;
fig=&t;
fig->wpiszWymiary(5.,2.5); fig->obliczPow();
fig=&p;
fig->wpiszWymiary(5.,2.5); fig->obliczPow();
fig=&k;
fig->wpiszWymiary(5.); fig->obliczPow();
return 0;
}
class Punkt
{
int x, y ;
public :
Punkt (int xx=0, int yy=0) { x=xx ; y=yy ; }
void nazwa ()
{ cout << "Jestem zwykłym punktem \n" ; }
void drukuj ()
{ nazwa () ;
cout << "Oto moje wspolrzedne : " << x << " " << y << "\n" ;
}
} ;
class Punktkol : public Punkt
{
short kolor ;
public :
Punktkol (int xx=0, int yy=0, int kk=1 ) : Punkt (xx, yy)
{ kolor = kk ; }
void nazwa ()
{ cout << "Jestem punktem kolorowym a moj kolor to : "
<< kolor << "\n" ; }
} ;
Co będzie wydrukowane przez poniższy program?
#include <iostream>
main()
{ Punkt p(2,3) ; Punktkol pk(4,6,9) ;
p.drukuj () ; pk.drukuj () ;
cout << "---------------\n" ;
Punkt * wsk = &p ; Punktkol * wsk_k = &pk ;
wsk->drukuj () ; wsk_k->drukuj () ;
cout << "---------------\n" ;
wsk = wsk_k ;
wsk->drukuj () ;
wsk_k->drukuj () ;
}
Co trzeba zmienić, aby program działał poprawnie?
Czyste funkcje wirtualne
#include <iostream>
class Figura {
protected:
double x,y;
public:
void wpiszWymiary (double i, double j=0)
{ x=i; y=j; }
virtual void obliczPow()= 0;
};
class Trojkat : public Figura {
public:
void obliczPow()
{
cout << "Trojkat o wysokosci " << x << " i podstawie " << y;
cout << " ma pole powierzchni " << 0.5*x*y << endl;
}
};
class Prostokat : public Figura {
public:
// w tej klasie nie zdefiniowano funkcji obliczPow
...
};
int main()
{
Figura *fig;
Trojkat t;
Prostokat p;
fig=&t;
fig->wpiszWymiary(5.,2.5);
fig->obliczPow();
fig=&p;
fig->wpiszWymiary(5.,2.5);
fig->obliczPow();
return 0;
}
1
12
Nazwa klasy podstawowej
Tryb dziedziczenia
Rozszerzona wersja konstruktora klasy pochodnej, przekazującego argumenty konstruktorowi klasy bazowej
Punktkol::inicjalizuj()
Wywołanie konstruktora kopiującego A,
dokonana zostanie konwersja obiektu x klasy B na obiekt x klasy A
wsk_a może wskazywać na obiekt klasy pochodnej B i pozwala na dostęp do tych jej składowych, które są zdefiniowane w klasie bazowej.
Nie można jednak wykorzystać wskaźnika do klasy B do uzyskania dostępu do składowych występujących tylko w klasie pochodnej (bez rzutowania).
Program się nie skompiluje
private:
protected:
public:
Składowe własne klasy pochodnej
Klasa pochodna ma dostęp do składowych publicznych i do składowych chronionych
Klasa bazowa
Klasa pochodna
Składowe odziedziczone
Klient nie ma dostępu
Klient nie ma dostępu
Klient ma dostęp
1
1
2
2
0
wsk_a
wsk_b
a.drukuj();
wsk_a->drukuj();
b.drukuj();
wsk_b->drukuj();
wsk_b
wsk_a
0
2
2
1
1
Obiekt klasy Punkt
Punkt::drukuj()
0
2
2
4
2
Tablica funkcji wirtualnych
Funkcje
Punkt::inicjalizuj()
Funkcje
Tablica funkcji wirtualnych
Punktkol::drukuj()
Obiekt klasy Punktkol
*wsk_a nie ma
koloru
Wyszukiwarka
Podobne podstrony:
Programowanie obiektowe, wyklad6-czesc1, Dziedziczenie wielobazowe
Programowanie Obiektowe Cz2, Dziedziczenie proste
11 10 2011 programowanie obiektowe wykład
Programowanie obiektowe, wyklad8, Kolekcje
Programowanie obiektowe wykład
Programowanie Obiektowe wykłady
wyklad5.cpp, JAVA jest językiem programowania obiektowego
15 Enkapsulacja, dziedzicznie i polimorfizm w programowaniu obiektowym
Wyklad 3-4, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Wyklad 5-6, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Cwiczenie 1, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Wykład z programowania obiektowego, Informatyka, Semsetr 2, Programowanie obiektowe
Cwiczenie 4 Rozwiazania, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Dziedziczenie 3 PRZYKLADY, Programowanie obiektowe
Wyklad 9-10, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Wyklad 13-14, uwm wnt Mecha, SM 5, Programowanie obiektowe i strukturalne, Wykłady
Programowanie obiektowe(ćw) 1
więcej podobnych podstron