Książka "Język C. Wskaźniki. Vademecum profesjonalisty" przeznaczona jest dla zaawansowanych studentów i profesjonalistów, zapewniając obszerne źródło informacji dla tych, którzy potrzebują dogłębnego omówienia języka C. Dokładne wyjaśnienie podstaw oraz przegląd zaawansowanych funkcji pozwala programistom skorzystać z siły wskaźników w języku C. Dokładny opis idiomów programowych oraz gruntowna dyskusja zaawansowanych tematów powoduje, że książka jest nieocenionym podręcznikiem i informatorem dla studentów i zawodowych programistów.

• Zawiera wszystko, co jest niezbędne do dogłębnego poznania języka C
• Dokładnie opisuje wskaźniki, ich składnię, techniki efektywnego użycia oraz często stosowane idiomy programistyczne, w których występują wskaźniki
• Porównuje różne metody implementacji często stosowanych abstrakcyjnych typów danych
• Zawiera wskazówki na temat efektywności, przenośności i zagadnień inżynierii programowania, jak również ostrzeżenia o często popełnianych błędach
• Oferuje prosty, konwersacyjny styl, jasno opisujący trudne tematy, zawiera wiele ilustracji i diagramów pomagających z wizualizacji skomplikowanych zagadnień
• Opisuje wszystkie funkcje z biblioteki standardowej C.

O autorze:
Kenneth A. Reek jest profesorem informatyki w Rochester Institute of Technology i doświadczonym programistą, który pracował w wielu firmach jako konsultant. Książka ta powstała po dziewięciu latach prowadzenia seminariów z programowania w C. [więcej...]

Osoby które kupowały "Język C. Wskaźniki. Vademecum profesjonalisty", wybierały także:

• Język C. Kurs video. Praktyczne wprowadzenie do programowania 99,00 zł, (44,55 zł -55%)
• Linux. Programowanie systemowe 57,00 zł, (28,50 zł -50%)
• Język C. Solidna wiedza w praktyce. Wydanie VIII 199,00 zł, (109,45 zł -45%)
• Tablice informatyczne. C 17,00 zł, (9,35 zł -45%)
• Programowanie współbieżne. Systemy czasu rzeczywistego 49,00 zł, (26,95 zł -45%)

Spis treści

Język C. Wskaźniki. Vademecum profesjonalisty -- spis treści

Przedmowa (13)

Rozdział 1. Szybki start (19)

• 1.1. Wstęp (19)
  
  • 1.1.1. Odstępy i komentarze (22)
  • 1.1.2. Dyrektywy preprocesora (23)
  • 1.1.3. Funkcja main (24)
  • 1.1.4. Funkcja czytaj_zakresy_kolumn (27)
  • 1.1.5. Funkcja przeksztalc (32)
• 1.2. Inne możliwości (35)
  
• 1.3. Kompilacja (35)
  
• 1.4. Podsumowanie (35)
  
• 1.5. Podsumowanie ostrzeżeń (36)
  
• 1.6. Podsumowanie wskazówek (36)
  
• 1.7. Pytania (37)
  
• 1.8. Ćwiczenia (37)

Rozdział 2. Podstawowe pojęcia (39)

• 2.1. Środowiska (39)
  
  • 2.1.1. Translacja (39)
  • 2.1.2. Wykonanie (41)
• 2.2. Zasady leksykalne (42)
  
  • 2.2.1. Znaki (42)
  • 2.2.2. Komentarze (44)
  • 2.2.3. Dowolna postać kodu źródłowego (44)
  • 2.2.4. Identyfikatory (45)
  • 2.2.5. Postać programu (45)
• 2.3. Styl programowania (46)
  
• 2.4. Podsumowanie (47)
  
• 2.5. Podsumowanie ostrzeżeń (48)
  
• 2.6. Podsumowanie wskazówek (48)
  
• 2.7. Pytania (48)
  
• 2.8. Ćwiczenia (50)

Rozdział 3. Dane (51)

• 3.1. Podstawowe typy danych (51)
  
  • 3.1.1. Rodzina liczb całkowitych (51)
  • 3.1.2. Typy zmiennoprzecinkowe (55)
  • 3.1.3. Wskaźniki (56)
• 3.2. Podstawowe deklaracje (58)
  
  • 3.2.1. Inicjalizacja (59)
  • 3.2.2. Deklarowanie prostych tablic (59)
  • 3.2.3. Deklaracja wskaźników (60)
  • 3.2.4. Niejawne deklaracje (61)
