Książka "Programowanie gier. Kompendium" dostarczy całej potrzebnej wiedzy, byś stał się twórcą pasjonujących gier komputerowych.

Podzielona na rozdziały zgodnie z poziomem zaawansowania, opisuje kolejno wszystkie aspekty dotyczące programowania gier. Mniej doświadczeni czytelnicy poznać mogą zasady posługiwania się językiem C++ i sprawdzić swe umiejętności pisząc dwie gry tekstowe. Ale to tylko rozgrzewka przed skokiem w krainę DirectX i poznaniem podstawowych składników tej najbardziej rozrywkowej z bibliotek, czyli DirectX Graphics, DirectSound i DirectInput. Twoje umiejętności podniesie z pewnością zaprojektowanie własnych, uniwersalnych modułów, z pomocą których tworzone są przykładowe programy.
Kolejna część książki opisuje w przystępny sposób bardziej zaawansowane tematy, takie jak matematyczne podstawy tworzenia gier, modelowanie fizyczne, sztuczna inteligencja. Na zakończenie dowiesz się, jak napisać prawdziwą, dużą i atrakcyjną grę i... jak ją sprzedać.

Książka zawiera:

• Podstawy C++ i środowiska Visual C++
• Zmienne, operatory, funkcje C++
• Projekty wieloplikowe i preprocesor
• Łańcuchy i wskaźniki
• Programowanie obiektowe: klasy, dziedziczenie
• Strumienie danych
• Projektowanie dużych aplikacji
• Projektowanie bibliotek gier
• Wprowadzenie do programowania w Windows i DirectX
• Grafika w DirectX, DirectInput i DirectSound
• Podstawowe algorytmy i struktury danych
• Matematyczne aspekty programowania gier
• Sztuczna inteligencja w grach
• Modelowanie fizyczne - pisanie gier opartych na prawach fizyki
• Publikowanie gier

Na dołączonej płycie CD znajdują się: Microsoft DirectX 8.1 SDK, Caligari TrueSpace 5 (wersja testowa), Syntrillium CollEdit 2000 (wersja testowa), Jasc Zaint Shop Pro 7 (wersja testowa), gry Gemdrop, Smiley, Smugglets 2 oraz kod źródłowy zamieszczonych w książce przykładów.

 

Osoby które kupowały "Programowanie gier. Kompendium", wybierały także:

• Tworzenie gier w języku HTML5 dla profesjonalistów. Wydanie II 67,42 zł, (20,90 zł -69%)
• Baw się kodem! Twoja własna gra. CoderDojo Nano 24,69 zł, (7,90 zł -68%)
• Twórz gry w Pythonie. Kurs video. Poznaj bibliotekę PyGame 243,59 zł, (112,05 zł -54%)
• Gry Unity i Facebook. Efektywna integracja, budowanie zasięgu i popularności. Kurs video 47,93 zł, (22,05 zł -54%)
• Unity. Kurs video. Poziom pierwszy. Tworzenie gier komputerowych 3D 47,93 zł, (22,05 zł -54%)

• 
• 
• 
• 
• 

Spis treści

Programowanie gier. Kompendium -- spis treści

O Autorze (17)

Wstęp (19)

Część I Programowanie w języku C++ (21)

Rozdział 1. Wprowadzenie do programowania w C++ (23)

• Dlaczego akurat C++? (23)
  
• Praca z edytorem Visual C++ (24)
  
  • Tworzenie obszaru roboczego (24)
  • Tworzenie projektów (25)
  • Tworzenie i dodawanie plików (26)
• Pierwszy program: "Witajcie, dobrzy ludzie" (27)
  
• Struktura programu w C++ (30)
  
  • Język projektowania programów (PDL) (31)
  • Kod źródłowy i jego kompilacja (32)
  • Obiekty i konsolidacja (32)
  • Plik wykonywalny (33)
• Komentarze (33)
  
• Szukanie błędów (34)
  
• Ostrzeżenia (36)
  
