C dla kazdego Wydanie II cppint

background image
background image

Idź do

• Spis treści
• Przykładowy rozdział

• Katalog online

• Dodaj do koszyka

• Zamów cennik

• Zamów informacje

o nowościach

• Fragmenty książek

online

Helion SA

ul. Kościuszki 1c

44-100 Gliwice

tel. 32 230 98 63

e-mail: helion@helion.pl

© Helion 1991–2010

Katalog książek

Twój koszyk

Cennik i informacje

Czytelnia

Kontakt

• Zamów drukowany

katalog

C++ dla każdego.
Wydanie II

Autorzy:

Jesse Liberty

, Siddhartha Rao, Bradley L. Jones

Tłumaczenie: Robert Górczyński
ISBN: 978-83-246-2782-0
Tytuł oryginału:

Sams Teach Yourself C++

in One Hour a Day (6th Edition)

Format: B5, stron: 850

Poznaj język C++ w 21 dni!

Pomimo swojego wieku, język C++ wciąż utrzymuje wysoką formę. Przez lata zdobył i ugruntował
sobie świetną pozycję na rynku języków programowania. Dzięki temu, nawet dziś w czasach gdzie
króluje język Java oraz platforma .NET, wciąż swoich zwolenników. Ba! Istnieją takie gałęzie
oprogramowania, w których jest on niezastąpiony. Dlatego jeżeli oczekujesz najwyższej
wydajności, operowania blisko sprzętu oraz pełnej kontroli nad sposobem wykonywania
programu powinieneś postawić właśnie na C++.

Dzięki książce, którą trzymasz w ręku będzie to stosunkowo proste zadanie. Poświęcając tylko
godzinę dziennie zdobędziesz wiedzę, która pozwoli Ci spokojnie rozpocząć przygodę z językiem
C++, poznać jego tajniki, zalety oraz wady. Z każdą kolejną godziną będziesz zdobywać coraz to
bardziej zaawansowaną i ciekawą wiedzę. Jaki więc zakres obejmuje niniejszy podręcznik?
Kompletny, którego opanowanie pozwoli Ci na pisanie programów o różnym stopniu złożoności
oraz swobodne poruszanie się w świecie języka C++. Zdobędziesz informacje na temat stałych,
zmiennych, tablic, instrukcji warunkowych oraz pętli. Ponadto dowiesz się, jak wykorzystać
wskaźniki oraz dyrektywy kompilatora. Natomiast lektura ostatnich rozdziałów książki pozwoli Ci
na swobodne poruszanie się w świecie programowania obiektowego, strumieni oraz klas STL.
Obiekty, klasy, dziedziczenie czy polimorfizm – te pojęcia nie skryją przed Tobą już żadnej
tajemnicy! Kolejne wydanie cenionej książki sprawdzi się w rękach każdego adepta języka C++.
Jeżeli chcesz poznać ten język, to nie ma na co czekać. Lepszej okazji nie będzie!

• Historia języka C++
• Konstrukcja programu w języku C++
• Komentowanie kodu
• Zmienne i stałe
• Zastosowanie tablic i ciągów tekstowych
• Formułowanie wyrażeń
• Instrukcje warunkowe i operatory
• Wykorzystanie i tworzenie funkcji
• Zakresy zmiennych
• Sterowanie przebiegiem programu
• Zasada działania wskaźników
• Programowanie obiektowe – klasy, obiekty, dziedziczenie, polimorfizm
• Rzutowanie
• Wykorzystanie strumieni
• Kompilowanie warunkowe, instrukcje kompilatora

Sprawdź czy język C++ spełni Twoje oczekiwania!

background image

Spis treci

Wstp 25

Cz I Podstawy

Lekcja 1. Zaczynamy

31

Krótka historia jzyka C++ ............................................................................................31

Interpretery i kompilatory ....................................................................................33

Zmiana wymaga, zmiana platform ..................................................................34

Programowanie proceduralne, strukturalne i obiektowe .......................35

Programowanie zorientowane obiektowo .....................................................36

C++ i programowanie zorientowane obiektowo .............................................37

Jak ewoluowao C++ ........................................................................................................38

Czy naley najpierw pozna C? ...................................................................................39

Dodatek Microsoft Managed Extensions for C++ ................................................39

Standard ANSI ....................................................................................................................39

Przygotowanie do programowania ..........................................................................40

Twoje rodowisko programowania ..........................................................................41

Tworzenie programu ......................................................................................................42

Tworzenie pliku obiektowego za pomoc kompilatora ...........................42

Tworzenie pliku wykonywalnego za pomoc linkera ...............................43

Cykl tworzenia programu .............................................................................................43

HELLO.cpp — Twój pierwszy program w C++ ....................................................45

Zaczynamy prac z kompilatorem ............................................................................47

Budowanie projektu Hello World .......................................................................48

Bdy kompilacji ................................................................................................................49

Podsumowanie ...................................................................................................................50

Pytania i odpowiedzi .......................................................................................................50

Warsztaty .............................................................................................................................51

Quiz ..................................................................................................................................52

wiczenia .......................................................................................................................52

background image

4

C++ dla kadego

Lekcja 2. Anatomia programu C++

53

Prosty program ................................................................................................................. 53

Rzut oka na obiekt cout ................................................................................................. 56

Uywanie przestrzeni nazw standardowych ....................................................... 58

Komentarze ......................................................................................................................... 61

Rodzaje komentarzy ................................................................................................. 61

Uywanie komentarzy ............................................................................................. 62

Jeszcze jedna uwaga na temat komentarzy ................................................... 63

Funkcje .................................................................................................................................. 63

Korzystanie z funkcji ................................................................................................ 65

Metody kontra funkcje ............................................................................................ 67

Podsumowanie .................................................................................................................. 67

Pytania i odpowiedzi ....................................................................................................... 67

Warsztaty ............................................................................................................................. 68

Quiz .................................................................................................................................. 68

wiczenia ...................................................................................................................... 69

Lekcja 3. Zmienne i stae

71

Czym jest zmienna? ......................................................................................................... 71

Dane s przechowywane w pamici ................................................................. 71

Przydzielanie pamici ............................................................................................. 72

Rozmiar liczb cakowitych .................................................................................... 73

Zapis ze znakiem i bez znaku ............................................................................... 74

Podstawowe typy zmiennych .............................................................................. 74

Definiowanie zmiennej .................................................................................................. 75

Uwzgldnianie wielkoci liter .............................................................................. 77

Konwencje nazywania zmiennych ..................................................................... 77

Sowa kluczowe .......................................................................................................... 78

Okrelenie iloci pamici uywanej przez typ zmiennej ................................ 79

Tworzenie kilku zmiennych jednoczenie ............................................................ 81

Przypisywanie zmiennym wartoci ......................................................................... 81

Tworzenie aliasów za pomoc typedef ................................................................... 83

Kiedy uywa typu short, a kiedy typu long? ....................................................... 84

Zawinicie liczby cakowitej bez znaku ........................................................... 85

Zawinicie liczby cakowitej ze znakiem ........................................................ 86

background image

Spis

treci

5

Znaki .......................................................................................................................................87

Znaki i liczby ................................................................................................................ 88

Znaki specjalne ............................................................................................................89

Stae ........................................................................................................................................90

Literay ...........................................................................................................................90

Stae symboliczne ......................................................................................................91

Stae wyliczeniowe ...........................................................................................................92

Podsumowanie ...................................................................................................................95

Pytania i odpowiedzi .......................................................................................................96

Warsztaty .............................................................................................................................97

Quiz ..................................................................................................................................97

wiczenia .......................................................................................................................98

Lekcja 4. Tablice i cigi tekstowe

99

Czym jest tablica? ..............................................................................................................99

Elementy tablicy ...................................................................................................... 100

Zapisywanie za kocem tablicy ........................................................................ 102

Bd supka w pocie ............................................................................................. 104

Inicjalizowanie tablic ............................................................................................ 105

Deklarowanie tablic ............................................................................................... 106

Tablice wielowymiarowe ........................................................................................... 107

Deklarowanie tablic wielowymiarowych ..................................................... 108

Inicjalizowanie tablic wielowymiarowych .................................................. 110

Tablice znaków i cigi tekstowe .............................................................................. 113

Metody strcpy() oraz strncpy() ............................................................................... 115

Klasy cigów tekstowych ........................................................................................... 117

Podsumowanie ................................................................................................................ 120

Pytania i odpowiedzi .................................................................................................... 120

Warsztaty .......................................................................................................................... 121

Quiz ............................................................................................................................... 121

wiczenia .................................................................................................................... 122

Lekcja 5. Wyraenia, instrukcje i operatory

123

Instrukcje ........................................................................................................................... 123

Biae znaki .................................................................................................................. 124

Bloki i instrukcje zoone .................................................................................... 124

Wyraenia ......................................................................................................................... 125

background image

6

C++ dla kadego

Operatory ...........................................................................................................................126

Operator przypisania .............................................................................................127

Operatory matematyczne ....................................................................................127

czenie operatora przypisania z operatorem matematycznym .............130

Inkrementacja i dekrementacja ...............................................................................130

Przedrostki i przyrostki ........................................................................................131

Kolejno dziaa ............................................................................................................133

Zagniedanie nawiasów ............................................................................................134

Prawda i fasz ...................................................................................................................135

Operatory relacji ......................................................................................................136

Instrukcja if .......................................................................................................................137

Styl wci .....................................................................................................................141

Instrukcja else ...........................................................................................................141

Zaawansowane instrukcje if ...............................................................................143

Uycie nawiasów klamrowych w zagniedonych instrukcjach if ...........146

Operatory logiczne .........................................................................................................149

Logiczne I ....................................................................................................................149

Logiczne LUB .............................................................................................................150

Logiczne NIE ..............................................................................................................150

Skrócone obliczanie wyrae logicznych ............................................................150

Kolejno operatorów logicznych ...........................................................................151

Kilka sów na temat prawdy i faszu ......................................................................152

Operator warunkowy (trójelementowy) .............................................................152

Podsumowanie ................................................................................................................154

Pytania i odpowiedzi .....................................................................................................154

Warsztaty ...........................................................................................................................155

Quiz ................................................................................................................................155

wiczenia ....................................................................................................................156

Lekcja 6. Funkcje

159

Czym jest funkcja? ..........................................................................................................159

Zwracane wartoci, parametry i argumenty ......................................................160

Deklarowanie i definiowanie funkcji .....................................................................161

Prototypy funkcji .....................................................................................................162

Definiowanie funkcji ..............................................................................................164

Wykonywanie funkcji ...................................................................................................166

background image

Spis

treci

7

Zakres zmiennej ............................................................................................................. 166

Zmienne lokalne ...................................................................................................... 166

Zmienne lokalne zdefiniowane w blokach .................................................. 168

Parametry s zmiennymi lokalnymi ...................................................................... 170

Zmienne globalne .................................................................................................... 172

Zmienne globalne: ostrzeenie ......................................................................... 173

Rozwaania na temat tworzenia instrukcji funkcji ........................................ 174

Kilka sów na temat argumentów funkcji ........................................................... 174

Kilka sów na temat zwracanych wartoci ......................................................... 175

Parametry domylne .................................................................................................... 178

Przecianie funkcji ...................................................................................................... 181

Zagadnienia zwizane z funkcjami ......................................................................... 185

Funkcje typu inline ................................................................................................. 185

Rekurencja ................................................................................................................. 188

Jak dziaaj funkcje — rzut oka „pod mask” .................................................... 193

Poziomy abstrakcji ................................................................................................. 193

Podsumowanie ................................................................................................................ 198

Pytania i odpowiedzi .................................................................................................... 199

Warsztaty .......................................................................................................................... 200

Quiz ............................................................................................................................... 200

wiczenia .................................................................................................................... 200

Lekcja 7. Sterowanie przebiegiem dziaania programu

203

Ptle ..................................................................................................................................... 203

Pocztki ptli: instrukcja goto ........................................................................... 203

Dlaczego nie jest zalecane stosowanie instrukcji goto? ......................... 205

Ptle while ......................................................................................................................... 205

Bardziej skomplikowane instrukcje while .................................................. 207

Instrukcje continue oraz break ......................................................................... 209

Ptla while (true) .................................................................................................... 212

Implementacja ptli do...while ................................................................................. 213

Uywanie ptli do...while ............................................................................................ 214

Ptle for .............................................................................................................................. 216

Zaawansowane ptle for ...................................................................................... 219

Puste ptle for .......................................................................................................... 222

Ptle zagniedone ................................................................................................. 223

Zakres zmiennych w ptlach for ...................................................................... 225

background image

8

C++ dla kadego

Podsumowanie ptli ......................................................................................................226

Sterowanie przebiegiem dziaania programu

za pomoc instrukcji switch ...................................................................................229

Uycie instrukcji switch w menu ......................................................................232

Podsumowanie ................................................................................................................236

Pytania i odpowiedzi .....................................................................................................236

Warsztaty ...........................................................................................................................237

Quiz ................................................................................................................................238

wiczenia ....................................................................................................................238

Lekcja 8. Wskaniki

241

Czym jest wskanik? .....................................................................................................241

Kilka sów na temat pamici ...............................................................................241

Uycie operatora adresu zmiennej w pamici (&) ...................................242

Przechowywanie adresu zmiennej we wskaniku ...................................244

Nazwy wskaników ................................................................................................244

Pobranie wartoci ze zmiennej .........................................................................245

Dereferencja za pomoc operatora wyuskania ........................................246

Wskaniki, adresy i zmienne ..............................................................................247

Operowanie danymi poprzez wskaniki .......................................................248

Sprawdzanie adresu ...............................................................................................250

Nazwy wskaników i tablic .................................................................................252

Wskanik do tablicy kontra tablica wskaników ......................................254

Do czego su wskaniki? .........................................................................................255

Stos i sterta ........................................................................................................................255

Alokacja pamici za pomoc sowa kluczowego new .............................257

Zwalnianie pamici: sowo kluczowe delete ...............................................258

Inne spojrzenie na wycieki pamici .......................................................................260

Tworzenie obiektów na stercie ................................................................................261

Usuwanie obiektów ze sterty ....................................................................................261

Utracone wskaniki .......................................................................................................263

Wskaniki const ..............................................................................................................267

Podsumowanie ................................................................................................................268

Pytania i odpowiedzi .....................................................................................................268

Warsztaty ...........................................................................................................................269

Quiz ................................................................................................................................269

wiczenia ....................................................................................................................269

background image

Spis

treci

9

Lekcja 9. Referencje

271

Czym jest referencja? ................................................................................................... 271

Uycie operatora adresu (&) z referencj ........................................................... 273

Nie mona zmienia przypisania referencji ................................................ 275

Zerowe wskaniki i zerowe referencje ................................................................. 276

Przekazywanie argumentów funkcji przez referencj .................................. 277

Tworzenie funkcji swap() otrzymujcej wskaniki ................................. 279

Implementacja funkcji swap() za pomoc referencji .............................. 281

Zwracanie kilku wartoci ........................................................................................... 283

Zwracanie wartoci przez referencj ............................................................. 285

Przekazywanie przez referencj zwiksza efektywno

dziaania programu .................................................................................................... 286

Przekazywanie wskanika const ...................................................................... 290

Referencje jako metoda alternatywna ........................................................... 293

Kiedy uywa wskaników, a kiedy referencji ................................................. 295

czenie referencji i wskaników ........................................................................... 296

Zwracanie referencji do obiektu, którego nie ma w zakresie .................... 298

