Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne statyczne
Hermetyzacja oraz pola i metody statyczne
Bogdan Kreczmer
[e-mail]
Zakład Podstaw Cybernetyki i Robotyki
Instytut Informatyki, Automatyki i Robotyki
Politechnika Wrocławska
Kurs: Programowanie obiektowe
Copyright©2010 Bogdan Kreczmer
Niniejszy dokument zawiera materiały do wykładu dotyczącego programowania obiektowego. Jest on
udostępniony pod warunkiem wykorzystania wyłącznie do własnych prywatnych potrzeb i może on być kopiowany
wyłącznie w całości, razem z niniejszą stroną tytułową.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne statyczne
Niniejsza prezentacja została wykonana przy użyciu sys-
A
temu składu LTEX oraz stylubeamer, którego autorem
jest Till Tantau.
Strona domowa projektuBeamer:
http://latex-beamer.sourceforge.net
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne statyczne
1
Struktury danych w języku C++
class, struct, union
2
Zachowanie spójności danych poprzez hermetyzację
Niebezpieczeństwa struktur bez kontroli dostępu
Redukcja możliwych błędów poprzez metody
Redukcja możliwych błędów poprzez kontrolę dostępu
Zalety hermetyzacji
3
Inne sposoby zapobiegania błędom
Hamowanie propagacji błędu
4
Zmienne statyczne
Zmienne globalne versus zmienne statyczne
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Podstawowe własności
W języku C++ istnieją trzy rodzaje definicji struktur złożonych rozpoczynających
się od słów kluczowych: class , struct , union . Dwie pierwsze definiują klasę.
Jednak nie każda z nich może zawierać wszystkie dostępne własności klasy. Poprzez
union definiowana jest struktura specjalna (analogicznie jak w języku C).
class NazwaKlasy { struct NazwaKlasy { union NazwaKlasy {
// Domyślnie prywatna // Domyślnie publiczna // Domyślnie publiczna
. . . . . . . . .
protected: private: private:
. . . . . . . . .
private: protected: protected:
. . . . . . . . .
public: public: public:
. . . . . . . . .
}; }; };
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Tryby dostępu
Sekcje private, protected, public; definiują tryb dostępu do poszczególnych elementów
sekcji w niej zawartych, tzn. pól i metod (w tym również konstruktora i destruktora).
Ich porządek występowania w definicji nie jest ustalony. Mogą występować wielokrotnie
i wzajemnie się przeplatać. końcu public.
private  dostęp i bezpośrednie odwołanie się do
class NazwaKlasy {
pól i metod tej sekcji możliwy jest tylko z po-
// Domyślnie prywatna
ziomu metod klasy, w której deklarowane i de-
. . .
finiowane sÄ… te pola i metody.
protected:
. . .
protected  dostęp i bezpośrednie odwołanie się do
private:
pól i metod tej sekcji możliwy jest z poziomu
. . .
metod klasy, w której deklarowane i definiowa-
public:
ne są te pola i metody. Odwołanie się i bez-
. . .
pośredni dostęp możliwy jest również w klasie
private:
pochodnej.
. . .
public  nie ma żadnego ograniczenia na dostęp do
};
pól i metod z tej sekcji.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Definicja klasy z wykorzystaniem słowa kluczowego class
class NazwaKlasy {
class  definiuje klasę, która może posia- //Domyślnie prywatna
. . .
dać wszystkie możliwe atrybuty klasy
protected:
dostępne w języku C++, tzn. może po-
. . .
siadać metody, konstruktory, destruk-
private:
tory, metody wirtualne, pola i metody
. . .
statyczne itd. Pozwala na dziedziczenie
public:
innych struktur i sama może być dzie- . . .
};
dziczona. Oprócz tego klasę definiowa-
ną poprzez class można parametryzo-
Przykład definicji:
wać tworząc w ten sposób szablony.
class LZepolona {
Domyślną sekcją w definicji klasy jest
float re, im;
zawsze sekcja private.
public:
float Re( ) const { return re; }
float Im( ) const { return im; }
void Zmien(float r, float i);
};
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Definicja klasy z wykorzystaniem słowa kluczowego struct
struct NazwaKlasy {
struct  definiuje klasę, która może posia- //Domyślnie publiczna
. . .
dać prawie wszystkie możliwe atrybuty
protected:
klasy dostępne w języku C++, tzn. mo-
. . .
że posiadać metody, konstruktory, de-
private:
struktory, metody wirtualne, pola i me-
. . .
tody statyczne itd. Pozwala na dziedzi- public:
czenie innych struktur i sama może być . . .
};
dziedziczona. Jedyne ograniczenie po-
lega na tym, że definiowaną w ten spo-
Przykład definicji:
sób klasę nie można parametryzować,
struct LZepolona {
tzn. za jej pomocą nie można tworzyć
float Re( ) const { return re; }
szablonów.
float Im( ) const { return im; }
Domyślną sekcją w definicji klasy jest
void Zmien(float r, float i);
zawsze sekcja public.
private:
float re, im;
};
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Definicja klasy z wykorzystaniem słowa kluczowego union
union NazwaKlasy {
union  definiuje strukturę, w której każde //Domyślnie publiczna
. . .
pole ma ten sam adres. Unia może mieć
protected:
pola i metody. Nie może mieć nato-
. . .
miast zarówno pól statycznych, jak też
private:
metod statycznych. Nie może również
. . .
posiadać konstruktorów oraz destruk-
public:
tora. Struktura zdefiniowana przez uniÄ™ . . .
};
może być dziedziczona, ale nie może
dziedziczyć innych struktur. Unia nie
Przykład definicji:
może też posiadać metod wirtualnych.
union Wartosc {
Domyślną sekcją w definicji klasy jest
int Absolutna;
zawsze sekcja public.
float Wzgledna;
};
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
double Tab[2][2];
public :
double Wez( int i, int j ) const { return Tab[i][j]; }
void Zmien( double elem, int i, int j ) { Tab[ i ][ j ] = elem; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Wyznacznik( const Macierz2x2 &M )
{
return M. Tab[0][0]"M. Tab[1][1]  M. Tab[0][1]"M. Tab[1][0];
}
Czy jest to poprawne (i dlaczego nie ;-) ?
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
double Tab[2][2];
public :
double Wez( int i, int j ) const { return Tab[i][j]; }
void Zmien( double elem, int i, int j ) { Tab[ i ][ j ] = elem; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Wyznacznik( const Macierz2x2 &M )



{





return M. Tab[0][0]"M.

Tab[1][1] Tab[0][1]"M.
 M.
Tab[1][0];
}
Poza definicjami metod danej klasy nie można odwoływać się wprost do elementów
tej klasy, które znajdują się w sekcji prywatnej. Z tego powodu odwołanie się do
pola TabobiektuMw funkcjiWyznacznikjest niedopuszczalne.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
protected :
double Tab[2][2];
public :
double Wez( int i, int j ) const { return Tab[i][j]; }
void Zmien( double elem, int i, int j ) { Tab[ i ][ j ] = elem; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Wyznacznik( const Macierz2x2 &M )



{


ab[0][1]"M.
return T M. T


M. ab[0][0]"M. Tab[1][1]  T
ab[1][0];
}
Jeżeli pole zadeklarowane jest w sekcji protected, to bezpośredni dostęp do tego
pola poza metodami klasy jest również niemożliwy. Różnice między sekcją public,
a protected pojawiają się dopiero przy dziedziczeniu. Dla pojedynczej klasy, która
nie jest dziedziczona, sekcje te majÄ… takie samo znaczenie.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
double Tab[2][2];
public :
double Wez( int i, int j ) const { return Tab[i][j]; }
void Zmien( double elem, int i, int j ) { Tab[ i ][ j ] = elem; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Wyznacznik( const Macierz2x2 &M )
{
return M.Wez(0,0)"M.Wez(1,1)  M.Wez(0,1)"M.Wez(1,0);
}
W sekcji publicznej zdefiniowany jest interfejs do pól klasy Macierz2x2. Pozwala
to zachować kontrolę nad sposobem dostępu do tych pól oraz sposobem ich
udostępniania. Pozwala to również udostępnić tylko te pola, które chcemy
udostępnić.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
friend float Wyznacznik( const Macierz2x2 &M );
double Tab[2][2];
public :
double Wez( int i, int j ) const { return Tab[i][j]; }
void Zmien( double elem, int i, int j ) { Tab[ i ][ j ] = elem; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Wyznacznik( const Macierz2x2 &M )
{
return M. Tab[0][0]"M. Tab[1][1]  M. Tab[0][1]"M. Tab[1][0];
}
Pomimo ograniczenia dostępu do pola Tabmożna uczynić wyjątek dla wybranych
funkcji. Pozwala na to deklaracja funkcji zaprzyjaz
nionych z danÄ… klasÄ…. Musi ona
znalez
ć się w obrębie definicji klasy. Miejsce wystąpienia nie jest istotne.
Zwyczajowo jednak jest to poczÄ…tek definicji klasy.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float Tab[2][2];
float Elem[3][3];
public :
float Wez(int i, int j) const public :
{ return Tab[i][j]; } float Wez(int i, int j) const
{ return Elem[i][j]; }
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Zmien(float elem, int i, int j);
void Wstaw(Macierz2x2 M);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz3x3::Wstaw( Macierz2x2 M2 )
{
Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[0][1];
Elem[1][0] = M2. Tab[1][0]; Elem[1][1] = M2. Tab[1][1];
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float Tab[2][2];
float Elem[3][3];
public :
float Wez(int i, int j) const public :
{ return Tab[i][j]; } float Wez(int i, int j) const
{ return Elem[i][j]; }
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Zmien(float elem, int i, int j);
void Wstaw(Macierz2x2 M);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz3x3::Wstaw( Macierz2x2 M2 )
{
Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[0][1];
Elem[1][0] = M2. Tab[1][0]; Elem[1][1] = M2. Tab[1][1];
}
Ze względu na podobieństwo klas tu jest wszystko poprawnie. Czyż nie?
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float Tab[2][2];
float Elem[3][3];
public :
float Wez(int i, int j) const public :
{ return Tab[i][j]; } float Wez(int i, int j) const
{ return Elem[i][j]; }
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Zmien(float elem, int i, int j);
void Wstaw(Macierz2x2 M);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz3x3::Wstaw( Macierz2x2 M2 )
{




Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[0][1];








Elem[1][0] = M2. Tab[1][0]; Elem[1][1] = M2. Tab[1][1];




}
Podobieństwo tych klas ma charakter subiektywny. Dla kompilatora to są tak samo
różne klasy jak każde inne. Dostęp do pól prywatnych danej klasy nie jest możliwy
na poziomie zarówno funkcji jak też metody innej klasy.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
friend void Macierz3x3::Wstaw(Macierz2x2);
float Elem[3][3];
float Tab[2][2];
public :
public :
float Wez(int i, int j) const
float Wez(int i, int j) const
{ return Elem[i][j]; }
{ return Tab[i][j]; }
void Zmien(float elem, int i, int j);
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Wstaw(Macierz2x2 M);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz3x3::Wstaw( Macierz2x2 M2 )
{
Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[0][1];
Elem[1][0] = M2. Tab[1][0]; Elem[1][1] = M2. Tab[1][1];
}
Dostęp do pól prywatnych staje się możliwy, gdy  zaprzyjaz
nimy danÄ… metodÄ™ z
klasą, do której pól prywatnych metody tej klasy mają uzyskać dostęp.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . class Macierz3x3 { // . . . . . . . . . . . . . . . . . . . . . . .
friend void Macierz3x3::Wstaw(Macierz2x2);
float Elem[3][3];
float Tab[2][2];
public :
public :
float Wez(int i, int j) const
float Wez(int i, int j) const
{ return Elem[i][j]; }
{ return Tab[i][j]; }
void Zmien(float elem, int i, int j);
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Wstaw(Macierz2x2 M);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz3x3::Wstaw( Macierz2x2 M2 )
{
Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[0][1];
Elem[1][0] = M2. Tab[1][0]; Elem[1][1] = M2. Tab[1][1];
}
Zaprzyjaz
nienie jednej
metody nie rozwiÄ…zuje
void Macierz3x3::WstawTrans( Macierz2x2 M2 )
problemu dostępu do pól
{




prywatnych na poziomie Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[1][0];








innej metody tej samej Elem[1][0] = M2. Tab[0][1]; Elem[1][1] = M2. Tab[1][1];




}
klasy.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . class Macierz3x3 { // . . . . . . . . . . . . . . . . . . . . . . .
friend class Macierz3x3;
float Elem[3][3];
float Tab[2][2]; public :
public :
float Wez(int i, int j) const
float Wez(int i, int j) const
{ return Tab[i][j]; }
{ return Elem[i][j]; }
void Zmien(float elem, int i, int j);
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Wstaw(Macierz2x2 M);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz3x3::Wstaw( Macierz2x2 M2 )
{
Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[0][1];
Elem[1][0] = M2. Tab[1][0]; Elem[1][1] = M2. Tab[1][1];
}
Zaprzyjaz
nienie całej klasy
pozwala odwoływać się do
void Macierz3x3::WstawTrans( Macierz2x2 M2 )
pól prywatnych na
{
poziomie metod klasy Elem[0][0] = M2. Tab[0][0]; Elem[0][1] = M2. Tab[1][0];
zaprzyjaz
nionej. Elem[1][0] = M2. Tab[0][1]; Elem[1][1] = M2. Tab[1][1];
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float Tab[2][2];
float Elem[3][3];
public :
float Wez(int i, int j) const public :
{ return Tab[i][j]; } float Wez(int i, int j) const
{ return Elem[i][j]; }
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Zmien(float elem, int i, int j);
void Wstaw(Macierz2x2 M);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz3x3::Wstaw( Macierz2x2 M2 )
{
Elem[0][0] = M2.Wez(0,0); Elem[0][1] = M2.Wez(0,1);
Elem[1][0] = M2.Wez(1,0); Elem[1][1] = M2.Wez(1,1);
}
Zaprzyjaz
nienie z klasą jest ostatecznością. O ile tylko jest to możliwe należy
korzystać z metod wchodzących w skład interfejsu danej klasy.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pojęcie prywatności
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[2][2];
public :
float Wez( int i, int j ) const { return Tab[i][j]; }
void Zmien( float elem, int i, int j );
void Wstaw( Macierz2x2 M );
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz2x2::Wstaw( Macierz2x2 M )
{
Tab[0][0] = M. Tab[0][0]; Tab[0][1] = M. Tab[0][1];
Tab[1][0] = M. Tab[1][0]; Tab[1][1] = M. Tab[1][1];
}
Czy można na poziomie metody danej klasy odwoływać się do pól prywatnych
obiektu tej samej klasy?
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
class, struct, union
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pojęcie prywatności
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Tab[2][2];
public :
float Wez( int i, int j ) const { return Tab[i][j]; }
void Zmien( float elem, int i, int j );
void Wstaw( Macierz2x2 M );
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
void Macierz2x2::Wstaw( Macierz2x2 M )
{
Tab[0][0] = M. Tab[0][0]; Tab[0][1] = M. Tab[0][1];
Tab[1][0] = M. Tab[1][0]; Tab[1][1] = M. Tab[1][1];
}
Prywatność nie jest cechą obiektu. Jest to cecha klasy.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Potencjalne możliwości błędów
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Potencjalne możliwości błędów
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Stos St;
float Arg;
. . .
if (St. Ilosc>= ROZ STOSU) { /" Obsługa błędu "/ }
St. TabStosu[St. Ilosc++] = 12.3;
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Potencjalne możliwości błędów
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Stos St;
float Arg;
. . .
if (St. Ilosc>= ROZ STOSU) { /" Obsługa błędu "/ }
St. TabStosu[St. Ilosc] = 12.3;
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Potencjalne możliwości błędów
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Stos St;
float Arg;
. . .
if (St. Ilosc<= 0) { /" Obsługa błędu "/ }
Arg = St. TabStosu[--St. Ilosc];
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Potencjalne możliwości błędów
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
Stos St;
float Arg;
. . .
if (St. Ilosc<= 0) { /" Obsługa błędu "/ }
Arg = St. TabStosu[-St. Ilosc];
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
float Pobierz( );
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
float Pobierz( );
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
return TabStosu[-- Ilosc];
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
float Pobierz( );
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
if ( Ilosc<= 0) return numeric limits::max( );
return TabStosu[-- Ilosc];
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
#include
using namespace std;
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
float Pobierz( );
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
if ( Ilosc<= 0) return numeric limits::max( );
return TabStosu[-- Ilosc];
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
Stos( ) { Ilosc = 0; }
float Pobierz( );
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
if ( Ilosc<= 0) return numeric limits::max( );
return TabStosu[-- Ilosc];
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
if ( Ilosc<= 0) return numeric limits::max( );
return TabStosu[-- Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz( );
if (Arg == numeric limits::max()) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
if ( Ilosc<= 0) return numeric limits::max( );
return TabStosu[-- Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz( );
if (Arg == numeric limits::max()) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz(bool & Sukces )
{
if ( Ilosc<= 0) { Sukces = false; return numeric limits::max( ); }
return Sukces = true, TabStosu[-- Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz(CzySukces);
if (CzySukces) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz(bool & Sukces )
{
if ( Ilosc<= 0) { Sukces = false; return numeric limits::max( ); }
return Sukces = true, TabStosu[-- Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz(CzySukces);
if (CzySukces) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz(bool & Sukces )
{
if ( Ilosc<= 0) { Sukces = false; return numeric limits::max( ); }
return Sukces = true, TabStosu[-- Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz(CzySukces);
if (CzySukces) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Stos::Pobierz(float & ZeStosu )
{
if ( Ilosc<= 0) return false;
return ZeStosu = TabStosu[-- Ilosc], true;
}
int main( )
{
. . .
Arg = St.Pobierz(CzySukces);
if (CzySukces) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Stos::Pobierz(float & ZeStosu )
{
if ( Ilosc<= 0) return false;
return ZeStosu = TabStosu[-- Ilosc], true;
}
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Stos::Pobierz(float & ZeStosu )
{
if ( Ilosc<= 0) return false;
return ZeStosu = TabStosu[-- Ilosc], true;
}
Czy takie rozwiązanie pozwala w pełni zabezpieczyć się przed
int main( )
błędnym pobraniem wartości ze stosu?
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Stos::Pobierz(float & ZeStosu )
{
if ( Ilosc<= 0 || ROZ STOSU< Ilosc) return false;
return ZeStosu = TabStosu[-- Ilosc], true;
}
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Stos::Pobierz(float & ZeStosu )
{
if ( Ilosc<= 0 || ROZ STOSU< Ilosc) return false;
return ZeStosu = TabStosu[-- Ilosc], true;
}
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
. . .
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Stos::Pobierz(float & ZeStosu )
{
if (! Ilosc || ROZ STOSU< Ilosc) return false;
return ZeStosu = TabStosu[-- Ilosc], true;
}
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
bool Pobierz(float& ZeStosu);
bool Poloz(float NaStos);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
bool Pobierz(float& ZeStosu);
bool Poloz(float NaStos);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
St. TabStosu[3] = 5;
--St. Ilosc;
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Pobierz(float& ZeStosu);
bool Poloz(float NaStos);
private:
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
St. TabStosu[3] = 5;
--St. Ilosc;
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Pobierz(float& ZeStosu);
bool Poloz(float NaStos);
private:
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }


St. TabStosu[3] = 5;



--St.
Ilosc;


. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Pobierz(float& ZeStosu);
bool Poloz(float NaStos);
private:
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Pobierz(float& ZeStosu);
bool Poloz(float NaStos);
unsigned int Ilosc( ) { return Ilosc; }
private:
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
bool Pobierz(float& ZeStosu);
bool Poloz(float NaStos);
unsigned int Ilosc( ) const { return Ilosc; }
private:
float TabStosu[ROZ STOSU];
unsigned int Ilosc;
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . .
int main( )
{
. . .
if (St.Pobierz(Arg)) { /" Obsługa błędu "/ }
. . .
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Reprezentacja liczby zespolonej
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float re, im;
public :
float Re( ) const { return re; }
float Im( ) const { return im; }
float Modul( ) const { return re" re + im" im; }
void ZmienRI( float re, float im) { re = re; im = im; }
void ZmienMA( float m, float alfa) { re = m"cos(alfa); im = m"sin(alfa); }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z;
Z.ZmienRI(2,5);
cout<< Modul:  <}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Reprezentacja liczby zespolonej
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float re, im;
public :
float Re( ) const { return re; }
float Im( ) const { return im; }
float Modul( ) const { return re" re + im" im; }
void ZmienRI( float re, float im) { re = re; im = im; }
void ZmienMA( float m, float alfa) { re = m"cos(alfa); im = m"sin(alfa); }
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main( )
{
LZespolona Z;
Z.ZmienRI(2,5);
cout<< Modul:  <}
Bezpośrednia reprezentacja części rzeczywistej i urojonej ułatwia implementację
operacji dodawania i odejmowania dwóch liczb. Jednak jednocześnie utrudnia
realizację operacji mnożenia, dzielenia i wyznaczania modułu.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Reprezentacja liczby zespolonej
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float m, alfa; // Kąt wyrażony w radianach
public :
float Re( ) const { return m"cos( alfa); }
float Im( ) const { return m"sin( alfa); }
float Modul( ) const { return m; }
void ZmienRI( float re, float im) { m = sqrt(re"re+im"im); alfa = atan2(im,re);}
void ZmienMA( float m, float alfa) { m = m; alfa = alfa;}
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main()
{
LZespolona Z;
Z.ZmienRI(2,5);
cout<< Modul:  <}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Reprezentacja liczby zespolonej
class LZespolona { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float m, alfa; // Kąt wyrażony w radianach
public :
float Re( ) const { return m"cos( alfa); }
float Im( ) const { return m"sin( alfa); }
float Modul( ) const { return m; }
void ZmienRI( float re, float im) { m = sqrt(re"re+im"im); alfa = atan2(im,re);}
void ZmienMA( float m, float alfa) { m = m; alfa = alfa;}
}; //. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int main()
{
LZespolona Z;
Z.ZmienRI(2,5);
cout<< Modul:  <}
Reprezentacja trygonometryczna liczby zespolonej ułatwia implementację
operacji mnożenia, dzielenia oraz wyznaczania modułu. Mimo istotnej zmiany
wewnętrznej reprezentacji liczby zespolonej na zewnątrz nic się nie zmieniło.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Podsumowanie: Ważniejsze cechy i własności
Hermetyzacja pozwala ukryć wewnętrzne cechy
implementacji danej klasy.
Daje możliwość wydzielenia tej części interfejsu, która
realizuje modyfikację obiektu oraz tej, która służy do
odczytu stanu obiektu.
Umożliwia zdefiniowanie interfejsu, który określa sposób
manipulowania wewnętrznymi strukturami obiektu.
Pozwala to na zapewnienie spójności wewnętrznych
struktur danych.
Zapobiega przypadkowej ingerencji w wewnętrzną
strukturę obiektu, która mogłaby spowodować utratę
spójność przechowywanych danych w obiekcie.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Podsumowanie: Ważniejsze cechy i własności
Hermetyzacja pozwala ukryć wewnętrzne cechy
implementacji danej klasy.
Daje możliwość wydzielenia tej części interfejsu, która
realizuje modyfikację obiektu oraz tej, która służy do
odczytu stanu obiektu.
Umożliwia zdefiniowanie interfejsu, który określa sposób
manipulowania wewnętrznymi strukturami obiektu.
Pozwala to na zapewnienie spójności wewnętrznych
struktur danych.
Zapobiega przypadkowej ingerencji w wewnętrzną
strukturę obiektu, która mogłaby spowodować utratę
spójność przechowywanych danych w obiekcie.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Podsumowanie: Ważniejsze cechy i własności
Hermetyzacja pozwala ukryć wewnętrzne cechy
implementacji danej klasy.
Daje możliwość wydzielenia tej części interfejsu, która
realizuje modyfikację obiektu oraz tej, która służy do
odczytu stanu obiektu.
Umożliwia zdefiniowanie interfejsu, który określa sposób
manipulowania wewnętrznymi strukturami obiektu.
Pozwala to na zapewnienie spójności wewnętrznych
struktur danych.
Zapobiega przypadkowej ingerencji w wewnętrzną
strukturę obiektu, która mogłaby spowodować utratę
spójność przechowywanych danych w obiekcie.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Podsumowanie: Ważniejsze cechy i własności
Hermetyzacja pozwala ukryć wewnętrzne cechy
implementacji danej klasy.
Daje możliwość wydzielenia tej części interfejsu, która
realizuje modyfikację obiektu oraz tej, która służy do
odczytu stanu obiektu.
Umożliwia zdefiniowanie interfejsu, który określa sposób
manipulowania wewnętrznymi strukturami obiektu.
Pozwala to na zapewnienie spójności wewnętrznych
struktur danych.
Zapobiega przypadkowej ingerencji w wewnętrzną
strukturę obiektu, która mogłaby spowodować utratę
spójność przechowywanych danych w obiekcie.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++ Niebezpieczeństwa struktur bez kontroli dostępu
Zachowanie spójności danych poprzez hermetyzację Redukcja możliwych błędów poprzez metody
Inne sposoby zapobiegania błędom Redukcja możliwych błędów poprzez kontrolę dostępu
Zmienne statyczne Zalety hermetyzacji
Przykład zastosowania stosu - kalkulator RPN
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Hamowanie propagacji błędu
Inne sposoby zapobiegania błędom
Zmienne statyczne
Formułowanie warunków
Licznik = 0;
do {
. . .
++Licznik;
. . .
. . .
. . .
} while (Licznik != MAKS ILOSC);
. . .
if (Licznik == MAKS ILOSC) cerr<<  Blad << endl;
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Hamowanie propagacji błędu
Inne sposoby zapobiegania błędom
Zmienne statyczne
Formułowanie warunków
Licznik = 0;
do {
. . .
++Licznik;
. . .
if ( JakisWarunek ) ++Licznik;
. . .
} while (Licznik != MAKS ILOSC);
. . .
if (Licznik == MAKS ILOSC) cerr<<  Blad << endl;
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Hamowanie propagacji błędu
Inne sposoby zapobiegania błędom
Zmienne statyczne
Formułowanie warunków
Licznik = 0;
do {
. . .
++Licznik;
. . .
if ( JakisWarunek ) ++Licznik;
. . .
} while (Licznik != MAKS ILOSC);
. . .
if (Licznik == MAKS ILOSC) cerr<<  Blad << endl;
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Hamowanie propagacji błędu
Inne sposoby zapobiegania błędom
Zmienne statyczne
Formułowanie warunków
Licznik = 0;
do {
. . .
++Licznik;
. . .
if ( JakisWarunek ) ++Licznik;
. . .
} while (Licznik < MAKS ILOSC);
. . .
if (Licznik >= MAKS ILOSC) cerr<<  Blad << endl;
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne globalne
#include
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf( Pakiet nr: %i\n ,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
· · ·
WyslijPakiet( );
return 0;
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne globalne
#include
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf( Pakiet nr: %i\n ,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
Pakiet nr: 1
· · ·
Pakiet nr: 2
WyslijPakiet( ); Pakiet nr: 3
return 0;
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne globalne
#include
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf( Pakiet nr: %i\n ,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
Pakiet nr: 1
· · ·
Pakiet nr: 2
WyslijPakiet( ); Pakiet nr: 11
return 0;
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne globalne
#include
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf( Pakiet nr: %i\n ,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
Pakiet nr: 1
IloscPakietow = 10;
Pakiet nr: 2
WyslijPakiet( ); Pakiet nr: 11
return 0;
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne lokalne
#include
void WyslijPakiet( )
{
int IloscPakietow = 0;
. . .
printf( Pakiet nr: %i\n ,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );




IloscPakietow 10;
=



?
WyslijPakiet( );
return 0;
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne lokalne
#include
void WyslijPakiet( )
{
int IloscPakietow = 0;
. . .
printf( Pakiet nr: %i\n ,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
Pakiet nr: 1




IloscPakietow 10;
=
Pakiet nr: 1



WyslijPakiet( ); Pakiet nr: 1
return 0;
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne statyczne
#include
void WyslijPakiet( )
{
static int IloscPakietow = 0;
. . .
printf( Pakiet nr: %i\n ,++IloscPakietow);
}
Zmienne statyczne w języku C pełnią rolę zmiennych
globalnych z ograniczonym zakresem dostępu tylko do
int main( )
poziomu funkcji, w której są deklarowane.
{
WyslijPakiet( );
WyslijPakiet( );
Pakiet nr: 1




IloscPakietow 10;
=
Pakiet nr: 2



WyslijPakiet( ); Pakiet nr: 3
return 0;
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Zmienne statyczne
#include
void WyslijPakiet( )
{
static int IloscPakietow = 0;
. . .
std::cout<< Pakiet nr:  <<++IloscPakietow<}
Identyczne znaczenie mają również w języku C++ .
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
Pakiet nr: 1




IloscPakietow 10;
=
Pakiet nr: 2



WyslijPakiet( ); Pakiet nr: 3
}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static int IloscLacz;
LaczeSieciowe( ) { ++ IloscLacz; }
<"
LaczeSieciowe( ) { -- IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz = 0;
int main( )
{
cout<}
Pole statyczne pełni rolę zmiennej globalnej w ramach danej klasy. Istnieje tylko
w jednym egzemplarzu niezależnie od wszystkich obiektów.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static int IloscLacz;
LaczeSieciowe( ) { ++ IloscLacz; }
<"
LaczeSieciowe( ) { -- IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz = 0;
int main( )
{
cout<}
Musi być zadeklarowane oraz zainicjalizowane poza klasą w przestrzeni
zmiennych globalnych. Określony zostaje w ten sposób moment jego utworzenia.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static int IloscLacz;
LaczeSieciowe( ) { ++ IloscLacz; }
<"
LaczeSieciowe( ) { -- IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
cout<}
Czy brak inicjalizacji oznacza wartość przypadkową?
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static int IloscLacz;
LaczeSieciowe( ) { ++ IloscLacz; }
<"
LaczeSieciowe( ) { -- IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
cout<}
Pola statyczne typów wbudowanych zawsze inicjalizowane są wartością 0.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static int IloscLacz;
LaczeSieciowe( ) { ++ IloscLacz; }
<"
LaczeSieciowe( ) { -- IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
cout<}
Do pola statycznego można odwoływać się bez konieczności tworzenia obiektu,
gdyż jest ono własnością klasy, a nie obiektu.
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static int IloscLacz;
LaczeSieciowe( ) { ++ IloscLacz; }
<"
LaczeSieciowe( ) { -- IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
Dlatego też każdy z tych trzech sposobów
odwołania się do pola IloscLaczjest
int main( )
odwołaniem się do tego samego obszaru
{
pamięci.
LaczeSieciowe Lacze1, Lacze2;
cout<cout<cout<}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Zmienne globalne versus zmienne statyczne
Inne sposoby zapobiegania błędom
Zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static int IloscLacz;
LaczeSieciowe( ) { ++ IloscLacz; }
<"
LaczeSieciowe( ) { -- IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
Aby móc odwołać się do pola
statycznego, nie musi istnieć żaden
int main( )
obiekt. Pola statyczne istnieją niezależnie
{
od poszczególnych obiektów.
cout<}
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne
Struktury danych w języku C++
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne statyczne
Koniec prezentacji
Programowanie obiektowe Hermetyzacja oraz pola i metody statyczne