• 3.3. Typedef (61)
  
• 3.4. Stałe (62)
  
• 3.5. Zasięg (63)
  
  • 3.5.1. Zasięg ograniczony do bloku (64)
  • 3.5.2. Zasięg ograniczony do pliku (65)
  • 3.5.3. Zasięg ograniczony do prototypu (65)
  • 3.5.4. Zasięg ograniczony do funkcji (65)
• 3.6. Sposób konsolidacji (66)
  
• 3.7. Klasa zapisu (67)
  
  • 3.7.1. Inicjalizacja (69)
• 3.8. Słowo kluczowe static (69)
  
• 3.9. Przykład zasięgu, rodzaju łączenia i klas zapisu (70)
  
• 3.10. Podsumowanie (72)
  
• 3.11. Podsumowanie ostrzeżeń (72)
  
• 3.12. Podsumowanie wskazówek (73)
  
• 3.13. Pytania (73)

Rozdział 4. Instrukcje (77)

• 4.1. Instrukcja pusta (77)
  
• 4.2. Instrukcja wyrażenia (77)
  
• 4.3. Instrukcja bloku (78)
  
• 4.4. Instrukcja if (79)
  
• 4.5. Instrukcja while (80)
  
  • 4.5.1. Instrukcje break i continue (80)
  • 4.5.2. Działanie pętli while (81)
• 4.6. Instrukcja for (82)
  
  • 4.6.1. Wykonanie pętli for (82)
• 4.7. Instrukcja do (83)
  
• 4.8. Instrukcja switch (84)
  
  • 4.8.1. Instrukcja break w switch (85)
  • 4.8.2. Wartości domyślne (86)
  • 4.8.3. Wykonanie instrukcji switch (86)
• 4.9. Instrukcja goto (87)
  
• 4.10. Podsumowanie (89)
  
• 4.11. Podsumowanie ostrzeżeń (90)
  
• 4.12. Podsumowanie wskazówek (90)
  
• 4.13. Pytania (90)
  
• 4.14. Ćwiczenia (92)

Rozdział 5. Operatory i wyrażenia (95)

• 5.1. Operatory (95)
  
  • 5.1.1. Arytmetyka (95)
  • 5.1.2. Przesunięcia (95)
  • 5.1.3. Operatory bitowe (97)
  • 5.1.4. Przypisania (98)
  • 5.1.5. Operatory jednoargumentowe (101)
  • 5.1.6. Operatory relacyjne (103)
  • 5.1.7. Operatory logiczne (104)
  • 5.1.8. Operator warunkowy (105)
  • 5.1.9. Operator przecinka (105)
  • 5.1.10. Indeks, wywołanie funkcji i element struktury (107)
• 5.2. Wartości logiczne (108)
  
• 5.3. L-wartości i R-wartości (109)
  
• 5.4. Obliczanie wyrażeń (110)
  
  • 5.4.1. Niejawna konwersja typów (110)
  • 5.4.2. Konwersje arytmetyczne (111)
  • 5.4.3. Właściwości operatorów (112)
  • 5.4.4. Priorytety i kolejność wykonywania (114)
• 5.5. Podsumowanie (116)
  
• 5.6. Podsumowanie ostrzeżeń (118)
  
• 5.7. Podsumowanie wskazówek (118)
  
• 5.8. Pytania (118)
  
• 5.9. Ćwiczenia (121)

Rozdział 6. Wskaźniki (123)

• 6.1. Pamięć i adresy (123)
  
  • 6.1.1. Adresy i zawartość (124)
• 6.2. Wartości i ich typy (124)
  
• 6.3. Zawartość zmiennej wskaźnikowej (126)
  
• 6.4. Operator dereferencji (126)
  
• 6.5. Niezainicjowane i nieprawidłowe wskaźniki (128)
  
• 6.6. Wskaźnik NULL (129)
  
• 6.7. Wskaźniki, dereferencja i L-wartości (130)
  
• 6.8. Wskaźniki, dereferencja i zmienne (131)
  
• 6.9. Stałe wskaźnikowe (131)
  
• 6.10. Wskaźniki do wskaźników (132)
  
• 6.11. Operacje na wskaźnikach (133)
  
• 6.12. Przykłady (138)
  
