C++ dla każdego.
Idz
do
Wydanie II
" Spis treści
" Przykładowy rozdział
Autorzy: Jesse Liberty, Siddhartha Rao, Bradley L. Jones
Tłumaczenie: Robert Górczyński
ISBN: 978-83-246-2782-0
Katalog książek
Tytuł oryginału: Sams Teach Yourself C++
in One Hour a Day (6th Edition)
" Katalog online
Format: B5, stron: 850
" Zamów drukowany
katalog
Poznaj język C++ w 21 dni!
Twój koszyk
Pomimo swojego wieku, język C++ wciąż utrzymuje wysoką formę. Przez lata zdobył i ugruntował
sobie świetną pozycję na rynku języków programowania. Dzięki temu, nawet dziś w czasach gdzie
króluje język Java oraz platforma .NET, wciąż swoich zwolenników. Ba! Istnieją takie gałęzie
" Dodaj do koszyka
oprogramowania, w których jest on niezastąpiony. Dlatego jeżeli oczekujesz najwyższej
wydajności, operowania blisko sprzętu oraz pełnej kontroli nad sposobem wykonywania
programu powinieneś postawić właśnie na C++.
Cennik i informacje
Dzięki książce, którą trzymasz w ręku będzie to stosunkowo proste zadanie. Poświęcając tylko
godzinę dziennie zdobędziesz wiedzę, która pozwoli Ci spokojnie rozpocząć przygodę z językiem
" Zamów informacje
C++, poznać jego tajniki, zalety oraz wady. Z każdą kolejną godziną będziesz zdobywać coraz to
o nowościach
bardziej zaawansowaną i ciekawą wiedzę. Jaki więc zakres obejmuje niniejszy podręcznik?
" Zamów cennik
Kompletny, którego opanowanie pozwoli Ci na pisanie programów o różnym stopniu złożoności
oraz swobodne poruszanie się w świecie języka C++. Zdobędziesz informacje na temat stałych,
Czytelnia
zmiennych, tablic, instrukcji warunkowych oraz pętli. Ponadto dowiesz się, jak wykorzystać
wskaz
niki oraz dyrektywy kompilatora. Natomiast lektura ostatnich rozdziałów książki pozwoli Ci
na swobodne poruszanie się w świecie programowania obiektowego, strumieni oraz klas STL.
" Fragmenty książek
Obiekty, klasy, dziedziczenie czy polimorfizm  te pojęcia nie skryją przed Tobą już żadnej
online
tajemnicy! Kolejne wydanie cenionej książki sprawdzi się w rękach każdego adepta języka C++.
Jeżeli chcesz poznać ten język, to nie ma na co czekać. Lepszej okazji nie będzie!
" Historia języka C++
" Konstrukcja programu w języku C++
" Komentowanie kodu
" Zmienne i stałe
" Zastosowanie tablic i ciągów tekstowych
" Formułowanie wyrażeń
" Instrukcje warunkowe i operatory
" Wykorzystanie i tworzenie funkcji
" Zakresy zmiennych
" Sterowanie przebiegiem programu
Kontakt
" Zasada działania wskaz
ników
" Programowanie obiektowe  klasy, obiekty, dziedziczenie, polimorfizm
Helion SA
" Rzutowanie
ul. Kościuszki 1c
" Wykorzystanie strumieni
44-100 Gliwice
" Kompilowanie warunkowe, instrukcje kompilatora
tel. [phone]
e-mail: [e-mail]
Sprawdz
czy język C++ spełni Twoje oczekiwania!
© Helion 1991 2010
Spis tre ci
Wst p 25
Cz I Podstawy
Lekcja 1. Zaczynamy 31
Krótka historia j zyka C++ ............................................................................................31
Interpretery i kompilatory ....................................................................................33
Zmiana wymaga , zmiana platform ..................................................................34
Programowanie proceduralne, strukturalne i obiektowe .......................35
Programowanie zorientowane obiektowo .....................................................36
C++ i programowanie zorientowane obiektowo .............................................37
Jak ewoluowa o C++ ........................................................................................................38
Czy nale y najpierw pozna C? ...................................................................................39
Dodatek Microsoft Managed Extensions for C++ ................................................39
Standard ANSI ....................................................................................................................39
Przygotowanie do programowania ..........................................................................40
Twoje rodowisko programowania ..........................................................................41
Tworzenie programu ......................................................................................................42
Tworzenie pliku obiektowego za pomoc kompilatora ...........................42
Tworzenie pliku wykonywalnego za pomoc linkera ...............................43
Cykl tworzenia programu .............................................................................................43
HELLO.cpp  Twój pierwszy program w C++ ....................................................45
Zaczynamy prac z kompilatorem ............................................................................47
Budowanie projektu Hello World .......................................................................48
B dy kompilacji ................................................................................................................49
Podsumowanie ...................................................................................................................50
Pytania i odpowiedzi .......................................................................................................50
Warsztaty .............................................................................................................................51
Quiz ..................................................................................................................................52
wiczenia .......................................................................................................................52
4 C++ dla ka dego
Lekcja 2. Anatomia programu C++ 53
Prosty program ................................................................................................................. 53
Rzut oka na obiekt cout ................................................................................................. 56
U ywanie przestrzeni nazw standardowych ....................................................... 58
Komentarze ......................................................................................................................... 61
Rodzaje komentarzy ................................................................................................. 61
U ywanie komentarzy ............................................................................................. 62
Jeszcze jedna uwaga na temat komentarzy ................................................... 63
Funkcje .................................................................................................................................. 63
Korzystanie z funkcji ................................................................................................ 65
Metody kontra funkcje ............................................................................................ 67
Podsumowanie .................................................................................................................. 67
Pytania i odpowiedzi ....................................................................................................... 67
Warsztaty ............................................................................................................................. 68
Quiz .................................................................................................................................. 68
wiczenia ...................................................................................................................... 69
Lekcja 3. Zmienne i sta e 71
Czym jest zmienna? ......................................................................................................... 71
Dane s przechowywane w pami ci ................................................................. 71
Przydzielanie pami ci ............................................................................................. 72
Rozmiar liczb ca kowitych .................................................................................... 73
Zapis ze znakiem i bez znaku ............................................................................... 74
Podstawowe typy zmiennych .............................................................................. 74
Definiowanie zmiennej .................................................................................................. 75
Uwzgl dnianie wielko ci liter .............................................................................. 77
Konwencje nazywania zmiennych ..................................................................... 77
S owa kluczowe .......................................................................................................... 78
Okre lenie ilo ci pami ci u ywanej przez typ zmiennej ................................ 79
Tworzenie kilku zmiennych jednocze nie ............................................................ 81
Przypisywanie zmiennym warto ci ......................................................................... 81
Tworzenie aliasów za pomoc typedef ................................................................... 83
Kiedy u ywa typu short, a kiedy typu long? ....................................................... 84
Zawini cie liczby ca kowitej bez znaku ........................................................... 85
Zawini cie liczby ca kowitej ze znakiem ........................................................ 86
 Spis tre ci 5
Znaki .......................................................................................................................................87
Znaki i liczby ................................................................................................................88
Znaki specjalne ............................................................................................................89
Sta e ........................................................................................................................................90
Litera y ...........................................................................................................................90
Sta e symboliczne ......................................................................................................91
Sta e wyliczeniowe ...........................................................................................................92
Podsumowanie ...................................................................................................................95
Pytania i odpowiedzi .......................................................................................................96
Warsztaty .............................................................................................................................97
Quiz ..................................................................................................................................97
wiczenia .......................................................................................................................98
Lekcja 4. Tablice i ci gi tekstowe 99
Czym jest tablica? ..............................................................................................................99
Elementy tablicy ...................................................................................................... 100
Zapisywanie za ko cem tablicy ........................................................................ 102
B d s upka w p ocie ............................................................................................. 104
Inicjalizowanie tablic ............................................................................................ 105
Deklarowanie tablic ............................................................................................... 106
Tablice wielowymiarowe ........................................................................................... 107
Deklarowanie tablic wielowymiarowych ..................................................... 108
Inicjalizowanie tablic wielowymiarowych .................................................. 110
Tablice znaków i ci gi tekstowe .............................................................................. 113
Metody strcpy() oraz strncpy() ............................................................................... 115
Klasy ci gów tekstowych ........................................................................................... 117
Podsumowanie ................................................................................................................ 120
Pytania i odpowiedzi .................................................................................................... 120
Warsztaty .......................................................................................................................... 121
Quiz ............................................................................................................................... 121
wiczenia .................................................................................................................... 122
Lekcja 5. Wyra enia, instrukcje i operatory 123
Instrukcje ........................................................................................................................... 123
Bia e znaki .................................................................................................................. 124
Bloki i instrukcje z o one .................................................................................... 124
Wyra enia ......................................................................................................................... 125
6 C++ dla ka dego
Operatory ...........................................................................................................................126
Operator przypisania .............................................................................................127
Operatory matematyczne ....................................................................................127
czenie operatora przypisania z operatorem matematycznym .............130
Inkrementacja i dekrementacja ...............................................................................130
Przedrostki i przyrostki ........................................................................................131
Kolejno dzia a ............................................................................................................133
Zagnie d anie nawiasów ............................................................................................134
Prawda i fa sz ...................................................................................................................135
Operatory relacji ......................................................................................................136
Instrukcja if .......................................................................................................................137
Styl wci .....................................................................................................................141
Instrukcja else ...........................................................................................................141
Zaawansowane instrukcje if ...............................................................................143
U ycie nawiasów klamrowych w zagnie d onych instrukcjach if ...........146
Operatory logiczne .........................................................................................................149
Logiczne I ....................................................................................................................149
Logiczne LUB .............................................................................................................150
Logiczne NIE ..............................................................................................................150
Skrócone obliczanie wyra e logicznych ............................................................150
Kolejno operatorów logicznych ...........................................................................151
Kilka s ów na temat prawdy i fa szu ......................................................................152
Operator warunkowy (trójelementowy) .............................................................152
Podsumowanie ................................................................................................................154
Pytania i odpowiedzi .....................................................................................................154
Warsztaty ...........................................................................................................................155
Quiz ................................................................................................................................155
wiczenia ....................................................................................................................156
Lekcja 6. Funkcje 159
Czym jest funkcja? ..........................................................................................................159
Zwracane warto ci, parametry i argumenty ......................................................160
Deklarowanie i definiowanie funkcji .....................................................................161
Prototypy funkcji .....................................................................................................162
Definiowanie funkcji ..............................................................................................164
Wykonywanie funkcji ...................................................................................................166
 Spis tre ci 7
Zakres zmiennej ............................................................................................................. 166
Zmienne lokalne ...................................................................................................... 166
Zmienne lokalne zdefiniowane w blokach .................................................. 168
Parametry s zmiennymi lokalnymi ...................................................................... 170
Zmienne globalne .................................................................................................... 172
Zmienne globalne: ostrze enie ......................................................................... 173
Rozwa ania na temat tworzenia instrukcji funkcji ........................................ 174
Kilka s ów na temat argumentów funkcji ........................................................... 174
Kilka s ów na temat zwracanych warto ci ......................................................... 175
Parametry domy lne .................................................................................................... 178
Przeci anie funkcji ...................................................................................................... 181
Zagadnienia zwi zane z funkcjami ......................................................................... 185
Funkcje typu inline ................................................................................................. 185
Rekurencja ................................................................................................................. 188
Jak dzia aj funkcje  rzut oka  pod mask  .................................................... 193
Poziomy abstrakcji ................................................................................................. 193
Podsumowanie ................................................................................................................ 198
Pytania i odpowiedzi .................................................................................................... 199
Warsztaty .......................................................................................................................... 200
Quiz ............................................................................................................................... 200
wiczenia .................................................................................................................... 200
Lekcja 7. Sterowanie przebiegiem dzia ania programu 203
P tle ..................................................................................................................................... 203
Pocz tki p tli: instrukcja goto ........................................................................... 203
Dlaczego nie jest zalecane stosowanie instrukcji goto? ......................... 205
P tle while ......................................................................................................................... 205
Bardziej skomplikowane instrukcje while .................................................. 207
Instrukcje continue oraz break ......................................................................... 209
P tla while (true) .................................................................................................... 212
Implementacja p tli do...while ................................................................................. 213
U ywanie p tli do...while ............................................................................................ 214
P tle for .............................................................................................................................. 216
Zaawansowane p tle for ...................................................................................... 219
Puste p tle for .......................................................................................................... 222
P tle zagnie d one ................................................................................................. 223
Zakres zmiennych w p tlach for ...................................................................... 225
8 C++ dla ka dego
Podsumowanie p tli ......................................................................................................226
Sterowanie przebiegiem dzia ania programu
za pomoc instrukcji switch ...................................................................................229
U ycie instrukcji switch w menu ......................................................................232
Podsumowanie ................................................................................................................236
Pytania i odpowiedzi .....................................................................................................236
Warsztaty ...........................................................................................................................237
Quiz ................................................................................................................................238
wiczenia ....................................................................................................................238
Lekcja 8. Wska niki 241
Czym jest wska nik? .....................................................................................................241
Kilka s ów na temat pami ci ...............................................................................241
U ycie operatora adresu zmiennej w pami ci (&) ...................................242
Przechowywanie adresu zmiennej we wska niku ...................................244
Nazwy wska ników ................................................................................................244
Pobranie warto ci ze zmiennej .........................................................................245
Dereferencja za pomoc operatora wy uskania ........................................246
Wska niki, adresy i zmienne ..............................................................................247
Operowanie danymi poprzez wska niki .......................................................248
Sprawdzanie adresu ...............................................................................................250
Nazwy wska ników i tablic .................................................................................252
Wska nik do tablicy kontra tablica wska ników ......................................254
Do czego s u wska niki? .........................................................................................255
Stos i sterta ........................................................................................................................255
Alokacja pami ci za pomoc s owa kluczowego new .............................257
Zwalnianie pami ci: s owo kluczowe delete ...............................................258
Inne spojrzenie na wycieki pami ci .......................................................................260
Tworzenie obiektów na stercie ................................................................................261
Usuwanie obiektów ze sterty ....................................................................................261
Utracone wska niki .......................................................................................................263
Wska niki const ..............................................................................................................267
Podsumowanie ................................................................................................................268
Pytania i odpowiedzi .....................................................................................................268
Warsztaty ...........................................................................................................................269
Quiz ................................................................................................................................269
wiczenia ....................................................................................................................269
 Spis tre ci 9
