Professional Documents
Culture Documents
PRZYKADOWY ROZDZIA
SPIS TRECI
KATALOG KSIEK
KATALOG ONLINE
ZAMW DRUKOWANY KATALOG
TWJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMW INFORMACJE
O NOWOCIACH
ZAMW CENNIK
CZYTELNIA
FRAGMENTY KSIEK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
"
"
"
"
"
"
O Autorze ...........................................................................................................15
Wstp ................................................................................................................17
Cz I ..........................................................................................19
Rozdzia 1. Zaczynamy ......................................................................................21
Wprowadzenie...................................................................................................................21
Krtka historia jzyka C++ ...............................................................................................21
Rozwizywanie problemw........................................................................................22
Programowanie proceduralne, strukturalne i obiektowe ............................................23
C++ i programowanie zorientowane obiektowo.........................................................25
Jak ewoluowao C++.........................................................................................................26
Czy naley najpierw pozna C? ........................................................................................26
C++ a Java i C# .................................................................................................................27
Standard ANSI ..................................................................................................................27
Przygotowanie do programowania....................................................................................28
Twoje rodowisko programowania ...................................................................................28
Tworzenie programu .........................................................................................................29
Tworzenie pliku obiektowego za pomoc kompilatora ..............................................29
Tworzenie pliku wykonywalnego za pomoc linkera ................................................30
Cykl tworzenia programu..................................................................................................30
HELLO.cpp twj pierwszy program w C++................................................................32
Zaczynamy prac z kompilatorem ....................................................................................34
Budowanie projektu Hello World...............................................................................34
Bdy kompilacji ...............................................................................................................36
Spis treci
Cz II .......................................................................................191
Rozdzia 8. Wskaniki ......................................................................................193
Czym jest wskanik?.......................................................................................................193
Kilka sw na temat pamici.....................................................................................193
Uycie operatora adresu (&) .....................................................................................194
Przechowywanie adresu we wskaniku ....................................................................195
Puste i bdne wskaniki...........................................................................................195
Nazwy wskanikw ..................................................................................................196
Operator wyuskania .................................................................................................197
Wskaniki, adresy i zmienne ....................................................................................197
Operowanie danymi poprzez wskaniki ...................................................................199
Sprawdzanie adresu ..................................................................................................200
Do czego su wskaniki? .............................................................................................202
Stos i sterta ......................................................................................................................203
Operator new.............................................................................................................204
delete .........................................................................................................................204
Wycieki pamici..............................................................................................................206
Tworzenie obiektw na stercie........................................................................................207
Usuwanie obiektw .........................................................................................................207
Dostp do skadowych klasy ...........................................................................................208
Dane skadowe na stercie ................................................................................................210
Wskanik this ..................................................................................................................212
Utracone wskaniki .........................................................................................................214
Wskaniki const ..............................................................................................................217
Wskaniki const i funkcje skadowe const ...............................................................218
Wskaniki const this .................................................................................................219
Dziaania arytmetyczne na wskanikach temat dla zaawansowanych.......................220
Spis treci
5
Do czego mog odnosi si referencje? ..........................................................................227
Zerowe wskaniki i zerowe referencje............................................................................229
Przekazywanie argumentw funkcji przez referencj.....................................................229
Tworzenie funkcji swap() otrzymujcej wskaniki ..................................................231
Implementacja funkcji swap() za pomoc referencji ................................................233
Nagwki i prototypy funkcji ..........................................................................................234
Zwracanie kilku wartoci ................................................................................................235
Zwracanie wartoci przez referencj ........................................................................237
Przekazywanie przez referencj zwiksza efektywno dziaania programu .................238
Przekazywanie wskanika const ...............................................................................241
Referencje jako metoda alternatywna .......................................................................243
Kiedy uywa wskanikw, a kiedy referencji...............................................................245
czenie referencji i wskanikw ...................................................................................246
Nie pozwl funkcji zwraca referencji do obiektu, ktrego nie ma w zakresie! ............247
Zwracanie referencji do obiektu na stercie .....................................................................249
Wskanik, wskanik, kto ma wskanik?.........................................................................251
Spis treci
Cz III ......................................................................................435
Rozdzia 15. Specjalne klasy i funkcje................................................................437
Statyczne dane skadowe.................................................................................................437
Statyczne funkcje skadowe ............................................................................................442
Wskaniki do funkcji ......................................................................................................444
Dlaczego warto uywa wskanikw do funkcji? ....................................................447
Tablice wskanikw do funkcji ................................................................................450
Przekazywanie wskanikw do funkcji innym funkcjom ........................................452
Uycie instrukcji typedef ze wskanikami do funkcji ..............................................455
Wskaniki do funkcji skadowych ..................................................................................457
Tablice wskanikw do funkcji skadowych ............................................................459
Spis treci
9
Uycie elementw wzorca ..............................................................................................579
Funkcje specjalizowane ............................................................................................582
Wzorce i skadowe statyczne ....................................................................................588
Standardowa biblioteka wzorcw ...................................................................................591
Kontenery ........................................................................................................................591
Kontenery sekwencyjne ..................................................................................................592
Kontener vector.........................................................................................................592
Kontener list..............................................................................................................598
Kontener deque .........................................................................................................599
Stosy ................................................................................................................................600
Kolejki.............................................................................................................................601
Kontenery asocjacyjne ....................................................................................................601
Kontener map............................................................................................................601
Inne kontenery asocjacyjne.......................................................................................604
Klasy algorytmw ...........................................................................................................604
Bezmutacyjne operacje sekwencyjne .......................................................................605
Mutacyjne algorytmy sekwencyjne ..........................................................................606
10
Dodatki .......................................................................................683
Dodatek A Dwjkowo i szesnastkowo..............................................................685
Inne podstawy .................................................................................................................686
Wok podstaw................................................................................................................686
Dwjkowo.................................................................................................................688
Dlaczego podstawa 2?...............................................................................................689
Bity, bajty, nible........................................................................................................689
Co to jest KB?...........................................................................................................690
Liczby dwjkowe......................................................................................................690
Szesnastkowo ..................................................................................................................691
Rozdzia 6.
Klasy rozszerzaj wbudowane w C++ moliwoci, uatwiajce rozwizywanie zoonych, rzeczywistych problemw.
Z tego rozdziau dowiesz si:
czym s klasy i obiekty,
jak definiowa now klas oraz tworzy obiekty tej klasy,
czym s funkcje i dane skadowe,
czym s konstruktory i jak z nich korzysta.
130
Cz I
rozbudowa jest niemoliwa. Graficzne interfejsy uytkownika, Internet, telefonia cyfrowa i bezprzewodowa oraz wiele innych technologii, znacznie zwikszyy poziom
skomplikowania nowych projektw, a wymagania konsumentw dotyczce jakoci
interfejsu uytkownika wzrosy.
W obliczu rosncych wymaga, programici bacznie przyjrzeli si przemysowi informatycznemu. Wnioski, do jakich doszli, byy co najmniej przygnbiajce. Oprogramowanie powstawao z opnieniem, posiadao bdy, dziaao niestabilnie i byo
drogie. Projekty regularnie przekraczay budet i trafiay na rynek z opnieniem.
Koszt obsugi tych projektw by znaczny, zmarnowano ogromne iloci pienidzy.
Jedynym wyjciem z tej sytuacji okazao si tworzenie oprogramowania zorientowanego obiektowo. Jzyki programowania obiektowego stworzyy silne wizy pomidzy
strukturami danych a metodami manipulowania tymi danymi. A co najwaniejsze,
w programowaniu zorientowanym obiektowo nie ju musisz myle o strukturach danych i manipulujcych nimi funkcjami; mylisz o obiektach. Rzeczach.
wiat jest wypeniony przedmiotami: samochodami, psami, drzewami, chmurami,
kwiatami. Rzeczy. Kada rzecz ma charakterystyk (szybki, przyjazny, brzowy, puszysty, adny). Wikszo rzeczy cechuje jakie zachowanie (ruch, szczekanie,
wzrost, deszcz, uwid). Nie mylimy o danych psa i o tym, jak moglibymy nimi manipulowa mylimy o psie jako o rzeczy: do czego jest podobny i co robi.
131
W tradycyjnych jzykach, takich jak C, typy byy wbudowane w jzyk. W C++ programista moe rozszerzy jzyk, tworzc potrzebne mu typy, za kady z tych nowych
typw moe by w peni funkcjonalny i dysponowa t sam si, co typy wbudowane.
Klasy i skadowe
Nowy typ zmiennych tworzy si, deklarujc klas. Klasa jest waciwie grup zmiennych czsto o rnych typach skojarzonych z zestawem odnoszcych si do
nich funkcji.
Jedn z moliwoci mylenia o samochodzie jest potraktowanie go jako zbioru k,
drzwi, foteli, okien itd. Inna moliwo to wyobraenie sobie, co samochd moe
zrobi: jedzi, przyspiesza, zwalnia, zatrzymywa si, parkowa itd. Klasa umoliwia kapsukowanie, czyli upakowanie, tych rnych czci oraz rnych dziaa
w jeden zbir, ktry jest nazywana obiektem.
Upakowanie wszystkiego, co wiesz o samochodzie, w jedn klas przynosi programicie liczne korzyci. Wszystko jest na miejscu, uatwia to odwoywanie si, kopiowanie i manipulowanie danymi. Klienty twojej klasy tj. te czci programu, ktre
z niej korzystaj mog uywa twojego obiektu bez zastanawiania si, co znajduje
si w rodku i jak on dziaa.
Klasa moe skada si z dowolnej kombinacji zmiennych prostych oraz zmiennych
innych klas. Zmienna wewntrz klasy jest nazywana zmienn skadow lub dan
skadow. Klasa (samochd) moe posiada skadowe reprezentujce siedzenia,
typ radia, opony itd.
Zmienne skadowe s zmiennymi w danej klasie. Stanowi one cz klasy, tak jak
koa i silnik stanowi cz samochodu.
Funkcje w danej klasie zwykle manipuluj zmiennymi skadowymi. Funkcje klasy
nazywa si funkcjami skadowymi lub metodami klasy. Metodami klasy mog
132
Cz I
by (uruchom) oraz (hamuj). Klasa (kot) moe posiada zmienne
skadowe, reprezentujce wiek i wag; jej metodami mog by (pij),
(miaucz) czy (ap myszy).
Funkcje skadowe (metody) s funkcjami w klasie. Podobnie jak zmienne skadowe,
stanowi cz klasy i okrelaj, co dana klasa moe zrobi.
Deklarowanie klasy
Aby zadeklarowa klas, uyj sowa kluczowego , po ktrym nastpuje otwierajcy nawias klamrowy, a nastpnie lista danych skadowych i metod tej klasy. Deklaracja koczy si zamykajcym nawiasem klamrowym i rednikiem. Oto deklaracja
klasy o nazwie (kot):
Zadeklarowanie takiej klasy nie powoduje zaalokowania pamici dla obiektu . Informuje jedynie kompilator, czym jest typ , jakie dane zawiera ( jego wiek
oraz jego waga) oraz co moe robi ( miaucz). Informuje take kompilator, jak dua jest zmienna typu to jest, jak duo miejsca w pamici
ma przygotowa w przypadku tworzenia zmiennej typu . W tym przykadzie, o ile
typ ma cztery bajty, zmienna typu zajmuje osiem bajtw: cztery bajty dla
zmiennej i cztery dla zmiennej . Funkcja nie zajmuje miejsca, gdy dla funkcji skadowych (metod) miejsce nie jest rezerwowane.
133
Jzyk C++ uwzgldnia wielko liter, dlatego wszystkie nazwy klas powinny przestrzega tej samej konwencji. Dziki temu nigdy nie bdziesz musia sprawdza pisowni nazwy klasy (czy to byo , czy "#$%?).
Niektrzy programici lubi poprzedzi kad nazw klasy okrelon liter na
przykad czy & podczas, gdy inni uywaj wycznie duych lub maych liter. Ja sam korzystam z konwencji, w ktrej wszystkie nazwy klas rozpoczynaj si od duej litery, tak jak czy & (osoba).
Wielu programistw rozpoczyna wszystkie nazwy funkcji od duej litery, za wszystkie nazwy zmiennych od maej. Sowa zwykle rozdzielane s znakiem podkrelenia tak jak w ! lub poprzez zastosowanie duej litery dla kadego
sowa na przykad czy ' (rysuj okrg).
Wane jest, by wybra okrelony styl i trzyma si go w kadym programie. Z czasem rozwiniesz swj styl nie tylko na konwencje nazw, ale take na wcicia, wyrwnanie nawiasw klamrowych oraz styl komentarzy.
W firmach programistycznych powszechne jest okrelenie standardu wielu
elementw stylu zapisu kodu rdowego. Sprawia on, e wszyscy programici
mog atwo odczytywa wzajemnie swj kod.
Definiowanie obiektu
Definiowanie obiektu nowego typu przypomina definiowanie zmiennej cakowitej:
!"
#
!"
Ten kod definiuje zmienn o nazwie $ (czna waga), ktrej typem jest
. Oprcz tego definiuje zmienn o nazwie
(, ktra jest obiektem
klasy (typu) .
Klasy a obiekty
Nigdy nie karmi si definicji kota, lecz konkretnego kota. Naley dokona rozrnienia pomidzy ide kota a konkretnym kotem, ktry wanie ociera si o twoje nogi.
C++ rwnie dokonuje rozrnienia pomidzy klas , bdc ide kota, a poszczeglnymi obiektami typu . Tak wic
( jest obiektem typu , tak jak
$ jest zmienn typu
.
Obiekt jest indywidualnym egzemplarzem klasy.
134
Cz I
Gdy uywasz metody klasy, oznacza to, e wywoujesz t metod. W tym przykadzie
wywoae metod obiektu
(.
Kompilator uzna to za bd, gdy nie mona przypisa wartoci pi typowi cakowitemu. Zamiast tego musisz zdefiniowa zmienn typu cakowitego i przypisa jej
warto *. Na przykad:
)
!"
)%&
*
)
&
Jest to skrcony zapis stwierdzenia: Przypisz warto * zmiennej ,, ktra jest zmienn typu . Nie mona rwnie napisa:
$
%&(
Kompilator uzna to za bd, gdy nie moesz przypisa wartoci * do elementu
klasy . Zamiast tego musisz zdefiniowa egzemplarz obiektu klasy i dopiero
wtedy przypisa warto jego skadowej. Na przykad:
#"+
#
)
#$
%&"+
#)%&
135
Kompilator wypisze: Nie, guptasie, koty (cats) nie szczekaj! (By moe w twoim
kompilatorze ten komunikat bdzie brzmia nieco inaczej.). Kompilator wie, e Mruczek nie moe szczeka, gdy klasa nie posiada metody (szczekaj). Kompilator nie pozwoli Mruczkowi nawet zamiaucze, jeli nie zdefiniujesz dla niego
funkcji (miaucz).
TAK
NIE
Prywatne i publiczne
W deklaracji klasy uywanych jest take kilka innych sw kluczowych. Dwa najwaniejsze z nich to:
- (publiczny) i . (prywatny).
Wszystkie skadowe klasy dane i metody s domylnie prywatne. Prywatne skadowe mog by uywane tylko przez metody nalece do danej klasy. Skadowe publiczne s dostpne dla innych funkcji i klas. To rozrnienie jest wane, cho na pocztku moe sprawia kopot. Aby to lepiej wyjani, spjrzmy na poprzedni przykad:
W tej deklaracji, skadowe , oraz s prywatne, gdy wszystkie skadowe klasy s prywatne domylnie. Oznacza to, e dopki nie postanowisz
inaczej, pozostan one prywatne.
Jeli jednak w funkcji napiszesz na przykad:
,+
,+$
%&+./0
1
1!-"!
!
!0
136
Cz I
Teraz skadowe , oraz s publiczne. -)
/
*0 kompiluje si bez problemw.
Listing 6.1 przedstawia deklaracj klasy z publicznymi zmiennymi skadowymi.
Listing 6.1. Dostp do publicznych skadowych w prostej klasie
'23
#
#!
42
+
#
#!$
52
627
8
9
:2
&2
#
#;#
<2
=2" +2
;" /
"! #.
/" +
>2
#.
?2
#.
4'2@- ;
*
#
442
452
462
4:2
4&2
#
4<2
#$
%&"!"
#.
4=222 88A
#
#
A
4>222 88
#$
88A$B
A
4?2
'
5'2
#
#
&$
137
138
Cz I
Listing 6.2 przedstawia klas zmodyfikowan tak, by zawieraa prywatne dane
skadowe i publiczne akcesory. Zwr uwag, e ten listing przedstawia wycznie
deklaracj klasy, nie ma w nim kodu wykonywalnego.
Listing 6.2. Klasa z akcesorami
'23
##!
423
#.
/"!
C" +
#
!"*
/
52
!!
*#.!"!
!
62
:2
&2
<2" +2
=2" +
#
!
>2
?2D
4'2
442
452D
462
4:2" +
##.
4&2
4<2
4=2"!
#.
4>2"
2
4?2
5'2
542
552
Ta klasa posiada pi metod publicznych. Linie 8. i 9. zawieraj akcesory dla skadowej . Linie 11. i 12. zawieraj akcesory dla skadowej . Te akcesory ustawiaj zmienne skadowe i zwracaj ich wartoci.
W linii 15. jest zadeklarowana publiczna funkcja skadowa . Ta funkcja nie jest
akcesorem. Nie zwraca wartoci ani ich nie ustawia; wykonuje inn usug dla klasy
wypisuje sowo
.
Zmienne skadowe s zadeklarowane w liniach 19. i 20.
Aby ustawi wiek
(, powiniene przekaza warto metodzie (ustaw
wiek), na przykad:
#
#$D
&
# #
1!/" +
#
Prywatno% a ochrona
Zadeklarowanie metod lub danych jako prywatnych umoliwia kompilatorowi wyszukanie w programach pomyek, zanim stan si one bdami. Kady szanujcy si
139
#.
#!
Sowo kluczowe suy do deklarowania nowych typw. Klasa stanowi zbir danych
skadowych klasy, ktre s zmiennymi rnych typw, take innych klas. Klasa zawiera take funkcje klasy tzw. metody ktre s funkcjami uywanymi do manipulowania danymi
w danej klasie i wykonywania innych usug dla klasy.
Obiekty nowego typu definiuje si$ w taki sam sposb, w jaki definiuje si$ inne zmienne.
Naley okreli typ (klas$), a po nim nazw$ zmiennej (obiektu). Do uzyskania dost$pu do
funkcji i danych klasy suy operator kropki ()).
Sowa kluczowe kontroli dost$pu okrelaj, ktre sekcje klasy s prywatne, a ktre publiczne. Domylnie wszystkie skadowe klasy s prywatne. Kade sowo kluczowe zmienia
kontrol$ dost$pu od danego miejsca a do ko1ca klasy, lub kontrol$ wystpienia nast$pnego sowa kluczowego kontroli dost$pu. Deklaracja klasy ko1czy si$ zamykajcym nawiasem klamrowym i rednikiem.
Przykad 1
" +2
#
#$
%>
#$
%4>
#$
Przykad 2
" +2";-
;"
!#.!
" +
!
D
,#
D
F
!
F
"
2".;*-
"!
F
G5&&H
140
Cz I
#
##!
IJ !
"#!
+ #
!"
IJ $D
F
>: #./F
>:
+ %IJ $
F
/+
>:
IJ $D!.
;D
TAK
NIE
#.
462
4:2
4&2
C" +
!#
4<2/!*-#.
4=2
22
4>2
4?2
141
5'2
542
552
D
C#
562" +
5:2 /
#./
5&222D
5<2
5=2
/#./
5>2
*/"
#
/"
5?2
%
6'2
642
652
!
6622
6:2"
!2+#
6&2.
2!"
#
.A !A
6<222
6=2
6>222 88A !$B
A
6?2
:'2
:42!#C
#C"C
:521
!C!"
#"
!$
:62
::2
:&2
#
:<2
#$D
&
:=2
#$
:>222 88A
#
#
A
:?222 88
#$
88A$B
A
&'2
#$
&42
'
&52
!$
#
#
&$
!$
Linie od 5. do 13. zawieraj definicj klasy (kot). Linia 7. zawiera sowo kluczowe
-, ktre informuje kompilator, e to, co po nim nastpuje, jest zestawem publicznych skadowych. Linia 8. zawiera deklaracj publicznego akcesora $
(pobierz wiek). $ zapewnia dostp do prywatnej zmiennej skadowej
(jego wiek), zadeklarowanej w linii 12. Linia 9. zawiera publiczny akcesor
(ustaw wiek). Funkcja otrzymuje parametr typu , ktry nastpnie przypisuje skadowej .
Linia 10. zawiera deklaracj metody (miaucz). Funkcja nie jest akcesorem. Jest to oglna metoda klasy, wypisujca na ekranie sowo Miauczy.
Linia 11. rozpoczyna sekcj prywatn, ktra obejmuje jedynie zadeklarowan w linii
12. prywatn skadow . Deklaracja klasy koczy si zamykajcym nawiasem
klamrowym i rednikiem.
142
Cz I
Linie od 17. do 20. zawieraj definicj skadowej funkcji $. Ta metoda nie ma
parametrw i zwraca warto cakowit. Zauwa, e ta metoda klasy zawiera nazw
klasy, dwa dwukropki oraz nazw funkcji (linia 17.). Ta skadnia informuje kompilator, e definiowana funkcja $ jest wanie t funkcj, ktra zostaa zadeklarowana w klasie . Poza formatem tego nagwka, definiowanie funkcji wasnej
$ niczym nie rni si od definiowania innych (zwykych) funkcji.
Funkcja $ posiada tylko jedn lini i zwraca po prostu warto zmiennej skadowej . Zauwa, e funkcja nie ma dostpu do tej zmiennej skadowej,
gdy jest ona prywatna dla klasy . Funkcja ma za to dostp do publicznej
metody $. Poniewa ta metoda jest skadow klasy , ma peny dostp do
zmiennej . Dziki temu moe zwrci funkcji warto zmiennej .
Linia 25. zawiera definicj funkcji skadowej . Ta funkcja posiada parametr
w postaci wartoci cakowitej i przypisuje skadowej jego warto (linia 29.).
Poniewa jest skadow klasy , ma bezporedni dostp do jej zmiennych prywatnych i publicznych.
Linia 36. rozpoczyna definicj (czyli implementacj) metody klasy . Jest to
jednoliniowa funkcja wypisujca na ekranie sowo Miaucz, zakoczone znakiem
nowej linii. Pamitaj, e znak 1 powoduje przejcie do nowej linii.
Linia 43. rozpoczyna ciao funkcji , czyli waciwy program. W tym przypadku
funkcja nie posiada argumentw. W linii 45., funkcja deklaruje obiekt
o nazwie
(. W linii 46. zmiennej tego obiektu jest przypisywana
warto 5 (poprzez uycie akcesora ). Zauwa, e wywoanie tej metody nastpuje dziki uyciu nazwy obiektu (
(), po ktrej zastosowano operator kropki
()) i nazw metody (). W podobny sposb wywoywane s wszystkie inne
metody wszystkich klas.
Linia 47. wywouje funkcj skadow , za w linii 48. za pomoc akcesora $
, wypisywany jest komunikat. Linia 50. ponownie wywouje funkcj .
Konstruktory i destruktory
Istniej dwa sposoby definiowania zmiennej cakowitej. Mona zdefiniowa zmienn,
a nastpnie, w dalszej czci programu, przypisa jej warto. Na przykad:
!
/
$$$
!#
%="!"
!
*-
143
Inicjalizacja czy w sobie definiowanie zmiennej oraz pocztkowe przypisanie wartoci. Nic nie stoi na przeszkodzie temu, by zmieni pniej warto zmiennej. Inicjalizacja powoduje tylko, e zmienna nigdy nie bdzie pozbawiona sensownej wartoci.
W jaki sposb zainicjalizowa skadowe klasy? Klasy posiadaj specjalne funkcje
skadowe, zwane konstruktorami. Konstruktor (ang. constructor) moe w razie potrzeby posiada parametry, ale nie moe zwraca wartoci nawet typu . . Konstruktor jest metod klasy o takiej samej nazwie, jak nazwa klasy.
Gdy zadeklarujesz konstruktor, powiniene take zadeklarowa destruktor (ang. destructor). Konstruktor tworzy i inicjalizuje obiekt danej klasy, za destruktor porzdkuje
obiekt i zwalnia pami, ktr moge w niej zaalokowa. Destruktor zawsze nosi nazw klasy, poprzedzon znakiem tyldy (2). Destruktory nie maj argumentw i nie
zwracaj wartoci. Dlatego deklaracja destruktora klasy ma nastpujc posta:
K
Gdy definiujesz obiekt klasy, wywoywany jest konstruktor. Gdyby konstruktor klasy
mia dwa parametry, mgby zdefiniowa obiekt , piszc
#&C=
144
Cz I
#.
4<2
4=2
4>2#
##!
4?222
5'2
542
%
145
552
562
5:222K
#C
+
5&2
5<2
5=2
5>2
C" +
!#
5?2*-#.
6'2
22
642
652
662
6:2
6&2
D
C#
6<2" +
6=2
6>222D
6?2
:'2
/#./
:42
*/"
#
/"
:52
%
:62
::2
:&2
!
:<22
:=2"
!2+#
:>2.
2!"
#
.A !A
:?222
&'2
&4222 88A !$B
A
&52
&62
&:2!#C
#C"C
&&21
!C!"
#"
!$
&<2
&=2
&>2
#&
&?2
#$
<'222 88A
#
#
A
<4222 88
#$
88A$B
A
<52
#$
<62
#$D
=
<:222 88AL
# A
<&222 88
#$
88A$B
A
<<2
'
<=2
!$
#
#
&$
!$
L
# =$
Listing 6.4 przypomina listing 6.3, jednak w linii 9. dodano konstruktor, posiadajcy
argument w postaci wartoci cakowitej. Linia 10. deklaruje destruktor, ktry nie posiada parametrw. Destruktory nigdy nie maj parametrw, za destruktory i konstruktory nie zwracaj adnych wartoci nawet typu . .
146
Cz I
Linie od 19. do 22. zawieraj implementacj konstruktora. Jest ona podobna do implementacji akcesora . Konstruktor nie zwraca wartoci.
Linie od 24. do 26. przedstawiaj implementacj destruktora 2. Ta funkcja nie
robi nic, ale jeli deklaracja klasy zawiera deklaracj destruktora, zdefiniowany musi
zosta wtedy take ten destruktor.
Linia 58. zawiera definicj obiektu
(, stanowicego egzemplarz klasy . Do
konstruktora obiektu
( przekazywana jest warto *. Nie ma potrzeby wywoywania funkcji , gdy
( zosta stworzony z wartoci * znajdujc si
w zmiennej skadowej , tak jak pokazano w linii 61. W linii 63. zmiennej
obiektu
( jest przypisywana warto 7. T now warto wypisuje linia 65.
TAK
NIE
Funkcja nie moe by funkcj , gdy modyfikuje warto zmiennej skadowej . Natomiast funkcja $ moe by , gdy nie modyfikuje wartoci adnej ze skadowych klasy. Funkcja $ po prostu zwraca biec warto
skadowej . Zatem deklaracje tych funkcji mona przepisa nastpujco:
D
147
bd. Na przykad, gdy napiszesz funkcj $ w taki sposb, e bdziesz zapamitywa ilo zapyta o wiek kota, spowodujesz bd kompilacji. Jest to spowodowane tym, e wywoujc t metod, modyfikujesz zawarto obiektu .
Deklaruj funkcje jako wsz$dzie, gdzie to jest moliwe. Deklaruj je tam,
gdzie nie przewidujesz modyfikowania obiektu. Kompilator moe w ten sposb
pomc ci w wykryciu b$dw w programie; tak jest szybciej i dokadniej.
Deklarowanie funkcji jako wszdzie tam, gdzie jest to moliwe, naley do tradycji programistycznej. Za kadym razem, gdy to zrobisz, umoliwisz kompilatorowi
wykrycie pomyki, zanim stanie si ona bdem, ktry ujawni si ju podczas dziaania programu.
Interfejs a implementacja
Jak wiesz, klienty s tymi elementami programu, ktre tworz i wykorzystuj obiekty
twojej klasy. Publiczny interfejs swojej klasy deklaracj klasy moesz traktowa
jako kontrakt z tymi klientami. Ten kontrakt informuje, jak zachowuje si dana klasa.
Na przykad, w deklaracji klasy , stworzye kontrakt informujcy, e wiek kadego kota moe by zainicjalizowany w jego konstruktorze, modyfikowany za pomoc
akcesora oraz odczytywany za pomoc akcesora $. Oprcz tego
obiecujesz, e kady kot moe miaucze (funkcj ). Zwr uwag, e w publicznym interfejsie nie ma ani sowa o zmiennej skadowej ; jest to szczeg
implementacji, ktry nie stanowi elementu kontraktu. Na danie dostarczysz wieku
($) i ustawisz go (), ale sam mechanizm () jest niewidoczny.
Gdy uczynisz funkcj $funkcj a powiniene to zrobi kontrakt obiecuje take, e funkcja $ nie modyfikuje obiektu , dla ktrego jest wywoana.
C++ jest jzykiem zapewniajcym siln kontrol typw, co oznacza, e kompilator
wymusza przestrzeganie kontraktu, zgaszajc bdy kompilacji za kadym razem,
gdy naruszysz reguy tego kontraktu. Listing 6.5 przedstawia program, ktry nie
skompiluje si z powodu naruszenia ustale takiego kontraktu.
148
Cz I
<2
=2" +2
>2
?2K
4'2
#
!"
442D
452
462"
2
4:2
4&2
4<2
4=2#
##!C
4>222
4?2
5'2
%
54222 88AM
##!B
A
552
562
5:222K
#C
+
5&2
5<222 88A3
##!B
A
5=2
5>2
C
#
C
5?2
;
0
6'2
22
642
652
NN
0
662
6:2
6&2
D
C" +
6<2#
6=2
6>222D
6?2
:'2
/#./
:42
*/"
#
/"
:52
%
:62
::2
:&2
!
:<22
:=2"
!2+#
:>2.
2!"
#
.A !A
:?222
&'2
&4222 88A !$B
A
&52
&62
&:2
@1
.
&&2!
#/
+.;!# "
&<2
&=2
&>2
#
"
#
&?2
#$
<'2
#$,#O
C. "
C#!
#/$
<42
#$
%=
#./"!
/
<52
'
<62
149
150
Cz I
Informuje ona kompilator, by wstawi w tym miejscu zawarto pliku CAT.hpp tak, jakby j wpisa rcznie. Uwaga: niektre kompilatory nalegaj, by wielko liter w nazwie
pliku w dyrektywie 5
zgadzaa si z wielkoci liter w nazwie pliku na dysku.
Deklaracja klasy mwi kompilatorowi, czym jest ta klasa, jakie dane zawiera
oraz jakie funkcje posiada. Deklaracja klasy jest nazywana jej interfejsem, gdy
informuje kompilator w jaki sposb ma z ni wspdziaa. Ten interfejs jest
zwykle przechowywany w pliku .hpp, cz$sto nazywanym plikiem nagwkowym.
Definicja funkcji mwi kompilatorowi, jak dziaa dana funkcja. Definicja funkcji
jest nazywana implementacj metody klasy i jest przechowywana w pliku .cpp.
Szczegy dotyczce implementacji klasy nale wycznie do jej autora. Klienty klasy tj. cz$ci programu uywajce tej klasy nie musz, ani nie powinny wiedzie, jak zaimplementowane zostay funkcje.
151
Dlaczego masz si trudzi, rozdzielajc program na pliki .hpp i .cpp, skoro i tak plik
.hpp jest wstawiany do pliku .cpp? W wikszoci przypadkw klienty klasy nie dbaj
o szczegy jej implementacji. Odczytanie pliku nagwkowego daje im wystarczajc ilo informacji, by zignorowa plik implementacji. Poza tym, ten sam plik .hpp
moesz docza do wielu rnych plikw .cpp.
Implementacja inline
Moesz poprosi kompilator, by uczyni zwyk funkcj funkcj , funkcjami
mog sta si rwnie metody klasy. W tym celu naley umieci sowo kluczowe przed typem zwracanej wartoci. Na przykad, implementacja
funkcji $ wyglda nastpujco:
22
/#./
Listingi 6.6 i 6.7 odtwarzaj klas , tym razem jednak deklaracja klasy zostaa
umieszczona w pliku CAT.hpp, za jej definicja w pliku CAT.cpp. Oprcz tego, na listingu 6.7 akcesor zosta zadeklarowany jako funkcja .
152
Cz I
Kod zaprezentowany na listingach 6.6 i 6.7 jest podobny do kodu z listingu 6.4, trzy
metody zostay zadeklarowane w pliku deklaracji jako , a deklaracja zostaa
przeniesiona do pliku CAT.hpp (listing 6.6).
153
Funkcja $ jest deklarowana w linii 6., gdzie znajduje si take jej implementacja. Linie 7. i 8. zawieraj kolejne funkcje , jednak w stosunku do poprzednich, zwykych implementacji, dziaanie tych funkcji nie zmienia si.
Linia 4. listingu 6.7 zawiera dyrektyw 5
6)6, ktra powoduje wstawienie do pliku zawartoci pliku CAT.hpp. Doczajc plik CAT.hpp, informujesz
prekompilator, by odczyta zawarto tego pliku i wstawi j w miejscu wystpienia
dyrektywy 5
(tak jakby, poczwszy od linii 5, sam wpisa t zawarto).
Ta technika umoliwia umieszczenie deklaracji w pliku innym ni implementacja,
a jednoczenie zapewnienie kompilatorowi dostpu do niej. W programach C++ technika ta jest powszechnie wykorzystywana. Zwykle deklaracje klas znajduj si w plikach .hpp, ktre s doczane do powizanych z nimi plikw .cpp za pomoc dyrektyw 5
.
Linie od 18. do 29. stanowi powtrzenie funkcji z listingu 6.4. Oznacza to, e
funkcje dziaaj tak samo jak zwyke funkcje.
154
Cz I
>2D
F
!F%!
?2
R
R
4'2
F
F
442"
2
452
R
462
F
4:2#
##!Q
4&2
4<2
4=2P
4>2
4?2" +2
5'2P
"C
C
+ C
542KP
552
562
L"
L"
5:2
S
S
5&2
,
,
5<2
P
P
5=2
5>2Q
T""
S
T""
S
5?2Q
S
S
S
S
6'2Q
T""
P
T""
P
642Q
S
P
S
P
652
662D
T""
S
Q
S
T""
S
%S
6:2D
S
S
Q
S
S
S
%S
6&2D
T""
PQ
S
T""
P%S
6<2D
S
PQ
S
S
P%S
6=2
6>2D
L"
"L"%"
6?2D
S
S
%
:'2D
,
+ , %+
:42D
P
P%
:52
:62
::2
:&2"
2
:<2Q
T""
S
:=2Q
T""
P
:>2Q
S
S
:?2Q
S
P
&'2
L"
&42
S
&52
,
&62
P
&:2
&&2#
P
$""
155
:2
&2L"%"
<2S
%
=2, %+
>2P%
?2
4'2T""
S
$D
R
442T""
S
$D
F"
452
462T""
P$D
R
4:2T""
P$D
F"
4&2
4<2S
S
$D
R
4=2S
S
$D
F+
4>2
4?2S
P$D
R
5'2S
P$D
F+
542
552
562
5:2++"#/"
+
5&2"
1
#*!#*
5<2
P
22
5=2
5>2
%PUS
5?2
V
%L"U,
6'2
WV
642
652
662
6:2
6&2
#
/
/!" P
6<2P
!P
4''C5'C&'C>'
6=2
6>2
%!P
$
6?2
:'222 88AI+2A88
88AB
A
:4222 88A"$R
2A
:5222 88!P
$
T""
S
$
R
:62
'
::2
I+26'''
"$R
25'
Linie od 3. do 14. listingu 6.8 deklaruj klas & (punkt), ktra suy do przechowywania wsprzdnych , i okrelonego punktu rysunku. W tym programie nie
wykorzystujemy naleycie klasy &. Jej zastosowania wymagaj jednak inne metody rysunkowe.
Gdy nadasz klasie nazw$ , niektre kompilatory zgosz bd. W takim przypadku po prostu zmie1 nazw$ klasy na .
156
Cz I
W deklaracji klasy &, w liniach 12. i 13., zadeklarowalimy dwie zmienne skadowe (7 oraz 8). Te zmienne przechowuj wsprzdne punktu. Zakadamy, e
wsprzdna , ronie w prawo, a wsprzdna w gr. Istniej take inne systemy.
W niektrych programach okienkowych wsprzdna y ronie w d okna.
Klasa & uywa akcesorw inline, zwracajcych i ustawiajcych wsprzdne 7 i 8
punktu. Te akcesory zostay zadeklarowane w liniach od 7. do 10. Punkty uywaj
konstruktora i destruktora domylnego. W zwizku z tym ich wsprzdne trzeba
ustawia jawnie.
Linia 17. rozpoczyna deklaracj klasy (prostokt). Klasa ta kada si z czterech punktw reprezentujcych cztery naroniki prostokta.
Konstruktor klasy (linia 20.) otrzymuje cztery wartoci cakowite, (grna),
9 (lewa), - (dolna) oraz (prawa). Do czterech zmiennych skadowych (listing 6.9) kopiowane s cztery parametry konstruktora i tworzone s cztery punkty.
Oprcz standardowych akcesorw, klasa posiada funkcj $ (pobierz obszar), zadeklarowan w linii 43. Zamiast przechowywa obszar w zmiennej,
funkcja $ oblicza go w liniach od 28. do 30. listingu 6.9. W tym celu oblicza
szeroko i wysoko prostokta, nastpnie mnoy je przez siebie.
Uzyskanie wsprzdnej , lewego grnego wierzchoka prostokta wymaga dostpu
do punktu :%9 (lewy grny) i zapytania o jego wsprzdn 7. Poniewa funkcja $:%9 jest funkcj klasy , moe ona bezporednio odwoywa
si do prywatnych danych tej klasy, wcznie ze zmienn (:%9). Poniewa
:%9 jest obiektem klasy &, a zmienna 7 tej klasy jest prywatna, funkcja $:%9 nie moe odwoywa si do niej bezporednio. Zamiast tego,
w celu uzyskania tej wartoci musi uy publicznego akcesora $7.
Linia 33. listingu 6.9 stanowi pocztek ciaa programu. Pami nie jest alokowana a
do linii 36.; w obszarze tym nic si nie dzieje. Jedyna rzecz, jak zrobilimy, to poinformowanie kompilatora, jak ma stworzy punkt i prostokt (gdyby byy potrzebne
w przyszoci).
W linii 36. definiujemy obiekt typu , przekazujc mu wartoci ", %9,
oraz .
W linii 38. tworzymy lokaln zmienn (obszar) typu . Ta zmienna przechowuje obszar stworzonego przez nas prostokta. Zmienn inicjalizujemy za pomoc wartoci zwrconej przez funkcj $ klasy .
Klient klasy moe stworzy obiekt tej klasy i uzyska jego obszar, nie znajc nawet implementacji funkcji $.
Plik RECT.hpp zosta przedstawiony na listingu 6.8. Obserwujc plik nagwkowy, ktry zawiera deklaracj klasy , programista moe wysnu wniosek, e funkcja
157
$ zwraca warto typu . Sposb, w jaki funkcja $ uzyskuje t warto, nie interesuje klientw klasy . Autor klasy mgby zmieni
funkcj $; nie wpynoby to na programy, ktre z niej korzystaj.
Czsto zadawane pytanie
Jaka jest rnica pomi$dzy deklaracj a definicj?
Odpowied4
Deklaracja wprowadza now nazw$, lecz nie alokuje pami$ci; dokonuje tego
definicja.
Struktury
Bardzo bliskim kuzynem sowa kluczowego jest sowo kluczowe
, uywane do deklarowania struktur. W C++ struktura jest odpowiednikiem klasy, ale
wszystkie jej skadowe s domylnie publiczne. Moesz zadeklarowa struktur dokadnie tak, jak klas; moesz zastosowa w niej te same zmienne i funkcje skadowe.
Gdy przestrzegasz jawnego deklarowania publicznych i prywatnych sekcji klasy, nie
ma adnej rnicy pomidzy klas a struktur.
Sprbuj wprowadzi do listingu 6.8 nastpujce zmiany:
w linii 3., zmie
& na
&,
w linii 17., zmie
na
.
Nastpnie skompiluj i uruchom program. Otrzymane wyniki nie powinny si od siebie rni.
158
TAK
Umieszczaj deklaracj klasy w pliku .hpp, za funkcje skadowe definiuj w pliku .cpp.
Uywaj
wszdzie tam, gdzie jest to moliwe.
Zanim przejdziesz dalej, postaraj si dokadnie zrozumie zasady dziaania klasy.
Cz I