C_dla_programistow_gier_Wydanie_II_cpprog.pdf

(464 KB) Pobierz
C++ dla programistów
gier. Wydanie II
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
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
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
Spis treści
Wprowadzenie ................................................................................ 13
Część I
Elementy C++ .............................................................. 21
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ł 1. Dziedziczenie ................................................................................. 23
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
6
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
7
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
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ł 6. Wydajność ................................................................................... 115
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
8
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:

Zgłoś jeśli naruszono regulamin