Spis treści

Thinking in C++. Edycja polska. Tom 2 -- spis treści

Wstęp (11)

• Cele (11)
  
• Rozdziały (12)
  
• Ćwiczenia (14)
  
  • Rozwiązania do ćwiczeń (14)
• Kod źródłowy (15)
  
• Obsługiwane wersje języka (16)
  
• Standardy językowe (17)
  
• O okładce (17)

Część I Tworzenie niezawodnych systemów (19)

Rozdział 1. Obsługa wyjątków (21)

• Tradycyjna obsługa błędów (22)
  
• Wyrzucanie wyjątku (24)
  
• Przechwytywanie wyjątku (25)
  
  • Blok try (25)
  • Obsługa wyjątków (25)
  • Zakończenie i kontynuacja (26)
• Dopasowywanie wyjątków (27)
  
  • Przechwytywanie dowolnych wyjątków (29)
  • Ponowne wyrzucanie wyjątku (29)
  • Wyjątki nieprzechwycone (30)
• Czyszczenie (32)
  
  • Zarządzanie zasobami (33)
  • Wszystko jest obiektem (34)
  • auto_ptr (36)
  • Bloki try na poziomie funkcji (38)
• Wyjątki standardowe (39)
  
• Specyfikacje wyjątków (41)
  
  • Jakieś lepsze specyfikacje wyjątków? (45)
  • Specyfikacja wyjątków i dziedziczenie (45)
  • Kiedy nie używać specyfikacji wyjątków? (46)
• Bezpieczeństwo wyjątków (47)
  
• Programowanie z użyciem wyjątków (50)
  
  • Kiedy unikać wyjątków? (51)
  • Typowe zastosowania wyjątków (52)
• Narzuty (55)
  
• Podsumowanie (57)
  
• Ćwiczenia (57)

Rozdział 2. Programowanie defensywne (59)

• Asercje (61)
  
• Najprostszy system testów jednostkowych, który ma szansę zadziałać (65)
  
  • Automatyczne testowanie (66)
  • Szkielet TestSuite (70)
  • Zestawy testowe (73)
  • Kod szkieletu testowego (74)
• Techniki usuwania błędów (79)
  
  • Makra śledzące (79)
  • Plik śladu (80)
  • Znajdowanie wycieków pamięci (81)
• Podsumowanie (86)
  
• Ćwiczenia (86)

Część II Standardowa biblioteka C++ (91)

Rozdział 3. Wszystko o łańcuchach (93)

• Czym jest łańcuch? (94)
  
• Tworzenie i inicjalizacja łańcuchów C++ (95)
  
• Operacje na łańcuchach (98)
  
  • Dodawanie, wstawianie i łączenie łańcuchów (98)
  • Podmiana znaków łańcucha (100)
  • Sklejanie za pomocą przeciążonych operatorów spoza klasy (103)
• Szukanie w łańcuchach (104)
  
  • Znajdowanie od końca (107)
  • Znajdowanie pierwszego i ostatniego ze zbioru znaków (109)
  • Usuwanie znaków z łańcuchów (111)
  • Porównywanie łańcuchów (112)
  • Łańcuchy a znaki (116)
• Przykład zastosowania łańcuchów (121)
  
• Podsumowanie (125)
  
• Ćwiczenia (126)

Rozdział 4. Strumienie wejścia-wyjścia (129)

• Po co nowa biblioteka? (129)
  
• Iostream przybywa z odsieczą (133)
  
  • Wstawianie i pobieranie (134)
  • Typowe zastosowania (137)
  • Dane wejściowe pobierane wierszami (139)
• Obsługa błędów strumieni (140)
  
• Strumienie związane z plikami (143)
  
  • Przykład przetwarzania pliku (143)
  • Tryby otwarcia (145)
• Buforowanie strumieni (146)
  
• Przeszukiwanie strumieni wejścia-wyjścia (148)
  
• Strumienie powiązane z łańcuchami (151)
  
  • Łańcuchowe strumienie wejściowe (152)
  • Łańcuchowe strumienie wyjściowe (153)
• Formatowanie strumieni wyjściowych (156)
  
  • Flagi formatujące (156)
  • Pola formatujące (158)
  • Szerokość, wypełnienie, dokładność (159)
  • Kompletny przykład (160)
• Manipulatory (162)
  
  • Manipulatory z argumentami (163)
  • Tworzenie manipulatorów (166)
  • Efektory (167)
• Przykłady wykorzystujące iostream (169)
  
  • Zarządzanie kodem źródłowym biblioteki klas (169)
  • Wykrywanie błędów kompilatora (173)
  • Prosty rejestrator danych (175)
• Obsługa wielu języków (179)
  
  • Strumienie znaków szerokich (179)
  • Ustawienia lokalne (181)
• Podsumowanie (183)
  
