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

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 ); // ???

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

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

· relacja generalizacji – specjalizacji PojazdyKolowe PojazdySilnikowe PojazdyElektryczne PojazdySpalinowe

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

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

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

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

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

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

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ą

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 ; }

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

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

·      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 }

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

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 ) ; } ;

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

·      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 } ;

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

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

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

#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

#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 ) ; }

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

·      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 ) ;

·      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 ; } } ;

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 ) ;

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

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

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.

·      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 ( ) { } } ;

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

·      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 ( ) { ......... } } ;

// 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

·      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

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

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; }

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' ) ;

·      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 ;

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

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

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

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

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; ...... }

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

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;

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

  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 );

·      przeciążanie operatorów Obiekt1 . Rowny ( Obiekt2 ) Obiekt1 == Obiekt2 1 + 2 1.5 + 2.5E7 –      operatory istniejące w C++ ( poza kilkoma ) –      jeden z argumentów  obiekt klasy –      zachowuje arność i priorytet

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 } ;

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

–      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; } } ;

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

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 ] ;

·      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;

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

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

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

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 ; }

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;

–      pliki dyskowe  fstream #include <fstream> using namespace std; char *Tekst = "Aktualna wiadomość" ; double P = 124.57; 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 ( ) ;

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 ) ;

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

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

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

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

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

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