Spis treści

C++. Zaawansowane programowanie -- spis treści

O autorach (17)

Wprowadzenie (19)

Część I Wprowadzenie do profesjonalnego C++ (23)

Rozdział 1. Skrócony kurs C++ (25)

• Podstawy C++ (25)
  
  • Teraz obowiązkowo Hello, World (26)
  • Przestrzenie nazw (28)
  • Zmienne (30)
  • Operatory (32)
  • Typy danych (34)
  • Wyrażenia warunkowe (36)
  • Pętle (38)
  • Tablice (40)
  • Funkcje (41)
  • To był elementarz (42)
• C++ z bliska (42)
  
  • Wskaźniki i pamięć alokowana dynamicznie (42)
  • Łańcuchy znakowe w C++ (45)
  • Referencje (47)
  • Wyjątki (48)
  • Wiele zastosowań słowa kluczowego const (49)
• C++ jako język obiektowy (50)
  
  • Deklarowanie klasy (51)
• Nasz pierwszy praktyczny program C++ (53)
  
  • System obsługi kadrowej (53)
  • Klasa Employee (54)
  • Klasa Database (58)
  • Interfejs użytkownika (62)
  • Udoskonalanie programu (65)
• Podsumowanie (65)

Rozdział 2. Tworzenie profesjonalnych programów w C++ (67)

• Czym jest projekt programu? (68)
  
• Dlaczego projekt programu jest tak ważny? (68)
  
• Co jest szczególnego w projektach C++? (70)
  
• Dwie zasady tworzenia projektów w C++ (71)
  
  • Abstrakcja (71)
  • Wielokrotne użycie (73)
• Projektowanie programu szachowego (75)
  
  • Wymagania (75)
  • Kolejne etapy projektowania (76)
• Podsumowanie (80)

Rozdział 3. Projektowanie obiektowe (83)

• Obiektowe spojrzenie na świat (83)
  
  • Czy myślę proceduralnie? (83)
  • Filozofia obiektowa (84)
  • W świecie obiektów (87)
  • Powiązania obiektów (89)
  • Abstrakcja (99)
• Podsumowanie (102)

Rozdział 4. Użycie bibliotek i wzorców (103)

• Wielokrotne użycie kodu (103)
  
  • Uwaga na temat terminologii (104)
  • Podejmowanie decyzji, czy ponownie wykorzystać kod (105)
  • Strategie wielokrotnego użycia kodu (107)
  • Korzystanie z obcych aplikacji (112)
  • Biblioteki open-source (113)
  • Standardowa biblioteka C++ (114)
• Projektowanie z użyciem wzorców i technik (127)
  
  • Techniki projektowe (128)
  • Wzorce projektowe (129)
• Podsumowanie (130)

Rozdział 5. Projektowanie z myślą o ponownym użyciu (131)

• Filozofia wielokrotnego użycia (132)
  
• Jak projektować kod wielokrotnego użycia (132)
  
  • Użycie abstrakcji (133)
  • Struktura kodu wielokrotnego użycia (134)
  • Projektowanie interfejsów (139)
  • Łączenie ogólności i prostoty użycia (145)
• Podsumowanie (146)

Rozdział 6. Użycie metod inżynierii oprogramowania (147)

• Potrzeba stosowania procesu (147)
  
• Modele cyklu życia oprogramowania (149)
  
  • Model etapowy i kaskadowy (149)
  • Metoda spirali (152)
  • Rational Unified Process (154)
• Metodyki inżynierii oprogramowania (155)
  
  • Programowanie ekstremalne (XP) (156)
  • Sąd nad oprogramowaniem (160)
• Tworzenie własnego procesu i metodyki (161)
  
  • Bądź otwarty na nowe pomysły (161)
  • Dziel się pomysłami (161)
  • Zorientuj się, co działa, a co nie (162)
  • Nie bądź renegatem (162)
• Podsumowanie (162)

Część II Profesjonalne kodowanie w C++ (163)