Problem zwizany ze zwracaniem referencji do obiektu na stercie ........ 299

Podsumowanie ................................................................................................................ 301

Pytania i odpowiedzi .................................................................................................... 301

Warsztaty .......................................................................................................................... 302

Quiz ............................................................................................................................... 302

wiczenia .................................................................................................................... 302

Cz II Podstawy programowania

zorientowanego obiektowo i C++

Lekcja 10. Klasy i obiekty

307

Czy C++ jest zorientowane obiektowo? ............................................................... 307

Tworzenie nowych typów .......................................................................................... 309

Wprowadzenie klas i elementów skadowych ................................................. 310

Deklarowanie klasy ................................................................................................ 311

Kilka sów o konwencji nazw ............................................................................ 311

Definiowanie obiektu ............................................................................................ 313

Klasy a obiekty ......................................................................................................... 313

Dostp do elementów skadowych klasy ............................................................ 313

Przypisywa naley obiektom, nie klasom .................................................. 314

Czego nie zadeklarujesz, tego klasa nie bdzie miaa ............................. 314

background image

10

C++ dla kadego

Dostp prywatny i publiczny ....................................................................................315

Oznaczanie danych skadowych jako prywatnych ...................................317

Implementowanie metod klasy ................................................................................321

Konstruktory i destruktory ........................................................................................324

Domylne konstruktory i destruktory ...........................................................325

Uycie domylnego konstruktora ....................................................................326

Funkcje skadowe const ..............................................................................................329

Gdzie umieszcza deklaracje klasy i definicje metod .....................................331

Implementacja inline ....................................................................................................332

Klasy, których danymi skadowymi s inne klasy ...........................................335

Struktury ............................................................................................................................340

Podsumowanie ................................................................................................................340

Pytania i odpowiedzi .....................................................................................................341

Warsztaty ...........................................................................................................................343

Quiz ................................................................................................................................343

wiczenia ....................................................................................................................343

Lekcja 11. Dziedziczenie

345

Czym jest dziedziczenie? .............................................................................................345

Dziedziczenie i wyprowadzanie ........................................................................346

Królestwo zwierzt .................................................................................................347

Skadnia wyprowadzania .....................................................................................348

Prywatne kontra chronione .......................................................................................350

Dziedziczenie oraz konstruktory i destruktory ................................................353

Przekazywanie argumentów do konstruktorów bazowych .................355

Przesanianie funkcji klasy bazowej ......................................................................360

Ukrywanie metod klasy bazowej ......................................................................363

Wywoywanie metod klasy bazowej ..............................................................365

Metody wirtualne ...........................................................................................................367

Jak dziaaj funkcje wirtualne ............................................................................372

Próba uzyskania dostpu do metod klasy bazowej ..................................373

Okrajanie .....................................................................................................................374

Tworzenie destruktorów wirtualnych ...........................................................377

Wirtualne konstruktory kopiujce ..................................................................377

Koszt metod wirtualnych .....................................................................................381

Dziedziczenie prywatne ..............................................................................................381

Uywanie dziedziczenia prywatnego .............................................................382

Dziedziczenie prywatne kontra agregacja (zoenie) .............................384

background image

Spis

treci

11

Podsumowanie ................................................................................................................ 385

Pytania i odpowiedzi .................................................................................................... 386

Warsztaty .......................................................................................................................... 387

Quiz ............................................................................................................................... 387

wiczenia .................................................................................................................... 388

Lekcja 12. Polimorfizm

389

Problemy z pojedynczym dziedziczeniem .......................................................... 389

Przenoszenie w gór .............................................................................................. 392

Rzutowanie w dó ................................................................................................... 393

Poczenie dwóch list ............................................................................................ 396

Dziedziczenie wielokrotne ......................................................................................... 397

Czci obiektu z dziedziczeniem wielokrotnym ....................................... 401

Konstruktory w obiektach dziedziczonych wielokrotnie ..................... 402

Eliminowanie niejednoznacznoci .................................................................. 405

Dziedziczenie ze wspólnej klasy bazowej .................................................... 406

Dziedziczenie wirtualne ....................................................................................... 410

Problemy z dziedziczeniem wielokrotnym ................................................. 415

Mixiny i klasy metod .............................................................................................. 415

Abstrakcyjne typy danych .......................................................................................... 416

Czyste funkcje wirtualne ..................................................................................... 420

Implementowanie czystych funkcji wirtualnych ...................................... 422

Zoone hierarchie abstrakcji ............................................................................ 426

Które typy s abstrakcyjne? ............................................................................... 430

Podsumowanie ................................................................................................................ 430

Pytania i odpowiedzi .................................................................................................... 431

Warsztaty .......................................................................................................................... 432

Quiz ............................................................................................................................... 432

wiczenia .................................................................................................................... 433

Lekcja 13. Typy operatorów i przecianie operatorów

435

Czym s operatory w C++? ......................................................................................... 435

Operatory jednoargumentowe ................................................................................ 436

Typy operatorów jednoargumentowych ..................................................... 437

Programowanie jednoargumentowego operatora inkrementacji

i dekrementacji ...................................................................................................... 437

background image

12

C++ dla kadego

Programowanie operatora dereferencji *

i operatora wyboru elementu skadowego -> ...............................................441

Programowanie operatorów konwersji ........................................................444

Operatory dwuargumentowe ...................................................................................446

Typy operatorów dwuargumentowych .........................................................446

Programowanie operatorów dodawania (a+b) i odejmowania (a-b) .......447

Programowanie operatorów dodawania/przypisania

i odejmowania/przypisania .............................................................................450

Przecianie operatorów porównywania ....................................................452

Przecianie operatorów <, >, <= i >= ............................................................456

Operatory indeksowania ......................................................................................459

Funkcja operator() .........................................................................................................462

Operatory, których nie mona ponownie zdefiniowa ..................................463

Podsumowanie ................................................................................................................464

Pytania i odpowiedzi .....................................................................................................464

Warsztaty ...........................................................................................................................465

Quiz ................................................................................................................................465

wiczenia ....................................................................................................................465

Lekcja 14. Operatory rzutowania

467

Co to jest rzutowanie? ..................................................................................................467

Kiedy zachodzi potrzeba rzutowania? ..................................................................467

Dlaczego rzutowanie w stylu C nie jest popularne

wród niektórych programistów C++? ..............................................................468

Operatory rzutowania C++ .........................................................................................469

Uycie static_cast .....................................................................................................470

Uycie dynamic_cast i identyfikacja typu w czasie dziaania ...............471

Uycie reinterpret_cast .........................................................................................474

Uycie const_cast .....................................................................................................475

Problemy z operatorami rzutowania C++ ..............................................................476

Podsumowanie ................................................................................................................477

Pytania i odpowiedzi .....................................................................................................477

Warsztaty ...........................................................................................................................478

Quiz ................................................................................................................................478

Lekcja 15. Wprowadzenie do makr i wzorców

481

Preprocesor i kompilator ............................................................................................481

Dyrektywa #define preprocesora ...........................................................................482

background image

Spis

treci

13

Funkcje makro ................................................................................................................. 482

Po co te wszystkie nawiasy? .............................................................................. 484

W jaki sposób makra i sabe bezpieczestwo typów

id rka w rk? .................................................................................................... 485

Makra a funkcje i wzorce ..................................................................................... 486

Funkcje inline ........................................................................................................... 486

Wprowadzenie do wzorców ..................................................................................... 488

Skadnia deklaracji wzorca ................................................................................. 489

Róne rodzaje deklaracji wzorca ..................................................................... 490

Klasy wzorca ............................................................................................................. 490

Ustanawianie i specjalizacja wzorca .............................................................. 491

Wzorce i bezpieczestwo typów ...................................................................... 492

Deklarowanie wzorców z wieloma parametrami .................................... 492

Deklarowanie wzorców z parametrami domylnymi ............................ 493

Przykad wzorca ...................................................................................................... 493

Uycie wzorców w praktycznym programowaniu C++ ......................... 495

Podsumowanie ................................................................................................................ 496

Pytania i odpowiedzi .................................................................................................... 496

Warsztaty .......................................................................................................................... 498

Quiz ............................................................................................................................... 498

wiczenia .................................................................................................................... 498

Cz III Poznajemy standardow bibliotek

wzorców (STL)

Lekcja 16. Wprowadzenie do standardowej biblioteki wzorców

501

Kontenery STL ................................................................................................................. 501

Kontenery sekwencyjne ....................................................................................... 501

Kontenery asocjacyjne .......................................................................................... 502

Wybór odpowiedniego kontenera ................................................................... 503

Iteratory STL .................................................................................................................... 503

Algorytmy STL ................................................................................................................. 506

Oddziaywania midzy kontenerami i algorytmami

za pomoc iteratorów ............................................................................................... 507

Podsumowanie ................................................................................................................ 509

Pytania i odpowiedzi .................................................................................................... 510

Warsztaty .......................................................................................................................... 510

Quiz ............................................................................................................................... 511

background image

14

C++ dla kadego

Lekcja 17. Klasa string w STL

513

Potrzeba powstania klasy sucej do manipulowania cigami

tekstowymi .....................................................................................................................513

Praca z klas STL string ...............................................................................................515

Ustanawianie obiektu STL string i tworzenie kopii .................................515

Uzyskanie dostpu do obiektu string i jego zawartoci .........................518

czenie cigów tekstowych ..............................................................................520

Wyszukiwanie znaku bd podcigu tekstowego w obiekcie string .....521

Skracanie obiektu STL string ..............................................................................523

Odwracanie zawartoci cigu tekstowego ...................................................525

Konwersja wielkoci znaków obiektu string .................................................526

Bazujca na wzorcach implementacja klasy STL string ................................528

Podsumowanie ................................................................................................................528

Pytania i odpowiedzi .....................................................................................................529

Warsztaty ...........................................................................................................................529

Quiz ................................................................................................................................529

wiczenia ....................................................................................................................530

Lekcja 18. Dynamiczne klasy tablic w STL

531

Charakterystyka klasy std::vector ..........................................................................531

Typowe operacje klasy vector ..................................................................................532

Ustanawianie klasy vector ...................................................................................532

Wstawianie elementów do obiektu vector ..................................................533

Uzyskanie dostpu do elementów obiektu vector ....................................538

Usuwanie elementów z obiektu vector ..........................................................541

Zrozumienie funkcji size() i capacity() .................................................................542

Klasa STL deque ..............................................................................................................545

Podsumowanie ................................................................................................................547

Pytania i odpowiedzi .....................................................................................................547

Warsztaty ...........................................................................................................................548

Quiz ................................................................................................................................549

wiczenia ....................................................................................................................549

Lekcja 19. Klasa STL list

551

Charakterystyka klasy std::list .................................................................................551

Podstawowe operacje klasy list ...............................................................................552

Ustanawianie obiektu std::list ...........................................................................552

Wstawianie elementów na pocztku obiektu list .....................................552

background image

Spis

treci

15

Wstawianie elementów na kocu obiektu list ........................................... 554

Wstawianie elementów w rodku obiektu list .......................................... 555

Usuwanie elementów w obiekcie list ............................................................. 558

Odwrócenie i sortowanie elementów w obiekcie list .................................... 560

Odwracanie elementów ....................................................................................... 561

Sortowanie elementów ........................................................................................ 562

Podsumowanie ................................................................................................................ 573

Pytania i odpowiedzi .................................................................................................... 573

Warsztaty .......................................................................................................................... 574

Quiz ............................................................................................................................... 574

wiczenia .................................................................................................................... 574

Lekcja 20. Klasy STL set i multiset

575

Wprowadzenie ................................................................................................................ 575

Podstawowe operacje klas STL set i multiset ................................................... 576

Ustanawianie obiektu std::set ........................................................................... 576

Wstawianie elementów do obiektu set lub multiset ............................... 577

Wyszukiwanie elementów w obiekcie STL set lub multiset ................ 579

Usuwanie elementów z obiektu STL set lub multiset ............................. 581

Wady i zalety uywania obiektów STL set i multiset ..................................... 592

Podsumowanie ................................................................................................................ 592

Pytania i odpowiedzi .................................................................................................... 592

Warsztaty .......................................................................................................................... 593

Quiz ............................................................................................................................... 593

wiczenia .................................................................................................................... 594

Lekcja 21. Klasy STL map i multimap

595

Krótkie wprowadzenie ................................................................................................ 595

Podstawowe operacje klas STL map i multimap ............................................. 596

Ustanawianie obiektu std::map ........................................................................ 596

Wstawianie elementów do obiektu STL map lub multimap ................ 597

Wyszukiwanie elementów w obiekcie STL map lub multimap .......... 600

Usuwanie elementów z obiektu STL map lub multimap ....................... 602

Dostarczanie wasnego predykatu sortowania ................................................ 606

Podsumowanie ................................................................................................................ 610

Pytania i odpowiedzi .................................................................................................... 610

Warsztaty .......................................................................................................................... 611

Quiz ............................................................................................................................... 612

wiczenia .................................................................................................................... 612

background image

16

C++ dla kadego

Cz IV Jeszcze wicej STL

Lekcja 22. Zrozumienie obiektów funkcji

615

Koncepcja obiektów funkcji i predykatów .............................................................615

Typowe aplikacje obiektów funkcji ........................................................................616

Funkcje jednoargumentowe ...............................................................................616

Predykat jednoargumentowy ............................................................................621

Funkcje dwuargumentowe .................................................................................623

Predykat dwuargumentowy ...............................................................................626

Podsumowanie ................................................................................................................629

Pytania i odpowiedzi .....................................................................................................629

Warsztaty ...........................................................................................................................630

Quiz ................................................................................................................................630

wiczenia ....................................................................................................................630

Lekcja 23. Algorytmy STL

631

Co to s algorytmy STL? ...............................................................................................631

Klasyfikacja algorytmów STL ....................................................................................631

Algorytmy niezmienne ..........................................................................................632

Algorytmy zmienne ................................................................................................633

Uywanie algorytmów STL ........................................................................................636

Zliczanie i znajdowanie elementów ................................................................636

Wyszukiwanie elementu lub zakresu w kolekcji .......................................639

Inicjalizacja elementów w kontenerze wraz

z okrelonymi wartociami ..............................................................................642

Przetwarzanie elementów w zakresie za pomoc for_each .................645

Przeprowadzanie transformacji zakresu

za pomoc std::transform .................................................................................647

Operacje kopiowania i usuwania ......................................................................650

Zastpowanie wartoci oraz zastpowanie elementu

na podstawie danego warunku ......................................................................654

Sortowanie i przeszukiwanie posortowanej kolekcji oraz

usuwanie duplikatów ..........................................................................................656

Partycjonowanie zakresu .....................................................................................659

Wstawianie elementów do posortowanej kolekcji ...................................661

Podsumowanie ................................................................................................................664

Pytania i odpowiedzi .....................................................................................................664

background image

Spis

treci

17

Warsztaty .......................................................................................................................... 665

Quiz ............................................................................................................................... 665

wiczenia .................................................................................................................... 666

Lekcja 24. Kontenery adaptacyjne: stack i queue

667

Cechy charakterystyczne zachowania stosów i kolejek ............................... 667

Stosy .............................................................................................................................. 667

Kolejki .......................................................................................................................... 668

Uywanie klasy STL stack .......................................................................................... 668

Ustanawianie obiektu stack ............................................................................... 669

Funkcje skadowe klasy stack ........................................................................... 670

Uywanie klasy STL queue ........................................................................................ 672

