You are on page 1of 41

IDZ DO

PRZYKADOWY ROZDZIA
SPIS TRECI

KATALOG KSIEK
KATALOG ONLINE
ZAMW DRUKOWANY KATALOG

TWJ KOSZYK
DODAJ DO KOSZYKA

CENNIK I INFORMACJE
ZAMW INFORMACJE
O NOWOCIACH
ZAMW CENNIK

CZYTELNIA
FRAGMENTY KSIEK ONLINE

Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl

C++ dla kadego


Autor: Jesse Liberty
Tumaczenie: Marcin Pancewicz
ISBN: 83-7197-538-4
Tytu oryginau: Teach Yourself C++ in 21 Days.
Fourth Edition
Format: B5, stron: 712

Materia zawarty w tej ksice to podstawowe zagadnienia i koncepcje zwizane


z programowaniem w C++, tak wic nie musisz posiada adnego dowiadczenia
w programowaniu w tym jzyku. Liczne przykady skadni oraz szczegowa analiza
kodu stanowi doskonay przewodnik na pocztku podry, ktrej celem jest
opanowanie programowania w jzyku C++. Bez wzgldu na to, czy jeste
pocztkujcy, czy te posiadasz pewne dowiadczenie w programowaniu, przekonasz
si, e dziki przejrzystej organizacji tej ksiki nauka C++ bdzie szybka i atwa.
Ksika ta stanowi wprowadzenie do programowania w jzyku C++. Nie koncentruje
si na konkretnej implementacji, lecz raczej opisuje standard ANSI/ISO; znajdziesz
w niej rwnie omwienie biblioteki STL (Standard Template Library). Jeli nawet nie
masz dowiadczenia w pisaniu programw, to dziki tej ksice:
Bdziesz tworzy szybkie i wydajne programy w C++.
Zrozumiesz standard ANSI/ISO i skorzystasz z wprowadzonych w nim zmian.
Opanujesz zaawansowane programowanie z uyciem funkcji, tablic, zmiennych
i wskanikw.
Poznasz C++ oraz obiektowo zorientowane projektowanie, programowanie
i analiz.
Nauczysz si wzbogaca swoje programy za pomoc dziedziczenia
i polimorfizmu.
Bdziesz mg korzysta z dowolnego kompilatora zgodnego ze standardem
ANSI/ISO C++.

"
"
"
"
"
"

O Autorze ...........................................................................................................15
Wstp ................................................................................................................17

Cz I ..........................................................................................19
Rozdzia 1. Zaczynamy ......................................................................................21
Wprowadzenie...................................................................................................................21
Krtka historia jzyka C++ ...............................................................................................21
Rozwizywanie problemw........................................................................................22
Programowanie proceduralne, strukturalne i obiektowe ............................................23
C++ i programowanie zorientowane obiektowo.........................................................25
Jak ewoluowao C++.........................................................................................................26
Czy naley najpierw pozna C? ........................................................................................26
C++ a Java i C# .................................................................................................................27
Standard ANSI ..................................................................................................................27
Przygotowanie do programowania....................................................................................28
Twoje rodowisko programowania ...................................................................................28
Tworzenie programu .........................................................................................................29
Tworzenie pliku obiektowego za pomoc kompilatora ..............................................29
Tworzenie pliku wykonywalnego za pomoc linkera ................................................30
Cykl tworzenia programu..................................................................................................30
HELLO.cpp twj pierwszy program w C++................................................................32
Zaczynamy prac z kompilatorem ....................................................................................34
Budowanie projektu Hello World...............................................................................34
Bdy kompilacji ...............................................................................................................36

Rozdzia 2. Anatomia programu C++ ..................................................................37


Prosty program ..................................................................................................................37
Rzut oka na obiekt cout.....................................................................................................39
Uywanie przestrzeni nazw standardowych .....................................................................41
Komentarze .......................................................................................................................43
Rodzaje komentarzy....................................................................................................44
Uywanie komentarzy ................................................................................................44
Jeszcze jedna uwaga na temat komentarzy .................................................................45
Funkcje ..............................................................................................................................45
Korzystanie z funkcji ..................................................................................................46

C++ dla kadego

Rozdzia 3. Zmienne i stae................................................................................49


Czym jest zmienna? ..........................................................................................................49
Dane s przechowywane w pamici ...........................................................................49
Przydzielanie pamici .................................................................................................50
Rozmiar liczb cakowitych .........................................................................................51
Zapis ze znakiem i bez znaku .....................................................................................52
Podstawowe typy zmiennych......................................................................................53
Definiowanie zmiennej .....................................................................................................54
Uwzgldnianie wielkoci liter.....................................................................................55
Sowa kluczowe ..........................................................................................................56
Tworzenie kilku zmienych jednoczenie ..........................................................................56
Przypisywanie zmiennym wartoci...................................................................................56
typedef...............................................................................................................................58
Kiedy uywa typu short, a kiedy typu long? ...................................................................59
Zawinicie liczby cakowitej bez znaku .....................................................................60
Zawinicie liczby cakowitej ze znakiem ...................................................................61
Znaki..................................................................................................................................62
Znaki i liczby ..............................................................................................................62
Znaki specjalne ...........................................................................................................63
Stae...................................................................................................................................64
Literay........................................................................................................................64
Stae symboliczne .......................................................................................................64
Stae wyliczeniowe............................................................................................................66

Rozdzia 4. Wyraenia i instrukcje ......................................................................69


Instrukcje...........................................................................................................................69
Biae spacje .................................................................................................................70
Bloki i instrukcje zoone ...........................................................................................70
Wyraenia..........................................................................................................................70
Operatory...........................................................................................................................72
Operator przypisania ...................................................................................................72
Operatory matematyczne ............................................................................................73
Dzielenie cakowite i reszta z dzielenia ......................................................................73
czenie operatora przypisania z operatorem matematycznym .......................................74
Inkrementacja i dekrementacja..........................................................................................75
Przedrostki i przyrostki ...............................................................................................75
Kolejno dziaa ..............................................................................................................77
Zagniedanie nawiasw...................................................................................................78
Prawda i fasz ....................................................................................................................79
Operatory relacji .........................................................................................................79
Instrukcja if .......................................................................................................................80
Styl wci....................................................................................................................83
else ..............................................................................................................................84
Zaawansowane instrukcje if........................................................................................86
Uycie nawiasw klamrowych w zagniedonych instrukcjach if...................................87
Operatory logiczne ............................................................................................................89
Logiczne I ...................................................................................................................90
Logiczne LUB.............................................................................................................90
Logiczne NIE ..............................................................................................................90
Skrcone obliczanie wyrae logicznych .........................................................................91
Kolejno operatorw logicznych.....................................................................................91
Kilka sw na temat prawdy i faszu .................................................................................92
Operator warunkowy (trjelementowy) ............................................................................93

Spis treci

Rozdzia 5. Funkcje ...........................................................................................95


Czym jest funkcja? ............................................................................................................95
Zwracane wartoci, parametry i argumenty ......................................................................96
Deklarowanie i definiowanie funkcji ................................................................................97
Deklarowanie funkcji..................................................................................................97
Prototypy funkcji ........................................................................................................98
Definiowanie funkcji ..................................................................................................99
Wykonywanie funkcji .....................................................................................................100
Zmienne lokalne..............................................................................................................101
Zakres........................................................................................................................102
Zmienne globalne............................................................................................................102
Zmienne globalne: ostrzeenie........................................................................................104
Kilka sw na temat zmiennych lokalnych .....................................................................104
Instrukcje funkcji.............................................................................................................106
Kilka sw na temat argumentw funkcji .......................................................................106
Uycie funkcji jako parametrw funkcji...................................................................106
Parametry s zmiennymi lokalnymi................................................................................107
Kilka sw na temat zwracanych wartoci ......................................................................109
Parametry domylne........................................................................................................111
Przecianie funkcji ........................................................................................................113
Zagadnienia zwizane z funkcjami .................................................................................116
Funkcje typu inline ...................................................................................................116
Rekurencja ................................................................................................................118
Jak dziaaj funkcje rzut oka pod mask ................................................................123
Poziomy abstrakcji....................................................................................................123
Podzia pamici.........................................................................................................123
Stos i funkcje.............................................................................................................126

Rozdzia 6. Programowanie zorientowane obiektowo.........................................129


Czy C++ jest zorientowane obiektowo? .........................................................................129
Tworzenie nowych typw ...............................................................................................130
Po co tworzy nowy typ?..........................................................................................131
Klasy i skadowe .............................................................................................................131
Deklarowanie klasy...................................................................................................132
Kilka sw o konwencji nazw ...................................................................................132
Definiowanie obiektu................................................................................................133
Klasy a obiekty .........................................................................................................133
Dostp do skadowych klasy ...........................................................................................134
Przypisywa naley obiektom, nie klasom ...............................................................134
Czego nie zadeklarujesz, tego klasa nie bdzie miaa ..............................................134
Prywatne i publiczne .......................................................................................................135
Oznaczanie danych skadowych jako prywatnych ...................................................137
Prywatno a ochrona ...............................................................................................138
Implementowanie metod klasy........................................................................................140
Konstruktory i destruktory ..............................................................................................142
Domylne konstruktory i destruktory .......................................................................143
Uycie domylnego konstruktora .............................................................................143
Funkcje skadowe const ..................................................................................................146
Interfejs a implementacja ................................................................................................147
Gdzie umieszcza deklaracje klasy i definicje metod.....................................................150
Implementacja inline .......................................................................................................151
Klasy, ktrych danymi skadowymi s inne klasy ..........................................................153
Struktury..........................................................................................................................157
Dlaczego dwa sowa kluczowe speniaj t sam funkcj........................................157

C++ dla kadego

Rozdzia 7. Sterowanie przebiegiem dziaania programu ....................................159


Ptle.................................................................................................................................159
Pocztki ptli: instrukcja goto...................................................................................159
Dlaczego nie jest zalecane stosowanie instrukcji goto?............................................160
Ptle while .......................................................................................................................160
Bardziej skomplikowane instrukcje while ................................................................162
continue oraz break ...................................................................................................163
Ptla while (true).......................................................................................................166
Ptla do...while ................................................................................................................167
do...while .........................................................................................................................168
Ptle for ...........................................................................................................................170
Zaawansowane ptle for ...........................................................................................171
Puste ptle for ...........................................................................................................174
Ptle zagniedone....................................................................................................175
Zakres zmiennych w ptlach for ...............................................................................177
Podsumowanie ptli ........................................................................................................178
Instrukcja switch .............................................................................................................180
Uycie instrukcji switch w menu..............................................................................182
Program podsumowujcy wiadomoci............................................................................186

