Programowanie obiektowe C++

Programowanie obiektowe C++ Programowanie zorientowane obiektowo Wykład 1 Witold Dyrka witold.dyrka@pwr.wroc.pl 8/10/2012

Prawa autorskie itp. Wiele slajdów do tego wykładu powstało w oparciu o: slajdy Bjarne Stroustrupa do kursu Foundations of Engineering II (C++) prowadzonego w Texas A&M University http://www.stroustrup.com/programming przykładowe programy Jerzego Grębosza do książki Symfonia C++ Standard http://www.ifj.edu.pl/~grebosz/symfonia_c++_std_p.html Dziękuję dr inż. lek. med. Marcinowi Masalskiemu za udostępnienie materiałów do wykładu w roku ak. 2010/11

Program wykładów 1. Wprowadzenie. Obsługa błędów. Klasy (8/10) 2. Abstrakcja i enkapsulacja: klasy i struktury. (15/10) 3. Polimorfizm: przeładowanie funkcji i operatorów. Konwersje (22/10) 4. Zarządzanie pamięcią: konstruktory, destruktory, pryzpisanie (29/10) 5. Dziedziczenie. Polimorfizm dynamiczny 6. Programowanie uogólnione: szablony (5/11) (12/11)

Materiały Literatura Bjarne Stroustrup. Programowanie: Teoria i praktyka z wykorzystaniem C++. Helion (2010) Jerzy Grębosz. Symfonia C++ standard. Edition 2000 (2008) Dowolny podręcznik programowania zorientowanego obiektowo w języku C++ w standardzie ISO 98 Środowisko programistyczne Microsoft Visual C++ (rekomendowane) Dowolne środowisko korzystające z GCC

Warunki zaliczenia Kolokwium zaliczeniowe 19/11/2012 w terminie wykładu jedno kolokwium poprawkowe w tyg. 26-30/11/2012 zaliczenie od >50% Uwaga! jeśli ktoś ma braki z programowania zapraszam na wykład pt. Języki programowania w pt o 13.15 do sali 322/A-1

Zasady Nie toleruję plagiatów Nie toleruję ściągania dot. programów na laboratorium dot. kolokwium i sprawdzianów na laboratorium Zachęcam do korzystania z konsultacji ze mną: PN 10-12, ŚR 11.30-12.30, PT 16-17 pok. 118/D-1 z innymi Prowadzącymi pomiędzy sobą

Plan na dziś Błędy Źródła i rodzaje Mechanizm wyjątków Odrobaczanie Klasy

Błędy w programie Podstawowym celem programisty jest poprawność kodu uświadomiłem sobie, że od teraz dużą część mojego życia spędzę szukając i poprawiając moje własne błędy. Maurice Wilkes Przypuszczam, że unikanie, znajdowanie i poprawianie błędów stanowi 95% lub więcej wysiłku w poważnym tworzeniu oprogramowania. Bjarne Stroustrup

Błędy w programie Źródła błędów Rodzaje błędów Sprawdzanie argumentów funkcji Raportowanie błędów Wykrywanie błędów Wyjątki Debugowanie (odrobaczanie) Testowanie

Źródła błędów Słaba specyfikacja (80% dużych projektów wysypuje się przez złą specyfikację) Niekompletny program Nieoczekiwane argumenty funkcji (np. funkcja sqrt() nie przyjmie wartości -1) Niespodziewane dane wejściowe (np. uszkodzony plik z danymi) Niespodziewany stan Błędy logiczne

Rodzaje błędów Błędy kompilacji błędy typów błędy składni Błędy konsolidacji Błędy czasu wykonania (ang. run-time) wykryte przez system ( program się wysypał ) wykryte przez biblioteki (wyjątki) wykryte przez kod użytkownika Błędy logiczne wykryte przez programistę/testera

Oczekiwania Każdy program 1)Powinien wytworzyć pożądany wynik dla każdego poprawnego wejścia 2)Powinien zwrócić sensowny komunikat o błędzie dla niepoprawnych danych wejściowych Twój program 3)Nie musi przejmować się błędami sprzętu 4)Nie musi przejmować się błędami systemu 5)Może zakończyć działanie po znalezieniu błędu