Ustanawianie obiektu queue ............................................................................. 673

Funkcje skadowe klasy queue ......................................................................... 674

Uywanie klasy STL priority_queue ...................................................................... 676

Ustanawianie obiektu priority_queue ........................................................... 677

Funkcje skadowe klasy priority_queue ....................................................... 678

Podsumowanie ................................................................................................................ 682

Pytania i odpowiedzi .................................................................................................... 682

Warsztaty .......................................................................................................................... 682

Quiz ............................................................................................................................... 682

wiczenia .................................................................................................................... 683

Lekcja 25. Praca z opcjami bitowymi za pomoc STL

685

Klasa bitset ........................................................................................................................ 685

Ustanowienie klasy std::bitset .......................................................................... 685

Uywanie klasy std::bitset i jej elementów skadowych .............................. 687

Operatory std::bitset ............................................................................................. 687

Metody skadowe klasy std::bitset .................................................................. 687

Klasa vector<bool> ........................................................................................................ 691

Ustanowienie klasy vector<bool> ................................................................... 691

Uywanie klasy vector<bool> ........................................................................... 692

Podsumowanie ................................................................................................................ 693

Pytania i odpowiedzi .................................................................................................... 694

Warsztaty .......................................................................................................................... 694

Quiz ............................................................................................................................... 695

wiczenia .................................................................................................................... 695

background image

18

C++ dla kadego

Cz V Zaawansowane koncepcje C++

Lekcja 26. Sprytne wskaniki

699

Czym s sprytne wskaniki? ......................................................................................699

Na czym polega problem zwizany z uywaniem

wskaników konwencjonalnych? ..................................................................700

W jaki sposób sprytne wskaniki mog pomóc? .......................................701

W jaki sposób s implementowane sprytne wskaniki? ..............................701

Typy sprytnych wskaników ....................................................................................703

Kopiowanie gbokie .............................................................................................704

Mechanizm kopiowania przy zapisie (COW) ..............................................706

Sprytne wskaniki zliczania odniesie ..........................................................706

Sprytne wskaniki powizane z licznikiem odniesie ............................707

Kopiowanie destrukcyjne ....................................................................................708

Uywanie klasy std::auto_ptr ....................................................................................710

Popularne biblioteki sprytnych wskaników ....................................................712

Podsumowanie ................................................................................................................713

Pytania i odpowiedzi .....................................................................................................713

Warsztaty ...........................................................................................................................714

Quiz ................................................................................................................................714

wiczenia ....................................................................................................................715

Lekcja 27. Strumienie

717

Przegld strumieni .........................................................................................................717

Hermetyzacja przepywu danych .....................................................................718

Buforowanie ..............................................................................................................719

Strumienie i bufory ........................................................................................................721

Standardowe obiekty wejcia-wyjcia ..................................................................722

Przekierowywanie standardowych strumieni ..................................................722

Wejcie z uyciem cin ...................................................................................................723

Wejciowe cigi tekstowe ....................................................................................725

Problemy z cigami tekstowymi .......................................................................725

Warto zwracana przez cin ...............................................................................728

Inne funkcje skadowe w dyspozycji cin ..............................................................729

Wprowadzanie pojedynczych znaków ..........................................................729

Odczytywanie cigów tekstowych z wejcia standardowego .............732

Uycie cin.ignore() ..................................................................................................735

Funkcje peek() oraz putback() ..........................................................................737

background image

Spis

treci

19

Wyjcie poprzez cout ................................................................................................... 738

Zrzucanie zawartoci bufora ............................................................................. 739

Funkcje obsugujce wyjcie .............................................................................. 739

Manipulatory, znaczniki oraz instrukcje formatowania ........................ 741

Strumienie kontra funkcja printf() ........................................................................ 747

Wejcie i wyjcie z uyciem plików ....................................................................... 751

ofstream ...................................................................................................................... 751

Stany strumieni ........................................................................................................ 751

Otwieranie plików dla wejcia i wyjcia ....................................................... 751

Zmiana domylnego zachowania obiektu ofstream

w trakcie otwierania pliku ............................................................................... 753

Pliki binarne a pliki tekstowe ................................................................................... 756

Przetwarzanie linii polecenia ................................................................................... 759

Podsumowanie ................................................................................................................ 763

Pytania i odpowiedzi .................................................................................................... 763

Warsztaty .......................................................................................................................... 764

Quiz ............................................................................................................................... 765

wiczenia .................................................................................................................... 765

Lekcja 28. Obsuga wyjtków

767

Pluskwy, bdy, pomyki i „psujcy si” kod ...................................................... 767

Sytuacje wyjtkowe ............................................................................................... 768

Wyjtki ................................................................................................................................ 770

Jak uywane s wyjtki ........................................................................................ 771

Zgaszanie wasnych wyjtków ........................................................................ 775

Tworzenie klasy wyjtku ..................................................................................... 777

Umiejscowienie bloków try oraz bloków catch ................................................ 781

Sposób dziaania przechwytywania wyjtków ................................................ 781

Wychwytywanie wicej ni jednego rodzaju wyjtków ........................ 782

Hierarchie wyjtków ............................................................................................. 785

Dane w wyjtkach oraz nazwane obiekty wyjtków ..................................... 789

Wyjtki i wzorce ............................................................................................................. 796

Wyjtki bez bdów ...................................................................................................... 799

Bdy i usuwanie bdów ........................................................................................... 800

Punkty wstrzymania .............................................................................................. 801

ledzenie wartoci zmiennych .......................................................................... 801

Sprawdzanie pamici ............................................................................................ 802

Asembler ..................................................................................................................... 802

background image

20

C++ dla kadego

Podsumowanie ................................................................................................................802

Pytania i odpowiedzi .....................................................................................................803

Warsztaty ...........................................................................................................................804

Quiz ................................................................................................................................804

wiczenia ....................................................................................................................805

Lekcja 29. Wicej informacji na temat preprocesora

807

Preprocesor i kompilator ............................................................................................807

Uycie dyrektywy #define ..........................................................................................808

Uycie #define dla staych ...................................................................................808

Uycie #define do testowania ............................................................................809

Dyrektywa #else preprocesora .........................................................................810

Doczanie i wartowniki doczania ......................................................................811

Manipulacje cigami tekstowymi ............................................................................813

Zamiana na cig tekstowy ....................................................................................813

Konkatenacja .............................................................................................................813

Makra predefiniowane .................................................................................................814

Makro assert() .................................................................................................................814

Debuggowanie za pomoc makra assert() ...................................................816

Makro assert() a wyjtki ......................................................................................817

Efekty uboczne .........................................................................................................817

Niezmienniki klas ....................................................................................................818

Wywietlanie wartoci tymczasowych ..........................................................824

Operacje na bitach ..........................................................................................................825

Operator AND ............................................................................................................826

Operator OR ...............................................................................................................826

Operator wyczajcy OR .....................................................................................827

Operator negacji .......................................................................................................827

Ustawianie bitów .....................................................................................................827

Zerowanie bitów ......................................................................................................828

Zmiana stanu bitów na przeciwny ...................................................................828

Pola bitowe .................................................................................................................829

Styl programowania ......................................................................................................832

Wcicia .........................................................................................................................833

Nawiasy klamrowe .................................................................................................833

Dugo linii oraz dugo funkcji ....................................................................833

Instrukcje switch .....................................................................................................834

background image

Spis

treci

21

Tekst programu ....................................................................................................... 834

Nazwy identyfikatorów ........................................................................................ 835

Pisownia nazw i zastosowanie w nich wielkich liter .............................. 836

Komentarze ............................................................................................................... 836

Konfiguracja dostpu ............................................................................................ 837

Definicje klas ............................................................................................................. 838

Doczanie plików .................................................................................................. 838

Uywanie makra assert() .................................................................................... 838

Uywanie modyfikatora const .......................................................................... 838

Nastpne kroki w programowaniu C++ ............................................................... 839

Gdzie uzyska pomoc i porad .......................................................................... 839

Tematy powizane z C++: rozszerzenie Managed C++, C#

oraz platforma .NET firmy Microsoft .......................................................... 840

Podsumowanie ................................................................................................................ 841

Pytania i odpowiedzi .................................................................................................... 841

Warsztaty .......................................................................................................................... 843

Quiz ............................................................................................................................... 843

wiczenia .................................................................................................................... 843

Dodatki

Dodatek A Praca z liczbami: dwójkowo i szesnastkowo

847

Inne podstawy ................................................................................................................. 848

Konwersja na inn podstaw ................................................................................... 849

Dwójkowo .................................................................................................................. 851

Dlaczego podstawa 2? ........................................................................................... 852

Bity, bajty, nible ....................................................................................................... 852

Co to jest KB? ............................................................................................................ 853

Liczby dwójkowe ..................................................................................................... 853

Szesnastkowo .................................................................................................................. 853

Dodatek B Sowa kluczowe C++

859

Dodatek C Kolejno operatorów

861

Dodatek D Odpowiedzi

863

Skorowidz 919

background image

Czy C++ jest zorientowane obiektowo?

307

Lekcja 10

Klasy i obiekty

Klasy rozszerzaj wbudowane w C++ moliwoci, uatwiajce rozwizywanie

zoonych, „rzeczywistych” problemów.

Z tej lekcji dowiesz si:

X

czym s klasy i obiekty,

X

jak definiowa now klas oraz tworzy obiekty tej klasy,

X

czym s funkcje i dane skadowe,

X

czym s konstruktory i jak z nich korzysta.

Czy C++ jest zorientowane obiektowo?

W pewnym momencie jzyk C, czyli poprzednik C++, by najpopularniejszym

jzykiem programowania na wiecie uywanym do tworzenia oprogramowania

komercyjnego. By wykorzystywany do tworzenia systemów operacyjnych

(na przykad systemu Unix), do tworzenia oprogramowania dziaajcego w czasie

rzeczywistym (kontrola maszyn, urzdze i elektroniki). Dopiero póniej zacz

by stosowany jako jzyk programowania sucy do budowy innych jzyków

konwencjonalnych. Opracowanie jzyka C pozwolio na znalezienie atwiejszego

i bezpieczniejszego sposobu zblienia oprogramowania i osprztu.

Jzyk C jest etapem porednim pomidzy wysokopoziomowymi jzykami aplikacji

„firmowych”, takimi jak COBOL, a niskopoziomowym, wysokowydajnym, lecz

trudnym do uycia asemblerem. C wymusza programowanie „strukturalne”,

w którym poszczególne zagadnienia s dzielone na mniejsze jednostki powtarzalnych

dziaa, zwanych funkcjami, natomiast dane s umieszczane w pakietach

nazywanych strukturami.

background image

308

Lekcja 10.

Klasy i obiekty

Jednak jzyki takie jak Smalltalk i CLU zaczy torowa drog w nowym kierunku

— programowania zorientowanego obiektowo. Ten rodzaj programowania

pozwala na umieszczanie w pojedynczej jednostce — obiekcie — podzespoów

danych takich jak struktura oraz funkcja.

wiat jest wypeniony przedmiotami: samochodami, psami, drzewami, chmurami,

kwiatami. Rzeczy. Kada rzecz ma charakterystyk (szybki, przyjazny, brzowy,

puszysty, adny). Wikszo rzeczy cechuje jakie zachowanie (ruch, szczekanie,

wzrost, deszcz, uwid). Nie mylimy o danych samochodu i o tym, jak moglibymy

nimi manipulowa — mylimy o samochodzie jako o rzeczy: do czego jest podobny

i co robi. Z tym samym moemy si zetkn po przeniesieniu do wiata komputerów

dowolnego „rzeczywistego” obiektu.

Programy, które piszemy na pocztku dwudziestego pierwszego wieku, s duo

bardziej zoone ni te, które byy pisane pod koniec wieku dwudziestego. Programy

stworzone w jzykach proceduralnych s trudne w zarzdzaniu i konserwacji,

a ich rozbudowa jest niemoliwa. Graficzne interfejsy uytkownika, Internet,

telefonia cyfrowa i bezprzewodowa oraz wiele innych technologii, znacznie

zwikszyy poziom skomplikowania nowych projektów, a wymagania

konsumentów dotyczce jakoci interfejsu uytkownika wzrosy.

Programowanie zorientowane obiektowo oferuje narzdzie pomagajce

w sprostaniu wyzwaniom stojcym przed twórcami oprogramowania. Chocia

nie istnieje zoty rodek dla tworzenia skomplikowanego oprogramowania,

jzyki zorientowane obiektowo stworzyy silne wizy pomidzy strukturami

danych a metodami manipulowania tymi danymi. Ponadto jeszcze bardziej zbliaj

si do sposobu mylenia ludzi (programistów i klientów), usprawniajc tym

samym komunikacj oraz poprawiajc jako tworzonego oprogramowania.

A co najwaniejsze, w programowaniu zorientowanym obiektowo nie musisz

ju myle o strukturach danych i manipulujcych nimi funkcjach; mylisz

o obiektach w taki sposób, jakby byy odpowiednikami obiektów w rzeczywistoci:

czyli jak one wygldaj i jak dziaaj.

Jzyk C++ stanowi pomost pomidzy programowaniem zorientowanym obiektowo

a jzykiem C. Celem jego autorów byo stworzenie obiektowo zorientowanego

jzyka dla tej szybkiej i efektywnej platformy sucej do tworzenia oprogramowania

komercyjnego, ze szczególnym naciskiem na wysok wydajno . W dalszej czci

lekcji przekonasz si, jak C++ osiga cele postawione przed jzykiem.

background image

Tworzenie nowych typów

309

Tworzenie nowych typów

Programy s zwykle pisane w celu rozwizania jakiego realnego problemu,

takiego jak prowadzenie rejestru pracowników czy symulacja dziaania systemu

grzewczego. Cho istnieje moliwo rozwizywania tych problemów za pomoc

programów napisanych wycznie przy uyciu liczb cakowitych i znaków, jednak

w przypadku wikszych, bardziej rozbudowanych problemów, duo atwiej jest

stworzy reprezentacje obiektów, o których si mówi. Innymi sowy, symulowanie

dziaania systemu grzewczego bdzie atwiejsze, gdy stworzymy zmienne

reprezentujce pomieszczenia, czujniki ciepa, termostaty i bojlery. Im bardziej

te zmienne odpowiadaj rzeczywistoci, tym atwiejsze jest napisanie programu.

Poznae ju kilka typów zmiennych, m.in. liczby cakowite i znaki. Typ zmiennej

dostarcza nam kilka informacji o niej. Na przykad, jeli zadeklarujesz zmienne

Height (wysoko ) i Width (szeroko ) jako liczby cakowite typu unsigned

short int, wiesz, e w kadej z nich moesz przechowa warto z przedziau od

0 do 65 535 (przy zaoeniu e typ unsigned short int zajmuje dwa bajty pamici).

S to liczby cakowite bez znaku; próba przechowania w nich czegokolwiek

innego powoduje bd. W zmiennej typu unsigned short nie moesz umieci

swojego imienia, nie powiniene nawet próbowa .

Deklarujc te zmienne jako unsigned short int, wiesz, e moesz doda do

siebie wysoko i szeroko oraz przypisa t warto innej zmiennej.

Typ zmiennych informuje:

X

o ich rozmiarze w pamici,

X

jaki rodzaj informacji mog zawiera ,

X

jakie dziaania mona na nich wykonywa .

W tradycyjnych jzykach, takich jak C, typy byy wbudowane w jzyk. W C++