Lekcja 9. Referencje 271
Czym jest referencja? ................................................................................................... 271
U ycie operatora adresu (&) z referencj ........................................................... 273
Nie mo na zmienia przypisania referencji ................................................ 275
Zerowe wska niki i zerowe referencje ................................................................. 276
Przekazywanie argumentów funkcji przez referencj .................................. 277
Tworzenie funkcji swap() otrzymuj cej wska niki ................................. 279
Implementacja funkcji swap() za pomoc referencji .............................. 281
Zwracanie kilku warto ci ........................................................................................... 283
Zwracanie warto ci przez referencj ............................................................. 285
Przekazywanie przez referencj zwi ksza efektywno
dzia ania programu .................................................................................................... 286
Przekazywanie wska nika const ...................................................................... 290
Referencje jako metoda alternatywna ........................................................... 293
Kiedy u ywa wska ników, a kiedy referencji ................................................. 295
czenie referencji i wska ników ........................................................................... 296
Zwracanie referencji do obiektu, którego nie ma w zakresie .................... 298
Problem zwi zany ze zwracaniem referencji do obiektu na stercie ........ 299
Podsumowanie ................................................................................................................ 301
Pytania i odpowiedzi .................................................................................................... 301
Warsztaty .......................................................................................................................... 302
Quiz ............................................................................................................................... 302
wiczenia .................................................................................................................... 302
Cz II Podstawy programowania
zorientowanego obiektowo i C++
Lekcja 10. Klasy i obiekty 307
Czy C++ jest zorientowane obiektowo? ............................................................... 307
Tworzenie nowych typów .......................................................................................... 309
Wprowadzenie klas i elementów sk adowych ................................................. 310
Deklarowanie klasy ................................................................................................ 311
Kilka s ów o konwencji nazw ............................................................................ 311
Definiowanie obiektu ............................................................................................ 313
Klasy a obiekty ......................................................................................................... 313
Dost p do elementów sk adowych klasy ............................................................ 313
Przypisywa nale y obiektom, nie klasom .................................................. 314
Czego nie zadeklarujesz, tego klasa nie b dzie mia a ............................. 314
10 C++ dla ka dego
Dost p prywatny i publiczny ....................................................................................315
Oznaczanie danych sk adowych jako prywatnych ...................................317
Implementowanie metod klasy ................................................................................321
Konstruktory i destruktory ........................................................................................324
Domy lne konstruktory i destruktory ...........................................................325
U ycie domy lnego konstruktora ....................................................................326
Funkcje sk adowe const ..............................................................................................329
Gdzie umieszcza deklaracje klasy i definicje metod .....................................331
Implementacja inline ....................................................................................................332
Klasy, których danymi sk adowymi s inne klasy ...........................................335
Struktury ............................................................................................................................340
Podsumowanie ................................................................................................................340
Pytania i odpowiedzi .....................................................................................................341
Warsztaty ...........................................................................................................................343
Quiz ................................................................................................................................343
wiczenia ....................................................................................................................343
Lekcja 11. Dziedziczenie 345
Czym jest dziedziczenie? .............................................................................................345
Dziedziczenie i wyprowadzanie ........................................................................346
Królestwo zwierz t .................................................................................................347
Sk adnia wyprowadzania .....................................................................................348
Prywatne kontra chronione .......................................................................................350
Dziedziczenie oraz konstruktory i destruktory ................................................353
Przekazywanie argumentów do konstruktorów bazowych .................355
Przes anianie funkcji klasy bazowej ......................................................................360
Ukrywanie metod klasy bazowej ......................................................................363
Wywo ywanie metod klasy bazowej ..............................................................365
Metody wirtualne ...........................................................................................................367
Jak dzia aj funkcje wirtualne ............................................................................372
Próba uzyskania dost pu do metod klasy bazowej ..................................373
Okrajanie .....................................................................................................................374
Tworzenie destruktorów wirtualnych ...........................................................377
Wirtualne konstruktory kopiuj ce ..................................................................377
Koszt metod wirtualnych .....................................................................................381
Dziedziczenie prywatne ..............................................................................................381
U ywanie dziedziczenia prywatnego .............................................................382
Dziedziczenie prywatne kontra agregacja (z o enie) .............................384
 Spis tre ci 11
Podsumowanie ................................................................................................................ 385
Pytania i odpowiedzi .................................................................................................... 386
Warsztaty .......................................................................................................................... 387
Quiz ............................................................................................................................... 387
wiczenia .................................................................................................................... 388
Lekcja 12. Polimorfizm 389
Problemy z pojedynczym dziedziczeniem .......................................................... 389
Przenoszenie w gór .............................................................................................. 392
Rzutowanie w dó ................................................................................................... 393
Po czenie dwóch list ............................................................................................ 396
Dziedziczenie wielokrotne ......................................................................................... 397
Cz ci obiektu z dziedziczeniem wielokrotnym ....................................... 401
Konstruktory w obiektach dziedziczonych wielokrotnie ..................... 402
Eliminowanie niejednoznaczno ci .................................................................. 405
Dziedziczenie ze wspólnej klasy bazowej .................................................... 406
Dziedziczenie wirtualne ....................................................................................... 410
Problemy z dziedziczeniem wielokrotnym ................................................. 415
Mixiny i klasy metod .............................................................................................. 415
Abstrakcyjne typy danych .......................................................................................... 416
Czyste funkcje wirtualne ..................................................................................... 420
Implementowanie czystych funkcji wirtualnych ...................................... 422
Z o one hierarchie abstrakcji ............................................................................ 426
Które typy s abstrakcyjne? ............................................................................... 430
Podsumowanie ................................................................................................................ 430
Pytania i odpowiedzi .................................................................................................... 431
Warsztaty .......................................................................................................................... 432
Quiz ............................................................................................................................... 432
wiczenia .................................................................................................................... 433
Lekcja 13. Typy operatorów i przeci anie operatorów 435
Czym s operatory w C++? ......................................................................................... 435
Operatory jednoargumentowe ................................................................................ 436
Typy operatorów jednoargumentowych ..................................................... 437
Programowanie jednoargumentowego operatora inkrementacji
i dekrementacji ...................................................................................................... 437
12 C++ dla ka dego
Programowanie operatora dereferencji *
i operatora wyboru elementu sk adowego -> ...............................................441
Programowanie operatorów konwersji ........................................................444
Operatory dwuargumentowe ...................................................................................446
Typy operatorów dwuargumentowych .........................................................446
Programowanie operatorów dodawania (a+b) i odejmowania (a-b) .......447
Programowanie operatorów dodawania/przypisania
i odejmowania/przypisania .............................................................................450
Przeci anie operatorów porównywania ....................................................452
Przeci anie operatorów <, >, <= i >= ............................................................456
Operatory indeksowania ......................................................................................459
Funkcja operator() .........................................................................................................462
Operatory, których nie mo na ponownie zdefiniowa ..................................463
Podsumowanie ................................................................................................................464
Pytania i odpowiedzi .....................................................................................................464
Warsztaty ...........................................................................................................................465
Quiz ................................................................................................................................465
wiczenia ....................................................................................................................465
Lekcja 14. Operatory rzutowania 467
Co to jest rzutowanie? ..................................................................................................467
Kiedy zachodzi potrzeba rzutowania? ..................................................................467
Dlaczego rzutowanie w stylu C nie jest popularne
w ród niektórych programistów C++? ..............................................................468
Operatory rzutowania C++ .........................................................................................469
U ycie static_cast .....................................................................................................470
U ycie dynamic_cast i identyfikacja typu w czasie dzia ania ...............471
U ycie reinterpret_cast .........................................................................................474
U ycie const_cast .....................................................................................................475
Problemy z operatorami rzutowania C++ ..............................................................476
Podsumowanie ................................................................................................................477
Pytania i odpowiedzi .....................................................................................................477
Warsztaty ...........................................................................................................................478
Quiz ................................................................................................................................478
Lekcja 15. Wprowadzenie do makr i wzorców 481
Preprocesor i kompilator ............................................................................................481
Dyrektywa #define preprocesora ...........................................................................482
 Spis tre ci 13
Funkcje makro ................................................................................................................. 482
Po co te wszystkie nawiasy? .............................................................................. 484
W jaki sposób makra i s abe bezpiecze stwo typów
id r ka w r k ? .................................................................................................... 485
Makra a funkcje i wzorce ..................................................................................... 486
Funkcje inline ........................................................................................................... 486
Wprowadzenie do wzorców ..................................................................................... 488
Sk adnia deklaracji wzorca ................................................................................. 489
Ró ne rodzaje deklaracji wzorca ..................................................................... 490
Klasy wzorca ............................................................................................................. 490
Ustanawianie i specjalizacja wzorca .............................................................. 491
Wzorce i bezpiecze stwo typów ...................................................................... 492
Deklarowanie wzorców z wieloma parametrami .................................... 492
Deklarowanie wzorców z parametrami domy lnymi ............................ 493
Przyk ad wzorca ...................................................................................................... 493
U ycie wzorców w praktycznym programowaniu C++ ......................... 495
Podsumowanie ................................................................................................................ 496
Pytania i odpowiedzi .................................................................................................... 496
Warsztaty .......................................................................................................................... 498
Quiz ............................................................................................................................... 498
wiczenia .................................................................................................................... 498
Cz III Poznajemy standardow bibliotek
wzorców (STL)
Lekcja 16. Wprowadzenie do standardowej biblioteki wzorców 501
Kontenery STL ................................................................................................................. 501
Kontenery sekwencyjne ....................................................................................... 501
Kontenery asocjacyjne .......................................................................................... 502
Wybór odpowiedniego kontenera ................................................................... 503
Iteratory STL .................................................................................................................... 503
Algorytmy STL ................................................................................................................. 506
Oddzia ywania mi dzy kontenerami i algorytmami
za pomoc iteratorów ............................................................................................... 507
Podsumowanie ................................................................................................................ 509
Pytania i odpowiedzi .................................................................................................... 510
Warsztaty .......................................................................................................................... 510
Quiz ............................................................................................................................... 511
14 C++ dla ka dego
Lekcja 17. Klasa string w STL 513
Potrzeba powstania klasy s u cej do manipulowania ci gami
tekstowymi .....................................................................................................................513
Praca z klas STL string ...............................................................................................515
Ustanawianie obiektu STL string i tworzenie kopii .................................515
Uzyskanie dost pu do obiektu string i jego zawarto ci .........................518
czenie ci gów tekstowych ..............................................................................520
Wyszukiwanie znaku b d podci gu tekstowego w obiekcie string .....521
Skracanie obiektu STL string ..............................................................................523
Odwracanie zawarto ci ci gu tekstowego ...................................................525
Konwersja wielko ci znaków obiektu string .................................................526
Bazuj ca na wzorcach implementacja klasy STL string ................................528
Podsumowanie ................................................................................................................528
Pytania i odpowiedzi .....................................................................................................529
Warsztaty ...........................................................................................................................529
Quiz ................................................................................................................................529
wiczenia ....................................................................................................................530
Lekcja 18. Dynamiczne klasy tablic w STL 531
Charakterystyka klasy std::vector ..........................................................................531
Typowe operacje klasy vector ..................................................................................532
Ustanawianie klasy vector ...................................................................................532
Wstawianie elementów do obiektu vector ..................................................533
Uzyskanie dost pu do elementów obiektu vector ....................................538
Usuwanie elementów z obiektu vector ..........................................................541
Zrozumienie funkcji size() i capacity() .................................................................542
Klasa STL deque ..............................................................................................................545
Podsumowanie ................................................................................................................547
Pytania i odpowiedzi .....................................................................................................547
Warsztaty ...........................................................................................................................548
Quiz ................................................................................................................................549
wiczenia ....................................................................................................................549
Lekcja 19. Klasa STL list 551
Charakterystyka klasy std::list .................................................................................551
Podstawowe operacje klasy list ...............................................................................552
Ustanawianie obiektu std::list ...........................................................................552
Wstawianie elementów na pocz tku obiektu list .....................................552
 Spis tre ci 15
Wstawianie elementów na ko cu obiektu list ........................................... 554
Wstawianie elementów w rodku obiektu list .......................................... 555
Usuwanie elementów w obiekcie list ............................................................. 558
Odwrócenie i sortowanie elementów w obiekcie list .................................... 560
Odwracanie elementów ....................................................................................... 561
Sortowanie elementów ........................................................................................ 562
Podsumowanie ................................................................................................................ 573
Pytania i odpowiedzi .................................................................................................... 573
Warsztaty .......................................................................................................................... 574
Quiz ............................................................................................................................... 574
wiczenia .................................................................................................................... 574
Lekcja 20. Klasy STL set i multiset 575
Wprowadzenie ................................................................................................................ 575
Podstawowe operacje klas STL set i multiset ................................................... 576
Ustanawianie obiektu std::set ........................................................................... 576
Wstawianie elementów do obiektu set lub multiset ............................... 577
Wyszukiwanie elementów w obiekcie STL set lub multiset ................ 579
Usuwanie elementów z obiektu STL set lub multiset ............................. 581
Wady i zalety u ywania obiektów STL set i multiset ..................................... 592
Podsumowanie ................................................................................................................ 592
Pytania i odpowiedzi .................................................................................................... 592
Warsztaty .......................................................................................................................... 593
Quiz ............................................................................................................................... 593
wiczenia .................................................................................................................... 594
Lekcja 21. Klasy STL map i multimap 595
Krótkie wprowadzenie ................................................................................................ 595
Podstawowe operacje klas STL map i multimap ............................................. 596
Ustanawianie obiektu std::map ........................................................................ 596
Wstawianie elementów do obiektu STL map lub multimap ................ 597
Wyszukiwanie elementów w obiekcie STL map lub multimap .......... 600
Usuwanie elementów z obiektu STL map lub multimap ....................... 602
Dostarczanie w asnego predykatu sortowania ................................................ 606
Podsumowanie ................................................................................................................ 610
Pytania i odpowiedzi .................................................................................................... 610
Warsztaty .......................................................................................................................... 611
Quiz ............................................................................................................................... 612
wiczenia .................................................................................................................... 612
16 C++ dla ka dego
Cz IV Jeszcze wi cej STL
Lekcja 22. Zrozumienie obiektów funkcji 615
Koncepcja obiektów funkcji i predykatów .............................................................615
Typowe aplikacje obiektów funkcji ........................................................................616
Funkcje jednoargumentowe ...............................................................................616
Predykat jednoargumentowy ............................................................................621
Funkcje dwuargumentowe .................................................................................623
Predykat dwuargumentowy ...............................................................................626
Podsumowanie ................................................................................................................629
Pytania i odpowiedzi .....................................................................................................629
Warsztaty ...........................................................................................................................630
Quiz ................................................................................................................................630
wiczenia ....................................................................................................................630
Lekcja 23. Algorytmy STL 631
Co to s algorytmy STL? ...............................................................................................631
Klasyfikacja algorytmów STL ....................................................................................631
Algorytmy niezmienne ..........................................................................................632
Algorytmy zmienne ................................................................................................633
U ywanie algorytmów STL ........................................................................................636
Zliczanie i znajdowanie elementów ................................................................636
Wyszukiwanie elementu lub zakresu w kolekcji .......................................639
Inicjalizacja elementów w kontenerze wraz
z okre lonymi warto ciami ..............................................................................642
Przetwarzanie elementów w zakresie za pomoc for_each .................645
Przeprowadzanie transformacji zakresu
za pomoc std::transform .................................................................................647
Operacje kopiowania i usuwania ......................................................................650
Zast powanie warto ci oraz zast powanie elementu
na podstawie danego warunku ......................................................................654
Sortowanie i przeszukiwanie posortowanej kolekcji oraz
usuwanie duplikatów ..........................................................................................656
Partycjonowanie zakresu .....................................................................................659
Wstawianie elementów do posortowanej kolekcji ...................................661
Podsumowanie ................................................................................................................664
Pytania i odpowiedzi .....................................................................................................664
 Spis tre ci 17