Błędy argumentów funkcji Kompilator sprawdza liczbę i typy argumentów funkcji: int pole(int wysokosc, int szerokosc) { return wysokosc*szerokosc; } int x1 = pole(7); // błąd kompilacji: zła liczba argumentów int x2 = pole("siedem", 2); // błąd kompilacji: argument 1 ma zły typ int x3 = pole(7, 10); // ok int x5 = pole(7.5, 10); // działa, ale: 7.5 zostanie obcięte do 7; // większość kompilatorów zgłosi ostrzeżenie int x = pole(10, -7); // typy się zgadzają, ale wartość -7 nie ma sensu!!!

Obsługa błędów int a = 10; int b = -7; int x = pole(a, b); // typy się zgadzają, ale wartość -7 nie ma sensu!!! Tym błędem musi zająć się programista Dwie strategie sprawdzania poprawności argumentów sprawdza wywołujący funkcję + wie jak obsłużyć błąd - musi znać specyfikację funkcji, dłuższy i nieczytelny kod sprawdza funkcja wywoływana + prostszy, bardziej elegancki kod - nie wie co zrobić z błędem Pomysł: funkcja zwraca informacje o błędzie, a wywołujący decyduje co z tym zrobić

Raportowanie błedów (1) Zwracanie wartości błędu int pole(int wysokosc, int szerokosc) // zwraca -1 jeśli błędne dane { if(wysokosc <0 szerokosc < 0) return -1; return wysokosc*szerokosc; } Wywołujący musi (może?) sprawdzić wynik i podjąć działanie int z = pole(x,y); if (z<0) { cerr<<"problem z obliczaniem pola"; return; // Kolejny problem: jaką wartość błędu może zwracać funkcja max()?

Raportowanie błędów (2) Ustawianie znacznika błędu: int errno = 0; int pole(int wysokosc, int szerokosc) { if(wysokosc <0 szerokosc < 0) errno = 7; return wysokosc*szerokosc; } Wywołujący musi (może?) sprawdzić wynik i podjąć działanie int z = pole(x,y); if (errno==7) { cerr<<"problem z obliczaniem pola"; return; // Te same problemy co poprzednio nie używaj!!

Raportowanie błedów (3) Zgłaszanie wyjątków: int pole(int wysokosc, int szerokosc) { if (wysokosc <0 szerokosc < 0) throw 1; // wyrzucamy wyjątek nr 1 return wysokosc*szerokosc; } Wywołujący próbuje czy we fragmencie kodu nie zgłoszono wyjątku, chwyta go i decyduje co zrobić try { int z = pole(x,y); // jeżeli pole() nie zgłosiło wyjątku } // wykonuje przypisanie i idzie dalej catch(int& wyjatek) { // jeżeli pole() zgłosiło wyjątek typu int, obsługuje go: if (wyjatek==1) cerr << "Ups! Problem z obliczaniem pola"; }

Raportowanie błedów (3) Zgłaszanie wyjątków: int pole(int wysokosc, int szerokosc) { if (wysokosc <0 szerokosc < 0) throw string("zle pole"); // wyrzucamy wyjątek return wysokosc*szerokosc; // Zle pole } Wywołujący próbuje czy we fragmencie kodu nie zgłoszono wyjątku, chwyta go i decyduje co zrobić try { int z = pole(x,y); // jeżeli pole() nie zgłosiło wyjątku } // wykonuje przypisanie i idzie dalej catch(string& wyjatek) { // jeżeli pole() zgłosiło wyjątek typu string, obsługuje go: cerr << "Ups! Problem z obliczaniem pola: " << wyjatek; }

Raportowanie błedów (3) Zgłaszanie wyjątków: class Zle_pole { }; // Tak w C++ definiujemy typ użytkownika, tutaj typ błędu int pole(int wysokosc, int szerokosc) { if (wysokosc <0 szerokosc < 0) throw Zle_pole(); // wyrzucamy obiekt typu Zle_pole return wysokosc*szerokosc; } Wywołujący próbuje czy we fragmencie kodu nie zgłoszono wyjątku, chwyta go i decyduje co zrobić try { int z = pole(x,y); // jeżeli pole() nie zgłosiło wyjątku } // wykonuje przypisanie i idzie dalej catch(zle_pole&) { // jeżeli pole() zgłosiło wyjątek Zle_pole(), obsługuje go: cerr << "Ups! Problem z obliczaniem pola"; }

Wyjątki - idea Program, czyli grupa funkcji przybywa na dzikie i niebezpieczne tereny. Jedna z nich wyrusza na rekonesans www.sidzina.net.pl Sygnalizuje go rzucając wyjątek: Wtem, napotyka problem: msw-pttk.org.pl Reszta chwyta, że żółta flara oznacza misia i podejmuje dalsze działania artofmanliness.com

Dlaczego wyjątki? Obsługa wyjątków jest uniwersalna Nie można o nich zapomnieć: wystarczy, że umieścisz całość programu w bloku try catch, a program zakończy działanie, jeśli wyjątek pojawi się i nie zostanie obsłużony Prawie każdy typ błędu można zgłosić wyjątkiem Jednak to wciąż programista musi zastanowić się co zrobić z każdym wyjątkiem

Wyjątki błąd poza zakresem int main() try { vector<int> v(10); // wektor 10-ciu int-ów for (int i = 0; i<v.size(); ++i) v.at(i) = i; // ustawiamy wartości // at(i) = [i] + wyjątek zakresu for (int i = 0; i<=10; ++i) // drukujemy 10 wartości (???) cout << "v[" << i << "] == " << v.at(i) << endl; } catch (out_of_range&) { // wyjątek out_of_range cerr << "ups któryś indeks wektora poza zakresem\n"; } catch ( ) { cerr << "ups jakiś błąd\n"; } // wszystkie inne wyjątki

Odrobaczanie Na proces debugowania składa się: 1) Zauważenie, że coś działa inaczej niż oczekiwano 2) Sprawdzenie co tak na prawdę się dzieje 3) Poprawienie A jak tego nie robić? dopóki (program nie sprawia wrażenia działającego) { zaglądam tu i tam, szukając czegoś co wygląda dziwnie; zmieniam to, aby wyglądało lepiej ; }

Krok 1: Zadbaj o strukturę programu Jeżeli masz znaleźć błąd program musi być łatwy do czytania 1) Komentuj wyjaśniaj swoje pomysły 2) Używaj znaczących nazw 3) Rób wcięcia trzymaj się jednego stylu 4) Podziel kod na małe funkcje - unikaj funkcji dłuższych niż strona kodu 5) Jeśli to możliwe, unikaj skomplikowanego kodu, np. zagnieżdżonych pętli i instrukcji warunkowych 6) Używaj funkcji bibliotecznych są sprawdzone