Rozdział 7. Styl kodowania (165)

• Piękny wygląd (165)
  
  • Myślenie o przyszłości (165)
  • Zachowanie porządku (166)
  • Elementy dobrego stylu (166)
• Dokumentowanie kodu (166)
  
  • Po co pisać komentarze (166)
  • Style komentowania (169)
  • Komentarze w tej książce (174)
• Dekompozycja (174)
  
  • Dekompozycja przez refaktoring (174)
  • Dekompozycja na etapie projektu (176)
  • Dekompozycja w tej książce (176)
• Nazewnictwo (176)
  
  • Dobór właściwej nazwy (177)
  • Konwencje nazewnicze (177)
• Elementy języka a styl (180)
  
  • Stałe (180)
  • Korzystanie ze zmiennych const (180)
  • Użycie referencji zamiast wskaźników (180)
  • Wyjątki użytkownika (181)
• Formatowanie (181)
  
  • Rozmieszczenie nawiasów klamrowych (182)
  • Spacje i nawiasy (183)
  • Spacje i tabulatory (183)
• Wyzwania związane ze stylem (183)
  
• Podsumowanie (184)

Rozdział 8. Poznajemy lepiej klasy i obiekty (185)

• Wprowadzenie do przykładu arkusza kalkulacyjnego (185)
  
• Pisanie klas (186)
  
  • Definicje klasy (186)
  • Definiowanie metod (188)
  • Użycie obiektów (192)
• Cykl życia obiektów (193)
  
  • Tworzenie obiektu (193)
  • Usuwanie obiektu (204)
  • Przypisania do obiektów (206)
  • Odróżnianie kopiowania od przypisania (208)
• Podsumowanie (210)

Rozdział 9. Doskonalenie znajomości klas i obiektów (211)

• Dynamiczna alokacja pamięci w obiektach (211)
  
  • Klasa Spreadsheet (212)
  • Zwalnianie pamięci w destruktorach (213)
  • Obsługa kopiowania i przypisania (214)
• Różne rodzaje pól w klasach (221)
  
  • Pola statyczne (221)
  • Pola stałe (223)
  • Pola będące referencjami (225)
  • Pola będące stałymi referencjami (226)
• Jeszcze o metodach (226)
  
  • Metody statyczne (226)
  • Metody stałe (227)
  • Przeciążanie metod (229)
  • Parametry domyślne (230)
  • Metody inline (231)
• Klasy zagnieżdżone (233)
  
• Zaprzyjaźnienie (235)
  
• Przeciążanie operatorów (236)
  
  • Implementacja dodawania (236)
  • Przeciążanie operatorów arytmetycznych (240)
  • Przeciążanie operatorów porównania (242)
  • Tworzenie typów z przeciążaniem operatorów (244)
• Wskaźniki pól i metod (244)
  
• Tworzenie klas abstrakcyjnych (245)
  
  • Użycie klas interfejsu i implementacji (246)
• Podsumowanie (249)

Rozdział 10. Przygoda z dziedziczeniem (251)

• Klasy i dziedziczenie (251)
  
  • Rozszerzanie klas (252)
  • Nadpisywanie metod (255)
• Dziedziczenie a wielokrotne użycie kodu (258)
  
  • Klasa WeatherPrediction (258)
  • Nowe możliwości w podklasie (259)
  • Inne możliwości w podklasie (261)
• Szacunek dla rodziców (262)
  
  • Konstruktory rodziców (262)
  • Destruktory rodziców (264)
  • Odwołania do danych rodziców (266)
  • Rzutowanie w górę i w dół (267)
• Dziedziczenie i polimorfizm (268)
  
  • Powrót do arkusza kalkulacyjnego (269)
  • Polimorficzna komórka arkusza (269)
  • Klasa bazowa komórki arkusza (270)
  • Poszczególne podklasy (272)
  • Polimorfizm dla zaawansowanych (274)
  • Uwagi na przyszłość (275)
