Spis treści

Język C++. Koncepcje i techniki programowania -- spis treści

Wstęp (11)

Wprowadzenie (15)

• 0.1. Podejście pierwsze (15)
  
• 0.2. Jak to zrobić bez klas? (18)
  
• 0.3. Dlaczego w C++ było łatwiej? (19)
  
• 0.4. Bardziej rozbudowany przykład (20)
  
• 0.5. Wnioski (20)

Część I Motywacja (23)

Rozdział 1. Dlaczego używam C++? (25)

• 1.1. Problem (25)
  
• 1.2. Historia i kontekst (26)
  
• 1.3. Automatyczna dystrybucja oprogramowania (27)
  
• 1.4. Czas na C++ (30)
  
• 1.5. Oprogramowanie z odzysku (34)
  
• 1.6. Postscriptum (35)

Rozdział 2. Dlaczego pracuję nad rozwojem C++? (37)

• 2.1. Sukces małych projektów (37)
  
• 2.2. Abstrakcja (39)
  
• 2.3. Maszyny powinny pracować dla ludzi (42)

Rozdział 3. Życie w prawdziwym świecie (43)

Część II Klasy i dziedziczenie (49)

Rozdział 4. Lista kontrolna dla autorów klas (51)

Rozdział 5. Klasy surogatów (61)

• 5.1. Problem (61)
  
• 5.2. Rozwiązanie klasyczne (62)
  
• 5.3. Wirtualne funkcje kopiujące (63)
  
• 5.4. Definiowanie klasy surogatu (64)
  
• 5.5. Podsumowanie (67)

Rozdział 6. Uchwyty - część 1. (69)

• 6.1. Problem (69)
  
• 6.2. Prosta klasa (70)
  
• 6.3. Przyłączanie uchwytu (72)
  
• 6.4. Dostęp do obiektu (72)
  
• 6.5. Prosta implementacja (73)
  
• 6.6. Uchwyty z licznikami użycia (74)
  
• 6.7. Kopiowanie przy zapisie (76)
  
• 6.8. Omówienie (77)

Rozdział 7. Uchwyty - część 2. (79)

• 7.1. Przypomnienie (80)
  
• 7.2. Separowanie licznika użycia (81)
  
• 7.3. Abstrahowanie liczników użycia (82)
  
• 7.4. Funkcje dostępowe i kopiowanie przy zapisie (84)
  
• 7.5. Omówienie (85)

Rozdział 8. Program obiektowy (87)

• 8.1. Problem (87)
  
• 8.2. Rozwiązanie obiektowe (88)
  
• 8.3. Klasy uchwytów (91)
  
• 8.4. Rozwinięcie 1. - nowe operacje (94)
  
• 8.5. Rozwinięcie 2. - nowe typy węzłów (96)
  
• 8.6. Refleksje (98)

Rozdział 9. Analiza ćwiczenia praktycznego - część 1. (99)

• 9.1. Problem (99)
  
• 9.2. Projektowanie interfejsu (101)
  
• 9.3. Kilka brakujących elementów (103)
  
• 9.4. Testowanie interfejsu (104)
  
• 9.5. Strategia (104)
  
• 9.6. Taktyka (105)
  
• 9.7. Łączenie obrazów (108)
  
• 9.8. Wnioski (111)

Rozdział 10. Analiza ćwiczenia praktycznego - część 2. (113)

• 10.1. Strategia (113)
  
• 10.2. Korzystanie z możliwości struktury (125)
  
• 10.3. Wnioski (128)

Rozdział 11. Kiedy nie używać funkcji wirtualnych? (131)

• 11.1. Argumenty "za" (131)
  
• 11.2. Argumenty "przeciw" (132)
  
• 11.3. Szczególna rola destruktorów (137)
  
• 11.4. Podsumowanie (139)

Część III Szablony (141)

Rozdział 12. Tworzenie klasy zasobnika (143)

• 12.1. Co jest w środku? (143)
  
• 12.2. Co oznacza kopiowanie zasobnika? (144)
  
• 12.3. Jak dostać się do elementów w zasobniku? (147)
  
• 12.4. Jak odróżnić odczyt od zapisu? (148)
  
• 12.5. Jak poradzić sobie z rozrostem zasobnika? (150)
  
• 12.6. Jakie operacje udostępnia zasobnik? (151)
  
• 12.7. Jakie są założenia związane z typem elementu zasobnika? (152)
  