Cz II .......................................................................................191
Rozdzia 8. Wskaniki ......................................................................................193
Czym jest wskanik?.......................................................................................................193
Kilka sw na temat pamici.....................................................................................193
Uycie operatora adresu (&) .....................................................................................194
Przechowywanie adresu we wskaniku ....................................................................195
Puste i bdne wskaniki...........................................................................................195
Nazwy wskanikw ..................................................................................................196
Operator wyuskania .................................................................................................197
Wskaniki, adresy i zmienne ....................................................................................197
Operowanie danymi poprzez wskaniki ...................................................................199
Sprawdzanie adresu ..................................................................................................200
Do czego su wskaniki? .............................................................................................202
Stos i sterta ......................................................................................................................203
Operator new.............................................................................................................204
delete .........................................................................................................................204
Wycieki pamici..............................................................................................................206
Tworzenie obiektw na stercie........................................................................................207
Usuwanie obiektw .........................................................................................................207
Dostp do skadowych klasy ...........................................................................................208
Dane skadowe na stercie ................................................................................................210
Wskanik this ..................................................................................................................212
Utracone wskaniki .........................................................................................................214
Wskaniki const ..............................................................................................................217
Wskaniki const i funkcje skadowe const ...............................................................218
Wskaniki const this .................................................................................................219
Dziaania arytmetyczne na wskanikach temat dla zaawansowanych.......................220

Rozdzia 9. Referencje .....................................................................................223


Czym jest referencja? ......................................................................................................223
Uycie operatora adresu z referencj ..............................................................................225
Nie mona zmienia przypisania referencji ..............................................................226

Spis treci

5
Do czego mog odnosi si referencje? ..........................................................................227
Zerowe wskaniki i zerowe referencje............................................................................229
Przekazywanie argumentw funkcji przez referencj.....................................................229
Tworzenie funkcji swap() otrzymujcej wskaniki ..................................................231
Implementacja funkcji swap() za pomoc referencji ................................................233
Nagwki i prototypy funkcji ..........................................................................................234
Zwracanie kilku wartoci ................................................................................................235
Zwracanie wartoci przez referencj ........................................................................237
Przekazywanie przez referencj zwiksza efektywno dziaania programu .................238
Przekazywanie wskanika const ...............................................................................241
Referencje jako metoda alternatywna .......................................................................243
Kiedy uywa wskanikw, a kiedy referencji...............................................................245
czenie referencji i wskanikw ...................................................................................246
Nie pozwl funkcji zwraca referencji do obiektu, ktrego nie ma w zakresie! ............247
Zwracanie referencji do obiektu na stercie .....................................................................249
Wskanik, wskanik, kto ma wskanik?.........................................................................251

Rozdzia 10. Funkcje zaawansowane ..................................................................253


Przecione funkcje skadowe ........................................................................................253
Uycie wartoci domylnych ..........................................................................................255
Wybr pomidzy wartociami domylnymi a przecianiem funkcji ............................257
Konstruktor domylny.....................................................................................................258
Przecianie konstruktorw ............................................................................................258
Inicjalizowanie obiektw ................................................................................................260
Konstruktor kopiujcy.....................................................................................................261
Przecianie operatorw .................................................................................................265
Pisanie funkcji inkrementacji....................................................................................266
Przecianie operatora przedrostkowego..................................................................267
Zwracanie typw w przecionych funkcjach operatorw.......................................268
Zwracanie obiektw tymczasowych bez nadawania im nazw..................................270
Uycie wskanika this...............................................................................................271
Dlaczego staa referencja? ........................................................................................273
Przecianie operatora przyrostkowego ...................................................................273
Rnica pomidzy przedrostkiem a przyrostkiem ....................................................273
Operator dodawania ..................................................................................................275
Przecianie operatora dodawania ............................................................................277
Zagadnienia zwizane z przecianiem operatorw.................................................278
Ograniczenia w przecianiu operatorw .................................................................278
Co przecia? ..........................................................................................................279
Operator przypisania .................................................................................................279
Obsuga konwersji typw danych ...................................................................................282
Operatory konwersji..................................................................................................285

Rozdzia 11. Analiza i projektowanie zorientowane obiektowo .............................287


Budowanie modeli...........................................................................................................287
Projektowanie oprogramowania: jzyk modelowania ....................................................288
Projektowanie oprogramowania: proces .........................................................................289
Programowanie ekstremalne ...........................................................................................292
Pomys.............................................................................................................................292
Analiza wymaga............................................................................................................293
Przypadki uycia .......................................................................................................293
Analiza aplikacji .......................................................................................................303
Analiza systemw .....................................................................................................304

C++ dla kadego


Tworzenie dokumentacji...........................................................................................304
Wizualizacje..............................................................................................................305
Dokumentacja produktu............................................................................................305
Projektowanie..................................................................................................................306
Czym s klasy? .........................................................................................................306
Przeksztacenia..........................................................................................................308
Model statyczny ........................................................................................................309
Model dynamiczny....................................................................................................318

Rozdzia 12. Dziedziczenie .................................................................................321


Czym jest dziedziczenie? ................................................................................................321
Dziedziczenie i wyprowadzanie ...............................................................................322
Krlestwo zwierzt ...................................................................................................323
Skadnia wyprowadzania ..........................................................................................323
Prywatne kontra chronione..............................................................................................325
Konstruktory i destruktory ..............................................................................................327
Przekazywanie argumentw do konstruktorw bazowych.......................................329
Przesanianie funkcji .......................................................................................................333
Ukrywanie metod klasy bazowej ..............................................................................335
Wywoywanie metod klasy bazowej ........................................................................337
Metody wirtualne ............................................................................................................338
Jak dziaaj funkcje wirtualne...................................................................................342
Nie moesz przej std dotd ..................................................................................343
Okrajanie...................................................................................................................344
Destruktory wirtualne ...............................................................................................346
Wirtualne konstruktory kopiujce.............................................................................346
Koszt metod wirtualnych ..........................................................................................349

Rozdzia 13. Tablice i listy poczone .................................................................351


Czym jest tablica? ...........................................................................................................351
Elementy tablicy..............................................................................................................352
Zapisywanie za kocem tablicy ......................................................................................353
Bd supka w pocie .......................................................................................................356
Inicjalizowanie tablic ......................................................................................................356
Deklarowanie tablic.........................................................................................................357
Tablice obiektw .............................................................................................................358
Tablice wielowymiarowe ................................................................................................360
Inicjalizowanie tablic wielowymiarowych......................................................................360
Kilka sw na temat pamici ...........................................................................................362
Tablice wskanikw........................................................................................................363
Deklarowane tablic na stercie .........................................................................................364
Wskanik do tablicy a tablica wskanikw.....................................................................365
Wskaniki a nazwy tablic................................................................................................365
Usuwanie tablic ze sterty.................................................................................................367
Tablice znakw ...............................................................................................................368
strcpy() oraz strncpy() .....................................................................................................370
Klasy acuchw .............................................................................................................371
Listy poczone i inne struktury ......................................................................................378
Analiza listy poczonej ..................................................................................................378
Przeniesienie odpowiedzialnoci ..............................................................................379
Czci skadowe ..............................................................................................................379
Czego si nauczya, Dorotko? .......................................................................................388
Klasy tablic......................................................................................................................388

Spis treci

Rozdzia 14. Polimorfizm....................................................................................391


Problemy z pojedynczym dziedziczeniem ......................................................................391
Przenoszenie w gr .................................................................................................394
Rzutowanie w d .....................................................................................................394
Poczenie dwch list................................................................................................397
Dziedziczenie wielokrotne ..............................................................................................397
Czci obiektu z dziedziczeniem wielokrotnym.......................................................400
Konstruktory w obiektach dziedziczonych wielokrotnie..........................................401
Eliminowanie niejednoznacznoci............................................................................403
Dziedziczenie ze wsplnej klasy bazowej ................................................................404
Dziedziczenie wirtualne............................................................................................408
Problemy z dziedziczeniem wielokrotnym ...............................................................411
Mixiny i klasy metod ................................................................................................412
Abstrakcyjne typy danych...............................................................................................413
Czyste funkcje wirtualne...........................................................................................416
Implementowanie czystych funkcji wirtualnych ......................................................417
Zoone hierarchie abstrakcji ....................................................................................420
Ktre typy s abstrakcyjne? ......................................................................................424
Program podsumowujcy wiadomoci............................................................................425

Cz III ......................................................................................435
Rozdzia 15. Specjalne klasy i funkcje................................................................437
Statyczne dane skadowe.................................................................................................437
Statyczne funkcje skadowe ............................................................................................442
Wskaniki do funkcji ......................................................................................................444
Dlaczego warto uywa wskanikw do funkcji? ....................................................447
Tablice wskanikw do funkcji ................................................................................450
Przekazywanie wskanikw do funkcji innym funkcjom ........................................452
Uycie instrukcji typedef ze wskanikami do funkcji ..............................................455
Wskaniki do funkcji skadowych ..................................................................................457
Tablice wskanikw do funkcji skadowych ............................................................459

Rozdzia 16. Dziedziczenie zaawansowane..........................................................463


Zawieranie.......................................................................................................................463
Dostp do skadowych klasy zawieranej ..................................................................469
Filtrowany dostp do skadowych zawieranych .......................................................469
Koszt zawierania .......................................................................................................470
Kopiowanie przez warto........................................................................................473
Implementowanie poprzez dziedziczenie i zawieranie oraz poprzez delegacj .............476
Delegacja...................................................................................................................477
Dziedziczenie prywatne ..................................................................................................485
Klasy zaprzyjanione ......................................................................................................493
Funkcje zaprzyjanione...................................................................................................501
Funkcje zaprzyjanione i przecianie operatorw ........................................................501
Przecianie operatora wstawiania..................................................................................505

Rozdzia 17. Strumienie .....................................................................................511


Przegld strumieni...........................................................................................................511
Kapsukowanie..........................................................................................................512
Buforowanie..............................................................................................................512
Strumienie i bufory..........................................................................................................514
Standardowe obiekty wejcia-wyjcia ............................................................................514

C++ dla kadego


Przekierowywanie ...........................................................................................................515
Wejcie z uyciem cin.....................................................................................................516
acuchy...................................................................................................................517
Problemy z acuchami.............................................................................................517
Zwracanie referencji do obiektu istream przez operator>> ......................................520
Inne funkcje skadowe w dyspozycji cin.........................................................................520
Wprowadzanie pojedynczych znakw......................................................................521
Odczytywanie acuchw z wejcia standardowego ................................................523
Uycie cin.ignore() ...................................................................................................526
peek() oraz putback() ................................................................................................527
Wyjcie poprzez cout ......................................................................................................528
Zrzucanie zawartoci bufora .....................................................................................528
Powizane funkcje...........................................................................................................528
Manipulatory, znaczniki oraz instrukcje formatowania..................................................530
Uycie cout.width()...................................................................................................530
Ustawianie znakw wypenienia...............................................................................531
Funkcja setf() ............................................................................................................532
Strumienie kontra funkcja printf()...................................................................................534
Wejcie i wyjcie z uyciem plikw ...............................................................................537
ofstream...........................................................................................................................538
Stany strumieni .........................................................................................................538
Otwieranie plikw dla wejcia i wyjcia ..................................................................538
Zmiana domylnego zachowania obiektu ofstream w trakcie otwierania pliku .......540
Pliki binarne a pliki tekstowe ..........................................................................................542
Przetwarzanie linii polecenia ..........................................................................................544