• Podsumowanie (37)
  
• Pytania i odpowiedzi (38)
  
• Ćwiczenia (39)

Rozdział 2. Zmienne i operatory (41)

• Zmienne i pamięć (41)
  
• Typy zmiennych (42)
  
• Używanie zmiennych w programach (44)
  
  • Deklarowanie zmiennej (44)
  • Używanie zmiennych (45)
  • Inicjowanie zmiennych (46)
• Modyfikatory zmiennych (47)
  
  • Stałe (const) (47)
  • Zmienna typu register (48)
• Nazewnictwo zmiennych (49)
  
• Redefinicja nazw typów (49)
  
• Co to jest operator? (50)
  
  • Operator przyporządkowania (50)
  • Operatory matematyczne (50)
  • Operatory jednoargumentowe (51)
  • Operatory dwuargumentowe (52)
  • Złożone operatory przyporządkowania (53)
• Operatory przesunięcia bitowego (54)
  
• Operatory porównania (54)
  
• Operator warunkowy (55)
  
• Operatory logiczne (56)
  
• Kolejność operatorów (57)
  
• Podsumowanie (58)
  
• Pytania i odpowiedzi (59)
  
• Ćwiczenia (59)

Rozdział 3. Funkcje i przebieg programu (61)

• Funkcje: czym są i do czego się przydają? (61)
  
• Tworzenie i korzystanie z funkcji (63)
  
  • Deklarowanie prototypu (63)
• Parametry domyślne (66)
  
• Zakres zmiennej (67)
  
  • Zmienne lokalne (68)
  • Zmienne globalne (68)
  • Zmienne statyczne (69)
• Rekurencja (70)
  
• O czym warto pamiętać, korzystając z funkcji? (72)
  
• Przebieg programu (73)
  
• Bloki kodu i pojedyncze instrukcje (73)
  
• Instrukcje if, else if i else (73)
  
  • if (74)
  • else (75)
• Pętle while, do ... while i for (76)
  
  • while (76)
  • do ... while (77)
  • for (78)
• Przerywanie i kontynuacja pętli (80)
  
  • break (80)
  • continue (80)
• Instrukcja switch (82)
  
• Liczby losowe (84)
  
• Pierwsza gra - "Craps" (87)
  
  • Cel (87)
  • Zasady (87)
  • Projekt (87)
  • Implementacja (88)
• Podsumowanie (94)
  
• Pytania i odpowiedzi (94)
  
• Ćwiczenia (94)

Rozdział 4. Projekty wieloplikowe i preprocesor (97)

• Pliki źródłowe a pliki nagłówków (97)
  
• Korzystanie z wielu plików (98)
  
• Co to jest preprocesor? (100)
  
• Unikanie podwójnych załączeń (101)
  
  • Użycie dyrektywy #pragma (102)
  • Użycie #ifdef, #define i #endif (102)
• Makra (104)
  
• Inne dyrektywy preprocesora (105)
  
• Podsumowanie (105)
  
• Ćwiczenia (105)

Rozdział 5. Tablice, wskaźniki i łańcuchy (107)

• Czym jest tablica? (107)
  
• Deklarowanie i używanie tablicy (107)
  
  • Deklaracja (108)
  • Używanie tablic (108)
  • Inicjowanie tablicy (110)
• Tablice wielowymiarowe (111)
  
• Co wskazują wskaźniki? (113)
  
• Wskaźniki a zmienne (114)
  
  • Deklaracja i inicjowanie (114)
  • Używanie wskaźników (114)
• Wskaźniki a tablice (116)
  
  • Związek wskaźników z tablicami (116)
  • Przesyłanie tablic do funkcji (116)
• Deklaracja i rezerwacja pamięci dla wskaźnika (118)
  
  • Rezerwacja pamięci (118)
  • Uwalnianie pamięci (119)
• Operatory wskaźnikowe (121)
  
• Manipulowanie pamięcią (124)
  
  • memcpy (124)
  • memset (125)