• Ćwiczenia (183)

Rozdział 5. Wszystko o szablonach (187)

• Parametry szablonów (187)
  
  • Parametry szablonów niebędące typami (188)
  • Domyślne argumenty szablonów (190)
  • Szablony jako parametry szablonów (191)
  • Słowo kluczowe typename (196)
  • Użycie słowa kluczowego template jako wskazówki (198)
  • Szablony składowe (199)
• Szablony funkcji (201)
  
  • Dedukowanie typu argumentów szablonu funkcji (202)
  • Przeciążanie szablonów funkcji (205)
  • Pobieranie adresu wygenerowanej z szablonu funkcji (206)
  • Stosowanie funkcji do sekwencji STL (209)
  • Częściowe uporządkowanie szablonów funkcji (212)
• Specjalizacja szablonów (213)
  
  • Specjalizacja jawna (214)
  • Specjalizacja częściowa (215)
  • Przykład praktyczny (217)
  • Unikanie nadmiarowego kodu (220)
• Odszukiwanie nazw (224)
  
  • Nazwy w szablonach (224)
  • Szablony i funkcje zaprzyjaźnione (228)
• Idiomy programowania za pomocą szablonów (233)
  
  • Cechy charakterystyczne (233)
  • Reguły (238)
  • Tajemniczo powtarzający się wzorzec szablonów (240)
• Szablony i metaprogramowanie (242)
  
  • Programowanie na poziomie kompilacji (243)
  • Szablony wyrażeń (251)
• Modele kompilacji szablonów (256)
  
  • Model włączania (256)
  • Ukonkretnianie jawne (257)
  • Model separacji (259)
• Podsumowanie (260)
  
• Ćwiczenia (261)

Rozdział 6. Algorytmy uogólnione (265)

• Algorytmy uogólnione - wprowadzenie (265)
  
  • Predykaty (268)
  • Iteratory strumieni (270)
  • Złożoność algorytmu (272)
• Obiekty funkcyjne (274)
  
  • Klasyfikacja obiektów funkcyjnych (275)
  • Automatyczne tworzenie obiektów funkcyjnych (276)
  • Adaptowalność obiektów funkcyjnych (279)
  • Więcej przykładów wykorzystania obiektów funkcyjnych (281)
  • Adaptery wskaźników do funkcji (287)
  • Pisanie własnych adapterów obiektów funkcyjnych (293)
• Katalog algorytmów STL (297)
  
  • Narzędzia przydatne w tworzeniu przykładów (299)
  • Wypełnianie i generowanie sekwencji (303)
  • Zliczanie (304)
  • Manipulowanie sekwencjami (305)
  • Wyszukiwanie i zastępowanie elementów (310)
  • Porównywanie sekwencji (316)
  • Usuwanie elementów sekwencji (319)
  • Sortowanie i operacje na sekwencjach posortowanych (322)
  • Operacje na stertach (331)
  • Wykonywanie operacji na wszystkich elementach sekwencji (332)
  • Algorytmy numeryczne (339)
  • Narzędzia (342)
• Tworzenie własnych algorytmów uogólnionych (343)
  
• Podsumowanie (345)
  
• Ćwiczenia (345)

Rozdział 7. Kontenery (351)

• Kontenery i iteratory (351)
  
  • Dokumentacja biblioteki STL (353)
• Wprowadzenie (353)
  
  • Kontenery przechowujące ciągi znakowe (358)
  • Dziedziczenie po kontenerach STL (360)
• Kraina iteratorów (362)
  
  • Iterator w kontenerach dwukierunkowych (364)
  • Kategorie iteratorów (365)
  • Iteratory predefiniowane (367)
• Kontenery sekwencyjne: vector, list i deque (373)
  
  • Podstawowe operacje na kontenerach sekwencyjnych (373)
  • Kontener typu vector (376)
  • Kontener typu deque (383)
  • Konwersja sekwencji (385)
  • Kontrolowany dostęp swobodny (387)
  • Kontener typu list (388)
  • Wymienianie całych sekwencji (393)
• Kontener typu set (394)
  
  • Klasa iteratora słów (397)
• Szablon stack (402)
  
• Szablon queue (405)
  
• Kolejki priorytetowe (410)
  
• Przechowywanie bitów (418)
  
  • Typ bitset<n> (419)
  • Typ vector<bool> (422)
• Kontenery asocjacyjne (424)
  
  • Generowanie elementów i wypełnianie kontenerów asocjacyjnych (428)
  • Magia kontenerów typu map (431)
  • Kontener typu multimap (433)
  • Kontener typu multiset (436)
• Korzystanie z wielu kontenerów STL (439)
  
• Czyszczenie kontenera wskaźników (442)
  
• Tworzenie własnych kontenerów (444)
  