Rozdzia 18. Przestrzenie nazw ..........................................................................549


Zaczynamy ......................................................................................................................549
Funkcje i klasy s rozpoznawane poprzez nazwy...........................................................550
Tworzenie przestrzeni nazw............................................................................................553
Deklarowanie i definiowanie typw .........................................................................554
Definiowanie funkcji poza przestrzeni nazw ..........................................................554
Dodawanie nowych skadowych...............................................................................555
Zagniedanie przestrzeni nazw ...............................................................................555
Uywanie przestrzeni nazw.............................................................................................556
Sowo kluczowe using.....................................................................................................558
Dyrektywa using .......................................................................................................558
Deklaracja using........................................................................................................559
Alias przestrzeni nazw ....................................................................................................561
Nienazwana przestrze nazw ..........................................................................................561
Standardowa przestrze nazw std ...................................................................................562

Rozdzia 19. Wzorce ..........................................................................................565


Czym s wzorce?.............................................................................................................565
Typy parametryzowane ...................................................................................................566
Tworzenie egzemplarza wzorca................................................................................566
Definicja wzorca .............................................................................................................566
Uycie nazwy............................................................................................................568
Implementowanie wzorca .........................................................................................568
Funkcje wzorcowe...........................................................................................................571
Wzorce i przyjaciele........................................................................................................572
Niewzorcowe zaprzyjanione klasy i funkcje...........................................................572
Oglne wzorcowe zaprzyjanione klasy i funkcje....................................................575

Spis treci

9
Uycie elementw wzorca ..............................................................................................579
Funkcje specjalizowane ............................................................................................582
Wzorce i skadowe statyczne ....................................................................................588
Standardowa biblioteka wzorcw ...................................................................................591
Kontenery ........................................................................................................................591
Kontenery sekwencyjne ..................................................................................................592
Kontener vector.........................................................................................................592
Kontener list..............................................................................................................598
Kontener deque .........................................................................................................599
Stosy ................................................................................................................................600
Kolejki.............................................................................................................................601
Kontenery asocjacyjne ....................................................................................................601
Kontener map............................................................................................................601
Inne kontenery asocjacyjne.......................................................................................604
Klasy algorytmw ...........................................................................................................604
Bezmutacyjne operacje sekwencyjne .......................................................................605
Mutacyjne algorytmy sekwencyjne ..........................................................................606

Rozdzia 20. Wyjtki i obsuga bdw................................................................609


Pluskwy, bdy, pomyki i psujcy si kod..................................................................609
Wyjtki......................................................................................................................610
Wyjtki ............................................................................................................................611
Jak uywane s wyjtki.............................................................................................611
Uycie blokw try oraz blokw catch.............................................................................616
Wychwytywanie wyjtkw.......................................................................................616
Wychwytywanie wicej ni jednego rodzaju wyjtkw...........................................617
Hierarchie wyjtkw .................................................................................................620
Dane w wyjtkach oraz nazwane obiekty wyjtkw ......................................................622
Wyjtki i wzorce .............................................................................................................629
Wyjtki bez bdw.........................................................................................................631
Kilka sw na temat psujcego si kodu......................................................................632
Pluskwy i odpluskwianie.................................................................................................633
Punkty wstrzymania..................................................................................................633
ledzenie wartoci zmiennych..................................................................................633
Sprawdzanie pamici ................................................................................................634
Asembler ...................................................................................................................634

Rozdzia 21. Co dalej.........................................................................................635


Preprocesor i kompilator .................................................................................................635
Przegldanie formy poredniej........................................................................................636
Uycie dyrektywy #define ..............................................................................................636
Uycie #define dla staych ........................................................................................636
Uycie #define do definiowania symboli .................................................................636
Dyrektywa #else preprocesora..................................................................................637
Doczanie i wartowniki doczania ...............................................................................638
Funkcje makro.................................................................................................................640
Po co te wszystkie nawiasy? .....................................................................................641
Makra a funkcje i wzorce..........................................................................................642
Funkcje inline..................................................................................................................642
Manipulacje acuchami .................................................................................................644
Zamiana w acuch ...................................................................................................644
Konkatenacja.............................................................................................................644
Makra predefiniowane.....................................................................................................645

10

C++ dla kadego


Makro assert() .................................................................................................................645
Debuggowanie za pomoc makra assert() ................................................................647
Makro assert() a wyjtki ...........................................................................................647
Efekty uboczne..........................................................................................................648
Niezmienniki klas .....................................................................................................648
Wypisywanie wartoci tymczasowych .....................................................................653
Poziomy debuggowania ............................................................................................654
Operacje na bitach...........................................................................................................660
Operator AND...........................................................................................................661
Operator OR..............................................................................................................661
Operator XOR...........................................................................................................661
Operator negacji........................................................................................................661
Ustawianie bitw ......................................................................................................661
Zerowanie bitw .......................................................................................................662
Zmiana stanu bitw na przeciwny ............................................................................662
Pola bitowe................................................................................................................663
Styl ..................................................................................................................................666
Wcicia .....................................................................................................................666
Nawiasy klamrowe....................................................................................................666
Dugo linii..............................................................................................................666
Instrukcje switch .......................................................................................................667
Tekst programu .........................................................................................................667
Nazwy identyfikatorw.............................................................................................668
Komentarze ...............................................................................................................669
Dostp .......................................................................................................................670
Definicje klas ............................................................................................................670
Doczanie plikw ....................................................................................................670
assert().......................................................................................................................671
const ..........................................................................................................................671
Nastpne kroki.................................................................................................................671
Gdzie uzyska pomoc i porad .................................................................................671
Przej do C#?...........................................................................................................672
Bd w kontakcie ......................................................................................................672
Program podsumowujcy wiadomoci............................................................................672

Dodatki .......................................................................................683
Dodatek A Dwjkowo i szesnastkowo..............................................................685
Inne podstawy .................................................................................................................686
Wok podstaw................................................................................................................686
Dwjkowo.................................................................................................................688
Dlaczego podstawa 2?...............................................................................................689
Bity, bajty, nible........................................................................................................689
Co to jest KB?...........................................................................................................690
Liczby dwjkowe......................................................................................................690
Szesnastkowo ..................................................................................................................691

Dodatek B Sowa kluczowe C++ ......................................................................695


Dodatek C Kolejno operatorw.....................................................................697
Skorowidz.........................................................................................................699

Rozdzia 6.

Klasy rozszerzaj wbudowane w C++ moliwoci, uatwiajce rozwizywanie zoonych, rzeczywistych problemw.
Z tego rozdziau dowiesz si:
czym s klasy i obiekty,
jak definiowa now klas oraz tworzy obiekty tej klasy,
czym s funkcje i dane skadowe,
czym s konstruktory i jak z nich korzysta.

Czy C++ jest zorientowane obiektowo?


Jzyk C++ stanowi pomost pomidzy programowaniem zorientowanym obiektowo
a jzykiem C, najpopularniejszym jzykiem programowania aplikacji komercyjnych.
Celem jego autorw byo stworzenie obiektowo zorientowanego jzyka dla tej szybkiej i efektywnej platformy.
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 ktrym poszczeglne zagadnienia s dzielone na mniejsze jednostki powtarzalnych dziaa,
zwanych funkcjami.
Programy, ktre piszemy na pocztku dwudziestego pierwszego wieku, s duo bardziej zoone ni te, ktre byy pisane pod koniec wieku dwudziestego. Programy
stworzone w jzykach proceduralnych s trudne w zarzdzaniu i konserwacji, a ich

130

Cz I

rozbudowa jest niemoliwa. Graficzne interfejsy uytkownika, Internet, telefonia cyfrowa i bezprzewodowa oraz wiele innych technologii, znacznie zwikszyy poziom
skomplikowania nowych projektw, a wymagania konsumentw dotyczce jakoci
interfejsu uytkownika wzrosy.
W obliczu rosncych wymaga, programici bacznie przyjrzeli si przemysowi informatycznemu. Wnioski, do jakich doszli, byy co najmniej przygnbiajce. Oprogramowanie powstawao z opnieniem, posiadao bdy, dziaao niestabilnie i byo
drogie. Projekty regularnie przekraczay budet i trafiay na rynek z opnieniem.
Koszt obsugi tych projektw by znaczny, zmarnowano ogromne iloci pienidzy.
Jedynym wyjciem z tej sytuacji okazao si tworzenie oprogramowania zorientowanego obiektowo. Jzyki programowania obiektowego stworzyy silne wizy pomidzy
strukturami danych a metodami manipulowania tymi danymi. A co najwaniejsze,
w programowaniu zorientowanym obiektowo nie ju musisz myle o strukturach danych i manipulujcych nimi funkcjami; mylisz o obiektach. Rzeczach.
wiat jest wypeniony przedmiotami: samochodami, psami, drzewami, chmurami,
kwiatami. Rzeczy. Kada rzecz ma charakterystyk (szybki, przyjazny, brzowy, puszysty, adny). Wikszo rzeczy cechuje jakie zachowanie (ruch, szczekanie,
wzrost, deszcz, uwid). Nie mylimy o danych psa i o tym, jak moglibymy nimi manipulowa mylimy o psie jako o rzeczy: do czego jest podobny i co robi.

Tworzenie nowych typw


Poznae ju kilka typw zmiennych, m.in. liczby cakowite i znaki. Typ zmiennej
dostarcza nam kilka informacji o niej. Na przykad, jeli zadeklarujesz zmienne 
 (wysoko) i   (szeroko) jako liczby cakowite typu
    ,
wiesz, e w kadej z nich moesz przechowa warto z przedziau od 0 do 65 535
(przy zaoeniu e typ
     zajmuje dwa bajty pamici). S to liczby
cakowite bez znaku; prba przechowania w nich czegokolwiek innego powoduje
bd. W zmiennej typu
   nie moesz umieci swojego imienia, nie
powiniene nawet prbowa.
Deklarujc te zmienne jako
    , wiesz, e moesz doda do siebie
wysoko i szeroko oraz przypisa t warto innej zmiennej.
Typ zmiennych informuje:
o ich rozmiarze w pamici,
jaki rodzaj informacji mog zawiera,
jakie dziaania mona na nich wykonywa.

Rozdzia 6. Programowanie zorientowane obiektowo

131

W tradycyjnych jzykach, takich jak C, typy byy wbudowane w jzyk. W C++ programista moe rozszerzy jzyk, tworzc potrzebne mu typy, za kady z tych nowych
typw moe by w peni funkcjonalny i dysponowa t sam si, co typy wbudowane.

Po co tworzy nowy typ?


Programy s zwykle pisane w celu rozwizania jakiego realnego problemu, takiego
jak prowadzenie rejestru pracownikw czy symulacja dziaania systemu grzewczego.
Cho istnieje moliwo rozwizywania tych problemw za pomoc programw napisanych wycznie przy uyciu liczb cakowitych i znakw, jednak w przypadku
wikszych, bardziej rozbudowanych problemw, duo atwiej jest stworzy reprezentacje obiektw, o ktrych si mwi. 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.

Klasy i skadowe
Nowy typ zmiennych tworzy si, deklarujc klas. Klasa jest waciwie grup zmiennych czsto o rnych typach skojarzonych z zestawem odnoszcych si do
nich funkcji.
Jedn z moliwoci mylenia o samochodzie jest potraktowanie go jako zbioru k,
drzwi, foteli, okien itd. Inna moliwo to wyobraenie sobie, co samochd moe
zrobi: jedzi, przyspiesza, zwalnia, zatrzymywa si, parkowa itd. Klasa umoliwia kapsukowanie, czyli upakowanie, tych rnych czci oraz rnych dziaa
w jeden zbir, ktry jest nazywana obiektem.
Upakowanie wszystkiego, co wiesz o samochodzie, w jedn klas przynosi programicie liczne korzyci. Wszystko jest na miejscu, uatwia to odwoywanie si, kopiowanie i manipulowanie danymi. Klienty twojej klasy tj. te czci programu, ktre
z niej korzystaj mog uywa twojego obiektu bez zastanawiania si, co znajduje
si w rodku i jak on dziaa.
Klasa moe skada si z dowolnej kombinacji zmiennych prostych oraz zmiennych
innych klas. Zmienna wewntrz klasy jest nazywana zmienn skadow lub dan
skadow. Klasa  (samochd) moe posiada skadowe reprezentujce siedzenia,
typ radia, opony itd.
Zmienne skadowe s zmiennymi w danej klasie. Stanowi one cz klasy, tak jak
koa i silnik stanowi cz samochodu.
Funkcje w danej klasie zwykle manipuluj zmiennymi skadowymi. Funkcje klasy
nazywa si funkcjami skadowymi lub metodami klasy. Metodami klasy  mog

132

Cz I

by  (uruchom) oraz  (hamuj). Klasa  (kot) moe posiada zmienne
skadowe, reprezentujce wiek i wag; jej metodami mog by  (pij), 
(miaucz) czy   (ap myszy).
Funkcje skadowe (metody) s funkcjami w klasie. Podobnie jak zmienne skadowe,
stanowi cz klasy i okrelaj, co dana klasa moe zrobi.

Deklarowanie klasy
Aby zadeklarowa klas, uyj sowa kluczowego  , po ktrym nastpuje otwierajcy nawias klamrowy, a nastpnie lista danych skadowych i metod tej klasy. Deklaracja koczy si zamykajcym nawiasem klamrowym i rednikiem. Oto deklaracja
klasy o nazwie  (kot):





  



  
  


Zadeklarowanie takiej klasy nie powoduje zaalokowania pamici dla obiektu . Informuje jedynie kompilator, czym jest typ , jakie dane zawiera (  jego wiek
oraz   jego waga) oraz co moe robi ( miaucz). Informuje take kompilator, jak dua jest zmienna typu  to jest, jak duo miejsca w pamici
ma przygotowa w przypadku tworzenia zmiennej typu . W tym przykadzie, o ile
typ   ma cztery bajty, zmienna typu  zajmuje osiem bajtw: cztery bajty dla
zmiennej   i cztery dla zmiennej  . Funkcja  nie zajmuje miejsca, gdy dla funkcji skadowych (metod) miejsce nie jest rezerwowane.

Kilka sw o konwencji nazw


Jako programista, musisz nazwa wszystkie swoje zmienne skadowe, funkcje skadowe oraz klasy. Jak przeczytae w rozdziale 3., Stae i zmienne, nazwy te powinny by zrozumiae i znaczce. Dobrymi nazwami klas mog by wspomniana ,
  (prostokt) czy   (pracownik). ,   czy   
(zatrzymaj silnik) rwnie s dobrymi nazwami funkcji, gdy informuj, co robi te
funkcje. Wielu programistw nadaje nazwom zmiennych skadowych przedrostek its
(jego), tak jak w zmiennych  ,   czy   (jego szybko). Pomaga
to w odrnieniu zmiennych skadowych od innych zmiennych.
Niektrzy programici wol przedrostek my (mj), tak jak w nazwach  ,  
 czy   . Jeszcze inni uywaj po prostu litery  (od sowa member skadowa), czasem wraz ze znakiem podkrelenia (!):  i !,  i !
czy  i !  .

Rozdzia 6. Programowanie zorientowane obiektowo

133

