C++ dla programistow gier Wydanie II.pdf

C++ dla programistów

Autor: Michael J. Dickheiser

T³umaczenie: Przemys³aw Szeremiota

ISBN: 978-83-246-0967-3

Tytu³ orygina³ u: C++ For Game Programmers

(Second edition)

Format: B5, stron: 480

Wydawnictwo Helion

ul. Koœciuszki 1c

44-100 Gliwice

tel. 032 230 98 63

e-mail: helion@helion.pl

Poznaj nowoczesne metody tworzenia gier komputerowych

Wykorzystaj najefektywniejsze techniki oferowane przez C++

Popraw czytelnoœæ kodu i wydajnoœæ programów

Zastosuj wzorce projektowe

Rynek gier komputerowych jest niezwykle wymagaj¹cy. Gracze stawiaj¹ tego rodzaju

programom coraz wy¿sze wymagania, co z kolei przek³ada siê na koniecznoœæ

stosowania coraz doskonalszych technik ich tworzenia. Bêd¹c programist¹ gier

komputerowych, na pewno doskonale zdajesz sobie z tego sprawê. Jeœli chcesz,

aby kolejna stworzona przez Ciebie gra spe³nia³a oczekiwania nawet najbardziej

wybrednych graczy, wykorzystaj jêzyk C++. Jego mo¿liwoœci sprawiaj¹, ¿e jest

doskona³ym narzêdziem do tworzenia gier.

„C++ dla programistów gier. Wydanie II” to przewodnik po jêzyku C++ opisuj¹cy go

z punktu widzenia programowania specyficznych aplikacji, jakimi s¹ gry. Ksi¹¿ka

przedstawia najefektywniejsze techniki C++ i metody rozwi¹zywania problemów,

przed którymi staj¹ programiœci gier. Czytaj¹c j¹, dowiesz siê, jak zarz¹dzaæ pamiêci¹

i stosowaæ wzorce projektowe oraz STL. Poznasz mo¿liwoœci wykorzystania jêzyków

skryptowych do usprawnienia procesu tworzenia gry komputerowej. Ka¿de z rozwi¹zañ

opatrzone jest przyk³adem, dziêki czemu ³atwo bêdzie Ci zaimplementowaæ je w swoich

pracach.

Podstawy jêzyka C++

Korzystanie z szablonów

Obs³uga wyj¹tków

Zarz¹dzanie pamiêci¹

Poprawa wydajnoœci aplikacji

Wzorce projektowe

Biblioteka STL

Stosowanie jêzyków skryptowych

Zarz¹dzanie obiektami

Serializacja

Do³¹cz do elitarnej grupy programistów gier komputerowych

gier. Wydanie II

Spis treści

Wprowadzenie ................................................................................ 13

Część I Elementy C++ .............................................................. 21

Rozdział 1. Dziedziczenie ................................................................................. 23

Klasy ................................................................................................................................ 23

Dziedziczenie ................................................................................................................... 24

Polimorfizm i funkcje wirtualne ...................................................................................... 27

Dziedziczyć czy nie dziedziczyć? ................................................................................... 30

Zasada 1. Dziedziczenie kontra zawieranie .............................................................. 30

Zasada 2. Zachowanie kontra dane ........................................................................... 31

Kiedy stosować dziedziczenie, a kiedy go unikać ........................................................... 31

Implementacja dziedziczenia (zaawansowane) ............................................................... 33

Analiza kosztowa (zaawansowane) ................................................................................. 35

Alternatywy (zaawansowane) .......................................................................................... 38

Dziedziczenie a architektura programu (zaawansowane) ............................................... 39

Wnioski ............................................................................................................................ 41

Zalecana lektura ...............................................................................................................41

Rozdział 2. Dziedziczenie wielobazowe .............................................................. 43

Stosowanie dziedziczenia wielobazowego ...................................................................... 43

Wszystko w jednym .................................................................................................. 44

Wersja z zawieraniem ............................................................................................... 44

Dziedziczenie zwyczajne .......................................................................................... 46

Ratunek w dziedziczeniu wielobazowym ................................................................. 47

Problemy dziedziczenia wielobazowego ......................................................................... 47

Niejednoznaczność .................................................................................................... 48

Topografia ................................................................................................................. 48

Architektura programu .............................................................................................. 51

Polimorfizm ..................................................................................................................... 51

Kiedy stosować dziedziczenie wielobazowe, a kiedy go unikać ..................................... 53