• Rozszerzenia biblioteki STL (446)
  
• Kontenery spoza STL (448)
  
• Podsumowanie (452)
  
• Ćwiczenia (453)

Część III Zagadnienia zaawansowane (457)

Rozdział 8. Rozpoznawanie typu w czasie wykonania programu (459)

• Rzutowanie w czasie wykonania (459)
  
• Operator typeid (464)
  
  • Rzutowanie na pośrednie poziomy hierarchii klas (466)
  • Wskaźniki na typ void (467)
  • RTTI a szablony (468)
• Wielodziedziczenie (469)
  
• Zastosowania mechanizmu RTTI (470)
  
  • Sortownia odpadków (471)
• Implementacja i narzuty mechanizmu RTTI (475)
  
• Podsumowanie (475)
  
• Ćwiczenia (476)

Rozdział 9. Wielodziedziczenie (479)

• Wprowadzenie do wielodziedziczenia (479)
  
• Dziedziczenie interfejsu (481)
  
• Dziedziczenie implementacji (484)
  
• Duplikaty podobiektów (489)
  
• Wirtualne klasy bazowe (493)
  
• Wyszukiwanie nazw (502)
  
• Unikanie wielodziedziczenia (504)
  
• Rozszerzanie interfejsu (506)
  
• Podsumowanie (509)
  
• Ćwiczenia (510)

Rozdział 10. Wzorce projektowe (513)

• Pojęcie wzorca (513)
  
  • Wyższość kompozycji nad dziedziczeniem (515)
• Klasyfikacja wzorców (515)
  
  • Właściwości, pojęcia, wzorce (516)
• Upraszczanie pojęć (516)
  
  • Posłaniec (517)
  • Parametr zbiorczy (518)
• Singleton (519)
  
  • Odmiany Singletona (520)
• Polecenie - wybór operacji (524)
  
  • Polecenia izolujące obsługę zdarzeń (526)
• Izolowanie obiektów (529)
  
  • Pośrednik - dostęp do innego obiektu (529)
  • Stan - modyfikowanie czynności obiektu (531)
• Adapter (532)
  
• Metoda szablonowa (535)
  
• Strategia - dynamiczny wybór algorytmu (536)
  
• Łańcuch odpowiedzialności - wypróbowywanie sekwencji strategii (537)
  
• Fabryki - hermetyzacja procesu tworzenia obiektu (540)
  
  • Fabryki polimorficzne (542)
  • Fabryka abstrakcyjna (545)
  • Konstruktory wirtualne (547)
• Builder - tworzenie złożonych obiektów (552)
  
• Obserwator (558)
  
  • Pojęcie klasy wewnętrznej (561)
  • Przykład zastosowania Obserwatora (564)
• Dyspozycja wielokrotna (567)
  
  • Wielokrotna dyspozycja z wzorcem Wizytator (571)
• Podsumowanie (575)
  
• Ćwiczenia (575)

Rozdział 11. Współbieżność (579)

• Motywacja (580)
  
• Współbieżność w języku C++ (582)
  
  • Instalacja biblioteki ZThread (582)
• Definiowanie zadań (584)
  
• Klasa Thread (585)
  
  • Tworzenie interfejsu użytkownika o krótkim czasie odpowiedzi (587)
  • Uproszczenie kodu z wykorzystaniem Wykonawców (589)
  • Tymczasowe zawieszanie działania wątków (592)
  • Usypianie wątków (594)
  • Priorytety wątków (595)
• Współdzielenie ograniczonych zasobów (597)
  
  • Gwarantowanie istnienia obiektów (597)
  • Niewłaściwe odwołania do zasobów (601)
  • Kontrola dostępu (603)
  • Uproszczenie kodu z wykorzystaniem Strażników (605)
  • Pamięć lokalna wątku (608)
• Zatrzymywanie zadań (610)
  
  • Zapobieganie kolizji odwołań do strumieni wejścia-wyjścia (610)
  • Ogród botaniczny (611)
  • Zatrzymywanie zadań zablokowanych (616)
  • Przerwanie (617)
• Współpraca wątków (623)
  
  • Oczekiwanie i nadawanie sygnałów (623)
  • Zależności typu producent-konsument (627)
  • Rozwiązywanie problemów wielowątkowości przez kolejkowanie (630)
  • Sygnalizacja rozgłoszeniowa (635)
• Zakleszczenie (641)
  
• Podsumowanie (647)
  
• Ćwiczenia (649)

Dodatki (653)

Dodatek A Zalecana lektura (655)

• Język C++ (655)
  
  • Książki Bruce'a Eckela (656)
  • Książki Chucka Allisona (657)
• Zaawansowane omówienia języka C++ (658)
  
• Książki o wzorcach projektowych (660)

Dodatek B Uzupełnienie (661)

Skorowidz (667)