• 6.13. Arytmetyka wskaźników (141)
  
  • 6.13.1. Operacje arytmetyczne (142)
  • 6.13.2. Operacje relacyjne (145)
• 6.14. Podsumowanie (146)
  
• 6.15. Podsumowanie ostrzeżeń (147)
  
• 6.16. Podsumowanie wskazówek (147)
  
• 6.17. Pytania (148)
  
• 6.18. Ćwiczenia (150)

Rozdział 7. Funkcje (153)

• 7.1. Definicja funkcji (153)
  
  • 7.1.1. Instrukcja return (154)
• 7.2. Deklaracje funkcji (155)
  
  • 7.2.1. Prototypy (155)
  • 7.2.2. Domyślne założenia dla funkcji (158)
• 7.3. Argumenty funkcji (158)
  
• 7.4. ATD i czarne skrzynki (162)
  
• 7.5. Rekurencja (164)
  
  • 7.5.1. Śledzenie funkcji rekurencyjnych (166)
  • 7.5.2. Rekurencja a iteracja (169)
• 7.6. Zmienna lista argumentów (172)
  
  • 7.6.1. Makra stdarg (173)
  • 7.6.2. Ograniczenia zmiennej listy argumentów (174)
• 7.7. Podsumowanie (175)
  
• 7.8. Podsumowanie ostrzeżeń (176)
  
• 7.9. Podsumowanie wskazówek (176)
  
• 7.10. Pytania (177)
  
• 7.11. Ćwiczenia (178)

Rozdział 8. Tablice (179)

• 8.1. Tablice jednowymiarowe (179)
  
  • 8.1.1. Nazwy tablic (179)
  • 8.1.2. Indeksy (180)
  • 8.1.3. Wskaźniki kontra indeksy (183)
  • 8.1.4. Efektywność wskaźników (184)
  • 8.1.5. Tablice i wskaźniki (190)
  • 8.1.6. Nazwy tablic i argumenty funkcji (190)
  • 8.1.7. Deklarowanie parametrów tablicowych (192)
  • 8.1.8. Inicjalizacja (192)
  • 8.1.9. Niekompletne inicjalizacje (193)
  • 8.1.10. Automatyczne określanie wielkości tablicy (194)
  • 8.1.11. Inicjalizacja tablicy znaków (194)
• 8.2. Tablice wielowymiarowe (194)
  
  • 8.2.1. Kolejność zapisu (195)
  • 8.2.2. Nazwy tablic (196)
  • 8.2.3. Indeksy (197)
  • 8.2.4. Wskaźniki na tablice (199)
  • 8.2.5. Tablice wielowymiarowe jako argumenty funkcji (200)
  • 8.2.6. Inicjalizacja (201)
  • 8.2.7. Automatyczne określanie wielkości tablic (204)
• 8.3. Tablice wskaźników (204)
  
• 8.4. Podsumowanie (207)
  
• 8.5. Podsumowanie ostrzeżeń (208)
  
• 8.6. Podsumowanie wskazówek (209)
  
• 8.7. Pytania (209)
  
• 8.8. Ćwiczenia (213)

Rozdział 9. Ciągi, znaki i bajty (219)

• 9.1. Ciągi znaków - podstawy (219)
  
• 9.2. Długość ciągu (219)
  
• 9.3. Nieograniczone funkcje operujące na ciągach (221)
  
  • 9.3.1. Kopiowanie ciągów (221)
  • 9.3.2. Łączenie ciągów (222)
  • 9.3.3. Wartość zwracana przez funkcję (222)
  • 9.3.4. Porównywanie ciągów (223)
• 9.4. Funkcje operujące na ciągach o ograniczonej długości (223)
  
• 9.5. Proste wyszukiwanie w ciągach (224)
  
  • 9.5.1. Wyszukiwanie znaków (225)
  • 9.5.2. Wyszukiwanie dowolnego z kilku znaków (225)
  • 9.5.3. Wyszukiwanie podciągu (225)
• 9.6. Zaawansowane wyszukiwanie ciągów (227)
  
  • 9.6.1. Wyszukiwanie przedrostków w ciągu (227)
  • 9.6.2. Wyszukiwanie tokenów (227)
• 9.7. Komunikaty dotyczące błędów (229)
  
• 9.8. Operacje na znakach (229)
  
  • 9.8.1. Klasyfikacja znaków (229)
  • 9.8.2. Transformacje znaków (230)
