C++ jest obecnie wiodącym językiem programowania obiektowego. Jego podstawowymi zaletami w stosunku do innych języków obiektowych jest wysoka efektywność i uniwersalność. Stosowany jest do tworzenia komercyjnego oprogramowania oraz efektywnych rozwiązań złożonych problemów.
Książka krok po kroku omawia wszystkie właściwości języka i wyjaśnia sposoby ich praktycznego użycia. Przedstawione przykłady programów nie są zbyt skomplikowane, by nie odrywać Twojej uwagi od omawianych zagadnień, ale nie są też sztucznie uproszczone. Kluczowym założeniem języka C++ jest programowanie z wykorzystaniem szablonów, które umożliwiają tworzenie rozwiązań o wysokim poziomie ogólności - na przykład implementację polimorfizmu. Nicolai Josuttis omawia możliwość łączenia szablonów z programowaniem obiektowym, która decyduje o potężnych możliwościach języka C++ jako narzędzia tworzenia wydajnych programów. W tym zakresie książka wykracza daleko poza podstawy.
- Wprowadzenie do C++ i programowania obiektowego
- Podstawowe pojęcia języka C++
- Programowanie klas
- Dziedziczenie i polimorfizm
- Składowe dynamiczne i statyczne
- Szablony języka C++
- Szczegółowe omówienie standardowej biblioteki wejścia-wyjścia
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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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)
- 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 B Słownik (533)
Skorowidz (539)