programista moe rozszerzy jzyk, tworzc potrzebne mu typy, za kady z tych

nowych typów moe by w peni funkcjonalny i dysponowa t sam si, co typy

wbudowane.

Wady tworzenia typów za pomoc sowa kluczowego struct

Pewne moliwoci rozszerzenia jzyka C nowymi typami wi si z czeniem
w struktury (

struct

) powizanych ze sob zmiennych, które mog by dostpne

w postaci nowego typu danych za pomoc instrukcji

typedef

. Jednak istniej

pewne wady takiego podejcia:

background image

310

Lekcja 10.

Klasy i obiekty

X

Struktury i operujce na nich funkcje nie s spójnymi caociami. Funkcje
mona znale jedynie poprzez odczyt plików nagówkowych z dostpnych
bibliotek i wyszukanie tych z nowym typem jako parametrem.

X

Koordynacja aktywnoci grupy powizanych funkcji w strukturze jest trudniejszym
zadaniem, poniewa dowolny fragment logiki programu moe w dowolnej
chwili zmieni cokolwiek w strukturze. Z tego powodu nie ma moliwoci
ochrony struktury przed ingerencj.

X

Wbudowane operatory nie dziaaj ze strukturami — nie dziaa nawet
dodanie dwóch struktur za pomoc znaku plus (+), cho taka operacja
mogaby si wydawa najbardziej naturalnym sposobem przedstawienia
rozwizania problemu (na przykad, kiedy kada struktura przedstawia
skomplikowane fragmenty tekstu, które maj by ze sob poczone).

Wprowadzenie klas
i elementów skadowych

Nowy typ zmiennych tworzy si, deklarujc klas. Klasa jest waciwie grup

zmiennych — czsto o rónych typach — skojarzonych z zestawem odnoszcych

si do nich funkcji.

Jedn z moliwoci mylenia o samochodzie jest potraktowanie go jako zbioru

kó, drzwi, foteli, okien itd. Inna moliwo to wyobraenie sobie, co samochód

moe zrobi : jedzi , przyspiesza , zwalnia , zatrzymywa si, parkowa itd.

Klasa umoliwia hermetyzacj, czyli upakowanie, tych rónych czci oraz

rónych dziaa w jeden zbiór, który jest nazywany obiektem.

Upakowanie wszystkiego, co wiesz o samochodzie, w jedn klas przynosi

programicie liczne korzyci. Wszystko jest na miejscu, uatwia to odwoywanie si,

kopiowanie i manipulowanie danymi. Klienci Twojej klasy — tj. te czci programu,

które z niej korzystaj — mog uywa Twojego obiektu bez zastanawiania si,

co znajduje si w rodku i jak on dziaa.

Klasa moe skada si z dowolnej kombinacji zmiennych prostych oraz zmiennych

innych klas. Zmienna wewntrz klasy jest nazywana zmiennskadow lub

danskadow. Klasa Car (samochód) moe posiada skadowe reprezentujce

siedzenia, typ radia, opony itd. Zmienne skadowe s zmiennymi w danej klasie.

Stanowi one cz klasy, tak jak koa i silnik stanowi cz samochodu.

background image

Wprowadzenie klas i elementów skadowych

311

Klasa moe zawiera równie funkcje, które s wówczas nazywane funkcjami

skadowymi lub metodami. Podobnie jak zmienne skadowe, stanowi cz

klasy i okrelaj, co dana klasa moe zrobi .

Funkcje w danej klasie zwykle manipuluj zmiennymi skadowymi. Przykadowo,

metodami klasy Car mog by Start() (uruchom) oraz Brake() (hamuj). Klasa Cat

(kot) moe posiada zmienne skadowe, reprezentujce wiek i wag; jej metodami

mog by Sleep() (pij), Meow() (miaucz) czy ChaseMice() (ap myszy).

Deklarowanie klasy

Deklaracja klasy informuje kompilator o jej istnieniu. Aby zadeklarowa klas,

uyj sowa kluczowego class, po którym nastpuje otwierajcy nawias klamrowy,

a nastpnie lista danych skadowych i metod tej klasy. Deklaracja koczy si

zamykajcym nawiasem klamrowym i rednikiem. Oto deklaracja klasy o nazwie

Cat (kot):

class Cat
{
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};

Zadeklarowanie takiej klasy nie powoduje zaalokowania pamici dla obiektu Cat.

Informuje jedynie kompilator, czym jest typ Cat, jakie dane zawiera (itsAge

— jego wiek oraz itsWeight — jego waga) oraz co moe robi (Meow() — miaucz).

Informuje take kompilator, jak dua jest zmienna typu Cat — to jest, jak duo

miejsca w pamici ma przygotowa w przypadku tworzenia zmiennej typu Cat.

W tym przykadzie, o ile typ int ma cztery bajty, zmienna typu Cat zajmuje osiem

bajtów: cztery bajty dla zmiennej itsAge i cztery dla zmiennej itsWeight.

Funkcja Meow() nie zajmuje miejsca, gdy dla funkcji skadowych (metod)

miejsce nie jest rezerwowane. Jest to wskanik do funkcji, który na platformie

32-bitowej moe zaj cztery bajty.

Kilka sów o konwencji nazw

Jako programista, musisz nazwa wszystkie swoje zmienne skadowe, funkcje

skadowe oraz klasy. Jak przeczytae w lekcji 3., „Stae i zmienne”, nazwy te

powinny by zrozumiae i znaczce. Dobrymi nazwami klas mog by wspomniana

background image

312

Lekcja 10.

Klasy i obiekty

Cat, Rectangle (prostokt) czy Employee (pracownik). Meow(), ChaseMice()

czy StopEngine() (zatrzymaj silnik) równie s dobrymi nazwami funkcji, gdy

informuj, co robi te funkcje. Wielu programistów nadaje nazwom zmiennych

skadowych przedrostek „its” (jego), tak jak w zmiennych itsAge, itsWeight

czy itsSpeed (jego szybko ). Pomaga to w odrónieniu zmiennych skadowych

od innych zmiennych.

Niektórzy programici wol przedrostek „my” (mój), tak jak w nazwach myAge,

myWeight czy mySpeed. Jeszcze inni uywaj po prostu litery m (od sowa member

— skadowa), czasem wraz ze znakiem podkrelenia (_): mAge i m_age, mWeight

i m_weight czy mSpeed i m_speed.

Niektórzy programici lubi poprzedzi kad nazw klasy okrelon liter

— na przykad cCat czy cPerson — podczas, gdy inni uywaj wycznie duych

lub maych liter. Ja sam korzystam z konwencji, w której wszystkie nazwy klas

rozpoczynaj si od duej litery, tak jak Cat czy Person (osoba).

Wielu programistów rozpoczyna wszystkie nazwy funkcji od duej litery, za

wszystkie nazwy zmiennych — od maej. Sowa zwykle rozdzielane s znakiem

podkrelenia — tak jak w Chase_Mice — lub poprzez zastosowanie duej litery

dla kadego sowa — na przykad ChaseMice czy DrawCircle (rysuj okrg).

Wane jest, by wybra okrelony styl i trzyma si go w kadym programie.

Z czasem rozwiniesz swój styl nie tylko na konwencje nazw, ale take na wcicia,

wyrównanie nawiasów klamrowych oraz styl komentarzy.

W firmach programistycznych powszechne jest okrelenie standardu wielu
elementów stylu zapisu kodu ródowego. Sprawia on, e wszyscy programici
mog atwo odczytywa wzajemnie swój kod. Niestety, przenosi si to równie do
firm opracowujcych systemy operacyjne i biblioteki klas przeznaczonych do
ponownego uytku. Zazwyczaj oznacza to, e w programach C++ jest jednoczenie
stosowanych wiele rónych konwencji nazw.

Jak ju wczeniej wspomniano, jzyk C++ uwzgldnia wielko liter, dlatego
wszystkie nazwy klas powinny przestrzega tej samej konwencji. Dziki temu nigdy
nie bdziesz musia sprawdza pisowni nazwy klasy (czy to byo Rectangle,

rectangle

czy RECTANGLE?).

background image

Dostp do elementów skadowych klasy

313

Definiowanie obiektu

Po zadeklarowaniu klasy mona jej nastpnie uywa jako nowego typu dla

definiowanych zmiennych tego typu. Definiowanie obiektu nowego typu

przypomina definiowanie zmiennej cakowitej:

unsigned int GrossWeight; // definicja zmiennej typu unsigned int
Cat Frisky; // definicja zmiennej typu Cat

Ten kod definiuje zmienn o nazwie GrossWeight (czna waga), której typem

jest unsigned int. Oprócz tego definiuje zmienn o nazwie Frisky, która jest

obiektem klasy (typu) Cat.

Klasy a obiekty

Nigdy nie karmi si definicji kota, lecz konkretnego kota. Naley dokona

rozrónienia pomidzy ide kota a konkretnym kotem, który wanie ociera si

o Twoje nogi. C++ równie dokonuje rozrónienia pomidzy klas Cat, bdc

ide kota, a poszczególnymi obiektami typu Cat. Tak wic Frisky jest obiektem

typu Cat, tak jak GrossWeight jest zmienn typu unsigned int. Obiekt jest

indywidualnym egzemplarzem klasy.

Dostp do elementów skadowych klasy

Gdy zdefiniujesz ju faktyczny obiekt Cat — na przykad:

Cat Frisky;

w celu uzyskania dostpu do jego skadowych moesz uy operatora kropki (.).

Aby zmiennej skadowej itsWeight obiektu Frisky przypisa warto 50,

powiniene napisa :

Frisky.itsWeight = 50;

Aby wywoa funkcj Meow(), moesz napisa :

Frisky.Meow();

Gdy uywasz metody klasy, oznacza to, e wywoujesz t metod. W tym

przykadzie wywoae metod Meow() obiektu Frisky.

background image

314

Lekcja 10.

Klasy i obiekty

Przypisywa naley obiektom, nie klasom

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

nie mona napisa :

int = 5; // le

Kompilator uzna to za bd, gdy nie mona przypisa wartoci pi typowi

cakowitemu. Zamiast tego musisz zdefiniowa zmienn typu cakowitego

i przypisa jej warto 5. Na przykad:

int x ; // definicja zmiennej typu int
x = 5; // ustawienie wartoci zmiennej x na 5

Jest to skrócony zapis stwierdzenia: „Przypisz warto 5 zmiennej x, która jest

zmienn typu int”. Nie mona równie napisa :

Cat.itsAge = 5; // le

Kompilator uzna to za bd, gdy nie moesz przypisa wartoci 5 do elementu

itsAge klasy Cat. Zamiast tego musisz zdefiniowa egzemplarz obiektu klasy

Cat i dopiero wtedy przypisa warto jego skadowej. Na przykad:

Cat Frisky; // podobnie jak int x;
Frisky.itsAge = 5; // podobnie jak x = 5;

Czego nie zadeklarujesz,
tego klasa nie bdzie miaa

Przeprowad taki eksperyment: podejd do trzylatka i poka mu kota. Nastpnie

powiedz: To jest Frisky. Frisky zna sztuczk. Frisky, zaszczekaj! Dziecko rozemieje

si i powie: „Nie, guptasie, koty nie szczekaj!”.

Jeli napisae:

Cat Frisky; // tworzy obiekt Cat o nazwie Frisky
Frisky.Bark(); // nakazuje Friskiemu szczeka

Kompilator wywietli komunikat: „Nie, guptasie, koty (cats) nie szczekaj!”.

(By moe w Twoim kompilatorze ten komunikat bdzie brzmia nieco inaczej).

Kompilator wie, e Frisky nie moe szczeka , gdy klasa Cat nie posiada metody

Bark() (szczekaj). Kompilator nie pozwoli Friskiemu nawet zamiaucze , jeli nie

zdefiniujesz dla niego funkcji Meow() (miaucz).

background image

Dostp prywatny i publiczny

315

Tak

Nie

Do deklarowania klasy uywaj sowa
kluczowego class.

W celu uzyskania dostpu do zmiennych
i funkcji skadowych klasy uywaj
operatora kropki (.).

Nie myl deklaracji z definicj. Deklaracja
mówi czym jest klasa, a definicja
przygotowuje pami dla obiektu.

Nie myl klasy z obiektem.

Nie przypisuj klasie wartoci. Wartoci
przypisuj danym skadowym obiektu.

Dostp prywatny i publiczny

W deklaracji klasy uywanych jest take kilka innych sów kluczowych. Dwa

najwaniejsze z nich to: public (publiczny) i private (prywatny).

Sowa kluczowe private i public s uywane wraz z egzemplarzami klasy

— zarówno ze zmiennymi skadowymi, jak i metodami klasy. Prywatne skadowe

mog by uywane tylko przez metody nalece do danej klasy. Skadowe

publiczne s dostpne dla innych funkcji i klas. To rozrónienie jest wane, cho

na pocztku moe sprawia kopot. Wszystkie skadowe klasy — dane i metody

— s domylnie prywatne. Aby to lepiej wyjani , spójrzmy na poprzedni przykad:

class Cat
{
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};

W tej deklaracji, skadowe itsAge, itsWeight oraz Meow() s prywatne, gdy

wszystkie skadowe klasy s prywatne domylnie. Oznacza to, e dopóki nie

postanowisz inaczej, pozostan one prywatne. Jeli jednak w funkcji main()

napiszesz na przykad:

Cat Bobas;
Bobas.itsAge = 5; // bd! nie mona uywa prywatnych danych!

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

e skadowych itsAge, itsWeight oraz Meow() bdziesz uywa tylko w funkcjach

skadowych klasy Cat. W powyszym fragmencie kodu próbujesz odwoa si

do zmiennej skadowej obiektu Bobas spoza metody klasy Cat. To, e Bobas jest

obiektem klasy Cat, nie oznacza, e moesz korzysta z tych elementów obiektu

Bobas, które s prywatne.

background image

316

Lekcja 10.

Klasy i obiekty

Wanie to jest ródem niekoczcych si kopotów pocztkujcych programistów

C++. Ju sysz, jak narzekasz: „Hej! Wanie napisaem, e Bobas jest kotem, tj.

obiektem klasy Cat. Dlaczego Bobas nie ma dostpu do swojego wasnego wieku?”.

Odpowied brzmi: Bobas ma dostp, ale Ty nie masz. Bobas, w swoich wasnych

metodach, ma dostp do wszystkich swoich skadowych, zarówno publicznych,

jak i prywatnych. Nawet jeli to Ty tworzysz obiekt klasy Cat, nie moesz

przeglda ani zmienia tych jego skadowych, które s prywatne.

Aby mie dostp do skadowych obiektu Cat, pewne elementy skadowe powinny

by publiczne:

class Cat
{
public:
unsigned int itsAge;
unsigned int itsWeight;
void Meow();
};

Teraz skadowe itsAge, itsWeight oraz Meow() s publiczne. Bobas.itsAge = 5;

kompiluje si bez problemów.

Sowo kluczowe public ma zastosowanie wzgldem wszystkich elementów
skadowych w danej deklaracji a do napotkania sowa kluczowego private i na
odwrót. W ten sposób sekcje klasy mona bardzo atwo zadeklarowa jako
publiczne bd prywatne.

Listing 10.1 przedstawia deklaracj klasy Cat z publicznymi zmiennymi skadowymi.

Listing 10.1. Dostp do publicznych skadowych w prostej klasie