• Łańcuchy (125)
  
  • Łańcuchy a tablice (125)
  • Korzystanie z łańcuchów (125)
  • Operacje na łańcuchach (126)
• Podsumowanie (141)
  
• Pytania i odpowiedzi (141)
  
• Ćwiczenia (142)

Rozdział 6. Klasy (143)

• Czym jest klasa? (143)
  
  • Nowe typy (144)
• Tworzenie klas (144)
  
  • Projektowanie (144)
  • Definiowanie (145)
  • Implementacja (146)
• Korzystanie z klas (146)
  
• Składowe prywatne, publiczne i chronione (146)
  
  • Tryb prywatny (private) (147)
  • Tryb publiczny (public) (147)
  • Tryb chroniony (protected) (148)
  • Który tryb jest najlepszy? (148)
• Konstruktory i destruktory (149)
  
  • Konstruktor domyślny (149)
  • Konstruktory ogólne (150)
  • Konstruktor kopiujący i wskazania (150)
  • Destruktor (151)
• Przeładowywanie operatorów (152)
  
• Przykład zastosowania klas - klasa String (153)
  
• Podstawy dziedziczenia i polimorfizmu (158)
  
  • Dziedziczenie (158)
  • Polimorfizm (163)
• Wyliczenia (166)
  
• Unie (167)
  
• Składowe statyczne (168)
  
• Przydatne techniki korzystania z klas (169)
  
  • Klasa singleton (169)
  • Fabryka obiektów (172)
• Podsumowanie (176)
  
• Pytania i odpowiedzi (177)
  
• Ćwiczenia (177)

Rozdział 7. "Potwór" - pierwsza prawdziwa gra (179)

• ConLib (179)
  
  • Projektowanie (180)
  • Implementacja (182)
• Tworzenie "Potwora" (192)
  
  • Cel gry (192)
  • Reguły gry (193)
  • Projektowanie gry (193)
  • Implementacja (197)
• Podsumowanie (215)

Rozdział 8. Strumienie (217)

• Co to jest strumień? (217)
  
• Strumienie binarne i tekstowe (217)
  
• Wejście i wyjście (218)
  
  • istream (218)
  • ostream (221)
• Strumienie plików (223)
  
  • Otwieranie i zamykanie strumieni (223)
  • Tekst (227)
  • Tryb binarny (232)
• Modyfikacja gry "Potwór" - zapisywanie i odczyt gry (236)
  
• Podsumowanie (242)
  
• Pytania i odpowiedzi (242)
  
• Ćwiczenia (243)

Rozdział 9. Architektura oprogramowania (245)

• Rola projektowania w tworzeniu programów (245)
  
• Strategie projektowe (246)
  
  • Strategia odgórna (246)
  • Strategia oddolna (246)
  • Strategia odgórna kontra oddolna (247)
• Kilka podstawowych technik (247)
  
  • Przykład 1. Operator przyporządkowania zamiast równości (247)
  • Przykład 2. Instrukcje kontra bloki (248)
  • Przykład 3. Makra kontra funkcje inline (248)
  • Przykład 4. Prywatne kontra publiczne, przypadek pierwszy (249)
  • Przykład 5. Prywatne kontra publiczne, przypadek drugi (250)
• Moduły i stosowanie wielu plików (251)
  
  • Tworzenie modułów w C++ (251)
  • Dlaczego warto tworzyć moduły? (252)
• Konwencje nazewnicze (252)
  
  • Nazywanie funkcji (252)
  • Nazwy zmiennych (253)
  • Identyfikacja (253)
• Gdzie zdrowy rozsądek wygrywa z projektem (254)
  
• Metoda projektowania używana w tej książce (254)
  
• Podsumowanie (256)
  
• Pytania i odpowiedzi (256)
  
• Ćwiczenia (257)

Część II Programowanie w środowisku Windows (259)

Rozdział 10. Projektowanie biblioteki gier: Mirus (261)

• Opis ogólny (261)
  