• Dziedziczenie wielokrotne (276)
  
  • Dziedziczenie po wielu klasach (277)
  • Kolizje nazw i niejednoznaczne klasy bazowe (278)
• Ciekawostki i tajemnice dziedziczenia (281)
  
  • Zmiana charakterystyki nadpisanej metody (281)
  • Przypadki szczególne nadpisywania metod (285)
  • Konstruktory kopiujące i operator równości (291)
  • Prawda o wirtualności (293)
  • Typy podczas działania programu (296)
  • Dziedziczenie niepubliczne (297)
  • Wirtualne klasy bazowe (298)
• Podsumowanie (299)

Rozdział 11. Szablony i kod ogólny (301)

• Szablony w skrócie (302)
  
• Szablony klas (303)
  
  • Pisanie szablonu klasy (303)
  • Jak kompilator przetwarza szablony (311)
  • Rozdzielanie kodu szablonu między pliki (312)
  • Parametry szablonów (313)
  • Szablony metod (316)
  • Specjalizacja klas szablonów (321)
  • Podklasy szablonów klas (324)
  • Dziedziczenie a specjalizacja (325)
• Szablony funkcji (326)
  
  • Specjalizacja szablonów funkcji (327)
  • Przeciążanie szablonów funkcji (327)
  • Szablony funkcji zaprzyjaźnionych szablonów klas (328)
• Szablony: zagadnienia zaawansowane (330)
  
  • Więcej o parametrach szablonów (330)
  • Częściowa specjalizacja szablonów klas (338)
  • Przeciążanie jako symulacja specjalizacji częściowej funkcji (344)
  • Szablony rekurencyjnie (345)
• Podsumowanie (353)

Rozdział 12. Dziwactwa C++ (355)

• Referencje (355)
  
  • Zmienne referencyjne (356)
  • Referencje do pól (358)
  • Parametry referencyjne (358)
  • Zwracanie wartości przez referencję (359)
  • Wybór między referencjami a wskaźnikami (360)
• Zamieszanie ze słowami kluczowymi (362)
  
  • Słowo kluczowe const (362)
  • Słowo kluczowe static (365)
  • Porządek inicjalizacji zmiennych nielokalnych (369)
• Typy i rzutowanie (369)
  
  • typedef (370)
  • Rzutowanie (371)
• Zasięg (375)
  
• Pliki nagłówkowe (376)
  
• Narzędzia C (377)
  
  • Listy parametrów o zmiennej długości (378)
  • Makra preprocesora (380)
• Podsumowanie (381)

Część III Zaawansowane elementy C++ (383)

Rozdział 13. Skuteczne zarządzanie pamięcią (385)

• Użycie pamięci dynamicznej (385)
  
  • Jak sobie wyobrazić pamięć (386)
  • Alokacja i zwalnianie (387)
  • Tablice (389)
  • Użycie wskaźników (396)
• Dualność tablic i wskaźników (398)
  
  • Tablice są wskaźnikami! (398)
  • Nie wszystkie wskaźniki są tablicami! (399)
• Łańcuchy dynamiczne (400)
  
  • Łańcuchy w stylu C (400)
  • Literały łańcuchowe (402)
  • Klasa C++ string (402)
• Niskopoziomowe operacje na pamięci (404)
  
  • Arytmetyka wskaźników (405)
  • Specjalne zarządzanie pamięcią (405)
  • Odśmiecanie pamięci (406)
  • Pule obiektów (407)
  • Wskaźniki funkcji (407)
• Typowe błędy związane z zarządzaniem pamięcią (409)
  
  • Brak pamięci na łańcuchy (409)
  • Wycieki pamięci (410)
  • Dwukrotne usuwanie i błędne wskaźniki (413)
  • Dostęp do pamięci spoza zakresu (414)
• Podsumowanie (414)

Rozdział 14. Wejście-wyjście w C++. Pożegnanie z mitami (415)