1: // Demonstruje deklaracj klasy oraz
2: // definicje obiektu tej klasy.
3:
4: #include <iostream>
5:
6: class Cat // deklaruj klas Cat (kot)
7: {
8: public: // nastpujce po tym skadowe s publiczne
9: int itsAge; // zmienna skadowa
10: int itsWeight; // zmienna skadowa
11: }; // zwró uwag na rednik
12:
13: int main()
14: {
15: Cat Frisky;

background image

Dostp prywatny i publiczny

317

16: Frisky.itsAge = 5; // przypisanie do zmiennej skadowej
17: std::cout << "Frisky jest kotem i ma " ;
18: std::cout << Frisky.itsAge << " lat.\n";
19: return 0;
20: }

Wynik

d

Frisky jest kotem i ma 5 lat.

Analiza

d

Linia 6. zawiera sowo kluczowe class. Informuje ono kompilator, e nastpuje

po nim deklaracja klasy. Nazwa nowej klasy nastpuje bezporednio po sowie

kluczowym class. W tym przypadku nazw klasy jest Cat (kot).

Ciao deklaracji rozpoczyna si w linii 7. od otwierajcego nawiasu klamrowego

i koczy si zamykajcym nawiasem klamrowym i rednikiem w linii 11. Linia 8.

zawiera sowo kluczowe public, które wskazuje, e wszystko, co po nim nastpi,

bdzie publiczne, a do natrafienia na sowo kluczowe private lub koniec deklaracji

klasy. Linie 9. i 10. zawieraj deklaracje skadowych klasy, itsAge (jego wiek)

oraz itsWeight (jego waga).

W linii 13. rozpoczyna si funkcja main(). W linii 15. Frisky jest definiowany

jako egzemplarz klasy Cat — tj. jako obiekt klasy Cat. W linii 16. wiek Friska

jest ustawiany na 5. W liniach 17. i 18. zmienna skadowa itsAge zostaje uyta

do wywietlenia informacji o kocie Frisky. Powiniene zauway , jak w liniach

16. i 18. nastpuje uzyskanie dostpu do obiektu Frisky. Zmienna itsAge jest

dostpna poprzez nazw obiektu (w tym przykadzie Frisky), nastpnie kropk

i nazw zmiennej skadowej (w tym przypadku itsAge).

Spróbuj wykomentowa lini 8., po czym skompiluj program ponownie. W linii 16.
wystpi bd, gdy zmienna skadowa itsAge nie bdzie ju skadow publiczn.
Domylnie, wszystkie skadowe klasy s prywatne.

Oznaczanie danych skadowych
jako prywatnych

Powiniene przyj jako ogóln regu, e dane skadowe klasy naley utrzymywa

jako prywatne. Oczywicie, moesz si zastanawia , w jaki sposób uzyska

informacje dotyczce klasy, jeli wszystkie elementy skadowe bd prywatne.

background image

318

Lekcja 10.

Klasy i obiekty

Przykadowo, jeli zmienna itsAge bdzie prywatna, jak mona odczyta bd

ustawi wiek obiektu Cat?

W celu uzyskania dostpu do danych prywatnych w klasie musisz stworzy

publiczne funkcje skadowe, zwane akcesorami. Funkcje te umoliwi odczyt

zmiennych skadowych i przypisywanie im wartoci. Te funkcje dostpowe

(akcesory) s funkcjami skadowymi, uywanymi przez inne czci programu

w celu odczytywania i ustawiania prywatnych zmiennych skadowych. Publiczny

akcesor jest funkcj skadow klasy, uywan albo do odczytu wartoci prywatnej

zmiennej skadowej klasy, albo do ustawiania wartoci tej zmiennej.

Dlaczego miaby utrudnia sobie ycie dodatkowym poziomem poredniego

dostpu? Po co dodawa kolejne funkcje, skoro prociej i atwiej jest bezporednio

posugiwa si danymi? Jaki cel ma stosowanie akcesorów?

Odpowied na te pytania jest cakiem prosta: akcesory umoliwiaj oddzielenie

szczegóów przechowywania danych klasy od szczegóów jej uywania. Dziki

temu moesz zmienia sposób przechowywania danych klasy bez koniecznoci

przepisywania funkcji, które z tych danych korzystaj.

Jeli funkcja, która chce pozna wiek kota, odwoa si bezporednio do zmiennej

itsAge klasy Cat, bdzie musiaa zosta przepisana, jeeli Ty, jako autor klasy

Cat, zdecydujesz si na zmian sposobu przechowywania tej zmiennej. Jednak

posiadajc funkcj skadow GetAge() (pobierz wiek), klasa Cat moe atwo

zwróci waciw warto bez wzgldu na to, w jaki sposób przechowywany

bdzie wiek. Funkcja wywoujca nie musi wiedzie , czy jest on przechowywany

jako zmienna typu unsigned int czy long lub czy wiek jest obliczany w miar

potrzeb.

Ta technika uatwia zapanowanie nad programem. Przedua istnienie kodu,

gdy zmiany projektowe nie powoduj, e program staje si przestarzay.

Oprócz tego funkcje akcesorów mog zawiera dodatkow logik — na przykad

mao prawdopodobne jest, aby wiek kota (obiektu Cat) przekroczy warto 100,

a jego waga przekroczya warto 1000. Wymienione wartoci powinny by

niedozwolone. Funkcja akcesora moe wymusi stosowanie tego rodzaju

ogranicze, jak równie wykonywa wiele innych zada.

Listing 10.2 przedstawia klas Cat zmodyfikowan tak, by zawieraa prywatne

dane skadowe i publiczne akcesory. Zwró uwag, e ten listing przedstawia

wycznie deklaracj klasy, nie ma w nim kodu wykonywalnego.

background image

Dostp prywatny i publiczny

319

Listing 10.2. Klasa z akcesorami

1: // Deklaracja klasy Cat
2: // Dane skadowe s prywatne, publiczne akcesory porednicz
3: // w ustawianiu i odczytywaniu wartoci skadowych prywatnych
4: class Cat
5: {
6: public:
7: // publiczne akcesory
8: unsigned int GetAge();
9: void SetAge(unsigned int Age);
10:
11: unsigned int GetWeight();
12: void SetWeight(unsigned int Weight);
13:
14: // publiczna funkcja skadowa
15: void Meow();
16:
17: // prywatne dane skadowe
18: private:
19: unsigned int itsAge;
20: unsigned int itsWeight;
21: };

Analiza

d

Ta klasa posiada pi metod publicznych. Linie 8. i 9. zawieraj akcesory dla

skadowej itsAge. Moesz zobaczy , e w linii 8. znajduje si metoda pobierajca

wiek kota, natomiast w linii 9. metoda ustawiajca wiek kota. Linie 11. i 12.

zawieraj podobne akcesory dla skadowej itsWeight. Te akcesory ustawiaj

zmienne skadowe i zwracaj ich wartoci.

W linii 15. jest zadeklarowana publiczna funkcja skadowa Meow(). Ta funkcja

nie jest akcesorem. Nie zwraca wartoci ani ich nie ustawia; wykonuje inn

usug dla klasy — wywietla sowo Miau. Zmienne skadowe s zadeklarowane

w liniach 19. i 20.

Aby ustawi wiek Friska, powiniene przekaza warto metodzie SetAge()

(ustaw wiek), na przykad:

Cat Frisky;
Frisky.SetAge(5); // ustawia wiek Friska
// uywajc publicznego akcesora

W dalszej czci lekcji poznasz kod, dziki któremu metoda SetAge() oraz inne

mog dziaa .

background image

320

Lekcja 10.

Klasy i obiekty

Zadeklarowanie metod lub danych jako prywatnych umoliwia kompilatorowi

wyszukanie w programach pomyek, zanim stan si one bdami. Kady szanujcy

si programista potrafi znale sposób na obejcie prywatnoci skadowych.

Stroustrup, autor jzyka C++, stwierdza, e „...mechanizmy ochrony z poziomu

jzyka chroni przed pomyk, a nie przed wiadomym oszustwem” (WNT, 1995).

Sowo kluczowe class

Skadnia sowa kluczowego class jest nastpujca:

class nazwa_klasy
{
// sowa kluczowe kontroli dostpu
// zadeklarowane zmienne i skadowe klasy
};

Sowo kluczowe class suy do deklarowania nowych typów. Klasa stanowi zbiór
danych skadowych klasy, które s zmiennymi rónych typów, take innych klas.
Klasa zawiera take funkcje klasy — tzw. metody — które s funkcjami uywanymi
do manipulowania danymi w danej klasie i wykonywania innych usug dla klasy.

Obiekty nowego typu definiuje si w taki sam sposób, w jaki definiuje si inne
zmienne. Naley okreli typ (klas), a po nim nazw zmiennej (obiektu).
Do uzyskania dostpu do funkcji i danych klasy suy operator kropki (.).

Sowa kluczowe kontroli dostpu okrelaj, które sekcje klasy s prywatne, a które
publiczne. Domylnie wszystkie skadowe klasy s prywatne. Kade sowo kluczowe
zmienia kontrol dostpu od danego miejsca a do ko ca klasy, lub kontrol
wystpienia nastpnego sowa kluczowego kontroli dostpu. Deklaracja klasy
ko czy si zamykajcym nawiasem klamrowym i rednikiem.

Przykad 1

class Cat
{
public:
unsigned int Age;
unsigned int Weight;
void Meow();
};

Cat Frisky;
Frisky.Age = 8;
Frisky.Weight = 18;
Frisky.Meow();
Przykad 2
class Car
{

background image

Implementowanie metod klasy

321

public: // pi nastpnych skadowych jest publicznych
void Start();
void Accelerate();
void Brake();
void SetYear(int year);
int GetYear();

private: // pozostaa cz jest prywatna
int Year;
char Model [255];
}; // koniec deklaracji klasy

Car OldFaithful; // tworzy egzemplarz klasy
int bought; // lokalna zmienna typu int
OldFaithful.SetYear(84); // ustawia skadow Year na 84
bought = OldFaithful.GetYear(); // ustawia zmienn bought na 84
OldFaithful.Start(); //wywouje metod Start

Tak

Nie

Uywaj publicznych akcesorów, czyli
publicznych funkcji dostpowych.

Odwouj si do prywatnych zmiennych
skadowych z funkcji skadowych
klasy.

Nie deklaruj zmiennych skadowych
jako publiczne, o ile nie ma takiej
potrzeby.

Nie uywaj prywatnych zmiennych
skadowych klasy poza t klas.

Implementowanie metod klasy

Jak ju si przekonae, akcesory stanowi publiczny interfejs do prywatnych

danych klasy. Kady akcesor musi posiada , wraz z innymi zadeklarowanymi

metodami klasy, implementacj. Implementacja jest nazywana definicjfunkcji.

Definicja funkcji skadowej rozpoczyna si podobnie jak definicja zwykej funkcji.

W pierwszej kolejnoci trzeba poda typ zwracany z danej funkcji lub uy

sowa kluczowego void, jeli funkcja niczego nie zwraca. Nastpnie podajemy

nazw klasy, po której wystpuj dwa dwukropki, nazwa funkcji i jej parametry.

Listing 10.3 przedstawia pen deklaracj prostej klasy Cat, wraz z implementacj

jej akcesorów i jednej ogólnej funkcji tej klasy.

background image

322

Lekcja 10.

Klasy i obiekty

Listing 10.3. Implementacja metod prostej klasy

1: // Demonstruje deklarowanie klasy oraz
2: // definiowanie jej metod
3: #include <iostream> // dla cout
4:
5: class Cat // pocztek deklaracji klasy
6: {
7: public: // pocztek sekcji publicznej
8: int GetAge(); // akcesor
9: void SetAge(int age); // akcesor
10: void Meow(); // ogólna funkcja
11: private: // pocztek sekcji prywatnej
12: int itsAge; // zmienna skadowa
13: };
14:
15: // GetAge, publiczny akcesor
16: // zwracajcy warto skadowej itsAge
17: int Cat::GetAge()
18: {
19: return itsAge;
20: }
21:
22: // definicja SetAge, akcesora
23: // publicznego
24: // ustawiajcego skadow itsAge
25: void Cat::SetAge(int age)
26: {
27: // ustawia zmienn skadow itsAge
28: // zgodnie z wartoci przekazan w parametrze age
29: itsAge = age;
30: }
31:
32: // definicja metody Meow
33: // zwraca: void
34: // parametery: brak
35: // dziaanie: wywietla na ekranie sowo "miauczy"
36: void Cat::Meow()
37: {
38: std::cout << "Miauczy.\n";
39: }
40:
41: // tworzy kota, ustawia jego wiek, sprawia,
42: // e miauczy, wywietla jego wiek i ponownie miauczy.
43: int main()
44: {
45: Cat Frisky;
46: Frisky.SetAge(5);
47: Frisky.Meow();

background image

Implementowanie metod klasy

323

48: std::cout << "Frisky jest kotem i ma " ;
49: std::cout << Frisky.GetAge() << " lat.\n";
50: Frisky.Meow();
51: return 0;
52: }

Wynik

d

Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.

Analiza

d

Linie od 5. do 13. zawieraj definicj klasy Cat (kot). Linia 7. zawiera sowo

kluczowe public, które informuje kompilator, e to, co po nim nastpuje, jest

zestawem publicznych skadowych. Linia 8. zawiera deklaracj publicznego

akcesora GetAge() (pobierz wiek). GetAge() zapewnia dostp do prywatnej

zmiennej skadowej itsAge (jego wiek), zadeklarowanej w linii 12. Linia 9.

zawiera publiczny akcesor SetAge() (ustaw wiek). Funkcja SetAge() otrzymuje

parametr typu int, który nastpnie przypisuje skadowej itsAge.

Linia 10. zawiera deklaracj metody Meow() (miaucz). Funkcja Meow() nie jest

akcesorem. Jest to ogólna metoda klasy, wywietlajca na ekranie sowo „Miauczy.”

Linia 11. rozpoczyna sekcj prywatn, która obejmuje jedynie zadeklarowan

w linii 12. prywatn skadow itsAge. Deklaracja klasy koczy si w linii 13.

zamykajcym nawiasem klamrowym i rednikiem.

Linie od 17. do 20. zawieraj definicj skadowej funkcji GetAge(). Ta metoda

nie ma parametrów i zwraca warto cakowit. Zauwa, e ta metoda klasy

zawiera nazw klasy, dwa dwukropki oraz nazw funkcji (linia 17.). Ta skadnia

informuje kompilator, e definiowana funkcja GetAge() jest wanie t funkcj,

która zostaa zadeklarowana w klasie Cat. Poza formatem tego nagówka,

definiowanie funkcji wasnej GetAge() niczym nie róni si od definiowania

innych (zwykych) funkcji.

Funkcja GetAge() posiada tylko jedn lini i zwraca po prostu warto zmiennej

skadowej itsAge. Zauwa, e funkcja main() nie ma dostpu do tej zmiennej

skadowej, gdy jest ona prywatna dla klasy Cat. Funkcja main() ma za to dostp

do publicznej metody GetAge().

background image

324

Lekcja 10.

Klasy i obiekty

Poniewa ta metoda jest skadow klasy Cat, ma peny dostp do zmiennej itsAge.

Dziki temu moe zwróci funkcji main() warto zmiennej itsAge.

Linia 25. zawiera definicj funkcji skadowej SetAge(). Moesz zauway , e ta

funkcja pobiera jedn warto w postaci liczby cakowitej (age) i nie zwraca adnej

wartoci, co jest wskazane przez sowo kluczowe void. Ta funkcja posiada

