Spis treści

C++ dla programistów 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)

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)
• 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)
• 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)

Rozdział 10. STL: algorytmy i zagadnienia zaawansowane (237)

• Obiekty funkcyjne (funktory) (237)
  
  • Wskaźniki funkcji (237)
  • Funktory (238)
  • Adaptory funktorów (240)
• Algorytmy (241)
  
  • Algorytmy niemodyfikujące (242)
  • Algorytmy modyfikujące (245)
  • Algorytmy sortujące (248)
  • Uogólnione algorytmy numeryczne (249)
• Ciągi znaków (250)
  
  • Ciągle bez ciągów (250)
  • Klasa string (252)
  • Wydajność (254)
  • Pamięć (255)
  • Alternatywy (256)
• Alokatory (zaawansowane) (257)
  
• Kiedy STL nie wystarcza (zaawansowane) (260)
  
• Wnioski (262)
  
• Zalecana lektura (262)

Rozdział 11. Poza STL: własne struktury i algorytmy (265)

• Grafy - studium przypadku (265)
  
  • Powtórka z grafów (265)
  • Ogólniej o grafie (267)
  • W kwestii kosztów (267)
  • Koszt przebycia krawędzi a jakość rozgrywki (268)
• Grafy w C++ (269)
  
• Zaprząc grafy do pracy (271)
  
• "Inteligencja" grafów (276)
  
  • Życie na krawędzi (276)
  • Aktualizacja, wracamy do C++ (279)
  • Implementacja wyznaczania trasy (285)
  • A może A* (zaawansowane) (293)
• Inne zastosowania grafów (294)
  
  • Optymalizacja przejść w interfejsie użytkownika (296)
  • Brakujące ścieżki powrotne (298)
  • Zagubione plansze menu (298)
• Wnioski (299)
  
• Zalecana lektura (299)

Część III Techniki specjalne (301)

Rozdział 12. Interfejsy abstrakcyjne (303)

• Interfejsy abstrakcyjne (303)
  
• Implementacja interfejsów w C++ (305)
  
• Interfejsy abstrakcyjne w roli bariery (306)
  
  • Nagłówki i wytwórnie (308)
  • Z życia (310)
• Interfejsy abstrakcyjne w roli charakterystyk klas (312)
  
  • Implementacje (313)
  • Pytanie o interfejs (315)
  • Rozszerzanie gry (317)
• Nie wszystko złoto... (319)
  
• Wnioski (320)
  
• Zalecana lektura (321)

Rozdział 13. Wtyczki (323)

• Po co komu wtyczki (323)
  
  • Wtyczki do cudzych programów (324)
  • Wtyczki do własnych programów (325)
• Architektura wtyczek (326)
  
  • Interfejs wtyczek (326)
  • Tworzenie konkretnych wtyczek (327)
  • Obsługa różnych rodzajów wtyczek (328)
  • Ładowanie wtyczek (329)
  • Menedżer wtyczek (331)
  • Komunikacja dwukierunkowa (333)
• Żeby miało ręce i nogi... (335)
  
• Wtyczki w praktyce (335)
  
  • Stosowanie wtyczek (336)
  • Wady (336)
  • Inne platformy (337)
• Wnioski (338)
  
• Zalecana lektura (338)

Rozdział 14. C++ a skrypty (339)

• Po co jeszcze jeden język, i to skryptowy? (339)
  
  • Złe wieści... (340)
  • I wieści dobre (341)
• Rozważania o architekturze (344)
  
  • Engine kontra gameplay (345)
• Zintegrowany interpreter skryptów - nie tylko w sterowaniu rozgrywką (349)
  
  • Konsola (349)
  • Interaktywne sesje diagnostyczne (350)
  • Szybkie prototypowanie (352)
  • Automatyzacja testów (353)
• Wnioski (355)
  
• Zalecana lektura (356)
  
  • Lua (356)
  • Python (357)
  • GameMonkey Script (357)
  • AngelScript (358)

Rozdział 15. Informacja o typach w czasie wykonania (359)

• Praca bez RTTI (359)
  
• Używanie i nadużywanie RTTI (361)
  
• Standardowe RTTI w C++ (363)
  
  • Operator dynamic_cast (363)
  • Operator typeid (365)
  • Analiza RTTI w wydaniu C++ (366)
• Własny system RTTI (368)
  
  • Najprostsze rozwiązanie (368)
  • Z obsługą dziedziczenia pojedynczego (372)
  • Z obsługą dziedziczenia wielobazowego (375)
• Wnioski (378)
  
• Zalecana lektura (378)

Rozdział 16. Tworzenie obiektów i zarządzanie nimi (379)

• Tworzenie obiektów (379)
  
  • Kiedy new nie wystarcza (380)
  • Wielka selekcja (381)
• Wytwórnie obiektów (382)
  
  • Prosta wytwórnia (382)
  • Wytwórnia rozproszona (383)
  • Jawne rejestrowanie obiektów wytwórczych (384)
  • Niejawne rejestrowanie obiektów wytwórczych (385)
  • Identyfikatory typów obiektów (387)
  • Od szablonu (388)
• Obiekty współużytkowane (389)
  
  • Bez wspólnych obiektów (390)
  • Ignorowanie problemu (391)
  • Niech się właściciel martwi (392)
  • Zliczanie odwołań (393)
  • Uchwyty (396)
  • Inteligentne wskaźniki (398)
• Wnioski (401)
  
• Zalecana lektura (402)

Rozdział 17. Utrwalanie obiektów (405)

• Przegląd zagadnień dotyczących utrwalania jednostek gry (405)
  
  • Jednostki kontra zasoby (406)
  • Najprostsze rozwiązanie, które nie zadziała (406)
  • Czego potrzebujemy (407)
• Implementacja utrwalania jednostek gry (409)
  
  • Strumienie (409)
  • Zapisywanie (412)
  • Wczytywanie (416)
• Wespół w zespół (419)
  
• Wnioski (420)
  
• Zalecana lektura (421)

Rozdział 18. Postępowanie z dużymi projektami (423)

• Struktura logiczna a struktura fizyczna (423)
  
• Klasy i pliki (425)
  
• Pliki nagłówkowe (426)
  
  • Co ma się znaleźć w pliku nagłówkowym? (426)
  • Bariery włączania (427)
  • Dyrektywy #include w plikach implementacji (430)
  • Dyrektywy #include w plikach nagłówkowych (432)
  • Wstępnie kompilowane pliki nagłówkowe (434)
  • Wzorzec implementacji prywatnej (437)
• Biblioteki (440)
  
• Konfiguracje (443)
  
  • Konfiguracja diagnostyczna (444)
  • Konfiguracja dystrybucyjna (444)
  • Konfiguracja diagnostyczna zoptymalizowana (445)
• Wnioski (445)
  
• Zalecana lektura (446)

Rozdział 19. Zbrojenie gry (447)

• Stosowanie asercji (447)
  
  • Kiedy stosować asercje (448)
  • Kiedy nie stosować asercji (450)
  • Własne asercje (451)
  • Co powinno się znaleźć w ostatecznej wersji (452)
  • Własna przykładowa implementacja asercji (454)
• Zawsze świeżo (455)
  
  • Wycieki pamięci (456)
  • Fragmentacja pamięci (456)
  • Dryf zegara (456)
  • Kumulacja błędu (457)
  • Co robić? (457)
• Postępowanie ze "złymi" danymi (458)
  
  • Wykrywać asercjami (459)
  • Radzić sobie samemu (459)
  • Kompromis (461)
• Wnioski (463)
  
• Zalecana lektura (463)

Skorowidz (465)