• Komponenty biblioteki Mirus (262)
  
• Komponent pomocniczy (262)
  
• Komponent Windows (263)
  
• Komponent graficzny (263)
  
  • mrScreen (264)
  • mrRGBAImage (264)
  • mrSurface (264)
  • mrTexture (265)
  • mrTemplateSet (265)
  • mrAnimation (265)
  • mrABO (265)
• Komponent dźwiękowy (266)
  
  • mrSoundPlayer (266)
  • mrCDPlayer (266)
• Komponent komunikacji z użytkownikiem (267)
  
  • mrKeyboard (267)
  • mrMouse (267)
  • mrJoystick (268)
• Tworzenie komponentu pomocniczego (268)
  
  • Deklarowanie typów (268)
  • mrTimer (269)
  • Jak utworzyć plik błędów (274)
• Jak korzystać z biblioteki Mirus (275)
  
• Podsumowanie (275)
  
• Pytania i odpowiedzi (275)

Rozdział 11. Wprowadzenie do programowania w Windows (277)

• Historia Windows (277)
  
• Wstęp do programowania w Windows (278)
  
  • Okna (278)
  • Wielozadaniowość (279)
  • Windows ma swój własny API (280)
  • Kolejki komunikatów (280)
• Visual C++ a aplikacje Windows (280)
  
• Tworzenie aplikacji Windows (281)
  
  • WinMain kontra Main (283)
  • Tworzenie okna (284)
  • Pętla komunikatów (288)
  • Obsługa komunikatów (289)
• Tworzenie pętli komunikatów działającej w czasie rzeczywistym (291)
  
• Tworzenie ogólnej klasy okna (294)
  
• Wykorzystanie szkieletu okna z biblioteki Mirus (301)
  
• Funkcje okien (302)
  
  • SetPosition (302)
  • GetPosition (303)
  • SetSize (304)
  • GetSize (304)
  • Show (305)
• Podsumowanie (305)
  
• Pytania i odpowiedzi (305)
  
• Ćwiczenia (306)

Rozdział 12. Wprowadzenie do DirectX (307)

• Co to jest DirectX? (307)
  
• Krótka historia DirectX (307)
  
• Dlaczego akurat DirectX? (308)
  
• Komponenty DirectX (309)
  
• Jak działa DirectX? (310)
  
  • Warstwa abstrakcji sprzętowej (310)
  • Model COM (311)
  • COM i DirectX (312)
• Jak używać DirectX w Visual C++? (313)
  
• Podsumowanie (314)
  
• Pytania i odpowiedzi (314)
  
• Ćwiczenia (314)

Rozdział 13. Grafika DirectX (315)

• Używane interfejsy (315)
  
• Korzystanie z Direct3D: podstawy (317)
  
• Powierzchnie, bufory i łańcuchy zamiany (329)
  
  • Powierzchnie (329)
  • Bufory (329)
  • Łańcuchy zamiany (330)
• Renderowanie powierzchni (330)
  
• Wierzchołki, wielokąty i tekstury (336)
  
  • Wierzchołki i wielokąty (337)
  • Tekstury (337)
  • Z trzech wymiarów na dwa (340)
• Mapy bitowe Windows (347)
  
  • Struktura mapy bitowej (348)
  • Ładowanie mapy bitowej (349)
• Tryb pełnoekranowy i inne tryby kolorów (350)
  
• Teoria kolorów i kluczowanie kolorów (351)
  
  • Teoria kolorów (351)
  • Kluczowanie kolorów (353)
• Pliki Targa (354)
  
  • Struktura pliku Targa (354)
  • Ładowanie pliku Targa (355)
• Animacja i zestawy szablonów (356)
  
  • Animacja (356)
  • Zestawy szablonów (356)
• Wykrywanie kolizji (357)
  
  • Figury opisujące (357)
  • Okręgi opisujące (357)
  • Prostokąty opisujące (358)
• Manipulacja obrazem dwuwymiarowym (360)
  
  • Przesunięcie (360)
  • Skalowanie (361)
  • Obrót (361)