Warsztaty .......................................................................................................................... 665
Quiz ............................................................................................................................... 665
wiczenia .................................................................................................................... 666
Lekcja 24. Kontenery adaptacyjne: stack i queue 667
Cechy charakterystyczne zachowania stosów i kolejek ............................... 667
Stosy .............................................................................................................................. 667
Kolejki .......................................................................................................................... 668
U ywanie klasy STL stack .......................................................................................... 668
Ustanawianie obiektu stack ............................................................................... 669
Funkcje sk adowe klasy stack ........................................................................... 670
U ywanie klasy STL queue ........................................................................................ 672
Ustanawianie obiektu queue ............................................................................. 673
Funkcje sk adowe klasy queue ......................................................................... 674
U ywanie klasy STL priority_queue ...................................................................... 676
Ustanawianie obiektu priority_queue ........................................................... 677
Funkcje sk adowe klasy priority_queue ....................................................... 678
Podsumowanie ................................................................................................................ 682
Pytania i odpowiedzi .................................................................................................... 682
Warsztaty .......................................................................................................................... 682
Quiz ............................................................................................................................... 682
wiczenia .................................................................................................................... 683
Lekcja 25. Praca z opcjami bitowymi za pomoc STL 685
Klasa bitset ........................................................................................................................ 685
Ustanowienie klasy std::bitset .......................................................................... 685
U ywanie klasy std::bitset i jej elementów sk adowych .............................. 687
Operatory std::bitset ............................................................................................. 687
Metody sk adowe klasy std::bitset .................................................................. 687
Klasa vector ........................................................................................................ 691
Ustanowienie klasy vector ................................................................... 691
U ywanie klasy vector ........................................................................... 692
Podsumowanie ................................................................................................................ 693
Pytania i odpowiedzi .................................................................................................... 694
Warsztaty .......................................................................................................................... 694
Quiz ............................................................................................................................... 695
wiczenia .................................................................................................................... 695
18 C++ dla ka dego
Cz V Zaawansowane koncepcje C++
Lekcja 26. Sprytne wska niki 699
Czym s sprytne wska niki? ......................................................................................699
Na czym polega problem zwi zany z u ywaniem
wska ników konwencjonalnych? ..................................................................700
W jaki sposób sprytne wska niki mog pomóc? .......................................701
W jaki sposób s implementowane sprytne wska niki? ..............................701
Typy sprytnych wska ników ....................................................................................703
Kopiowanie g bokie .............................................................................................704
Mechanizm kopiowania przy zapisie (COW) ..............................................706
Sprytne wska niki zliczania odniesie ..........................................................706
Sprytne wska niki powi zane z licznikiem odniesie ............................707
Kopiowanie destrukcyjne ....................................................................................708
U ywanie klasy std::auto_ptr ....................................................................................710
Popularne biblioteki sprytnych wska ników ....................................................712
Podsumowanie ................................................................................................................713
Pytania i odpowiedzi .....................................................................................................713
Warsztaty ...........................................................................................................................714
Quiz ................................................................................................................................714
wiczenia ....................................................................................................................715
Lekcja 27. Strumienie 717
Przegl d strumieni .........................................................................................................717
Hermetyzacja przep ywu danych .....................................................................718
Buforowanie ..............................................................................................................719
Strumienie i bufory ........................................................................................................721
Standardowe obiekty wej cia-wyj cia ..................................................................722
Przekierowywanie standardowych strumieni ..................................................722
Wej cie z u yciem cin ...................................................................................................723
Wej ciowe ci gi tekstowe ....................................................................................725
Problemy z ci gami tekstowymi .......................................................................725
Warto zwracana przez cin ...............................................................................728
Inne funkcje sk adowe w dyspozycji cin ..............................................................729
Wprowadzanie pojedynczych znaków ..........................................................729
Odczytywanie ci gów tekstowych z wej cia standardowego .............732
U ycie cin.ignore() ..................................................................................................735
Funkcje peek() oraz putback() ..........................................................................737
 Spis tre ci 19
Wyj cie poprzez cout ................................................................................................... 738
Zrzucanie zawarto ci bufora ............................................................................. 739
Funkcje obs uguj ce wyj cie .............................................................................. 739
Manipulatory, znaczniki oraz instrukcje formatowania ........................ 741
Strumienie kontra funkcja printf() ........................................................................ 747
Wej cie i wyj cie z u yciem plików ....................................................................... 751
ofstream ...................................................................................................................... 751
Stany strumieni ........................................................................................................ 751
Otwieranie plików dla wej cia i wyj cia ....................................................... 751
Zmiana domy lnego zachowania obiektu ofstream
w trakcie otwierania pliku ............................................................................... 753
Pliki binarne a pliki tekstowe ................................................................................... 756
Przetwarzanie linii polecenia ................................................................................... 759
Podsumowanie ................................................................................................................ 763
Pytania i odpowiedzi .................................................................................................... 763
Warsztaty .......................................................................................................................... 764
Quiz ............................................................................................................................... 765
wiczenia .................................................................................................................... 765
Lekcja 28. Obs uga wyj tków 767
Pluskwy, b dy, pomy ki i  psuj cy si  kod ...................................................... 767
Sytuacje wyj tkowe ............................................................................................... 768
Wyj tki ................................................................................................................................ 770
Jak u ywane s wyj tki ........................................................................................ 771
Zg aszanie w asnych wyj tków ........................................................................ 775
Tworzenie klasy wyj tku ..................................................................................... 777
Umiejscowienie bloków try oraz bloków catch ................................................ 781
Sposób dzia ania przechwytywania wyj tków ................................................ 781
Wychwytywanie wi cej ni jednego rodzaju wyj tków ........................ 782
Hierarchie wyj tków ............................................................................................. 785
Dane w wyj tkach oraz nazwane obiekty wyj tków ..................................... 789
Wyj tki i wzorce ............................................................................................................. 796
Wyj tki bez b dów ...................................................................................................... 799
B dy i usuwanie b dów ........................................................................................... 800
Punkty wstrzymania .............................................................................................. 801
ledzenie warto ci zmiennych .......................................................................... 801
Sprawdzanie pami ci ............................................................................................ 802
Asembler ..................................................................................................................... 802
20 C++ dla ka dego
Podsumowanie ................................................................................................................802
Pytania i odpowiedzi .....................................................................................................803
Warsztaty ...........................................................................................................................804
Quiz ................................................................................................................................804
wiczenia ....................................................................................................................805
Lekcja 29. Wi cej informacji na temat preprocesora 807
Preprocesor i kompilator ............................................................................................807
U ycie dyrektywy #define ..........................................................................................808
U ycie #define dla sta ych ...................................................................................808
U ycie #define do testowania ............................................................................809
Dyrektywa #else preprocesora .........................................................................810
Do czanie i wartowniki do czania ......................................................................811
Manipulacje ci gami tekstowymi ............................................................................813
Zamiana na ci g tekstowy ....................................................................................813
Konkatenacja .............................................................................................................813
Makra predefiniowane .................................................................................................814
Makro assert() .................................................................................................................814
Debuggowanie za pomoc makra assert() ...................................................816
Makro assert() a wyj tki ......................................................................................817
Efekty uboczne .........................................................................................................817
Niezmienniki klas ....................................................................................................818
Wy wietlanie warto ci tymczasowych ..........................................................824
Operacje na bitach ..........................................................................................................825
Operator AND ............................................................................................................826
Operator OR ...............................................................................................................826
Operator wy czaj cy OR .....................................................................................827
Operator negacji .......................................................................................................827
Ustawianie bitów .....................................................................................................827
Zerowanie bitów ......................................................................................................828
Zmiana stanu bitów na przeciwny ...................................................................828
Pola bitowe .................................................................................................................829
Styl programowania ......................................................................................................832
Wci cia .........................................................................................................................833
Nawiasy klamrowe .................................................................................................833
D ugo linii oraz d ugo funkcji ....................................................................833
Instrukcje switch .....................................................................................................834
 Spis tre ci 21
Tekst programu ....................................................................................................... 834
Nazwy identyfikatorów ........................................................................................ 835
Pisownia nazw i zastosowanie w nich wielkich liter .............................. 836
Komentarze ............................................................................................................... 836
Konfiguracja dost pu ............................................................................................ 837
Definicje klas ............................................................................................................. 838
Do czanie plików .................................................................................................. 838
U ywanie makra assert() .................................................................................... 838
U ywanie modyfikatora const .......................................................................... 838
Nast pne kroki w programowaniu C++ ............................................................... 839
Gdzie uzyska pomoc i porad .......................................................................... 839
Tematy powi zane z C++: rozszerzenie Managed C++, C#
oraz platforma .NET firmy Microsoft .......................................................... 840
Podsumowanie ................................................................................................................ 841
Pytania i odpowiedzi .................................................................................................... 841
Warsztaty .......................................................................................................................... 843
Quiz ............................................................................................................................... 843
wiczenia .................................................................................................................... 843
Dodatki
Dodatek A Praca z liczbami: dwójkowo i szesnastkowo 847
Inne podstawy ................................................................................................................. 848
Konwersja na inn podstaw ................................................................................... 849
Dwójkowo .................................................................................................................. 851
Dlaczego podstawa 2? ........................................................................................... 852
Bity, bajty, nible ....................................................................................................... 852
Co to jest KB? ............................................................................................................ 853
Liczby dwójkowe ..................................................................................................... 853
Szesnastkowo .................................................................................................................. 853
Dodatek B S owa kluczowe C++ 859
Dodatek C Kolejno operatorów 861
Dodatek D Odpowiedzi 863
Skorowidz 919
Czy C++ jest zorientowane obiektowo? 307
Lekcja 10
Klasy i obiekty
Klasy rozszerzaj wbudowane w C++ mo liwo ci, u atwiaj ce rozwi zywanie
z o onych,  rzeczywistych problemów.
Z tej lekcji dowiesz si :

czym s klasy i obiekty,

jak definiowa now klas oraz tworzy obiekty tej klasy,

czym s funkcje i dane sk adowe,

czym s konstruktory i jak z nich korzysta .
Czy C++ jest zorientowane obiektowo?
W pewnym momencie j zyk C, czyli poprzednik C++, by najpopularniejszym
j zykiem programowania na wiecie u ywanym do tworzenia oprogramowania
komercyjnego. By wykorzystywany do tworzenia systemów operacyjnych
(na przyk ad systemu Unix), do tworzenia oprogramowania dzia aj cego w czasie
rzeczywistym (kontrola maszyn, urz dze i elektroniki). Dopiero pó niej zacz
by stosowany jako j zyk programowania s u cy do budowy innych j zyków
konwencjonalnych. Opracowanie j zyka C pozwoli o na znalezienie atwiejszego
i bezpieczniejszego sposobu zbli enia oprogramowania i osprz tu.
J zyk C jest etapem po rednim pomi dzy wysokopoziomowymi j zykami aplikacji
 firmowych , takimi jak COBOL, a niskopoziomowym, wysokowydajnym, lecz
trudnym do u ycia asemblerem. C wymusza programowanie  strukturalne ,
w którym poszczególne zagadnienia s dzielone na mniejsze jednostki powtarzalnych
dzia a , zwanych funkcjami, natomiast dane s umieszczane w pakietach
nazywanych strukturami.
308 Lekcja 10. Klasy i obiekty
Jednak j zyki takie jak Smalltalk i CLU zacz y torowa drog w nowym kierunku
 programowania zorientowanego obiektowo. Ten rodzaj programowania
pozwala na umieszczanie w pojedynczej jednostce  obiekcie  podzespo ów
danych takich jak struktura oraz funkcja.
wiat jest wype niony przedmiotami: samochodami, psami, drzewami, chmurami,
kwiatami. Rzeczy. Ka da rzecz ma charakterystyk (szybki, przyjazny, br zowy,
puszysty, adny). Wi kszo rzeczy cechuje jakie zachowanie (ruch, szczekanie,
wzrost, deszcz, uwi d). Nie my limy o danych samochodu i o tym, jak mogliby my
nimi manipulowa  my limy o samochodzie jako o rzeczy: do czego jest podobny
i co robi. Z tym samym mo emy si zetkn po przeniesieniu do wiata komputerów
dowolnego  rzeczywistego obiektu.
Programy, które piszemy na pocz tku dwudziestego pierwszego wieku, s du o
bardziej z o one ni te, które by y pisane pod koniec wieku dwudziestego. Programy
stworzone w j zykach proceduralnych s trudne w zarz dzaniu i konserwacji,
a ich rozbudowa jest niemo liwa. Graficzne interfejsy u ytkownika, Internet,
telefonia cyfrowa i bezprzewodowa oraz wiele innych technologii, znacznie
zwi kszy y poziom skomplikowania nowych projektów, a wymagania
konsumentów dotycz ce jako ci interfejsu u ytkownika wzros y.
Programowanie zorientowane obiektowo oferuje narz dzie pomagaj ce
w sprostaniu wyzwaniom stoj cym przed twórcami oprogramowania. Chocia
nie istnieje z oty rodek dla tworzenia skomplikowanego oprogramowania,
j zyki zorientowane obiektowo stworzy y silne wi zy pomi dzy strukturami
danych a metodami manipulowania tymi danymi. Ponadto jeszcze bardziej zbli aj
si do sposobu my lenia ludzi (programistów i klientów), usprawniaj c tym
samym komunikacj oraz poprawiaj c jako tworzonego oprogramowania.
A co najwa niejsze, w programowaniu zorientowanym obiektowo nie musisz
ju my le o strukturach danych i manipuluj cych nimi funkcjach; my lisz
o obiektach w taki sposób, jakby by y odpowiednikami obiektów w rzeczywisto ci:
czyli jak one wygl daj i jak dzia aj .
J zyk C++ stanowi pomost pomi dzy programowaniem zorientowanym obiektowo
a j zykiem C. Celem jego autorów by o stworzenie obiektowo zorientowanego
j zyka dla tej szybkiej i efektywnej platformy s u cej do tworzenia oprogramowania
komercyjnego, ze szczególnym naciskiem na wysok wydajno . W dalszej cz ci
lekcji przekonasz si , jak C++ osi ga cele postawione przed j zykiem.
Tworzenie nowych typów 309
Tworzenie nowych typów
Programy s zwykle pisane w celu rozwi zania jakiego realnego problemu,
takiego jak prowadzenie rejestru pracowników czy symulacja dzia ania systemu
grzewczego. Cho istnieje mo liwo rozwi zywania tych problemów za pomoc
programów napisanych wy cznie przy u yciu liczb ca kowitych i znaków, jednak
w przypadku wi kszych, bardziej rozbudowanych problemów, du o atwiej jest
stworzy reprezentacje obiektów, o których si mówi. Innymi s owy, symulowanie
dzia ania systemu grzewczego b dzie atwiejsze, gdy stworzymy zmienne
reprezentuj ce pomieszczenia, czujniki ciep a, termostaty i bojlery. Im bardziej
te zmienne odpowiadaj rzeczywisto ci, tym atwiejsze jest napisanie programu.
Pozna e ju kilka typów zmiennych, m.in. liczby ca kowite i znaki. Typ zmiennej
dostarcza nam kilka informacji o niej. Na przyk ad, je li zadeklarujesz zmienne
Height (wysoko ) i Width (szeroko ) jako liczby ca kowite typu unsigned
short int, wiesz, e w ka dej z nich mo esz przechowa warto z przedzia u od
0 do 65 535 (przy za o eniu e typ unsigned short int zajmuje dwa bajty pami ci).
S to liczby ca kowite bez znaku; próba przechowania w nich czegokolwiek
innego powoduje b d. W zmiennej typu unsigned short nie mo esz umie ci
swojego imienia, nie powiniene nawet próbowa .
Deklaruj c te zmienne jako unsigned short int, wiesz, e mo esz doda do
siebie wysoko i szeroko oraz przypisa t warto innej zmiennej.
Typ zmiennych informuje:

o ich rozmiarze w pami ci,

jaki rodzaj informacji mog zawiera ,

jakie dzia ania mo na na nich wykonywa .
W tradycyjnych j zykach, takich jak C, typy by y wbudowane w j zyk. W C++
programista mo e rozszerzy j zyk, tworz c potrzebne mu typy, za ka dy z tych
nowych typów mo e by w pe ni funkcjonalny i dysponowa t sam si , co typy
wbudowane.
Wady tworzenia typów za pomoc s owa kluczowego struct
Pewne mo liwo ci rozszerzenia j zyka C nowymi typami wi si z czeniem
w struktury (struct) powi zanych ze sob zmiennych, które mog by dost pne
w postaci nowego typu danych za pomoc instrukcji typedef. Jednak istniej
pewne wady takiego podej cia:
310 Lekcja 10. Klasy i obiekty