• Użycie strumieni (416)
  
  • Czym jest strumień (416)
  • Źródła i przeznaczenie strumieni (416)
  • Strumienie wyjściowe (417)
  • Strumienie wejściowe (421)
  • Wejście i wyjście realizowane za pomocą obiektów (426)
• Strumienie łańcuchowe (428)
  
• Strumienie plikowe (429)
  
  • Poruszanie się za pomocą seek() i tell() (430)
  • Wiązanie strumieni (432)
• Wejście-wyjście dwukierunkowe (433)
  
• Internacjonalizacja (435)
  
  • Znaki rozszerzone (435)
  • Zestawy znaków inne niż zachodnie (436)
  • Ustawienia lokalne i fazy (436)
• Podsumowanie (438)

Rozdział 15. Obsługa błędów (439)

• Błędy i wyjątki (440)
  
  • Czym są wyjątki (440)
  • Zalety wyjątków języka C++ (441)
  • Wady wyjątków języka C++ (442)
  • Zalecenia (442)
• Mechanika wyjątków (443)
  
  • Zgłaszanie i wyłapywanie wyjątków (443)
  • Typy wyjątków (445)
  • Zgłaszanie i wyłapywanie wielu wyjątków (447)
  • Niewyłapane wyjątki (449)
  • Lista zgłaszanych wyjątków (451)
• Wyjątki i polimorfizm (455)
  
  • Hierarchia standardowych wyjątków (455)
  • Przechwytywanie wyjątków w hierarchii klas (456)
  • Pisanie własnych klas wyjątków (458)
• Odwijanie stosu i zwalnianie zasobów (461)
  
  • Złap wyjątek, dokonaj zwolnienia zasobu i ponownie zgłoś wyjątek (462)
  • Wykorzystanie inteligentnych wskaźników (463)
• Typowe zagadnienia dotyczące obsługi błędów (463)
  
  • Błędy alokacji pamięci (463)
  • Błędy w konstruktorach (466)
  • Błędy w destruktorze (467)
• Połączenie wszystkiego razem (468)
  
• Podsumowanie (470)

Część IV Pozbywanie się błędów (471)

Rozdział 16. Przeciążanie operatorów języka C++ (473)

• Omówienie przeciążania operatorów (474)
  
  • Powody przeciążania operatorów (474)
  • Ograniczenia przeciążania operatorów (474)
  • Wybór przeciążania operatorów (475)
  • Operatory, których nie należy przeciążać (478)
  • Podsumowanie operatorów z możliwością przeciążania (478)
• Przeciążanie operatorów arytmetycznych (481)
  
  • Przeciążanie jednoargumentowego operatora plus i minus (481)
  • Przeciążanie inkrementacji i dekrementacji (482)
• Przeciążanie operatorów bitowych i operatorów logicznych dwuargumentowych (484)
  
• Przeciążanie operatorów wstawiania i wydobywania (484)
  
• Przeciążanie operatora indeksu tablicy (486)
  
  • Zapewnienie dostępu tylko do odczytu dla operatora operator[] (489)
  • Indeksy niebędące liczbami całkowitymi (490)
• Przeciążenie operatora wywołania funkcji (491)
  
• Przeciążanie operatorów dereferencji (493)
  
  • Implementacja operatora operator* (494)
  • Implementacja operatora operator-> (495)
  • Co oznacza operator->*? (496)
• Pisanie operatorów konwersji (496)
  
  • Problemy niejednoznaczności operatorów konwersji (498)
  • Konwersje dla wyrażeń logicznych (498)
• Przeciążanie operatorów alokacji i zwalniania pamięci (500)
  
  • Jak tak naprawdę działają operatory new i delete (501)
  • Przeciążanie operatorów new i delete (502)
  • Przeciążanie operatorów new i delete z dodatkowymi parametrami (505)
• Podsumowanie (507)

Rozdział 17. Pisanie wydajnego kodu (509)

• Omówienie wydajności i efektywności (509)
  
  • Dwa podejścia do efektywności (510)
  • Dwa rodzaje programów (510)
  • Czy C++ to nieefektywny język programowania? (510)