• Kreślenie figur płaskich (364)
  
  • Linie (364)
  • Prostokąty i inne wielokąty (367)
  • Okręgi (368)
• Tworzenie biblioteki Mirus (368)
  
  • mrScreen (368)
  • mrRGBAImage (384)
  • mrSurface (395)
  • mrTexture (402)
  • mrTemplateSet (409)
  • mrAnimation (413)
  • mrABO (419)
• Podsumowanie (434)
  
• Pytania i odpowiedzi (435)
  
• Ćwiczenia (435)

Rozdział 14. DirectInput (437)

• Wprowadzenie do DirectInput (437)
  
  • Dane niebuforowane (438)
  • Dane buforowane (438)
• Klasa mrInputManager (439)
  
• Klasa mrKeyboard (441)
  
• Klasa mrMouse (453)
  
• Klasa mrJoystick (464)
  
• Podsumowanie (473)
  
• Pytania i odpowiedzi (474)
  
• Ćwiczenia (474)

Rozdział 15. DirectSound (475)

• Teoria dźwięku (475)
  
• Podstawy interfejsu DirectSound (476)
  
• Klasa mrSoundPlayer (477)
  
• Klasa mrSound (480)
  
• Interfejs MCI (490)
  
• Klasa mrCDPlayer (491)
  
• Podsumowanie (496)
  
• Pytania i Odpowiedzi (497)
  
• Ćwiczenia (497)

Część III Właściwe programowanie gry (499)

Rozdział 16. Wprowadzenie do projektowania gry (501)

• Na czym polega projektowanie gier? (501)
  
• Ta straszna dokumentacja projektu (502)
  
• Dlaczego technika "mam to wszystko w mojej głowie" nie jest dobra? (503)
  
• Dwa rodzaje projektów (504)
  
  • Miniprojekt (504)
  • Kompletny projekt (504)
• Wypełnianie tworzonej dokumentacji projektu (505)
  
  • Ogólny opis gry (505)
  • Docelowy system operacyjny oraz wymagania gry (505)
  • Opowieść tworząca fabułę gry (506)
  • Ogólne założenia grafiki i dźwięku (506)
  • Menu (506)
  • Przebieg gry (506)
  • Opis postaci i bohaterów niezależnych (506)
  • Schemat sztucznej inteligencji gry (506)
  • Podsumowanie (507)
• Przykładowy projekt gry: "Najeźdźcy z kosmosu" (507)
  
  • Ogólny opis gry (507)
  • Docelowy system operacyjny i wymagania gry (507)
  • Fabuła gry (508)
  • Ogólne założenia grafiki i dźwięku (508)
  • Menu (508)
  • Przebieg gry (509)
  • Opis postaci i bohaterów niezależnych (509)
  • Schemat sztucznej inteligencji gry (510)
  • Podsumowanie gry (510)
• Podsumowanie (510)
  
• Pytania i Odpowiedzi (511)
  
• Ćwiczenia (511)

Rozdział 17. Algorytmy i struktury danych (513)

• Znaczenie doboru właściwych struktur danych i algorytmów (513)
  
• Listy (515)
  
  • Prosta struktura listy (516)
  • Listy dwustronnie powiązane (524)
  • Listy zapętlone (524)
  • Zalety list (525)
  • Wady list (526)
• Drzewa (526)
  
• Drzewa uniwersalne (527)
  
  • Konstruowanie drzewa uniwersalnego (530)
  • Trawersowanie drzewa uniwersalnego (531)
  • Destruktor drzewa uniwersalnego (533)
  • Zastosowania drzew uniwersalnych (533)
• Drzewa przeszukiwania binarnego (534)
  
  • Krótki wykład na temat drzew binarnych (534)
  • Czym jest drzewo przeszukiwania binarnego? (535)
  • Przeszukiwanie drzewa przeszukiwania binarnego (536)
  • Wstawianie elementów do drzewa przeszukiwania binarnego (538)
  • Usuwanie wartości z drzewa przeszukiwania binarnego (539)
  • Uwarunkowania związane z wydajnością (546)
  • Zastosowania drzew przeszukiwania binarnego (547)