Struktury i operuj ce na nich funkcje nie s spójnymi ca o ciami. Funkcje
mo na znale jedynie poprzez odczyt plików nag ówkowych z dost pnych
bibliotek i wyszukanie tych z nowym typem jako parametrem.

Koordynacja aktywno ci grupy powi zanych funkcji w strukturze jest trudniejszym
zadaniem, poniewa dowolny fragment logiki programu mo e w dowolnej
chwili zmieni cokolwiek w strukturze. Z tego powodu nie ma mo liwo ci
ochrony struktury przed ingerencj .

Wbudowane operatory nie dzia aj ze strukturami  nie dzia a nawet
dodanie dwóch struktur za pomoc znaku plus (+), cho taka operacja
mog aby si wydawa najbardziej naturalnym sposobem przedstawienia
rozwi zania problemu (na przyk ad, kiedy ka da struktura przedstawia
skomplikowane fragmenty tekstu, które maj by ze sob po czone).
Wprowadzenie klas
i elementów sk adowych
Nowy typ zmiennych tworzy si , deklaruj c klas . Klasa jest w a ciwie grup
zmiennych  cz sto o ró nych typach  skojarzonych z zestawem odnosz cych
si do nich funkcji.
Jedn z mo liwo ci my lenia o samochodzie jest potraktowanie go jako zbioru
kó , drzwi, foteli, okien itd. Inna mo liwo to wyobra enie sobie, co samochód
mo e zrobi : je dzi , przyspiesza , zwalnia , zatrzymywa si , parkowa itd.
Klasa umo liwia hermetyzacj , czyli upakowanie, tych ró nych cz ci oraz
ró nych dzia a w jeden zbiór, który jest nazywany obiektem.
Upakowanie wszystkiego, co wiesz o samochodzie, w jedn klas przynosi
programi cie liczne korzy ci. Wszystko jest na miejscu, u atwia to odwo ywanie si ,
kopiowanie i manipulowanie danymi. Klienci Twojej klasy  tj. te cz ci programu,
które z niej korzystaj  mog u ywa Twojego obiektu bez zastanawiania si ,
co znajduje si w rodku i jak on dzia a.
Klasa mo e sk ada si z dowolnej kombinacji zmiennych prostych oraz zmiennych
innych klas. Zmienna wewn trz klasy jest nazywana zmienn sk adow lub
dan sk adow . Klasa Car (samochód) mo e posiada sk adowe reprezentuj ce
siedzenia, typ radia, opony itd. Zmienne sk adowe s zmiennymi w danej klasie.
Stanowi one cz klasy, tak jak ko a i silnik stanowi cz samochodu.
Wprowadzenie klas i elementów sk adowych 311
Klasa mo e zawiera równie funkcje, które s wówczas nazywane funkcjami
sk adowymi lub metodami. Podobnie jak zmienne sk adowe, stanowi cz
klasy i okre laj , co dana klasa mo e zrobi .
Funkcje w danej klasie zwykle manipuluj zmiennymi sk adowymi. Przyk adowo,
metodami klasy Car mog by Start() (uruchom) oraz Brake() (hamuj). Klasa Cat
(kot) mo e posiada zmienne sk adowe, reprezentuj ce wiek i wag ; jej metodami
mog by Sleep() ( pij), Meow() (miaucz) czy ChaseMice() ( ap myszy).
Deklarowanie klasy
Deklaracja klasy informuje kompilator o jej istnieniu. Aby zadeklarowa klas ,
u yj s owa kluczowego class, po którym nast puje otwieraj cy nawias klamrowy,
a nast pnie lista danych sk adowych i metod tej klasy. Deklaracja ko czy si
zamykaj cym nawiasem klamrowym i rednikiem. Oto deklaracja klasy o nazwie
Cat (kot):
class Cat
{
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};
Zadeklarowanie takiej klasy nie powoduje zaalokowania pami ci dla obiektu Cat.
Informuje jedynie kompilator, czym jest typ Cat, jakie dane zawiera (itsAge
 jego wiek oraz itsWeight  jego waga) oraz co mo e robi (Meow()  miaucz).
Informuje tak e kompilator, jak du a jest zmienna typu Cat  to jest, jak du o
miejsca w pami ci ma przygotowa w przypadku tworzenia zmiennej typu Cat.
W tym przyk adzie, o ile typ int ma cztery bajty, zmienna typu Cat zajmuje osiem
bajtów: cztery bajty dla zmiennej itsAge i cztery dla zmiennej itsWeight.
Funkcja Meow() nie zajmuje miejsca, gdy dla funkcji sk adowych (metod)
miejsce nie jest rezerwowane. Jest to wska nik do funkcji, który na platformie
32-bitowej mo e zaj cztery bajty.
Kilka s ów o konwencji nazw
Jako programista, musisz nazwa wszystkie swoje zmienne sk adowe, funkcje
sk adowe oraz klasy. Jak przeczyta e w lekcji 3.,  Sta e i zmienne , nazwy te
powinny by zrozumia e i znacz ce. Dobrymi nazwami klas mog by wspomniana
312 Lekcja 10. Klasy i obiekty
Cat, Rectangle (prostok t) czy Employee (pracownik). Meow(), ChaseMice()
czy StopEngine() (zatrzymaj silnik) równie s dobrymi nazwami funkcji, gdy
informuj , co robi te funkcje. Wielu programistów nadaje nazwom zmiennych
sk adowych przedrostek  its (jego), tak jak w zmiennych itsAge, itsWeight
czy itsSpeed (jego szybko ). Pomaga to w odró nieniu zmiennych sk adowych
od innych zmiennych.
Niektórzy programi ci wol przedrostek  my (mój), tak jak w nazwach myAge,
myWeight czy mySpeed. Jeszcze inni u ywaj po prostu litery m (od s owa member
 sk adowa), czasem wraz ze znakiem podkre lenia (_): mAge i m_age, mWeight
i m_weight czy mSpeed i m_speed.
Niektórzy programi ci lubi poprzedzi ka d nazw klasy okre lon liter
 na przyk ad cCat czy cPerson  podczas, gdy inni u ywaj wy cznie du ych
lub ma ych liter. Ja sam korzystam z konwencji, w której wszystkie nazwy klas
rozpoczynaj si od du ej litery, tak jak Cat czy Person (osoba).
Wielu programistów rozpoczyna wszystkie nazwy funkcji od du ej litery, za
wszystkie nazwy zmiennych  od ma ej. S owa zwykle rozdzielane s znakiem
podkre lenia  tak jak w Chase_Mice  lub poprzez zastosowanie du ej litery
dla ka dego s owa  na przyk ad ChaseMice czy DrawCircle (rysuj okr g).
Wa ne jest, by wybra okre lony styl i trzyma si go w ka dym programie.
Z czasem rozwiniesz swój styl nie tylko na konwencje nazw, ale tak e na wci cia,
wyrównanie nawiasów klamrowych oraz styl komentarzy.
W firmach programistycznych powszechne jest okre lenie standardu wielu
elementów stylu zapisu kodu ród owego. Sprawia on, e wszyscy programi ci
mog atwo odczytywa wzajemnie swój kod. Niestety, przenosi si to równie do
firm opracowuj cych systemy operacyjne i biblioteki klas przeznaczonych do
ponownego u ytku. Zazwyczaj oznacza to, e w programach C++ jest jednocze nie
stosowanych wiele ró nych konwencji nazw.
Jak ju wcze niej wspomniano, j zyk C++ uwzgl dnia wielko liter, dlatego
wszystkie nazwy klas powinny przestrzega tej samej konwencji. Dzi ki temu nigdy
nie b dziesz musia sprawdza pisowni nazwy klasy (czy to by o Rectangle,
rectangle czy RECTANGLE?).
Dost p do elementów sk adowych klasy 313
Definiowanie obiektu
Po zadeklarowaniu klasy mo na jej nast pnie u ywa jako nowego typu dla
definiowanych zmiennych tego typu. Definiowanie obiektu nowego typu
przypomina definiowanie zmiennej ca kowitej:
unsigned int GrossWeight; // definicja zmiennej typu unsigned int
Cat Frisky; // definicja zmiennej typu Cat
Ten kod definiuje zmienn o nazwie GrossWeight ( czna waga), której typem
jest unsigned int. Oprócz tego definiuje zmienn o nazwie Frisky, która jest
obiektem klasy (typu) Cat.
Klasy a obiekty
Nigdy nie karmi si definicji kota, lecz konkretnego kota. Nale y dokona
rozró nienia pomi dzy ide kota a konkretnym kotem, który w a nie ociera si
o Twoje nogi. C++ równie dokonuje rozró nienia pomi dzy klas Cat, b d c
ide kota, a poszczególnymi obiektami typu Cat. Tak wi c Frisky jest obiektem
typu Cat, tak jak GrossWeight jest zmienn typu unsigned int. Obiekt jest
indywidualnym egzemplarzem klasy.
Dost p do elementów sk adowych klasy
Gdy zdefiniujesz ju faktyczny obiekt Cat  na przyk ad:
Cat Frisky;
w celu uzyskania dost pu do jego sk adowych mo esz u y operatora kropki (.).
Aby zmiennej sk adowej itsWeight obiektu Frisky przypisa warto 50,
powiniene napisa :
Frisky.itsWeight = 50;
Aby wywo a funkcj Meow(), mo esz napisa :
Frisky.Meow();
Gdy u ywasz metody klasy, oznacza to, e wywo ujesz t metod . W tym
przyk adzie wywo a e metod Meow() obiektu Frisky.
314 Lekcja 10. Klasy i obiekty
Przypisywa nale y obiektom, nie klasom
W C++ nie przypisuje si warto ci typom; przypisuje si je zmiennym. Na przyk ad,
nie mo na napisa :
int = 5; // le
Kompilator uzna to za b d, gdy nie mo na przypisa warto ci pi typowi
ca kowitemu. Zamiast tego musisz zdefiniowa zmienn typu ca kowitego
i przypisa jej warto 5. Na przyk ad:
int x ; // definicja zmiennej typu int
x = 5; // ustawienie warto ci zmiennej x na 5
Jest to skrócony zapis stwierdzenia:  Przypisz warto 5 zmiennej x, która jest
zmienn typu int . Nie mo na równie napisa :
Cat.itsAge = 5; // le
Kompilator uzna to za b d, gdy nie mo esz przypisa warto ci 5 do elementu
itsAge klasy Cat. Zamiast tego musisz zdefiniowa egzemplarz obiektu klasy
Cat i dopiero wtedy przypisa warto jego sk adowej. Na przyk ad:
Cat Frisky; // podobnie jak int x;
Frisky.itsAge = 5; // podobnie jak x = 5;
Czego nie zadeklarujesz,
tego klasa nie b dzie mia a
Przeprowad taki eksperyment: podejd do trzylatka i poka mu kota. Nast pnie
powiedz: To jest Frisky. Frisky zna sztuczk . Frisky, zaszczekaj! Dziecko roze mieje
si i powie:  Nie, g uptasie, koty nie szczekaj ! .
Je li napisa e :
Cat Frisky; // tworzy obiekt Cat o nazwie Frisky
Frisky.Bark(); // nakazuje Friskiemu szczeka
Kompilator wy wietli komunikat:  Nie, g uptasie, koty (cats) nie szczekaj ! .
(By mo e w Twoim kompilatorze ten komunikat b dzie brzmia nieco inaczej).
Kompilator wie, e Frisky nie mo e szczeka , gdy klasa Cat nie posiada metody
Bark() (szczekaj). Kompilator nie pozwoli Friskiemu nawet zamiaucze , je li nie
zdefiniujesz dla niego funkcji Meow() (miaucz).
Dost p prywatny i publiczny 315
Tak Nie
Do deklarowania klasy u ywaj s owa Nie myl deklaracji z definicj . Deklaracja
kluczowego class. mówi czym jest klasa, a definicja
przygotowuje pami dla obiektu.
W celu uzyskania dost pu do zmiennych
i funkcji sk adowych klasy u ywaj Nie myl klasy z obiektem.
operatora kropki (.).
Nie przypisuj klasie warto ci. Warto ci
przypisuj danym sk adowym obiektu.
Dost p prywatny i publiczny
W deklaracji klasy u ywanych jest tak e kilka innych s ów kluczowych. Dwa
najwa niejsze z nich to: public (publiczny) i private (prywatny).
S owa kluczowe private i public s u ywane wraz z egzemplarzami klasy
 zarówno ze zmiennymi sk adowymi, jak i metodami klasy. Prywatne sk adowe
mog by u ywane tylko przez metody nale ce do danej klasy. Sk adowe
publiczne s dost pne dla innych funkcji i klas. To rozró nienie jest wa ne, cho
na pocz tku mo e sprawia k opot. Wszystkie sk adowe klasy  dane i metody
 s domy lnie prywatne. Aby to lepiej wyja ni , spójrzmy na poprzedni przyk ad:
class Cat
{
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};
W tej deklaracji, sk adowe itsAge, itsWeight oraz Meow() s prywatne, gdy
wszystkie sk adowe klasy s prywatne domy lnie. Oznacza to, e dopóki nie
postanowisz inaczej, pozostan one prywatne. Je li jednak w funkcji main()
napiszesz na przyk ad:
Cat Bobas;
Bobas.itsAge = 5; // b d! nie mo na u ywa prywatnych danych!
kompilator uzna to za b d. We wcze niejszej deklaracji powiedzia e kompilatorowi,
e sk adowych itsAge, itsWeight oraz Meow() b dziesz u ywa tylko w funkcjach
sk adowych klasy Cat. W powy szym fragmencie kodu próbujesz odwo a si
do zmiennej sk adowej obiektu Bobas spoza metody klasy Cat. To, e Bobas jest
obiektem klasy Cat, nie oznacza, e mo esz korzysta z tych elementów obiektu
Bobas, które s prywatne.
316 Lekcja 10. Klasy i obiekty
W a nie to jest ród em nieko cz cych si k opotów pocz tkuj cych programistów
C++. Ju s ysz , jak narzekasz:  Hej! W a nie napisa em, e Bobas jest kotem, tj.
obiektem klasy Cat. Dlaczego Bobas nie ma dost pu do swojego w asnego wieku? .
Odpowied brzmi: Bobas ma dost p, ale Ty nie masz. Bobas, w swoich w asnych
metodach, ma dost p do wszystkich swoich sk adowych, zarówno publicznych,
jak i prywatnych. Nawet je li to Ty tworzysz obiekt klasy Cat, nie mo esz
przegl da ani zmienia tych jego sk adowych, które s prywatne.
Aby mie dost p do sk adowych obiektu Cat, pewne elementy sk adowe powinny
by publiczne:
class Cat
{
public:
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};
Teraz sk adowe itsAge, itsWeight oraz Meow() s publiczne. Bobas.itsAge = 5;
kompiluje si bez problemów.
S owo kluczowe public ma zastosowanie wzgl dem wszystkich elementów
sk adowych w danej deklaracji a do napotkania s owa kluczowego private i na
odwrót. W ten sposób sekcje klasy mo na bardzo atwo zadeklarowa jako
publiczne b d prywatne.
Listing 10.1 przedstawia deklaracj klasy Cat z publicznymi zmiennymi sk adowymi.
Listing 10.1. Dost p do publicznych sk adowych w prostej klasie
1: // Demonstruje deklaracj klasy oraz
2: // definicje obiektu tej klasy.
3:
4: #include
5:
6: class Cat // deklaruj klas Cat (kot)
7: {
8: public: // nast puj ce po tym sk adowe s publiczne
9: int itsAge; // zmienna sk adowa
10: int itsWeight; // zmienna sk adowa
11: }; // zwró uwag na rednik
12:
13: int main()
14: {
15: Cat Frisky;
Dost p prywatny i publiczny 317
16: Frisky.itsAge = 5; // przypisanie do zmiennej sk adowej
17: std::cout << "Frisky jest kotem i ma " ;
18: std::cout << Frisky.itsAge << " lat.\n";
19: return 0;
20: }
Wynik
Frisky jest kotem i ma 5 lat.
Analiza
Linia 6. zawiera s owo kluczowe class. Informuje ono kompilator, e nast puje
po nim deklaracja klasy. Nazwa nowej klasy nast puje bezpo rednio po s owie
kluczowym class. W tym przypadku nazw klasy jest Cat (kot).
Cia o deklaracji rozpoczyna si w linii 7. od otwieraj cego nawiasu klamrowego
i ko czy si zamykaj cym nawiasem klamrowym i rednikiem w linii 11. Linia 8.
zawiera s owo kluczowe public, które wskazuje, e wszystko, co po nim nast pi,
b dzie publiczne, a do natrafienia na s owo kluczowe private lub koniec deklaracji
klasy. Linie 9. i 10. zawieraj deklaracje sk adowych klasy, itsAge (jego wiek)
oraz itsWeight (jego waga).
W linii 13. rozpoczyna si funkcja main(). W linii 15. Frisky jest definiowany
jako egzemplarz klasy Cat  tj. jako obiekt klasy Cat. W linii 16. wiek Friska
jest ustawiany na 5. W liniach 17. i 18. zmienna sk adowa itsAge zostaje u yta
do wy wietlenia informacji o kocie Frisky. Powiniene zauwa y , jak w liniach
16. i 18. nast puje uzyskanie dost pu do obiektu Frisky. Zmienna itsAge jest
dost pna poprzez nazw obiektu (w tym przyk adzie Frisky), nast pnie kropk
i nazw zmiennej sk adowej (w tym przypadku itsAge).
Spróbuj wykomentowa lini 8., po czym skompiluj program ponownie. W linii 16.
wyst pi b d, gdy zmienna sk adowa itsAge nie b dzie ju sk adow publiczn .
Domy lnie, wszystkie sk adowe klasy s prywatne.
Oznaczanie danych sk adowych
jako prywatnych
Powiniene przyj jako ogóln regu , e dane sk adowe klasy nale y utrzymywa
jako prywatne. Oczywi cie, mo esz si zastanawia , w jaki sposób uzyska
informacje dotycz ce klasy, je li wszystkie elementy sk adowe b d prywatne.
318 Lekcja 10. Klasy i obiekty
Przyk adowo, je li zmienna itsAge b dzie prywatna, jak mo na odczyta b d
ustawi wiek obiektu Cat?
W celu uzyskania dost pu do danych prywatnych w klasie musisz stworzy
publiczne funkcje sk adowe, zwane akcesorami. Funkcje te umo liwi odczyt
zmiennych sk adowych i przypisywanie im warto ci. Te funkcje dost powe
(akcesory) s funkcjami sk adowymi, u ywanymi przez inne cz ci programu
w celu odczytywania i ustawiania prywatnych zmiennych sk adowych. Publiczny
akcesor jest funkcj sk adow klasy, u ywan albo do odczytu warto ci prywatnej
zmiennej sk adowej klasy, albo do ustawiania warto ci tej zmiennej.
Dlaczego mia by utrudnia sobie ycie dodatkowym poziomem po redniego
dost pu? Po co dodawa kolejne funkcje, skoro pro ciej i atwiej jest bezpo rednio
pos ugiwa si danymi? Jaki cel ma stosowanie akcesorów?
Odpowied na te pytania jest ca kiem prosta: akcesory umo liwiaj oddzielenie
szczegó ów przechowywania danych klasy od szczegó ów jej u ywania. Dzi ki
temu mo esz zmienia sposób przechowywania danych klasy bez konieczno ci
przepisywania funkcji, które z tych danych korzystaj .
Je li funkcja, która chce pozna wiek kota, odwo a si bezpo rednio do zmiennej
itsAge klasy Cat, b dzie musia a zosta przepisana, je eli Ty, jako autor klasy
Cat, zdecydujesz si na zmian sposobu przechowywania tej zmiennej. Jednak
posiadaj c funkcj sk adow GetAge() (pobierz wiek), klasa Cat mo e atwo
zwróci w a ciw warto bez wzgl du na to, w jaki sposób przechowywany
b dzie wiek. Funkcja wywo uj ca nie musi wiedzie , czy jest on przechowywany
jako zmienna typu unsigned int czy long lub czy wiek jest obliczany w miar
potrzeb.
Ta technika u atwia zapanowanie nad programem. Przed u a istnienie kodu,
gdy zmiany projektowe nie powoduj , e program staje si przestarza y.
Oprócz tego funkcje akcesorów mog zawiera dodatkow logik  na przyk ad
ma o prawdopodobne jest, aby wiek kota (obiektu Cat) przekroczy warto 100,
a jego waga przekroczy a warto 1000. Wymienione warto ci powinny by
niedozwolone. Funkcja akcesora mo e wymusi stosowanie tego rodzaju
ogranicze , jak równie wykonywa wiele innych zada .
Listing 10.2 przedstawia klas Cat zmodyfikowan tak, by zawiera a prywatne
dane sk adowe i publiczne akcesory. Zwró uwag , e ten listing przedstawia
wy cznie deklaracj klasy, nie ma w nim kodu wykonywalnego.
Dost p prywatny i publiczny 319
Listing 10.2. Klasa z akcesorami
1: // Deklaracja klasy Cat
2: // Dane sk adowe s prywatne, publiczne akcesory po rednicz
3: // w ustawianiu i odczytywaniu warto ci sk adowych prywatnych
4: class Cat
5: {
6: public:
7: // publiczne akcesory
8: unsigned int GetAge();
9: void SetAge(unsigned int Age);
10:
11: unsigned int GetWeight();
12: void SetWeight(unsigned int Weight);
13:
14: // publiczna funkcja sk adowa
15: void Meow();
16:
17: // prywatne dane sk adowe
18: private:
19: unsigned int itsAge;
20: unsigned int itsWeight;
21: };
Analiza
Ta klasa posiada pi metod publicznych. Linie 8. i 9. zawieraj akcesory dla
sk adowej itsAge. Mo esz zobaczy , e w linii 8. znajduje si metoda pobieraj ca
wiek kota, natomiast w linii 9. metoda ustawiaj ca wiek kota. Linie 11. i 12.
zawieraj podobne akcesory dla sk adowej itsWeight. Te akcesory ustawiaj
zmienne sk adowe i zwracaj ich warto ci.
W linii 15. jest zadeklarowana publiczna funkcja sk adowa Meow(). Ta funkcja
nie jest akcesorem. Nie zwraca warto ci ani ich nie ustawia; wykonuje inn
us ug dla klasy  wy wietla s owo Miau. Zmienne sk adowe s zadeklarowane
w liniach 19. i 20.
Aby ustawi wiek Friska, powiniene przekaza warto metodzie SetAge()
(ustaw wiek), na przyk ad:
Cat Frisky;
Frisky.SetAge(5); // ustawia wiek Friska
// u ywaj c publicznego akcesora
W dalszej cz ci lekcji poznasz kod, dzi ki któremu metoda SetAge() oraz inne
mog dzia a .
320 Lekcja 10. Klasy i obiekty
Zadeklarowanie metod lub danych jako prywatnych umo liwia kompilatorowi
wyszukanie w programach pomy ek, zanim stan si one b dami. Ka dy szanuj cy
si programista potrafi znale sposób na obej cie prywatno ci sk adowych.
Stroustrup, autor j zyka C++, stwierdza, e  ...mechanizmy ochrony z poziomu
j zyka chroni przed pomy k , a nie przed wiadomym oszustwem (WNT, 1995).
S owo kluczowe class
Sk adnia s owa kluczowego class jest nast puj ca:
class nazwa_klasy
{
// s owa kluczowe kontroli dost pu
// zadeklarowane zmienne i sk adowe klasy
};
S owo kluczowe class s u y do deklarowania nowych typów. Klasa stanowi zbiór
danych sk adowych klasy, które s zmiennymi ró nych typów, tak e innych klas.
Klasa zawiera tak e funkcje klasy  tzw. metody  które s funkcjami u ywanymi
do manipulowania danymi w danej klasie i wykonywania innych us ug dla klasy.
Obiekty nowego typu definiuje si w taki sam sposób, w jaki definiuje si inne
zmienne. Nale y okre li typ (klas ), a po nim nazw zmiennej (obiektu).
Do uzyskania dost pu do funkcji i danych klasy s u y operator kropki (.).
S owa kluczowe kontroli dost pu okre laj , które sekcje klasy s prywatne, a które
publiczne. Domy lnie wszystkie sk adowe klasy s prywatne. Ka de s owo kluczowe
zmienia kontrol dost pu od danego miejsca a do ko ca klasy, lub kontrol
wyst pienia nast pnego s owa kluczowego kontroli dost pu. Deklaracja klasy
ko czy si zamykaj cym nawiasem klamrowym i rednikiem.
Przyk ad 1
class Cat
{
public:
unsigned int Age;
unsigned int Weight;
void Meow();
};
Cat Frisky;
Frisky.Age = 8;
Frisky.Weight = 18;
Frisky.Meow();
Przyk ad 2
class Car
{
Implementowanie metod klasy 321
public: // pi nast pnych sk adowych jest publicznych
void Start();
void Accelerate();
void Brake();
void SetYear(int year);
int GetYear();
private: // pozosta a cz jest prywatna
int Year;
char Model [255];
}; // koniec deklaracji klasy
Car OldFaithful; // tworzy egzemplarz klasy
int bought; // lokalna zmienna typu int
OldFaithful.SetYear(84); // ustawia sk adow Year na 84
bought = OldFaithful.GetYear(); // ustawia zmienn bought na 84
OldFaithful.Start(); //wywo uje metod Start
Tak Nie
U ywaj publicznych akcesorów, czyli Nie deklaruj zmiennych sk adowych
publicznych funkcji dost powych. jako publiczne, o ile nie ma takiej
potrzeby.
Odwo uj si do prywatnych zmiennych
sk adowych z funkcji sk adowych Nie u ywaj prywatnych zmiennych
klasy. sk adowych klasy poza t klas .
Implementowanie metod klasy
Jak ju si przekona e , akcesory stanowi publiczny interfejs do prywatnych
danych klasy. Ka dy akcesor musi posiada , wraz z innymi zadeklarowanymi
metodami klasy, implementacj . Implementacja jest nazywana definicj funkcji.
Definicja funkcji sk adowej rozpoczyna si podobnie jak definicja zwyk ej funkcji.
W pierwszej kolejno ci trzeba poda typ zwracany z danej funkcji lub u y
s owa kluczowego void, je li funkcja niczego nie zwraca. Nast pnie podajemy
nazw klasy, po której wyst puj dwa dwukropki, nazwa funkcji i jej parametry.
Listing 10.3 przedstawia pe n deklaracj prostej klasy Cat, wraz z implementacj
jej akcesorów i jednej ogólnej funkcji tej klasy.
322 Lekcja 10. Klasy i obiekty
Listing 10.3. Implementacja metod prostej klasy
1: // Demonstruje deklarowanie klasy oraz
2: // definiowanie jej metod
3: #include // dla cout
4:
5: class Cat // pocz tek deklaracji klasy
6: {
7: public: // pocz tek sekcji publicznej
8: int GetAge(); // akcesor
9: void SetAge(int age); // akcesor
10: void Meow(); // ogólna funkcja
11: private: // pocz tek sekcji prywatnej
12: int itsAge; // zmienna sk adowa
13: };
14:
15: // GetAge, publiczny akcesor
16: // zwracaj cy warto sk adowej itsAge
17: int Cat::GetAge()
18: {
19: return itsAge;
20: }
21:
22: // definicja SetAge, akcesora
23: // publicznego
24: // ustawiaj cego sk adow itsAge
25: void Cat::SetAge(int age)
26: {
27: // ustawia zmienn sk adow itsAge
28: // zgodnie z warto ci przekazan w parametrze age
29: itsAge = age;
30: }
31:
32: // definicja metody Meow
33: // zwraca: void
34: // parametery: brak
35: // dzia anie: wy wietla na ekranie s owo "miauczy"
36: void Cat::Meow()
37: {
38: std::cout << "Miauczy.\n";
39: }
40:
41: // tworzy kota, ustawia jego wiek, sprawia,
42: // e miauczy, wy wietla jego wiek i ponownie miauczy.
43: int main()
44: {
45: Cat Frisky;
46: Frisky.SetAge(5);
47: Frisky.Meow();
Implementowanie metod klasy 323
48: std::cout << "Frisky jest kotem i ma " ;
49: std::cout << Frisky.GetAge() << " lat.\n";
50: Frisky.Meow();
51: return 0;
52: }
Wynik
Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Analiza
Linie od 5. do 13. zawieraj definicj klasy Cat (kot). Linia 7. zawiera s owo
kluczowe public, które informuje kompilator, e to, co po nim nast puje, jest
zestawem publicznych sk adowych. Linia 8. zawiera deklaracj publicznego
akcesora GetAge() (pobierz wiek). GetAge() zapewnia dost p do prywatnej
zmiennej sk adowej itsAge (jego wiek), zadeklarowanej w linii 12. Linia 9.
zawiera publiczny akcesor SetAge() (ustaw wiek). Funkcja SetAge() otrzymuje
parametr typu int, który nast pnie przypisuje sk adowej itsAge.
Linia 10. zawiera deklaracj metody Meow() (miaucz). Funkcja Meow() nie jest
akcesorem. Jest to ogólna metoda klasy, wy wietlaj ca na ekranie s owo  Miauczy.
Linia 11. rozpoczyna sekcj prywatn , która obejmuje jedynie zadeklarowan
w linii 12. prywatn sk adow itsAge. Deklaracja klasy ko czy si w linii 13.
zamykaj cym nawiasem klamrowym i rednikiem.
Linie od 17. do 20. zawieraj definicj sk adowej funkcji GetAge(). Ta metoda
nie ma parametrów i zwraca warto ca kowit . Zauwa , e ta metoda klasy
zawiera nazw klasy, dwa dwukropki oraz nazw funkcji (linia 17.). Ta sk adnia
informuje kompilator, e definiowana funkcja GetAge() jest w a nie t funkcj ,
która zosta a zadeklarowana w klasie Cat. Poza formatem tego nag ówka,
definiowanie funkcji w asnej GetAge() niczym nie ró ni si od definiowania
innych (zwyk ych) funkcji.
Funkcja GetAge() posiada tylko jedn lini i zwraca po prostu warto zmiennej
sk adowej itsAge. Zauwa , e funkcja main() nie ma dost pu do tej zmiennej
sk adowej, gdy jest ona prywatna dla klasy Cat. Funkcja main() ma za to dost p
do publicznej metody GetAge().
324 Lekcja 10. Klasy i obiekty
Poniewa ta metoda jest sk adow klasy Cat, ma pe ny dost p do zmiennej itsAge.
Dzi ki temu mo e zwróci funkcji main() warto zmiennej itsAge.
Linia 25. zawiera definicj funkcji sk adowej SetAge(). Mo esz zauwa y , e ta
funkcja pobiera jedn warto w postaci liczby ca kowitej (age) i nie zwraca adnej
warto ci, co jest wskazane przez s owo kluczowe void. Ta funkcja posiada
parametr w postaci warto ci ca kowitej i przypisuje sk adowej itsAge jego
warto (linia 29.). Poniewa jest sk adow klasy Cat, ma bezpo redni dost p
do jej zmiennych prywatnych i publicznych.
Linia 36. rozpoczyna definicj (czyli implementacj ) metody Meow() klasy Cat.
Jest to jednoliniowa funkcja wy wietlaj ca na ekranie s owo  Miauczy , zako czone
znakiem nowej linii. Pami taj, e znak \n powoduje przej cie do nowej linii. Mo esz
zauwa y , e metoda Meow() jest zaimplementowana podobnie jak funkcja
akcesora, czyli rozpoczyna si od typu zwracanej warto ci, a nast pnie mamy
nazw klasy, nazw funkcji oraz parametry (w tym przypadku nie ma adnych
parametrów).
Linia 43. rozpoczyna cia o funkcji main(), czyli w a ciwy program. W linii 45.,
funkcja main() deklaruje obiekt Cat o nazwie Frisky. Ujmuj c to inaczej, mo na
powiedzie , e funkcja main() deklaruje kota (Cat) o imieniu Frisky.
W linii 46. zmiennej itsAge tego obiektu jest przypisywana warto 5 (poprzez
u ycie akcesora SetAge()). Zauwa , e wywo anie tej metody nast puje dzi ki
u yciu nazwy obiektu (Frisky), po której zastosowano operator kropki (.) i nazw
metody (SetAge()). W podobny sposób wywo ywane s wszystkie inne metody
wszystkich klas.
Poj cia funkcja sk adowa i metoda sk adowa mog by u ywane zamiennie.
Linia 47. wywo uje funkcj sk adow Meow(), za w linii 49. za pomoc akcesora
GetAge(), wy wietlany jest komunikat. Linia 50. ponownie wywo uje funkcj Meow().
Cho wymienione metody s cz ci klasy (Cat) i u ywane poprzez obiekt (Frisky),
to dzia aj dok adnie tak samo jak funkcje, które widzia e do tej pory.
Konstruktory i destruktory
Istniej dwa sposoby definiowania zmiennej ca kowitej. Mo na zdefiniowa zmienn ,
a nast pnie, w dalszej cz ci programu, przypisa jej warto . Na przyk ad:
Konstruktory i destruktory 325
int Weight; // definiujemy zmienn
... // tu inny kod
Weight = 7; // przypisujemy jej warto
Mo emy te zdefiniowa zmienn i jednocze nie zainicjalizowa j . Na przyk ad:
int Weight = 7; // definiujemy i inicjalizujemy warto ci 7
Inicjalizacja czy w sobie definiowanie zmiennej oraz pocz tkowe przypisanie
warto ci. Nic nie stoi na przeszkodzie temu, by zmieni pó niej warto zmiennej.
Inicjalizacja powoduje tylko, e zmienna nigdy nie b dzie pozbawiona sensownej
warto ci.
W jaki sposób zainicjalizowa sk adowe klasy? Klasy posiadaj specjalne funkcje
sk adowe, zwane konstruktorami. Konstruktor (ang. constructor) mo e w razie
potrzeby posiada parametry, ale nie mo e zwraca warto ci  nawet typu void.
Konstruktor jest metod klasy o takiej samej nazwie, jak nazwa klasy.
Gdy zadeklarujesz konstruktor, powiniene tak e zadeklarowa destruktor
(ang. destructor). Konstruktor tworzy i inicjalizuje obiekt danej klasy, za destruktor
porz dkuje obiekt i zwalnia pami , któr mog e w niej zaalokowa (albo
w konstruktorze, albo w trakcie cyklu yciowego obiektu). Destruktor zawsze
nosi nazw klasy, poprzedzon znakiem tyldy (~). Destruktory nie maj
argumentów i nie zwracaj warto ci. Dlatego deklaracja destruktora klasy Cat
ma nast puj c posta :
~Cat();
Domy lne konstruktory i destruktory
Istnieje wiele rodzajów konstruktorów; niektóre z nich posiadaj argumenty,
inne nie. Konstruktor, którego mo na wywo a bez adnych argumentów, jest
nazywany konstruktorem domy lnym. Istnieje tylko jeden rodzaj destruktora.
On tak e nie posiada argumentów.
Je li nie stworzysz konstruktora lub destruktora, kompilator stworzy je za
Ciebie. Konstruktor dostarczany przez kompilator jest konstruktorem domy lnym
 czyli konstruktorem bez argumentów. Stworzone przez kompilator domy lny
