Programowania obiektowe
w języku C++




Literatura:

* Zalewski A. "Programowanie w językach C i C++ . . ."
* Bielecki J. "Turbo C++ nowa generacja"
* Delannoy C. "Ćwiczenia z języka C++, programowanie obiektowe"
* Grębosz J. "Symfonia C++"
* Holzner S. "Programowanie w Borland C++"
* Shammas N. "Borland C++ 4 kurs na zderzenie"

* Bjarne Stroustrup "Język C++"



PROGRAM WYKŁADU
1. Rozszerzenia C++ � programowanie obiektowe:
klasy, składowe, sekcje, konstruktory, destruktory
2. Ukrywanie danych (hermetyzacja), funkcje zaprzyjaźnione.
Przykład obiektu � tablica z kontrolą zakresu
3. Klasy pochodne - dziedziczenie, hierarchia klas,
funkcje wirtualne - polimorfizm.
4. Dynamiczne tworzenie obiektów i alokacja pamięci.
Kolokwium kontrolne.
5. Przeciążanie funkcji i operatorów.
Uwagi na temat programowania w środowisku Windows
6. Przykłady korzystania z obiektowych bibliotek (Object Windows).
7. Obiektowa realizacja operacji We/Wy (obiektowe strumienie).
8. Podsumowanie wykładu i kolokwium sprawdzające.



WSTĘP
C++ jest rozszerzeniem języka C:
* typy i zmienne referencyjne,
* unie anonimowe,
* operatory new i delete,
* funkcje przeciążone,
* domyślne wartości parametrów funkcji,
* przekazywanie parametrów funkcji przez referencję,
* funkcje z atrybutem inline,
* klasy i obiekty (programowanie obiektowe) !

PROGRAMOWANIE OBIEKTOWE
C++ nie jest językiem ściśle obiektowym � pozwala również
na programowanie proceduralne (zaleta)

Programowanie ( polega na zapisywaniu algorytmów w formie programów zrozumiałych dla komputera.
Algorytm ( określa sposób przekształcania danych wejściowych w dane wyjściowe zgodnie z zadanym celem. Algorytm składa się z opisu:
* obiektów na których wykonywane są działania,
* działań realizujących cel algorytmu,
* kolejności działań.

1) Podejście proceduralne (dane i funkcje oddzielnie),

struct PUNKT_1
{
int x, y;
} ;


void RYSUJ_PUNKT( struct PUNKT_1 p ; int kolor )
{
putpixel( p.x, p. y, kolor );
}


2) podejscie obiektowe (dane i funkcje razem)
� podstawowe jest pojęcie klasy

Jeżeli napotkasz pojęcie, którego nie daje się wyrazić reprezentować za pomocą typów podstawowych � zadeklaruj klasę, która będzie je reprezentować w programie.

Opis klasy składa się z:
* danych charakteryzujących przedmiot
* funkcji określających jego właściwości

class PUNKT_2
{
int x, y, kolor ; // dane opisujące obiekt
public:
void RYSUJ_PUNKT( void ) // funkcje ( metody
{
putpixel( x, y, kolor );
}
. . .
} ; // class PUNKT_2


Ogólna postać definicji klasy:

class | struct | union NAZWA_KLASY
{
private: { Sekcja prywatna � domyślna dla class}
( ( ( składowe prywatne są widoczne tylko w obrębie
funkcji składowych danej klasy

protected: {Sekcja zabezpieczona}
( ( ( składowe zabezpieczone są widoczne tylko w
obrębie funkcji danej klasy i klas wyprowadzonych

public: {Sekcja publiczna � domyślna dla struct i union}
( ( ( składowe publiczne są widoczne w obszarze
całego pliku
} ;
Przykład definicji klasy:

class PUNKT
{
private:
int x, y;
protected:
unsigned kolor;
public:
void USTAL_WSP( int wsp_x, int wsp_y );
void USTAL_KOLOR( unsigned kol )
{
kolor = kol; // PUNKT::kolor = kol;
}
void RYSUJ( void );
} ;

void PUNKT::USTAL_WSP( int wsp_x, int wsp_y )
{ // definicja funkcji - metody klasy PUNKT
x = wsp_x; // PUNKT::x = wsp_x;
y = wsp_y; // PUNKT::y = wsp_y;
}

. . . // uwaga tu powinna być definicja metody RYSUJ
--------------------------------------------------------------------------------------------
// utworzenie zmiennej prostej, struktury i obiektu
int wzrost ;
struct PUNKT_1 punkt_1 ;
class PUNKT punkt ;

wzrost = 10; // operacje na zmiennej prostej
wzrost = wzrost + 1;

punkt_1.x = 10 ; // operacje na strukturze
punkt_1.y = 20 ;
RYSUJ_PUNKT( punkt_1, WHITE );

punkt.x = 10 ;
punkt.USTAL_WSP( 10, 20 ); // operacje na obiekcie
punkt.USTAL_KOLOR( WHITE );
punkt.RYSUJ( );
Oprócz zwykłych funkcji składowych istnieją dwie specjalne funkcje:
* KONSTRUKTOR funkcja wywoływana w momencie tworzenia obiektu
� służy do inicjacji danych obiektu,
� nazwa taka sama jak nazwa klasy,
� nie wolno określać typu zwracanej wartości,
� nie może być wywoływany tak jak normalne funkcje.

Inicjacja danych poprzez przypisanie w "ciele" konstruktora:
PUNKT( void )
{
x = 0; y = 0; kolor = WHITE;
}

Inicjacja danych poprzez listę inicjacyjną:
PUNKT( void ) : x(0), y(0), kolor(WHITE)
{
}

Inicjacja danych poprzez konstruktor z parametrami:

PUNKT( int wsp_x, int wsp_y, int kol ) : x(wsp_x), y(wsp_y), kolor(kol)
{ }

// tworzenie obiektu za pomocą domyślnego konstruktora (bezparametrowego)
PUNKT punkt, a, b;

// tworzenie obiektu za pomocą zdefiniowanego konstruktora
PUNKT punkt_2( 10, 20, WHITE ), c( -7, 4, YELLOW) ;


Konstrukcja podobiektów:
class ODCINEK
{
PUNKT pocz, kon;
public:
ODCINEK( int x0, int y0, int x1, int y1) : pocz( x0,y0), kon(x1,y1)
{ }

. . .

}
* DESTRUKTOR - funkcja wywoływana niejawnie przed usunięciem obiektu (służy do "posprzątania", np. do zwolnienia pamięci)
� nazwa: taka jak nazwa klasy poprzedzona znakiem tyldy: ~
� nie wolno określać typu zwracanej wartości;

class CIAG_BAJTOW
{
char( dane_obiektu; // wskaźnik pamięci
public:
CIAG_BAJTOW( void ) // konstruktor
{
dane_obiektu = new char[100]; // przydzielenie pamięci
}

~ CIAG_BAJTOW( void ) // destruktor
{
delete dane_obiektu; // zwolnienie pamięci
}
} ;


Funkcje i klasy zaprzyjaźnione
Ukrywanie danych ( hermetyzacja ( kapsułkowanie ( ang. encapsulation (
poprzez zdefiniowanie danych obiektu w sekcji private lub protected .

Aby zezwolić funkcji zdefiniowanej poza klasą na dostęp do jej składowych prywatnych i zabezpieczonych trzeba zadeklarować relację przyjaźni (friend)

class CIAG_BAJTOW
{
char( dane_obiektu; i
friend void WYSWIETL( CIAG_BAJTOW & cb ); (
public:
CIAG_BAJTOW( void );
~ CIAG_BAJTOW( void );
} ;

void WYSWIETL( CIAG_BAJTOW & cb ) // funkcja zaprzyjaźniona
{
printf( "Zawartość obiektu: %s" , cb.dane_obiektu );
}
#include // #include
class TABLICA
{
int (t ;
int rozmiar ;
public:
TABLICA( int il_elem ) ;
~TABLICA( void ) ;
void WSTAW( int pozycja, int wartosc ) ;
int POBIERZ( int pozycja ) ;
} ; //-------------------------------------------------------------------------- class TABLICA

TABLICA::TABLICA( int il_elem )
{
rozmiar = 0; t = NULL;
if( il_elem<1 ) return;
if( t = new int[ il_elem ] ) // if( t = (int*)calloc(il_elem,sizeof(int)) )
{ rozmiar = il_elem;
for( int i=0; i t[ i ]=0;
}
} //------------------------------------------------------------------------------------ TABLICA

TABLICA::~TABLICA( void )
{
if( t ) delete t ; // if( t ) free(t) ;
} //----------------------------------------------------------------------------------- ~TABLICA

void TABLICA::WSTAW( int pozycja, int wartosc )
{
if( pozycja>=0 && pozycja t[ pozycja ] = wartosc;
} //----------------------------------------------------------------------- TABLICA::WSTAW

int TABLICA::POBIERZ( int pozycja )
{
if( pozycja>=0 && pozycja return t[ pozycja ] ;
else
return 0 ;
} //---------------------------------------------------------------------- TABLICA::POBIERZ

void main( void )
{
TABLICA tab(10);
tab.WSTAW(3,15);
int wynik = tab.POBIERZ(3);
}




Marek Piasecki (Cpp01) ( 1 ( "ProgramowanieObiektowe."

Dr Marek Piasecki "Programowanie obiektowe w C++" (Cpp01)

M.P. "Prog.Obiekt." (Cpp01) ( 2 ( Wstęp

M.P. "Prog.Obiekt." (Cpp01) ( 4 ( Definiowanie klas

Przykład klasy � jednowymiarowa tablica N liczb int