• 9.9. Operacje na pamięci (230)
  
• 9.10. Podsumowanie (232)
  
• 9.11. Podsumowanie ostrzeżeń (233)
  
• 9.12. Podsumowanie wskazówek (233)
  
• 9.13. Pytania (234)
  
• 9.14. Ćwiczenia (234)

Rozdział 10. Struktury i unie (241)

• 10.1. Podstawy struktur (241)
  
  • 10.1.1. Deklaracje struktur (242)
  • 10.1.2. Składniki struktury (243)
  • 10.1.3. Bezpośredni dostęp do składników (244)
  • 10.1.4. Pośredni dostęp do składników (244)
  • 10.1.5. Struktury odwołujące się do samych siebie (245)
  • 10.1.6. Niekompletne deklaracje (246)
  • 10.1.7. Inicjalizacja struktur (246)
• 10.2. Struktury, wskaźniki i składniki (247)
  
  • 10.2.1. Odwołanie poprzez wskaźnik (248)
  • 10.2.2. Odwoływanie się do struktury (248)
  • 10.2.3. Odwoływanie się do składników struktury (249)
  • 10.2.4. Odwoływanie się do zagnieżdżonej struktury (251)
  • 10.2.5. Odwoływanie się do składnika wskaźnikowego (251)
• 10.3. Sposób zapisu struktur (253)
  
• 10.4. Struktury jako argumenty funkcji (254)
  
• 10.5. Pola bitowe (257)
  
• 10.6. Unie (260)
  
  • 10.6.1. Rekordy z wariantami (261)
  • 10.6.2. Inicjalizacja unii (262)
• 10.7. Podsumowanie (263)
  
• 10.8. Podsumowanie ostrzeżeń (264)
  
• 10.9. Podsumowanie wskazówek (264)
  
• 10.10. Pytania (264)
  
• 10.11. Ćwiczenia (267)

Rozdział 11. Dynamiczne przydzielanie pamięci (271)

• 11.1. Dlaczego korzystamy z dynamicznego przydzielania pamięci (271)
  
• 11.2. Funkcje malloc i free (271)
  
• 11.3. Funkcje calloc i realloc (273)
  
• 11.4. Wykorzystanie dynamicznie przydzielanej pamięci (273)
  
• 11.5. Częste błędy pamięci dynamicznej (274)
  
  • 11.5.1. Wycieki pamięci (277)
• 11.6. Przykłady przydzielania pamięci (277)
  
• 11.7. Podsumowanie (283)
  
• 11.8. Podsumowanie ostrzeżeń (283)
  
• 11.9. Podsumowanie wskazówek (283)
  
• 11.10. Pytania (284)
  
• 11.11. Ćwiczenia (285)

Rozdział 12. Wykorzystanie struktur i wskaźników (287)

• 12.1. Listy (287)
  
• 12.2. Lista jednokierunkowa (287)
  
  • 12.2.1. Wstawianie węzłów do listy jednokierunkowej (288)
  • 12.2.2. Inne operacje na listach (297)
• 12.3. Lista dwukierunkowa (298)
  
  • 12.3.1. Wstawianie do listy dwukierunkowej (298)
  • 12.3.2. Inne operacje na listach (306)
• 12.4. Podsumowanie (307)
  
• 12.5. Podsumowanie ostrzeżeń (307)
  
• 12.6. Podsumowanie wskazówek (308)
  
• 12.7. Pytania (308)
  
• 12.8. Ćwiczenia (308)

Rozdział 13. Zaawansowane zagadnienia dotyczące wskaźników (311)

• 13.1. Więcej o wskaźnikach do wskaźników (311)
  
• 13.2. Deklaracje zaawansowane (313)
  
• 13.3. Wskaźniki do funkcji (315)
  
  • 13.3.1. Funkcje wywołania zwrotnego (316)
  • 13.3.2. Tablice skoków (319)
• 13.4. Argumenty wiersza poleceń (321)
  
  • 13.4.1. Przekazywanie argumentów wiersza poleceń (321)
  • 13.4.2. Przetwarzanie argumentów wiersza poleceń (323)
• 13.5. Literały ciągów znaków (326)
  
• 13.6. Podsumowanie (328)
  
• 13.7. Podsumowanie ostrzeżeń (329)
  
• 13.8. Podsumowanie wskazówek (329)
  
