Instrukcje do ćwiczeń z Programowania Obiektowego w C++.
Ćwiczenie nr 1. : Klasy.
UWAGA!!! Odpowiedzi na pytania/polecenia zaznaczone na szaro muszą znaleźć się
w sprawozdaniu z ćwiczenia.
Wprowadzenie
Tworzenie programów zorientowanych obiektowo w C++ to tworzenie i używanie klas (ang. classes). Klasa definiuje nowy typ. Jednak w odróżnieniu od typów poznanych do tej pory, definicja klasy łączy w sobie defnicję nowych obiektów (danych) oraz operacji (metod), które mogą być wykonywane na tych obiektach. Ogólna postać definicji klasy wygląda następująco:
class nazwa_klasy {
instrukcje_definiujace_klase
};
Pierwsza linia to deklaracja klasy; po niej następuje definicja klasy ujęta w nawiasy klamrowe,
a wszystko zakończone średnikiem. Instrukcje definujące klasę obejmują deklaracje zmiennych (danych) oraz funkcji (metod).
Cel ćwiczenia
W tym ćwiczeniu stworzymy dwie proste klasy, Punkt i Prosta, reprezentujące obiekty geometryczne (odpowiednio: punkt i prostą) na płaszczyźnie. Następnie wykorzystamy te dwie klasy w krótkim programie rozwiązującym proste problemy geometryczne.
Niezbędne wiadomości z geometrii
Będą nam potrzebne pewne podstawowe wiadomości z geometrii:
Definicja punktu na płaszczyźnie.
Punkt na płaszczyźnie (oznaczmy ten punkt przez P) reprezentujemy przy pomocy pary współrzędnych (czyli liczb rzeczywistych x i y) ujętych w nawias okrągły:
P(x,y),
a zatem, żeby zdefniować punkt wystarczą dwie liczby: x i y.
Definicja prostej na płaszczyźnie.
Prostą na płaszczyźnie reprezentujemy przy pomocy równania:
ax + by + c = 0,
a zatem, żeby zdefniować prostą wystarczą trzy liczby: a, b i c.
Definicja prostej na płaszczyźnie przy pomocy dwóch punktów.
Prostą można też zdefiniować nieco inaczej: otóż przez dwa punkty na płaszczyźnie przechodzi dokładnie jedna prosta, a zatem żeby jednozacznie zdefniować prostą wystarczy podać dwa punkty przez które ta prosta przechodzi.
Załóżmy, że chcemy aby nasza prosta przechodziła przez punkty P1(x1,y1) i P2(x2,y2).
Wówczas współczynniki prostej, a, b i c (patrz punkt 2.) znajdujemy przy pomocy współrzędnych punktów P1 i P2 według następującego przepisu (algorytmu):
Jeżeli (x1 = x2), to
a = 1
b = 0
c = - x1
w przeciwnym razie
a = y2 - y1
b = x1 - x2
c = y1 ∙ x2 - y2 ∙ x1
Odległość między dwoma punktami.
Mając dwa punkty na płaszczyźnie P1(x1,y1) i P2(x2,y2) możemy obliczyć odległość między nimi. Przepis (algorytm) jest następujący:
odległość_miedzy_punktami = sqrt( (x1- x2)2 + (y1- y2)2 ),
gdzie sqrt oznacza, że bierzemy pierwiastek kwadratowy z wyrażenia w nawiasie.
Odległość między punktem a prostą.
Mając punkt P1(x1,y1) oraz prostą zdefiniowaną równianiem ax + by + c = 0 możemy obliczyć odległość między tymi dwoma obiektami. Przepis (algorytm) jest następujący:
odległość_prosta_punkt = abs (a ∙ x1 + b ∙ y1 + c) / sqrt (a2 + b2),
gdzie abs oznacza, że bierzemy wartość bezwzględną z wyrażenia w nawiasie, natomiast sqrt oznacza, że bierzemy pierwiastek kwadratowy z wyrażenia w nawiasie.
Punkt przecięcia dwóch prostych.
Dwie proste które nie są równoległe, przecinają się dokładnie w jednym punkcie. Jeśli proste są równoległe, to przyjmujemy, że ich punkt przecięcia znajduje się w nieskończoności (∞).
Załóżmy, że znamy dwie proste o równaniach a1x + b1y + c1 = 0 oraz a2x + b2y + c2 = 0. Chcemy znaleźć współrzędne punktu P0(x0,y0), który jest punktem przecięcia tych prostych. Współrzędne te obliczymy przy pomocy znanych współczynników a1, b1, c1, a2, b2, c2. Przepis (algorytm) jest następujący:
Oblicz liczbę pomocniczą d: d = a1 ∙ b2 - a2 ∙ b1
Oblicz kwadrat sinusa kąta między liniami: sin_kw = d2 / ((a12 + b12) ∙ (a22 + b22))
Jeżeli (sin_kw = 0) to (czyli proste są równoległe, więc punkt przecięcia jest w nieskończoności)
x0 = ∞
y0 = ∞
w przeciwnym razie
x0 = (b1 ∙ c2 - b2 ∙ c1) / d
y0 = (c1 ∙ a2 - c2 ∙ a1) / d
Przygotwanie programu głównego
Zanim stworzymy klasy Punkt i Prosta musimy przygotować środowisko (czyli program główny), w którym te dwie klasy będą pracować.
W tym celu przygotujmy krótki program w C++ (nazwijmy ten program umownie Geometria), który będzie komunikował się z użytkownikiem według następującego schematu:
wypisze na ekranie napis: "Podaj wspolrzedne (x,y) dla czterech dowolnych punktow"
wczytaj współrzędne czterech punktów i zapamiętaj je w zmiennych x1,y1, x2,y2, x3,y3, x4,y4
UWAGA!!! Powyższe zmienne mają być typu Liczba. Typ Liczba zdefiniujemy sami korzystając z deklaracji:
typedef float Liczba;
(umożliwi nam to łatwą zmianę typu naszych zmiennych w razie potrzeby).
UWAGA!!! Deklaracja typedef float Liczba; powinna być umieszczona PRZED deklaracją funkcji main() !!!!
Po przygotowaniu programu Geometria proszę sprawdzić, czy działa on poprawnie
(a więc czy poprawnie wczytuje i zapamiętuje współrzędne podawane przez użytkownika)!
Teraz jesteśmy gotowi do przygotowania klas Punkt i Prosta, które następnie wykorzystamy
w programie Geometria.
Projektowanie klasy Punkt
Chcemy aby klasa Punkt "potrafiła" wykonywać następujące operacje na obiektach typu Punkt:
wykreować punkt na płaszczyźnie na podstawie pary współrzędnych (x,y) (zgodnie z opisem w 1.);
obliczyć odległość do innego punktu (zgodnie z opisem w 4.);
obliczyć odległość do prostej (zgodnie z opisem w 5.);
wypisać współrzędne punktu;
Defninicja klasy Punkt
Zdefniujemy teraz klasę Punkt zgodnie z powyższym projektem. Będzie to na razie "atrapa" klasy Punkt, tzn. podamy deklaracje metod, ale jeszcze przez chwilę nie będziemy definiować co konkretnie te metody mają robić.
Oto definicja klasy Punkt:
// Definicja klasy Punkt
class Prosta;
class Punkt {
public:
Punkt(); // utworz obiekt niezainicjowany
Punkt(Liczba x, Liczba y); // utworz obiekt ze wspolrzednych (x,y)
Liczba odleglosc(Punkt q); // odleglosc do innego punktu q
Liczba odleglosc(Prosta f); // odleglosc do prostej f
Liczba x(); // wypisz wspolrzedna x
Liczba y(); // wypisz wspolrzedna y
private:
Liczba wsp_x; // wspolrzedna x
Liczba wsp_y; // wspolrzedna y
};
Skorzystaliśmy z typu Liczba zdefiniowanego w programie Geometria. W pierwszej linii zadeklarowaliśmy klasę Prosta nie podając definicji tej klasy (zrobimy to później). To jednak wystarczy, aby móc używać słowa Prosta jako typu, zanim zdefiniujemy czym Prosta tak naprawdę jest. Jest to przykład tzw. "deklaracji wyprzedzającej" (ang. forward declaration); jest to analogiczne do prototypu funkcji.
Definicja klasy Punkt (czyli to co znajduje się pomiędzy nawiasami klamrowymi) zawiera sześć funkcji (metod), które są odzwierciedleniem naszego projektu klasy Punkt. Metody zadeklarowane po słowie public są dostępne na zewnątrz klasy. Słowo private oznacza rzecz przeciwną—dane zadeklarowane po słowie private nie są dostępne na zewnątrz klasy. Dane wsp_x i wsp_y będą przechowywać współrzędne naszych punktów.
Wklejmy powyższą definicję klasy Punkt do pliku punkt.h (NIE do pliku z programem Geometria).
Wstawiamy klasę Punkt do programu Geometria
Odwołajmy się do definicji klasy Punkt w programie Geometria. W tym celu użyjmy instrukcji #include"punkt.h" .
Musi się ona znaleźć pomiędzy linią typedef float Liczba a deklaracją funkcji main() :
typedef float Liczba;
#include"punkt.h"
int main () { //...
Nasz program Geometria powinien kompilować się prawidłowo. Sprawdźmy, czy tak jest !!!
Eksperymentujemy z programem Geometria
Zamieńmy na chwilę miejscami linie typedef float Liczba i #include"punkt.h" . Skompilujmy program. Co się stało? Dlaczego?
Wróćmy teraz do pierwornej kolejności linii typedef float Liczba i #include"punkt.h" . Sprawdźmy, czy program kompiluje się prawidłowo!
Zaprojektujemy teraz i zdefinujemy klasę Prosta.
Projektowanie klasy Prosta
Chcemy aby klasa Prosta "potrafiła" wykonywać następujące operacje na obiektach typu Prosta:
wykreować prostą na płaszczyźnie na podstawie pary punktów P1(x1,y1) i P2(x2,y2) (zgodnie z opisem w 3.);
obliczyć odległość do punktu (zgodnie z opisem w 5.);
obliczyć punkt przecięcia z inną prostą (zgodnie z opisem w 6.);
Defninicja klasy Prosta
Zdefniujemy klasę Prosta zgodnie z powyższym projektem. Będzie to znowu "atrapa" klasy Prosta, tzn. podamy deklaracje metod, ale jeszcze przez chwilę nie będziemy definiować co konkretnie te metody mają robić.
Oto definicja klasy Prosta:
// Definicja klasy Prosta
class Prosta {
public:
Prosta(Punkt p1, Punkt p2); // utworz linie przy pomocy dwoch punktow
Punkt przeciecie(Prosta f); // znajdz punkt przeciecia z prosta f
Liczba odleglosc(Punkt p); // znajdz odleglosc do punktu p
private:
// ax + by + c = 0
Liczba a;
Liczba b;
Liczba c;
};
Zauważmy, że korzystamy tu z uprzednio zdefniowanej klasy Punkt oraz z typu Liczba. Dane a, b i c przechowują współczynniki prostej.
Wklejmy powyższą definicję klasy Prosta do pliku prosta.h (NIE do pliku z programem Geometria).
Wstawiamy klasę Prosta do programu Geometria
Odwołajmy się do definicji klasy Prosta w programie Geometria. W tym celu użyjmy instrukcji #include"prosta.h" .
Musi się ona znaleźć PO linii #include"punkt.h":
#include"punkt.h"
#include"prosta.h"
(ponieważ klasa prosta korzysta z klasy punkt).
Nasz program Geometria powinien kompilować się prawidłowo. Sprawdźmy, czy tak jest !!!
Ponownie eksperymentujemy z programem Geometria
Zamieńmy na chwilę miejscami linie #include"punkt.h" i #include"prosta.h" . Skompilujmy program. Co się stało? Dlaczego?
Wróćmy teraz do pierwornej kolejności linii #include"punkt.h" i #include"prosta.h" . Sprawdźmy, czy program kompiluje się prawidłowo!
Mamy zatem "atrapy" klas Punkt i Prosta. Aby te klasy cokolwiek robiły musimy teraz zdefniować funkcje należące do tych klas.
Definicja konstruktora Punkt(Liczba x, Liczba y)z klasy Punkt
Spójrzmy na plik punkt.h. Są tam dwie funkcje: Punkt()
i Punkt(Liczba x, Liczba y). Różnią się one od pozostałych funkcji w klasie Punkt tym, że:
nazywają się tak samo jak klasa;
w ich deklaracji nie ma specyfikacji typu.
Te dwie cechy wyróżniają tzw. konstruktory. Konstruktory służą do tworzenia obiektów danej klasy, np. deklaracja:
Punkt jakis_punkt(-3,17);
wywołuje konstruktor Punkt(Liczba x, Liczba y). W wyniku działania tego konstruktora tworzony jest obiekt typu Punkt (mający właściwości klasy punkt). Liczby -3 i 17 zostają przypisane odpowiednio do zmiennych wsp_x i wsp_y klasy Punkt.
Zdefiniujemy teraz w jaki konkretnie sposób to przypisanie ma się odbywać, a zatem zdefiniujemy konstruktor Punkt(Liczba x, Liczba y):
Punkt::Punkt(Liczba x, Liczba y) {
wsp_x = x;
wsp_y = y;
}
Napis Punkt::Punkt mówi, że Punkt jest funkcją należącą do klasy Punkt. (Lewy argument operatora zasięgu :: jest nazwą klasy a prawy nazwą funkcji należącej do tej klasy).
Funkcja Punkt(Liczba x, Liczba y)należy do klasy Punkt i w związku z tym ma dostęp do zmiennych wsp_x i wsp_y mimo, że zostały one zadeklarowane w klasie Punkt jako private.
Definicja konstruktora Punkt()z klasy Punkt
W defnicji klasy Punkt mamy też drugi konstruktor: Punkt(). Zdefiniujemy go następująco:
Punkt::Punkt() {
}
Będzie on więc służył do deklarowania obiektów typu punkt, które nie będą zainicjowane.
Wklejmy definicje konstruktorów do pliku punkt.h (umieśćmy je po defnicji klasy). Sprawdźmy czy program się kompiluje!
Definicja funkcji x()i y()z klasy Punkt
Funkcja x()klasy Punkt ma zwracać współrzędną x punktu. Jej definicja jest więc bardzo prosta:
Liczba Punkt::x() { return wsp_x; }
Zauważmy, że funkcja x()nie jest konstruktorem, dlatego w jej definicji musi znajdować się deklaracja zwracanego typu (w tym przypadku jest to typ Liczba).
Wklej definicję funkcji x()do pliku punkt.h.
Analogicznie do funkcji x()SAMODZIELNIE zdefinuj funkcję y()w pliku punkt.h.
Sprawdź, czy program się kompiluje!
Wykorzystujemy nowo zdefniowane funkcje z klasy Punkt w programie Geometria
Program Geometria potrafi wczytywać współrzędne czterech punktów. Wykorzystamy wczytane współrzędne x1,y1 do utworzenia obiektu p1 typu Punkt przy użyciu konstruktora Punkt(Liczba x, Liczba y) . W tym celu w programie Geometria umieszczamy instrukcję:
// deklaracja punktu p1
Punkt p1(x1,y1);
W ten sposób został wywołany konstruktor Punkt(Liczba x, Liczba y), który utworzył nowy obiekt typu Punkt i przypisał zmiennym wsp_x i wsp_y wartości x1 i y1.
Następnie przy pomocy funkcji x()i y()wypiszemy na ekranie współrzędne punktu p1:
// wypisz na ekranie wspolrzedne punktu p1
cout << "wspolrzedne punktu p1 to (" << p1.x() << "," << p1.y() << ")" << endl;
Napis p1.x()oznacza wywołanie funkcji x()dla obiektu p1. A zatem do funkcji x()zostają przekazane konkretne wartości wsp_x i wsp_y związane z obiektem p1.
Skompilujmy teraz program i wykonajmy go. Wprowadźmy z ekranu współrzędne punktów i sprawdźmy, czy program prawidłowo wypisze te współrzędne.
Powtórz podobne instrukcje dla punktów p2, p3 i p4.
Definicja funkcji Liczba odleglosc(Punkt q)z klasy Punkt
Funkcja Liczba odleglosc(Punkt q)z klasy Punkt ma zwracać liczbę (typu Liczba) równą odległości punktu danego od punktu q. Zdefiniujemy ją zatem zgodnie z 4.:
Liczba Punkt::odleglosc(Punkt q) {
Liczba dx = wsp_x - q.wsp_x;
Liczba dy = wsp_y - q.wsp_y;
return sqrt(dx*dx+dy*dy);
}
Przyjrzyjmy się przykładowemu wywołaniu funkcji odleglosc :
p1.odleglosc(p2);
Wywołanie to zwróci odległość między punktem p1 a punktem p2. Zmienne wsp_x i wsp_y będą odnosić się do punktu p1 natomiast wyrażenia q.wsp_x i q.wsp_y pozwolą "dobrać się" do współrzędnych punktu p2.
Wklej definicję funkcji odleglosc(Punkt q)do pliku punkt.h.
UWAGA!!! W definicji funkcji odleglosc(Punkt q) występuje funkcja sqrt. W związku z tym, aby program się skompilował należy dodać w programie Geometria plik nagłówkowy math.h
Sprawdź, czy program się kompiluje!
Wykorzystujemy funkcję odległość z klasy Punkt w programie Geometria
Dodajmy w programie Geometria następujące linie, które wypiszą odległości między róznymi parami punktów:
// wypisz odleglosci
cout << "odl. miedzy punktami p1 i p2 wynosi: " << p1.odleglosc(p2) << endl;
cout << "odl. miedzy punktami p2 i p4 wynosi: " << p2.odleglosc(p4) << endl;
cout << "odl. miedzy punktami p4 i p2 wynosi: " << p4.odleglosc(p2) << endl;
cout << "odl. miedzy punktami p3 i p3 wynosi: " << p3.odleglosc(p3) << endl;
Skompiluj program i przetestuj go dla następujących punktów: (1,8) (4,7) (16,-1) (5,3)
Jakie odległości otrzymałeś?
Definicja konstruktora Prosta(Punkt p1, Punkt p2) oraz funkcji Liczba odleglosc(Punkt p) z klasy Prosta
Funkcje te definujemy zgodnie z 3. i 5. :
Prosta::Prosta(Punkt p1, Punkt p2) {
// wyznacza prosta biegnaca przez punkty p1 i p2
if (p1.x() == p2.x()) {
a = 1;
b = 0;
c = -p1.x();
}
else {
a = p2.y() - p1.y();
b = p1.x() - p2.x();
c = p1.y()*p2.x() - p2.y()*p1.x();
}
}
Liczba Prosta::odleglosc(Punkt p) {
// zwraca dystans od punktu p do linii
return abs( a * p.x() + b * p.y() + c) / sqrt(a*a + b*b);
}
Wklejmy te dwie definicje do pliku prosta.h i sprawdźmy, czy program się kompiluje.
Wykorzystanie konstruktora Prosta(Punkt p1, Punkt p2) oraz funkcji Liczba odleglosc(Punkt p) w programie Geometria
Zadeklarujmy teraz dwie proste f1 i f2 biegnące odpowiednio przez punkty p1,p2 oraz p3,p4, wykorzystując konstruktor Prosta(Punkt p1, Punkt p2):
// deklaracja prostych
Prosta f1(p1,p2);
Prosta f2(p3,p4);
Następnie obliczmy (i wypiszmy) odległości między prostymi a punktami wykorzystując funkcje Liczba Prosta::odleglosc(Punkt p):
// wypisz odleglosci
cout << "odl. miedzy punktem p1 a prosta f1 wynosi: " << f1.odleglosc(p1) << endl;
cout << "odl. miedzy punktem p1 a prosta f2 wynosi: " << f2.odleglosc(p1) << endl;
cout << "odl. miedzy punktem p4 a prosta f2 wynosi: " << f2.odleglosc(p4) << endl;
cout << "odl. miedzy punktem p4 a prosta f1 wynosi: " << f1.odleglosc(p4) << endl;
Skompiluj program i przetestuj go dla następujących punktów: (1,8) (4,7) (16,-1) (5,3)
Jakie odległości otrzymałeś?
Definicja funkcji Liczba odleglosc(Prosta f) z klasy Punkt
Do tej pory nie zdefinowaliśmy funkcji Liczba odleglosc(Prosta f) z klasy Punkt.
Funkcja ta ma obliczać odległość między punktem a prostą f. Zdefiniowaliśmy już jednak w klasie Prosta podobną funkcję: Liczba odleglosc(Punkt p); wykorzystamy ją do definicji funkcji Liczba odleglosc(Prosta f) z klasy Punkt:
Liczba Punkt::odleglosc(Prosta f) {return f.odleglosc(*this);}
Zauważmy, że działanie tak zdefiniowanej funkcji odleglosc(Prosta f) z klasy Punkt polega na wywołaniu uprzednio zdefniowanej funkcji odleglosc(Punkt p) dla prostej f—to właśnie oznacza napis f.odleglosc(*this).
Zmienna lokalna this jest wskaźnikiem (w tym wypadku typu Punkt*), który wskazuje na zmienną użytą do wywołania funkcji. A zatem przy wywołaniu:
p1.odleglosc(f1);
wskaźnik this wskazuje na p1.
Wklej definicję funkcji odleglosc(Prosta f)do pliku punkt.h.
Sprawdź, czy program się kompiluje!
Następnie wykorzystaj funkcję odleglosc(Prosta f)do wypisania na ekranie odległości między prostymi i punktami.
UWAGA!!! W sprawozdaniu zamieść kompletne kody źródłowe dla programu Geometria oraz dla plików nagłówkowych punkt.h i prosta.h