• Efektywność na poziomie języka (511)
  
  • Wydajna obsługa obiektów (512)
  • Nie nadużywaj kosztownych elementów języka (515)
  • Użycie metod i funkcji rozwijanych w miejscu wywołania (516)
• Efektywność na poziomie projektu (517)
  
  • Stosuj buforowanie podręczne, jeśli tylko to możliwe (517)
  • Pule obiektów (518)
  • Wykorzystanie puli wątków (523)
• Profilowanie (524)
  
  • Profilowanie przykładu za pomocą gprof (524)
• Podsumowanie (533)

Rozdział 18. Tworzenie aplikacji wieloplatformowych i wielojęzykowych (535)

• Tworzenie aplikacji wieloplatformowych (536)
  
  • Kwestie architektury (536)
  • Kwestie implementacji (539)
  • Elementy specyficzne dla platformy programowo-sprzętowej (540)
• Aplikacje wielojęzykowe (541)
  
  • Mieszanie języków C i C++ (541)
  • Zmieszane paradygmaty (542)
  • Konsolidacja kodu języka C (545)
  • Łączenie Javy i C++ dzięki JNI (546)
  • Mieszanie C++ z Perlem i skryptami powłoki (549)
  • Mieszanie C++ z kodem w języku asemblera (552)
• Podsumowanie (552)

Rozdział 19. Podstawy testowania (553)

• Kontrola jakości (554)
  
  • Kto jest odpowiedzialny za testowanie? (554)
  • Cykl życia błędu (554)
  • Narzędzia do śledzenia błędów (555)
• Testy jednostkowe (556)
  
  • Metody testowania jednostkowego (557)
  • Proces testowania jednostkowego (558)
  • Testy jednostkowe w praktyce (562)
• Testowanie wyższego poziomu (570)
  
  • Testy integracyjne (571)
  • Testy systemowe (572)
  • Testy regresyjne (573)
• Wskazówki na temat testowania (574)
  
• Podsumowanie (574)

Rozdział 20. Wszystko o debugowaniu (575)

• Podstawowe zasady debugowania (575)
  
• Taksonomia błędów (576)
  
• Unikanie błędów (576)
  
• Przewidywanie błędów (577)
  
  • Rejestrowanie błędów (577)
  • Rejestrowanie śladu (578)
  • Asercje (589)
• Techniki debugowania (590)
  
  • Reprodukcja błędów (591)
  • Debugowanie błędów powtarzalnych (592)
  • Debugowanie błędów niemożliwych do powtórzenia (592)
  • Debugowanie błędów pamięci (593)
  • Debugowanie programów wielowątkowych (597)
  • Przykład debugowania: cytowanie artykułów (598)
  • Wnioski z przykładu ArticleCitations (609)
• Podsumowanie (609)

Rozdział 21. W głąb STL: kontenery i iteratory (611)

• Przegląd kontenerów (612)
  
  • Wymagania co do elementów (612)
  • Wyjątki i kontrola błędów (614)
  • Iteratory (614)
• Kontenery sekwencyjne (616)
  
  • Wektor (616)
  • Specjalizowana implementacja vector<bool> (634)
  • Kontener deque (635)
  • Kontener list (636)
• Adaptery kontenerów (640)
  
  • Adapter queue (640)
  • Adapter priority_queue (643)
  • Adapter stack (646)
• Kontenery asocjacyjne (647)
  
  • Klasa narzędziowa pair (647)
  • Kontener map (648)
  • Kontener multimap (657)
  • Kontener set (661)
  • Kontener multiset (663)
• Inne kontenery (663)
  
  • Tablice jako kontenery STL (663)
  • string jako kontener STL (664)
  • Strumienie jako kontenery STL (665)
  • Kontener bitset (665)
• Podsumowanie (670)

Część V Użycie bibliotek i wzorców (671)