parametr w postaci wartoci cakowitej i przypisuje skadowej itsAge jego

warto (linia 29.). Poniewa jest skadow klasy Cat, ma bezporedni dostp

do jej zmiennych prywatnych i publicznych.

Linia 36. rozpoczyna definicj (czyli implementacj) metody Meow() klasy Cat.

Jest to jednoliniowa funkcja wywietlajca na ekranie sowo „Miauczy”, zakoczone

znakiem nowej linii. Pamitaj, e znak \n powoduje przejcie do nowej linii. Moesz

zauway , e metoda Meow() jest zaimplementowana podobnie jak funkcja

akcesora, czyli rozpoczyna si od typu zwracanej wartoci, a nastpnie mamy

nazw klasy, nazw funkcji oraz parametry (w tym przypadku nie ma adnych

parametrów).

Linia 43. rozpoczyna ciao funkcji main(), czyli waciwy program. W linii 45.,

funkcja main() deklaruje obiekt Cat o nazwie Frisky. Ujmujc to inaczej, mona

powiedzie , e funkcja main() deklaruje kota (Cat) o imieniu Frisky.

W linii 46. zmiennej itsAge tego obiektu jest przypisywana warto 5 (poprzez

uycie akcesora SetAge()). Zauwa, e wywoanie tej metody nastpuje dziki

uyciu nazwy obiektu (Frisky), po której zastosowano operator kropki (.) i nazw

metody (SetAge()). W podobny sposób wywoywane s wszystkie inne metody

wszystkich klas.

Pojcia funkcja skadowa i metoda skadowa mog by uywane zamiennie.

Linia 47. wywouje funkcj skadow Meow(), za w linii 49. za pomoc akcesora

GetAge(), wywietlany jest komunikat. Linia 50. ponownie wywouje funkcj Meow().

Cho wymienione metody s czci klasy (Cat) i uywane poprzez obiekt (Frisky),

to dziaaj dokadnie tak samo jak funkcje, które widziae do tej pory.

Konstruktory i destruktory

Istniej dwa sposoby definiowania zmiennej cakowitej. Mona zdefiniowa zmienn,

a nastpnie, w dalszej czci programu, przypisa jej warto . Na przykad:

background image

Konstruktory i destruktory

325

int Weight; // definiujemy zmienn
... // tu inny kod
Weight = 7; // przypisujemy jej warto

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

int Weight = 7; // definiujemy i inicjalizujemy wartoci 7

Inicjalizacja czy w sobie definiowanie zmiennej oraz pocztkowe przypisanie

wartoci. Nic nie stoi na przeszkodzie temu, by zmieni póniej warto zmiennej.

Inicjalizacja powoduje tylko, e zmienna nigdy nie bdzie pozbawiona sensownej

wartoci.

W jaki sposób zainicjalizowa skadowe klasy? Klasy posiadaj specjalne funkcje

skadowe, zwane konstruktorami. Konstruktor (ang. constructor) moe w razie

potrzeby posiada parametry, ale nie moe zwraca wartoci — nawet typu void.

Konstruktor jest metod klasy o takiej samej nazwie, jak nazwa klasy.

Gdy zadeklarujesz konstruktor, powiniene take zadeklarowa destruktor

(ang. destructor). Konstruktor tworzy i inicjalizuje obiekt danej klasy, za destruktor

porzdkuje obiekt i zwalnia pami , któr moge w niej zaalokowa (albo

w konstruktorze, albo w trakcie cyklu yciowego obiektu). Destruktor zawsze

nosi nazw klasy, poprzedzon znakiem tyldy (~). Destruktory nie maj

argumentów i nie zwracaj wartoci. Dlatego deklaracja destruktora klasy Cat

ma nastpujc posta :

~Cat();

Domylne konstruktory i destruktory

Istnieje wiele rodzajów konstruktorów; niektóre z nich posiadaj argumenty,

inne nie. Konstruktor, którego mona wywoa bez adnych argumentów, jest

nazywany konstruktorem domylnym. Istnieje tylko jeden rodzaj destruktora.

On take nie posiada argumentów.

Jeli nie stworzysz konstruktora lub destruktora, kompilator stworzy je za

Ciebie. Konstruktor dostarczany przez kompilator jest konstruktorem domylnym

— czyli konstruktorem bez argumentów. Stworzone przez kompilator domylny

konstruktor i destruktor nie maj adnych argumentów, a na dodatek w ogóle nic

nie robi! Jeeli chcesz, aby wykonyway jakiekolwiek operacje, musisz samodzielnie

utworzy domylny konstruktor i destruktor.

background image

326

Lekcja 10.

Klasy i obiekty

Uycie domylnego konstruktora

Do czego moe przyda si konstruktor, który nic nie robi? Jest to problem

techniczny: wszystkie obiekty musz by konstruowane i niszczone, dlatego

w odpowiednich momentach wywoywane s te nic nie robice funkcje.

Aby móc zadeklarowa obiekt bez przekazywania parametrów, na przykad

Cat Boots; // Boots nie ma parametrów

musisz posiada konstruktor w postaci

Cat();

Gdy definiujesz obiekt klasy, wywoywany jest konstruktor. Gdyby konstruktor

klasy Cat mia dwa parametry, mógby zdefiniowa obiekt Cat, piszc

Cat Frisky (5, 7);

W tym przypadku pierwszy parametr mógby by wiekiem, natomiast drugi

mógby oznacza wag kota. Gdyby konstruktor mia jeden parametr, napisaby

Cat Frisky (3);

W przypadku, gdy konstruktor nie ma adnych parametrów (gdy jest konstruktorem

domylnym), moesz opuci nawiasy i napisa

Cat Frisky;

Jest to wyjtek od reguy, zgodnie z któr wszystkie funkcje wymagaj zastosowania

nawiasów, nawet jeli nie maj parametrów. Wanie dlatego moesz napisa :

Cat Frisky;

Jest to interpretowane jako wywoanie konstruktora domylnego. Nie dostarczamy

mu parametrów i pomijamy nawiasy.

Zwró uwag, e nie musisz uywa domylnego konstruktora dostarczanego

przez kompilator. Zawsze moesz napisa wasny konstruktor domylny — tj.

konstruktor bez parametrów. Moesz zastosowa w nim ciao funkcji, w którym

moesz zainicjalizowa obiekt. Zgodnie z konwencj, zawsze zaleca si zdefiniowanie

konstruktora i ustawienie zmiennym skadowym odpowiednich wartoci

domylnych w celu zagwarantowania prawidowego zachowania obiektu.

Zgodnie z konwencj, gdy deklarujesz konstruktor, powiniene take zadeklarowa

destruktor, nawet jeli nie robi on niczego. Nawet jeli destruktor domylny bdzie

dziaa poprawnie, nie zaszkodzi zadeklarowa wasnego. Dziki niemu kod staje

si bardziej przejrzysty.

background image

Konstruktory i destruktory

327

Listing 10.4 zawiera now wersj klasy Cat, w której do zainicjalizowania obiektu

kota nie uyto domylnego konstruktora. Wiek kota zosta ustawiony zgodnie

z wartoci otrzyman jako parametr konstruktora. Listing pokazuje równie

miejsce, w którym wywoywany jest destruktor.

Listing 10.4. Uycie konstruktora i destruktora

1: // Demonstruje deklarowanie konstruktora
2: // i destruktora dla klasy Cat
3: // Domylny konstruktor zosta stworzony przez programist
4: #include <iostream> // dla cout
5:
6: class Cat // pocztek deklaracji klasy
7: {
8: public: // pocztek sekcji publicznej
9: Cat(int initialAge); // konstruktor
10: ~Cat(); // destruktor
11: int GetAge(); // akcesor
12: void SetAge(int age); // akcesor
13: void Meow();
14: private: // pocztek sekcji prywatnej
15: int itsAge; // zmienna skadowa
16: };
17:
18: // konstruktor klasy Cat
19: Cat::Cat(int initialAge)
20: {
21: itsAge = initialAge;
22: }
23:
24: Cat::~Cat() // destruktor, nic nie robi
25: {
26: }
27:
28: // GetAge, publiczny akcesor
29: // zwraca warto skadowej itsAge
30: int Cat::GetAge()
31: {
32: return itsAge;
33: }
34:
35: // definicja SetAge, akcesora
36: // publicznego
37: void Cat::SetAge(int age)
38: {
39: // ustawia zmienn skadow itsAge
40: // zgodnie z wartoci przekazan w parametrze age
41: itsAge = age;

background image

328

Lekcja 10.

Klasy i obiekty

42: }
43:
44: // definicja metody Meow
45: // zwraca: void
46: // parametery: brak
47: // dziaanie: wywietla na ekranie sowo "miauczy"
48: void Cat::Meow()
49: {
50: std::cout << "Miauczy.\n";
51: }
52:
53: // tworzy kota, ustawia jego wiek, sprawia,
54: // e miauczy, wywietla jego wiek i ponownie miauczy.
55: int main()
56: {
57: Cat Frisky(5);
58: Frisky.Meow();
59: std::cout << "Frisky jest kotem i ma " ;
60: std::cout << Frisky.GetAge() << " lat.\n";
61: Frisky.Meow();
62: Frisky.SetAge(7);
63: std::cout << "Teraz Frisky ma " ;
64: std::cout << Frisky.GetAge() << " lat.\n";
65: return 0;
66: }

Wynik

d

Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Teraz Frisky ma 7 lat.

Analiza

d

Listing 10.4 przypomina listing 10.3, jednak w linii 9. dodano konstruktor,

posiadajcy argument w postaci wartoci cakowitej. Linia 10. deklaruje destruktor,

który nie posiada parametrów. Destruktory nigdy nie maj parametrów, za

destruktory i konstruktory nie zwracaj adnych wartoci — nawet typu void.

Linie od 19. do 22. zawieraj implementacj konstruktora. Jest ona podobna do

implementacji akcesora SetAge(). Jak moesz zobaczy , nazwa klasy poprzedza

nazw konstruktora. Jak ju wczeniej wspomniano, to identyfikuje metod

(w tym przypadku Cat()) jako cz klasy Cat. Poniewa wymieniona metoda

jest konstruktorem, to nie zwraca adnej wartoci, nawet void. Jednak w linii 21.

konstruktor pobiera warto pocztkow przypisan danej skadowej itsAge.

background image

Funkcje skadowe const

329

Linie od 24. do 26. przedstawiaj implementacj destruktora ~Cat(). W tej

chwili ta funkcja nie robi nic, ale jeli deklaracja klasy zawiera deklaracj

destruktora, zdefiniowany musi zosta wtedy take ten destruktor. Podobnie

jak w przypadku konstruktora oraz innych metod, destruktor jest poprzedzony

nazw klasy. Podobnie jak w przypadku konstruktora, ale odmiennie ni

w przypadku innych metod, nie podaje si zwracanego typu oraz parametrów.

To jest standardowy wymóg dla destruktorów.

Linia 57. zawiera definicj obiektu Frisky, stanowicego egzemplarz klasy Cat.

Do konstruktora obiektu Frisky przekazywana jest warto 5. Nie ma potrzeby

wywoywania funkcji SetAge(), gdy Frisky zosta stworzony z wartoci 5

znajdujc si w zmiennej skadowej itsAge, tak jak pokazano w linii 60. W linii 62.

zmiennej itsAge obiektu Frisky jest przypisywana warto 7. T now warto

wywietla linia 64.

Tak

Nie

W celu zainicjalizowania obiektów
uywaj konstruktorów.

Jeeli dodae konstruktor, dodaj
równie destruktor.

Pamitaj, e konstruktory i destruktory
nie mog zwraca wartoci.

Pamitaj, e destruktory nie mog
mie parametrów.

Funkcje skadowe const

Sowo kluczowe const suy do deklarowania zmiennych, które nie ulegaj

zmianie. Const mona stosowa równie wraz z funkcjami skadowymi w klasie.

Jeli zadeklarujesz metod klasy jako const, obiecujesz w ten sposób, e metoda

ta nie zmieni wartoci adnej ze skadowych klasy.

Aby zadeklarowa metod w ten sposób, umie sowo kluczowe const za

nawiasami, lecz przed rednikiem. Przykadowo:

void SomeFunction() const;

Pokazana powyej deklaracja funkcji skadowej const o nazwie SomeFunction()

nie posiada argumentów i zwraca typ void. Wiesz, e powysza funkcja nie zmieni

adnych elementów skadowych w klasie, poniewa zostaa zadeklarowana wraz

ze sowem kluczowym const.

background image

330

Lekcja 10.

Klasy i obiekty

Wraz z modyfikatorem const czsto deklarowane s akcesory, które jedynie

pobieraj warto . Przedstawiona wczeniej klasa Cat posiada dwa akcesory:

void SetAge(int anAge);
int GetAge();

Funkcja SetAge() nie moe by funkcj const, gdy modyfikuje warto zmiennej

skadowej itsAge. Natomiast funkcja GetAge() moe i powinna by const, gdy

nie modyfikuje wartoci adnej ze skadowych klasy. Funkcja GetAge() po prostu

zwraca biec warto skadowej itsAge. Zatem deklaracje tych funkcji mona

przepisa nastpujco:

void SetAge(int anAge);
int GetAge() const;

Gdy zadeklarujesz funkcj jako const, za implementacja tej funkcji modyfikuje

obiekt poprzez modyfikacj wartoci którejkolwiek ze skadowych, kompilator

zgosi bd. Na przykad, gdy napiszesz funkcj GetAge() w taki sposób, e bdziesz

zapamitywa ilo zapyta o wiek kota, spowodujesz bd kompilacji. Jest to

spowodowane tym, e wywoujc t metod, modyfikujesz zawarto obiektu Cat.

Deklarowanie funkcji jako const wszdzie tam, gdzie jest to moliwe, naley

do tradycji programistycznej. Za kadym razem, gdy to zrobisz, umoliwisz

kompilatorowi wykrycie pomyki, zanim stanie si ona bdem, który ujawni si

ju podczas dziaania programu.

Po co uywa kompilatora do wykrywania bdów?

Gdyby mona byo tworzy programy w stu procentach pozbawione bdów,
byoby cudowanie, jednak tylko bardzo niewielu programistów jest w stanie
tego dokona. Wielu programistów opracowao jednak system pozwalajcy
zminimalizowa ilo bdów przez wczesne ich wykrycie i poprawienie.

Cho bdy kompilatora s irytujce i stanowi dla programisty przekle stwo, jednak
s czym duo lepszym ni opisana dalej alternatywa. Jzyk o sabej kontroli typów
umoliwia naruszanie zasad kontraktu bez sowa sprzeciwu ze strony kompilatora,
jednak program moe zaama si w trakcie dziaania — na przykad wtedy, gdy
pracuje z nim Twój szef. Co gorsze, w takim przypadku testowanie w celu
wychwycenia tych bdów bdzie mao pomocne, poniewa istnieje zbyt duo
cieek wykonywania kodu rzeczywistych programów, aby móc przetestowa je
wszystkie.

Bdy czasu kompilacji — tj. bdy wykryte podczas kompilowania programu —
s zdecydowanie lepsze ni bdy czasu dziaania — tj. bdy wykryte podczas
dziaania programu. S lepsze, gdy duo atwiej i precyzyjniej mona okreli

background image

Gdzie umieszcza deklaracje klasy i definicje metod

331

