C++ dla programistów gier. Wydanie II

Autor: Michael J. Dickheiser

Szczegóły książki w Helionie
Tytuł oryginału: C++ For Game Programmers (Second edition)
ISBN: 978-83-246-0967-3
Cena: 77 zł
Oprawa: miękka
Format: B5
Data wydania: 2007.04.19
Liczba stron: 480
Przykładowy rozdział: ftp://ftp.helion.pl/online/cpprog/cpprog-8.pdf
Kategoria: C++

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.

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)

©2007 Włodzimierz Gajda | prace magisterskie | Dubai | Korekta prac magisterskich , Ebooki programowanie androida, Pozycjonowanie stron Poznań