konstruktor i destruktor nie maj adnych argumentów, a na dodatek w ogóle nic
nie robi ! Je eli chcesz, aby wykonywa y jakiekolwiek operacje, musisz samodzielnie
utworzy domy lny konstruktor i destruktor.
326 Lekcja 10. Klasy i obiekty
U ycie domy lnego konstruktora
Do czego mo e przyda si konstruktor, który nic nie robi? Jest to problem
techniczny: wszystkie obiekty musz by konstruowane i niszczone, dlatego
w odpowiednich momentach wywo ywane s te nic nie robi ce funkcje.
Aby móc zadeklarowa obiekt bez przekazywania parametrów, na przyk ad
Cat Boots; // Boots nie ma parametrów
musisz posiada konstruktor w postaci
Cat();
Gdy definiujesz obiekt klasy, wywo ywany jest konstruktor. Gdyby konstruktor
klasy Cat mia dwa parametry, móg by zdefiniowa obiekt Cat, pisz c
Cat Frisky (5, 7);
W tym przypadku pierwszy parametr móg by by wiekiem, natomiast drugi
móg by oznacza wag kota. Gdyby konstruktor mia jeden parametr, napisa by
Cat Frisky (3);
W przypadku, gdy konstruktor nie ma adnych parametrów (gdy jest konstruktorem
domy lnym), mo esz opu ci nawiasy i napisa
Cat Frisky;
Jest to wyj tek od regu y, zgodnie z któr wszystkie funkcje wymagaj zastosowania
nawiasów, nawet je li nie maj parametrów. W a nie dlatego mo esz napisa :
Cat Frisky;
Jest to interpretowane jako wywo anie konstruktora domy lnego. Nie dostarczamy
mu parametrów i pomijamy nawiasy.
Zwró uwag , e nie musisz u ywa domy lnego konstruktora dostarczanego
przez kompilator. Zawsze mo esz napisa w asny konstruktor domy lny  tj.
konstruktor bez parametrów. Mo esz zastosowa w nim cia o funkcji, w którym
mo esz zainicjalizowa obiekt. Zgodnie z konwencj , zawsze zaleca si zdefiniowanie
konstruktora i ustawienie zmiennym sk adowym odpowiednich warto ci
domy lnych w celu zagwarantowania prawid owego zachowania obiektu.
Zgodnie z konwencj , gdy deklarujesz konstruktor, powiniene tak e zadeklarowa
destruktor, nawet je li nie robi on niczego. Nawet je li destruktor domy lny b dzie
dzia a poprawnie, nie zaszkodzi zadeklarowa w asnego. Dzi ki niemu kod staje
si bardziej przejrzysty.
Konstruktory i destruktory 327
Listing 10.4 zawiera now wersj klasy Cat, w której do zainicjalizowania obiektu
kota nie u yto domy lnego konstruktora. Wiek kota zosta ustawiony zgodnie
z warto ci otrzyman jako parametr konstruktora. Listing pokazuje równie
miejsce, w którym wywo ywany jest destruktor.
Listing 10.4. U ycie konstruktora i destruktora
1: // Demonstruje deklarowanie konstruktora
2: // i destruktora dla klasy Cat
3: // Domy lny konstruktor zosta stworzony przez programist
4: #include // dla cout
5:
6: class Cat // pocz tek deklaracji klasy
7: {
8: public: // pocz tek sekcji publicznej
9: Cat(int initialAge); // konstruktor
10: ~Cat(); // destruktor
11: int GetAge(); // akcesor
12: void SetAge(int age); // akcesor
13: void Meow();
14: private: // pocz tek sekcji prywatnej
15: int itsAge; // zmienna sk adowa
16: };
17:
18: // konstruktor klasy Cat
19: Cat::Cat(int initialAge)
20: {
21: itsAge = initialAge;
22: }
23:
24: Cat::~Cat() // destruktor, nic nie robi
25: {
26: }
27:
28: // GetAge, publiczny akcesor
29: // zwraca warto sk adowej itsAge
30: int Cat::GetAge()
31: {
32: return itsAge;
33: }
34:
35: // definicja SetAge, akcesora
36: // publicznego
37: void Cat::SetAge(int age)
38: {
39: // ustawia zmienn sk adow itsAge
40: // zgodnie z warto ci przekazan w parametrze age
41: itsAge = age;
328 Lekcja 10. Klasy i obiekty
42: }
43:
44: // definicja metody Meow
45: // zwraca: void
46: // parametery: brak
47: // dzia anie: wy wietla na ekranie s owo "miauczy"
48: void Cat::Meow()
49: {
50: std::cout << "Miauczy.\n";
51: }
52:
53: // tworzy kota, ustawia jego wiek, sprawia,
54: // e miauczy, wy wietla jego wiek i ponownie miauczy.
55: int main()
56: {
57: Cat Frisky(5);
58: Frisky.Meow();
59: std::cout << "Frisky jest kotem i ma " ;
60: std::cout << Frisky.GetAge() << " lat.\n";
61: Frisky.Meow();
62: Frisky.SetAge(7);
63: std::cout << "Teraz Frisky ma " ;
64: std::cout << Frisky.GetAge() << " lat.\n";
65: return 0;
66: }
Wynik
Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Teraz Frisky ma 7 lat.
Analiza
Listing 10.4 przypomina listing 10.3, jednak w linii 9. dodano konstruktor,
posiadaj cy argument w postaci warto ci ca kowitej. Linia 10. deklaruje destruktor,
który nie posiada parametrów. Destruktory nigdy nie maj parametrów, za
destruktory i konstruktory nie zwracaj adnych warto ci  nawet typu void.
Linie od 19. do 22. zawieraj implementacj konstruktora. Jest ona podobna do
implementacji akcesora SetAge(). Jak mo esz zobaczy , nazwa klasy poprzedza
nazw konstruktora. Jak ju wcze niej wspomniano, to identyfikuje metod
(w tym przypadku Cat()) jako cz klasy Cat. Poniewa wymieniona metoda
jest konstruktorem, to nie zwraca adnej warto ci, nawet void. Jednak w linii 21.
konstruktor pobiera warto pocz tkow przypisan danej sk adowej itsAge.
Funkcje sk adowe const 329
Linie od 24. do 26. przedstawiaj implementacj destruktora ~Cat(). W tej
chwili ta funkcja nie robi nic, ale je li deklaracja klasy zawiera deklaracj
destruktora, zdefiniowany musi zosta wtedy tak e ten destruktor. Podobnie
jak w przypadku konstruktora oraz innych metod, destruktor jest poprzedzony
nazw klasy. Podobnie jak w przypadku konstruktora, ale odmiennie ni
w przypadku innych metod, nie podaje si zwracanego typu oraz parametrów.
To jest standardowy wymóg dla destruktorów.
Linia 57. zawiera definicj obiektu Frisky, stanowi cego egzemplarz klasy Cat.
Do konstruktora obiektu Frisky przekazywana jest warto 5. Nie ma potrzeby
wywo ywania funkcji SetAge(), gdy Frisky zosta stworzony z warto ci 5
znajduj c si w zmiennej sk adowej itsAge, tak jak pokazano w linii 60. W linii 62.
zmiennej itsAge obiektu Frisky jest przypisywana warto 7. T now warto
wy wietla linia 64.
Tak Nie
W celu zainicjalizowania obiektów Pami taj, e konstruktory i destruktory
u ywaj konstruktorów. nie mog zwraca warto ci.
Je eli doda e konstruktor, dodaj Pami taj, e destruktory nie mog
równie destruktor. mie parametrów.
Funkcje sk adowe const
S owo kluczowe const s u y do deklarowania zmiennych, które nie ulegaj
zmianie. Const mo na stosowa równie wraz z funkcjami sk adowymi w klasie.
Je li zadeklarujesz metod klasy jako const, obiecujesz w ten sposób, e metoda
ta nie zmieni warto ci adnej ze sk adowych klasy.
Aby zadeklarowa metod w ten sposób, umie s owo kluczowe const za
nawiasami, lecz przed rednikiem. Przyk adowo:
void SomeFunction() const;
Pokazana powy ej deklaracja funkcji sk adowej const o nazwie SomeFunction()
nie posiada argumentów i zwraca typ void. Wiesz, e powy sza funkcja nie zmieni
adnych elementów sk adowych w klasie, poniewa zosta a zadeklarowana wraz
ze s owem kluczowym const.
330 Lekcja 10. Klasy i obiekty
Wraz z modyfikatorem const cz sto deklarowane s akcesory, które jedynie
pobieraj warto . Przedstawiona wcze niej klasa Cat posiada dwa akcesory:
void SetAge(int anAge);
int GetAge();
Funkcja SetAge() nie mo e by funkcj const, gdy modyfikuje warto zmiennej
sk adowej itsAge. Natomiast funkcja GetAge() mo e i powinna by const, gdy
nie modyfikuje warto ci adnej ze sk adowych klasy. Funkcja GetAge() po prostu
zwraca bie c warto sk adowej itsAge. Zatem deklaracje tych funkcji mo na
przepisa nast puj co:
void SetAge(int anAge);
int GetAge() const;
Gdy zadeklarujesz funkcj jako const, za implementacja tej funkcji modyfikuje
obiekt poprzez modyfikacj warto ci którejkolwiek ze sk adowych, kompilator
zg osi b d. Na przyk ad, gdy napiszesz funkcj GetAge() w taki sposób, e b dziesz
zapami tywa ilo zapyta o wiek kota, spowodujesz b d kompilacji. Jest to
spowodowane tym, e wywo uj c t metod , modyfikujesz zawarto obiektu Cat.
Deklarowanie funkcji jako const wsz dzie tam, gdzie jest to mo liwe, nale y
do tradycji programistycznej. Za ka dym razem, gdy to zrobisz, umo liwisz
kompilatorowi wykrycie pomy ki, zanim stanie si ona b dem, który ujawni si
ju podczas dzia ania programu.
Po co u ywa kompilatora do wykrywania b dów?
Gdyby mo na by o tworzy programy w stu procentach pozbawione b dów,
by oby cudowanie, jednak tylko bardzo niewielu programistów jest w stanie
tego dokona . Wielu programistów opracowa o jednak system pozwalaj cy
zminimalizowa ilo b dów przez wczesne ich wykrycie i poprawienie.
Cho b dy kompilatora s irytuj ce i stanowi dla programisty przekle stwo, jednak
s czym du o lepszym ni opisana dalej alternatywa. J zyk o s abej kontroli typów
umo liwia naruszanie zasad kontraktu bez s owa sprzeciwu ze strony kompilatora,
jednak program mo e za ama si w trakcie dzia ania  na przyk ad wtedy, gdy
pracuje z nim Twój szef. Co gorsze, w takim przypadku testowanie w celu
wychwycenia tych b dów b dzie ma o pomocne, poniewa istnieje zbyt du o
cie ek wykonywania kodu rzeczywistych programów, aby móc przetestowa je
wszystkie.
B dy czasu kompilacji  tj. b dy wykryte podczas kompilowania programu 
s zdecydowanie lepsze ni b dy czasu dzia ania  tj. b dy wykryte podczas
dzia ania programu. S lepsze, gdy du o atwiej i precyzyjniej mo na okre li
Gdzie umieszcza deklaracje klasy i definicje metod 331
ich przyczyn . Mo e si zdarzy , e program zostanie wykonany wielokrotnie
bez wykonania wszystkich istniej cych cie ek wykonania kodu. Dlatego b d
czasu dzia ania mo e przez d u szy czas pozosta niezauwa ony. B dy kompilacji
s wykrywane podczas ka dej kompilacji, s wi c du o atwiejsze do zidentyfikowania
i poprawienia. Celem dobrego programowania jest ochrona przed pojawianiem si
b dów czasu dzia ania. Jedn ze znanych i sprawdzonych technik jest wykorzystanie
kompilatora do wykrycia pomy ek ju na wczesnym etapie tworzenia programu.
Gdzie umieszcza deklaracje klasy
i definicje metod
Ka da funkcja, któr zadeklarujesz dla klasy, musi posiada definicj . Definicja
jest nazywana tak e implementacj funkcji. Podobnie jak w przypadku innych
funkcji, definicja metody klasy posiada nag ówek i cia o.
Definicja musi znajdowa si w pliku, który mo e zosta znaleziony przez
kompilator. Wi kszo kompilatorów C++ wymaga, by taki plik mia rozszerzenie
.c lub .cpp. W tej ksi ce korzystamy z rozszerzenia .cpp, ale aby mie pewno ,
sprawd , czego oczekuje Twój kompilator.
Wiele kompilatorów zak ada, e pliki z rozszerzeniem .c s programami C,
za pliki z rozszerzeniem .cpp s programami C++. Mo esz u ywa dowolnego
rozszerzenia, ale rozszerzenie .cpp wyeliminuje ewentualne nieporozumienia.
W pliku, w którym umieszczasz implementacj funkcji, mo esz umie ci równie
jej deklaracj , ale nie nale y to do dobrych obyczajów. Zgodnie z konwencj
zaadoptowan przez wi kszo programistów, deklaracje umieszcza si w tak
zwanych plikach nag ówkowych, zwykle posiadaj cych t sam nazw , lecz
z rozszerzeniem .h, .hp lub .hpp. W tej ksi ce dla plików nag ówkowych stosujemy
rozszerzenie .h, ale sprawd w swoim kompilatorze, jakie rozszerzenie powiniene
stosowa .
Na przyk ad, deklaracj klasy Cat powiniene umie ci w pliku o nazwie Cat.h, za
definicj metod tej klasy w pliku o nazwie Cat.cpp. Nast pnie powiniene do czy
do pliku .cpp plik nag ówkowy, poprzez umieszczenie na pocz tku pliku Cat.cpp
nast puj cej dyrektywy:
#include "Cat.h"
332 Lekcja 10. Klasy i obiekty
Informuje ona kompilator, by wstawi w tym miejscu zawarto pliku Cat.h tak,
jakby j wpisa r cznie. Uwaga: niektóre kompilatory nalegaj , by wielko liter
w nazwie pliku w dyrektywie #include zgadza a si z wielko ci liter w nazwie
pliku na dysku.
Dlaczego masz si trudzi , rozdzielaj c program na pliki .h i .cpp, skoro i tak plik .h
jest wstawiany do pliku .cpp? W wi kszo ci przypadków klienci klasy nie dbaj
o szczegó y jej implementacji. Odczytanie pliku nag ówkowego daje im wystarczaj c
ilo informacji, by zignorowa plik implementacji. Poza tym, ten sam plik .h mo esz
do cza do wielu ró nych plików .cpp.
Deklaracja klasy mówi kompilatorowi, czym jest ta klasa, jakie dane zawiera
oraz jakie funkcje posiada. Deklaracja klasy jest nazywana jej interfejsem, gdy
informuje kompilator w jaki sposób ma z ni wspó dzia a . Ten interfejs jest
zwykle przechowywany w pliku .h, cz sto nazywanym plikiem nag ówkowym.
Definicja funkcji mówi kompilatorowi, jak dzia a dana funkcja. Definicja funkcji
jest nazywana implementacj metody klasy i jest przechowywana w pliku .cpp.
Szczegó y dotycz ce implementacji klasy nale wy cznie do jej autora. Klienci
klasy  tj. cz ci programu u ywaj ce tej klasy  nie musz , ani nie powinny
wiedzie , jak zaimplementowane zosta y funkcje.
Implementacja inline
Mo esz poprosi kompilator, by uczyni zwyk funkcj funkcj inline, funkcjami
inline mog sta si równie metody klasy. W tym celu nale y umie ci s owo
kluczowe inline przed typem zwracanej warto ci. Na przyk ad, implementacja
inline funkcji GetWeight() wygl da nast puj co:
inline int Cat::GetWeight()
{
return itsWeight; // zwraca dan sk adow itsWeight
}
Definicj funkcji mo na tak e umie ci w deklaracji klasy, co automatycznie sprawia,
e ta funkcja staje si funkcj inline. Na przyk ad:
class Cat
{
public:
int GetWeight() { return itsWeight; } // inline
void SetWeight(int aWeight);
};
Implementacja inline 333
Zwró uwag na sk adni definicji funkcji GetWeight(). Cia o funkcji inline
zaczyna si natychmiast po deklaracji metody klasy; po nawiasach nie wyst puje
rednik. Podobnie jak w innych funkcjach, definicja zaczyna si od otwieraj cego
nawiasu klamrowego i ko czy zamykaj cym nawiasem klamrowym. Jak zwykle,
bia e znaki nie maj znaczenia; mo esz zapisa t deklaracj jako:
class Cat
{
public:
int GetWeight() const
{
return itsWeight;
} // inline
void SetWeight(int aWeight);
};
Listingi 10.5 i 10.6 odtwarzaj klas Cat, tym razem jednak deklaracja klasy
zosta a umieszczona w pliku Cat.h, za jej definicja w pliku Cat.cpp. Oprócz tego,
na listingu 10.5 akcesor Meow() zosta zadeklarowany jako funkcja inline.
Listing 10.5. Deklaracja klasy Cat w pliku CAT.h
1: #include
2: class Cat
3: {
4: public:
5: Cat (int initialAge);
6: ~Cat();
7: int GetAge() const { return itsAge;} // inline!
8: void SetAge (int age) { itsAge = age;} // inline!
9: void Meow() const { std::cout << "Miauczy.\n";} // inline!
10: private:
11: int itsAge;
12: };
Listing 10.6. Implementacja klasy Cat w pliku CAT.cpp
1: // Demonstruje funkcje inline
2: // oraz do czanie pliku nag ówkowego
3: // pami taj o w czeniu plików nag ówkowych!
4: #include "Cat.h"
5:
6:
7: Cat::Cat(int initialAge) //konstruktor
8: {
9: itsAge = initialAge;
10: }
334 Lekcja 10. Klasy i obiekty
11:
12: Cat::~Cat() //destruktor, nic nie robi
13: {
14: }
15:
16: // tworzy kota, ustawia jego wiek, sprawia
17: // e miauczy, wy wietla jego wiek i ponownie miauczy.
18: int main()
19: {
20: Cat Frisky(5);
21: Frisky.Meow();
22: std::cout << "Frisky jest kotem i ma " ;
23: std::cout << Frisky.GetAge() << " lat.\n";
24: Frisky.Meow();
25: Frisky.SetAge(7);
26: std::cout << "Teraz Frisky ma " ;
27: std::cout << Frisky.GetAge() << " lat.\n";
28: return 0;
29: }
Wynik
Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Teraz Frisky ma 7 lat.
Analiza
Kod zaprezentowany na listingach 10.5 i 10.6 jest podobny do kodu z listingu 10.4,
trzy metody zosta y zadeklarowane w pliku deklaracji jako inline, a deklaracja
zosta a przeniesiona do pliku Cat.hpp (listing 10.5).
Funkcja GetAge() jest deklarowana w linii 6. pliku Cat.h, gdzie znajduje si
tak e jej implementacja inline. Linie 7. i 8. zawieraj kolejne funkcje inline,
jednak w stosunku do poprzednich,  zwyk ych implementacji, dzia anie tych
funkcji nie zmienia si .
Linia 4. listingu 10.6 zawiera dyrektyw #include "Cat.h", która powoduje
wstawienie do pliku zawarto ci pliku Cat.h. Do czaj c plik Cat.h, informujesz
prekompilator, by odczyta zawarto tego pliku i wstawi j w miejscu wyst pienia
dyrektywy #include (tak jakby , pocz wszy od linii 5, sam wpisa t zawarto ).
Ta technika umo liwia umieszczenie deklaracji w pliku innym ni implementacja,
a jednocze nie zapewnienie kompilatorowi dost pu do niej. W programach C++
Klasy, których danymi sk adowymi s inne klasy 335
technika ta jest powszechnie wykorzystywana. Zwykle deklaracje klas znajduj
si w plikach .h, które s do czane do powi zanych z nimi plików .cpp za pomoc
dyrektyw #include.
Linie od 18. do 29. stanowi powtórzenie funkcji main() z listingu 10.4. Oznacza to,
e funkcje inline dzia aj tak samo jak zwyk e funkcje.
Klasy, których danymi sk adowymi
s inne klasy
Budowanie z o onych klas przez deklarowanie prostszych klas i do czanie ich do
deklaracji bardziej skomplikowanej klasy nie jest niczym niezwyk ym. Na przyk ad,
mo esz zadeklarowa klas ko a, klas silnika, klas skrzyni biegów itd., a nast pnie
po czy je w klas  samochód . Deklaruje to relacj posiadania. Samochód
posiada silnik, ko a i skrzyni biegów.
We my inny przyk ad. Prostok t sk ada si z odcinków. Odcinek jest zdefiniowany
przez dwa punkty. Punkt jest zdefiniowany przez wspó rz dn x i wspó rz dn
y. Listing 10.7 przedstawia pe n deklaracj klasy Rectangle (prostok t), która
mo e wyst pi w pliku Rectangle.h. Poniewa prostok t jest zdefiniowany jako
cztery odcinki cz ce cztery punkty, za ka dy punkt odnosi si do wspó rz dnej
w uk adzie, najpierw zadeklarujemy klas Point (punkt) jako przechowuj c
wspó rz dne x oraz y punktu. Listing 10.8 zawiera implementacje obu klas.
Listing 10.7. Deklarowanie kompletnej klasy
1: // pocz tek Rect.h
2: #include
3: class Point // przechowuje wspó rz dne x,y
4: {
5: // bez konstruktora, u ywa domy lnego
6: public:
7: void SetX(int x) { itsX = x; }
8: void SetY(int y) { itsY = y; }
9: int GetX()const { return itsX;}
10: int GetY()const { return itsY;}
11: private:
12: int itsX;
13: int itsY;
14: }; // koniec deklaracji klasy Point
15:
336 Lekcja 10. Klasy i obiekty
16:
17: class Rectangle
18: {
19: public:
20: Rectangle (int top, int left, int bottom, int right);
21: ~Rectangle () {}
22:
23: int GetTop() const { return itsTop; }
24: int GetLeft() const { return itsLeft; }
25: int GetBottom() const { return itsBottom; }
26: int GetRight() const { return itsRight; }
27:
28: Point GetUpperLeft() const { return itsUpperLeft; }
29: Point GetLowerLeft() const { return itsLowerLeft; }
30: Point GetUpperRight() const { return itsUpperRight; }
31: Point GetLowerRight() const { return itsLowerRight; }
32:
33: void SetUpperLeft(Point Location) {itsUpperLeft = Location;}
34: void SetLowerLeft(Point Location) {itsLowerLeft = Location;}
35: void SetUpperRight(Point Location) {itsUpperRight = Location;}
36: void SetLowerRight(Point Location) {itsLowerRight = Location;}
37:
38: void SetTop(int top) { itsTop = top; }
39: void SetLeft (int left) { itsLeft = left; }
40: void SetBottom (int bottom) { itsBottom = bottom; }
41: void SetRight (int right) { itsRight = right; }
42:
43: int GetArea() const;
44:
45: private:
46: Point itsUpperLeft;
47: Point itsUpperRight;
48: Point itsLowerLeft;
49: Point itsLowerRight;
50: int itsTop;
51: int itsLeft;
52: int itsBottom;
53: int itsRight;
54: };
55: // koniec Rect.h
Listing 10.8. Rect.cpp
1: // pocz tek rect.cpp
2: #include "rect.h"
3: Rectangle::Rectangle(int top, int left, int bottom, int right)
Klasy, których danymi sk adowymi s inne klasy 337
4: {
5: itsTop = top;
6: itsLeft = left;
7: itsBottom = bottom;
8: itsRight = right;
9:
10: itsUpperLeft.SetX(left);
11: itsUpperLeft.SetY(top);
12:
13: itsUpperRight.SetX(right);
14: itsUpperRight.SetY(top);
15:
16: itsLowerLeft.SetX(left);
17: itsLowerLeft.SetY(bottom);
18:
19: itsLowerRight.SetX(right);
20: itsLowerRight.SetY(bottom);
21: }
22:
23:
24: // oblicza obszar prostok ta przez obliczenie
25: // i pomno enie szeroko ci i wysoko ci
26: int Rectangle::GetArea() const
27: {
28: int Width = itsRight-itsLeft;
29: int Height = itsTop - itsBottom;
30: return (Width * Height);
31: }
32:
33: int main()
34: {
35: //inicjalizuje lokaln zmienn typu Rectangle
36: Rectangle MyRectangle (100, 20, 50, 80 );
37:
38: int Area = MyRectangle.GetArea();
39:
40: std::cout << "Obszar: " << Area << "\n";
41: std::cout << "Wsp. X lewego górnego rogu: ";
42: std::cout << MyRectangle.GetUpperLeft().GetX();
43: return 0;
44: }
Wynik
Obszar: 3000
Wsp. X lewego górnego rogu: 20
338 Lekcja 10. Klasy i obiekty
Analiza
Linie od 3. do 14. listingu 10.7 deklaruj klas Point (punkt), która s u y do
przechowywania wspó rz dnych x i y okre lonego punktu rysunku. W tym
programie nie wykorzystujemy nale ycie klasy Point. Jej zastosowania wymagaj
jednak inne metody rysunkowe.
Gdy nadasz klasie nazw Rectangle, niektóre kompilatory zg osz b d. Wynika
to z istnienia wewn trznej klasy o nazwie Rectangle. W takim przypadku po prostu
zmie nazw klasy na myRectangle.
W deklaracji klasy Point, w liniach 12. i 13., zadeklarowali my dwie zmienne
sk adowe (itsX oraz itsY). Te zmienne przechowuj wspó rz dne punktu.
Zak adamy, e wspó rz dna x ro nie w prawo, a wspó rz dna y w gór . Istniej
tak e inne systemy. W niektórych programach okienkowych wspó rz dna y ro nie
 w dó  okna.