• 13.9. Pytania (330)
  
• 13.10. Ćwiczenia (333)

Rozdział 14. Preprocesor (337)

• 14.1. Symbole predefiniowane (337)
  
• 14.2. #define (337)
  
  • 14.2.1. Makra (339)
  • 14.2.2. Podstawianie za pomocą #define (340)
  • 14.2.3. Makra kontra funkcje (341)
  • 14.2.4. Argumenty makr z efektami ubocznymi (342)
  • 14.2.5. Konwencje nazewnictwa (343)
  • 14.2.6. #undef (344)
  • 14.2.7. Definicje z wiersza poleceń (345)
• 14.3. Kompilacja warunkowa (345)
  
  • 14.3.1. #if defined (347)
  • 14.3.2. Dyrektywy zagnieżdżone (347)
• 14.4. Dołączanie plików (348)
  
  • 14.4.1. Dołączanie biblioteczne (349)
  • 14.4.2. Dołączanie lokalne (349)
  • 14.4.3. Zagnieżdżone dołączanie plików (350)
• 14.5. Inne dyrektywy (351)
  
• 14.6. Podsumowanie (352)
  
• 14.7. Podsumowanie ostrzeżeń (353)
  
• 14.8. Podsumowanie wskazówek (354)
  
• 14.9. Pytania (354)
  
• 14.10. Ćwiczenia (356)

Rozdział 15. Funkcje wejścia-wyjścia (357)

• 15.1. Raportowanie błędów (357)
  
• 15.2. Przerywanie działania (358)
  
• 15.3. Standardowa biblioteka wejścia-wyjścia (358)
  
• 15.4. Założenia wejścia-wyjścia ANSI (359)
  
  • 15.4.1 Strumienie (359)
  • 15.4.2. Struktury FILE (361)
  • 15.4.3. Standardowe stałe wejścia-wyjścia (361)
• 15.5. Przegląd strumieniowego wejścia-wyjścia (362)
  
• 15.6. Otwieranie strumieni (363)
  
• 15.7. Zamykanie strumieni (365)
  
• 15.8. Znakowe wejście-wyjście (366)
  
  • 15.8.1. Makra znakowego wejścia-wyjścia (367)
  • 15.8.2. Wycofywanie operacji znakowego wejścia-wyjścia (368)
• 15.9. Niesformatowane wierszowe wejście-wyjście (369)
  
• 15.10. Formatowane wierszowe wejście-wyjście (371)
  
  • 15.10.1. Rodzina scanf (371)
  • 15.10.2. Kody formatujące funkcji scanf (371)
  • 15.10.3. Rodzina printf (376)
  • 15.10.4. Kody formatujące printf (376)
• 15.11. Binarne wejście-wyjście (380)
  
• 15.12. Funkcje wyszukujące i opróżniające bufory (381)
  
• 15.13. Zmiana buforowania (384)
  
• 15.14. Funkcje obsługi błędów strumienia (385)
  
• 15.15. Pliki tymczasowe (385)
  
• 15.16. Funkcje do manipulacji plikami (386)
  
• 15.17. Podsumowanie (386)
  
• 15.18. Podsumowanie ostrzeżeń (388)
  
• 15.19. Podsumowanie wskazówek (389)
  
• 15.20. Pytania (389)
  
• 15.21. Ćwiczenia (390)

Rozdział 16. Biblioteka standardowa (395)

• 16.1. Funkcje typu całkowitego (395)
  
  • 16.1.1. Arytmetyka <stdlib.h> (395)
  • 16.1.2. Liczby losowe <stdlib.h> (396)
  • 16.1.3. Konwersja ciągów znaków <stdlib.h> (397)
• 16.2. Funkcje zmiennoprzecinkowe (398)
  
  • 16.2.1. Trygonometria <math.h> (399)
  • 16.2.2. Funkcje hiperboliczne <math.h> (399)
  • 16.2.3. Funkcje logarytmiczne i wykładnicze <math.h> (399)
  • 16.2.4. Reprezentacja zmiennoprzecinkowa <math.h> (400)
  • 16.2.5. Potęgowanie <math.h> (400)
  • 16.2.6. Podłoga, sufit, wartość bezwzględna i reszta <math.h> (400)
  • 16.2.7. Konwersja ciągów znaków <stdlib.h> (401)
