Idź do
• Spis treści
• Przykładowy rozdział
Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. 32 230 98 63
© Helion 1991–2010
Katalog książek
Twój koszyk
Cennik i informacje
Czytelnia
Kontakt
C++ dla każdego.
Wydanie II
, Siddhartha Rao, Bradley L. Jones
Tłumaczenie: Robert Górczyński
ISBN: 978-83-246-2782-0
Tytuł oryginału:
in One Hour a Day (6th Edition)
Format: B5, stron: 850
Poznaj język C++ w 21 dni!
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
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++.
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
C++, poznać jego tajniki, zalety oraz wady. Z każdą kolejną godziną będziesz zdobywać coraz to
bardziej zaawansowaną i ciekawą wiedzę. Jaki więc zakres obejmuje niniejszy podręcznik?
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,
zmiennych, tablic, instrukcji warunkowych oraz pętli. Ponadto dowiesz się, jak wykorzystać
wskaź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.
Obiekty, klasy, dziedziczenie czy polimorfizm – te pojęcia nie skryją przed Tobą już żadnej
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
• Zasada działania wskaźników
• Programowanie obiektowe – klasy, obiekty, dziedziczenie, polimorfizm
• Rzutowanie
• Wykorzystanie strumieni
• Kompilowanie warunkowe, instrukcje kompilatora
Sprawdź czy język C++ spełni Twoje oczekiwania!
Spis treci
Wstp 25
Cz I Podstawy
Lekcja 1. Zaczynamy
31
Krótka historia jzyka 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 ewoluowao C++ ........................................................................................................38
Czy naley 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
Bdy kompilacji ................................................................................................................49
Podsumowanie ...................................................................................................................50
Pytania i odpowiedzi .......................................................................................................50
Warsztaty .............................................................................................................................51
Quiz ..................................................................................................................................52
wiczenia .......................................................................................................................52
4
C++ dla kadego
Lekcja 2. Anatomia programu C++
53
Prosty program ................................................................................................................. 53
Rzut oka na obiekt cout ................................................................................................. 56
Uywanie przestrzeni nazw standardowych ....................................................... 58
Komentarze ......................................................................................................................... 61
Rodzaje komentarzy ................................................................................................. 61
Uywanie 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 stae
71
Czym jest zmienna? ......................................................................................................... 71
Dane s przechowywane w pamici ................................................................. 71
Przydzielanie pamici ............................................................................................. 72
Rozmiar liczb cakowitych .................................................................................... 73
Zapis ze znakiem i bez znaku ............................................................................... 74
Podstawowe typy zmiennych .............................................................................. 74
Definiowanie zmiennej .................................................................................................. 75
Uwzgldnianie wielkoci liter .............................................................................. 77
Konwencje nazywania zmiennych ..................................................................... 77
Sowa kluczowe .......................................................................................................... 78
Okrelenie iloci pamici uywanej przez typ zmiennej ................................ 79
Tworzenie kilku zmiennych jednoczenie ............................................................ 81
Przypisywanie zmiennym wartoci ......................................................................... 81
Tworzenie aliasów za pomoc typedef ................................................................... 83
Kiedy uywa typu short, a kiedy typu long? ....................................................... 84
Zawinicie liczby cakowitej bez znaku ........................................................... 85
Zawinicie liczby cakowitej ze znakiem ........................................................ 86
Spis
treci
5
Znaki .......................................................................................................................................87
Znaki i liczby ................................................................................................................ 88
Znaki specjalne ............................................................................................................89
Stae ........................................................................................................................................90
Literay ...........................................................................................................................90
Stae symboliczne ......................................................................................................91
Stae wyliczeniowe ...........................................................................................................92
Podsumowanie ...................................................................................................................95
Pytania i odpowiedzi .......................................................................................................96
Warsztaty .............................................................................................................................97
Quiz ..................................................................................................................................97
wiczenia .......................................................................................................................98
Lekcja 4. Tablice i cigi tekstowe
99
Czym jest tablica? ..............................................................................................................99
Elementy tablicy ...................................................................................................... 100
Zapisywanie za kocem tablicy ........................................................................ 102
Bd supka w pocie ............................................................................................. 104
Inicjalizowanie tablic ............................................................................................ 105
Deklarowanie tablic ............................................................................................... 106
Tablice wielowymiarowe ........................................................................................... 107
Deklarowanie tablic wielowymiarowych ..................................................... 108
Inicjalizowanie tablic wielowymiarowych .................................................. 110
Tablice znaków i cigi tekstowe .............................................................................. 113
Metody strcpy() oraz strncpy() ............................................................................... 115
Klasy cigów tekstowych ........................................................................................... 117
Podsumowanie ................................................................................................................ 120
Pytania i odpowiedzi .................................................................................................... 120
Warsztaty .......................................................................................................................... 121
Quiz ............................................................................................................................... 121
wiczenia .................................................................................................................... 122
Lekcja 5. Wyraenia, instrukcje i operatory
123
Instrukcje ........................................................................................................................... 123
Biae znaki .................................................................................................................. 124
Bloki i instrukcje zoone .................................................................................... 124
Wyraenia ......................................................................................................................... 125
6
C++ dla kadego
Operatory ...........................................................................................................................126
Operator przypisania .............................................................................................127
Operatory matematyczne ....................................................................................127
czenie operatora przypisania z operatorem matematycznym .............130
Inkrementacja i dekrementacja ...............................................................................130
Przedrostki i przyrostki ........................................................................................131
Kolejno dziaa ............................................................................................................133
Zagniedanie nawiasów ............................................................................................134
Prawda i fasz ...................................................................................................................135
Operatory relacji ......................................................................................................136
Instrukcja if .......................................................................................................................137
Styl wci .....................................................................................................................141
Instrukcja else ...........................................................................................................141
Zaawansowane instrukcje if ...............................................................................143
Uycie nawiasów klamrowych w zagniedonych instrukcjach if ...........146
Operatory logiczne .........................................................................................................149
Logiczne I ....................................................................................................................149
Logiczne LUB .............................................................................................................150
Logiczne NIE ..............................................................................................................150
Skrócone obliczanie wyrae logicznych ............................................................150
Kolejno operatorów logicznych ...........................................................................151
Kilka sów na temat prawdy i faszu ......................................................................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 wartoci, parametry i argumenty ......................................................160
Deklarowanie i definiowanie funkcji .....................................................................161
Prototypy funkcji .....................................................................................................162
Definiowanie funkcji ..............................................................................................164
Wykonywanie funkcji ...................................................................................................166
Spis
treci
7
Zakres zmiennej ............................................................................................................. 166
Zmienne lokalne ...................................................................................................... 166
Zmienne lokalne zdefiniowane w blokach .................................................. 168
Parametry s zmiennymi lokalnymi ...................................................................... 170
Zmienne globalne .................................................................................................... 172
Zmienne globalne: ostrzeenie ......................................................................... 173
Rozwaania na temat tworzenia instrukcji funkcji ........................................ 174
Kilka sów na temat argumentów funkcji ........................................................... 174
Kilka sów na temat zwracanych wartoci ......................................................... 175
Parametry domylne .................................................................................................... 178
Przecianie funkcji ...................................................................................................... 181
Zagadnienia zwizane z funkcjami ......................................................................... 185
Funkcje typu inline ................................................................................................. 185
Rekurencja ................................................................................................................. 188
Jak dziaaj 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 dziaania programu
203
Ptle ..................................................................................................................................... 203
Pocztki ptli: instrukcja goto ........................................................................... 203
Dlaczego nie jest zalecane stosowanie instrukcji goto? ......................... 205
Ptle while ......................................................................................................................... 205
Bardziej skomplikowane instrukcje while .................................................. 207
Instrukcje continue oraz break ......................................................................... 209
Ptla while (true) .................................................................................................... 212
Implementacja ptli do...while ................................................................................. 213
Uywanie ptli do...while ............................................................................................ 214
Ptle for .............................................................................................................................. 216
Zaawansowane ptle for ...................................................................................... 219
Puste ptle for .......................................................................................................... 222
Ptle zagniedone ................................................................................................. 223
Zakres zmiennych w ptlach for ...................................................................... 225
8
C++ dla kadego
Podsumowanie ptli ......................................................................................................226
Sterowanie przebiegiem dziaania programu
za pomoc instrukcji switch ...................................................................................229
Uycie instrukcji switch w menu ......................................................................232
Podsumowanie ................................................................................................................236
Pytania i odpowiedzi .....................................................................................................236
Warsztaty ...........................................................................................................................237
Quiz ................................................................................................................................238
wiczenia ....................................................................................................................238
Lekcja 8. Wskaniki
241
Czym jest wskanik? .....................................................................................................241
Kilka sów na temat pamici ...............................................................................241
Uycie operatora adresu zmiennej w pamici (&) ...................................242
Przechowywanie adresu zmiennej we wskaniku ...................................244
Nazwy wskaników ................................................................................................244
Pobranie wartoci ze zmiennej .........................................................................245
Dereferencja za pomoc operatora wyuskania ........................................246
Wskaniki, adresy i zmienne ..............................................................................247
Operowanie danymi poprzez wskaniki .......................................................248
Sprawdzanie adresu ...............................................................................................250
Nazwy wskaników i tablic .................................................................................252
Wskanik do tablicy kontra tablica wskaników ......................................254
Do czego su wskaniki? .........................................................................................255
Stos i sterta ........................................................................................................................255
Alokacja pamici za pomoc sowa kluczowego new .............................257
Zwalnianie pamici: sowo kluczowe delete ...............................................258
Inne spojrzenie na wycieki pamici .......................................................................260
Tworzenie obiektów na stercie ................................................................................261
Usuwanie obiektów ze sterty ....................................................................................261
Utracone wskaniki .......................................................................................................263
Wskaniki const ..............................................................................................................267
Podsumowanie ................................................................................................................268
Pytania i odpowiedzi .....................................................................................................268
Warsztaty ...........................................................................................................................269
Quiz ................................................................................................................................269
wiczenia ....................................................................................................................269
Spis
treci
9
Lekcja 9. Referencje
271
Czym jest referencja? ................................................................................................... 271
Uycie operatora adresu (&) z referencj ........................................................... 273
Nie mona zmienia przypisania referencji ................................................ 275
Zerowe wskaniki i zerowe referencje ................................................................. 276
Przekazywanie argumentów funkcji przez referencj .................................. 277
Tworzenie funkcji swap() otrzymujcej wskaniki ................................. 279
Implementacja funkcji swap() za pomoc referencji .............................. 281
Zwracanie kilku wartoci ........................................................................................... 283
Zwracanie wartoci przez referencj ............................................................. 285
Przekazywanie przez referencj zwiksza efektywno
dziaania programu .................................................................................................... 286
Przekazywanie wskanika const ...................................................................... 290
Referencje jako metoda alternatywna ........................................................... 293
Kiedy uywa wskaników, a kiedy referencji ................................................. 295
czenie referencji i wskaników ........................................................................... 296
Zwracanie referencji do obiektu, którego nie ma w zakresie .................... 298
Problem zwizany 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 skadowych ................................................. 310
Deklarowanie klasy ................................................................................................ 311
Kilka sów o konwencji nazw ............................................................................ 311
Definiowanie obiektu ............................................................................................ 313
Klasy a obiekty ......................................................................................................... 313
Dostp do elementów skadowych klasy ............................................................ 313
Przypisywa naley obiektom, nie klasom .................................................. 314
Czego nie zadeklarujesz, tego klasa nie bdzie miaa ............................. 314
10
C++ dla kadego
Dostp prywatny i publiczny ....................................................................................315
Oznaczanie danych skadowych jako prywatnych ...................................317
Implementowanie metod klasy ................................................................................321
Konstruktory i destruktory ........................................................................................324
Domylne konstruktory i destruktory ...........................................................325
Uycie domylnego konstruktora ....................................................................326
Funkcje skadowe const ..............................................................................................329
Gdzie umieszcza deklaracje klasy i definicje metod .....................................331
Implementacja inline ....................................................................................................332
Klasy, których danymi skadowymi 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 zwierzt .................................................................................................347
Skadnia wyprowadzania .....................................................................................348
Prywatne kontra chronione .......................................................................................350
Dziedziczenie oraz konstruktory i destruktory ................................................353
Przekazywanie argumentów do konstruktorów bazowych .................355
Przesanianie funkcji klasy bazowej ......................................................................360
Ukrywanie metod klasy bazowej ......................................................................363
Wywoywanie metod klasy bazowej ..............................................................365
Metody wirtualne ...........................................................................................................367
Jak dziaaj funkcje wirtualne ............................................................................372
Próba uzyskania dostpu do metod klasy bazowej ..................................373
Okrajanie .....................................................................................................................374
Tworzenie destruktorów wirtualnych ...........................................................377
Wirtualne konstruktory kopiujce ..................................................................377
Koszt metod wirtualnych .....................................................................................381
Dziedziczenie prywatne ..............................................................................................381
Uywanie dziedziczenia prywatnego .............................................................382
Dziedziczenie prywatne kontra agregacja (zoenie) .............................384
Spis
treci
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
Poczenie dwóch list ............................................................................................ 396
Dziedziczenie wielokrotne ......................................................................................... 397
Czci obiektu z dziedziczeniem wielokrotnym ....................................... 401
Konstruktory w obiektach dziedziczonych wielokrotnie ..................... 402
Eliminowanie niejednoznacznoci .................................................................. 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
Zoone 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 przecianie 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 kadego
Programowanie operatora dereferencji *
i operatora wyboru elementu skadowego -> ...............................................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
Przecianie operatorów porównywania ....................................................452
Przecianie operatorów <, >, <= i >= ............................................................456
Operatory indeksowania ......................................................................................459
Funkcja operator() .........................................................................................................462
Operatory, których nie mona 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
wród niektórych programistów C++? ..............................................................468
Operatory rzutowania C++ .........................................................................................469
Uycie static_cast .....................................................................................................470
Uycie dynamic_cast i identyfikacja typu w czasie dziaania ...............471
Uycie reinterpret_cast .........................................................................................474
Uycie 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
treci
13
Funkcje makro ................................................................................................................. 482
Po co te wszystkie nawiasy? .............................................................................. 484
W jaki sposób makra i sabe bezpieczestwo typów
id rka w rk? .................................................................................................... 485
Makra a funkcje i wzorce ..................................................................................... 486
Funkcje inline ........................................................................................................... 486
Wprowadzenie do wzorców ..................................................................................... 488
Skadnia deklaracji wzorca ................................................................................. 489
Róne rodzaje deklaracji wzorca ..................................................................... 490
Klasy wzorca ............................................................................................................. 490
Ustanawianie i specjalizacja wzorca .............................................................. 491
Wzorce i bezpieczestwo typów ...................................................................... 492
Deklarowanie wzorców z wieloma parametrami .................................... 492
Deklarowanie wzorców z parametrami domylnymi ............................ 493
Przykad wzorca ...................................................................................................... 493
Uycie 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
Oddziaywania midzy kontenerami i algorytmami
za pomoc iteratorów ............................................................................................... 507
Podsumowanie ................................................................................................................ 509
Pytania i odpowiedzi .................................................................................................... 510
Warsztaty .......................................................................................................................... 510
Quiz ............................................................................................................................... 511
14
C++ dla kadego
Lekcja 17. Klasa string w STL
513
Potrzeba powstania klasy sucej do manipulowania cigami
tekstowymi .....................................................................................................................513
Praca z klas STL string ...............................................................................................515
Ustanawianie obiektu STL string i tworzenie kopii .................................515
Uzyskanie dostpu do obiektu string i jego zawartoci .........................518
czenie cigów tekstowych ..............................................................................520
Wyszukiwanie znaku bd podcigu tekstowego w obiekcie string .....521
Skracanie obiektu STL string ..............................................................................523
Odwracanie zawartoci cigu tekstowego ...................................................525
Konwersja wielkoci znaków obiektu string .................................................526
Bazujca 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 dostpu 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 pocztku obiektu list .....................................552
Spis
treci
15
Wstawianie elementów na kocu 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 uywania 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 wasnego predykatu sortowania ................................................ 606
Podsumowanie ................................................................................................................ 610
Pytania i odpowiedzi .................................................................................................... 610
Warsztaty .......................................................................................................................... 611
Quiz ............................................................................................................................... 612
wiczenia .................................................................................................................... 612
16
C++ dla kadego
Cz IV Jeszcze wicej 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
Uywanie algorytmów STL ........................................................................................636
Zliczanie i znajdowanie elementów ................................................................636
Wyszukiwanie elementu lub zakresu w kolekcji .......................................639
Inicjalizacja elementów w kontenerze wraz
z okrelonymi wartociami ..............................................................................642
Przetwarzanie elementów w zakresie za pomoc for_each .................645
Przeprowadzanie transformacji zakresu
za pomoc std::transform .................................................................................647
Operacje kopiowania i usuwania ......................................................................650
Zastpowanie wartoci oraz zastpowanie 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
treci
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
Uywanie klasy STL stack .......................................................................................... 668
Ustanawianie obiektu stack ............................................................................... 669
Funkcje skadowe klasy stack ........................................................................... 670
Uywanie klasy STL queue ........................................................................................ 672
Ustanawianie obiektu queue ............................................................................. 673
Funkcje skadowe klasy queue ......................................................................... 674
Uywanie klasy STL priority_queue ...................................................................... 676
Ustanawianie obiektu priority_queue ........................................................... 677
Funkcje skadowe 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
Uywanie klasy std::bitset i jej elementów skadowych .............................. 687
Operatory std::bitset ............................................................................................. 687
Metody skadowe klasy std::bitset .................................................................. 687
Klasa vector<bool> ........................................................................................................ 691
Ustanowienie klasy vector<bool> ................................................................... 691
Uywanie klasy vector<bool> ........................................................................... 692
Podsumowanie ................................................................................................................ 693
Pytania i odpowiedzi .................................................................................................... 694
Warsztaty .......................................................................................................................... 694
Quiz ............................................................................................................................... 695
wiczenia .................................................................................................................... 695
18
C++ dla kadego
Cz V Zaawansowane koncepcje C++
Lekcja 26. Sprytne wskaniki
699
Czym s sprytne wskaniki? ......................................................................................699
Na czym polega problem zwizany z uywaniem
wskaników konwencjonalnych? ..................................................................700
W jaki sposób sprytne wskaniki mog pomóc? .......................................701
W jaki sposób s implementowane sprytne wskaniki? ..............................701
Typy sprytnych wskaników ....................................................................................703
Kopiowanie gbokie .............................................................................................704
Mechanizm kopiowania przy zapisie (COW) ..............................................706
Sprytne wskaniki zliczania odniesie ..........................................................706
Sprytne wskaniki powizane z licznikiem odniesie ............................707
Kopiowanie destrukcyjne ....................................................................................708
Uywanie klasy std::auto_ptr ....................................................................................710
Popularne biblioteki sprytnych wskaników ....................................................712
Podsumowanie ................................................................................................................713
Pytania i odpowiedzi .....................................................................................................713
Warsztaty ...........................................................................................................................714
Quiz ................................................................................................................................714
wiczenia ....................................................................................................................715
Lekcja 27. Strumienie
717
Przegld strumieni .........................................................................................................717
Hermetyzacja przepywu danych .....................................................................718
Buforowanie ..............................................................................................................719
Strumienie i bufory ........................................................................................................721
Standardowe obiekty wejcia-wyjcia ..................................................................722
Przekierowywanie standardowych strumieni ..................................................722
Wejcie z uyciem cin ...................................................................................................723
Wejciowe cigi tekstowe ....................................................................................725
Problemy z cigami tekstowymi .......................................................................725
Warto zwracana przez cin ...............................................................................728
Inne funkcje skadowe w dyspozycji cin ..............................................................729
Wprowadzanie pojedynczych znaków ..........................................................729
Odczytywanie cigów tekstowych z wejcia standardowego .............732
Uycie cin.ignore() ..................................................................................................735
Funkcje peek() oraz putback() ..........................................................................737
Spis
treci
19
Wyjcie poprzez cout ................................................................................................... 738
Zrzucanie zawartoci bufora ............................................................................. 739
Funkcje obsugujce wyjcie .............................................................................. 739
Manipulatory, znaczniki oraz instrukcje formatowania ........................ 741
Strumienie kontra funkcja printf() ........................................................................ 747
Wejcie i wyjcie z uyciem plików ....................................................................... 751
ofstream ...................................................................................................................... 751
Stany strumieni ........................................................................................................ 751
Otwieranie plików dla wejcia i wyjcia ....................................................... 751
Zmiana domylnego 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. Obsuga wyjtków
767
Pluskwy, bdy, pomyki i „psujcy si” kod ...................................................... 767
Sytuacje wyjtkowe ............................................................................................... 768
Wyjtki ................................................................................................................................ 770
Jak uywane s wyjtki ........................................................................................ 771
Zgaszanie wasnych wyjtków ........................................................................ 775
Tworzenie klasy wyjtku ..................................................................................... 777
Umiejscowienie bloków try oraz bloków catch ................................................ 781
Sposób dziaania przechwytywania wyjtków ................................................ 781
Wychwytywanie wicej ni jednego rodzaju wyjtków ........................ 782
Hierarchie wyjtków ............................................................................................. 785
Dane w wyjtkach oraz nazwane obiekty wyjtków ..................................... 789
Wyjtki i wzorce ............................................................................................................. 796
Wyjtki bez bdów ...................................................................................................... 799
Bdy i usuwanie bdów ........................................................................................... 800
Punkty wstrzymania .............................................................................................. 801
ledzenie wartoci zmiennych .......................................................................... 801
Sprawdzanie pamici ............................................................................................ 802
Asembler ..................................................................................................................... 802
20
C++ dla kadego
Podsumowanie ................................................................................................................802
Pytania i odpowiedzi .....................................................................................................803
Warsztaty ...........................................................................................................................804
Quiz ................................................................................................................................804
wiczenia ....................................................................................................................805
Lekcja 29. Wicej informacji na temat preprocesora
807
Preprocesor i kompilator ............................................................................................807
Uycie dyrektywy #define ..........................................................................................808
Uycie #define dla staych ...................................................................................808
Uycie #define do testowania ............................................................................809
Dyrektywa #else preprocesora .........................................................................810
Doczanie i wartowniki doczania ......................................................................811
Manipulacje cigami tekstowymi ............................................................................813
Zamiana na cig tekstowy ....................................................................................813
Konkatenacja .............................................................................................................813
Makra predefiniowane .................................................................................................814
Makro assert() .................................................................................................................814
Debuggowanie za pomoc makra assert() ...................................................816
Makro assert() a wyjtki ......................................................................................817
Efekty uboczne .........................................................................................................817
Niezmienniki klas ....................................................................................................818
Wywietlanie wartoci tymczasowych ..........................................................824
Operacje na bitach ..........................................................................................................825
Operator AND ............................................................................................................826
Operator OR ...............................................................................................................826
Operator wyczajcy 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
Wcicia .........................................................................................................................833
Nawiasy klamrowe .................................................................................................833
Dugo linii oraz dugo funkcji ....................................................................833
Instrukcje switch .....................................................................................................834
Spis
treci
21
Tekst programu ....................................................................................................... 834
Nazwy identyfikatorów ........................................................................................ 835
Pisownia nazw i zastosowanie w nich wielkich liter .............................. 836
Komentarze ............................................................................................................... 836
Konfiguracja dostpu ............................................................................................ 837
Definicje klas ............................................................................................................. 838
Doczanie plików .................................................................................................. 838
Uywanie makra assert() .................................................................................... 838
Uywanie modyfikatora const .......................................................................... 838
Nastpne kroki w programowaniu C++ ............................................................... 839
Gdzie uzyska pomoc i porad .......................................................................... 839
Tematy powizane 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 Sowa 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++ moliwoci, uatwiajce rozwizywanie
zoonych, „rzeczywistych” problemów.
Z tej lekcji dowiesz si:
X
czym s klasy i obiekty,
X
jak definiowa now klas oraz tworzy obiekty tej klasy,
X
czym s funkcje i dane skadowe,
X
czym s konstruktory i jak z nich korzysta.
Czy C++ jest zorientowane obiektowo?
W pewnym momencie jzyk C, czyli poprzednik C++, by najpopularniejszym
jzykiem programowania na wiecie uywanym do tworzenia oprogramowania
komercyjnego. By wykorzystywany do tworzenia systemów operacyjnych
(na przykad systemu Unix), do tworzenia oprogramowania dziaajcego w czasie
rzeczywistym (kontrola maszyn, urzdze i elektroniki). Dopiero póniej zacz
by stosowany jako jzyk programowania sucy do budowy innych jzyków
konwencjonalnych. Opracowanie jzyka C pozwolio na znalezienie atwiejszego
i bezpieczniejszego sposobu zblienia oprogramowania i osprztu.
Jzyk C jest etapem porednim pomidzy wysokopoziomowymi jzykami aplikacji
„firmowych”, takimi jak COBOL, a niskopoziomowym, wysokowydajnym, lecz
trudnym do uycia asemblerem. C wymusza programowanie „strukturalne”,
w którym poszczególne zagadnienia s dzielone na mniejsze jednostki powtarzalnych
dziaa, zwanych funkcjami, natomiast dane s umieszczane w pakietach
nazywanych strukturami.
308
Lekcja 10.
Klasy i obiekty
Jednak jzyki takie jak Smalltalk i CLU zaczy 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 wypeniony przedmiotami: samochodami, psami, drzewami, chmurami,
kwiatami. Rzeczy. Kada rzecz ma charakterystyk (szybki, przyjazny, brzowy,
puszysty, adny). Wikszo rzeczy cechuje jakie zachowanie (ruch, szczekanie,
wzrost, deszcz, uwid). Nie mylimy o danych samochodu i o tym, jak moglibymy
nimi manipulowa — mylimy o samochodzie jako o rzeczy: do czego jest podobny
i co robi. Z tym samym moemy si zetkn po przeniesieniu do wiata komputerów
dowolnego „rzeczywistego” obiektu.
Programy, które piszemy na pocztku dwudziestego pierwszego wieku, s duo
bardziej zoone ni te, które byy pisane pod koniec wieku dwudziestego. Programy
stworzone w jzykach proceduralnych s trudne w zarzdzaniu i konserwacji,
a ich rozbudowa jest niemoliwa. Graficzne interfejsy uytkownika, Internet,
telefonia cyfrowa i bezprzewodowa oraz wiele innych technologii, znacznie
zwikszyy poziom skomplikowania nowych projektów, a wymagania
konsumentów dotyczce jakoci interfejsu uytkownika wzrosy.
Programowanie zorientowane obiektowo oferuje narzdzie pomagajce
w sprostaniu wyzwaniom stojcym przed twórcami oprogramowania. Chocia
nie istnieje zoty rodek dla tworzenia skomplikowanego oprogramowania,
jzyki zorientowane obiektowo stworzyy silne wizy pomidzy strukturami
danych a metodami manipulowania tymi danymi. Ponadto jeszcze bardziej zbliaj
si do sposobu mylenia ludzi (programistów i klientów), usprawniajc tym
samym komunikacj oraz poprawiajc jako tworzonego oprogramowania.
A co najwaniejsze, w programowaniu zorientowanym obiektowo nie musisz
ju myle o strukturach danych i manipulujcych nimi funkcjach; mylisz
o obiektach w taki sposób, jakby byy odpowiednikami obiektów w rzeczywistoci:
czyli jak one wygldaj i jak dziaaj.
Jzyk C++ stanowi pomost pomidzy programowaniem zorientowanym obiektowo
a jzykiem C. Celem jego autorów byo stworzenie obiektowo zorientowanego
jzyka dla tej szybkiej i efektywnej platformy sucej do tworzenia oprogramowania
komercyjnego, ze szczególnym naciskiem na wysok wydajno. W dalszej czci
lekcji przekonasz si, jak C++ osiga cele postawione przed jzykiem.
Tworzenie nowych typów
309
Tworzenie nowych typów
Programy s zwykle pisane w celu rozwizania jakiego realnego problemu,
takiego jak prowadzenie rejestru pracowników czy symulacja dziaania systemu
grzewczego. Cho istnieje moliwo rozwizywania tych problemów za pomoc
programów napisanych wycznie przy uyciu liczb cakowitych i znaków, jednak
w przypadku wikszych, bardziej rozbudowanych problemów, duo atwiej jest
stworzy reprezentacje obiektów, o których si mówi. Innymi sowy, symulowanie
dziaania systemu grzewczego bdzie atwiejsze, gdy stworzymy zmienne
reprezentujce pomieszczenia, czujniki ciepa, termostaty i bojlery. Im bardziej
te zmienne odpowiadaj rzeczywistoci, tym atwiejsze jest napisanie programu.
Poznae ju kilka typów zmiennych, m.in. liczby cakowite i znaki. Typ zmiennej
dostarcza nam kilka informacji o niej. Na przykad, jeli zadeklarujesz zmienne
Height (wysoko) i Width (szeroko) jako liczby cakowite typu unsigned
short int, wiesz, e w kadej z nich moesz przechowa warto z przedziau od
0 do 65 535 (przy zaoeniu e typ unsigned short int zajmuje dwa bajty pamici).
S to liczby cakowite bez znaku; próba przechowania w nich czegokolwiek
innego powoduje bd. W zmiennej typu unsigned short nie moesz umieci
swojego imienia, nie powiniene nawet próbowa.
Deklarujc te zmienne jako unsigned short int, wiesz, e moesz doda do
siebie wysoko i szeroko oraz przypisa t warto innej zmiennej.
Typ zmiennych informuje:
X
o ich rozmiarze w pamici,
X
jaki rodzaj informacji mog zawiera,
X
jakie dziaania mona na nich wykonywa.
W tradycyjnych jzykach, takich jak C, typy byy wbudowane w jzyk. W C++
programista moe rozszerzy jzyk, tworzc potrzebne mu typy, za kady z tych
nowych typów moe by w peni funkcjonalny i dysponowa t sam si, co typy
wbudowane.
Wady tworzenia typów za pomoc sowa kluczowego struct
Pewne moliwoci rozszerzenia jzyka C nowymi typami wi si z czeniem
w struktury (
struct
) powizanych ze sob zmiennych, które mog by dostpne
w postaci nowego typu danych za pomoc instrukcji
typedef
. Jednak istniej
pewne wady takiego podejcia:
310
Lekcja 10.
Klasy i obiekty
X
Struktury i operujce na nich funkcje nie s spójnymi caociami. Funkcje
mona znale jedynie poprzez odczyt plików nagówkowych z dostpnych
bibliotek i wyszukanie tych z nowym typem jako parametrem.
X
Koordynacja aktywnoci grupy powizanych funkcji w strukturze jest trudniejszym
zadaniem, poniewa dowolny fragment logiki programu moe w dowolnej
chwili zmieni cokolwiek w strukturze. Z tego powodu nie ma moliwoci
ochrony struktury przed ingerencj.
X
Wbudowane operatory nie dziaaj ze strukturami — nie dziaa nawet
dodanie dwóch struktur za pomoc znaku plus (+), cho taka operacja
mogaby si wydawa najbardziej naturalnym sposobem przedstawienia
rozwizania problemu (na przykad, kiedy kada struktura przedstawia
skomplikowane fragmenty tekstu, które maj by ze sob poczone).
Wprowadzenie klas
i elementów skadowych
Nowy typ zmiennych tworzy si, deklarujc klas. Klasa jest waciwie grup
zmiennych — czsto o rónych typach — skojarzonych z zestawem odnoszcych
si do nich funkcji.
Jedn z moliwoci mylenia o samochodzie jest potraktowanie go jako zbioru
kó, drzwi, foteli, okien itd. Inna moliwo to wyobraenie sobie, co samochód
moe zrobi: jedzi, przyspiesza, zwalnia, zatrzymywa si, parkowa itd.
Klasa umoliwia hermetyzacj, czyli upakowanie, tych rónych czci oraz
rónych dziaa w jeden zbiór, który jest nazywany obiektem.
Upakowanie wszystkiego, co wiesz o samochodzie, w jedn klas przynosi
programicie liczne korzyci. Wszystko jest na miejscu, uatwia to odwoywanie si,
kopiowanie i manipulowanie danymi. Klienci Twojej klasy — tj. te czci programu,
które z niej korzystaj — mog uywa Twojego obiektu bez zastanawiania si,
co znajduje si w rodku i jak on dziaa.
Klasa moe skada si z dowolnej kombinacji zmiennych prostych oraz zmiennych
innych klas. Zmienna wewntrz klasy jest nazywana zmiennskadow lub
danskadow. Klasa Car (samochód) moe posiada skadowe reprezentujce
siedzenia, typ radia, opony itd. Zmienne skadowe s zmiennymi w danej klasie.
Stanowi one cz klasy, tak jak koa i silnik stanowi cz samochodu.
Wprowadzenie klas i elementów skadowych
311
Klasa moe zawiera równie funkcje, które s wówczas nazywane funkcjami
skadowymi lub metodami. Podobnie jak zmienne skadowe, stanowi cz
klasy i okrelaj, co dana klasa moe zrobi.
Funkcje w danej klasie zwykle manipuluj zmiennymi skadowymi. Przykadowo,
metodami klasy Car mog by Start() (uruchom) oraz Brake() (hamuj). Klasa Cat
(kot) moe posiada zmienne skadowe, reprezentujce 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,
uyj sowa kluczowego class, po którym nastpuje otwierajcy nawias klamrowy,
a nastpnie lista danych skadowych i metod tej klasy. Deklaracja koczy si
zamykajcym nawiasem klamrowym i rednikiem. Oto deklaracja klasy o nazwie
Cat (kot):
class Cat
{
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};
Zadeklarowanie takiej klasy nie powoduje zaalokowania pamici dla obiektu Cat.
Informuje jedynie kompilator, czym jest typ Cat, jakie dane zawiera (itsAge
— jego wiek oraz itsWeight — jego waga) oraz co moe robi (Meow() — miaucz).
Informuje take kompilator, jak dua jest zmienna typu Cat — to jest, jak duo
miejsca w pamici ma przygotowa w przypadku tworzenia zmiennej typu Cat.
W tym przykadzie, 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 skadowych (metod)
miejsce nie jest rezerwowane. Jest to wskanik do funkcji, który na platformie
32-bitowej moe zaj cztery bajty.
Kilka sów o konwencji nazw
Jako programista, musisz nazwa wszystkie swoje zmienne skadowe, funkcje
skadowe oraz klasy. Jak przeczytae w lekcji 3., „Stae i zmienne”, nazwy te
powinny by zrozumiae i znaczce. Dobrymi nazwami klas mog by wspomniana
312
Lekcja 10.
Klasy i obiekty
Cat, Rectangle (prostokt) 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
skadowych przedrostek „its” (jego), tak jak w zmiennych itsAge, itsWeight
czy itsSpeed (jego szybko). Pomaga to w odrónieniu zmiennych skadowych
od innych zmiennych.
Niektórzy programici wol przedrostek „my” (mój), tak jak w nazwach myAge,
myWeight czy mySpeed. Jeszcze inni uywaj po prostu litery m (od sowa member
— skadowa), czasem wraz ze znakiem podkrelenia (_): mAge i m_age, mWeight
i m_weight czy mSpeed i m_speed.
Niektórzy programici lubi poprzedzi kad nazw klasy okrelon liter
— na przykad cCat czy cPerson — podczas, gdy inni uywaj wycznie duych
lub maych liter. Ja sam korzystam z konwencji, w której wszystkie nazwy klas
rozpoczynaj si od duej litery, tak jak Cat czy Person (osoba).
Wielu programistów rozpoczyna wszystkie nazwy funkcji od duej litery, za
wszystkie nazwy zmiennych — od maej. Sowa zwykle rozdzielane s znakiem
podkrelenia — tak jak w Chase_Mice — lub poprzez zastosowanie duej litery
dla kadego sowa — na przykad ChaseMice czy DrawCircle (rysuj okrg).
Wane jest, by wybra okrelony styl i trzyma si go w kadym programie.
Z czasem rozwiniesz swój styl nie tylko na konwencje nazw, ale take na wcicia,
wyrównanie nawiasów klamrowych oraz styl komentarzy.
W firmach programistycznych powszechne jest okrelenie standardu wielu
elementów stylu zapisu kodu ródowego. Sprawia on, e wszyscy programici
mog atwo odczytywa wzajemnie swój kod. Niestety, przenosi si to równie do
firm opracowujcych systemy operacyjne i biblioteki klas przeznaczonych do
ponownego uytku. Zazwyczaj oznacza to, e w programach C++ jest jednoczenie
stosowanych wiele rónych konwencji nazw.
Jak ju wczeniej wspomniano, jzyk C++ uwzgldnia wielko liter, dlatego
wszystkie nazwy klas powinny przestrzega tej samej konwencji. Dziki temu nigdy
nie bdziesz musia sprawdza pisowni nazwy klasy (czy to byo Rectangle,
rectangle
czy RECTANGLE?).
Dostp do elementów skadowych klasy
313
Definiowanie obiektu
Po zadeklarowaniu klasy mona jej nastpnie uywa jako nowego typu dla
definiowanych zmiennych tego typu. Definiowanie obiektu nowego typu
przypomina definiowanie zmiennej cakowitej:
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. Naley dokona
rozrónienia pomidzy ide kota a konkretnym kotem, który wanie ociera si
o Twoje nogi. C++ równie dokonuje rozrónienia pomidzy klas Cat, bdc
ide kota, a poszczególnymi obiektami typu Cat. Tak wic Frisky jest obiektem
typu Cat, tak jak GrossWeight jest zmienn typu unsigned int. Obiekt jest
indywidualnym egzemplarzem klasy.
Dostp do elementów skadowych klasy
Gdy zdefiniujesz ju faktyczny obiekt Cat — na przykad:
Cat Frisky;
w celu uzyskania dostpu do jego skadowych moesz uy operatora kropki (.).
Aby zmiennej skadowej itsWeight obiektu Frisky przypisa warto 50,
powiniene napisa:
Frisky.itsWeight = 50;
Aby wywoa funkcj Meow(), moesz napisa:
Frisky.Meow();
Gdy uywasz metody klasy, oznacza to, e wywoujesz t metod. W tym
przykadzie wywoae metod Meow() obiektu Frisky.
314
Lekcja 10.
Klasy i obiekty
Przypisywa naley obiektom, nie klasom
W C++ nie przypisuje si wartoci typom; przypisuje si je zmiennym. Na przykad,
nie mona napisa:
int = 5; // le
Kompilator uzna to za bd, gdy nie mona przypisa wartoci pi typowi
cakowitemu. Zamiast tego musisz zdefiniowa zmienn typu cakowitego
i przypisa jej warto 5. Na przykad:
int x ; // definicja zmiennej typu int
x = 5; // ustawienie wartoci zmiennej x na 5
Jest to skrócony zapis stwierdzenia: „Przypisz warto 5 zmiennej x, która jest
zmienn typu int”. Nie mona równie napisa:
Cat.itsAge = 5; // le
Kompilator uzna to za bd, gdy nie moesz przypisa wartoci 5 do elementu
itsAge klasy Cat. Zamiast tego musisz zdefiniowa egzemplarz obiektu klasy
Cat i dopiero wtedy przypisa warto jego skadowej. Na przykad:
Cat Frisky; // podobnie jak int x;
Frisky.itsAge = 5; // podobnie jak x = 5;
Czego nie zadeklarujesz,
tego klasa nie bdzie miaa
Przeprowad taki eksperyment: podejd do trzylatka i poka mu kota. Nastpnie
powiedz: To jest Frisky. Frisky zna sztuczk. Frisky, zaszczekaj! Dziecko rozemieje
si i powie: „Nie, guptasie, koty nie szczekaj!”.
Jeli napisae:
Cat Frisky; // tworzy obiekt Cat o nazwie Frisky
Frisky.Bark(); // nakazuje Friskiemu szczeka
Kompilator wywietli komunikat: „Nie, guptasie, koty (cats) nie szczekaj!”.
(By moe w Twoim kompilatorze ten komunikat bdzie brzmia nieco inaczej).
Kompilator wie, e Frisky nie moe szczeka, gdy klasa Cat nie posiada metody
Bark() (szczekaj). Kompilator nie pozwoli Friskiemu nawet zamiaucze, jeli nie
zdefiniujesz dla niego funkcji Meow() (miaucz).
Dostp prywatny i publiczny
315
Tak
Nie
Do deklarowania klasy uywaj sowa
kluczowego class.
W celu uzyskania dostpu do zmiennych
i funkcji skadowych klasy uywaj
operatora kropki (.).
Nie myl deklaracji z definicj. Deklaracja
mówi czym jest klasa, a definicja
przygotowuje pami dla obiektu.
Nie myl klasy z obiektem.
Nie przypisuj klasie wartoci. Wartoci
przypisuj danym skadowym obiektu.
Dostp prywatny i publiczny
W deklaracji klasy uywanych jest take kilka innych sów kluczowych. Dwa
najwaniejsze z nich to: public (publiczny) i private (prywatny).
Sowa kluczowe private i public s uywane wraz z egzemplarzami klasy
— zarówno ze zmiennymi skadowymi, jak i metodami klasy. Prywatne skadowe
mog by uywane tylko przez metody nalece do danej klasy. Skadowe
publiczne s dostpne dla innych funkcji i klas. To rozrónienie jest wane, cho
na pocztku moe sprawia kopot. Wszystkie skadowe klasy — dane i metody
— s domylnie prywatne. Aby to lepiej wyjani, spójrzmy na poprzedni przykad:
class Cat
{
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};
W tej deklaracji, skadowe itsAge, itsWeight oraz Meow() s prywatne, gdy
wszystkie skadowe klasy s prywatne domylnie. Oznacza to, e dopóki nie
postanowisz inaczej, pozostan one prywatne. Jeli jednak w funkcji main()
napiszesz na przykad:
Cat Bobas;
Bobas.itsAge = 5; // bd! nie mona uywa prywatnych danych!
kompilator uzna to za bd. We wczeniejszej deklaracji powiedziae kompilatorowi,
e skadowych itsAge, itsWeight oraz Meow() bdziesz uywa tylko w funkcjach
skadowych klasy Cat. W powyszym fragmencie kodu próbujesz odwoa si
do zmiennej skadowej obiektu Bobas spoza metody klasy Cat. To, e Bobas jest
obiektem klasy Cat, nie oznacza, e moesz korzysta z tych elementów obiektu
Bobas, które s prywatne.
316
Lekcja 10.
Klasy i obiekty
Wanie to jest ródem niekoczcych si kopotów pocztkujcych programistów
C++. Ju sysz, jak narzekasz: „Hej! Wanie napisaem, e Bobas jest kotem, tj.
obiektem klasy Cat. Dlaczego Bobas nie ma dostpu do swojego wasnego wieku?”.
Odpowied brzmi: Bobas ma dostp, ale Ty nie masz. Bobas, w swoich wasnych
metodach, ma dostp do wszystkich swoich skadowych, zarówno publicznych,
jak i prywatnych. Nawet jeli to Ty tworzysz obiekt klasy Cat, nie moesz
przeglda ani zmienia tych jego skadowych, które s prywatne.
Aby mie dostp do skadowych obiektu Cat, pewne elementy skadowe powinny
by publiczne:
class Cat
{
public:
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};
Teraz skadowe itsAge, itsWeight oraz Meow() s publiczne. Bobas.itsAge = 5;
kompiluje si bez problemów.
Sowo kluczowe public ma zastosowanie wzgldem wszystkich elementów
skadowych w danej deklaracji a do napotkania sowa kluczowego private i na
odwrót. W ten sposób sekcje klasy mona bardzo atwo zadeklarowa jako
publiczne bd prywatne.
Listing 10.1 przedstawia deklaracj klasy Cat z publicznymi zmiennymi skadowymi.
Listing 10.1. Dostp do publicznych skadowych w prostej klasie
1: // Demonstruje deklaracj klasy oraz
2: // definicje obiektu tej klasy.
3:
4: #include <iostream>
5:
6: class Cat // deklaruj klas Cat (kot)
7: {
8: public: // nastpujce po tym skadowe s publiczne
9: int itsAge; // zmienna skadowa
10: int itsWeight; // zmienna skadowa
11: }; // zwró uwag na rednik
12:
13: int main()
14: {
15: Cat Frisky;
Dostp prywatny i publiczny
317
16: Frisky.itsAge = 5; // przypisanie do zmiennej skadowej
17: std::cout << "Frisky jest kotem i ma " ;
18: std::cout << Frisky.itsAge << " lat.\n";
19: return 0;
20: }
Wynik
d
Frisky jest kotem i ma 5 lat.
Analiza
d
Linia 6. zawiera sowo kluczowe class. Informuje ono kompilator, e nastpuje
po nim deklaracja klasy. Nazwa nowej klasy nastpuje bezporednio po sowie
kluczowym class. W tym przypadku nazw klasy jest Cat (kot).
Ciao deklaracji rozpoczyna si w linii 7. od otwierajcego nawiasu klamrowego
i koczy si zamykajcym nawiasem klamrowym i rednikiem w linii 11. Linia 8.
zawiera sowo kluczowe public, które wskazuje, e wszystko, co po nim nastpi,
bdzie publiczne, a do natrafienia na sowo kluczowe private lub koniec deklaracji
klasy. Linie 9. i 10. zawieraj deklaracje skadowych 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 skadowa itsAge zostaje uyta
do wywietlenia informacji o kocie Frisky. Powiniene zauway, jak w liniach
16. i 18. nastpuje uzyskanie dostpu do obiektu Frisky. Zmienna itsAge jest
dostpna poprzez nazw obiektu (w tym przykadzie Frisky), nastpnie kropk
i nazw zmiennej skadowej (w tym przypadku itsAge).
Spróbuj wykomentowa lini 8., po czym skompiluj program ponownie. W linii 16.
wystpi bd, gdy zmienna skadowa itsAge nie bdzie ju skadow publiczn.
Domylnie, wszystkie skadowe klasy s prywatne.
Oznaczanie danych skadowych
jako prywatnych
Powiniene przyj jako ogóln regu, e dane skadowe klasy naley utrzymywa
jako prywatne. Oczywicie, moesz si zastanawia, w jaki sposób uzyska
informacje dotyczce klasy, jeli wszystkie elementy skadowe bd prywatne.
318
Lekcja 10.
Klasy i obiekty
Przykadowo, jeli zmienna itsAge bdzie prywatna, jak mona odczyta bd
ustawi wiek obiektu Cat?
W celu uzyskania dostpu do danych prywatnych w klasie musisz stworzy
publiczne funkcje skadowe, zwane akcesorami. Funkcje te umoliwi odczyt
zmiennych skadowych i przypisywanie im wartoci. Te funkcje dostpowe
(akcesory) s funkcjami skadowymi, uywanymi przez inne czci programu
w celu odczytywania i ustawiania prywatnych zmiennych skadowych. Publiczny
akcesor jest funkcj skadow klasy, uywan albo do odczytu wartoci prywatnej
zmiennej skadowej klasy, albo do ustawiania wartoci tej zmiennej.
Dlaczego miaby utrudnia sobie ycie dodatkowym poziomem poredniego
dostpu? Po co dodawa kolejne funkcje, skoro prociej i atwiej jest bezporednio
posugiwa si danymi? Jaki cel ma stosowanie akcesorów?
Odpowied na te pytania jest cakiem prosta: akcesory umoliwiaj oddzielenie
szczegóów przechowywania danych klasy od szczegóów jej uywania. Dziki
temu moesz zmienia sposób przechowywania danych klasy bez koniecznoci
przepisywania funkcji, które z tych danych korzystaj.
Jeli funkcja, która chce pozna wiek kota, odwoa si bezporednio do zmiennej
itsAge klasy Cat, bdzie musiaa zosta przepisana, jeeli Ty, jako autor klasy
Cat, zdecydujesz si na zmian sposobu przechowywania tej zmiennej. Jednak
posiadajc funkcj skadow GetAge() (pobierz wiek), klasa Cat moe atwo
zwróci waciw warto bez wzgldu na to, w jaki sposób przechowywany
bdzie wiek. Funkcja wywoujca nie musi wiedzie, czy jest on przechowywany
jako zmienna typu unsigned int czy long lub czy wiek jest obliczany w miar
potrzeb.
Ta technika uatwia zapanowanie nad programem. Przedua istnienie kodu,
gdy zmiany projektowe nie powoduj, e program staje si przestarzay.
Oprócz tego funkcje akcesorów mog zawiera dodatkow logik — na przykad
mao prawdopodobne jest, aby wiek kota (obiektu Cat) przekroczy warto 100,
a jego waga przekroczya warto 1000. Wymienione wartoci powinny by
niedozwolone. Funkcja akcesora moe wymusi stosowanie tego rodzaju
ogranicze, jak równie wykonywa wiele innych zada.
Listing 10.2 przedstawia klas Cat zmodyfikowan tak, by zawieraa prywatne
dane skadowe i publiczne akcesory. Zwró uwag, e ten listing przedstawia
wycznie deklaracj klasy, nie ma w nim kodu wykonywalnego.
Dostp prywatny i publiczny
319
Listing 10.2. Klasa z akcesorami
1: // Deklaracja klasy Cat
2: // Dane skadowe s prywatne, publiczne akcesory porednicz
3: // w ustawianiu i odczytywaniu wartoci skadowych 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 skadowa
15: void Meow();
16:
17: // prywatne dane skadowe
18: private:
19: unsigned int itsAge;
20: unsigned int itsWeight;
21: };
Analiza
d
Ta klasa posiada pi metod publicznych. Linie 8. i 9. zawieraj akcesory dla
skadowej itsAge. Moesz zobaczy, e w linii 8. znajduje si metoda pobierajca
wiek kota, natomiast w linii 9. metoda ustawiajca wiek kota. Linie 11. i 12.
zawieraj podobne akcesory dla skadowej itsWeight. Te akcesory ustawiaj
zmienne skadowe i zwracaj ich wartoci.
W linii 15. jest zadeklarowana publiczna funkcja skadowa Meow(). Ta funkcja
nie jest akcesorem. Nie zwraca wartoci ani ich nie ustawia; wykonuje inn
usug dla klasy — wywietla sowo Miau. Zmienne skadowe s zadeklarowane
w liniach 19. i 20.
Aby ustawi wiek Friska, powiniene przekaza warto metodzie SetAge()
(ustaw wiek), na przykad:
Cat Frisky;
Frisky.SetAge(5); // ustawia wiek Friska
// uywajc publicznego akcesora
W dalszej czci lekcji poznasz kod, dziki któremu metoda SetAge() oraz inne
mog dziaa.
320
Lekcja 10.
Klasy i obiekty
Zadeklarowanie metod lub danych jako prywatnych umoliwia kompilatorowi
wyszukanie w programach pomyek, zanim stan si one bdami. Kady szanujcy
si programista potrafi znale sposób na obejcie prywatnoci skadowych.
Stroustrup, autor jzyka C++, stwierdza, e „...mechanizmy ochrony z poziomu
jzyka chroni przed pomyk, a nie przed wiadomym oszustwem” (WNT, 1995).
Sowo kluczowe class
Skadnia sowa kluczowego class jest nastpujca:
class nazwa_klasy
{
// sowa kluczowe kontroli dostpu
// zadeklarowane zmienne i skadowe klasy
};
Sowo kluczowe class suy do deklarowania nowych typów. Klasa stanowi zbiór
danych skadowych klasy, które s zmiennymi rónych typów, take innych klas.
Klasa zawiera take funkcje klasy — tzw. metody — które s funkcjami uywanymi
do manipulowania danymi w danej klasie i wykonywania innych usug dla klasy.
Obiekty nowego typu definiuje si w taki sam sposób, w jaki definiuje si inne
zmienne. Naley okreli typ (klas), a po nim nazw zmiennej (obiektu).
Do uzyskania dostpu do funkcji i danych klasy suy operator kropki (.).
Sowa kluczowe kontroli dostpu okrelaj, które sekcje klasy s prywatne, a które
publiczne. Domylnie wszystkie skadowe klasy s prywatne. Kade sowo kluczowe
zmienia kontrol dostpu od danego miejsca a do koca klasy, lub kontrol
wystpienia nastpnego sowa kluczowego kontroli dostpu. Deklaracja klasy
koczy si zamykajcym nawiasem klamrowym i rednikiem.
Przykad 1
class Cat
{
public:
unsigned int Age;
unsigned int Weight;
void Meow();
};
Cat Frisky;
Frisky.Age = 8;
Frisky.Weight = 18;
Frisky.Meow();
Przykad 2
class Car
{
Implementowanie metod klasy
321
public: // pi nastpnych skadowych jest publicznych
void Start();
void Accelerate();
void Brake();
void SetYear(int year);
int GetYear();
private: // pozostaa 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 skadow Year na 84
bought = OldFaithful.GetYear(); // ustawia zmienn bought na 84
OldFaithful.Start(); //wywouje metod Start
Tak
Nie
Uywaj publicznych akcesorów, czyli
publicznych funkcji dostpowych.
Odwouj si do prywatnych zmiennych
skadowych z funkcji skadowych
klasy.
Nie deklaruj zmiennych skadowych
jako publiczne, o ile nie ma takiej
potrzeby.
Nie uywaj prywatnych zmiennych
skadowych klasy poza t klas.
Implementowanie metod klasy
Jak ju si przekonae, akcesory stanowi publiczny interfejs do prywatnych
danych klasy. Kady akcesor musi posiada, wraz z innymi zadeklarowanymi
metodami klasy, implementacj. Implementacja jest nazywana definicjfunkcji.
Definicja funkcji skadowej rozpoczyna si podobnie jak definicja zwykej funkcji.
W pierwszej kolejnoci trzeba poda typ zwracany z danej funkcji lub uy
sowa kluczowego void, jeli funkcja niczego nie zwraca. Nastpnie podajemy
nazw klasy, po której wystpuj dwa dwukropki, nazwa funkcji i jej parametry.
Listing 10.3 przedstawia pen 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 <iostream> // dla cout
4:
5: class Cat // pocztek deklaracji klasy
6: {
7: public: // pocztek sekcji publicznej
8: int GetAge(); // akcesor
9: void SetAge(int age); // akcesor
10: void Meow(); // ogólna funkcja
11: private: // pocztek sekcji prywatnej
12: int itsAge; // zmienna skadowa
13: };
14:
15: // GetAge, publiczny akcesor
16: // zwracajcy warto skadowej itsAge
17: int Cat::GetAge()
18: {
19: return itsAge;
20: }
21:
22: // definicja SetAge, akcesora
23: // publicznego
24: // ustawiajcego skadow itsAge
25: void Cat::SetAge(int age)
26: {
27: // ustawia zmienn skadow itsAge
28: // zgodnie z wartoci przekazan w parametrze age
29: itsAge = age;
30: }
31:
32: // definicja metody Meow
33: // zwraca: void
34: // parametery: brak
35: // dziaanie: wywietla na ekranie sowo "miauczy"
36: void Cat::Meow()
37: {
38: std::cout << "Miauczy.\n";
39: }
40:
41: // tworzy kota, ustawia jego wiek, sprawia,
42: // e miauczy, wywietla 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
d
Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Analiza
d
Linie od 5. do 13. zawieraj definicj klasy Cat (kot). Linia 7. zawiera sowo
kluczowe public, które informuje kompilator, e to, co po nim nastpuje, jest
zestawem publicznych skadowych. Linia 8. zawiera deklaracj publicznego
akcesora GetAge() (pobierz wiek). GetAge() zapewnia dostp do prywatnej
zmiennej skadowej itsAge (jego wiek), zadeklarowanej w linii 12. Linia 9.
zawiera publiczny akcesor SetAge() (ustaw wiek). Funkcja SetAge() otrzymuje
parametr typu int, który nastpnie przypisuje skadowej itsAge.
Linia 10. zawiera deklaracj metody Meow() (miaucz). Funkcja Meow() nie jest
akcesorem. Jest to ogólna metoda klasy, wywietlajca na ekranie sowo „Miauczy.”
Linia 11. rozpoczyna sekcj prywatn, która obejmuje jedynie zadeklarowan
w linii 12. prywatn skadow itsAge. Deklaracja klasy koczy si w linii 13.
zamykajcym nawiasem klamrowym i rednikiem.
Linie od 17. do 20. zawieraj definicj skadowej funkcji GetAge(). Ta metoda
nie ma parametrów i zwraca warto cakowit. Zauwa, e ta metoda klasy
zawiera nazw klasy, dwa dwukropki oraz nazw funkcji (linia 17.). Ta skadnia
informuje kompilator, e definiowana funkcja GetAge() jest wanie t funkcj,
która zostaa zadeklarowana w klasie Cat. Poza formatem tego nagówka,
definiowanie funkcji wasnej GetAge() niczym nie róni si od definiowania
innych (zwykych) funkcji.
Funkcja GetAge() posiada tylko jedn lini i zwraca po prostu warto zmiennej
skadowej itsAge. Zauwa, e funkcja main() nie ma dostpu do tej zmiennej
skadowej, gdy jest ona prywatna dla klasy Cat. Funkcja main() ma za to dostp
do publicznej metody GetAge().
324
Lekcja 10.
Klasy i obiekty
Poniewa ta metoda jest skadow klasy Cat, ma peny dostp do zmiennej itsAge.
Dziki temu moe zwróci funkcji main() warto zmiennej itsAge.
Linia 25. zawiera definicj funkcji skadowej SetAge(). Moesz zauway, e ta
funkcja pobiera jedn warto w postaci liczby cakowitej (age) i nie zwraca adnej
wartoci, co jest wskazane przez sowo kluczowe void. Ta funkcja posiada
parametr w postaci wartoci cakowitej i przypisuje skadowej itsAge jego
warto (linia 29.). Poniewa jest skadow klasy Cat, ma bezporedni dostp
do jej zmiennych prywatnych i publicznych.
Linia 36. rozpoczyna definicj (czyli implementacj) metody Meow() klasy Cat.
Jest to jednoliniowa funkcja wywietlajca na ekranie sowo „Miauczy”, zakoczone
znakiem nowej linii. Pamitaj, e znak \n powoduje przejcie do nowej linii. Moesz
zauway, e metoda Meow() jest zaimplementowana podobnie jak funkcja
akcesora, czyli rozpoczyna si od typu zwracanej wartoci, a nastpnie mamy
nazw klasy, nazw funkcji oraz parametry (w tym przypadku nie ma adnych
parametrów).
Linia 43. rozpoczyna ciao funkcji main(), czyli waciwy program. W linii 45.,
funkcja main() deklaruje obiekt Cat o nazwie Frisky. Ujmujc to inaczej, mona
powiedzie, e funkcja main() deklaruje kota (Cat) o imieniu Frisky.
W linii 46. zmiennej itsAge tego obiektu jest przypisywana warto 5 (poprzez
uycie akcesora SetAge()). Zauwa, e wywoanie tej metody nastpuje dziki
uyciu nazwy obiektu (Frisky), po której zastosowano operator kropki (.) i nazw
metody (SetAge()). W podobny sposób wywoywane s wszystkie inne metody
wszystkich klas.
Pojcia funkcja skadowa i metoda skadowa mog by uywane zamiennie.
Linia 47. wywouje funkcj skadow Meow(), za w linii 49. za pomoc akcesora
GetAge(), wywietlany jest komunikat. Linia 50. ponownie wywouje funkcj Meow().
Cho wymienione metody s czci klasy (Cat) i uywane poprzez obiekt (Frisky),
to dziaaj dokadnie tak samo jak funkcje, które widziae do tej pory.
Konstruktory i destruktory
Istniej dwa sposoby definiowania zmiennej cakowitej. Mona zdefiniowa zmienn,
a nastpnie, w dalszej czci programu, przypisa jej warto. Na przykad:
Konstruktory i destruktory
325
int Weight; // definiujemy zmienn
... // tu inny kod
Weight = 7; // przypisujemy jej warto
Moemy te zdefiniowa zmienn i jednoczenie zainicjalizowa j. Na przykad:
int Weight = 7; // definiujemy i inicjalizujemy wartoci 7
Inicjalizacja czy w sobie definiowanie zmiennej oraz pocztkowe przypisanie
wartoci. Nic nie stoi na przeszkodzie temu, by zmieni póniej warto zmiennej.
Inicjalizacja powoduje tylko, e zmienna nigdy nie bdzie pozbawiona sensownej
wartoci.
W jaki sposób zainicjalizowa skadowe klasy? Klasy posiadaj specjalne funkcje
skadowe, zwane konstruktorami. Konstruktor (ang. constructor) moe w razie
potrzeby posiada parametry, ale nie moe zwraca wartoci — nawet typu void.
Konstruktor jest metod klasy o takiej samej nazwie, jak nazwa klasy.
Gdy zadeklarujesz konstruktor, powiniene take zadeklarowa destruktor
(ang. destructor). Konstruktor tworzy i inicjalizuje obiekt danej klasy, za destruktor
porzdkuje obiekt i zwalnia pami, któr moge 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 wartoci. Dlatego deklaracja destruktora klasy Cat
ma nastpujc posta:
~Cat();
Domylne konstruktory i destruktory
Istnieje wiele rodzajów konstruktorów; niektóre z nich posiadaj argumenty,
inne nie. Konstruktor, którego mona wywoa bez adnych argumentów, jest
nazywany konstruktorem domylnym. Istnieje tylko jeden rodzaj destruktora.
On take nie posiada argumentów.
Jeli nie stworzysz konstruktora lub destruktora, kompilator stworzy je za
Ciebie. Konstruktor dostarczany przez kompilator jest konstruktorem domylnym
— czyli konstruktorem bez argumentów. Stworzone przez kompilator domylny
konstruktor i destruktor nie maj adnych argumentów, a na dodatek w ogóle nic
nie robi! Jeeli chcesz, aby wykonyway jakiekolwiek operacje, musisz samodzielnie
utworzy domylny konstruktor i destruktor.
326
Lekcja 10.
Klasy i obiekty
Uycie domylnego konstruktora
Do czego moe przyda si konstruktor, który nic nie robi? Jest to problem
techniczny: wszystkie obiekty musz by konstruowane i niszczone, dlatego
w odpowiednich momentach wywoywane s te nic nie robice funkcje.
Aby móc zadeklarowa obiekt bez przekazywania parametrów, na przykad
Cat Boots; // Boots nie ma parametrów
musisz posiada konstruktor w postaci
Cat();
Gdy definiujesz obiekt klasy, wywoywany jest konstruktor. Gdyby konstruktor
klasy Cat mia dwa parametry, mógby zdefiniowa obiekt Cat, piszc
Cat Frisky (5, 7);
W tym przypadku pierwszy parametr mógby by wiekiem, natomiast drugi
mógby oznacza wag kota. Gdyby konstruktor mia jeden parametr, napisaby
Cat Frisky (3);
W przypadku, gdy konstruktor nie ma adnych parametrów (gdy jest konstruktorem
domylnym), moesz opuci nawiasy i napisa
Cat Frisky;
Jest to wyjtek od reguy, zgodnie z któr wszystkie funkcje wymagaj zastosowania
nawiasów, nawet jeli nie maj parametrów. Wanie dlatego moesz napisa:
Cat Frisky;
Jest to interpretowane jako wywoanie konstruktora domylnego. Nie dostarczamy
mu parametrów i pomijamy nawiasy.
Zwró uwag, e nie musisz uywa domylnego konstruktora dostarczanego
przez kompilator. Zawsze moesz napisa wasny konstruktor domylny — tj.
konstruktor bez parametrów. Moesz zastosowa w nim ciao funkcji, w którym
moesz zainicjalizowa obiekt. Zgodnie z konwencj, zawsze zaleca si zdefiniowanie
konstruktora i ustawienie zmiennym skadowym odpowiednich wartoci
domylnych w celu zagwarantowania prawidowego zachowania obiektu.
Zgodnie z konwencj, gdy deklarujesz konstruktor, powiniene take zadeklarowa
destruktor, nawet jeli nie robi on niczego. Nawet jeli destruktor domylny bdzie
dziaa poprawnie, nie zaszkodzi zadeklarowa wasnego. Dziki 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 uyto domylnego konstruktora. Wiek kota zosta ustawiony zgodnie
z wartoci otrzyman jako parametr konstruktora. Listing pokazuje równie
miejsce, w którym wywoywany jest destruktor.
Listing 10.4. Uycie konstruktora i destruktora
1: // Demonstruje deklarowanie konstruktora
2: // i destruktora dla klasy Cat
3: // Domylny konstruktor zosta stworzony przez programist
4: #include <iostream> // dla cout
5:
6: class Cat // pocztek deklaracji klasy
7: {
8: public: // pocztek 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: // pocztek sekcji prywatnej
15: int itsAge; // zmienna skadowa
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 skadowej 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 skadow itsAge
40: // zgodnie z wartoci 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: // dziaanie: wywietla na ekranie sowo "miauczy"
48: void Cat::Meow()
49: {
50: std::cout << "Miauczy.\n";
51: }
52:
53: // tworzy kota, ustawia jego wiek, sprawia,
54: // e miauczy, wywietla 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
d
Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Teraz Frisky ma 7 lat.
Analiza
d
Listing 10.4 przypomina listing 10.3, jednak w linii 9. dodano konstruktor,
posiadajcy argument w postaci wartoci cakowitej. Linia 10. deklaruje destruktor,
który nie posiada parametrów. Destruktory nigdy nie maj parametrów, za
destruktory i konstruktory nie zwracaj adnych wartoci — nawet typu void.
Linie od 19. do 22. zawieraj implementacj konstruktora. Jest ona podobna do
implementacji akcesora SetAge(). Jak moesz zobaczy, nazwa klasy poprzedza
nazw konstruktora. Jak ju wczeniej wspomniano, to identyfikuje metod
(w tym przypadku Cat()) jako cz klasy Cat. Poniewa wymieniona metoda
jest konstruktorem, to nie zwraca adnej wartoci, nawet void. Jednak w linii 21.
konstruktor pobiera warto pocztkow przypisan danej skadowej itsAge.
Funkcje skadowe const
329
Linie od 24. do 26. przedstawiaj implementacj destruktora ~Cat(). W tej
chwili ta funkcja nie robi nic, ale jeli deklaracja klasy zawiera deklaracj
destruktora, zdefiniowany musi zosta wtedy take 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, stanowicego egzemplarz klasy Cat.
Do konstruktora obiektu Frisky przekazywana jest warto 5. Nie ma potrzeby
wywoywania funkcji SetAge(), gdy Frisky zosta stworzony z wartoci 5
znajdujc si w zmiennej skadowej itsAge, tak jak pokazano w linii 60. W linii 62.
zmiennej itsAge obiektu Frisky jest przypisywana warto 7. T now warto
wywietla linia 64.
Tak
Nie
W celu zainicjalizowania obiektów
uywaj konstruktorów.
Jeeli dodae konstruktor, dodaj
równie destruktor.
Pamitaj, e konstruktory i destruktory
nie mog zwraca wartoci.
Pamitaj, e destruktory nie mog
mie parametrów.
Funkcje skadowe const
Sowo kluczowe const suy do deklarowania zmiennych, które nie ulegaj
zmianie. Const mona stosowa równie wraz z funkcjami skadowymi w klasie.
Jeli zadeklarujesz metod klasy jako const, obiecujesz w ten sposób, e metoda
ta nie zmieni wartoci adnej ze skadowych klasy.
Aby zadeklarowa metod w ten sposób, umie sowo kluczowe const za
nawiasami, lecz przed rednikiem. Przykadowo:
void SomeFunction() const;
Pokazana powyej deklaracja funkcji skadowej const o nazwie SomeFunction()
nie posiada argumentów i zwraca typ void. Wiesz, e powysza funkcja nie zmieni
adnych elementów skadowych w klasie, poniewa zostaa zadeklarowana wraz
ze sowem kluczowym const.
330
Lekcja 10.
Klasy i obiekty
Wraz z modyfikatorem const czsto deklarowane s akcesory, które jedynie
pobieraj warto. Przedstawiona wczeniej klasa Cat posiada dwa akcesory:
void SetAge(int anAge);
int GetAge();
Funkcja SetAge() nie moe by funkcj const, gdy modyfikuje warto zmiennej
skadowej itsAge. Natomiast funkcja GetAge() moe i powinna by const, gdy
nie modyfikuje wartoci adnej ze skadowych klasy. Funkcja GetAge() po prostu
zwraca biec warto skadowej itsAge. Zatem deklaracje tych funkcji mona
przepisa nastpujco:
void SetAge(int anAge);
int GetAge() const;
Gdy zadeklarujesz funkcj jako const, za implementacja tej funkcji modyfikuje
obiekt poprzez modyfikacj wartoci którejkolwiek ze skadowych, kompilator
zgosi bd. Na przykad, gdy napiszesz funkcj GetAge() w taki sposób, e bdziesz
zapamitywa ilo zapyta o wiek kota, spowodujesz bd kompilacji. Jest to
spowodowane tym, e wywoujc t metod, modyfikujesz zawarto obiektu Cat.
Deklarowanie funkcji jako const wszdzie tam, gdzie jest to moliwe, naley
do tradycji programistycznej. Za kadym razem, gdy to zrobisz, umoliwisz
kompilatorowi wykrycie pomyki, zanim stanie si ona bdem, który ujawni si
ju podczas dziaania programu.
Po co uywa kompilatora do wykrywania bdów?
Gdyby mona byo tworzy programy w stu procentach pozbawione bdów,
byoby cudowanie, jednak tylko bardzo niewielu programistów jest w stanie
tego dokona. Wielu programistów opracowao jednak system pozwalajcy
zminimalizowa ilo bdów przez wczesne ich wykrycie i poprawienie.
Cho bdy kompilatora s irytujce i stanowi dla programisty przeklestwo, jednak
s czym duo lepszym ni opisana dalej alternatywa. Jzyk o sabej kontroli typów
umoliwia naruszanie zasad kontraktu bez sowa sprzeciwu ze strony kompilatora,
jednak program moe zaama si w trakcie dziaania — na przykad wtedy, gdy
pracuje z nim Twój szef. Co gorsze, w takim przypadku testowanie w celu
wychwycenia tych bdów bdzie mao pomocne, poniewa istnieje zbyt duo
cieek wykonywania kodu rzeczywistych programów, aby móc przetestowa je
wszystkie.
Bdy czasu kompilacji — tj. bdy wykryte podczas kompilowania programu —
s zdecydowanie lepsze ni bdy czasu dziaania — tj. bdy wykryte podczas
dziaania programu. S lepsze, gdy duo atwiej i precyzyjniej mona okreli
Gdzie umieszcza deklaracje klasy i definicje metod
331
ich przyczyn. Moe si zdarzy, e program zostanie wykonany wielokrotnie
bez wykonania wszystkich istniejcych cieek wykonania kodu. Dlatego bd
czasu dziaania moe przez duszy czas pozosta niezauwaony. Bdy kompilacji
s wykrywane podczas kadej kompilacji, s wic duo atwiejsze do zidentyfikowania
i poprawienia. Celem dobrego programowania jest ochrona przed pojawianiem si
bdów czasu dziaania. Jedn ze znanych i sprawdzonych technik jest wykorzystanie
kompilatora do wykrycia pomyek ju na wczesnym etapie tworzenia programu.
Gdzie umieszcza deklaracje klasy
i definicje metod
Kada funkcja, któr zadeklarujesz dla klasy, musi posiada definicj. Definicja
jest nazywana take implementacjfunkcji. Podobnie jak w przypadku innych
funkcji, definicja metody klasy posiada nagówek i ciao.
Definicja musi znajdowa si w pliku, który moe zosta znaleziony przez
kompilator. Wikszo kompilatorów C++ wymaga, by taki plik mia rozszerzenie
.c lub .cpp. W tej ksice korzystamy z rozszerzenia .cpp, ale aby mie pewno,
sprawd, czego oczekuje Twój kompilator.
Wiele kompilatorów zakada, e pliki z rozszerzeniem .c s programami C,
za pliki z rozszerzeniem .cpp s programami C++. Moesz uywa dowolnego
rozszerzenia, ale rozszerzenie .cpp wyeliminuje ewentualne nieporozumienia.
W pliku, w którym umieszczasz implementacj funkcji, moesz umieci równie
jej deklaracj, ale nie naley to do dobrych obyczajów. Zgodnie z konwencj
zaadoptowan przez wikszo programistów, deklaracje umieszcza si w tak
zwanych plikach nagówkowych, zwykle posiadajcych t sam nazw, lecz
z rozszerzeniem .h, .hp lub .hpp. W tej ksice dla plików nagówkowych stosujemy
rozszerzenie .h, ale sprawd w swoim kompilatorze, jakie rozszerzenie powiniene
stosowa.
Na przykad, deklaracj klasy Cat powiniene umieci w pliku o nazwie Cat.h, za
definicj metod tej klasy w pliku o nazwie Cat.cpp. Nastpnie powiniene doczy
do pliku .cpp plik nagówkowy, poprzez umieszczenie na pocztku pliku Cat.cpp
nastpujcej 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 rcznie. Uwaga: niektóre kompilatory nalegaj, by wielko liter
w nazwie pliku w dyrektywie #include zgadzaa si z wielkoci liter w nazwie
pliku na dysku.
Dlaczego masz si trudzi, rozdzielajc program na pliki .h i .cpp, skoro i tak plik .h
jest wstawiany do pliku .cpp? W wikszoci przypadków klienci klasy nie dbaj
o szczegóy jej implementacji. Odczytanie pliku nagówkowego daje im wystarczajc
ilo informacji, by zignorowa plik implementacji. Poza tym, ten sam plik .h moesz
docza 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ódziaa. Ten interfejs jest
zwykle przechowywany w pliku .h, czsto nazywanym plikiem nagówkowym.
Definicja funkcji mówi kompilatorowi, jak dziaa dana funkcja. Definicja funkcji
jest nazywana implementacj metody klasy i jest przechowywana w pliku .cpp.
Szczegóy dotyczce implementacji klasy nale wycznie do jej autora. Klienci
klasy — tj. czci programu uywajce tej klasy — nie musz, ani nie powinny
wiedzie, jak zaimplementowane zostay funkcje.
Implementacja inline
Moesz poprosi kompilator, by uczyni zwyk funkcj funkcj inline, funkcjami
inline mog sta si równie metody klasy. W tym celu naley umieci sowo
kluczowe inline przed typem zwracanej wartoci. Na przykad, implementacja
inline funkcji GetWeight() wyglda nastpujco:
inline int Cat::GetWeight()
{
return itsWeight; // zwraca dan skadow itsWeight
}
Definicj funkcji mona take umieci w deklaracji klasy, co automatycznie sprawia,
e ta funkcja staje si funkcj inline. Na przykad:
class Cat
{
public:
int GetWeight() { return itsWeight; } // inline
void SetWeight(int aWeight);
};
Implementacja inline
333
Zwró uwag na skadni definicji funkcji GetWeight(). Ciao funkcji inline
zaczyna si natychmiast po deklaracji metody klasy; po nawiasach nie wystpuje
rednik. Podobnie jak w innych funkcjach, definicja zaczyna si od otwierajcego
nawiasu klamrowego i koczy zamykajcym nawiasem klamrowym. Jak zwykle,
biae znaki nie maj znaczenia; moesz 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
zostaa 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 <iostream>
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 doczanie pliku nagówkowego
3: // pamitaj o wczeniu 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, wywietla 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
d
Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Teraz Frisky ma 7 lat.
Analiza
d
Kod zaprezentowany na listingach 10.5 i 10.6 jest podobny do kodu z listingu 10.4,
trzy metody zostay zadeklarowane w pliku deklaracji jako inline, a deklaracja
zostaa przeniesiona do pliku Cat.hpp (listing 10.5).
Funkcja GetAge() jest deklarowana w linii 6. pliku Cat.h, gdzie znajduje si
take jej implementacja inline. Linie 7. i 8. zawieraj kolejne funkcje inline,
jednak w stosunku do poprzednich, „zwykych” implementacji, dziaanie tych
funkcji nie zmienia si.
Linia 4. listingu 10.6 zawiera dyrektyw #include "Cat.h", która powoduje
wstawienie do pliku zawartoci pliku Cat.h. Doczajc plik Cat.h, informujesz
prekompilator, by odczyta zawarto tego pliku i wstawi j w miejscu wystpienia
dyrektywy #include (tak jakby, poczwszy od linii 5, sam wpisa t zawarto).
Ta technika umoliwia umieszczenie deklaracji w pliku innym ni implementacja,
a jednoczenie zapewnienie kompilatorowi dostpu do niej. W programach C++
Klasy, których danymi skadowymi s inne klasy
335
technika ta jest powszechnie wykorzystywana. Zwykle deklaracje klas znajduj
si w plikach .h, które s doczane do powizanych 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 dziaaj tak samo jak zwyke funkcje.
Klasy, których danymi skadowymi
s inne klasy
Budowanie zoonych klas przez deklarowanie prostszych klas i doczanie ich do
deklaracji bardziej skomplikowanej klasy nie jest niczym niezwykym. Na przykad,
moesz zadeklarowa klas koa, klas silnika, klas skrzyni biegów itd., a nastpnie
poczy je w klas „samochód”. Deklaruje to relacj posiadania. Samochód
posiada silnik, koa i skrzyni biegów.
Wemy inny przykad. Prostokt skada si z odcinków. Odcinek jest zdefiniowany
przez dwa punkty. Punkt jest zdefiniowany przez wspórzdn x i wspórzdn
y. Listing 10.7 przedstawia pen deklaracj klasy Rectangle (prostokt), która
moe wystpi w pliku Rectangle.h. Poniewa prostokt jest zdefiniowany jako
cztery odcinki czce cztery punkty, za kady punkt odnosi si do wspórzdnej
w ukadzie, najpierw zadeklarujemy klas Point (punkt) jako przechowujc
wspórzdne x oraz y punktu. Listing 10.8 zawiera implementacje obu klas.
Listing 10.7. Deklarowanie kompletnej klasy
1: // pocztek Rect.h
2: #include <iostream>
3: class Point // przechowuje wspórzdne x,y
4: {
5: // bez konstruktora, uywa domylnego
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: // pocztek rect.cpp
2: #include "rect.h"
3: Rectangle::Rectangle(int top, int left, int bottom, int right)
Klasy, których danymi skadowymi 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 prostokta przez obliczenie
25: // i pomnoenie szerokoci i wysokoci
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
d
Obszar: 3000
Wsp. X lewego górnego rogu: 20
338
Lekcja 10.
Klasy i obiekty
Analiza
d
Linie od 3. do 14. listingu 10.7 deklaruj klas Point (punkt), która suy do
przechowywania wspórzdnych x i y okrelonego punktu rysunku. W tym
programie nie wykorzystujemy naleycie klasy Point. Jej zastosowania wymagaj
jednak inne metody rysunkowe.
Gdy nadasz klasie nazw Rectangle, niektóre kompilatory zgosz bd. Wynika
to z istnienia wewntrznej klasy o nazwie Rectangle. W takim przypadku po prostu
zmie nazw klasy na myRectangle.
W deklaracji klasy Point, w liniach 12. i 13., zadeklarowalimy dwie zmienne
skadowe (itsX oraz itsY). Te zmienne przechowuj wspórzdne punktu.
Zakadamy, e wspórzdna x ronie w prawo, a wspórzdna y w gór. Istniej
take inne systemy. W niektórych programach okienkowych wspórzdna y ronie
„w dó” okna.
Klasa Point uywa akcesorów inline, zwracajcych i ustawiajcych wspórzdne
X i Y punktu. Te akcesory zostay zadeklarowane w liniach od 7. do 10. Punkty
uywaj konstruktora i destruktora domylnego. W zwizku z tym ich wspórzdne
trzeba ustawia jawnie.
Linia 17. rozpoczyna deklaracj klasy Rectangle (prostokt). Klasa ta skada si
z czterech punktów reprezentujcych cztery naroniki prostokta. Konstruktor klasy
Rectangle (linia 20.) otrzymuje cztery wartoci cakowite, top (górna), left (lewa),
bottom (dolna) oraz right (prawa). Do czterech zmiennych skadowych (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 prostokta, nastpnie mnoy je przez siebie.
Uzyskanie wspórzdnej x lewego górnego wierzchoka prostokta wymaga
dostpu do punktu UpperLeft (lewy górny) i zapytania o jego wspórzdn X.
Poniewa funkcja GetUpperLeft() jest funkcj klasy Rectangle, moe ona
bezporednio odwoywa si do prywatnych danych tej klasy, wcznie ze zmienn
(itsUpperLeft). Poniewa itsUpperLeft jest obiektem klasy Point, a zmienna
itsX tej klasy jest prywatna, funkcja GetUpperLeft() nie moe odwoywa si
do niej bezporednio. Zamiast tego, w celu uzyskania tej wartoci musi uy
publicznego akcesora GetX().
Klasy, których danymi skadowymi s inne klasy
339
Linia 33. listingu 10.8 stanowi pocztek ciaa programu. Pami nie jest alokowana
a do linii 36.; w obszarze tym nic si nie dzieje. Jedyna rzecz, jak zrobilimy,
to poinformowanie kompilatora, jak ma stworzy punkt i prostokt (gdyby
byy potrzebne w przyszoci). W linii 36. definiujemy obiekt typu Rectangle,
przekazujc mu wartoci top, left, bottom oraz right.
W linii 38. tworzymy lokaln zmienn Area (obszar) typu int. Ta zmienna
przechowuje obszar stworzonego przez nas prostokta. Zmienn Area inicjalizujemy
za pomoc wartoci zwróconej przez funkcj GetArea() klasy Rectangle. Klient
klasy Rectangle moe stworzy obiekt tej klasy i uzyska jego obszar, nie znajc
nawet implementacji funkcji GetArea().
Plik Rect.h zosta przedstawiony na listingu 10.7. Obserwujc plik nagówkowy,
który zawiera deklaracj klasy Rectangle, programista moe 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ógby zmieni funkcj GetArea(); nie wpynoby to na programy, które z niej
korzystaj, o ile wartoci zwrotn nadal byaby liczba cakowita.
Linia 42. listingu 10.8 moe wydawa si nieco dziwna, ale jeli zastanowisz si nad
tym, co tam si dzieje, powinna sta si jasna. W tej linii kodu nastpuje pobranie
wspórzdnej x lewego górnego punktu prostokta. Wzgldem prostokta
wywoywana jest metoda GetUpperLeft(), która zwraca obiekt typu Point.
Z tego obiektu potrzebujemy wspórzdnej x. Wczeniej dowiedziae si,
e akcesorem dla punktu x klasy Point jest GetX(). Dlatego te w celu pobrania
wspórzdnej x lewego górnego naronika prostokta naley uy akcesora GetX()
wzgldem funkcji akcesora GetUpperLeft() obiektu MyRectangle. To wanie
przedstawiono w linii 42.:
MyRectangle.GetUpperLeft().GetX();
Czsto zadawane pytanie
Jaka jest rónica pomidzy deklaracj a definicj?
Odpowied
Deklaracja wprowadza now nazw, lecz nie alokuje pamici; dokonuje tego definicja.
Wszystkie deklaracje (z kilkoma wyjtkami) s take definicjami. Najwaniejszym
wyjtkiem jest deklaracja funkcji globalnej (prototyp) oraz deklaracja klasy (zwykle
w pliku nagówkowym).
340
Lekcja 10.
Klasy i obiekty
Struktury
Bardzo bliskim kuzynem sowa kluczowego class jest sowo kluczowe struct,
uywane do deklarowania struktur. W C++ struktura jest odpowiednikiem klasy,
ale wszystkie jej skadowe s domylnie publiczne. Moesz zadeklarowa struktur
dokadnie tak, jak klas; moesz zastosowa w niej te same zmienne i funkcje
skadowe. Gdy przestrzegasz jawnego deklarowania publicznych i prywatnych
sekcji klasy, nie ma adnej rónicy pomidzy klas a struktur. Spróbuj wprowadzi
do listingu 10.7 nastpujce zmiany:
X
w linii 3., zmie class Point na struct Point,
X
w linii 17., zmie class Rectangle na struct Rectangle.
Nastpnie skompiluj i uruchom program. Otrzymane wyniki nie powinny si od
siebie róni.
Prawdopodobnie zastanawiasz si, dlaczego dwa sowa kluczowe speniaj t
sam funkcj. Przyczyn naley szuka w historii jzyka. Jzyk C++ powstawa
jako rozszerzenie jzyka C. Jzyk C posiada struktury, ale nie posiadaj one metod.
Bjarne Stroustrup, twórca jzyka C++, rozbudowa struktury, ale zmieni ich nazw
na klasy, odzwierciedlajc w ten sposób ich nowe, rozszerzone moliwoci oraz
zmian w domylnej dostpnoci elementów skadowych. To pozwala równie
na uywanie w programach C++ ogromnej biblioteki funkcji jzyka C.
Tak
Nie
Umieszczaj deklaracj klasy w pliku
nagówkowym .h, za funkcje skadowe
definiuj w pliku .cpp.
Uywaj const wszdzie tam, gdzie
jest to moliwe.
Nie przechod dalej, zanim dokadnie
nie zrozumiesz zasady dziaania klasy.
Podsumowanie
W tej lekcji nauczye si tworzy nowe typy danych za pomoc klas. Wiesz take,
jak definiowa zmienne tych nowych typów, które nazywamy obiektami.
Klasa moe mie dane skadowe, którymi s zmienne rónych typów, cznie
z innymi klasami. Poza tym, klasa moe zawiera funkcje skadowe — nazywane
równie metodami. Wymienione funkcje skadowe su do manipulowania
danymi skadowymi oraz przeprowadzania innych operacji.
Pytania i odpowiedzi
341
Elementy skadowe klasy, zarówno dane, jak i funkcje, mog by publiczne bd
prywatne. Elementy publiczne s dostpne w dowolnym miejscu programu.
Z kolei elementy prywatne s dostpne jedynie dla funkcji skadowych danej
klasy. Domylnie, elementy skadowe s definiowane jako prywatne.
Dobrym nawykiem w programowaniu jest izolowanie interfejsu — inaczej
deklaracji — klasy w pliku nagówkowym. Zazwyczaj odbywa si to poprzez
uycie pliku z rozszerzeniem .h, a nastpnie 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 uywane do inicjalizacji danych skadowych
obiektu. Natomiast destruktory s wykonywane w trakcie niszczenia obiektu.
W destruktorze bardzo czsto nastpuje zwolnienie pamici i innych zasobów,
które mogy zosta zaalokowane przez metody klasy.
Pytania i odpowiedzi
Pytanie:Jakduyjestobiektklasy?
Odpowied: Wielko obiektu w pamici zaley od wielkoci jego zmiennych
skadowych. Metody klasy zuywaj bardzo niewielkie iloci pamici, która jest
wykorzystywana do przechowywania informacji o pooeniu metody (wskanika).
Niektóre kompilatory umieszczaj zmienne w pamici w taki sposób, e dwubajtowe
zmienne zuywaj wicej ni tylko dwa bajty pamici. Zajrzyj do dokumentacji
uywanego kompilatora, aby to sprawdzi. Jednak na tym etapie nie naley
przejmowa si takimi szczegóami.
Pytanie:JeelizadeklarujklasCatwrazzprywatnymelementemskadowym
itsAge,anastpniezdefiniujdwaobiektyFriskyiBoots,czyobiektBoots
bdziemiadostpdozmiennejskadowejitsAgeobiektuFrisky?
Odpowied: Nie. Róne egzemplarze klasy mog uzyska dostp jedynie do danych
publicznych innych egzemplarzy tej klasy. Innymi sowy, jeeli Frisky i Boots
to egzemplarze klasy Cat, funkcje skadowe obiektu Frisky mog uzyska dostp
do danych obiektu Frisky, ale ju nie do danych obiektu Boots.
Pytanie:Dlaczegoniepowinienemdefiniowajakopublicznychwszystkich
danychskadowych?
342
Lekcja 10.
Klasy i obiekty
Odpowied: Zdefiniowanie danych skadowych jako prywatne umoliwia
klientowi klasy uywanie tych danych bez adnej zalenoci dotyczcej sposobu
ich przechowywania bd obliczania. Przykadowo, jeeli klasa Cat (kot) ma
metod GetAge(), klient klasy Cat moe zapyta obiekt o wiek kota, nie znajc
i nie przejmujc si sposobem, w jaki klasa Cat przechowuje ten wiek bd jak
oblicza go w locie. Oznacza to, e programista klasy Cat moe w przyszoci zmieni
projekt tej klasy bez wymagania od uytkowników klasy Cat zmiany ich programów.
Pytanie:Jeeliuyciefunkcjiconstdozmianyklasypowodujebdwtrakcie
kompilacji,todlaczegoniepowinienempoprostupozbysisówkluczowych
const,bymiepewno,etebdyniewystpi?
Odpowied: Jeeli funkcja skadowa nie powinna zmienia klasy, to uycie sowa
kluczowego const jest dobrym sposobem zagwarantowania, e kompilator
pomoe Ci w wykryciu popenionych bdów. Przykadowo, funkcja GetAge()
moe nie mie adnego powodu do zmiany klasy Cat, ale w implementacji moe
znajdowa si ponisza linia kodu:
if (itsAge = 100) cout << "Hej! Masz 100 lat\n";
Zdefiniowanie funkcji GetAge() jako const powoduje, e kompilator zgosi bd
w powyszej linii kodu. Celem programisty byo sprawdzenie, czy warto
zmiennej itsAge wynosi 100, ale ten kod przez pomyk przypisuje warto 100
zmiennej itsAge. Poniewa przypisanie powoduje zmian klasy — a zdefiniowano,
e ta metoda nie powinna modyfikowa klasy — kompilator wychwytuje bd.
Ten rodzaj bdu moe by trudny do wychwycenia poprzez samo przegldanie
kodu. Oko bardzo czsto widzi to, co chce zobaczy. Co waniejsze, moe wydawa
si, e program dziaa prawidowo, cho zmiennej itsAge przypisano niewaciw
warto. Wczeniej czy póniej to musi spowodowa problemy.
Pytanie:CzyistniejejakikolwiekpowóduywaniastrukturywprogramieC++?
Odpowied: Wielu programistów C++ rezerwuje sowo kluczowe struct dla
klas pozbawionych funkcji. To relikt starych struktur C, które nie miay funkcji.
Szczerze mówic, to mylca i kiepska praktyka programistyczna. Dzisiejsza
struktura pozbawiona metod jutro moe ich potrzebowa. Wówczas bdziesz
zmuszony albo do zmiany na typ class, albo do zamania reguy i umieszczenia
metod w strukturze. Jeeli musisz wywoa star funkcj jzyka C wymagajc
okrelonej struktury, jest to jedyny dobry powód jej uywania.
Warsztaty
343
Pytanie:Niektórzyprogramicipracujcyzprogramowaniemzorientowanym
obiektowouywajterminutworzenieegzemplarza.Cotooznacza?
Odpowied: Tworzenieegzemplarza to po prostu okrelenie procesu tworzenia
obiektu na podstawie klasy. Okrelony 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 take wiczenia pozwalajce na sprawdzenie
stopnia opanowania materiau. Spróbuj odpowiedzie na pytania i rozwiza quiz
przed sprawdzeniem odpowiedzi w dodatku D. Zanim przejdziesz do kolejnej
lekcji, upewnij si take, e rozumiesz odpowiedzi.
Quiz
1.
Co to jest operator kropki i do czego suy?
2.
Co powoduje zarezerwowanie pamici — deklaracja czy definicja?
3.
Czy deklaracja klasy jest jej interfejsem, czy implementacj?
4.
Jaka jest rónica midzy publicznymi i prywatnymi danymi skadowymi?
5.
Czy funkcja skadowa moe by prywatna?
6.
Czy dana skadowa moe by publiczna?
7.
Jeeli zadeklarujesz dwa obiekty Cat, to czy mog mie róne wartoci
w swoich elementach skadowych itsAge?
8.
Czy deklaracje klas s koczone rednikiem? A definicje metod klasy?
9.
Jaki bdzie nagówek funkcji Meow() klasy Cat, jeli nie pobiera ona
parametrów i zwraca void?
10.
Która funkcja jest wywoywana w celu inicjalizacji klasy?
wiczenia
1.
Napisz kod deklarujcy klas o nazwie Employee wraz z nastpujcymi
danymi skadowymi: itsAge, itsYearsOfService oraz itsSalary.
2.
Przepisz deklaracj klasy Employee w taki sposób, aby dane skadowe
byy prywatne. Zapewnij publiczne metody akcesorów pozwalajce na
pobieranie i ustawianie wartoci kadej danej skadowej.
344
Lekcja 10.
Klasy i obiekty
3.
Napisz program uywajcy klasy Employee, który tworzy dwóch
pracowników. Ustaw wartoci ich danych skadowych itsAge,
itsYearsOfService i itsSalary, a nastpnie wywietl je. Bdziesz
musia doda kod take w metodach akcesorów.
4.
Kontynuujc wiczenie 3., napisz kod dla metody klasy Employee, której
celem bdzie podanie zarobków kadego pracownika zaokrglonych
do najbliszego tysica.
5.
Zmie klas Employee w taki sposób, aby móg zainicjalizowa dane
skadowe itsAge, itsYearsOfService oraz itsSalary w trakcie tworzenia
pracownika.
6.
owcybdów: Co jest nie tak z ponisz deklaracj?
class Square
{
public:
int Side;
}
7.
owcybdów: Dlaczego ponisza deklaracja nie jest zbyt uyteczna?
class Cat
{
int GetAge() const;
private:
int itsAge;
};
8.
owcybdów: Wymie trzy bdy w poniszym 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);
}
Wyszukiwarka
Podobne podstrony:
PHP, MySQL i Apache dla kazdego Wydanie II
PHP, MySQL i Apache dla kazdego Wydanie II
C dla kazdego Wydanie II cppint
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP i MySQL Dla kazdego Wydanie II phmdk2
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
C dla kazdego Wydanie II cppint
C dla kazdego Wydanie II cppint
C dla kazdego Wydanie II
PHP MySQL i Apache dla kazdego Wydanie II
C dla kazdego Wydanie II cppint
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP, MySQL i Apache dla kazdego Wydanie II
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP MySQL i Apache dla kazdego Wydanie II 2
PHP, MySQL i Apache dla kazdego Wydanie II
więcej podobnych podstron