Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

PROGRAMOWANIE OBIEKTOWE metoda tworzenia oprogramowania obiekt odwzorowanie wycinka rzeczywistości obiekt zawiera: – dane – struktury danych – operacje.

Podobne prezentacje


Prezentacja na temat: "PROGRAMOWANIE OBIEKTOWE metoda tworzenia oprogramowania obiekt odwzorowanie wycinka rzeczywistości obiekt zawiera: – dane – struktury danych – operacje."— Zapis prezentacji:

1 PROGRAMOWANIE OBIEKTOWE metoda tworzenia oprogramowania obiekt odwzorowanie wycinka rzeczywistości obiekt zawiera: – dane – struktury danych – operacje ( funkcje ) klasa definicja obiektów o takiej samej budowie

2 double Wartosc ( double Liczba, double Cena) { return Liczba * Cena; } // double wartosc, liczba = 45, cena = 12.7; wartosc = Wartosc ( liczba, cena );// ok // double brutto, netto = 248.4, tara = 23.4; brutto = Wartosc ( netto, tara );// ???

3 Konto numer typ wlasciciel kwota stan wplata ( ) wyplata ( ) blokada ( ) oprocentowanie ( ) hermetyzacja danych

4 relacja całość – część Samochod Nadwozie Silnik Wyposazenie kolor cena

5 relacja generalizacji – specjalizacji PojazdyKolowe PojazdySilnikowe PojazdyElektryczne PojazdySpalinowe

6 Trolejbus LiczbaKol MocSilnika NapiecieZasilania Autobus LiczbaKol MocSilnika RodzajPaliwa streamIO:57

7 klasa składowe klasy : dane, struktury danych, funkcje atrybuty metody definicja klasy class identyfikator_klasy { treść_klasy } ;

8 class Prostokat { public: float Szerokosc ; float Wysokosc ; float Powierzchnia ( ) { return Szerokosc * Wysokosc ; } } ;

9 deklaracja klasy class identyfikator_klasy ; prawa dostępu do składowych klasy – public : – private : – protected :

10 class Pojemnik { private: int Zawartosc ; public: int Pozostalo ( ) { return Zawartosc ; } void Dodaj ( ) { ++ Zawartosc ; } void Zabierz ( ) { -- Zawartosc ; } } ;