• 16.3. Funkcje daty i czasu (401)
  
  • 16.3.1. Czas procesora <time.h> (401)
  • 16.3.2. Data i godzina <time.h> (402)
• 16.4. Skoki nielokalne <setjmp.h> (405)
  
  • 16.4.1. Przykład (406)
  • 16.4.2. Kiedy używać nielokalnych skoków (408)
• 16.5. Sygnały (408)
  
  • 16.5.1. Nazwy sygnałów <signal.h> (408)
  • 16.5.2. Przetwarzanie sygnałów <signal.h> (410)
  • 16.5.3. Obsługa sygnałów (411)
• 16.6. Drukowanie list zmiennych argumentów <stdarg.h> (413)
  
• 16.7. Środowisko wykonania (413)
  
  • 16.7.1. Przerwanie działania <stdlib.h> (413)
  • 16.7.2. Asercje <assert.h> (414)
  • 16.7.3. Środowisko <stdlib.h> (415)
  • 16.7.4. Wykonywanie poleceń systemowych <stdlib.h> (415)
• 16.8. Sortowanie i wyszukiwanie <stdlib.h> (415)
  
• 16.9. Ustawienia międzynarodowe (418)
  
  • 16.9.1. Formatowanie numeryczne i monetarne <locale.h> (419)
  • 16.9.2. Ciągi znaków i ustawienia regionalne <string.h> (421)
  • 16.9.3. Efekty zmiany ustawień regionalnych (422)
• 16.10. Podsumowanie (422)
  
• 16.11. Podsumowanie ostrzeżeń (424)
  
• 16.12. Podsumowanie wskazówek (424)
  
• 16.13. Pytania (425)
  
• 16.14. Ćwiczenia (426)

Rozdział 17. Klasyczne przykłady abstrakcyjnych typów danych (429)

• 17.1. Przydział pamięci (429)
  
• 17.2. Stosy (430)
  
  • 17.2.1. Interfejs stosu (430)
  • 17.2.2. Implementacja stosu (430)
• 17.3. Kolejki (438)
  
  • 17.3.1. Interfejs kolejki (439)
  • 17.3.2. Implementacja kolejki (440)
• 17.4. Drzewa (444)
  
  • 17.4.1. Wstawianie wartości do uporządkowanego drzewa binarnego (445)
  • 17.4.2. Usuwanie wartości z uporządkowanego drzewa binarnego (445)
  • 17.4.3. Wyszukiwanie wartości w uporządkowanym drzewie binarnym (446)
  • 17.4.4. Przeglądanie drzewa (446)
  • 17.4.5. Interfejs uporządkowanego drzewa binarnego (448)
  • 17.4.6. Implementacja uporządkowanego drzewa binarnego (448)
• 17.5. Usprawnienia implementacji (455)
  
  • 17.5.1. Utworzenie więcej niż jednego stosu (455)
  • 17.5.2. Wykorzystywanie więcej niż jednego typu (456)
  • 17.5.3. Konflikty nazw (457)
  • 17.5.4. Standardowe biblioteki ATD (457)
• 17.6. Podsumowanie (460)
  
• 17.7. Podsumowanie ostrzeżeń (461)
  
• 17.8. Podsumowanie wskazówek (461)
  
• 17.9. Pytania (462)
  
• 17.10. Ćwiczenia (463)

Rozdział 18. Środowisko wykonania (465)

• 18.1. Określanie cech środowiska wykonania (465)
  
  • 18.1.1. Program testowy (465)
  • 18.1.2 Zmienne statyczne i inicjalizacja (468)
  • 18.1.3. Ramka stosu (469)
  • 18.1.4. Zmienne register (470)
  • 18.1.5. Długość identyfikatorów zewnętrznych (471)
  • 18.1.6. Określanie układu ramki stosu (472)
  • 18.1.7. Efekty uboczne wyrażeń (477)
• 18.2. Współpraca z kodem asemblera (478)
  
• 18.3. Efektywność działania (479)
  
  • 18.3.1. Poprawianie wydajności (480)
• 18.4. Podsumowanie (482)
  
• 18.5. Podsumowanie ostrzeżeń (482)
  
• 18.6. Podsumowanie wskazówek (483)
  
• 18.7. Pytania (483)
  
• 18.8. Ćwiczenia (483)

Dodatek A Wybrane rozwiązania problemów (485)

Dodatek B Bibliografia (525)

Skorowidz (527)