Krok 2: Skompiluj program Jeśli program się nie kompiluje - sprawdź: 1) Czy zakończyłeś literały łańcuchowe ('') i znakowe (')? 2) Czy zakończyłeś każdy blok ({ }) 3) Czy zamknąłeś wszystkie nawiasy? 4) Czy każda nazwy została zadeklarowana? 5) Czy każda nazwa została zadeklarowana przed użyciem? 6) Czy zakończyłeś każdą instrukcję średnikiem?

Krok 3: Prześledź program Podejdź do tego jakbyś był komputerem Czy dane na wyjściu spełniają Twoje oczekiwania? Warto wyrzucić wartości paru zmiennych na wyjście błędu: cerr << "x == " << x << ", y == " << y << '\n'; Uważaj musisz zobaczyć to co programu rzeczywiście robi, nie to co uważasz, że powinien robić: for (int i=0; 0<month.size(); ++i) { // błąd! for( int i = 0; i<=max; ++j) { Gdzie szukać błędu? // podwójny błąd!

Krok 3: Gdzie szukać błędu? Wprowadź testy poczytalności (ang. sanity checks), if (liczba_elementow<0) throw runtime_error("ujemna liczba elementow"); if (maksymalny_sensowny<liczba_elementow) throw runtime_error("nieoczekiwanie wielka liczba elementow"); if (x<y) throw runtime_error("niemozliwosc: x<y"); Napisz je tak, aby nie trzeba było ich usuwać z kodu w momencie, gdy program będzie wyglądał na ukończony

Krok 3: Gdzie szukać błędu? Warunki początkowe i końcowe class Zly_argument { }; class Zle_pole { }; int pole(int wysokosc, int szerokosc) { if (wysokosc <0 szerokosc < 0) throw Zly_argument(); int p = wysokosc*szerokosc; if (p<0) throw Zle_pole(); return p; } Zasady Zawsze przemyśl warunki początkowe i końcowe Zapisz je przynajmniej w postaci komentarza Sprawdzaj, gdy szukasz błędu Kiedy w przykładzie warunek początkowy będzie spełniony, a końcowy nie?

Krok 3: Gdzie szukać błędu? Sprawdź przypadki brzegowe Czy zainicjowałeś każdą zmienną sensowną wartością? Czy funkcja dostała prawidłowe argumenty? Czy funkcja zwróciła prawidłową wartość? Czy poprawnie obsłużyłeś pierwszy i ostatni element? (np. pętli) Czy poprawnie obsłużyłeś przypadki puste? (brak elementów, brak wejścia) Czy poprawnie otworzyłeś plik? Czy rzeczywiście wczytałeś wejście i zapisałeś wyjście?

Kilka ogólnych zasad Jeżeli nie możesz znaleźć błędu, szukasz w złym miejscu Nie dowierzaj swojemu przekonianiu, że wiesz gdzie jest błąd Nie zgaduj, kieruj się danymi na wyjściu: Szukaj od miejsca, gdzie wiesz, że jest ok Co się dzieje dalej, dlaczego? Szukaj przed miejscem, gdzie dostałeś zły wynik Co mogło się wydarzyć? Znalezłeś robaka? Zastanów się, czy naprawienie go rozwiązuje cały problem Często szybka poprawka wprowadza nowe błędy Jeśli programista mówi: znalazłem ostatni błąd, to żartuje;-)

Plan na dziś Obsługa błędów Klasy Dane i funkcje składowe Implementacja i interfejs Konstruktory

Klasy Klasa bezpośrednio reprezentuje pojęcie w programie Jeśli o czymś można myśleć jako o oddzielnym bycie, to prawdopodobnie może to być klasą lub obiektem klasy Np. wektor, macierz, strumień wejściowy, łańcuch znakowy, szybka transformata Fouriera, kontroler zaworu, ramię robota, sterownik urządzenia, obraz na ekranie, okno dialogowe, wykres, okno, odczyt temperatur, zegar Klasa jest typem zdefiniowanym przez użytkownika, który określa jak tworzyć i używać obiekty tego typu Klasy po raz pierwszy wprowadzono w języku Simula67

Klasa, obiekt, zmienna class Pralka { // ta klasa nazywa się Pralka // Ciało klasy //... }; Pralka czerwona; // definicja zmiennej czerwona typu Pralka // powstaje nowy obiekt, który otrzymuje nazwę czerwona int numer; // definicja zmiennej numer typu int // powstaje nowy obiekt, który otrzymuje nazwę numer Pralka *wskaznik; // definicja wskaznika na typ Pralka Pralka &ruda = czerwona; // definicja referencji ruda do zmiennej czerwona Słowniczek: Klasa typ danych użytkownika Obiekt miejsce w pamięci przechowujące dane określonego typu Zmienna nazwany obiekt

` string model int nr_programu float temperatura_prania http://allegro.pl/czujnik-temperatury-do-pralki-elektrolux-ew-876-f-i2645030106.html

Dane składowe klasy class Pralka { public: // ta klasa nazywa się Pralka // int nr_programu; // dane składowe (przechowują informacje) float temperatura_prania; string model; // }; Pralka czerwona; czerwona.model = Frania ; // dostęp do danej składowej model zmiennej czerwona cout << czerwona.model; // Frania Pralka& ruda = czerwona; ruda.model = Frania ; Pralka *wskaznik = &czerwona; wskaznik->model = Frania ; // dostęp przez referencję // ustawienie wskaznika na zmiennej czerwona // dostęp przez wskaźnik

` int pierz(int program) int pierz(int program) { void wiruj(int minuty); }

Funkcje składowe klasy (metody) class Pralka { // ta klasa nazywa się Pralka public: int pierz(int program); // funkcje składowe (robią coś z danymi składowymi) void wiruj(int minuty); int nr_programu; // dane składowe (przechowują informacje) float temperatura_prania; string model; float krochmalenie(void); // znowu funkcja składowa }; int x = czerwona.pierz(1); // wywołanie funkcji składowej pierz() dla zmiennej czerwona int y = ruda.pierz(2); // wywołanie funkcji składowej pierz() dla referencji ruda wskaznik = &czerwona; int z = wskaznik->pierz(3); // wywołanie funkcji składowej pierz() dla wskaznika

Definiowanie funkcji składowych wewnątrz ciała funkcji inline class osoba { public: string nazwisko; int wiek; // Definicje funkcji składowych: ==================================== void zmien(const string &napis, int lata) { if (napis.length()==0 lata<0) throw runtime_error("niepoprawne dane"); nazwisko = napis; wiek = lata; } // ------------------------------------------------------------------------------------------------------------void wypisz() { cout << "\t" << nazwisko << ", lat: " << wiek << endl; } }; Kiedy? - Tylko krótkie funkcje, których ciało zajmuje do 2 linijek. - Kompilator (jeśli zechce) potraktuje je jako funkcje w linii, czyli inline

Definiowanie funkcji składowych na zewnątrz ciała funkcji class osoba { public: string nazwisko; int wiek; // Deklaracje funkcji składowych: ================================ void zmien(const string &napis, int lata); void wypisz(); }; // Definicje funkcji składowych: ==================================== void osoba::zmien(const string &napis, int lata) { if (napis.length()==0 lata<0) throw runtime_error("niepoprawne dane"); nazwisko = napis; wiek = lata; } // ------------------------------------------------------------------------------------------------------------void osoba::wypisz() { cout << "\t" << nazwisko << ", lat: " << wiek << endl; }

Inicjowanie obiektu typu użytkownika konstruktor Tworząc własny typ danych określamy sposób inicjowania obiektów tego typu: służy do tego konstruktor Konstruktor zawsze nazywa się tak samo jak klasa Nie podajemy zwracanego typu class osoba { public: string nazwisko; int wiek; // Deklaracje konstruktorów: =================================== osoba(const string &napis, int lata) : nazwisko(napis), wiek(lata) { if (napis.length()==0 lata<0) throw runtime_error("niepoprawna inicjalizacja"); }; osoba(int lata) : nazwisko("nn"), wiek(lata) { if (lata<0) throw runtime_error("niepoprawna inicjalizacja"); }; // Deklaracje funkcji składowych: ================================ void zmien(const string &napis, int lata); void wypisz(); };

Inicjowanie obiektu typu użytkownika konstruktor (2) class osoba { public: string nazwisko; int wiek; // Deklaracje konstruktorów: =================================== osoba(const string &napis, int lata) : nazwisko(napis), wiek(lata) { if (napis.length()==0 lata<0) throw runtime_error("niepoprawna inicjalizacja"); }; osoba(int lata) : nazwisko("nn"), wiek(lata) { if (lata<0) throw runtime_error("niepoprawna inicjalizacja"); }; //... }; osoba os1("nowak", 22); osoba os1 = osoba("nowak", 22); // ok: os1.nazwisko = "Nowak", os1.wiek = 22 // ok: dokładnie to samo co wyżej osoba os2(25); // ok: os2.nazwisko = "NN", os2.wiek = 25 osoba os3("kowalski"); // błąd: nie ma konstruktora o składni osoba(const string&) osoba os4; // błąd: klasa nie ma konstruktora bezargumentowego osoba os5("nowak", -22); // błąd wyjątek: Niepoprawna inicjalizacja

Konstruktor domyślny class osoba { public: string nazwisko; int wiek; // Deklaracje funkcji składowych: ================================ void zmien(const string &napis, int lata); void wypisz(); }; Klasa MUSI posiadać konstruktor jeśli nie zdefiniowany tworzony jest konstruktor domyślny: osoba os6; bezargumentowy: osoba() nie robi nic // ok: os6.nazwisko= "", os6.wiek = -858993460

Dziś najważniejsze było to, że... Mechanizm wyjątków - efektywne narzędzie obsługi błędów Jeśli programista mówi: znalazłem ostatni błąd, to żartuje;-) Klasa reprezentuje pojęcie Obiekt jest ucieleśnieniem tej klasy Zmienna jest nazwanym obiektem Każda klasa posiada konstruktor

A za tydzień... Abstrakcja i enkapsulacja