• Sortowanie danych (547)
  
  • Algorytm bubblesort (548)
  • Algorytm quicksort (550)
  • Porównanie sposobów sortowania (554)
• Kompresja danych (555)
  
  • Pakowanie z użyciem kodowania grupowego (555)
  • Kod źródłowy algorytmu kodowania grupowego (556)
• Podsumowanie (557)
  
• Pytania i odpowiedzi (558)
  
• Ćwiczenia (558)

Rozdział 18. Matematyczne aspekty programowania gier (559)

• Trygonometria (559)
  
  • Reprezentacja graficzna oraz wzory (559)
  • Zależności między kątami (562)
• Wektory (563)
  
  • Dodawanie i odejmowanie wektorów (566)
  • Iloczyn i iloraz skalarny (567)
  • Długość wektora (568)
  • Wektor jednostkowy (569)
  • Wektor prostopadły (569)
  • Iloczyn skalarny (570)
  • Iloczyn skalarny z wektorem prostopadłym (571)
• Macierze (571)
  
  • Dodawanie i odejmowanie macierzy (574)
  • Skalarne mnożenie i dzielenie macierzy (575)
  • Macierz zerowa i jednostkowa (577)
  • Macierz transponowana (578)
  • Mnożenie macierzy (578)
  • Transformacja wektora (580)
• Prawdopodobieństwo (580)
  
  • Zbiory (581)
  • Suma zbiorów (581)
  • Iloczyn (część wspólna) zbiorów (582)
• Funkcje (582)
  
  • Rachunek różniczkowy (583)
  • Pochodne (584)
• Podsumowanie (584)
  
• Pytania i odpowiedzi (585)
  
• Ćwiczenia (585)

Rozdział 19. Sztuczna inteligencja w pigułce (587)

• Obszary i zastosowania sztucznej inteligencji (587)
  
  • Systemy eksperckie (587)
  • Logika rozmyta (589)
  • Algorytmy genetyczne (590)
  • Sieci neuronowe (592)
• Algorytmy deterministyczne (593)
  
  • Ruch losowy (594)
  • Śledzenie (595)
  • Wzorce (596)
• Automat skończony (598)
  
• Logika rozmyta (599)
  
  • Podstawy logiki rozmytej (599)
  • Macierze rozmyte (601)
• Metody zapamiętywania (602)
  
• Sztuczna inteligencja i gry (602)
  
• Podsumowanie (603)
  
• Pytania i odpowiedzi (603)
  
• Ćwiczenia (604)

Rozdział 20. Wstęp do modelowania fizycznego (605)

• Czym jest fizyka (605)
  
• Budujemy moduł modelowania fizycznego (606)
  
  • Do czego służy moduł fizyczny (606)
  • Założenia modułu (606)
  • mrEntity (606)
• Podstawowe pojęcia fizyczne (608)
  
  • Masa (608)
  • Czas (609)
  • Położenie (609)
  • Prędkość (610)
  • Przyspieszenie (611)
  • Środek ciężkości (612)
• Siła (613)
  
  • Siła liniowa (613)
  • Moment obrotowy (615)
  • Siła wypadkowa (616)
• Grawitacja (617)
  
  • Prawo powszechnej grawitacji (617)
  • Grawitacja na Ziemi i innych planetach (618)
  • Symulacja lotu pocisku (619)
• Tarcie (621)
  
  • Pojęcie tarcia (621)
  • Rodzaje tarcia (621)
• Obsługa kolizji (626)
  
  • Moment pędu (626)
  • Metoda impulsowa (627)
• Symulacja (630)
  
  • Odstęp czasowy rysowania ramek (632)
• Zespoły cząstek (637)
  
  • Projekt zespołu cząstek (637)
  • Program demonstracyjny (647)