Rozdział 22. Poznajemy algorytmy STL oraz obiekty funkcyjne (673)

• Przegląd algorytmów (674)
  
  • Algorytmy find() oraz find_if() (674)
  • Algorytm accumulate() (677)
• Obiekty funkcyjne (678)
  
  • Obiekty funkcji arytmetycznych (678)
  • Obiekty funkcji porównań (679)
  • Obiekty funkcji logicznych (680)
  • Adaptery obiektów funkcyjnych (681)
  • Tworzenie własnych obiektów funkcyjnych (685)
• Szczegóły budowy algorytmów (686)
  
  • Algorytmy użytkowe (686)
  • Algorytmy niemodyfikujące (687)
  • Algorytmy modyfikujące (693)
  • Algorytmy sortujące (698)
  • Algorytmy dla zbiorów (701)
• Przykład użycia algorytmów i obiektów funkcyjnych: kontrola list wyborców (702)
  
  • Problem kontroli rejestrów wyborców (703)
  • Funkcja auditVoterRolls() (703)
  • Funkcja getDuplicates() (704)
  • Funktor RemoveNames (705)
  • Funktor NameInList (706)
  • Testowanie funkcji auditVoterRolls() (707)
• Podsumowanie (708)

Rozdział 23. Dostosowywanie i rozszerzanie STL (709)

• Alokatory (710)
  
• Adaptery iteratorów (710)
  
  • Iteratory działające wstecz (710)
  • Iteratory strumienia (712)
  • Iteratory wstawiające (712)
• Rozszerzanie STL (714)
  
  • Po co rozszerzamy STL? (715)
  • Tworzenie algorytmów STL (715)
  • Tworzenie kontenera STL (717)
• Podsumowanie (747)

Rozdział 24. Rzecz o obiektach rozproszonych (749)

• Zalety programowania rozproszonego (749)
  
  • Rozpraszanie w celu zwiększenia skalowalności (749)
  • Rozpraszanie w celu zwiększenia niezawodności (750)
  • Rozpraszanie w celu centralizacji (750)
  • Rozpraszanie treści (751)
  • Przetwarzanie rozproszone a sieciowe (751)
• Obiekty rozproszone (752)
  
  • Serializacja i szeregowanie (752)
  • Zdalne wywoływanie procedur (756)
• CORBA (758)
  
  • Język definicji interfejsu (758)
  • Implementacja klasy (761)
  • Wykorzystanie obiektów (762)
• XML (766)
  
  • Szybki kurs XML (766)
  • XML jako technologia obiektów rozproszonych (768)
  • Generowanie i analizowanie XML w C++ (769)
  • Kontrola poprawności XML (777)
  • Tworzenie obiektów rozproszonych z użyciem XML (779)
  • SOAP (ang. Simple Object Access Protocol) (782)
• Podsumowanie (784)

Rozdział 25. Korzystanie z technik i bibliotek (785)

• Nigdy nie pamiętam, jak... (786)
  
  • ...utworzyć klasę (786)
  • ...dziedziczyć po istniejącej klasie (787)
  • ...zgłosić i przechwycić wyjątek (788)
  • ...odczytać z pliku (789)
  • ...zapisać do pliku (789)
  • ...utworzyć szablon klasy (790)
• Musi istnieć lepszy sposób (792)
  
  • Inteligentne wskaźniki ze zliczaniem referencji (792)
  • Podwójne rozsyłanie (797)
  • Klasy domieszkowe (803)
• Biblioteki obiektowe (806)
  
  • Wykorzystywanie bibliotek (806)
  • Paradygmat model-widok-kontroler (807)
• Podsumowanie (808)

Rozdział 26. Wykorzystanie wzorców projektowych (809)

• Wzorzec singleton (810)
  
  • Przykład: mechanizm dziennika (810)
  • Implementacja klasy singleton (810)
  • Wykorzystanie klasy singleton (815)