Implementacja dziedziczenia wielobazowego (zaawansowane) ..................................... 54

Analiza kosztowa (zaawansowane) ................................................................................. 55

Rzutowanie ................................................................................................................ 55

Funkcje wirtualne z drugiej (kolejnej) klasy nadrzędnej .......................................... 57

Wnioski ............................................................................................................................ 58

Zalecana lektura ...............................................................................................................58

C++ dla programistów gier

Rozdział 3. O stałości, referencjach i o rzutowaniu ............................................ 59

Stałość .............................................................................................................................. 59

Koncepcja stałości ..................................................................................................... 60

Stałość a wskaźniki ................................................................................................... 60

Stałość a funkcje ........................................................................................................ 61

Stałość a klasy ........................................................................................................... 64

Stałe, ale zmienne — słowo mutable ........................................................................ 65

Słowo porady odnośnie const .................................................................................... 66

Referencje ........................................................................................................................ 67

Referencje kontra wskaźniki ..................................................................................... 67

Referencje a funkcje .................................................................................................. 68

Zalety referencji ........................................................................................................ 69

Kiedy stosować referencje ........................................................................................ 71

Rzutowanie ...................................................................................................................... 72

Potrzeba rzutowania .................................................................................................. 72

Rzutowanie w konwencji C++ .................................................................................. 73

Wnioski ............................................................................................................................ 76

Zalecana lektura ...............................................................................................................76

Rozdział 4. Szablony ........................................................................................ 77

W poszukiwaniu kodu uniwersalnego ............................................................................. 77

Podejście pierwsze: lista wbudowana w klasę .......................................................... 78

Podejście drugie: makrodefinicja .............................................................................. 79

Podejście trzecie: dziedziczenie ................................................................................ 80

Podejście czwarte: uniwersalna lista wskaźników void ............................................ 81

Szablony .......................................................................................................................... 83

Szablony klas ............................................................................................................. 83

Szablony funkcji ........................................................................................................ 85

Powrót do problemu listy — próba z szablonem ...................................................... 85

Wady ................................................................................................................................ 87

Złożoność .................................................................................................................. 87

Zależności .................................................................................................................. 87

Rozdęcie kodu ........................................................................................................... 88

Obsługa szablonów przez kompilator ....................................................................... 88

Kiedy stosować szablony ................................................................................................. 88

Specjalizacje szablonów (zaawansowane) ...................................................................... 89

Pełna specjalizacja szablonu ..................................................................................... 90

Częściowa specjalizacja szablonu ............................................................................. 91

Wnioski ............................................................................................................................ 91

Zalecana lektura ...............................................................................................................92

Rozdział 5. Obsługa wyjątków .......................................................................... 93

Jak sobie radzić z błędami ............................................................................................... 93

Ignorować! ................................................................................................................ 93

Stosować kody błędów .............................................................................................. 94

Poddać się (z asercjami)! ........................................................................................... 95

Stosować wywołania setjmp() i longjmp() ................................................................ 95

Stosować wyjątki C++ .............................................................................................. 96

Stosowanie wyjątków ...................................................................................................... 97

Wprowadzenie ........................................................................................................... 98

Zrzucanie wyjątków .................................................................................................. 98

Przechwytywanie wyjątków .................................................................................... 100

Spis treści

Odporność na wyjątki .................................................................................................... 103

Pozyskiwanie zasobów ............................................................................................ 104

Konstruktory ............................................................................................................ 107

Destruktory .............................................................................................................. 109

Analiza kosztowa ........................................................................................................... 109

Kiedy stosować wyjątki ................................................................................................. 111

Wnioski .......................................................................................................................... 112

Zalecana lektura ............................................................................................................. 112

Część II Wydobywanie mocy C++ ............................................. 113

Rozdział 6. Wydajność ................................................................................... 115

Wydajność i optymalizacje ............................................................................................ 115

W czasie programowania ........................................................................................ 117

Pod koniec programowania ..................................................................................... 118

Rodzaje funkcji .............................................................................................................. 119

Funkcje globalne ..................................................................................................... 119

Statyczne funkcje klas ............................................................................................. 120

Niewirtualne składowe klas .................................................................................... 120

Funkcje wirtualne przy dziedziczeniu pojedynczym .............................................. 121

Funkcje wirtualne przy dziedziczeniu wielobazowym ........................................... 123

Rozwijanie funkcji w miejscu wywołania ..................................................................... 124