• Podsumowanie (649)
  
• Pytania i odpowiedzi (650)
  
• Ćwiczenia (651)

Rozdział 21. Przykładowa gra "Breaking Through" (653)

• Projekt "Breaking Through" (653)
  
  • Ogólne zasady (653)
  • Wymagania sprzętowe (653)
  • Scenariusz (654)
  • Reguły (654)
  • Grafika (654)
  • Menu (655)
  • Przebieg gry (656)
  • Składniki aplikacji (657)
• Implementacja gry "Breaking Through" (659)
  
  • btBlock (659)
  • btPaddle (663)
  • btBall (667)
  • btGame (673)
  • Okno główne (699)
• Podsumowanie (701)

Rozdział 22. Publikacja gry (703)

• Czy Twoja gra warta jest opublikowania? (703)
  
• Gdzie powinieneś zapukać? (704)
  
• Naucz się pukać właściwie (704)
  
• Kontrakt (705)
  
  • List intencyjny (705)
  • Kontrakt (706)
• Kamienie milowe (706)
  
  • Lista błędów (707)
  • Dzień wydania (707)
• Gdy nie znajdziesz wydawcy (707)
  
• Wywiady (707)
  
  • Niels Bauer: Niels Bauer Software Design (707)
  • André LaMothe: Xtreme Games LLC (709)
• Podsumowanie (711)
  
• Przydatne adresy (711)
  
• Kilka słów na koniec (711)

Dodatki (713)

Dodatek A Zawartość płyty CD-ROM (715)

• Kody źródłowe (715)
  
• Microsoft DirectX 8.0 SDK (715)
  
• Aplikacje (715)
  
  • Jasc Paint Shop Pro 7 (716)
  • Syntrillium Cool Edit 2000 (716)
  • Caligari TrueSpace 5 (716)
• Gry (716)
  
  • Gamedrop (716)
  • Smiley (717)
  • Smugglers 2 (717)

Dodatek B Wykrywanie błędów za pomocą Microsoft Visual C++ (719)

• Pułapki i praca krokowa (719)
  
  • Pułapki (719)
  • Praca krokowa (720)
• Zmiana wartości zmiennych podczas działania programu (720)
  
• Podglądanie zmiennych (721)

Dodatek C System dwójkowy, dziesiętny i szesnastkowy (723)

• System binarny (723)
  
• System heksadecymalny (723)
  
• System dziesiętny (724)

Dodatek D Kompendium języka C (725)

• Standardowa biblioteka wejścia-wyjścia (725)
  
• Obsługa plików (726)
  
• Struktury (728)
  
• Dynamiczna alokacja pamięci (728)

Dodatek E Odpowiedzi do ćwiczeń (731)

• Rozdział 1. (731)
  
• Rozdział 2. (731)
  
• Rozdział 3. (732)
  
• Rozdział 4. (732)
  
• Rozdział 5. (732)
  
• Rozdział 6. (733)
  
• Rozdział 8. (733)
  
• Rozdział 9. (733)
  
• Rozdział 11. (734)
  
• Rozdział 12. (734)
  
• Rozdział 13. (734)
  
• Rozdział 14. (735)
  
• Rozdział 15. (735)
  
• Rozdział 17. (735)
  
• Rozdział 18. (735)
  
• Rozdział 19. (736)
  
• Rozdział 20. (736)

Dodatek F Słowa kluczowe C++ (737)

Dodatek G Przydatne tabele (739)

• Tabela znaków ASCII (739)
  
• Tablica całek nieoznaczonych (741)
  
• Tablica pochodnych (741)
  
• Moment bezwładności (742)

Dodatek H Dodatkowe źródła informacji (743)

• Tworzenie gier i programowanie (743)
  
• Nowości, recenzje, pobieranie plików (744)
  
• Biblioteki (744)
  
• Niezależni twórcy gier (744)
  
• Przemysł (745)
  
• Humor (745)
  
• Książki (745)

Skorowidz (747)