• 12.8. Zasobniki i dziedziczenie (153)
  
• 12.9. Projektowanie klasy "tablicopodobnej" (154)

Rozdział 13. Dostęp do elementów zasobnika (161)

• 13.1. Imitowanie wskaźnika (161)
  
• 13.2. Dostęp do danych (163)
  
• 13.3. Pozostałe problemy (165)
  
• 13.4. Pointer wskazujący const Array (169)
  
• 13.5. Użyteczne dodatki (170)

Rozdział 14. Iteratory (175)

• 14.1. Uzupełnianie klasy Pointer (175)
  
• 14.2. Co to jest iterator? (178)
  
• 14.3. Usuwanie elementu (179)
  
• 14.4. Usuwanie zasobnika (180)
  
• 14.5. Inne względy projektowe (181)
  
• 14.6. Podsumowanie (182)

Rozdział 15. Sekwencje (183)

• 15.1. Dzieło sztuki (183)
  
• 15.2. Stara, radykalna idea (185)
  
• 15.3. Może jeszcze kilka dodatków... (189)
  
• 15.4. Przykład zastosowania (192)
  
• 15.5. Może jeszcze coś... (196)
  
• 15.6. Do przemyślenia (198)

Rozdział 16. Szablony jako interfejsy (199)

• 16.1. Problem (199)
  
• 16.2. Pierwszy przykład (200)
  
• 16.3. Separowanie iteracji (200)
  
• 16.4. Iterowanie poprzez dowolne typy (203)
  
• 16.5. Dodawanie innych typów (204)
  
• 16.6. Uogólnianie sposobu przechowywania (204)
  
• 16.7. Dowód przydatności (207)
  
• 16.8. Podsumowanie (208)

Rozdział 17. Szablony a algorytmy ogólne (211)

• 17.1. Konkretny przykład (212)
  
• 17.2. Uogólnianie typu elementu (213)
  
• 17.3. Przełożenie zliczania elementów na później (214)
  
• 17.4. Niezależność od adresu (215)
  
• 17.5. Wyszukiwanie w strukturach niebędących tablicami (217)
  
• 17.6. Podsumowanie (218)

Rozdział 18. Iteratory ogólne (221)

• 18.1. Inny algorytm (221)
  
• 18.2. Kategorie i wymogi (223)
  
• 18.3. Iteratory wejściowe (224)
  
• 18.4. Iteratory wyjściowe (224)
  
• 18.5. Iteratory postępowe (225)
  
• 18.6. Iteratory dwukierunkowe (226)
  
• 18.7. Iteratory o dostępie swobodnym (226)
  
• 18.8. Dziedziczenie? (227)
  
• 18.9. Wydajność (228)
  
• 18.10. Podsumowanie (228)

Rozdział 19. Korzystanie z iteratorów ogólnych (231)

• 19.1. Typy iteratorów (232)
  
• 19.2. Wirtualne sekwencje (232)
  
• 19.3. Iterator strumienia wyjściowego (234)
  
• 19.4. Iterator strumienia wejściowego (236)
  
• 19.5. Omówienie (239)

Rozdział 20. Adaptery dla iteratorów (241)

• 20.1. Przykład (241)
  
• 20.2. Asymetria kierunkowa (243)
  
• 20.3. Konsekwencja a asymetria (244)
  
• 20.4. Automatyczne odwracanie (245)
  
• 20.5. Omówienie (247)

Rozdział 21. Obiekty funkcji (249)

• 21.1. Przykład (249)
  
• 21.2. Wskaźniki funkcji (252)
  
• 21.3. Obiekty funkcji (254)
  
• 21.4. Szablony obiektów funkcji (255)
  
• 21.5. Ukrywanie typów pośrednich (256)
  
• 21.6. Jeden typ zawiera kilka (257)
  
• 21.7. Implementacja (258)
  
• 21.8. Omówienie (260)

Rozdział 22. Adaptery funkcji (261)

• 22.1. Dlaczego obiekty funkcji? (261)
  
• 22.2. Obiekty funkcji dla operatorów wbudowanych (262)
  
• 22.3. Funkcje wiążące (263)
  
• 22.4. Spojrzenie z bliska (264)
  
• 22.5. Dziedziczenie interfejsu (265)
  
• 22.6. Używanie klas (266)
  
• 22.7. Omówienie (267)

Część IV Biblioteki (269)