ich przyczyn. Moe si zdarzy, e program zostanie wykonany wielokrotnie
bez wykonania wszystkich istniejcych cieek wykonania kodu. Dlatego bd
czasu dziaania moe przez duszy czas pozosta niezauwaony. Bdy kompilacji
s wykrywane podczas kadej kompilacji, s wic duo atwiejsze do zidentyfikowania
i poprawienia. Celem dobrego programowania jest ochrona przed pojawianiem si
bdów czasu dziaania. Jedn ze znanych i sprawdzonych technik jest wykorzystanie
kompilatora do wykrycia pomyek ju na wczesnym etapie tworzenia programu.

Gdzie umieszcza deklaracje klasy
i definicje metod

Kada funkcja, któr zadeklarujesz dla klasy, musi posiada definicj. Definicja

jest nazywana take implementacjfunkcji. Podobnie jak w przypadku innych

funkcji, definicja metody klasy posiada nagówek i ciao.

Definicja musi znajdowa si w pliku, który moe zosta znaleziony przez

kompilator. Wikszo kompilatorów C++ wymaga, by taki plik mia rozszerzenie

.c lub .cpp. W tej ksice korzystamy z rozszerzenia .cpp, ale aby mie pewno ,

sprawd, czego oczekuje Twój kompilator.

Wiele kompilatorów zakada, e pliki z rozszerzeniem .c s programami C,
za pliki z rozszerzeniem .cpp s programami C++. Moesz uywa dowolnego
rozszerzenia, ale rozszerzenie .cpp wyeliminuje ewentualne nieporozumienia.

W pliku, w którym umieszczasz implementacj funkcji, moesz umieci równie

jej deklaracj, ale nie naley to do dobrych obyczajów. Zgodnie z konwencj

zaadoptowan przez wikszo programistów, deklaracje umieszcza si w tak

zwanych plikach nagówkowych, zwykle posiadajcych t sam nazw, lecz

z rozszerzeniem .h, .hp lub .hpp. W tej ksice dla plików nagówkowych stosujemy

rozszerzenie .h, ale sprawd w swoim kompilatorze, jakie rozszerzenie powiniene

stosowa .

Na przykad, deklaracj klasy Cat powiniene umieci w pliku o nazwie Cat.h, za

definicj metod tej klasy w pliku o nazwie Cat.cpp. Nastpnie powiniene doczy

do pliku .cpp plik nagówkowy, poprzez umieszczenie na pocztku pliku Cat.cpp

nastpujcej dyrektywy:

#include "Cat.h"

background image

332

Lekcja 10.

Klasy i obiekty

Informuje ona kompilator, by wstawi w tym miejscu zawarto pliku Cat.h tak,

jakby j wpisa rcznie. Uwaga: niektóre kompilatory nalegaj, by wielko liter

w nazwie pliku w dyrektywie #include zgadzaa si z wielkoci liter w nazwie

pliku na dysku.

Dlaczego masz si trudzi , rozdzielajc program na pliki .h i .cpp, skoro i tak plik .h

jest wstawiany do pliku .cpp? W wikszoci przypadków klienci klasy nie dbaj

o szczegóy jej implementacji. Odczytanie pliku nagówkowego daje im wystarczajc

ilo informacji, by zignorowa plik implementacji. Poza tym, ten sam plik .h moesz

docza do wielu rónych plików .cpp.

Deklaracja klasy mówi kompilatorowi, czym jest ta klasa, jakie dane zawiera
oraz jakie funkcje posiada. Deklaracja klasy jest nazywana jej interfejsem, gdy
informuje kompilator w jaki sposób ma z ni wspódziaa. Ten interfejs jest
zwykle przechowywany w pliku .h, czsto nazywanym plikiem nagówkowym.

Definicja funkcji mówi kompilatorowi, jak dziaa dana funkcja. Definicja funkcji
jest nazywana implementacj metody klasy i jest przechowywana w pliku .cpp.
Szczegóy dotyczce implementacji klasy nale wycznie do jej autora. Klienci
klasy — tj. czci programu uywajce tej klasy — nie musz, ani nie powinny
wiedzie, jak zaimplementowane zostay funkcje.

Implementacja inline

Moesz poprosi kompilator, by uczyni zwyk funkcj funkcj inline, funkcjami

inline mog sta si równie metody klasy. W tym celu naley umieci sowo

kluczowe inline przed typem zwracanej wartoci. Na przykad, implementacja

inline funkcji GetWeight() wyglda nastpujco:

inline int Cat::GetWeight()
{
return itsWeight; // zwraca dan skadow itsWeight
}

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

e ta funkcja staje si funkcj inline. Na przykad:

class Cat
{
public:
int GetWeight() { return itsWeight; } // inline
void SetWeight(int aWeight);
};

background image

Implementacja inline

333

Zwró uwag na skadni definicji funkcji GetWeight(). Ciao funkcji inline

zaczyna si natychmiast po deklaracji metody klasy; po nawiasach nie wystpuje

rednik. Podobnie jak w innych funkcjach, definicja zaczyna si od otwierajcego

nawiasu klamrowego i koczy zamykajcym nawiasem klamrowym. Jak zwykle,

biae znaki nie maj znaczenia; moesz zapisa t deklaracj jako:

class Cat
{
public:
int GetWeight() const
{
return itsWeight;
} // inline
void SetWeight(int aWeight);
};

Listingi 10.5 i 10.6 odtwarzaj klas Cat, tym razem jednak deklaracja klasy

zostaa umieszczona w pliku Cat.h, za jej definicja w pliku Cat.cpp. Oprócz tego,

na listingu 10.5 akcesor Meow() zosta zadeklarowany jako funkcja inline.

Listing 10.5. Deklaracja klasy Cat w pliku CAT.h

1: #include <iostream>
2: class Cat
3: {
4: public:
5: Cat (int initialAge);
6: ~Cat();
7: int GetAge() const { return itsAge;} // inline!
8: void SetAge (int age) { itsAge = age;} // inline!
9: void Meow() const { std::cout << "Miauczy.\n";} // inline!
10: private:
11: int itsAge;
12: };

Listing 10.6. Implementacja klasy Cat w pliku CAT.cpp

1: // Demonstruje funkcje inline
2: // oraz doczanie pliku nagówkowego
3: // pamitaj o wczeniu plików nagówkowych!
4: #include "Cat.h"
5:
6:
7: Cat::Cat(int initialAge) //konstruktor
8: {
9: itsAge = initialAge;
10: }

background image

334

Lekcja 10.

Klasy i obiekty

11:
12: Cat::~Cat() //destruktor, nic nie robi
13: {
14: }
15:
16: // tworzy kota, ustawia jego wiek, sprawia
17: // e miauczy, wywietla jego wiek i ponownie miauczy.
18: int main()
19: {
20: Cat Frisky(5);
21: Frisky.Meow();
22: std::cout << "Frisky jest kotem i ma " ;
23: std::cout << Frisky.GetAge() << " lat.\n";
24: Frisky.Meow();
25: Frisky.SetAge(7);
26: std::cout << "Teraz Frisky ma " ;
27: std::cout << Frisky.GetAge() << " lat.\n";
28: return 0;
29: }

Wynik

d

Miauczy.
Frisky jest kotem i ma 5 lat.
Miauczy.
Teraz Frisky ma 7 lat.

Analiza

d

Kod zaprezentowany na listingach 10.5 i 10.6 jest podobny do kodu z listingu 10.4,

trzy metody zostay zadeklarowane w pliku deklaracji jako inline, a deklaracja

zostaa przeniesiona do pliku Cat.hpp (listing 10.5).

Funkcja GetAge() jest deklarowana w linii 6. pliku Cat.h, gdzie znajduje si

take jej implementacja inline. Linie 7. i 8. zawieraj kolejne funkcje inline,

jednak w stosunku do poprzednich, „zwykych” implementacji, dziaanie tych

funkcji nie zmienia si.

Linia 4. listingu 10.6 zawiera dyrektyw #include "Cat.h", która powoduje

wstawienie do pliku zawartoci pliku Cat.h. Doczajc plik Cat.h, informujesz

prekompilator, by odczyta zawarto tego pliku i wstawi j w miejscu wystpienia

dyrektywy #include (tak jakby, poczwszy od linii 5, sam wpisa t zawarto ).

Ta technika umoliwia umieszczenie deklaracji w pliku innym ni implementacja,

a jednoczenie zapewnienie kompilatorowi dostpu do niej. W programach C++

background image

Klasy, których danymi skadowymi s inne klasy

335

technika ta jest powszechnie wykorzystywana. Zwykle deklaracje klas znajduj

si w plikach .h, które s doczane do powizanych z nimi plików .cpp za pomoc

dyrektyw #include.

Linie od 18. do 29. stanowi powtórzenie funkcji main() z listingu 10.4. Oznacza to,

e funkcje inline dziaaj tak samo jak zwyke funkcje.

Klasy, których danymi skadowymi
s inne klasy

Budowanie zoonych klas przez deklarowanie prostszych klas i doczanie ich do

deklaracji bardziej skomplikowanej klasy nie jest niczym niezwykym. Na przykad,

moesz zadeklarowa klas koa, klas silnika, klas skrzyni biegów itd., a nastpnie

poczy je w klas „samochód”. Deklaruje to relacj posiadania. Samochód

posiada silnik, koa i skrzyni biegów.

Wemy inny przykad. Prostokt skada si z odcinków. Odcinek jest zdefiniowany

przez dwa punkty. Punkt jest zdefiniowany przez wspórzdn x i wspórzdn

y. Listing 10.7 przedstawia pen deklaracj klasy Rectangle (prostokt), która

moe wystpi w pliku Rectangle.h. Poniewa prostokt jest zdefiniowany jako

cztery odcinki czce cztery punkty, za kady punkt odnosi si do wspórzdnej

w ukadzie, najpierw zadeklarujemy klas Point (punkt) jako przechowujc

wspórzdne x oraz y punktu. Listing 10.8 zawiera implementacje obu klas.

Listing 10.7. Deklarowanie kompletnej klasy

1: // pocztek Rect.h
2: #include <iostream>
3: class Point // przechowuje wspórzdne x,y
4: {
5: // bez konstruktora, uywa domylnego
6: public:
7: void SetX(int x) { itsX = x; }
8: void SetY(int y) { itsY = y; }
9: int GetX()const { return itsX;}
10: int GetY()const { return itsY;}
11: private:
12: int itsX;
13: int itsY;
14: }; // koniec deklaracji klasy Point
15:

background image

336

Lekcja 10.

Klasy i obiekty

16:
17: class Rectangle
18: {
19: public:
20: Rectangle (int top, int left, int bottom, int right);
21: ~Rectangle () {}
22:
23: int GetTop() const { return itsTop; }
24: int GetLeft() const { return itsLeft; }
25: int GetBottom() const { return itsBottom; }
26: int GetRight() const { return itsRight; }
27:
28: Point GetUpperLeft() const { return itsUpperLeft; }
29: Point GetLowerLeft() const { return itsLowerLeft; }
30: Point GetUpperRight() const { return itsUpperRight; }
31: Point GetLowerRight() const { return itsLowerRight; }
32:
33: void SetUpperLeft(Point Location) {itsUpperLeft = Location;}
34: void SetLowerLeft(Point Location) {itsLowerLeft = Location;}
35: void SetUpperRight(Point Location) {itsUpperRight = Location;}
36: void SetLowerRight(Point Location) {itsLowerRight = Location;}
37:
38: void SetTop(int top) { itsTop = top; }
39: void SetLeft (int left) { itsLeft = left; }
40: void SetBottom (int bottom) { itsBottom = bottom; }
41: void SetRight (int right) { itsRight = right; }
42:
43: int GetArea() const;
44:
45: private:
46: Point itsUpperLeft;
47: Point itsUpperRight;
48: Point itsLowerLeft;
49: Point itsLowerRight;
50: int itsTop;
51: int itsLeft;
52: int itsBottom;
53: int itsRight;
54: };
55: // koniec Rect.h

Listing 10.8. Rect.cpp

1: // pocztek rect.cpp
2: #include "rect.h"
3: Rectangle::Rectangle(int top, int left, int bottom, int right)

background image

Klasy, których danymi skadowymi s inne klasy

337

4: {
5: itsTop = top;
6: itsLeft = left;
7: itsBottom = bottom;
8: itsRight = right;
9:
10: itsUpperLeft.SetX(left);
11: itsUpperLeft.SetY(top);
12:
13: itsUpperRight.SetX(right);
14: itsUpperRight.SetY(top);
15:
16: itsLowerLeft.SetX(left);
17: itsLowerLeft.SetY(bottom);
18:
19: itsLowerRight.SetX(right);
20: itsLowerRight.SetY(bottom);
21: }
22:
23:
24: // oblicza obszar prostokta przez obliczenie
25: // i pomnoenie szerokoci i wysokoci
26: int Rectangle::GetArea() const
27: {
28: int Width = itsRight-itsLeft;
29: int Height = itsTop - itsBottom;
30: return (Width * Height);
31: }
32:
33: int main()
34: {
35: //inicjalizuje lokaln zmienn typu Rectangle
36: Rectangle MyRectangle (100, 20, 50, 80 );
37:
38: int Area = MyRectangle.GetArea();
39:
40: std::cout << "Obszar: " << Area << "\n";
41: std::cout << "Wsp. X lewego górnego rogu: ";
42: std::cout << MyRectangle.GetUpperLeft().GetX();
43: return 0;
44: }

Wynik

d

Obszar: 3000
Wsp. X lewego górnego rogu: 20

background image

338

Lekcja 10.

Klasy i obiekty

Analiza

d

Linie od 3. do 14. listingu 10.7 deklaruj klas Point (punkt), która suy do

przechowywania wspórzdnych x i y okrelonego punktu rysunku. W tym

programie nie wykorzystujemy naleycie klasy Point. Jej zastosowania wymagaj

jednak inne metody rysunkowe.

Gdy nadasz klasie nazw Rectangle, niektóre kompilatory zgosz bd. Wynika
to z istnienia wewntrznej klasy o nazwie Rectangle. W takim przypadku po prostu
zmie nazw klasy na myRectangle.

W deklaracji klasy Point, w liniach 12. i 13., zadeklarowalimy dwie zmienne

skadowe (itsX oraz itsY). Te zmienne przechowuj wspórzdne punktu.

Zakadamy, e wspórzdna x ronie w prawo, a wspórzdna y w gór. Istniej

take inne systemy. W niektórych programach okienkowych wspórzdna y ronie

„w dó” okna.

Klasa Point uywa akcesorów inline, zwracajcych i ustawiajcych wspórzdne

X i Y punktu. Te akcesory zostay zadeklarowane w liniach od 7. do 10. Punkty

uywaj konstruktora i destruktora domylnego. W zwizku z tym ich wspórzdne

trzeba ustawia jawnie.

Linia 17. rozpoczyna deklaracj klasy Rectangle (prostokt). Klasa ta skada si

z czterech punktów reprezentujcych cztery naroniki prostokta. Konstruktor klasy
Rectangle (linia 20.) otrzymuje cztery wartoci cakowite, top (górna), left (lewa),

bottom (dolna) oraz right (prawa). Do czterech zmiennych skadowych (listing

10.8) kopiowane s cztery parametry konstruktora i tworzone s cztery punkty.

Oprócz standardowych akcesorów, klasa Rectangle posiada funkcj GetArea()

(pobierz obszar), zadeklarowan w linii 43. Zamiast przechowywa obszar
w zmiennej, funkcja GetArea() oblicza go w liniach od 28. do 30. listingu 10.8.

