PROGRAMOWANIE OBIEKTOWE metoda tworzenia oprogramowania obiekt odwzorowanie wycinka
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 numer typ wlasciciel kwota stan wplata ( ) wyplata ( ) blokada ( ) oprocentowanie ( ) · hermetyzacja danych
· relacja całość – część Samochod Nadwozie Silnik Wyposazenie kolor cena
· relacja generalizacji – specjalizacji Pojazdy. Kolowe Pojazdy. Silnikowe Pojazdy. Elektryczne Pojazdy. Spalinowe
Trolejbus Autobus Liczba. Kol Moc. Silnika Napiecie. Zasilania Rodzaj. Paliwa stream. IO: 57
· klasa składowe klasy : dane, struktury danych, atrybuty · funkcje metody definicja klasy class identyfikator_klasy { treść_klasy } ;
class { Prostokat public: float Szerokosc ; float Wysokosc ; float Powierzchnia ( ) { return Szerokosc * Wysokosc ; } } ;
· 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: . . . public: . . . }; //składowe prywatne //składowe powszechne
class { Baklazan. . . . public: //składowe prywatne . . . . private: . . . . //składowe powszechne //składowe prywatne } ; · 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 public: float void Liczba ; Wartosc ( ) { return Cena * Liczba ; 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 ; public: void Wyswietl ( ); . . . . } ;
void Osoba : : Wyswietl ( ) { printf( " %s", Imie ) ; . . . } // void Rura : : Wyswietl ( ) { printf ( " %d cm", Dlugosc); . . }
· class wartości domyślne argumentów funkcji Cement { private: float public: float Masa ; // kg 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* Czyje. Konto ( ) { return Wlasciciel ; bool Jest. Blokada ( ) { return float } ; } Blokada ; } Wyplata ( char*, int ) ;
float { Konto : : Wyplata ( char* Haslo , int Kwota ) if { ( Odpowiednie ( Haslo ) ) Depozyt -= Kwota ; return Depozyt ; } else return } 1 f ;
· · tworzenie obiektów klas – statycznie ( deklaracja ) – dynamicznie ( new ) inicjowanie składowych powszechnych class Dlugopis { public: } char Kolor [ 16 ] ; bool Jednorazowy ; Pisz 1, Pisz 2 = { "czarny", true }, Pisz 3 = { "niebieski", false } ;
Dlugopis Pisz 4, *p. Pisz 5 Dlugopis &Pisz 6 = Dlugopis *p. Pisz 7 = Dlugopis Pisz 8 = { "czerwony", true } ; · = &Pisz 4 ; Pisz 2 ; new Dlugopis ; 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) return Cena; } }; Ksiazka K 1 = { 35 }, K 2 = { 29 }; Ksiazka *w 1 = & K 1, *w 2 = & K 2 ; int Ile; Ile = K 1. Cena ; Ile = K 2. Cena ; Ile = w 1 –> Cena ; Ile = K 1. Przecena ( 10 ); // K 1. Cena Ile = K 2. Przecena ( 5 ); // K 2. Cena w 1 –> Przecena ( 5 ); // K 1. Cena w 2 –> Przecena ( 2 ); // K 2. Cena / 100; = = 31 27 29 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 Droga 1 = Ulica ( "Polna", 3. 8 ) ; Ulica Droga 2 ( "Rolna", 4. 2 ) ; Ulica *p. Droga 3 = new Ulica ( "Mylna", 2. 5 ) ; Ulica Droga 4 = { "Dolna", 1. 1 } ; // błąd, składowe prywatne
#include <string. h> class Most { float Dlugosc ; char Rzeka [ 32 ], Typ [ 16 ] ; public: Most (float, 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 } ; Punkt ( ) { Rzedna, Odcieta ; } // domyślny Odcinek_1
· lista powiązań class Trojkat { private: int Bok. A, Bok. B, Bok. C ; public: Trojkat ( int, int ) ; } ; Trojkat : : Trojkat( int A, int B, int C ): Bok. A ( A ), Bok. B ( B ) { Bok. C = C ; } Trojkat Triak 1 ( 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 + strcpy ( Napis, Tek ) ; } 1 ] ;
Tekst Proza 1 ( 17 ) ; // konstruktor I Tekst Proza 2 ( "samochód osobowy" ) ; // konstruktor II Tekst Proza 3 ; Tekst Proza 4 = // konstruktor III Tekst ( ) ; // konstruktor III Tekst Proza 5 ( ) ; // błąd // deklaracja funkcji bezargumentowej // o wyniku typu Tekst *p. Proza 6 = new Tekst ( 12. 7 ) ; // konstruktor I po // standardowej konwersji argumentu Odcinek_2
· destruktor class { Pracownik char float *Nazwisko ; 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 *Rob 1 = new Pracownik( "Wiśniewski", 1500 ); // delete Rob 1; // Wiśniewski - Panu już dziękujemy.
· tablice obiektów klas class Sruba { char *Gwint ; float Dlugosc ; public: Sruba ( char { Gwint = new *Mxx, float Dlg = 0 ) : Dlugosc( Dlg ) char [ strlen ( Mxx ) + 1 ] ; strcpy ( Gwint, } Sruba ( ) { } } ; Mxx ) ;
Sruba Tablica. Srub [ 10 ] ; // Sruba *Wykaz. Srub delete [ = new Sruba [ 10 ] ; ] Wykaz. Srub ; // Sruba Zestaw 1 [ ] = { "M 6", "M 5", "M 3", "M 8" } ; // 4 elementy Sruba Zestaw 2 [ 2 ] = { Sruba( "M 4", 3. 5 ), Sruba( "M 8", 10 ) }; Sruba Zestaw 3 [ 3 ] = { "M 10", Sruba ( "M 12", 12 ), Sruba ( "M 22" ) } ; Podwyżka
· obiekty jako składowe innych obiektów class Kaseta { float Pojemnosc ; public: char *Producent ; float Jaka. Pojemnosc ( ) { return Pojemnosc ; } } ; class { Nagranie Kaseta nosnik ; char *Film ; public: void Wyswietl ( {. . } ) } ;
Pojemnosc 120 Producent Film // w funkcji Wyswietl dostępne składowe Producent i Film, składowa Pojemnosc jedynie przez funkcję Jaka. Pojemnosc
· wskaźnik this float Poj_1 = Kaseta_1. Jaka. Pojemnosc(); float Poj_2 = Kaseta_2. Jaka. Pojemnosc(); // wskaźnik obiektu aktualnego this float Jaka. Pojemnosc ( ) { return this -> Pojemnosc ; } // nadmiarowe
class Plansza { char Pola [ 16 ] ; char Wiersz, Kolumna ; public: }; Plansza& Ustal. Wiersz ( char ) ; Plansza& Ustal. Kolumne ( char ) ; Plansza& Ustal. Pole ( char ) ;
Plansza& Plansza : : Ustal. Wiersz ( char Numer ) { Wiersz = Numer ; return *this; Plansza& { } Plansza : : Ustal. Kolumne ( char Numer ) Kolumna = Numer ; return *this; } Plansza& Plansza : : Ustal. Pole ( char Zawartosc ) { Pola [ Wiersz ] [ Kolumna ] return *this; } = Zawartosc ;
Plansza Gra; Plansza *p. Gra = new Plansza ; Gra. Ustal. Wiersz ( 10 ). Ustal. Kolumnę ( 3 ). Ustal. Pole ( 'A' ); Gra. Ustal. Pole ( 'K' ). Ustal. Wiersz ( 7 ). Ustal. Kolumnę ( 0 ); p. Gra > Ustal. Wiersz ( 15 ). Ustal. Kolumnę ( 15 ). Ustal. Pole ( 'J' ) ;
· statyczne składowe klas class Polaczenia { } ; int static int Licznik. Polaczen ; char *Nadawca ; char *Odbiorca ; public: Polaczenia ( char*, char* ) ; ~Polaczenia ( ) ; static int Liczba. Polaczen ( ) { return Licznik. Polaczen ; } Polaczenia : : Licznik. Polaczen = 0 ;
Polaczenia : : Polaczenia ( char *Nad, { char *Odb) . . . // Nadawca, Odbiorca ++ Licznik. Polaczen ; } Polaczenia : : ~Polaczenia ( ) { -- Licznik. Polaczen ; } int Zwiazki = Polaczenia : : Liczba. Polaczen ( ) ; // Związki == 0
Polaczenia Lacze 1( "Gniezno", "Poznań" ) ; Połączenia *p. Lacze = new Polaczenia ( "Ełk", "Radom" ) ; // Zwiazki = Lacze 1. Liczba. Polaczen ( // Związki == 2 Zwiazki = p. Lacze -> Liczba. Polaczen ( // Związki == 2 delete ) ) ; p. Lacze ; Zwiazki = Polaczenia : : Liczba. Polaczen( ); // Związki == 1
· funkcje i klasy zaprzyjaźnione class Podatek { private: float Stopa ; float Podstawa ; float Ulgi ; public: friend void Zmiana ( Podatek&, 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 o 1(5, 12); int dd; dd = (int)o 1; dd = o 1 + 5; }
class Okrag // konstruktor { public: Punkt Centrum; // X, Y double Promien; Okrag ( Punkt pp) { Centrum = pp; Promien = 1. 0; } };
bool Jest. Ponizej. X (Okrag a) { return a. Centrum. X < 0; } Punkt P 1( 1. 3, 5. 6 ), P 2( -4. 8, 2. 9 ); bool k = Jest. Ponizej. X ( P 1 ), l = Jest. Ponizej. X ( (Okrąg) P 2 );
· przeciążanie operatorów Obiekt 1. Rowny ( Obiekt 2 ) Obiekt 1 == Obiekt 2 1 + 1. 5 2 + 2. 5 E 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 ) ; friend float operator - (Beczka&, float ) ; float operator + ( float { return Zapas += // this -> Zapas } ; Dolano ) Dolano ; }
float operator - ( Beczka& beczka, float Pobrano ) { return beczka. Zapas -= Pobrano ; } Beczka float beczka 1543 ( "ocet", 150, 150 ) ; Pozostalo = beczka 1543 - 12. 4 , Nowa. Ilosc = beczka 1543 + 5. 3 ;
– operatory unarne i binarne – operatory = i [ class { ] Strona int Numer ; char *Tekst ; public: Strona& operator = ( Strona ) ; char operator [ ] ( int Nr. Znaku ) { return Tekst [ Nr. Znaku ] ; } int Daj. Numer( ) { return Numer; }
Strona& Strona: : operator = ( Strona org ) { Numer = org. Numer + 1000 ; Tekst = new char [ strlen ( org. Tekst ) strcpy ( Tekst, return + 1 ] ; org. Tekst ) ; *this ; } // // Kopia_Strony = Strona_Oryginalna ; this org
Strona Aktualna ( 15, "Rozdział 3" ) ; Strona Pomocnicza ( 0, int " " ) ; Numer. Kopii; Pomocnicza = Aktualna; Numer. Kopii = Pomocnicza. Daj. Numer ( ) ; // 1015 Strona Robocza ( 234, char Znak. Wybrany = "Zakończenie" ) ; 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 int Znak ; Srednia ; float Malo. Dokladna ; double Dokladna ; char *Tekst = new char [ 32 ] ; // cin >> Znak ; // cin >> Srednia >> Malo. Dokladna >> Tekst ;
int Liczba. Komorek ; float Srednia. Komorka ; char Napis[20] = "Koniec programu. "; // cout << "n Liczba komórek : " << Liczba. Komorek ; cout << "n Wielkość średniej komórki : " << cout << Napis << endl; Srednia. Komorka ; // iomanip. h Oper. Od
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 << "n. Rozmiar butów klawiatura >> cout << << buty. Rozmiar ; "n. Proponowana cena : " ; klawiatura >> cout buty. Cena ; "n. Kolor butów klawiatura >> : " ; buty. Kolor ; return klawiatura ; } : " ;
ostream& { operator << ( ostream& monitor, monitor << "n. Rozmiar butów monitor << buty. Rozmiar << endl ; monitor << "Proponowana cena : " ; monitor << buty. Cena monitor << "Kolor butów monitor << buty. Kolor << endl ; return monitor ; } Buty cin Buty buty ) Pantofle 231 ; >> Pantofle 231; cout << Pantofle 231; : " ; << endl ; : " ;
– pliki dyskowe fstream #include <fstream> using namespace std; char *Tekst = "Aktualna wiadomość" ; double P = 124. 57; ofstream Plik. Pierwszy("plik 1. txt") ; ofstream Plik. Drugi ; Plik. Drugi. open("plik 2. txt", ios: : out ) ; Plik. Pierwszy Plik. Drugi << << Tekst << 't' << P << endl; P << " " << Tekst << "n"; Plik. Pierwszy. close ( Plik. Drugi. close ( ) ;
char *Bufor[128]; int Liczba; double Dana; ifstream Plik. We 1; Plik. We 1. open( "Dane. txt", ios: : in ); Plik. We 1 >> Bufor >> Liczba >> Dana ; Plik. We 1. close( ); // ifstream archiwum ; archiwum. open( "Archiwum. Podstawowe. doc", ios: : in | ios: : nocreate ) ;
Flaga Znaczenie ios: : app Dopisuj dane na końcu pliku ios: : ate ios: : in Przesuń wskaźnik na koniec pliku 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 ("Magazyn. Butow. txt", ios: : in); Buty Nowe, Inne, Ladne; Magazyn >> Nowe; Magazyn >> Inne >> Ladne; Magazyn. Close();
ofstream Magazyn; Magazyn. open ("Magazyn. Butow. txt", ios: : out); Buty Nowe, Inne, Ladne; //. . . Magazyn << Nowe; Magazyn << Inne << Ladne; Magazyn. Close(); Use. Cir , Telewizor
- Slides: 70