Rozdział 23. Biblioteki w bieżącym zastosowaniu (271)

• 23.1. Problem (271)
  
• 23.2. Istota problemu - część 1. (273)
  
• 23.3. Implementacja - część 1. (273)
  
• 23.4. Istota problemu - część 2. (276)
  
• 23.5. Implementacja - część 2. (276)
  
• 23.6. Omówienie (278)

Rozdział 24. Obiektowa lekcja projektowania interfejsu biblioteki (281)

• 24.1. Komplikacje (282)
  
• 24.2. Poprawianie interfejsu (283)
  
• 24.3. Szczegółowe rozważania (285)
  
• 24.4. Pisanie kodu (286)
  
• 24.5. Wnioski (288)

Rozdział 25. Projektowanie bibliotek jako budowanie języka (289)

• 25.1. Ciągi znakowe (289)
  
• 25.2. Wyczerpanie dostępnej pamięci (290)
  
• 25.3. Kopiowanie (293)
  
• 25.4. Ukrywanie implementacji (296)
  
• 25.5. Konstruktor domyślny (298)
  
• 25.6. Inne operacje (299)
  
• 25.7. Podciągi (301)
  
• 25.8. Wnioski (302)

Rozdział 26. Projektowanie języka jako budowanie bibliotek (303)

• 26.1. Abstrakcyjne typy danych (303)
  
• 26.2. Biblioteki i abstrakcyjne typy danych (305)
  
• 26.3. Rezerwacja pamięci (308)
  
• 26.4. Przyporządkowywanie i inicjalizacja składowych klas (309)
  
• 26.5. Obsługa wyjątków (311)
  
• 26.6. Podsumowanie (312)

Część V Techniki (313)

Rozdział 27. Klasy, które się śledzą (315)

• 27.1. Projektowanie klasy śledzącej (315)
  
• 27.2. Tworzenie martwego kodu (318)
  
• 27.3. Generowanie wyników inspekcji dla obiektów (319)
  
• 27.4. Weryfikowanie zachowania zasobnika (321)
  
• 27.5. Podsumowanie (325)

Rozdział 28. Grupowy przydział pamięci dla obiektów (327)

• 28.1. Problem (327)
  
• 28.2. Projektowanie rozwiązania (327)
  
• 28.3. Implementacja (330)
  
• 28.4. Dziedziczenie (332)
  
• 28.5. Podsumowanie (333)

Rozdział 29. Aplikatory, manipulatory i obiekty funkcji (335)

• 29.1. Problem (336)
  
• 29.2. Rozwiązanie (338)
  
• 29.3. Inne rozwiązanie (338)
  
• 29.4. Dodatkowe argumenty (340)
  
• 29.5. Przykład (341)
  
• 29.6. Formy skrócone (343)
  
• 29.7. Przemyślenia (344)
  
• 29.8. Uwagi historyczne, źródła i podziękowania (345)

Rozdział 30. Uniezależnianie bibliotek aplikacji od wejść i wyjść (347)

• 30.1. Problem (347)
  
• 30.2. Rozwiązanie 1. - spryt i metoda siłowa (348)
  
• 30.3. Rozwiązanie 2. - abstrakcyjne wyjście (349)
  
• 30.4. Rozwiązanie 3. - spryt bez metody siłowej (351)
  
• 30.5. Uwagi (354)

Część VI Podsumowanie (355)

Rozdział 31. Przez złożoność do prostoty (357)

• 31.1. Świat jest złożony (357)
  
• 31.2. Złożoność staje się ukryta (358)
  
• 31.3. Komputery mają to samo (359)
  
• 31.4. Komputery rozwiązują prawdziwe problemy (361)
  
• 31.5. Biblioteki klas i semantyka języka (362)
  
• 31.6. Ułatwianie jest trudne (364)
  
• 31.7. Abstrakcja a interfejs (365)
  
• 31.8. Konserwacja złożoności (366)

Rozdział 32. "Witaj świecie" i co dalej? (367)

• 32.1. Znajdź w pobliżu eksperta (367)
  
• 32.2. Wybierz narzędzie i opanuj je (368)
  
• 32.3. Niektóre elementy C są ważne... (368)
  
• 32.4. ...inne niekoniecznie (370)
  
• 32.5. Wyznacz sobie szereg problemów do rozwiązania (371)
  
• 32.6. Konkluzja (374)

Dodatki (377)

Skorowidz (379)