Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Hermetyzacja oraz pola i metody statyczne
Bogdan Kreczmer
bogdan.kreczmer@pwr.wroc.pl
Zakład Podstaw Cybernetyki i Robotyki
Instytut Informatyki, Automatyki i Robotyki
Politechnika Wrocławska
Kurs: Programowanie obiektowe
Copyright c
°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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Niniejsza prezentacja została wykonana przy użyciu sys-
temu składu L
A
TEX oraz stylu beamer, którego autorem
jest Till Tantau.
Strona domowa projektu Beamer:
http://latex-beamer.sourceforge.net
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
1
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
4
Zmienne globalne versus zmienne statyczne
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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 {
// Domyślnie prywatna
. . .
protected:
. . .
private:
. . .
public:
. . .
};
struct NazwaKlasy {
// Domyślnie publiczna
. . .
private:
. . .
protected:
. . .
public:
. . .
};
union NazwaKlasy {
// Domyślnie publiczna
. . .
private:
. . .
protected:
. . .
public:
. . .
};
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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.
class NazwaKlasy {
// Domyślnie prywatna
. . .
protected:
. . .
private:
. . .
public:
. . .
private:
. . .
};
private – dostęp i bezpośrednie odwołanie się do
pól i metod tej sekcji możliwy jest tylko z po-
ziomu metod klasy, w której deklarowane i de-
finiowane są te pola i metody.
protected – dostęp i bezpośrednie odwołanie się do
pól i metod tej sekcji możliwy jest z poziomu
metod klasy, w której deklarowane i definiowa-
ne są te pola i metody. Odwołanie się i bez-
pośredni dostęp możliwy jest również w klasie
pochodnej.
public – nie ma żadnego ograniczenia na dostęp do
pól i metod z tej sekcji.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Definicja klasy z wykorzystaniem słowa kluczowego class
class
– definiuje klasę, która może posia-
dać wszystkie możliwe atrybuty klasy
dostępne w języku C++, tzn. może po-
siadać metody, konstruktory, destruk-
tory, metody wirtualne, pola i metody
statyczne itd. Pozwala na dziedziczenie
innych struktur i sama może być dzie-
dziczona. Oprócz tego klasę definiowa-
ną poprzez class można parametryzo-
wać tworząc w ten sposób szablony.
Domyślną sekcją w definicji klasy jest
zawsze sekcja private.
class NazwaKlasy {
//Domyślnie prywatna
. . .
protected:
. . .
private:
. . .
public:
. . .
};
Przykład definicji:
class LZepolona {
float re, im;
public:
float Re( ) const { return
re; }
float Im( ) const { return
im; }
void Zmien(float r, float i);
};
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Definicja klasy z wykorzystaniem słowa kluczowego struct
struct
– definiuje klasę, która może posia-
dać prawie wszystkie możliwe atrybuty
klasy dostępne w języku C++, tzn. mo-
że posiadać metody, konstruktory, de-
struktory, metody wirtualne, pola i me-
tody statyczne itd. Pozwala na dziedzi-
czenie innych struktur i sama może być
dziedziczona. Jedyne ograniczenie po-
lega na tym, że definiowaną w ten spo-
sób klasę nie można parametryzować,
tzn. za jej pomocą nie można tworzyć
szablonów.
Domyślną sekcją w definicji klasy jest
zawsze sekcja public.
struct NazwaKlasy {
//Domyślnie publiczna
. . .
protected:
. . .
private:
. . .
public:
. . .
};
Przykład definicji:
struct LZepolona {
float Re( ) const { return
re; }
float Im( ) const { return
im; }
void Zmien(float r, float i);
private:
float re, im;
};
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Definicja klasy z wykorzystaniem słowa kluczowego union
union
– definiuje strukturę, w której każde
pole ma ten sam adres. Unia może mieć
pola i metody. Nie może mieć nato-
miast zarówno pól statycznych, jak też
metod statycznych. Nie może również
posiadać konstruktorów oraz destruk-
tora. Struktura zdefiniowana przez unię
może być dziedziczona, ale nie może
dziedziczyć innych struktur. Unia nie
może też posiadać metod wirtualnych.
Domyślną sekcją w definicji klasy jest
zawsze sekcja public.
union NazwaKlasy {
//Domyślnie publiczna
. . .
protected:
. . .
private:
. . .
public:
. . .
};
Przykład definicji:
union Wartosc {
int
Absolutna;
float Wzgledna;
};
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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];
hhh
hhh
hhh
((
((
((
((
(
hhh
hhh
hhh
((
((
((
((
(hhh
hhh
hhh
((
((
((
((
(
hhh
hhh
hhh
((
((
((
((
(
}
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 Tab obiektu M w funkcji Wyznacznik jest niedopuszczalne.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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 )
{
return
M. Tab[0][0]∗M. Tab[1][1] – M. Tab[0][1]∗M. Tab[1][0];
hhh
hhh
hhh
((
((
((
((
(
hhh
hhh
hhh
((
((
((
((
(hhh
hhh
hhh
((
((
((
((
(
hhh
hhh
hhh
((
((
((
((
(
}
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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 Tab można uczynić wyjątek dla wybranych
funkcji. Pozwala na to deklaracja funkcji zaprzyjaźnionych z daną klasą. Musi ona
znaleźć się w obrębie definicji klasy. Miejsce wystąpienia nie jest istotne.
Zwyczajowo jednak jest to początek definicji klasy.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Dostęp do elementów klasy poza klasą
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);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float
Elem[3][3];
public :
float Wez(int i, int j) const
{ return
Elem[i][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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Dostęp do elementów klasy poza klasą
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);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float
Elem[3][3];
public :
float Wez(int i, int j) const
{ return
Elem[i][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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Dostęp do elementów klasy poza klasą
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);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float
Elem[3][3];
public :
float Wez(int i, int j) const
{ return
Elem[i][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];
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
Elem[1][0] = M2. Tab[1][0];
Elem[1][1] = M2. Tab[1][1];
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
}
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . .
friend void Macierz3x3::Wstaw(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);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float
Elem[3][3];
public :
float Wez(int i, int j) const
{ return
Elem[i][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 “zaprzyjaźnimy” daną metodę z
klasą, do której pól prywatnych metody tej klasy mają uzyskać dostęp.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . .
friend void Macierz3x3::Wstaw(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);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
class Macierz3x3 { // . . . . . . . . . . . . . . . . . . . . . . .
float
Elem[3][3];
public :
float Wez(int i, int j) const
{ return
Elem[i][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];
}
void Macierz3x3::WstawTrans( Macierz2x2
M2 )
{
Elem[0][0] = M2. Tab[0][0];
Elem[0][1] = M2. Tab[1][0];
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
Elem[1][0] = M2. Tab[0][1];
Elem[1][1] = M2. Tab[1][1];
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
}
Zaprzyjaźnienie jednej
metody nie rozwiązuje
problemu dostępu do pól
prywatnych na poziomie
innej metody tej samej
klasy.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Dostęp do elementów klasy poza klasą
class Macierz2x2 { // . . . . . . . . . . . . . . . . . . . . . . . . . .
friend class Macierz3x3;
float
Tab[2][2];
public :
float Wez(int i, int j) const
{ return
Tab[i][j]; }
void Zmien(float elem, int i, int j);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
class Macierz3x3 { // . . . . . . . . . . . . . . . . . . . . . . .
float
Elem[3][3];
public :
float Wez(int i, int j) const
{ return
Elem[i][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];
}
void Macierz3x3::WstawTrans( Macierz2x2
M2 )
{
Elem[0][0] = M2. Tab[0][0];
Elem[0][1] = M2. Tab[1][0];
Elem[1][0] = M2. Tab[0][1];
Elem[1][1] = M2. Tab[1][1];
}
Zaprzyjaźnienie całej klasy
pozwala odwoływać się do
pól prywatnych na
poziomie metod klasy
zaprzyjaźnionej.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Dostęp do elementów klasy poza klasą
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);
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
class Macierz3x3 { // . . . . . . . . . . . . . . . . . . .
float
Elem[3][3];
public :
float Wez(int i, int j) const
{ return
Elem[i][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)
;
}
Zaprzyjaź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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Potencjalne możliwości błędów
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float
TabStosu[ROZ STOSU];
int
Ilosc;
Stos( ) { Ilosc = 0; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float
TabStosu[ROZ STOSU];
int
Ilosc;
Stos( ) { Ilosc = 0; }
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float
TabStosu[ROZ STOSU];
int
Ilosc;
Stos( ) { Ilosc = 0; }
float Pobierz( );
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
<
float
>
::max( );
return
TabStosu[−− Ilosc];
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Metoda jako element interfejsu klasy
#include
<
limits
>
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
<
float
>
::max( );
return
TabStosu[−− Ilosc];
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
<
float
>
::max( );
return
TabStosu[−− Ilosc];
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float
TabStosu[ROZ STOSU];
int
Ilosc;
. . .
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
if
( Ilosc
<
= 0) return numeric limits
<
float
>
::max( );
return
TabStosu[−− Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz( );
if
(Arg == numeric limits
<
float
>
::max()) { /∗ Obsługa błędu ∗/ }
. . .
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Metoda jako element interfejsu klasy
struct Stos { // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float
TabStosu[ROZ STOSU];
int
Ilosc;
. . .
}; // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
float Stos::Pobierz( )
{
if
( Ilosc
<
= 0) return numeric limits
<
float
>
::max( );
return
TabStosu[−− Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz( );
if
(Arg == numeric limits
<
float
>
::max()) { /∗ Obsługa błędu ∗/ }
. . .
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
<
float
>
::max( ); }
return Sukces = true, TabStosu[−− Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz(CzySukces);
if
(CzySukces) { /∗ Obsługa błędu ∗/ }
. . .
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
<
float
>
::max( ); }
return Sukces = true, TabStosu[−− Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz(CzySukces);
if
(CzySukces) { /∗ Obsługa błędu ∗/ }
. . .
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
<
float
>
::max( ); }
return Sukces = true, TabStosu[−− Ilosc];
}
int main( )
{
. . .
Arg = St.Pobierz(CzySukces);
if
(CzySukces) { /∗ Obsługa błędu ∗/ }
. . .
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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 ∗/ }
. . .
}
Czy takie rozwiązanie pozwala w pełni zabezpieczyć się przed
błędnym pobraniem wartości ze stosu?
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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;
P
P
P
³
³
³
−−St. Ilosc;
P
P
P
³
³
³
. . .
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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: ”
<<
Z.Modul( )
<<
endl;
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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: ”
<<
Z.Modul( )
<<
endl;
}
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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: ”
<<
Z.Modul( )
<<
endl;
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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: ”
<<
Z.Modul( )
<<
endl;
}
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
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
Przykład zastosowania stosu - kalkulator RPN
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Formułowanie warunków
Licznik = 0;
do
{
. . .
++Licznik;
. . .
. . .
. . .
} while
(Licznik != MAKS ILOSC);
. . .
if
(Licznik == MAKS ILOSC) cerr
<<
”Blad”
<<
endl;
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Formułowanie warunków
Licznik = 0;
do
{
. . .
++Licznik;
. . .
if
( JakisWarunek ) ++Licznik;
. . .
} while
(Licznik != MAKS ILOSC);
. . .
if
(Licznik == MAKS ILOSC) cerr
<<
”Blad”
<<
endl;
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Formułowanie warunków
Licznik = 0;
do
{
. . .
++Licznik;
. . .
if
( JakisWarunek ) ++Licznik;
. . .
} while
(
Licznik != MAKS ILOSC
);
. . .
if
(
Licznik == MAKS ILOSC
) cerr
<<
”Blad”
<<
endl;
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Formułowanie warunków
Licznik = 0;
do
{
. . .
++Licznik;
. . .
if
( JakisWarunek ) ++Licznik;
. . .
} while
(
Licznik < MAKS ILOSC
);
. . .
if
(
Licznik >= MAKS ILOSC
) cerr
<<
”Blad”
<<
endl;
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne globalne
#include
<
stdio.h
>
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf(”Pakiet nr: %i\n”,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
· · ·
WyslijPakiet( );
return 0;
}
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne globalne
#include
<
stdio.h
>
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf(”Pakiet nr: %i\n”,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
· · ·
WyslijPakiet( );
return 0;
}
Pakiet nr: 1
Pakiet nr: 2
Pakiet nr: 3
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne globalne
#include
<
stdio.h
>
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf(”Pakiet nr: %i\n”,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
· · ·
WyslijPakiet( );
return 0;
}
Pakiet nr: 1
Pakiet nr: 2
Pakiet nr: 11
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne globalne
#include
<
stdio.h
>
int IloscPakietow = 0;
void WyslijPakiet( )
{
. . .
printf(”Pakiet nr: %i\n”,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
IloscPakietow = 10;
WyslijPakiet( );
return 0;
}
Pakiet nr: 1
Pakiet nr: 2
Pakiet nr: 11
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne lokalne
#include
<
stdio.h
>
void WyslijPakiet( )
{
int IloscPakietow = 0;
. . .
printf(”Pakiet nr: %i\n”,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
IloscPakietow = 10;
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
WyslijPakiet( );
return 0;
}
?
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne lokalne
#include
<
stdio.h
>
void WyslijPakiet( )
{
int IloscPakietow = 0;
. . .
printf(”Pakiet nr: %i\n”,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
IloscPakietow = 10;
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
WyslijPakiet( );
return 0;
}
Pakiet nr: 1
Pakiet nr: 1
Pakiet nr: 1
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne statyczne
#include
<
stdio.h
>
void WyslijPakiet( )
{
static int IloscPakietow = 0;
. . .
printf(”Pakiet nr: %i\n”,++IloscPakietow);
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
IloscPakietow = 10;
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
WyslijPakiet( );
return 0;
}
Pakiet nr: 1
Pakiet nr: 2
Pakiet nr: 3
Zmienne statyczne w języku C pełnią rolę zmiennych
globalnych z ograniczonym zakresem dostępu tylko do
poziomu funkcji, w której są deklarowane.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Zmienne statyczne
#include
<
iostream
>
void WyslijPakiet( )
{
static int IloscPakietow = 0;
. . .
std::cout
<<
”Pakiet nr: ”
<<
++IloscPakietow
<<
std::endl;
}
int main( )
{
WyslijPakiet( );
WyslijPakiet( );
IloscPakietow = 10;
P
P
P
³
³
³
P
P
P
³
³
³
P
P
P
³
³
³
WyslijPakiet( );
}
Pakiet nr: 1
Pakiet nr: 2
Pakiet nr: 3
Identyczne znaczenie mają również w języku C++ .
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static
int
IloscLacz
;
LaczeSieciowe( ) { ++ IloscLacz; }
∼
LaczeSieciowe( ) { −− IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz = 0;
int main( )
{
cout
<<
Lacze1. IloscLacz
<<
endl;
}
Pole statyczne pełni rolę zmiennej globalnej w ramach danej klasy. Istnieje tylko
w jednym egzemplarzu niezależnie od wszystkich obiektów.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static
int
IloscLacz
;
LaczeSieciowe( ) { ++ IloscLacz; }
∼
LaczeSieciowe( ) { −− IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz = 0;
int main( )
{
cout
<<
Lacze1. IloscLacz
<<
endl;
}
Musi być zadeklarowane oraz zainicjalizowane poza klasą w przestrzeni
zmiennych globalnych. Określony zostaje w ten sposób moment jego utworzenia.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static
int
IloscLacz
;
LaczeSieciowe( ) { ++ IloscLacz; }
∼
LaczeSieciowe( ) { −− IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
cout
<<
Lacze1. IloscLacz
<<
endl;
}
Czy brak inicjalizacji oznacza wartość przypadkową?
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static
int
IloscLacz
;
LaczeSieciowe( ) { ++ IloscLacz; }
∼
LaczeSieciowe( ) { −− IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
cout
<<
Lacze1. IloscLacz
<<
endl;
}
Pola statyczne typów wbudowanych zawsze inicjalizowane są wartością 0.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static
int
IloscLacz
;
LaczeSieciowe( ) { ++ IloscLacz; }
∼
LaczeSieciowe( ) { −− IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
cout
<<
LaczeSieciowe:: IloscLacz
<<
endl;
}
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
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static
int
IloscLacz
;
LaczeSieciowe( ) { ++ IloscLacz; }
∼
LaczeSieciowe( ) { −− IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
LaczeSieciowe Lacze1, Lacze2;
cout
<<
LaczeSieciowe:: IloscLacz
<<
endl;
cout
<<
Lacze1. IloscLacz
<<
endl;
cout
<<
Lacze2. IloscLacz
<<
endl;
}
Dlatego też każdy z tych trzech sposobów
odwołania się do pola IloscLacz jest
odwołaniem się do tego samego obszaru
pamięci.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Zmienne globalne versus zmienne statyczne
Pola statyczne w klasie
class LaczeSieciowe { . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
public :
static
int
IloscLacz
;
LaczeSieciowe( ) { ++ IloscLacz; }
∼
LaczeSieciowe( ) { −− IloscLacz; }
}; . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
int LaczeSieciowe :: IloscLacz;
int main( )
{
cout
<<
LaczeSieciowe:: IloscLacz
<<
endl;
}
Aby móc odwołać się do pola
statycznego, nie musi istnieć żaden
obiekt. Pola statyczne istnieją niezależnie
od poszczególnych obiektów.
Programowanie obiektowe
Zachowanie spójności danych poprzez hermetyzację
Inne sposoby zapobiegania błędom
Koniec prezentacji
Programowanie obiektowe
Document Outline
- Struktury danych w jezyku C++
- Zachowanie spójnosci danych poprzez hermetyzacje
- Inne sposoby zapobiegania bledom
- Zmienne statyczne
Wyszukiwarka
Podobne podstrony:
MT st w 06
Kosci, kregoslup 28[1][1][1] 10 06 dla studentow
06 Kwestia potencjalności Aid 6191 ppt
06 Podstawy syntezy polimerówid 6357 ppt
06
06 Psych zaburz z somatoformiczne i dysocjacyjne
GbpUsd analysis for July 06 Part 1
Probl inter i kard 06'03
06 K6Z4
06 pamięć proceduralna schematy, skrypty, ramyid 6150 ppt
Sys Inf 03 Manning w 06
Ustawa z dnia 25 06 1999 r o świadcz pien z ubezp społ w razie choroby i macierz
więcej podobnych podstron