• Wzorzec factory (816)
  
  • Przykład: symulacja fabryki samochodów (816)
  • Implementacja klasy factory (818)
  • Wykorzystanie wzorca factory (820)
  • Inne zastosowania wzorca factory (822)
• Wzorzec proxy (822)
  
  • Przykład: ukrywanie problemów z połączeniem sieciowym (822)
  • Implementacja klasy proxy (823)
  • Wykorzystanie klasy proxy (824)
• Wzorzec adapter (824)
  
  • Przykład: adaptacja biblioteki XML (824)
  • Implementacja adaptera (825)
  • Wykorzystanie klasy adaptera (828)
• Wzorzec decorator (829)
  
  • Przykład: definiowanie stylów na stronach WWW (829)
  • Implementacja klasy decorator (830)
  • Wykorzystanie klasy decorator (831)
• Wzorzec chain of responsibility (832)
  
  • Przykład: obsługa zdarzeń (833)
  • Implementacja łańcucha odpowiedzialności (833)
  • Wykorzystanie łańcucha odpowiedzialności (834)
• Wzorzec observer (834)
  
  • Przykład: obsługa zdarzeń (835)
  • Implementacja wzorca observer (835)
  • Wykorzystanie wzorca observer (836)
• Podsumowanie (837)

Dodatki (839)

Dodatek A Rozmowy kwalifikacyjne z C++ (841)

• Rozdział 1. "Skrócony kurs C++" (841)
  
• Rozdział 2. "Tworzenie profesjonalnych programów w C++" (842)
  
• Rozdział 3. "Projektowanie obiektowe" (843)
  
• Rozdział 4. "Użycie bibliotek i wzorców" (844)
  
• Rozdział 5. "Projektowanie z myślą o ponownym użyciu" (845)
  
• Rozdział 6. "Użycie metod inżynierii oprogramowania" (846)
  
• Rozdział 7. "Styl kodowania" (847)
  
• Rozdziały 8. i 9. Klasy i obiekty (848)
  
• Rozdział 10. "Przygoda z dziedziczeniem" (851)
  
• Rozdział 11. "Szablony i kod ogólny" (851)
  
• Rozdział 12. "Dziwactwa C++" (852)
  
• Rozdział 13. "Skuteczne zarządzanie pamięcią" (853)
  
• Rozdział 14. "Wejście-wyjście w C++. Pożegnanie z mitami" (854)
  
• Rozdział 15. "Obsługa błędów" (855)
  
• Rozdział 16. "Przeciążanie operatorów języka C++" (856)
  
• Rozdział 17. "Pisanie wydajnego kodu" (856)
  
• Rozdział 18. "Tworzenie aplikacji wieloplatformowych i wielojęzykowych" (857)
  
• Rozdział 19. "Podstawy testowania" (858)
  
• Rozdział 20. "Wszystko o debugowaniu" (859)
  
• Rozdziały 21., 22. i 23. Biblioteka STL (859)
  
• Rozdział 24. "Rzecz o obiektach rozproszonych" (860)
  
• Rozdział 25. "Korzystanie z technik i bibliotek" (861)
  
• Rozdział 26. "Wykorzystanie wzorców projektowych" (861)

Dodatek B Bibliografia z omówieniami (863)

• C++ (863)
  
  • C++ dla początkujących (863)
  • Różne informacje o C++ (864)
  • Strumienie wejścia-wyjścia (865)
  • Standardowa biblioteka C++ (866)
  • Szablony C++ (866)
• Język C (866)
  
• Integracja C++ z innymi językami (867)
  
• Algorytmy i struktury danych (867)
  
• Oprogramowanie open-source (868)
  
• Metodologie inżynierii programowania (868)
  
• Styl programowania (869)
  
• Architektura komputerów (869)
  
• Wydajność (870)
  
• Testowanie (870)
  
• Debugowanie (870)
  
• Obiekty rozproszone (870)
  
  • CORBA (871)
  • XML oraz SOAP (871)
• Wzorce projektowe (872)

Skorowidz (873)