Jzyk C++ uwzgldnia wielko liter, dlatego wszystkie nazwy klas powinny przestrzega tej samej konwencji. Dziki temu nigdy nie bdziesz musia sprawdza pisowni nazwy klasy (czy to byo  ,   czy "#$%?).
Niektrzy programici lubi poprzedzi kad nazw klasy okrelon liter na
przykad  czy &  podczas, gdy inni uywaj wycznie duych lub maych liter. Ja sam korzystam z konwencji, w ktrej wszystkie nazwy klas rozpoczynaj si od duej litery, tak jak  czy &  (osoba).
Wielu programistw rozpoczyna wszystkie nazwy funkcji od duej litery, za wszystkie nazwy zmiennych od maej. Sowa zwykle rozdzielane s znakiem podkrelenia tak jak w  ! lub poprzez zastosowanie duej litery dla kadego
sowa na przykad   czy ' (rysuj okrg).
Wane jest, by wybra okrelony styl i trzyma si go w kadym programie. Z czasem rozwiniesz swj styl nie tylko na konwencje nazw, ale take na wcicia, wyrwnanie nawiasw klamrowych oraz styl komentarzy.
W firmach programistycznych powszechne jest okrelenie standardu wielu
elementw stylu zapisu kodu rdowego. Sprawia on, e wszyscy programici
mog atwo odczytywa wzajemnie swj kod.

Definiowanie obiektu
Definiowanie obiektu nowego typu przypomina definiowanie zmiennej cakowitej:



  


!" 



  # 


!" 

Ten kod definiuje zmienn o nazwie $  (czna waga), ktrej typem jest

   . Oprcz tego definiuje zmienn o nazwie 
(, ktra jest obiektem
klasy (typu) .

Klasy a obiekty
Nigdy nie karmi si definicji kota, lecz konkretnego kota. Naley dokona rozrnienia pomidzy ide kota a konkretnym kotem, ktry wanie ociera si o twoje nogi.
C++ rwnie dokonuje rozrnienia pomidzy klas , bdc ide kota, a poszczeglnymi obiektami typu . Tak wic 
( jest obiektem typu , tak jak
$  jest zmienn typu
   .
Obiekt jest indywidualnym egzemplarzem klasy.

134

Cz I

Dostp do skadowych klasy


Gdy zdefiniujesz ju faktyczny obiekt  na przykad 
( w celu uzyskania dostpu do jego skadowych moesz uy operatora kropki ()). Aby zmiennej
skadowej   obiektu 
( przypisa warto *+, powiniene napisa:
  #$  %&'

Aby wywoa funkcj , moesz napisa:


  #$ 

Gdy uywasz metody klasy, oznacza to, e wywoujesz t metod. W tym przykadzie
wywoae metod  obiektu 
(.

Przypisywa naley obiektom, nie klasom


W C++ nie przypisuje si wartoci typom; przypisuje si je zmiennym. Na przykad,
nie mona napisa:

%&(

Kompilator uzna to za bd, gdy nie mona przypisa wartoci pi typowi cakowitemu. Zamiast tego musisz zdefiniowa zmienn typu cakowitego i przypisa jej
warto *. Na przykad:

) 


!" 

)%& 
* 

)
&

Jest to skrcony zapis stwierdzenia: Przypisz warto * zmiennej ,, ktra jest zmienn typu  . Nie mona rwnie napisa:
$  %&(

Kompilator uzna to za bd, gdy nie moesz przypisa wartoci * do elementu  
klasy . Zamiast tego musisz zdefiniowa egzemplarz obiektu klasy  i dopiero
wtedy przypisa warto jego skadowej. Na przykad:
  #"+
#
)
  #$  %&"+
#)%&

Czego nie zadeklarujesz, tego klasa nie b"dzie miaa


Przeprowad taki eksperyment: podejd do trzylatka i poka mu kota. Nastpnie powiedz: To jest Mruczek. Mruczek zna sztuczk. Mruczek, zaszczekaj! Dziecko rozemieje si i powie: Nie, guptasie, koty nie szczekaj!.
Jeli napisae:
  #!+ #
   #
  #$,#
#   #  #-

Rozdzia 6. Programowanie zorientowane obiektowo

135

Kompilator wypisze: Nie, guptasie, koty (cats) nie szczekaj! (By moe w twoim
kompilatorze ten komunikat bdzie brzmia nieco inaczej.). Kompilator wie, e Mruczek nie moe szczeka, gdy klasa  nie posiada metody  (szczekaj). Kompilator nie pozwoli Mruczkowi nawet zamiaucze, jeli nie zdefiniujesz dla niego
funkcji  (miaucz).
TAK

NIE

Do deklarowania klasy uywaj sowa


kluczowego .

Nie myl deklaracji z definicj. Deklaracja mwi


czym jest klasa, a definicja przygotowuje pami
dla obiektu.

W celu uzyskania dostpu do zmiennych


i funkcji skadowych klasy uywaj operatora
kropki ()).

Nie myl klasy z obiektem.


Nie przypisuj klasie wartoci. Wartoci przypisuj
danym skadowym obiektu.

Prywatne i publiczne
W deklaracji klasy uywanych jest take kilka innych sw kluczowych. Dwa najwaniejsze z nich to: 
- (publiczny) i . (prywatny).
Wszystkie skadowe klasy dane i metody s domylnie prywatne. Prywatne skadowe mog by uywane tylko przez metody nalece do danej klasy. Skadowe publiczne s dostpne dla innych funkcji i klas. To rozrnienie jest wane, cho na pocztku moe sprawia kopot. Aby to lepiej wyjani, spjrzmy na poprzedni przykad:





  



  
  


W tej deklaracji, skadowe  ,   oraz  s prywatne, gdy wszystkie skadowe klasy s prywatne domylnie. Oznacza to, e dopki nie postanowisz
inaczej, pozostan one prywatne.
Jeli jednak w funkcji   napiszesz na przykad:
,+
,+$  %&+./0
 1
 1!-"!
!
!0

kompilator uzna to za bd. We wczeniejszej deklaracji powiedziae kompilatorowi,


e skadowych  ,   oraz  bdziesz uywa tylko w funkcjach
skadowych klasy . W powyszym fragmencie kodu prbujesz odwoa si do
zmiennej skadowej obiektu - spoza metody klasy . To, e - jest obiektem
klasy , nie oznacza, e moesz korzysta z tych elementw obiektu - , ktre s
prywatne.

136

Cz I

Wanie to jest rdem niekoczcych si kopotw pocztkujcych programistw


C++. Ju sysz, jak narzekasz: Hej! Wanie napisaem, e Bobas jest kotem, tj.
obiektem klasy . Dlaczego - nie ma dostpu do swojego wasnego wieku?.
Odpowied brzmi: - ma dostp, ale ty nie masz. - , w swoich wasnych metodach, ma dostp do wszystkich swoich skadowych, zarwno publicznych, jak
i prywatnych. Nawet, jeli to ty tworzysz obiekt klasy , nie moesz przeglda ani
zmienia tych jego skadowych, ktre s prywatne.
Aby mie dostp do skadowych obiektu , powiniene napisa:


" + 2



  



  
  


Teraz skadowe  ,   oraz  s publiczne. - )  / *0 kompiluje si bez problemw.
Listing 6.1 przedstawia deklaracj klasy  z publicznymi zmiennymi skadowymi.
Listing 6.1. Dostp do publicznych skadowych w prostej klasie
'23 
   # #!
42 
 + #  #!$
52
627
  8   9
:2
&2 #  #;#
<2
=2" + 2
;" / "! #. /" + 

>2
  

#.
?2
  

#.
4'2@-  ;
* 
#
442
452
462
 

4:2
4&2  #
4<2  #$  %&"!" 


#. 
4=222 88A  # #   A
4>222 88  #$  88A$B
A
4?2  
'
5'2
  # #   &$

Linia 5. zawiera sowo kluczowe  . Informuje ono kompilator, e nastpuje po


nim deklaracja klasy. Nazwa nowej klasy nastpuje bezporednio po sowie kluczowym  . W tym przypadku nazw klasy jest  (kot).

Rozdzia 6. Programowanie zorientowane obiektowo

137

Ciao deklaracji rozpoczyna si w linii 6. od otwierajcego nawiasu klamrowego i koczy


si zamykajcym nawiasem klamrowym i rednikiem w linii 10. Linia 7. zawiera sowo
kluczowe 
-, ktre wskazuje, e wszystko, co po nim nastpi, bdzie publiczne, a
do natrafienia na sowo kluczowe . lub koniec deklaracji klasy.
Linie 8. i 9. zawieraj deklaracje skadowych klasy,   (jego wiek) oraz  
(jego waga).
W linii 13. rozpoczyna si funkcja  . W linii 15. 
( jest definiowany jako
egzemplarz klasy  tj. jako obiekt klasy . W linii 16. wiek 
( jest ustawiany na *. W liniach 17. i 18. zmienna skadowa   zostaje uyta do wypisania
informacji o kocie 
(
.
Sprbuj wykomentowa lini$ 7., po czym skompiluj program ponownie. W linii
16. wystpi bd, gdy zmienna skadowa   nie b$dzie ju skadow publiczn. Domylnie, wszystkie skadowe klasy s prywatne.

Oznaczanie danych skadowych jako prywatnych


Powiniene przyj jako ogln regu, e dane skadowe klasy naley utrzymywa
jako prywatne. W zwizku z tym musisz stworzy publiczne funkcje skadowe, zwane
funkcjami dostpowymi lub 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? atwiej ni posugiwa si akcesorami jest uywa danych,.
Akcesory umoliwiaj oddzielenie szczegw przechowywania danych klasy od
szczegw jej uywania. Dziki temu moesz zmienia sposb przechowywania danych klasy bez koniecznoci przepisywania funkcji, ktre z tych danych korzystaj.
Jeli funkcja, ktra chce pozna wiek kota, odwoa si bezporednio do zmiennej
  klasy , bdzie musiaa zosta przepisana, jeeli ty, jako autor klasy ,
zdecydujesz si na zmian sposobu przechowywania tej zmiennej. Jednak posiadajc
funkcj skadow $ (pobierz wiek), klasa  moe atwo zwrci waciw
warto bez wzgldu na to, w jaki sposb przechowywany bdzie wiek. Funkcja wywoujca nie musi wiedzie, czy jest on przechowywany jako zmienna typu
 
  czy   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.

138

Cz I

Listing 6.2 przedstawia klas  zmodyfikowan tak, by zawieraa prywatne dane
skadowe i publiczne akcesory. Zwr uwag, e ten listing przedstawia wycznie
deklaracj klasy, nie ma w nim kodu wykonywalnego.
Listing 6.2. Klasa z akcesorami
'23 ##!
423
#. /"!
C" + 
# !"* 
/
52  
 !!
* #.!"!
!
62
:2
&2
<2" + 2
=2" + 
# !
>2


  
?2 D  


 
4'2
442


  
452 D  


 
462
4:2" + 

##.
4&2  
4<2
4=2"!

#.
4>2"  2
4?2


  
5'2


  
542
552

Ta klasa posiada pi metod publicznych. Linie 8. i 9. zawieraj akcesory dla skadowej  . Linie 11. i 12. zawieraj akcesory dla skadowej  . Te akcesory ustawiaj zmienne skadowe i zwracaj ich wartoci.
W linii 15. jest zadeklarowana publiczna funkcja skadowa . Ta funkcja nie jest
akcesorem. Nie zwraca wartoci ani ich nie ustawia; wykonuje inn usug dla klasy
wypisuje sowo 
.
Zmienne skadowe s zadeklarowane w liniach 19. i 20.
Aby ustawi wiek 
(, powiniene przekaza warto metodzie  (ustaw
wiek), na przykad:
  #
  #$D  &   # #
 1!/" + 
# 

Prywatno% a ochrona
Zadeklarowanie metod lub danych jako prywatnych umoliwia kompilatorowi wyszukanie w programach pomyek, zanim stan si one bdami. Kady szanujcy si

Rozdzia 6. Programowanie zorientowane obiektowo

139

programista potrafi znale sposb 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  jest nast$pujca:

E#!

.#  #
 ;"
 #


 #. #!


Sowo kluczowe  suy do deklarowania nowych typw. Klasa stanowi zbir danych
skadowych klasy, ktre s zmiennymi rnych typw, take innych klas. Klasa zawiera take funkcje klasy tzw. metody ktre s funkcjami uywanymi do manipulowania danymi
w danej klasie i wykonywania innych usug dla klasy.
Obiekty nowego typu definiuje si$ w taki sam sposb, w jaki definiuje si$ inne zmienne.
Naley okreli typ (klas$), a po nim nazw$ zmiennej (obiektu). Do uzyskania dost$pu do
funkcji i danych klasy suy operator kropki ()).
Sowa kluczowe kontroli dost$pu okrelaj, ktre sekcje klasy s prywatne, a ktre publiczne. Domylnie wszystkie skadowe klasy s prywatne. Kade sowo kluczowe zmienia
kontrol$ dost$pu od danego miejsca a do ko1ca klasy, lub kontrol$ wystpienia nast$pnego sowa kluczowego kontroli dost$pu. Deklaracja klasy ko1czy si$ zamykajcym nawiasem klamrowym i rednikiem.
Przykad 1


" + 2



 



 
  

  #
  #$ %>
  #$ %4>
  #$ 

Przykad 2


" + 2" ;-
;"
!#.! " + 
!
 D
    
 ,# 
 D F 
! 

 F 
"  2".;*- "!


F 
 G5&&H

140

Cz I

#
 # #!
IJ  !  "#!

+ #


!" 

IJ  $D F >:  #./F 
>:
+ %IJ  $ F   

/+ 
>:
IJ  $D!.   ;D

TAK

NIE

Deklaruj zmienne skadowe jako prywatne.

Nie uywaj prywatnych zmiennych skadowych


klasy poza t klas.

Uywaj publicznych akcesorw, czyli


publicznych funkcji dostpowych.
Odwouj si do prywatnych zmiennych
skadowych z funkcji skadowych klasy.

Implementowanie metod klasy


Akcesory stanowi publiczny interfejs do prywatnych danych klasy. Kady akcesor
musi posiada, wraz z innymi zadeklarowanymi metodami klasy, implementacj. Implementacja jest nazywana definicj funkcji.
Definicja funkcji skadowej rozpoczyna si od nazwy klasy, po ktrej wystpuj dwa
dwukropki, nazwa funkcji i jej parametry. Listing 6.3 przedstawia pen deklaracj
prostej klasy , wraz z implementacj jej akcesorw i jednej oglnej funkcji tej klasy.
Listing 6.3. Implementacja metod prostej klasy
'23 
   #
#!
42 

  
52
627
  8   9 
:2
&2"/ # # #!
<2
=2" + 2"/ # # " + 

>2
  # 
?2 D  
 # 
4'2   @

#
442"  2"/ # # "!

452
  

#.
462
4:2
4&2  C" + 
!# 
4<2/!*-#.  
4=2
22  
4>2
4?2  
  

Rozdzia 6. Programowanie zorientowane obiektowo

141

5'2
542
552 
D  C# 
562" + 

5:2  / #./ 
5&2 22D  
 
5<2
5=2  

/#./ 
5>2 
* /" #
/"  
5?2  % 
6'2
642
652 
 ! 
6622 
6:2"  !2+#
6&2 .
2!"   
 #
.A  !A
6<2 22 
6=2
6>222 88A  !$B
A
6?2
:'2
:42!#C    #C" C
:521   !C!"     # "

  !$
:62
 

::2
:&2  #
:<2  #$D  &
:=2  #$ 
:>222 88A  # #   A
:?222 88  #$  88A$B
A
&'2  #$ 
&42  
'
&52
  !$
  # #   &$
  !$

Linie od 5. do 13. zawieraj definicj klasy  (kot). Linia 7. zawiera sowo kluczowe 
-, ktre informuje kompilator, e to, co po nim nastpuje, jest zestawem publicznych skadowych. Linia 8. zawiera deklaracj publicznego akcesora $
(pobierz wiek). $ zapewnia dostp do prywatnej zmiennej skadowej  
(jego wiek), zadeklarowanej w linii 12. Linia 9. zawiera publiczny akcesor 
(ustaw wiek). Funkcja  otrzymuje parametr typu  , ktry nastpnie przypisuje skadowej  .
Linia 10. zawiera deklaracj metody  (miaucz). Funkcja  nie jest akcesorem. Jest to oglna metoda klasy, wypisujca na ekranie sowo Miauczy.
Linia 11. rozpoczyna sekcj prywatn, ktra obejmuje jedynie zadeklarowan w linii
12. prywatn skadow  . Deklaracja klasy koczy si zamykajcym nawiasem
klamrowym i rednikiem.

142

Cz I

Linie od 17. do 20. zawieraj definicj skadowej funkcji $. Ta metoda nie ma
parametrw i zwraca warto cakowit. Zauwa, e ta metoda klasy zawiera nazw
klasy, dwa dwukropki oraz nazw funkcji (linia 17.). Ta skadnia informuje kompilator, e definiowana funkcja $ jest wanie t funkcj, ktra zostaa zadeklarowana w klasie . Poza formatem tego nagwka, definiowanie funkcji wasnej
$ niczym nie rni si od definiowania innych (zwykych) funkcji.
Funkcja $ posiada tylko jedn lini i zwraca po prostu warto zmiennej skadowej  . Zauwa, e funkcja   nie ma dostpu do tej zmiennej skadowej,
gdy jest ona prywatna dla klasy . Funkcja   ma za to dostp do publicznej
metody $. Poniewa ta metoda jest skadow klasy , ma peny dostp do
zmiennej  . Dziki temu moe zwrci funkcji   warto zmiennej  .
Linia 25. zawiera definicj funkcji skadowej . Ta funkcja posiada parametr
w postaci wartoci cakowitej i przypisuje skadowej   jego warto (linia 29.).
Poniewa jest skadow klasy , ma bezporedni dostp do jej zmiennych prywatnych i publicznych.
Linia 36. rozpoczyna definicj (czyli implementacj) metody  klasy . Jest to
jednoliniowa funkcja wypisujca na ekranie sowo Miaucz, zakoczone znakiem
nowej linii. Pamitaj, e znak 1 powoduje przejcie do nowej linii.
Linia 43. rozpoczyna ciao funkcji  , czyli waciwy program. W tym przypadku
funkcja   nie posiada argumentw. W linii 45., funkcja   deklaruje obiekt
 o nazwie 
(. W linii 46. zmiennej   tego obiektu jest przypisywana
warto 5 (poprzez uycie akcesora ). Zauwa, e wywoanie tej metody nastpuje dziki uyciu nazwy obiektu (
(), po ktrej zastosowano operator kropki
()) i nazw metody (). W podobny sposb wywoywane s wszystkie inne
metody wszystkich klas.
Linia 47. wywouje funkcj skadow , za w linii 48. za pomoc akcesora $
, wypisywany jest komunikat. Linia 50. ponownie wywouje funkcj .

Konstruktory i destruktory
Istniej dwa sposoby definiowania zmiennej cakowitej. Mona zdefiniowa zmienn,
a nastpnie, w dalszej czci programu, przypisa jej warto. Na przykad:

  
 !

/
$$$ 

!#
 %="!"   ! *-

Moemy te zdefiniowa zmienn i jednoczenie zainicjalizowa j. Na przykad:



 %= 
 ! 
   !* /=

Rozdzia 6. Programowanie zorientowane obiektowo

143

Inicjalizacja czy w sobie definiowanie zmiennej oraz pocztkowe przypisanie wartoci. Nic nie stoi na przeszkodzie temu, by zmieni pniej warto zmiennej. Inicjalizacja powoduje tylko, e zmienna nigdy nie bdzie pozbawiona sensownej wartoci.
W jaki sposb zainicjalizowa skadowe klasy? Klasy posiadaj specjalne funkcje
skadowe, zwane konstruktorami. Konstruktor (ang. constructor) moe w razie potrzeby posiada parametry, ale nie moe zwraca wartoci nawet typu . . Konstruktor jest metod klasy o takiej samej nazwie, jak nazwa klasy.
Gdy zadeklarujesz konstruktor, powiniene take zadeklarowa destruktor (ang. destructor). Konstruktor tworzy i inicjalizuje obiekt danej klasy, za destruktor porzdkuje
obiekt i zwalnia pami, ktr moge w niej zaalokowa. Destruktor zawsze nosi nazw klasy, poprzedzon znakiem tyldy (2). Destruktory nie maj argumentw i nie
zwracaj wartoci. Dlatego deklaracja destruktora klasy  ma nastpujc posta:
K

Domy%lne konstruktory i destruktory


Jeli nie zadeklarujesz konstruktora lub destruktora, zrobi to za ciebie kompilator.
Istnieje wiele rodzajw konstruktorw; niektre z nich posiadaj argumenty, inne nie.
Konstruktor, ktrego mona wywoa bez adnych argumentw, jest nazywany konstruktorem domylnym. Istnieje tylko jeden rodzaj destruktora. On take nie posiada
argumentw.
Jeli nie stworzysz konstruktora lub destruktora, kompilator stworzy je za ciebie. Konstruktor dostarczany przez kompilator jest konstruktorem domylnym czyli konstruktorem bez argumentw. Taki konstruktor domylny moesz stworzy samodzielnie.
Stworzone przez kompilator domylny konstruktor i destruktor nie maj adnych argumentw, a na dodatek w ogle nic nie robi!

Uycie domy%lnego konstruktora


Do czego moe przyda si konstruktor, ktry 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 mc zadeklarowa obiekt
bez przekazywania parametrw, na przykad
J  
J  

 " @

musisz posiada konstruktor w postaci




Gdy definiujesz obiekt klasy, wywoywany jest konstruktor. Gdyby konstruktor klasy
 mia dwa parametry, mgby zdefiniowa obiekt , piszc
  #&C=

144

Cz I

Gdyby konstruktor mia jeden parametr, napisaby


  #6

W przypadku, gdy konstruktor nie ma adnych parametrw (gdy jest konstruktorem


domylnym), moesz opuci nawiasy i napisa
  #

Jest to wyjtek od reguy, zgodnie z ktr wszystkie funkcje wymagaj zastosowania


nawiasw, nawet jeli nie maj parametrw. Wanie dlatego moesz napisa:
  #

Jest to interpretowane jako wywoanie konstruktora domylnego. Nie dostarczamy


mu parametrw i pomijamy nawiasy.
Zwr uwag, e nie musisz uywa domylnego konstruktora dostarczanego przez
kompilator. Zawsze moesz napisa wasny konstruktor domylny tj. konstruktor
bez parametrw. Moesz zastosowa w nim ciao funkcji, w ktrym moesz zainicjalizowa obiekt.
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.
Listing 6.4 zawiera now wersj klasy , w ktrej do zainicjalizowania obiektu kota
uyto konstruktora. Wiek kota zosta ustawiony zgodnie z wartoci otrzyman jako
parametr konstruktora.
Listing 6.4. Uycie konstruktora i destruktora
'23 
   #
#
 #
42   ##!
523 !*
!#
 #.
!" "  ;
62
:27
  8   9 
&2
<2"/ # # #!
=2
>2" + 2"/ # # " + 

?2

  #
 #
4'2K  #
442
  # 
452 D  
 # 
462  
4:2"  2"/ # # "!

4&2
  

#.
4<2
4=2
4>2#
 ##!
4?222

  
5'2
542  %
  

Rozdzia 6. Programowanie zorientowane obiektowo

145

552
562
5:222K  #C

+
5&2
5<2
5=2
5>2  C" + 
!# 
5?2*-#.  
6'2
22  
642
652  
  
662
6:2
6&2 
D  C# 
6<2" + 

6=2
6>2 22D  
 
6?2
:'2  

/#./ 
:42 
* /" #
/"  
:52  % 
:62
::2
:&2 
 ! 
:<22 
:=2"  !2+#
:>2 .
2!"   
 #
.A  !A
:?2 22 
&'2
&4222 88A  !$B
A
&52
&62
&:2!#C    #C" C
&&21   !C!"     # "

  !$
&<2
 

&=2
&>2  #&
&?2  #$ 
<'222 88A  # #   A
<4222 88  #$  88A$B
A
<52  #$ 
<62  #$D  =
<:222 88AL   # A
<&222 88  #$  88A$B
A
<<2  
'
<=2
  !$
  # #   &$
  !$
L   # =$

Listing 6.4 przypomina listing 6.3, jednak w linii 9. dodano konstruktor, posiadajcy
argument w postaci wartoci cakowitej. Linia 10. deklaruje destruktor, ktry nie posiada parametrw. Destruktory nigdy nie maj parametrw, za destruktory i konstruktory nie zwracaj adnych wartoci nawet typu . .

146

Cz I

Linie od 19. do 22. zawieraj implementacj konstruktora. Jest ona podobna do implementacji akcesora . Konstruktor nie zwraca wartoci.
Linie od 24. do 26. przedstawiaj implementacj destruktora 2. Ta funkcja nie
robi nic, ale jeli deklaracja klasy zawiera deklaracj destruktora, zdefiniowany musi
zosta wtedy take ten destruktor.
Linia 58. zawiera definicj obiektu 
(, stanowicego egzemplarz klasy . Do
konstruktora obiektu 
( przekazywana jest warto *. Nie ma potrzeby wywoywania funkcji , gdy 
( zosta stworzony z wartoci * znajdujc si
w zmiennej skadowej  , tak jak pokazano w linii 61. W linii 63. zmiennej  
 obiektu 
( jest przypisywana warto 7. T now warto wypisuje linia 65.
TAK

NIE

W celu zainicjalizowania obiektw uywaj


konstruktorw.

Pamitaj, e konstruktory i destruktory nie mog


zwraca wartoci.
Pamitaj, e destruktory nie mog mie
parametrw.

Funkcje skadowe const


Jeli zadeklarujesz metod klasy jako  , obiecujesz w ten sposb, e metoda ta
nie zmieni wartoci adnej ze skadowych klasy. Aby zadeklarowa metod w ten
sposb, umie sowo kluczowe   za nawiasami, lecz przed rednikiem. Pokazana poniej deklaracja funkcji skadowej   o nazwie 3
  nie posiada
argumentw i zwraca typ . :
 D J
 



Wraz z modyfikatorem   czsto deklarowane s akcesory. Klasa  posiada dwa


akcesory:
 D  

 

  

Funkcja  nie moe by funkcj  , gdy modyfikuje warto zmiennej skadowej  . Natomiast funkcja $ moe by  , gdy nie modyfikuje wartoci adnej ze skadowych klasy. Funkcja $ po prostu zwraca biec warto
skadowej  . Zatem deklaracje tych funkcji mona przepisa nastpujco:
 D  

 

  


Gdy zadeklarujesz funkcj jako  , za implementacja tej funkcji modyfikuje


obiekt poprzez modyfikacj wartoci ktrejkolwiek ze skadowych, kompilator zgosi

Rozdzia 6. Programowanie zorientowane obiektowo

147

bd. Na przykad, gdy napiszesz funkcj $ w taki sposb, e bdziesz zapamitywa ilo zapyta o wiek kota, spowodujesz bd kompilacji. Jest to spowodowane tym, e wywoujc t metod, modyfikujesz zawarto obiektu .
Deklaruj funkcje jako   wsz$dzie, gdzie to jest moliwe. Deklaruj je tam,
gdzie nie przewidujesz modyfikowania obiektu. Kompilator moe w ten sposb
pomc ci w wykryciu b$dw w programie; tak jest szybciej i dokadniej.

Deklarowanie funkcji jako   wszdzie tam, gdzie jest to moliwe, naley do tradycji programistycznej. Za kadym razem, gdy to zrobisz, umoliwisz kompilatorowi
wykrycie pomyki, zanim stanie si ona bdem, ktry ujawni si ju podczas dziaania programu.

Interfejs a implementacja
Jak wiesz, klienty s tymi elementami programu, ktre tworz i wykorzystuj obiekty
twojej klasy. Publiczny interfejs swojej klasy deklaracj klasy moesz traktowa
jako kontrakt z tymi klientami. Ten kontrakt informuje, jak zachowuje si dana klasa.
Na przykad, w deklaracji klasy , stworzye kontrakt informujcy, e wiek kadego kota moe by zainicjalizowany w jego konstruktorze, modyfikowany za pomoc
akcesora  oraz odczytywany za pomoc akcesora $. Oprcz tego
obiecujesz, e kady kot moe miaucze (funkcj ). Zwr uwag, e w publicznym interfejsie nie ma ani sowa o zmiennej skadowej  ; jest to szczeg
implementacji, ktry nie stanowi elementu kontraktu. Na danie dostarczysz wieku
($) i ustawisz go (), ale sam mechanizm ( ) jest niewidoczny.
Gdy uczynisz funkcj $funkcj   a powiniene to zrobi kontrakt obiecuje take, e funkcja $ nie modyfikuje obiektu , dla ktrego jest wywoana.
C++ jest jzykiem zapewniajcym siln kontrol typw, co oznacza, e kompilator
wymusza przestrzeganie kontraktu, zgaszajc bdy kompilacji za kadym razem,
gdy naruszysz reguy tego kontraktu. Listing 6.5 przedstawia program, ktry nie
skompiluje si z powodu naruszenia ustale takiego kontraktu.

Listing 6.5 nie skompiluje si$!

Listing 6.5. Przykad naruszenia ustale interfejsu


'23 
  +.;!# " 
42L
"   ;
# "   0
52
627
  8   9 
:2
&2

148

Cz I
<2
=2" + 2
>2

  
?2K
4'2
  
# !" 

442 D  
 
452  
462"  2
4:2
  
4&2
4<2
4=2#
 ##!C
4>222

  
4?2
5'2  %
  
54222 88AM
 ##!B
A
552
562
5:222K  #C

+
5&2
5<222 88A3  ##!B
A
5=2
5>2  C
#
C
5?2 
 ;
0
6'2
22  

642
652  
  NN
 
0
662
6:2
6&2 
D  C" + 

6<2# 
6=2
6>2 22D  
 
6?2
:'2  

/#./ 
:42 
* /" #
/"  
:52  % 
:62
::2
:&2 
 ! 
:<22 
:=2"  !2+#
:>2 .
2!"   
 #
.A  !A
:?2 22 
&'2
&4222 88A  !$B
A
&52
&62
&:2 
  @1

 
 .
  
&&2!
#/  +.;!# " 
&<2
 

&=2
&>2  #
"   #
&?2  #$ 
<'2  #$,#O C . " C#!
 #/$
<42  #$  %=   #./"!
/
<52  
'
<62

Rozdzia 6. Programowanie zorientowane obiektowo

149

Program w przedstawionej powyej postaci si nie kompiluje, wic nie ma wynikw


dziaania.
Pisanie go byo do zabawne, poniewa zawiera tak duo bdw.
Linia 10 deklaruje funkcj $ jako akcesor typu   i tak powinno by. Jednak
w ciele funkcji $, w linii 32., inkrementowana jest zmienna skadowa  . Poniewa ta metoda zostaa zadeklarowana jako  , nie moe zmienia wartoci tej
zmiennej. Dlatego podczas kompilacji programu zostanie to zgoszone jako bd.
W linii 12., funkcja  nie jest zadeklarowana jako  . Cho nie jest to bdem, stanowi zy obyczaj. Naleaoby wzi pod uwag, e ta metoda nie modyfikuje
zmiennych skadowych klasy. Dlatego funkcja  powinna by funkcj  .
Linia 58. pokazuje definicj obiektu 
( klasy . W tym programie klasa 
posiada konstruktor, ktry wymaga podania argumentu, bdcego wartoci cakowit. Oznacza to, e musisz taki argument przekaza. Poniewa w linii 58. nie wystpuje argument konstruktora, kompilator zgosi bd.
Jeli stworzysz jakikolwiek konstruktor, kompilator zrezygnuje z dostarczenia swojego konstruktora domylnego. Gdy stworzysz konstruktor wymagajcy parametru,
nie b$dziesz mia konstruktora domylnego, chyba e stworzysz go sam.

Linia 60. zawiera wywoanie metody  dla obiektu 


(. Metoda  nie
zostaa zadeklarowana, wic jest niedozwolona.
Linia 61. zawiera przypisanie wartoci 4 do zmiennej  . Poniewa   jest
skadow prywatn, kompilator zgosi bd kompilacji.
Po co u.ywa kompilatora do wykrywania bdw?
Gdyby mona byo tworzy programy w stu procentach pozbawione b$dw, byoby cudowanie, jednak tylko bardzo niewielu programistw jest w stanie tego dokona. Wielu programistw opracowao jednak system pozwalajcy zminimalizowa ilo b$dw przez wczesne
ich wykrycie i poprawienie.
Cho b$dy kompilatora s irytujce i stanowi dla programisty przekle1stwo, jednak s
czym duo lepszym ni opisana dalej alternatywa. J$zyk o sabej kontroli typw 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 twj szef.
B$dy czasu kompilacji tj. b$dy wykryte podczas kompilowania programu s zdecydowanie lepsze ni b$dy czasu dziaania tj. b$dy wykryte podczas dziaania programu.
S lepsze, gdy duo atwiej i precyzyjniej mona okreli 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. B$dy kompilacji s wykrywane podczas kadej kompilacji, s wi$c duo atwiejsze do
zidentyfikowania i poprawienia. Celem dobrego programowania jest ochrona przed pojawianiem si$ b$dw czasu dziaania. Jedn ze znanych i sprawdzonych technik jest wykorzystanie kompilatora do wykrycia pomyek ju na wczesnym etapie tworzenia programu.

150

Cz I

Gdzie umieszcza deklaracje klasy


i definicje metod
Kada funkcja, ktr zadeklarujesz dla klasy, musi posiada definicj. Definicja jest
nazywana take implementacj funkcji. Podobnie jak w przypadku innych funkcji,
definicja metody klasy posiada nagwek i ciao.
Definicja musi znajdowa si w pliku, ktry moe zosta znaleziony przez kompilator. Wikszo kompilatorw C++ wymaga, by taki plik mia rozszerzenie .c lub .cpp.
W tej ksice korzystamy z rozszerzenia .cpp, ale aby mie pewno, sprawd, czego
oczekuje twj kompilator.
Wiele kompilatorw 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 ktrym umieszczasz implementacj funkcji, moesz umieci rwnie jej


deklaracj, ale nie naley to do dobrych obyczajw. Zgodnie z konwencj zaadoptowan przez wikszo programistw, deklaracje umieszcza si w tak zwanych plikach
nagwkowych, zwykle posiadajcych t sam nazw, lecz z rozszerzeniem .h, .hp
lub .hpp. W tej ksice dla plikw nagwkowych stosujemy rozszerzenie .hpp, ale
sprawd w swoim kompilatorze, jakie rozszerzenie powiniene stosowa.
Na przykad, deklaracj klasy  powiniene umieci w pliku o nazwie CAT.hpp,
za definicj metod tej klasy w pliku o nazwie CAT.cpp. Nastpnie powiniene doczy do pliku .cpp plik nagwkowy, poprzez umieszczenie na pocztku pliku
CAT.cpp nastpujcej dyrektywy:
7
  A$""A

Informuje ona kompilator, by wstawi w tym miejscu zawarto pliku CAT.hpp tak, jakby j wpisa rcznie. Uwaga: niektre kompilatory nalegaj, by wielko liter w nazwie
pliku w dyrektywie 5 
 zgadzaa si z wielkoci liter w nazwie pliku na dysku.
Deklaracja klasy mwi kompilatorowi, czym jest ta klasa, jakie dane zawiera
oraz jakie funkcje posiada. Deklaracja klasy jest nazywana jej interfejsem, gdy
informuje kompilator w jaki sposb ma z ni wspdziaa. Ten interfejs jest
zwykle przechowywany w pliku .hpp, cz$sto nazywanym plikiem nagwkowym.
Definicja funkcji mwi kompilatorowi, jak dziaa dana funkcja. Definicja funkcji
jest nazywana implementacj metody klasy i jest przechowywana w pliku .cpp.
Szczegy dotyczce implementacji klasy nale wycznie do jej autora. Klienty klasy tj. cz$ci programu uywajce tej klasy nie musz, ani nie powinny wiedzie, jak zaimplementowane zostay funkcje.

Rozdzia 6. Programowanie zorientowane obiektowo

151

Dlaczego masz si trudzi, rozdzielajc program na pliki .hpp i .cpp, skoro i tak plik
.hpp jest wstawiany do pliku .cpp? W wikszoci przypadkw klienty klasy nie dbaj
o szczegy jej implementacji. Odczytanie pliku nagwkowego daje im wystarczajc ilo informacji, by zignorowa plik implementacji. Poza tym, ten sam plik .hpp
moesz docza do wielu rnych plikw .cpp.

Implementacja inline
Moesz poprosi kompilator, by uczyni zwyk funkcj funkcj   , funkcjami
   mog sta si rwnie metody klasy. W tym celu naley umieci sowo kluczowe    przed typem zwracanej wartoci. Na przykad, implementacja   
funkcji $ wyglda nastpujco:



22  

  
  
/#./  


Definicj funkcji mona take umieci w deklaracji klasy, co automatycznie sprawia,


e ta funkcja staje si funkcj   . Na przykad:


" + 2

    
  


 D  
 


Zwr uwag na skadni definicji funkcji $. Ciao funkcji    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 spacje nie
maj znaczenia; moesz zapisa t deklaracj jako:


" + 2

  


  
  



 D  
 


Listingi 6.6 i 6.7 odtwarzaj klas , tym razem jednak deklaracja klasy zostaa
umieszczona w pliku CAT.hpp, za jej definicja w pliku CAT.cpp. Oprcz tego, na listingu 6.7 akcesor  zosta zadeklarowany jako funkcja   .

152

Cz I

Listing 6.6. Deklaracja klasy Cat w pliku CAT.hpp


'27
  8   9
42
52
62" + 2
:2

  
&2K
<2
  
  
  

0
=2 D  
   % 

0
>2  
22 88A  !$B
A

0
?2"  2
4'2
  
442

Listing 6.7. Implementacja klasy Cat w pliku CAT.cpp


'23 
  
# 


42./
" # 
 .@# 
52
62" ;./
" #@
 .@#!0
:27
  A$""A
&2
<2
=222

  #
 #
>2
?2  %
  
4'2
442
45222K  #C

+
462
4:2
4&2
4<2!#C    #C" 
4=21   !C!"     # "

  !$
4>2
 

4?2
5'2  #&
542  #$ 
55222 88A  # #   A
56222 88  #$  88A$B
A
5:2  #$ 
5&2  #$D  =
5<222 88AL   # A
5=222 88  #$  88A$B
A
5>2  
'
5?2
  !$
  # #   &$
  !$
L   # =$

Kod zaprezentowany na listingach 6.6 i 6.7 jest podobny do kodu z listingu 6.4, trzy
metody zostay zadeklarowane w pliku deklaracji jako   , a deklaracja zostaa
przeniesiona do pliku CAT.hpp (listing 6.6).

Rozdzia 6. Programowanie zorientowane obiektowo

153

Funkcja $ jest deklarowana w linii 6., gdzie znajduje si take jej implementacja. Linie 7. i 8. zawieraj kolejne funkcje   , jednak w stosunku do poprzednich, zwykych implementacji, dziaanie tych funkcji nie zmienia si.
Linia 4. listingu 6.7 zawiera dyrektyw 5 
 6)6, ktra powoduje wstawienie do pliku zawartoci pliku CAT.hpp. Doczajc plik CAT.hpp, informujesz
prekompilator, by odczyta zawarto tego pliku i wstawi j w miejscu wystpienia
dyrektywy 5 
 (tak jakby, poczwszy od linii 5, sam wpisa t zawarto).
Ta technika umoliwia umieszczenie deklaracji w pliku innym ni implementacja,
a jednoczenie zapewnienie kompilatorowi dostpu do niej. W programach C++ technika ta jest powszechnie wykorzystywana. Zwykle deklaracje klas znajduj si w plikach .hpp, ktre s doczane do powizanych z nimi plikw .cpp za pomoc dyrektyw 5 
.
Linie od 18. do 29. stanowi powtrzenie funkcji   z listingu 6.4. Oznacza to, e
funkcje    dziaaj tak samo jak zwyke funkcje.

Klasy, ktrych 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 biegw itd., a nastpnie
poczy je w klas samochd. Deklaruje to relacj posiadania. Samochd posiada
silnik, koa i skrzyni biegw.
Wemy inny przykad. Prostokt skada si z odcinkw. Odcinek jest zdefiniowany
przez dwa punkty. Punkt jest zdefiniowany przez wsprzdn x i wsprzdn y. Listing 6.8 przedstawia pen deklaracj klasy   (prostokt), ktra moe wystpi w pliku RECTANGLE.hpp. Poniewa prostokt jest zdefiniowany jako cztery
odcinki czce cztery punkty, za kady punkt odnosi si do wsprzdnej w ukadzie, najpierw zadeklarujemy klas &  (punkt) jako przechowujc wsprzdne
x oraz y punktu. Listing 6.9 zawiera implementacje obu klas.
Listing 6.8. Deklarowanie kompletnej klasy
'2"/ #P $""
42
527
  8   9
62Q
"   "@.;
)C!
:2
&2+ #
 #C 1! !*

<2" + 2
=2 D R
) R%)

154

Cz I
>2 D F
! F%!
?2
 R
  
 R
4'2
 F
  
 F
442"  2
452
 R
462
 F
4:2#
 # #!Q

4&2
4<2
4=2P 

4>2
4?2" + 2
5'2P 
 
"C
 C
+ C
 
542KP 
 
552
562
 L"
  
 L"
5:2
 S 
  
 S 
5&2
 , 
  
 , 
5<2
 P 
  
 P 
5=2
5>2Q
 T"" S 
  
 T"" S 
5?2Q
 S S 
  
 S S 
6'2Q
 T"" P 
  
 T"" P 
642Q
 S P 
  
 S P 
652
662 D T"" S Q
S 
 T"" S %S 

6:2 D S S Q
S 
 S S %S 

6&2 D T"" P Q
S 
 T"" P %S 

6<2 D S P Q
S 
 S P %S 

6=2
6>2 D L"
" L"%"
6?2 D S 
  S % 
:'2 D , 
+  , %+ 
:42 D P 
  P % 
:52
:62
  

::2
:&2"  2
:<2Q
 T"" S 
:=2Q
 T"" P 
:>2Q
 S S 
:?2Q
 S P 
&'2
 L"
&42
 S 
&52
 , 
&62
 P 
&:2
&&2#
P $""

Listing 6.9. RECTANGLE.cpp


'2"/ # $""
42
527
  A $""A
62P 
 22P 
 
"C
 C
+ C
 

Rozdzia 6. Programowanie zorientowane obiektowo

155

:2
&2 L"%"
<2 S % 
=2 , %+ 
>2 P % 
?2
4'2 T"" S $D R 
442 T"" S $D F"
452
462 T"" P $D R 
4:2 T"" P $D F"
4&2
4<2 S S $D R 
4=2 S S $D F+ 
4>2
4?2 S P $D R 
5'2 S P $D F+ 
542
552
562
5:2+ +"#/" + 

5&2 "
1
 #*  !#*
5<2
P 
 22  

5=2
5>2
 % P U S 
5?2
V % L"U , 
6'2  
 WV 
642
652
662
 

6:2
6&2
   #
/

/!" P 

6<2P 
 !P 
 4''C5'C&'C>'
6=2
6>2
 %!P 
 $  
6?2
:'222 88AI+2A88 88AB
A
:4222 88A"$R   
 2A
:5222 88!P 
 $ T"" S $ R
:62  
'
::2
I+26'''
"$R   
 25'

Linie od 3. do 14. listingu 6.8 deklaruj klas &  (punkt), ktra suy do przechowywania wsprzdnych , i okrelonego punktu rysunku. W tym programie nie
wykorzystujemy naleycie klasy & . Jej zastosowania wymagaj jednak inne metody rysunkowe.
Gdy nadasz klasie nazw$  , niektre kompilatory zgosz bd. W takim przypadku po prostu zmie1 nazw$ klasy na   .

156

Cz I

W deklaracji klasy & , w liniach 12. i 13., zadeklarowalimy dwie zmienne skadowe ( 7 oraz  8). Te zmienne przechowuj wsprzdne punktu. Zakadamy, e
wsprzdna , ronie w prawo, a wsprzdna w gr. Istniej take inne systemy.
W niektrych programach okienkowych wsprzdna y ronie w d okna.
Klasa &  uywa akcesorw inline, zwracajcych i ustawiajcych wsprzdne 7 i 8
punktu. Te akcesory zostay zadeklarowane w liniach od 7. do 10. Punkty uywaj
konstruktora i destruktora domylnego. W zwizku z tym ich wsprzdne trzeba
ustawia jawnie.
Linia 17. rozpoczyna deklaracj klasy   (prostokt). Klasa ta kada si z czterech punktw reprezentujcych cztery naroniki prostokta.
Konstruktor klasy   (linia 20.) otrzymuje cztery wartoci cakowite,  (grna),
9 (lewa), - (dolna) oraz  (prawa). Do czterech zmiennych skadowych (listing 6.9) kopiowane s cztery parametry konstruktora i tworzone s cztery punkty.
Oprcz standardowych akcesorw, klasa   posiada funkcj $ (pobierz obszar), zadeklarowan w linii 43. Zamiast przechowywa obszar w zmiennej,
funkcja $ oblicza go w liniach od 28. do 30. listingu 6.9. W tym celu oblicza
szeroko i wysoko prostokta, nastpnie mnoy je przez siebie.
Uzyskanie wsprzdnej , lewego grnego wierzchoka prostokta wymaga dostpu
do punktu :%9 (lewy grny) i zapytania o jego wsprzdn 7. Poniewa funkcja $:%9 jest funkcj klasy  , moe ona bezporednio odwoywa
si do prywatnych danych tej klasy, wcznie ze zmienn ( :%9). Poniewa
 :%9 jest obiektem klasy & , a zmienna  7 tej klasy jest prywatna, funkcja $:%9 nie moe odwoywa si do niej bezporednio. Zamiast tego,
w celu uzyskania tej wartoci musi uy publicznego akcesora $7.
Linia 33. listingu 6.9 stanowi pocztek ciaa programu. Pami nie jest alokowana a
do linii 36.; w obszarze tym nic si nie dzieje. Jedyna rzecz, jak zrobilimy, to poinformowanie kompilatora, jak ma stworzy punkt i prostokt (gdyby byy potrzebne
w przyszoci).
W linii 36. definiujemy obiekt typu  , przekazujc mu wartoci ", %9,
 oraz .
W linii 38. tworzymy lokaln zmienn  (obszar) typu  . Ta zmienna przechowuje obszar stworzonego przez nas prostokta. Zmienn  inicjalizujemy za pomoc wartoci zwrconej przez funkcj $ klasy  .
Klient klasy   moe stworzy obiekt tej klasy i uzyska jego obszar, nie znajc nawet implementacji funkcji $.
Plik RECT.hpp zosta przedstawiony na listingu 6.8. Obserwujc plik nagwkowy, ktry zawiera deklaracj klasy  , programista moe wysnu wniosek, e funkcja

Rozdzia 6. Programowanie zorientowane obiektowo

157

$ zwraca warto typu  . Sposb, w jaki funkcja $ uzyskuje t warto, nie interesuje klientw klasy  . Autor klasy   mgby zmieni
funkcj $; nie wpynoby to na programy, ktre z niej korzystaj.
Czsto zadawane pytanie
Jaka jest rnica pomi$dzy deklaracj a definicj?
Odpowied4
Deklaracja wprowadza now nazw$, lecz nie alokuje pami$ci; dokonuje tego
definicja.

Wszystkie deklaracje (z kilkoma wyjtkami) s take definicjami. Najwaniejszym


wyjtkiem jest deklaracja funkcji globalnej (prototyp) oraz deklaracja klasy (zwykle
w pliku nagwkowym).

Struktury
Bardzo bliskim kuzynem sowa kluczowego  jest sowo kluczowe 
, uywane do deklarowania struktur. W C++ struktura jest odpowiednikiem klasy, ale
wszystkie jej skadowe s domylnie publiczne. Moesz zadeklarowa struktur dokadnie tak, jak klas; moesz zastosowa w niej te same zmienne i funkcje skadowe.
Gdy przestrzegasz jawnego deklarowania publicznych i prywatnych sekcji klasy, nie
ma adnej rnicy pomidzy klas a struktur.
Sprbuj wprowadzi do listingu 6.8 nastpujce zmiany:
w linii 3., zmie  &  na 
 & ,
w linii 17., zmie    na 
  .
Nastpnie skompiluj i uruchom program. Otrzymane wyniki nie powinny si od siebie rni.

Dlaczego dwa sowa kluczowe


speniaj' t" sam' funkcj"
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, twrca jzyka C++, rozbudowa struktury, ale zmieni ich nazw na klasy, odzwierciedlajc w ten sposb ich nowe, rozszerzone moliwoci.

158

TAK
Umieszczaj deklaracj klasy w pliku .hpp, za funkcje skadowe definiuj w pliku .cpp.
Uywaj 
 wszdzie tam, gdzie jest to moliwe.
Zanim przejdziesz dalej, postaraj si dokadnie zrozumie zasady dziaania klasy.

Cz I

You might also like