Spis treści

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

Wstęp (13)

• Co nowego w drugim wydaniu? (13)
  
  • Zawartość drugiego tomu książki (14)
  • Skąd wziąć drugi tom książki? (14)
• Wymagania wstępne (14)
  
• Nauka języka C++ (15)
  
• Cele (16)
  
• Zawartość rozdziałów (17)
  
• Ćwiczenia (21)
  
  • Rozwiązania ćwiczeń (21)
• Kod źródłowy (21)
  
• Standardy języka (22)
  
  • Obsługa języka (23)
• Błędy (23)
  
• Okładka (24)

Rozdział 1. Wprowadzenie do obiektów (25)

• Postęp abstrakcji (26)
  
• Obiekt posiada interfejs (27)
  
• Ukryta implementacja (30)
  
• Wykorzystywanie istniejącej implementacji (31)
  
• Dziedziczenie - wykorzystywanie istniejącego interfejsu (32)
  
  • Relacje typu "jest" i "jest podobny do" (35)
• Zastępowanie obiektów przy użyciu polimorfizmu (36)
  
• Tworzenie i niszczenie obiektów (40)
  
• Obsługa wyjątków - sposób traktowania błędów (41)
  
• Analiza i projektowanie (42)
  
  • Etap 0. Przygotuj plan (44)
  • Etap 1. Co tworzymy? (45)
  • Etap 2. Jak to zrobimy? (49)
  • Etap 3. Budujemy jądro (52)
  • Etap 4. Iteracje przez przypadki użycia (53)
  • Etap 5. Ewolucja (53)
  • Planowanie się opłaca (55)
• Programowanie ekstremalne (55)
  
  • Najpierw napisz testy (56)
  • Programowanie w parach (57)
• Dlaczego C++ odnosi sukcesy? (58)
  
  • Lepsze C (59)
  • Zacząłeś się już uczyć (59)
  • Efektywność (60)
  • Systemy są łatwiejsze do opisania i do zrozumienia (60)
  • Maksymalne wykorzystanie bibliotek (60)
  • Wielokrotne wykorzystywanie kodu dzięki szablonom (61)
  • Obsługa błędów (61)
  • Programowanie na wielką skalę (61)
• Strategie przejścia (62)
  
  • Wskazówki (62)
  • Problemy z zarządzaniem (64)
• Podsumowanie (66)

Rozdział 2. Tworzenie i używanie obiektów (67)

• Proces tłumaczenia języka (68)
  
  • Interpretery (68)
  • Kompilatory (68)
  • Proces kompilacji (69)
• Narzędzia do rozłącznej kompilacji (71)
  
  • Deklaracje i definicje (71)
  • Łączenie (76)
  • Używanie bibliotek (76)
• Twój pierwszy program w C++ (78)
  
  • Używanie klasy strumieni wejścia-wyjścia (78)
  • Przestrzenie nazw (79)
  • Podstawy struktury programu (80)
  • "Witaj, świecie!" (81)
  • Uruchamianie kompilatora (82)
• Więcej o strumieniach wejścia-wyjścia (82)
  
  • Łączenie tablic znakowych (83)
  • Odczytywanie wejścia (84)
  • Wywoływanie innych programów (84)
• Wprowadzenie do łańcuchów (85)
  
• Odczytywanie i zapisywanie plików (86)
  
• Wprowadzenie do wektorów (88)
  
• Podsumowanie (92)
  
• Ćwiczenia (93)

Rozdział 3. Język C w C++ (95)

• Tworzenie funkcji (95)
  
  • Wartości zwracane przez funkcje (97)
  • Używanie bibliotek funkcji języka C (98)
  • Tworzenie własnych bibliotek za pomocą programu zarządzającego bibliotekami (99)
• Sterowanie wykonywaniem programu (99)
  
  • Prawda i fałsz (99)
  • if-else (100)
  • while (101)
  • do-while (101)
  • for (102)
  • Słowa kluczowe break i continue (103)
  • switch (104)
  • Używanie i nadużywanie instrukcji goto (105)
  • Rekurencja (106)
• Wprowadzenie do operatorów (107)
  
  • Priorytety (107)
  • Automatyczna inkrementacja i dekrementacja (108)
• Wprowadzenie do typów danych (108)
  
  • Podstawowe typy wbudowane (109)
  • bool, true i false (110)
  • Specyfikatory (111)
  • Wprowadzenie do wskaźników (112)
  • Modyfikacja obiektów zewnętrznych (115)
  • Wprowadzenie do referencji (117)
  • Wskaźniki i referencje jako modyfikatory (118)
• Zasięg (120)
  
  • Definiowanie zmiennych "w locie" (120)
• Specyfikacja przydziału pamięci (122)
  
  • Zmienne globalne (122)
  • Zmienne lokalne (124)
  • static (124)
  • extern (126)
  • Stałe (127)
  • volatile (129)
• Operatory i ich używanie (129)
  
  • Przypisanie (130)
  • Operatory matematyczne (130)
  • Operatory relacji (131)
  • Operatory logiczne (131)
  • Operatory bitowe (132)
  • Operatory przesunięć (133)
  • Operatory jednoargumentowe (135)
  • Operator trójargumentowy (136)
  • Operator przecinkowy (137)
  • Najczęstsze pułapki związane z używaniem operatorów (137)
  • Operatory rzutowania (138)
  • Jawne rzutowanie w C++ (139)
  • sizeof - samotny operator (143)
  • Słowo kluczowe asm (143)
  • Operatory dosłowne (144)
• Tworzenie typów złożonych (144)
  
  • Nadawanie typom nowych nazw za pomocą typedef (144)
  • Łączenie zmiennych w struktury (145)
  • Zwiększanie przejrzystości programów za pomocą wyliczeń (148)
  • Oszczędzanie pamięci za pomocą unii (150)
  • Tablice (151)
• Wskazówki dotyczące uruchamiania programów (159)
  
  • Znaczniki uruchomieniowe (160)
  • Przekształcanie zmiennych i wyrażeń w łańcuchy (162)
  • Makroinstrukcja assert( ) języka C (162)
• Adresy funkcji (163)
  
  • Definicja wskaźnika do funkcji (163)
  • Skomplikowane deklaracje i definicje (164)
  • Wykorzystywanie wskaźników do funkcji (165)
  • Tablice wskaźników do funkcji (166)
• Make - zarządzanie rozłączną kompilacją (167)
  
  • Działanie programu make (168)
  • Pliki makefile używane w książce (171)
  • Przykładowy plik makefile (171)
• Podsumowanie (173)
  
• Ćwiczenia (173)

Rozdział 4. Abstrakcja danych (179)

• Miniaturowa biblioteka w stylu C (180)
  
  • Dynamiczny przydział pamięci (183)
  • Błędne założenia (186)
• Na czym polega problem? (188)
  
• Podstawowy obiekt (188)
  
• Czym są obiekty? (194)
  
• Tworzenie abstrakcyjnych typów danych (195)
  
• Szczegóły dotyczące obiektów (196)
  
• Zasady używania plików nagłówkowych (197)
  
  • Znaczenie plików nagłówkowych (198)
  • Problem wielokrotnych deklaracji (199)
  • Dyrektywy preprocesora #define, #ifdef i #endif (200)
  • Standard plików nagłówkowych (201)
  • Przestrzenie nazw w plikach nagłówkowych (202)
  • Wykorzystywanie plików nagłówkowych w projektach (202)
• Zagnieżdżone struktury (202)
  
  • Zasięg globalny (206)
• Podsumowanie (206)
  
• Ćwiczenia (207)

Rozdział 5. Ukrywanie implementacji (211)

• Określanie ograniczeń (211)
  
• Kontrola dostępu w C++ (212)
  
  • Specyfikator protected (214)
• Przyjaciele (214)
  
  • Zagnieżdżeni przyjaciele (216)
  • Czy jest to "czyste"? (218)
• Struktura pamięci obiektów (219)
  
• Klasy (219)
  
  • Modyfikacja programu Stash, wykorzystująca kontrolę dostępu (222)
  • Modyfikacja stosu, wykorzystująca kontrolę dostępu (223)
• Klasy-uchwyty (223)
  
  • Ukrywanie implementacji (224)
  • Ograniczanie powtórnych kompilacji (224)
• Podsumowanie (226)
  
• Ćwiczenia (227)

Rozdział 6. Inicjalizacja i końcowe porządki (229)

• Konstruktor gwarantuje inicjalizację (230)
  
• Destruktor gwarantuje sprzątanie (232)
  
• Eliminacja bloku definicji (233)
  
  • Pętle for (235)
  • Przydzielanie pamięci (236)
• Klasa Stash z konstruktorami i destruktorami (237)
  
• Klasa Stack z konstruktorami i destruktorami (240)
  
• Inicjalizacja agregatowa (242)
  
• Konstruktory domyślne (245)
  
• Podsumowanie (246)
  
• Ćwiczenia (246)

Rozdział 7. Przeciążanie nazw funkcji i argumenty domyślne (249)

• Dalsze uzupełnienia nazw (250)
  
  • Przeciążanie na podstawie zwracanych wartości (251)
  • Łączenie bezpieczne dla typów (252)
• Przykładowe przeciążenie (253)
  
• Unie (255)
  
• Argumenty domyślne (258)
  
  • Argumenty-wypełniacze (259)
• Przeciążanie kontra argumenty domyślne (260)
  
• Podsumowanie (264)
  
• Ćwiczenia (265)

Rozdział 8. Stałe (267)

• Podstawianie wartości (267)
  
  • Stałe w plikach nagłówkowych (268)
  • Bezpieczeństwo stałych (269)
  • Agregaty (270)
  • Różnice w stosunku do języka C (271)
• Wskaźniki (272)
  
  • Wskaźniki do stałych (272)
  • Stałe wskaźniki (273)
  • Przypisanie a kontrola typów (274)
• Argumenty funkcji i zwracane wartości (275)
  
  • Przekazywanie stałej przez wartość (275)
  • Zwracanie stałej przez wartość (276)
  • Przekazywanie i zwracanie adresów (279)
• Klasy (282)
  
  • Stałe w klasach (282)
  • Stałe o wartościach określonych podczas kompilacji, zawarte w klasach (285)
  • Stałe obiekty i funkcje składowe (287)
• volatile (292)
  
• Podsumowanie (293)
  
• Ćwiczenia (294)

Rozdział 9. Funkcje inline (297)

• Pułapki preprocesora (298)
  
  • Makroinstrukcje a dostęp (300)
• Funkcje inline (301)
  
  • Funkcje inline wewnątrz klas (302)
  • Funkcje udostępniające (303)
• Klasy Stash i Stack z funkcjami inline (308)
  
• Funkcje inline a kompilator (311)
  
  • Ograniczenia (312)
  • Odwołania do przodu (313)
  • Działania ukryte w konstruktorach i destruktorach (313)
• Walka z bałaganem (314)
  
• Dodatkowe cechy preprocesora (315)
  
  • Sklejanie symboli (316)
• Udoskonalona kontrola błędów (316)
  
• Podsumowanie (319)
  
• Ćwiczenia (320)

Rozdział 10. Zarządzanie nazwami (323)

• Statyczne elementy języka C (323)
  
  • Zmienne statyczne znajdujące się wewnątrz funkcji (324)
  • Sterowanie łączeniem (328)
  • Inne specyfikatory klas pamięci (330)
• Przestrzenie nazw (330)
  
  • Tworzenie przestrzeni nazw (330)
  • Używanie przestrzeni nazw (332)
  • Wykorzystywanie przestrzeni nazw (336)
• Statyczne składowe w C++ (337)
  
  • Definiowanie pamięci dla statycznych danych składowych (337)
  • Klasy zagnieżdżone i klasy lokalne (341)
  • Statyczne funkcje składowe (342)
• Zależności przy inicjalizacji obiektów statycznych (344)
  
  • Jak można temu zaradzić? (346)
• Specyfikacja zmiany sposobu łączenia (352)
  
• Podsumowanie (353)
  
• Ćwiczenia (353)

Rozdział 11. Referencje i konstruktor kopiujący (359)

• Wskaźniki w C++ (359)
  
• Referencje w C++ (360)
  
  • Wykorzystanie referencji w funkcjach (361)
  • Wskazówki dotyczące przekazywania argumentów (363)
• Konstruktor kopiujący (363)
  
  • Przekazywanie i zwracanie przez wartość (364)
  • Konstrukcja za pomocą konstruktora kopiującego (369)
  • Domyślny konstruktor kopiujący (374)
  • Możliwości zastąpienia konstruktora kopiującego (376)
• Wskaźniki do składowych (378)
  
  • Funkcje (380)
• Podsumowanie (382)
  
• Ćwiczenia (383)

Rozdział 12. Przeciążanie operatorów (387)

• Ostrzeżenie i wyjaśnienie (387)
  
• Składnia (388)
  
• Operatory, które można przeciążać (389)
  
  • Operatory jednoargumentowe (390)
  • Operatory dwuargumentowe (393)
  • Argumenty i zwracane wartości (402)
  • Nietypowe operatory (405)
  • Operatory, których nie można przeciążać (412)
• Operatory niebędące składowymi (413)
  
  • Podstawowe wskazówki (414)
• Przeciążanie operacji przypisania (415)
  
  • Zachowanie się operatora = (416)
• Automatyczna konwersja typów (425)
  
  • Konwersja za pomocą konstruktora (425)
  • Operator konwersji (427)
  • Przykład konwersji typów (429)
  • Pułapki automatycznej konwersji typów (430)
• Podsumowanie (432)
  
• Ćwiczenia (432)

Rozdział 13. Dynamiczne tworzenie obiektów (437)

• Tworzenie obiektów (438)
  
  • Obsługa sterty w języku C (439)
  • Operator new (440)
  • Operator delete (441)
  • Prosty przykład (442)
  • Narzut menedżera pamięci (442)
• Zmiany w prezentowanych wcześniej przykładach (443)
  
  • Usuwanie wskaźnika void* jest prawdopodobnie błędem (443)
  • Odpowiedzialność za sprzątanie wskaźników (445)
  • Klasa Stash przechowująca wskaźniki (445)
• Operatory new i delete dla tablic (450)
  
  • Upodabnianie wskaźnika do tablicy (451)
• Brak pamięci (451)
  
• Przeciążanie operatorów new i delete (452)
  
  • Przeciążanie globalnych operatorów new i delete (453)
  • Przeciążanie operatorów new i delete w obrębie klasy (455)
  • Przeciążanie operatorów new i delete w stosunku do tablic (458)
  • Wywołania konstruktora (460)
  • Operatory umieszczania new i delete (461)
• Podsumowanie (463)
  
• Ćwiczenia (463)

Rozdział 14. Dziedziczenie i kompozycja (467)

• Składnia kompozycji (468)
  
• Składnia dziedziczenia (469)
  
• Lista inicjatorów konstruktora (471)
  
  • Inicjalizacja obiektów składowych (471)
  • Typy wbudowane znajdujące się na liście inicjatorów (472)
• Łączenie kompozycji i dziedziczenia (473)
  
  • Kolejność wywoływania konstruktorów i destruktorów (474)
• Ukrywanie nazw (476)
  
• Funkcje, które nie są automatycznie dziedziczone (480)
  
  • Dziedziczenie a statyczne funkcje składowe (483)
• Wybór między kompozycją a dziedziczeniem (484)
  
  • Tworzenie podtypów (485)
  • Dziedziczenie prywatne (487)
• Specyfikator protected (488)
  
  • Dziedziczenie chronione (489)
• Przeciążanie operatorów a dziedziczenie (490)
  
• Wielokrotne dziedziczenie (491)
  
• Programowanie przyrostowe (492)
  
• Rzutowanie w górę (492)
  
  • Dlaczego "rzutowanie w górę"? (494)
  • Rzutowanie w górę a konstruktor kopiujący (494)
  • Kompozycja czy dziedziczenie (po raz drugi) (497)
  • Rzutowanie w górę wskaźników i referencji (498)
  • Kryzys (498)
• Podsumowanie (498)
  
• Ćwiczenia (499)

Rozdział 15. Polimorfizm i funkcje wirtualne (503)

• Ewolucja programistów języka C++ (504)
  
• Rzutowanie w górę (504)
  
• Problem (506)
  
  • Wiązanie wywołania funkcji (506)
• Funkcje wirtualne (506)
  
  • Rozszerzalność (508)
• W jaki sposób język C++ realizuje późne wiązanie? (510)
  
  • Przechowywanie informacji o typie (511)
  • Obraz funkcji wirtualnych (512)
  • Rzut oka pod maskę (514)
  • Instalacja wskaźnika wirtualnego (515)
  • Obiekty są inne (516)
• Dlaczego funkcje wirtualne? (517)
  
• Abstrakcyjne klasy podstawowe i funkcje czysto wirtualne (518)
  
  • Czysto wirtualne definicje (522)
• Dziedziczenie i tablica VTABLE (523)
  
  • Okrajanie obiektów (525)
• Przeciążanie i zasłanianie (527)
  
  • Zmiana typu zwracanej wartości (529)
• Funkcje wirtualne a konstruktory (530)
  
  • Kolejność wywoływania konstruktorów (531)
  • Wywoływanie funkcji wirtualnych wewnątrz konstruktorów (532)
• Destruktory i wirtualne destruktory (533)
  
  • Czysto wirtualne destruktory (535)
  • Wirtualne wywołania w destruktorach (537)
  • Tworzenie hierarchii bazującej na obiekcie (538)
• Przeciążanie operatorów (541)
  
• Rzutowanie w dół (543)
  
• Podsumowanie (546)
  
• Ćwiczenia (546)

Rozdział 16. Wprowadzenie do szablonów (551)

• Kontenery (551)
  
  • Potrzeba istnienia kontenerów (553)
• Podstawy szablonów (554)
  
  • Rozwiązanie z wykorzystaniem szablonów (556)
• Składnia szablonów (558)
  
  • Definicje funkcji niebędących funkcjami inline (559)
  • Klasa IntStack jako szablon (560)
  • Stałe w szablonach (562)
• Klasy Stack i Stash jako szablony (563)
  
  • Kontener wskaźników Stash, wykorzystujący szablony (565)
• Przydzielanie i odbieranie prawa własności (570)
  
• Przechowywanie obiektów jako wartości (573)
  
• Wprowadzenie do iteratorów (575)
  
  • Klasa Stack z iteratorami (582)
  • Klasa PStash z iteratorami (585)
• Dlaczego iteratory? (590)
  
  • Szablony funkcji (593)
• Podsumowanie (594)
  
• Ćwiczenia (594)

Dodatek A Styl kodowania (599)

Dodatek B Wskazówki dla programistów (609)

Dodatek C Zalecana literatura (621)

• Język C (621)
  
• Ogólnie o języku C++ (621)
  
  • Książki, które napisałem (622)
• Głębia i mroczne zaułki (623)
  
• Analiza i projektowanie (623)

Skorowidz (627)