Klasa Point u ywa akcesorów inline, zwracaj cych i ustawiaj cych wspó rz dne
X i Y punktu. Te akcesory zosta y zadeklarowane w liniach od 7. do 10. Punkty
u ywaj konstruktora i destruktora domy lnego. W zwi zku z tym ich wspó rz dne
trzeba ustawia jawnie.
Linia 17. rozpoczyna deklaracj klasy Rectangle (prostok t). Klasa ta sk ada si
z czterech punktów reprezentuj cych cztery naro niki prostok ta. Konstruktor klasy
Rectangle (linia 20.) otrzymuje cztery warto ci ca kowite, top (górna), left (lewa),
bottom (dolna) oraz right (prawa). Do czterech zmiennych sk adowych (listing
10.8) kopiowane s cztery parametry konstruktora i tworzone s cztery punkty.
Oprócz standardowych akcesorów, klasa Rectangle posiada funkcj GetArea()
(pobierz obszar), zadeklarowan w linii 43. Zamiast przechowywa obszar
w zmiennej, funkcja GetArea() oblicza go w liniach od 28. do 30. listingu 10.8.
W tym celu oblicza szeroko i wysoko prostok ta, nast pnie mno y je przez siebie.
Uzyskanie wspó rz dnej x lewego górnego wierzcho ka prostok ta wymaga
dost pu do punktu UpperLeft (lewy górny) i zapytania o jego wspó rz dn X.
Poniewa funkcja GetUpperLeft() jest funkcj klasy Rectangle, mo e ona
bezpo rednio odwo ywa si do prywatnych danych tej klasy, w cznie ze zmienn
(itsUpperLeft). Poniewa itsUpperLeft jest obiektem klasy Point, a zmienna
itsX tej klasy jest prywatna, funkcja GetUpperLeft() nie mo e odwo ywa si
do niej bezpo rednio. Zamiast tego, w celu uzyskania tej warto ci musi u y
publicznego akcesora GetX().
Klasy, których danymi sk adowymi s inne klasy 339
Linia 33. listingu 10.8 stanowi pocz tek cia a programu. Pami nie jest alokowana
a do linii 36.; w obszarze tym nic si nie dzieje. Jedyna rzecz, jak zrobili my,
to poinformowanie kompilatora, jak ma stworzy punkt i prostok t (gdyby
by y potrzebne w przysz o ci). W linii 36. definiujemy obiekt typu Rectangle,
przekazuj c mu warto ci top, left, bottom oraz right.
W linii 38. tworzymy lokaln zmienn Area (obszar) typu int. Ta zmienna
przechowuje obszar stworzonego przez nas prostok ta. Zmienn Area inicjalizujemy
za pomoc warto ci zwróconej przez funkcj GetArea() klasy Rectangle. Klient
klasy Rectangle mo e stworzy obiekt tej klasy i uzyska jego obszar, nie znaj c
nawet implementacji funkcji GetArea().
Plik Rect.h zosta przedstawiony na listingu 10.7. Obserwuj c plik nag ówkowy,
który zawiera deklaracj klasy Rectangle, programista mo e wysnu wniosek,
e funkcja GetArea() zwraca warto typu int. Sposób, w jaki funkcja GetArea()
uzyskuje t warto , nie interesuje klientów klasy Rectangle. Autor klasy Rectangle
móg by zmieni funkcj GetArea(); nie wp yn oby to na programy, które z niej
korzystaj , o ile warto ci zwrotn nadal by aby liczba ca kowita.
Linia 42. listingu 10.8 mo e wydawa si nieco dziwna, ale je li zastanowisz si nad
tym, co tam si dzieje, powinna sta si jasna. W tej linii kodu nast puje pobranie
wspó rz dnej x lewego górnego punktu prostok ta. Wzgl dem prostok ta
wywo ywana jest metoda GetUpperLeft(), która zwraca obiekt typu Point.
Z tego obiektu potrzebujemy wspó rz dnej x. Wcze niej dowiedzia e si ,
e akcesorem dla punktu x klasy Point jest GetX(). Dlatego te w celu pobrania
wspó rz dnej x lewego górnego naro nika prostok ta nale y u y akcesora GetX()
wzgl dem funkcji akcesora GetUpperLeft() obiektu MyRectangle. To w a nie
przedstawiono w linii 42.:
MyRectangle.GetUpperLeft().GetX();
Cz sto zadawane pytanie
Jaka jest ró nica pomi dzy deklaracj a definicj ?
Odpowied
Deklaracja wprowadza now nazw , lecz nie alokuje pami ci; dokonuje tego definicja.
Wszystkie deklaracje (z kilkoma wyj tkami) s tak e definicjami. Najwa niejszym
wyj tkiem jest deklaracja funkcji globalnej (prototyp) oraz deklaracja klasy (zwykle
w pliku nag ówkowym).
340 Lekcja 10. Klasy i obiekty
Struktury
Bardzo bliskim kuzynem s owa kluczowego class jest s owo kluczowe struct,
u ywane do deklarowania struktur. W C++ struktura jest odpowiednikiem klasy,
ale wszystkie jej sk adowe s domy lnie publiczne. Mo esz zadeklarowa struktur
dok adnie tak, jak klas ; mo esz zastosowa w niej te same zmienne i funkcje
sk adowe. Gdy przestrzegasz jawnego deklarowania publicznych i prywatnych
sekcji klasy, nie ma adnej ró nicy pomi dzy klas a struktur . Spróbuj wprowadzi
do listingu 10.7 nast puj ce zmiany:

w linii 3., zmie class Point na struct Point,

w linii 17., zmie class Rectangle na struct Rectangle.
Nast pnie skompiluj i uruchom program. Otrzymane wyniki nie powinny si od
siebie ró ni .
Prawdopodobnie zastanawiasz si , dlaczego dwa s owa kluczowe spe niaj t
sam funkcj . Przyczyn nale y szuka w historii j zyka. J zyk C++ powstawa
jako rozszerzenie j zyka C. J zyk C posiada struktury, ale nie posiadaj one metod.
Bjarne Stroustrup, twórca j zyka C++, rozbudowa struktury, ale zmieni ich nazw
na klasy, odzwierciedlaj c w ten sposób ich nowe, rozszerzone mo liwo ci oraz
zmian w domy lnej dost pno ci elementów sk adowych. To pozwala równie
na u ywanie w programach C++ ogromnej biblioteki funkcji j zyka C.
Tak Nie
Umieszczaj deklaracj klasy w pliku Nie przechod dalej, zanim dok adnie
nag ówkowym .h, za funkcje sk adowe nie zrozumiesz zasady dzia ania klasy.
definiuj w pliku .cpp.
U ywaj const wsz dzie tam, gdzie
jest to mo liwe.
Podsumowanie
W tej lekcji nauczy e si tworzy nowe typy danych za pomoc klas. Wiesz tak e,
jak definiowa zmienne tych nowych typów, które nazywamy obiektami.
Klasa mo e mie dane sk adowe, którymi s zmienne ró nych typów, cznie
z innymi klasami. Poza tym, klasa mo e zawiera funkcje sk adowe  nazywane
równie metodami. Wymienione funkcje sk adowe s u do manipulowania
danymi sk adowymi oraz przeprowadzania innych operacji.
Pytania i odpowiedzi 341
Elementy sk adowe klasy, zarówno dane, jak i funkcje, mog by publiczne b d
prywatne. Elementy publiczne s dost pne w dowolnym miejscu programu.
Z kolei elementy prywatne s dost pne jedynie dla funkcji sk adowych danej
klasy. Domy lnie, elementy sk adowe s definiowane jako prywatne.
Dobrym nawykiem w programowaniu jest izolowanie interfejsu  inaczej
deklaracji  klasy w pliku nag ówkowym. Zazwyczaj odbywa si to poprzez
u ycie pliku z rozszerzeniem .h, a nast pnie wykorzystanie go w plikach kodu
(z rozszerzeniem .cpp) za pomoc instrukcji include. Implementacja metod klasy
znajduje si w pliku z rozszerzeniem .cpp.
Konstruktory klasy mog by u ywane do inicjalizacji danych sk adowych
obiektu. Natomiast destruktory s wykonywane w trakcie niszczenia obiektu.
W destruktorze bardzo cz sto nast puje zwolnienie pami ci i innych zasobów,
które mog y zosta zaalokowane przez metody klasy.
Pytania i odpowiedzi
Pytanie: Jak du y jest obiekt klasy?
Odpowied : Wielko obiektu w pami ci zale y od wielko ci jego zmiennych
sk adowych. Metody klasy zu ywaj bardzo niewielkie ilo ci pami ci, która jest
wykorzystywana do przechowywania informacji o po o eniu metody (wska nika).
Niektóre kompilatory umieszczaj zmienne w pami ci w taki sposób, e dwubajtowe
zmienne zu ywaj wi cej ni tylko dwa bajty pami ci. Zajrzyj do dokumentacji
u ywanego kompilatora, aby to sprawdzi . Jednak na tym etapie nie nale y
przejmowa si takimi szczegó ami.
Pytanie: Je eli zadeklaruj klas Cat wraz z prywatnym elementem sk adowym
itsAge, a nast pnie zdefiniuj dwa obiekty Frisky i Boots, czy obiekt Boots
b dzie mia dost p do zmiennej sk adowej itsAge obiektu Frisky?
Odpowied : Nie. Ró ne egzemplarze klasy mog uzyska dost p jedynie do danych
publicznych innych egzemplarzy tej klasy. Innymi s owy, je eli Frisky i Boots
to egzemplarze klasy Cat, funkcje sk adowe obiektu Frisky mog uzyska dost p
do danych obiektu Frisky, ale ju nie do danych obiektu Boots.
Pytanie: Dlaczego nie powinienem definiowa jako publicznych wszystkich
danych sk adowych?
342 Lekcja 10. Klasy i obiekty
Odpowied : Zdefiniowanie danych sk adowych jako prywatne umo liwia
klientowi klasy u ywanie tych danych bez adnej zale no ci dotycz cej sposobu
ich przechowywania b d obliczania. Przyk adowo, je eli klasa Cat (kot) ma
metod GetAge(), klient klasy Cat mo e zapyta obiekt o wiek kota, nie znaj c
i nie przejmuj c si sposobem, w jaki klasa Cat przechowuje ten wiek b d jak
oblicza go w locie. Oznacza to, e programista klasy Cat mo e w przysz o ci zmieni
projekt tej klasy bez wymagania od u ytkowników klasy Cat zmiany ich programów.
Pytanie: Je eli u ycie funkcji const do zmiany klasy powoduje b d w trakcie
kompilacji, to dlaczego nie powinienem po prostu pozby si s ów kluczowych
const, by mie pewno , e te b dy nie wyst pi ?
Odpowied : Je eli funkcja sk adowa nie powinna zmienia klasy, to u ycie s owa
kluczowego const jest dobrym sposobem zagwarantowania, e kompilator
pomo e Ci w wykryciu pope nionych b dów. Przyk adowo, funkcja GetAge()
mo e nie mie adnego powodu do zmiany klasy Cat, ale w implementacji mo e
znajdowa si poni sza linia kodu:
if (itsAge = 100) cout << "Hej! Masz 100 lat\n";
Zdefiniowanie funkcji GetAge() jako const powoduje, e kompilator zg osi b d
w powy szej linii kodu. Celem programisty by o sprawdzenie, czy warto
zmiennej itsAge wynosi 100, ale ten kod przez pomy k przypisuje warto 100
zmiennej itsAge. Poniewa przypisanie powoduje zmian klasy  a zdefiniowano,
e ta metoda nie powinna modyfikowa klasy  kompilator wychwytuje b d.
Ten rodzaj b du mo e by trudny do wychwycenia poprzez samo przegl danie
kodu. Oko bardzo cz sto widzi to, co chce zobaczy . Co wa niejsze, mo e wydawa
si , e program dzia a prawid owo, cho zmiennej itsAge przypisano niew a ciw
warto . Wcze niej czy pó niej to musi spowodowa problemy.
Pytanie: Czy istnieje jakikolwiek powód u ywania struktury w programie C++?
Odpowied : Wielu programistów C++ rezerwuje s owo kluczowe struct dla
klas pozbawionych funkcji. To relikt starych struktur C, które nie mia y funkcji.
Szczerze mówi c, to myl ca i kiepska praktyka programistyczna. Dzisiejsza
struktura pozbawiona metod jutro mo e ich potrzebowa . Wówczas b dziesz
zmuszony albo do zmiany na typ class, albo do z amania regu y i umieszczenia
metod w strukturze. Je eli musisz wywo a star funkcj j zyka C wymagaj c
okre lonej struktury, jest to jedyny dobry powód jej u ywania.
Warsztaty 343
Pytanie: Niektórzy programi ci pracuj cy z programowaniem zorientowanym
obiektowo u ywaj terminu tworzenie egzemplarza. Co to oznacza?
Odpowied : Tworzenie egzemplarza to po prostu okre lenie procesu tworzenia
obiektu na podstawie klasy. Okre lony obiekt zdefiniowany jako konkretny typ
klasy to pojedynczy egzemplarz klasy.
Warsztaty
Warsztaty zawieraj pytania w formie quizu, które pomog Ci w utrwaleniu
wiedzy przedstawionej w tej lekcji, a tak e wiczenia pozwalaj ce na sprawdzenie
stopnia opanowania materia u. Spróbuj odpowiedzie na pytania i rozwi za quiz
przed sprawdzeniem odpowiedzi w dodatku D. Zanim przejdziesz do kolejnej
lekcji, upewnij si tak e, e rozumiesz odpowiedzi.
Quiz
1. Co to jest operator kropki i do czego s u y?
2. Co powoduje zarezerwowanie pami ci  deklaracja czy definicja?
3. Czy deklaracja klasy jest jej interfejsem, czy implementacj ?
4. Jaka jest ró nica mi dzy publicznymi i prywatnymi danymi sk adowymi?
5. Czy funkcja sk adowa mo e by prywatna?
6. Czy dana sk adowa mo e by publiczna?
7. Je eli zadeklarujesz dwa obiekty Cat, to czy mog mie ró ne warto ci
w swoich elementach sk adowych itsAge?
8. Czy deklaracje klas s ko czone rednikiem? A definicje metod klasy?
9. Jaki b dzie nag ówek funkcji Meow() klasy Cat, je li nie pobiera ona
parametrów i zwraca void?
10. Która funkcja jest wywo ywana w celu inicjalizacji klasy?
wiczenia
1. Napisz kod deklaruj cy klas o nazwie Employee wraz z nast puj cymi
danymi sk adowymi: itsAge, itsYearsOfService oraz itsSalary.
2. Przepisz deklaracj klasy Employee w taki sposób, aby dane sk adowe
by y prywatne. Zapewnij publiczne metody akcesorów pozwalaj ce na
pobieranie i ustawianie warto ci ka dej danej sk adowej.
344 Lekcja 10. Klasy i obiekty
3. Napisz program u ywaj cy klasy Employee, który tworzy dwóch
pracowników. Ustaw warto ci ich danych sk adowych itsAge,
itsYearsOfService i itsSalary, a nast pnie wy wietl je. B dziesz
musia doda kod tak e w metodach akcesorów.
4. Kontynuuj c wiczenie 3., napisz kod dla metody klasy Employee, której
celem b dzie podanie zarobków ka dego pracownika zaokr glonych
do najbli szego tysi ca.
5. Zmie klas Employee w taki sposób, aby móg zainicjalizowa dane
sk adowe itsAge, itsYearsOfService oraz itsSalary w trakcie tworzenia
pracownika.
6. owcy b dów: Co jest nie tak z poni sz deklaracj ?
class Square
{
public:
int Side;
}
7. owcy b dów: Dlaczego poni sza deklaracja nie jest zbyt u yteczna?
class Cat
{
int GetAge() const;
private:
int itsAge;
};
8. owcy b dów: Wymie trzy b dy w poni szym kodzie, które powinny
by znalezione przez kompilator.
class TV
{
public:
void SetStation(int Station);
int GetStation() const;
private:
int itsStation;
};
main()
{
TV myTV;
myTV.itsStation = 9;
TV.SetStation(10);
TV myOtherTv(2);
}