11 class Abazur { private: //składowe prywatne public: //składowe powszechne private: //składowe prywatne public: //składowe powszechne };

12 class Baklazan { //składowe prywatne public: //składowe powszechne private: //składowe prywatne } ; definiowanie składowych – dane ( bez wartości początkowych ) – funkcje : w treści klasy lub poza klasą

13 class Towar { private: char *Nazwa ; float Cena ; int Liczba ; public: float Wartosc ( ) { return Cena * Liczba ; } void Przecena ( int ) ; } ; void Towar :: Przecena (int Procent ) { if ( Cena > CENA_ZAKUPU && Liczba > MAKSYMALNY_ZAPAS) Cena * = ( 100 Procent ) / 100 ; }

14 funkcje różnych klas mogą mieć takie same identyfikatory class Osoba { char *Imie ; public: void Wyswietl ( ) ; } ; class Rura { int Dlugosc ; public: void Wyswietl ( ); } ;

15 void Osoba :: Wyswietl ( ) { printf( " %s", Imie ) ; } // void Rura :: Wyswietl ( ) { printf ( " %d cm", Dlugosc); }

16 wartości domyślne argumentów funkcji class Cement { private: float Masa ; // kg public: float Ciezar ( float = 9.81 ) ; } ; // float Cement :: Ciezar( float Przyspieszenie ) { return Masa * Przyspieszenie ; // N }

17 rodzaje funkcji składowych – funkcje zarządzające ( konstruktory, destruktory ), – funkcje dostępu, – funkcje przetwarzające, – funkcje pomocnicze.

18 bool Odpowiednie ( char* ) ; class Konto { private: char *Wlasciciel ; float Depozyt ; bool Blokada ; public: char* CzyjeKonto ( ) { return Wlasciciel ; } bool JestBlokada ( ) { return Blokada ; } float Wyplata ( char*, int ) ; } ;

19 float Konto :: Wyplata ( char* Haslo, int Kwota ) { if ( Odpowiednie ( Haslo ) ) { Depozyt -= Kwota ; return Depozyt ; } else return 1f ; }

20 tworzenie obiektów klas – statycznie ( deklaracja ) – dynamicznie ( new ) inicjowanie składowych powszechnych class Dlugopis { public: char Kolor [ 16 ] ; bool Jednorazowy ; } Pisz1, Pisz2 = { "czarny", true }, Pisz3 = { "niebieski", false } ;

21 Dlugopis Pisz4, *pPisz5 = &Pisz4 ; Dlugopis &Pisz6 = Pisz2 ; Dlugopis *pPisz7 = new Dlugopis ; Dlugopis Pisz8 = { "czerwony", true } ; dostęp do składowych obiektu: – poprzez identyfikator, referencję :. – poprzez wskaźnik : –> Odcinek_0

22 class Ksiazka { public: int Cena; int Przecena ( int Procent ) {Cena = Cena * (100 - Procent) / 100; return Cena; } }; Ksiazka K1 = { 35 }, K2 = { 29 }; Ksiazka *w1 = & K1, *w2 = & K2 ; int Ile; Ile = K1.Cena ; Ile = K2.Cena ; Ile = w1 –> Cena ; Ile = K1.Przecena ( 10 ); // K1.Cena = 31 Ile = K2.Przecena ( 5 ); // K2.Cena = 27 w1 –> Przecena ( 5 ); // K1.Cena = 29 w2 –> Przecena ( 2 ); // K2.Cena = 26

23 stosowanie konstruktorów i destruktorów – konstruktor tworzenie obiektu – destruktor usuwanie obiektu wywoływane automatycznie

24 #include class Ulica { private: char *Nazwa ; float Dlugosc ; public: // konstruktor Ulica ( char *Tekst, float Kilometry ) { Nazwa = new char[strlen ( Tekst ) + 1]; strcpy (Nazwa, Tekst ) ; Dlugosc = Kilometry ; } } ; Ulica Droga1 = Ulica ( "Polna", 3.8 ) ; Ulica Droga2 ( "Rolna", 4.2 ) ; Ulica *pDroga3 = new Ulica ( "Mylna", 2.5 ) ; Ulica Droga4 = { "Dolna", 1.1 } ; // błąd, składowe prywatne

25 #include class Most { float Dlugosc ; char Rzeka [ 32 ], Typ [ 16 ] ; public: Most (float, char*, char* = "przeslowy" ) ; } ; Most :: Most ( float Kilometry, char* Woda = "Warta", char* Rodzaj ) { Długosc = Kilometry ; strcpy ( Rzeka, Woda ) ; strcpy ( Typ, Rodzaj ) ; }

26 Most Elzbiety( 1.2, "Dunaj", "wiszący" ) ; Most Poniatowskiego ( 1.8, "Wisła" ) ; Most Rocha ( 0.8 ) ; konstruktor domyślny class Punkt { public: float Rzedna, Odcieta ; } ; Punkt ( ) { } // domyślny Odcinek_1

27 lista powiązań class Trojkat { private: int BokA, BokB, BokC ; public: Trojkat ( int, int, int ) ; } ; Trojkat :: Trojkat( int A, int B, int C ): BokA ( A ), BokB ( B ) { BokC = C ; } Trojkat Triak1 ( 3, 12, 8 ) ;

28 konstruktory przeciążone #include class Tekst { int Dlugosc ; char* Napis ; public: Tekst ( int ) ; // konstruktor I Tekst ( char* ); // konstruktor II Tekst ( ) // konstruktor III { Dlugosc = 0 ; Napis = NULL ; } } ;

29 Tekst ::Tekst ( int Znaki ) : Dlugosc ( Znaki ) { char* Pomoc = new char [ Znaki ] ; Napis = Pomoc ; for ( int Kolejny = 1 ; Kolejny < Znaki ; ++Kolejny ) *Pomoc++ = 'x' ; *Pomoc = 0 ; } // Tekst :: Tekst ( char *Tek ) { Dlugosc = strlen ( Tek ) ; Napis = new char[ Dlugosc + 1 ] ; strcpy ( Napis, Tek ) ; }

30 Tekst Proza1 ( 17 ) ; // konstruktor I Tekst Proza2 ( "samochód osobowy" ) ; // konstruktor II Tekst Proza3 ; // konstruktor III Tekst Proza4 = Tekst ( ) ; // konstruktor III Tekst Proza5 ( ) ; // błąd - // deklaracja funkcji bezargumentowej // o wyniku typu Tekst Tekst *pProza6 = new Tekst ( 12.7 ) ; // konstruktor I po // standardowej konwersji argumentu Odcinek_2

31 destruktor class Pracownik { char *Nazwisko ; float Uposazenie ; public: Pracownik ( char*, float ) ; // konstruktor ~Pracownik ( ) ; // destruktor } ;

32 Pracownik :: Pracownik ( char *Nazwa, float Pensja ) : Uposazenie ( Pensja ) { Nazwisko = new char[strlen(Nazwa) + 1] ; strcpy ( Nazwisko, Nazwa ) ; } Pracownik :: ~Pracownik ( ) { printf ("\n%s - Panu już dziękujemy.\n", Nazwisko ); delete Nazwisko ; } // Pracownik *Rob1 = new Pracownik( "Wiśniewski", 1500 ); // delete Rob1; // Wiśniewski - Panu już dziękujemy.

33 tablice obiektów klas class Sruba { char *Gwint ; float Dlugosc ; public: Sruba ( char *Mxx, float Dlg = 0 ) : Dlugosc( Dlg ) { Gwint = new char [ strlen ( Mxx ) + 1 ] ; strcpy ( Gwint, Mxx ) ; } Sruba ( ) { } } ;

34 Sruba TablicaSrub [ 10 ] ; // Sruba *WykazSrub = new Sruba [ 10 ] ; delete [ ] WykazSrub ; // Sruba Zestaw1 [ ] = { "M6", "M5", "M3", "M8" } ; // 4 elementy Sruba Zestaw2 [ 2 ] = { Sruba( "M4", 3.5 ), Sruba( "M8", 10 ) }; Sruba Zestaw3 [ 3 ] = { "M10", Sruba ( "M12", 12 ), Sruba ( "M22" ) } ; Podwyżka

35 obiekty jako składowe innych obiektów class Kaseta { float Pojemnosc ; public: char *Producent ; float JakaPojemnosc ( ) { return Pojemnosc ; } } ; class Nagranie { Kaseta nosnik ; char *Film ; public: void Wyswietl ( ) { } } ;

36 Pojemnosc Producent Film 120 // w funkcji Wyswietl dostępne składowe Producent i Film, składowa Pojemnosc jedynie przez funkcję JakaPojemnosc

37 wskaźnik this float Poj_1 = Kaseta_1.JakaPojemnosc(); float Poj_2 = Kaseta_2.JakaPojemnosc(); // wskaźnik obiektu aktualnego this float JakaPojemnosc ( ) { return this -> Pojemnosc ; } // nadmiarowe

38 class Plansza { char Pola [ 16 ] [ 16 ] ; char Wiersz, Kolumna ; public: Plansza& UstalWiersz ( char ) ; Plansza& UstalKolumne ( char ) ; Plansza& UstalPole ( char ) ; };

39 Plansza& Plansza :: UstalWiersz ( char Numer ) { Wiersz = Numer ; return *this; } Plansza& Plansza :: UstalKolumne ( char Numer ) { Kolumna = Numer ; return *this; } Plansza& Plansza :: UstalPole ( char Zawartosc ) { Pola [ Wiersz ] [ Kolumna ] = Zawartosc ; return *this; }

40 Plansza Gra; Plansza *pGra = new Plansza ; Gra. UstalWiersz ( 10 ). UstalKolumnę ( 3 ). UstalPole ( 'A' ); Gra. UstalPole ( 'K' ). UstalWiersz ( 7 ). UstalKolumnę ( 0 ); pGra > UstalWiersz ( 15 ). UstalKolumnę ( 15 ). UstalPole ( 'J' ) ;

41 statyczne składowe klas class Polaczenia { static int LicznikPolaczen ; char *Nadawca ; char *Odbiorca ; public: Polaczenia ( char*, char* ) ; ~Polaczenia ( ) ; static int LiczbaPolaczen ( ) { return LicznikPolaczen ; } } ; int Polaczenia :: LicznikPolaczen = 0 ;

42 Polaczenia :: Polaczenia ( char *Nad, char *Odb) { // Nadawca, Odbiorca ++ LicznikPolaczen ; } Polaczenia :: ~Polaczenia ( ) { -- LicznikPolaczen ; } int Zwiazki = Polaczenia :: LiczbaPolaczen ( ) ; // Związki == 0

43 Polaczenia Lacze1( "Gniezno", "Poznań" ) ; Połączenia *pLacze = new Polaczenia ( "Ełk", "Radom" ) ; // Zwiazki = Lacze1.LiczbaPolaczen ( ) // Związki == 2 Zwiazki = pLacze -> LiczbaPolaczen ( ) ; // Związki == 2 delete pLacze ; Zwiazki = Polaczenia :: LiczbaPolaczen( ); // Związki == 1

44 funkcje i klasy zaprzyjaźnione class Podatek { private: float Stopa ; float Podstawa ; float Ulgi ; public: friend void Zmiana ( Podatek&, float ) ; Podatek ( float, float, float ) ; } ;

45 Podatek :: Podatek ( float St, float Po, float Ul ) : Stopa( St ), Podstawa ( Po ), Ulgi ( Ul ) { } ; void Zmiana ( Podatek& podatek, float St ) { podatek. Stopa = St ; } // zaprzyjaźnionej wolno

46 class Alfa { int Zmiana(Otwarta&); float Inna(Otwarta&);..... }; class Beta { double Mod_1(Otwarta&); char Mod_2(Otwarta&);..... }; class Otwarta { friend int Alfa::Zmiana(Otwarta&); friend class Beta; }

47 konwersja obiektów – operatory konwersji operator typ ( ) { blok } ( typ : nazwa typu podstawowego lub nazwa klasy) – konstruktor jako operator konwersji

48 class Odcinek// operator { public: int Poczatek, Koniec; Odcinek (int x, int y): Poczatek(x), Koniec(y) { } operator int ( ) {return Koniec - Poczatek; } }; Odcinek o1(5, 12); int dd; dd = (int)o1; dd = o1 + 5;

49 class Okrag// konstruktor { public: Punkt Centrum;// X, Y double Promien; Okrag ( Punkt pp) { Centrum = pp; Promien = 1.0; } };

50 bool JestPonizejX (Okrag a) { return a.Centrum.X < 0; } Punkt P1( 1.3, 5.6 ), P2( -4.8, 2.9 ); bool k = JestPonizejX ( P1 ), l = JestPonizejX ( (Okrąg) P2 );

51 przeciążanie operatorów Obiekt1. Rowny ( Obiekt2 ) Obiekt1 == Obiekt E 7 – operatory istniejące w C++ ( poza kilkoma ) – jeden z argumentów obiekt klasy – zachowuje arność i priorytet

52 class Beczka { char *Plyn ; float Pojemnosc, Zapas ; public: Beczka (char*, float, float ) ; friend float operator - (Beczka&, float ) ; float operator + ( float Dolano ) { return Zapas += Dolano ; } // this -> Zapas } ;

53 float operator - ( Beczka& beczka, float Pobrano ) { return beczka. Zapas -= Pobrano ; } Beczka beczka1543 ( "ocet", 150, 150 ) ; float Pozostalo = beczka , NowaIlosc = beczka ;

54 – operatory unarne i binarne – operatory = i [ ] class Strona { int Numer ; char *Tekst ; public: Strona& operator = ( Strona ) ; char operator [ ] ( int NrZnaku ) { return Tekst [ NrZnaku ] ; } int DajNumer( ) { return Numer; } } ;

55 Strona& Strona::operator = ( Strona org ) { Numer = org. Numer ; Tekst = new char [ strlen ( org. Tekst ) + 1 ] ; strcpy ( Tekst, org. Tekst ) ; return *this ; } // Kopia_Strony = Strona_Oryginalna ; // this org

56 Strona Aktualna ( 15, "Rozdział 3" ) ; Strona Pomocnicza ( 0, " " ) ; int NumerKopii; Pomocnicza = Aktualna; NumerKopii = Pomocnicza. DajNumer ( ) ; // 1015 Strona Robocza ( 234, "Zakończenie" ) ; char ZnakWybrany = Robocza [ 4 ] ;

57 wprowadzanie i wyprowadzanie danych – klawiatura i monitor iostream cin // strumień wejściowy (klawiatura) cout // strumień wyjściowy (monitor) cerr // strumień diagnostyczny (monitor) #include using namespace std;

58 char Znak ; int Srednia ; float MaloDokladna ; double Dokladna ; char *Tekst = new char [ 32 ] ; // cin >> Znak ; // cin >> Srednia >> MaloDokladna >> Dokladna >> Tekst ;

59 int LiczbaKomorek ; float SredniaKomorka ; char Napis[20] = "Koniec programu."; // cout << "\n Liczba komórek : " << LiczbaKomorek ; cout << "\n Wielkość średniej komórki : " << SredniaKomorka ; cout << Napis << endl; // iomanip.h OperOd

60 – dla obiektów klas class Buty { int Rozmiar ; float Cena ; char Kolor [ 32 ] ; public: friend istream& operator >> (istream&, Buty&); friend ostream& operator << (ostream&, Buty); } ;

61 istream& operator >> ( istream& klawiatura, Buty& buty ) { cout << "\nRozmiar butów : " ; klawiatura >> buty. Rozmiar ; cout << "\nProponowana cena : " ; klawiatura >> buty. Cena ; cout << "\nKolor butów : " ; klawiatura >> buty. Kolor ; return klawiatura ; }

62 ostream& operator << ( ostream& monitor, Buty buty ) { monitor << "\nRozmiar butów : " ; monitor << buty. Rozmiar << endl ; monitor << "Proponowana cena : " ; monitor << buty. Cena << endl ; monitor << "Kolor butów : " ; monitor << buty. Kolor << endl ; return monitor ; } Buty Pantofle231 ; cin >> Pantofle231; cout << Pantofle231;

63 – pliki dyskowe fstream #include using namespace std; char *Tekst = "Aktualna wiadomość" ; double P = ; ofstream PlikPierwszy("plik1.txt") ; ofstream PlikDrugi ; PlikDrugi. open("plik2.txt", ios::out ) ; PlikPierwszy << Tekst << '\t' << P << endl; PlikDrugi << P << " " << Tekst << "\n"; PlikPierwszy. close ( ) ; PlikDrugi. close ( ) ;

64 char *Bufor[128]; int Liczba; double Dana; ifstream PlikWe1; PlikWe1.open( "Dane.txt", ios::in ); PlikWe1 >> Bufor >> Liczba >> Dana ; PlikWe1. close( ); // ifstream archiwum ; archiwum. open( "ArchiwumPodstawowe.doc", ios::in | ios::nocreate ) ;

65 Flaga Znaczenie ios::app Dopisuj dane na końcu pliku ios::ate Przesuń wskaźnik na koniec pliku ios::in Otwarcie do odczytu ios::out Otwarcie do zapisu ios::binary Otwarcie w trybie binarnym ios::trunc Zapisuj na dotychczasową zawartość pliku ios::nocreate Nie twórz, jeżeli plik nie istnieje ios::noreplace Nie otwieraj, jeżeli plik już istnieje, chyba, że zadano ate lub app

66 – dla obiektów klas class Buty { int Rozmiar ; float Cena ; char Kolor [ 32 ] ; public: friend ifstream& operator >> (ifstream&, Buty&); friend ofstream& operator << (ofstream&, Buty); } ;

67 ifstream& operator >> ( ifstream& plikwe, Buty& buty ) { plikwe >> buty. Rozmiar ; plikwe >> buty. Cena ; plikwe >> buty. Kolor ; return plikwe ; }

68 ofstream& operator << ( ofstream& plikwy, Buty buty ) { plikwy << buty. Rozmiar << ' '; plikwy << buty. Cena << ' ' ; plikwy << buty. Kolor << ' '; plikwy << endl ; return plikwy ; }

69 ifstream Magazyn; Magazyn. open ("MagazynButow.txt", ios::in); Buty Nowe, Inne, Ladne; Magazyn >> Nowe; Magazyn >> Inne >> Ladne; Magazyn.Close();

70 ofstream Magazyn; Magazyn. open ("MagazynButow.txt", ios::out); Buty Nowe, Inne, Ladne; // Magazyn << Nowe; Magazyn << Inne << Ladne; Magazyn.Close(); UseCir, Telewizor


Pobierz ppt "PROGRAMOWANIE OBIEKTOWE metoda tworzenia oprogramowania obiekt odwzorowanie wycinka rzeczywistości obiekt zawiera: – dane – struktury danych – operacje."

Podobne prezentacje


Reklamy Google