W tym celu oblicza szeroko i wysoko prostokta, nastpnie mnoy je przez siebie.

Uzyskanie wspórzdnej x lewego górnego wierzchoka prostokta wymaga

dostpu do punktu UpperLeft (lewy górny) i zapytania o jego wspórzdn X.

Poniewa funkcja GetUpperLeft() jest funkcj klasy Rectangle, moe ona

bezporednio odwoywa si do prywatnych danych tej klasy, wcznie ze zmienn
(itsUpperLeft). Poniewa itsUpperLeft jest obiektem klasy Point, a zmienna

itsX tej klasy jest prywatna, funkcja GetUpperLeft() nie moe odwoywa si

do niej bezporednio. Zamiast tego, w celu uzyskania tej wartoci musi uy
publicznego akcesora GetX().

background image

Klasy, których danymi skadowymi s inne klasy

339

Linia 33. listingu 10.8 stanowi pocztek ciaa programu. Pami nie jest alokowana

a do linii 36.; w obszarze tym nic si nie dzieje. Jedyna rzecz, jak zrobilimy,

to poinformowanie kompilatora, jak ma stworzy punkt i prostokt (gdyby

byy potrzebne w przyszoci). W linii 36. definiujemy obiekt typu Rectangle,

przekazujc mu wartoci top, left, bottom oraz right.

W linii 38. tworzymy lokaln zmienn Area (obszar) typu int. Ta zmienna

przechowuje obszar stworzonego przez nas prostokta. Zmienn Area inicjalizujemy

za pomoc wartoci zwróconej przez funkcj GetArea() klasy Rectangle. Klient

klasy Rectangle moe stworzy obiekt tej klasy i uzyska jego obszar, nie znajc

nawet implementacji funkcji GetArea().

Plik Rect.h zosta przedstawiony na listingu 10.7. Obserwujc plik nagówkowy,

który zawiera deklaracj klasy Rectangle, programista moe wysnu wniosek,

e funkcja GetArea() zwraca warto typu int. Sposób, w jaki funkcja GetArea()

uzyskuje t warto , nie interesuje klientów klasy Rectangle. Autor klasy Rectangle

mógby zmieni funkcj GetArea(); nie wpynoby to na programy, które z niej

korzystaj, o ile wartoci zwrotn nadal byaby liczba cakowita.

Linia 42. listingu 10.8 moe wydawa si nieco dziwna, ale jeli zastanowisz si nad

tym, co tam si dzieje, powinna sta si jasna. W tej linii kodu nastpuje pobranie

wspórzdnej x lewego górnego punktu prostokta. Wzgldem prostokta

wywoywana jest metoda GetUpperLeft(), która zwraca obiekt typu Point.

Z tego obiektu potrzebujemy wspórzdnej x. Wczeniej dowiedziae si,

e akcesorem dla punktu x klasy Point jest GetX(). Dlatego te w celu pobrania

wspórzdnej x lewego górnego naronika prostokta naley uy akcesora GetX()

wzgldem funkcji akcesora GetUpperLeft() obiektu MyRectangle. To wanie

przedstawiono w linii 42.:

MyRectangle.GetUpperLeft().GetX();

Czsto zadawane pytanie

Jaka jest rónica pomidzy deklaracj a definicj?

Odpowied

Deklaracja wprowadza now nazw, lecz nie alokuje pamici; dokonuje tego definicja.

Wszystkie deklaracje (z kilkoma wyjtkami) s take definicjami. Najwaniejszym
wyjtkiem jest deklaracja funkcji globalnej (prototyp) oraz deklaracja klasy (zwykle
w pliku nagówkowym).

background image

340

Lekcja 10.

Klasy i obiekty

Struktury

Bardzo bliskim kuzynem sowa kluczowego class jest sowo kluczowe struct,

uywane do deklarowania struktur. W C++ struktura jest odpowiednikiem klasy,

ale wszystkie jej skadowe s domylnie publiczne. Moesz zadeklarowa struktur

dokadnie tak, jak klas; moesz zastosowa w niej te same zmienne i funkcje

skadowe. Gdy przestrzegasz jawnego deklarowania publicznych i prywatnych

sekcji klasy, nie ma adnej rónicy pomidzy klas a struktur. Spróbuj wprowadzi

do listingu 10.7 nastpujce zmiany:

X

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

X

w linii 17., zmie class Rectangle na struct Rectangle.

Nastpnie skompiluj i uruchom program. Otrzymane wyniki nie powinny si od

siebie róni .

Prawdopodobnie zastanawiasz si, dlaczego dwa sowa kluczowe speniaj t

sam funkcj. Przyczyn naley szuka w historii jzyka. Jzyk C++ powstawa

jako rozszerzenie jzyka C. Jzyk C posiada struktury, ale nie posiadaj one metod.

Bjarne Stroustrup, twórca jzyka C++, rozbudowa struktury, ale zmieni ich nazw

na klasy, odzwierciedlajc w ten sposób ich nowe, rozszerzone moliwoci oraz

zmian w domylnej dostpnoci elementów skadowych. To pozwala równie

na uywanie w programach C++ ogromnej biblioteki funkcji jzyka C.

Tak

Nie

Umieszczaj deklaracj klasy w pliku
nagówkowym .h, za funkcje skadowe
definiuj w pliku .cpp.

Uywaj const wszdzie tam, gdzie
jest to moliwe.

Nie przechod dalej, zanim dokadnie
nie zrozumiesz zasady dziaania klasy.

Podsumowanie

W tej lekcji nauczye si tworzy nowe typy danych za pomoc klas. Wiesz take,

jak definiowa zmienne tych nowych typów, które nazywamy obiektami.

Klasa moe mie dane skadowe, którymi s zmienne rónych typów, cznie

z innymi klasami. Poza tym, klasa moe zawiera funkcje skadowe — nazywane

równie metodami. Wymienione funkcje skadowe su do manipulowania

danymi skadowymi oraz przeprowadzania innych operacji.

background image

Pytania i odpowiedzi

341

Elementy skadowe klasy, zarówno dane, jak i funkcje, mog by publiczne bd

prywatne. Elementy publiczne s dostpne w dowolnym miejscu programu.

Z kolei elementy prywatne s dostpne jedynie dla funkcji skadowych danej

klasy. Domylnie, elementy skadowe s definiowane jako prywatne.

Dobrym nawykiem w programowaniu jest izolowanie interfejsu — inaczej

deklaracji — klasy w pliku nagówkowym. Zazwyczaj odbywa si to poprzez

uycie pliku z rozszerzeniem .h, a nastpnie wykorzystanie go w plikach kodu

(z rozszerzeniem .cpp) za pomoc instrukcji include. Implementacja metod klasy

znajduje si w pliku z rozszerzeniem .cpp.

Konstruktory klasy mog by uywane do inicjalizacji danych skadowych

obiektu. Natomiast destruktory s wykonywane w trakcie niszczenia obiektu.

W destruktorze bardzo czsto nastpuje zwolnienie pamici i innych zasobów,

które mogy zosta zaalokowane przez metody klasy.

Pytania i odpowiedzi

Pytanie:Jakduyjestobiektklasy?

Odpowied: Wielko obiektu w pamici zaley od wielkoci jego zmiennych

skadowych. Metody klasy zuywaj bardzo niewielkie iloci pamici, która jest

wykorzystywana do przechowywania informacji o pooeniu metody (wskanika).

Niektóre kompilatory umieszczaj zmienne w pamici w taki sposób, e dwubajtowe

zmienne zuywaj wicej ni tylko dwa bajty pamici. Zajrzyj do dokumentacji

uywanego kompilatora, aby to sprawdzi . Jednak na tym etapie nie naley

przejmowa si takimi szczegóami.

Pytanie:JeelizadeklarujklasCatwrazzprywatnymelementemskadowym

itsAge,anastpniezdefiniujdwaobiektyFriskyiBoots,czyobiektBoots

bdziemiadostpdozmiennejskadowejitsAgeobiektuFrisky?

Odpowied: Nie. Róne egzemplarze klasy mog uzyska dostp jedynie do danych

publicznych innych egzemplarzy tej klasy. Innymi sowy, jeeli Frisky i Boots

to egzemplarze klasy Cat, funkcje skadowe obiektu Frisky mog uzyska dostp

do danych obiektu Frisky, ale ju nie do danych obiektu Boots.

Pytanie:Dlaczegoniepowinienemdefiniowajakopublicznychwszystkich

danychskadowych?

background image

342

Lekcja 10.

Klasy i obiekty

Odpowied: Zdefiniowanie danych skadowych jako prywatne umoliwia

klientowi klasy uywanie tych danych bez adnej zalenoci dotyczcej sposobu

ich przechowywania bd obliczania. Przykadowo, jeeli klasa Cat (kot) ma

metod GetAge(), klient klasy Cat moe zapyta obiekt o wiek kota, nie znajc

i nie przejmujc si sposobem, w jaki klasa Cat przechowuje ten wiek bd jak

oblicza go w locie. Oznacza to, e programista klasy Cat moe w przyszoci zmieni

projekt tej klasy bez wymagania od uytkowników klasy Cat zmiany ich programów.

Pytanie:Jeeliuyciefunkcjiconstdozmianyklasypowodujebdwtrakcie

kompilacji,todlaczegoniepowinienempoprostupozbysisówkluczowych

const,bymiepewno ,etebdyniewystpi?

Odpowied: Jeeli funkcja skadowa nie powinna zmienia klasy, to uycie sowa

kluczowego const jest dobrym sposobem zagwarantowania, e kompilator

pomoe Ci w wykryciu popenionych bdów. Przykadowo, funkcja GetAge()

moe nie mie adnego powodu do zmiany klasy Cat, ale w implementacji moe

znajdowa si ponisza linia kodu:

if (itsAge = 100) cout << "Hej! Masz 100 lat\n";

Zdefiniowanie funkcji GetAge() jako const powoduje, e kompilator zgosi bd

w powyszej linii kodu. Celem programisty byo sprawdzenie, czy warto

zmiennej itsAge wynosi 100, ale ten kod przez pomyk przypisuje warto 100

zmiennej itsAge. Poniewa przypisanie powoduje zmian klasy — a zdefiniowano,

e ta metoda nie powinna modyfikowa klasy — kompilator wychwytuje bd.

Ten rodzaj bdu moe by trudny do wychwycenia poprzez samo przegldanie

kodu. Oko bardzo czsto widzi to, co chce zobaczy . Co waniejsze, moe wydawa

si, e program dziaa prawidowo, cho zmiennej itsAge przypisano niewaciw

warto . Wczeniej czy póniej to musi spowodowa problemy.

Pytanie:CzyistniejejakikolwiekpowóduywaniastrukturywprogramieC++?

Odpowied: Wielu programistów C++ rezerwuje sowo kluczowe struct dla

klas pozbawionych funkcji. To relikt starych struktur C, które nie miay funkcji.

Szczerze mówic, to mylca i kiepska praktyka programistyczna. Dzisiejsza

struktura pozbawiona metod jutro moe ich potrzebowa . Wówczas bdziesz

zmuszony albo do zmiany na typ class, albo do zamania reguy i umieszczenia

metod w strukturze. Jeeli musisz wywoa star funkcj jzyka C wymagajc

okrelonej struktury, jest to jedyny dobry powód jej uywania.

background image

Warsztaty

343

Pytanie:Niektórzyprogrami cipracujcyzprogramowaniemzorientowanym

obiektowouywajterminutworzenieegzemplarza.Cotooznacza?

Odpowied: Tworzenieegzemplarza to po prostu okrelenie procesu tworzenia

obiektu na podstawie klasy. Okrelony obiekt zdefiniowany jako konkretny typ

klasy to pojedynczy egzemplarz klasy.

Warsztaty

Warsztaty zawieraj pytania w formie quizu, które pomog Ci w utrwaleniu

wiedzy przedstawionej w tej lekcji, a take wiczenia pozwalajce na sprawdzenie

stopnia opanowania materiau. Spróbuj odpowiedzie na pytania i rozwiza quiz

przed sprawdzeniem odpowiedzi w dodatku D. Zanim przejdziesz do kolejnej

lekcji, upewnij si take, e rozumiesz odpowiedzi.

Quiz

1.

Co to jest operator kropki i do czego suy?

2.

Co powoduje zarezerwowanie pamici — deklaracja czy definicja?

3.

Czy deklaracja klasy jest jej interfejsem, czy implementacj?

4.

Jaka jest rónica midzy publicznymi i prywatnymi danymi skadowymi?

5.

Czy funkcja skadowa moe by prywatna?

6.

Czy dana skadowa moe by publiczna?

7.

Jeeli zadeklarujesz dwa obiekty Cat, to czy mog mie róne wartoci

w swoich elementach skadowych itsAge?

8.

Czy deklaracje klas s koczone rednikiem? A definicje metod klasy?

9.

Jaki bdzie nagówek funkcji Meow() klasy Cat, jeli nie pobiera ona

parametrów i zwraca void?

10.

Która funkcja jest wywoywana w celu inicjalizacji klasy?

wiczenia

1.

Napisz kod deklarujcy klas o nazwie Employee wraz z nastpujcymi

danymi skadowymi: itsAge, itsYearsOfService oraz itsSalary.

2.

Przepisz deklaracj klasy Employee w taki sposób, aby dane skadowe

byy prywatne. Zapewnij publiczne metody akcesorów pozwalajce na

pobieranie i ustawianie wartoci kadej danej skadowej.

background image

344

Lekcja 10.

Klasy i obiekty

3.

Napisz program uywajcy klasy Employee, który tworzy dwóch

pracowników. Ustaw wartoci ich danych skadowych itsAge,

itsYearsOfService i itsSalary, a nastpnie wywietl je. Bdziesz

musia doda kod take w metodach akcesorów.

4.

Kontynuujc wiczenie 3., napisz kod dla metody klasy Employee, której

celem bdzie podanie zarobków kadego pracownika zaokrglonych

do najbliszego tysica.

5.

Zmie klas Employee w taki sposób, aby móg zainicjalizowa dane

skadowe itsAge, itsYearsOfService oraz itsSalary w trakcie tworzenia

pracownika.

6.

owcybdów: Co jest nie tak z ponisz deklaracj?

class Square
{
public:
int Side;
}

7.

owcybdów: Dlaczego ponisza deklaracja nie jest zbyt uyteczna?

class Cat
{
int GetAge() const;
private:
int itsAge;
};

8.

owcybdów: Wymie trzy bdy w poniszym kodzie, które powinny

by znalezione przez kompilator.

class TV
{
public:
void SetStation(int Station);
int GetStation() const;
private:
int itsStation;
};
main()
{
TV myTV;
myTV.itsStation = 9;
TV.SetStation(10);
TV myOtherTv(2);
}


Wyszukiwarka

Podobne podstrony:
C dla kazdego Wydanie II cppint
C dla kazdego Wydanie II cppint
C dla kazdego Wydanie II cppint
PHP, MySQL i Apache dla kazdego Wydanie II
PHP, MySQL i Apache dla kazdego Wydanie II
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP i MySQL Dla kazdego Wydanie II phmdk2
C dla każdego Wydanie II
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
C dla kazdego Wydanie II
PHP MySQL i Apache dla kazdego Wydanie II
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP, MySQL i Apache dla kazdego Wydanie II
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP MySQL i Apache dla kazdego Wydanie II pmsadk
PHP MySQL i Apache dla kazdego Wydanie II 2
PHP, MySQL i Apache dla kazdego Wydanie II

więcej podobnych podstron