PROGRAMOWANIE OBIEKTOWE

Prezentacja na temat: "PROGRAMOWANIE OBIEKTOWE"— 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 · hermetyzacja danych 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 streamIO:57 Autobus Trolejbus LiczbaKol 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 class identyfikator_klasy ;
·      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 };

12 class Baklazan { //składowe prywatne public: //składowe powszechne private: } ; ·   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 ; 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 = ) ; } ; //  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 <string.h>
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 <string.h>
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 <string.h> 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 ; void Wyswietl ( ) { } } ;

36 // w funkcji Wyswietl dostępne składowe
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 =
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 == Obiekt2 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 <iostream> 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 <fstream> 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 ios::app Dopisuj dane na końcu pliku ios::ate
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 Magazyn . open ("MagazynButow.txt", ios::out);
ofstream Magazyn; Magazyn . open ("MagazynButow.txt", ios::out); Buty Nowe, Inne, Ladne; // Magazyn << Nowe; Magazyn << Inne << Ladne; Magazyn.Close(); UseCir ,Telewizor