Potrzeba rozwijania w funkcji ................................................................................. 124

Funkcje rozwijane w miejscu wywołania ............................................................... 125

Kiedy stosować rozwijanie zamiast wywołania? .................................................... 127

Jeszcze o narzutach wywołań funkcji ............................................................................ 128

Parametry funkcji .................................................................................................... 128

Wartości zwracane .................................................................................................. 130

Funkcje puste ........................................................................................................... 132

Unikanie kopiowania ..................................................................................................... 133

Argumenty wywołań ............................................................................................... 133

Obiekty tymczasowe ............................................................................................... 134

Jawność intencji ...................................................................................................... 135

Blokowanie kopiowania .......................................................................................... 135

Dopuszczanie kopiowania ....................................................................................... 136

Przeciążanie operatorów ......................................................................................... 137

Konstruktory i destruktory ............................................................................................. 139

Pamięci podręczne i wyrównywanie danych w pamięci (zaawansowane) ................... 143

Wzorce odwołań do pamięci ................................................................................... 144

Rozmiar obiektów ................................................................................................... 145

Rozmieszczanie składowych w obiektach .............................................................. 146

Wyrównanie pamięci ............................................................................................... 146

Wnioski .......................................................................................................................... 147

Zalecana lektura ............................................................................................................. 148

Rozdział 7. Przydział pamięci .......................................................................... 149

Stos ................................................................................................................................ 149

Sterta .............................................................................................................................. 150

Wydajność przydziału ............................................................................................. 151

Fragmentacja pamięci ............................................................................................. 152

Inne problemy ......................................................................................................... 154

Przydziały statyczne ...................................................................................................... 155

Zalety i wady przydziału statycznego ..................................................................... 156

Kiedy korzystać z przydziałów statycznych ........................................................... 157

C++ dla programistów gier

Przydziały dynamiczne .................................................................................................. 158

Łańcuch wywołań ................................................................................................... 158

Globalne operatory new i delete .............................................................................. 159

Operatory new i delete dla klas ............................................................................... 161

Własny menedżer pamięci ............................................................................................. 163

Kontrola błędów ...................................................................................................... 163

Przeglądanie stert .................................................................................................... 166

Zakładki i wycieki ................................................................................................... 166

Sterty hierarchiczne ................................................................................................. 167

Inne rodzaje przydziałów ........................................................................................ 169

Narzut mechanizmu zarządzania pamięcią ............................................................. 170

Pule pamięci .................................................................................................................. 171

Implementacja ......................................................................................................... 172

Podłączanie puli do sterty ....................................................................................... 175

Pule uniwersalne ..................................................................................................... 176

W nagłych wypadkach… ............................................................................................... 177

Wnioski .......................................................................................................................... 178

Zalecana lektura ............................................................................................................. 179

Rozdział 8. Wzorce projektowe w C++ ............................................................ 181

Czym są wzorce projektowe? ........................................................................................ 181

Wzorzec Singleton ......................................................................................................... 183

Przykład: menedżer plików ..................................................................................... 183

Implementacja Singletona ....................................................................................... 184

Wzorzec Façade ............................................................................................................. 185

Fasada dla systemu „w budowie” ............................................................................ 188

Fasada dla przeróbek ............................................................................................... 189

Wzorzec Observer ......................................................................................................... 190

Wzorzec Visitor ............................................................................................................. 195

Wnioski .......................................................................................................................... 199

Zalecana lektura ............................................................................................................. 199

Rozdział 9. Kontenery STL .............................................................................. 201

Przegląd STL ................................................................................................................. 201

Korzystać czy nie korzystać? ........................................................................................ 203

Wykorzystanie gotowego kodu ............................................................................... 203

Wydajność ............................................................................................................... 204

Wady ....................................................................................................................... 205

Kontenery sekwencyjne ................................................................................................. 206

Kontener vector ....................................................................................................... 206

Kontener deque ....................................................................................................... 211

Kontener list ............................................................................................................ 214

Kontenery asocjacyjne ................................................................................................... 217

Kontenery set i multiset ........................................................................................... 218

Kontenery map i multimap ...................................................................................... 222

Kontenery haszowane ............................................................................................. 226

Adaptory kontenerów .................................................................................................... 230

Stos .......................................................................................................................... 231

Kolejka .................................................................................................................... 231

Kolejka priorytetowa ............................................................................................... 232

Wnioski .......................................................................................................................... 233

Zalecana lektura ............................................................................................................. 235

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika: