Spis treści

C++. Programowanie zorientowane obiektowo. Vademecum profesjonalisty -- spis treści

Przedmowa (11)

Rozdział 1. O książce (13)

• 1.1. Dlaczego napisałem tę książkę? (13)
  
• 1.2. Wymagania (14)
  
• 1.3. Organizacja książki (14)
  
• 1.4. W jaki sposób należy czytać książkę? (15)
  
• 1.5. Przykłady programów i dodatkowe informacje (15)

Rozdział 2. Wprowadzenie: język C++ i programowanie obiektowe (19)

• 2.1. Język C++ (19)
  
  • 2.1.1. Kryteria projektowania (19)
  • 2.1.2. Historia języka (20)
• 2.2. C++ jako język programowania obiektowego (20)
  
  • 2.2.1. Obiekty, klasy i instancje (21)
  • 2.2.2. Klasy w języku C++ (23)
  • 2.2.3. Hermetyzacja danych (25)
  • 2.2.4. Dziedziczenie (27)
  • 2.2.5. Polimorfizm (28)
• 2.3. Inne koncepcje języka C++ (29)
  
  • 2.3.1. Obsługa wyjątków (30)
  • 2.3.2. Szablony (30)
  • 2.3.3. Przestrzenie nazw (32)
• 2.4. Terminologia (32)

Rozdział 3. Podstawowe pojęcia języka C++ (35)

• 3.1. Pierwszy program (35)
  
  • 3.1.1. "Hello, World!" (35)
  • 3.1.2. Komentarze w języku C++ (37)
  • 3.1.3. Funkcja main() (37)
  • 3.1.4. Wejście i wyjście (39)
  • 3.1.5. Przestrzenie nazw (40)
  • 3.1.6. Podsumowanie (41)
• 3.2. Typy, operatory i instrukcje sterujące (41)
  
  • 3.2.1. Pierwszy program, który przeprowadza obliczenia (41)
  • 3.2.2. Typy podstawowe (44)
  • 3.2.3. Operatory (48)
  • 3.2.4. Instrukcje sterujące (54)
  • 3.2.5. Podsumowanie (57)
• 3.3. Funkcje i moduły (58)
  
  • 3.3.1. Pliki nagłówkowe (58)
  • 3.3.2. Plik źródłowy zawierający definicję (60)
  • 3.3.3. Plik źródłowy zawierający wywołanie funkcji (60)
  • 3.3.4. Kompilacja i konsolidacja (61)
  • 3.3.5. Rozszerzenia nazw plików (62)
  • 3.3.6. Systemowe pliki nagłówkowe i biblioteki (63)
  • 3.3.7. Preprocesor (63)
  • 3.3.8. Przestrzenie nazw (66)
  • 3.3.9. Słowo kluczowe static (67)
  • 3.3.10. Podsumowanie (69)
• 3.4. Łańcuchy znaków (70)
  
  • 3.4.1. Pierwszy przykład programu wykorzystującego łańcuchy znaków (70)
  • 3.4.2. Kolejny przykładowy program wykorzystujący łańcuchy znaków (74)
  • 3.4.3. Przegląd operacji na łańcuchach znaków (78)
  • 3.4.4. Łańcuchy znaków i C-łańcuchy (79)
  • 3.4.5. Podsumowanie (80)
• 3.5. Kolekcje (80)
  
  • 3.5.1. Program wykorzystujący klasę vector (81)
  • 3.5.2. Program wykorzystujący klasę deque (82)
  • 3.5.3. Wektory i kolejki (83)
  • 3.5.4. Iteratory (84)
  • 3.5.5. Przykładowy program wykorzystujący listy (87)
  • 3.5.6. Przykłady programów wykorzystujących kontenery asocjacyjne (88)
  • 3.5.7. Algorytmy (92)
  • 3.5.8. Algorytmy wielozakresowe (96)
  • 3.5.9. Iteratory strumieni (98)
  • 3.5.10. Uwagi końcowe (100)
  • 3.5.11. Podsumowanie (101)
• 3.6. Obsługa wyjątków (102)
  
  • 3.6.1. Powody wprowadzenia obsługi wyjątków (102)
  • 3.6.2. Koncepcja obsługi wyjątków (104)
  • 3.6.3. Standardowe klasy wyjątków (105)
  • 3.6.4. Przykład obsługi wyjątku (106)
  • 3.6.5. Obsługa nieoczekiwanych wyjątków (109)
  • 3.6.6. Funkcje pomocnicze obsługi błędów (110)
  • 3.6.7. Podsumowanie (111)
• 3.7. Wskaźniki, tablice i C-łańcuchy (112)
  
  • 3.7.1. Wskaźniki (112)
  • 3.7.2. Tablice (115)
  • 3.7.3. C-łańcuchy (117)
  • 3.7.4. Podsumowanie (121)
• 3.8. Zarządzanie pamięcią za pomocą operatorów new i delete (121)
  
  • 3.8.1. Operator new (123)
  • 3.8.2. Operator delete (123)
  • 3.8.3. Dynamiczne zarządzanie pamięcią tablic (124)
  • 3.8.4. Obsługa błędów związanych z operatorem new (126)
  • 3.8.5. Podsumowanie (126)
• 3.9. Komunikacja ze światem zewnętrznym (126)
  
  • 3.9.1. Parametry wywołania programu (126)
  • 3.9.2. Dostęp do zmiennych środowiska (128)
  • 3.9.3. Przerwanie działania programu (128)
  • 3.9.4. Wywoływanie innych programów (129)
  • 3.9.5. Podsumowanie (130)

Rozdział 4. Programowanie klas (131)

• 4.1. Pierwsza klasa: Fraction (131)
  
  • 4.1.1. Zanim rozpoczniemy implementację (131)
  • 4.1.2. Deklaracja klasy Fraction (134)
  • 4.1.3. Struktura klasy (135)
  • 4.1.4. Funkcje składowe (138)
  • 4.1.5. Konstruktory (138)
  • 4.1.6. Przeciążenie funkcji (140)
  • 4.1.7. Implementacja klasy Fraction (141)
  • 4.1.8. Wykorzystanie klasy Fraction (146)
  • 4.1.9. Tworzenie obiektów tymczasowych (151)
  • 4.1.10. Notacja UML (152)
  • 4.1.11. Podsumowanie (152)
• 4.2. Operatory klas (153)
  
  • 4.2.1. Deklaracje operatorów (153)
  • 4.2.2. Implementacja operatorów (156)
  • 4.2.3. Posługiwanie się operatorami (163)
  • 4.2.4. Operatory globalne (164)
  • 4.2.5. Ograniczenia w definiowaniu operatorów (165)
  • 4.2.6. Specjalne właściwości niektórych operatorów (166)
  • 4.2.7. Podsumowanie (170)
• 4.3. Optymalizacja efektywności kodu (170)
  
  • 4.3.1. Wstępna optymalizacja klasy Fraction (171)
  • 4.3.2. Domyślne parametry funkcji (174)
  • 4.3.3. Funkcje rozwijane w miejscu wywołania (175)
  • 4.3.4. Optymalizacja z perspektywy użytkownika (177)
  • 4.3.5. Instrukcja using (178)
  • 4.3.6. Deklaracje pomiędzy instrukcjami (179)
  • 4.3.7. Konstruktory kopiujące (181)
  • 4.3.8. Podsumowanie (182)
• 4.4. Referencje i stałe (183)
  
  • 4.4.1. Konstruktory kopiujące i przekazywanie parametrów (183)
  • 4.4.2. Referencje (184)
  • 4.4.3. Stałe (187)
  • 4.4.4. Stałe funkcje składowe (189)
  • 4.4.5. Klasa Fraction wykorzystująca referencje (190)
  • 4.4.6. Wskaźniki stałych i stałe wskaźniki (193)
  • 4.4.7. Podsumowanie (195)
• 4.5. Strumienie wejścia i wyjścia (196)
  
  • 4.5.1. Strumienie (196)
  • 4.5.2. Korzystanie ze strumieni (197)
  • 4.5.3. Stan strumienia (203)
  • 4.5.4. Operatory wejścia i wyjścia dla typów definiowanych przez użytkownika (205)
  • 4.5.5. Podsumowanie (214)
• 4.6. Klasy zaprzyjaźnione i inne typy (214)
  
  • 4.6.1. Automatyczna konwersja typów (215)
  • 4.6.2. Słowo kluczowe explicit (217)
  • 4.6.3. Funkcje zaprzyjaźnione (217)
  • 4.6.4. Funkcje konwersji (223)
  • 4.6.5. Problemy automatycznej konwersji typu (225)
  • 4.6.6. Inne zastosowania słowa kluczowego friend (227)
  • 4.6.7. Słowo kluczowe friend i programowanie obiektowe (227)
  • 4.6.8. Podsumowanie (228)
• 4.7. Obsługa wyjątków w klasach (229)
  
  • 4.7.1. Powody zastosowania obsługi wyjątków w klasie Fraction (229)
  • 4.7.2. Obsługa wyjątków w klasie Fraction (230)
  • 4.7.3. Klasy wyjątków (237)
  • 4.7.4. Ponowne wyrzucenie wyjątku (237)
  • 4.7.5. Wyjątki w destruktorach (238)
  • 4.7.6. Wyjątki i deklaracje interfejsów (238)
  • 4.7.7. Hierarchie klas wyjątków (239)
  • 4.7.8. Projektowanie klas wyjątków (242)
  • 4.7.9. Wyrzucanie standardowych wyjątków (244)
  • 4.7.10. Bezpieczeństwo wyjątków (244)
  • 4.7.11. Podsumowanie (245)

Rozdział 5. Dziedziczenie i polimorfizm (247)

• 5.1. Dziedziczenie pojedyncze (249)
  
  • 5.1.1. Klasa Fraction jako klasa bazowa (249)
  • 5.1.2. Klasa pochodna RFraction (251)
  • 5.1.3. Deklaracja klasy pochodnej RFraction (253)
  • 5.1.4. Dziedziczenie i konstruktory (255)
  • 5.1.5. Implementacja klas pochodnych (258)
  • 5.1.6. Wykorzystanie klasy pochodnej (260)
  • 5.1.7. Konstruktory obiektów klasy bazowej (262)
  • 5.1.8. Podsumowanie (264)
• 5.2. Funkcje wirtualne (264)
  
  • 5.2.1. Problemy z przesłanianiem funkcji (265)
  • 5.2.2. Statyczne i dynamiczne wiązanie funkcji (267)
  • 5.2.3. Przeciążenie i przesłanianie (271)
  • 5.2.4. Dostęp do parametrów klasy bazowej (273)
  • 5.2.5. Destruktory wirtualne (274)
  • 5.2.6. Właściwe sposoby stosowania dziedziczenia (275)
  • 5.2.7. Inne pułapki przesłaniania funkcji (279)
  • 5.2.8. Dziedziczenie prywatne i deklaracje dostępu (281)
  • 5.2.9. Podsumowanie (284)
• 5.3. Polimorfizm (285)
  
  • 5.3.1. Czym jest polimorfizm? (285)
  • 5.3.2. Polimorfizm w języku C++ (287)
  • 5.3.3. Przykład polimorfizmu w języku C++ (288)
  • 5.3.4. Abstrakcyjna klasa bazowa GeoObj (291)
  • 5.3.5. Zastosowanie polimorfizmu wewnątrz klas (298)
  • 5.3.6. Polimorfizm nie wymaga instrukcji wyboru (304)
  • 5.3.7. Przywracanie obiektowi jego rzeczywistej klasy (304)
  • 5.3.8. Projektowanie przez kontrakt (308)
  • 5.3.9. Podsumowanie (309)
• 5.4. Dziedziczenie wielokrotne (310)
  
  • 5.4.1. Przykład dziedziczenia wielokrotnego (310)
  • 5.4.2. Wirtualne klasy bazowe (315)
  • 5.4.3. Identyczność i adresy (318)
  • 5.4.4. Wielokrotne dziedziczenie tej samej klasy bazowej (321)
  • 5.4.5. Podsumowanie (321)
• 5.5. Pułapki projektowania z użyciem dziedziczenia (322)
  
  • 5.5.1. Dziedziczenie kontra zawieranie (322)
  • 5.5.2. Błędy projektowania: ograniczanie dziedziczenia (323)
  • 5.5.3. Błędy projektowania: dziedziczenie zmieniające wartość (324)
  • 5.5.4. Błędy projektowania: dziedziczenie zmieniające interpretację wartości (326)
  • 5.5.5. Unikajmy dziedziczenia! (327)
  • 5.5.6. Podsumowanie (327)

Rozdział 6. Składowe dynamiczne i statyczne (329)

• 6.1. Składowe dynamiczne (329)
  
  • 6.1.1. Implementacja klasy String (329)
  • 6.1.2. Konstruktory i składowe dynamiczne (334)
  • 6.1.3. Implementacja konstruktora kopiującego (336)
  • 6.1.4. Destruktory (337)
  • 6.1.5. Implementacja operatora przypisania (337)
  • 6.1.6. Pozostałe operatory (339)
  • 6.1.7. Wczytywanie łańcucha klasy String (341)
  • 6.1.8. Komercyjne implementacje klasy String (344)
  • 6.1.9. Inne zastosowania składowych dynamicznych (346)
  • 6.1.10. Podsumowanie (347)
• 6.2. Inne aspekty składowych dynamicznych (348)
  
  • 6.2.1. Składowe dynamiczne w obiektach stałych (348)
  • 6.2.2. Funkcje konwersji dla składowych dynamicznych (351)
  • 6.2.3. Funkcje konwersji i instrukcje warunkowe (353)
  • 6.2.4. Stałe jako zmienne (355)
  • 6.2.5. Zapobieganie wywołaniu domyślnych operacji (357)
  • 6.2.6. Klasy zastępcze (358)
  • 6.2.7. Obsługa wyjątków z użyciem parametrów (361)
  • 6.2.8. Podsumowanie (365)
• 6.3. Dziedziczenie i klasy o składowych dynamicznych (365)
  
  • 6.3.1. Klasa CPPBook::String jak klasa bazowa (365)
  • 6.3.2 Klasa pochodna ColString (368)
  • 6.3.3. Dziedziczenie funkcji zaprzyjaźnionych (371)
  • 6.3.4. Plik źródłowy klasy pochodnej ColString (373)
  • 6.3.5. Aplikacja klasy ColString (374)
  • 6.3.6. Dziedziczenie specjalnych funkcji dla składowych dynamicznych (375)
  • 6.3.7. Podsumowanie (376)
• 6.4. Klasy zawierające klasy (376)
  
  • 6.4.1. Obiekty jako składowe innych klas (377)
  • 6.4.2. Implementacja klasy Person (377)
  • 6.4.3. Podsumowanie (383)
• 6.5. Składowe statyczne i typy pomocnicze (383)
  
  • 6.5.1. Statyczne składowe klas (384)
  • 6.5.2. Deklaracje typu wewnątrz klasy (389)
  • 6.5.3. Typy wyliczeniowe jako statyczne stałe klasy (391)
  • 6.5.4. Klasy zagnieżdżone i klasy lokalne (392)
  • 6.5.5. Podsumowanie (393)

Rozdział 7. Szablony (395)

• 7.1. Dlaczego szablony? (395)
  
  • 7.1.1. Terminologia (396)
• 7.2. Szablony funkcji (396)
  
  • 7.2.1. Definiowanie szablonów funkcji (397)
  • 7.2.2. Wywoływanie szablonów funkcji (398)
  • 7.2.3. Praktyczne wskazówki dotyczące używania szablonów (399)
  • 7.2.4. Szablony i automatyczna konwersja typu (399)
  • 7.2.5. Przeciążanie szablonów (400)
  • 7.2.6. Zmienne lokalne (402)
  • 7.2.7. Podsumowanie (402)
• 7.3. Szablony klas (403)
  
  • 7.3.1. Implementacja szablonu klasy Stack (403)
  • 7.3.2. Zastosowanie szablonu klasy Stack (406)
  • 7.3.3. Specjalizacja szablonów klas (408)
  • 7.3.4. Domyślne parametry szablonu (410)
  • 7.3.5. Podsumowanie (412)
• 7.4. Inne parametry szablonów (412)
  
  • 7.4.1. Przykład zastosowania innych parametrów szablonów (412)
  • 7.4.2. Ograniczenia parametrów szablonów (415)
  • 7.4.3. Podsumowanie (416)
• 7.5. Inne zagadnienia związane z szablonami (416)
  
  • 7.5.1. Słowo kluczowe typename (416)
  • 7.5.2. Składowe jako szablony (417)
  • 7.5.3. Polimorfizm statyczny z użyciem szablonów (420)
  • 7.5.4. Podsumowanie (424)
• 7.6. Szablony w praktyce (424)
  
  • 7.6.1. Kompilacja kodu szablonu (424)
  • 7.6.2. Obsługa błędów (429)
  • 7.6.3. Podsumowanie (430)

Rozdział 8. Standardowa biblioteka wejścia i wyjścia w szczegółach (433)

• 8.1. Standardowe klasy strumieni (433)
  
  • 8.1.1. Klasy strumieni i obiekty strumieni (434)
  • 8.1.2. Stan strumienia (436)
  • 8.1.3. Operatory standardowe (439)
  • 8.1.4. Funkcje standardowe (440)
  • 8.1.5. Manipulatory (443)
  • 8.1.6. Definicje formatu (445)
  • 8.1.7. Internacjonalizacja (455)
  • 8.1.8. Podsumowanie (458)
• 8.2. Dostęp do plików (458)
  
  • 8.2.1. Klasy strumieni dla plików (458)
  • 8.2.2. Wykorzystanie klas strumieni plików (459)
  • 8.2.3. Znaczniki plików (461)
  • 8.2.4. Jawne otwieranie i zamykanie plików (462)
  • 8.2.5. Swobodny dostęp do plików (463)
  • 8.2.6. Przekierowanie standardowych kanałów do plików (466)
  • 8.2.7. Podsumowanie (467)
• 8.3. Klasy strumieni łańcuchów (467)
  
  • 8.3.1. Klasy strumieni łańcuchów (468)
  • 8.3.2. Operator rzutowania leksykalnego (470)
  • 8.3.3. Strumienie C-łańcuchów (472)
  • 8.3.4. Podsumowanie (474)

Rozdział 9. Inne właściwości języka (475)

• 9.1. Dodatkowe informacje o bibliotece standardowej (475)
  
  • 9.1.1. Operacje na wektorach (475)
  • 9.1.2. Operacje wspólne dla wszystkich kontenerów STL (482)
  • 9.1.3. Algorytmy STL (482)
  • 9.1.4. Ograniczenia wartości numerycznych (488)
  • 9.1.5. Podsumowanie (492)
• 9.2. Definiowanie specjalnych operatorów (493)
  
  • 9.2.1. Inteligentne wskaźniki (493)
  • 9.2.2. Obiekty funkcji (496)
  • 9.2.3. Podsumowanie (500)
• 9.3. Inne aspekty operatorów new i delete (500)
  
  • 9.3.1. Operatory new i delete, które nie wyrzucają wyjątków (500)
  • 9.3.2. Określanie położenia obiektu (501)
  • 9.3.3. Funkcje obsługi operatora new (501)
  • 9.3.4. Przeciążanie operatorów new i delete (506)
  • 9.3.5. Dodatkowe parametry operatora new (509)
  • 9.3.6. Podsumowanie (510)
• 9.4. Wskaźniki funkcji i wskaźniki składowych (510)
  
  • 9.4.1. Wskaźniki funkcji (510)
  • 9.4.2. Wskaźniki składowych (511)
  • 9.4.3. Wskaźniki składowych i zewnętrzne interfejsy (514)
  • 9.4.4. Podsumowanie (515)
• 9.5. Łączenie programów w językach C i C++ (516)
  
  • 9.5.1. Łączenie zewnętrzne (516)
  • 9.5.2. Pliki nagłówkowe w językach C i C++ (517)
  • 9.5.3. Kompilacja funkcji main() (517)
  • 9.5.4. Podsumowanie (518)
• 9.6. Dodatkowe słowa kluczowe (518)
  
  • 9.6.1. Unie (518)
  • 9.6.2. Typy wyliczeniowe (519)
  • 9.6.3. Słowo kluczowe volatile (520)
  • 9.6.4. Podsumowanie (520)

Rozdział 10. Podsumowanie (521)

• 10.1. Hierarchia operatorów języka C++ (521)
  
• 10.2. Właściwości operacji klas (523)
  
• 10.3. Zasady automatycznej konwersji typów (524)
  
• 10.4. Przydatne zasady programowania i projektowania (525)

Dodatek A Bibliografia (529)

Dodatek B Słownik (533)

Skorowidz (539)