Język C++. Szkoła programowania. Wydanie VI - Stephen Prata

Spis treści

Podziękowania (19)

Wstęp (21)

Rozdział 1. Zaczynamy (31)

• Nauka C++ - co nas czeka? (31)
• Pochodzenie języka C++ - krótka historia (32)
  
  • Język C (32)
  • Filozofia programowania w C (33)
  • Zmiana w C++ - programowanie obiektowe (34)
  • C++ i programowanie uogólnione (35)
  • Pochodzenie C++ (36)
• Przenośność i standardy (37)
  
  • Rozwój języka w liczbach (38)
  • Standardy C++ w niniejszej książce (39)
• Mechanika tworzenia programu (39)
  
  • Pisanie kodu źródłowego (40)
  • Kompilacja i konsolidacja (41)
• Podsumowanie (45)

Rozdział 2. Pierwszy program w C++ (47)

• C++ - początek (47)
  
  • Cechy funkcji main() (49)
  • Komentarze w C++ (51)
  • Preprocesor i plik iostream (52)
  • Nazwy plików nagłówkowych (53)
  • Przestrzenie nazw (53)
  • Wypisywanie danych - cout (55)
  • Formatowanie kodu źródłowego C++ (57)
• Instrukcje C++ (59)
  
  • Instrukcje deklaracji i zmienne (60)
  • Instrukcja przypisania (61)
  • Nowa sztuczka z cout (62)
• Inne instrukcje C++ (62)
  
  • Użycie obiektu cin (63)
  • Złączanie za pomocą cout (64)
  • cin i cout - klasy po raz pierwszy (64)
• Funkcje (66)
  
  • Użycie funkcji zwracającej wartość (66)
  • Odmiany funkcji (69)
  • Funkcje definiowane przez użytkownika (70)
  • Funkcje użytkownika zwracające wartość (73)
  • Dyrektywa using w programach z wieloma funkcjami (74)
• Podsumowanie (76)
• Pytania sprawdzające (77)
• Ćwiczenia programistyczne (77)

Rozdział 3. Dane (79)

• Zmienne proste (80)
  
  • Nazwy zmiennych (80)
  • Typy całkowitoliczbowe (81)
  • Typy short, int, long i long long (82)
  • Typy bez znaku (87)
  • Dobór właściwego typu (89)
  • Literały całkowitoliczbowe (90)
  • Jak C++ ustala typ stałej? (91)
  • Typ char - znaki i małe liczby całkowite (92)
  • Typ danych bool (100)
• Kwalifikator const (100)
• Liczby zmiennoprzecinkowe (101)
  
  • Zapis liczb zmiennoprzecinkowych (102)
  • Zmiennoprzecinkowe typy danych (103)
  • Stałe zmiennoprzecinkowe (105)
  • Zalety i wady liczb zmiennoprzecinkowych (105)
• Operatory arytmetyczne C++ (106)
  
  • Kolejność działań - priorytety operatorów i łączność (107)
  • Odmiany dzielenia (108)
  • Operator modulo (110)
  • Konwersje typów (110)
  • Automatyczne deklaracje typów w C++11 (116)
• Podsumowanie (117)
• Pytania sprawdzające (117)
• Ćwiczenia programistyczne (118)

Rozdział 4. Typy złożone (121)

• Tablice w skrócie (122)
  
  • Uwagi o programie (124)
  • Inicjalizacja tablic (124)
  • Inicjalizacja tablic w C++11 (125)
• Łańcuchy (126)
  
  • Łączenie literałów napisowych (127)
  • Łańcuchy w tablicy (128)
  • Problemy z wprowadzaniem łańcuchów znakowych (129)
  • Wczytywanie łańcuchów znakowych wierszami (130)
  • Mieszanie w danych wejściowych łańcuchów i liczb (134)
• Klasa string - wprowadzenie (135)
  
  • Inicjalizacja łańcuchów znakowych w C++11 (136)
  • Przypisanie, konkatenacja i dołączanie (136)
  • Inne operacje klasy string (138)
  • Klasa string a wejście i wyjście (139)
  • Inne odmiany literałów napisowych (141)
• Struktury (142)
  
  • Użycie struktury w programie (143)
  • Inicjalizacja struktur w C++11 (145)
  • Czy w strukturze można użyć pola typu string? (146)
  • Inne cechy struktur (146)
  • Tablice struktur (148)
  • Pola bitowe (149)
• Unie (149)
• Typy wyliczeniowe (151)
  
  • Ustawianie wartości enumeratorów (153)
  • Zakresy wartości w typach wyliczeniowych (153)
• Wskaźniki i różne drobiazgi (154)
  
  • Deklarowanie i inicjalizacja wskaźników (156)
  • Niebezpieczeństwa związane ze wskaźnikami (158)
  • Wskaźniki i liczby (159)
  • Użycie operatora new do alokowania pamięci (159)
  • Zwalnianie pamięci za pomocą delete (161)
  • Użycie new do tworzenia tablic dynamicznych (162)
• Wskaźniki, tablice i arytmetyka wskaźników (165)
  
  • Podsumowanie informacji o wskaźnikach (168)
  • Wskaźniki i łańcuchy (170)
  • Użycie new do tworzenia struktur dynamicznych (174)
  • Alokacja pamięci: automatyczna, statyczna i dynamiczna (177)
• Kombinacje typów (179)
• Tablice inaczej (181)
  
  • Klasa szablonowa vector (181)
  • Klasa szablonowa array (C++11) (182)
  • Porównanie tablic z obiektami vector i array (183)
• Podsumowanie (184)
• Pytania sprawdzające (185)
• Ćwiczenia programistyczne (186)

Rozdział 5. Pętle i wyrażenia relacyjne (189)

• Pętle for (190)
  
  • Elementy pętli for (191)
  • Wracamy do pętli for (196)
  • Zmiana wielkości kroku (198)
  • Pętla for i łańcuchy znakowe (198)
  • Operatory inkrementacji (++) i dekrementacji (--) (199)
  • Efekty uboczne i punkty odniesienia (200)
  • Formy przedrostkowe a formy przyrostkowe (201)
  • Operatory inkrementacji i dekrementacji a wskaźniki (202)
  • Złożone operatory przypisania (203)
  • Instrukcje złożone, czyli bloki (203)
  • Przecinek jako operator (i pewne sztuczki składniowe) (205)
  • Wyrażenia relacyjne (208)
  • Przypisania, porównania i pomyłki (208)
  • Porównywanie łańcuchów w stylu C (210)
  • Porównywanie obiektów klasy string (213)
• Pętla while (213)
  
  • Uwagi o programie (215)
  • Pętla for a pętla while (216)
  • Chwileczkę - tworzymy pętlę opóźnienia (217)
• Pętla do while (219)
• Zakresowe pętle for (C++11) (221)
• Pętle i wprowadzanie danych tekstowych (221)
  
  • Najprostsza wersja cin (222)
  • cin.get(char) na odsiecz (223)
  • Która wersja cin.get() jest lepsza? (224)
  • Koniec pliku (224)
  • Jeszcze inna wersja cin.get() (227)
• Pętle zagnieżdżone i dwuwymiarowe tablice (230)
  
  • Inicjalizacja tablic dwuwymiarowych (232)
  • Stosowanie tablic dwuwymiarowych (232)
• Podsumowanie (234)
• Pytania sprawdzające (234)
• Ćwiczenia programistyczne (235)

Rozdział 6. Instrukcje warunkowe i operatory logiczne (237)

• Instrukcja if (237)
  
  • Instrukcja if else (239)
  • Formatowanie instrukcji if else (241)
  • Konstrukcja if else if else (241)
• Wyrażenia logiczne (243)
  
  • Logiczny operator alternatywy - || (243)
  • Logiczny operator koniunkcji - && (245)
  • Ustalanie zakresu za pomocą operatora && (247)
  • Operator negacji logicznej - ! (248)
  • O operatorach logicznych (250)
  • Zapis alternatywny (251)
• Biblioteka cctype (251)
• Operator ?: (253)
• Instrukcja switch (255)
  
  • Użycie enumeratorów jako etykiet (258)
  • switch versus if else (259)
• Instrukcje break i continue (259)
  
  • Uwagi o programie (261)
• Pętle wczytywania liczb (262)
  
  • Uwagi o programie (264)
• Proste wejście-wyjście z pliku (265)
  
  • Tekstowe wejście-wyjście i pliki tekstowe (265)
  • Zapis do pliku tekstowego (267)
  • Odczyt danych z pliku tekstowego (270)
• Podsumowanie (274)
• Pytania sprawdzające (275)
• Ćwiczenia programistyczne (276)

Rozdział 7. Funkcje - składniki programów w C++ (279)

• Funkcje w skrócie (280)
  
  • Definiowanie funkcji (281)
  • Prototypowanie i wywoływanie funkcji (283)
• Parametry funkcji i przekazywanie przez wartość (286)
  
  • Wiele parametrów (287)
  • Jeszcze jedna funkcja dwuargumentowa (289)
• Funkcje i tablice (291)
  
  • Jak wskaźniki umożliwiają tworzenie funkcji przetwarzających tablice? (292)
  • Skutki użycia tablic jako parametrów (293)
  • Dodatkowe przykłady funkcji i tablic (295)
  • Funkcje korzystające z zakresów tablic (301)
  • Wskaźniki i modyfikator const (302)
• Funkcje i tablice dwuwymiarowe (306)
• Funkcje i łańcuchy w stylu C (307)
  
  • Funkcje z łańcuchami w stylu C jako parametrami (307)
  • Funkcje zwracające łańcuchy w formacie C (309)
• Funkcje i struktury (310)
  
  • Przekazywanie i zwracanie struktur (311)
  • Inny przykład użycia funkcji i struktur (312)
  • Przekazywanie adresu struktury (317)
• Funkcje i obiekty klasy string (318)
  
  • Funkcje i obiekty typu array (320)
  • Uwagi o programie (321)
• Rekurencja (322)
  
  • Rekurencja w pojedynczym wywołaniu (322)
  • Rekurencja w wielu wywołaniach (324)
• Wskaźniki na funkcje (325)
  
  • Wskaźniki na funkcje - podstawy (325)
  • Przykład użycia wskaźników na funkcje (327)
  • Wariacje na temat wskaźników funkcji (329)
  • Uproszczenie poprzez typedef (333)
• Podsumowanie (333)
• Pytania sprawdzające (334)
• Ćwiczenia programistyczne (336)

Rozdział 8. Funkcje - zagadnienia zaawansowane (339)

• Funkcje inline (339)
• Zmienne referencyjne (342)
  
  • Tworzenie zmiennej referencyjnej (342)
  • Referencje jako parametry funkcji (345)
  • Właściwości referencji (348)
  • Użycie referencji do struktur (352)
  • Użycie referencji z obiektami (358)
  • Obiekty po raz wtóry - obiekty, dziedziczenie i referencje (361)
  • Kiedy korzystać z referencji jako parametrów? (364)
• Parametry domyślne (365)
  
  • Uwagi o programie (366)
• Przeciążanie funkcji (367)
  
  • Przykład przeciążania funkcji (370)
  • Kiedy korzystać z przeciążania funkcji? (372)
• Szablony funkcji (372)
  
  • Przeciążone szablony (375)
  • Ograniczenia szablonów (377)
  • Specjalizacje jawne (377)
  • Konkretyzacje i specjalizacje (380)
  • Którą wersję funkcji wybierze kompilator? (382)
  • Ewolucja szablonów funkcji (388)
• Podsumowanie (392)
• Pytania sprawdzające (392)
• Ćwiczenia programistyczne (393)

Rozdział 9. Model pamięci i przestrzenie nazw (397)

• Kompilacja rozłączna (397)
• Czas życia, zasięg i łączenie (403)
  
  • Zasięg i łączenie (404)
  • Przydział automatyczny (404)
  • Zmienne statyczne (409)
  • Przydział statyczny, łączenie zewnętrzne (411)
  • Specyfikatory i kwalifikatory (419)
  • Łączenie a funkcje (421)
  • Łączenie językowe (422)
  • Kategorie przydziału a przydział dynamiczny (423)
• Przestrzenie nazw (429)
  
  • Tradycyjne przestrzenie nazw języka C++ (429)
  • Nowe mechanizmy przestrzeni nazw (431)
  • Przestrzenie nazw - przykład (438)
  • Przyszłość przestrzeni nazw (441)
• Podsumowanie (442)
• Pytania sprawdzające (442)
• Ćwiczenia programistyczne (445)

Rozdział 10. Obiekty i klasy (447)

• Programowanie proceduralne a programowanie obiektowe (448)
• Klasy a abstrakcje (449)
  
  • Czym jest typ? (449)
  • Klasy w języku C++ (450)
  • Implementowanie metod klas (455)
  • Stosowanie klas (459)
  • Zmiany implementacji (461)
  • Podsumowanie poznanych wiadomości (462)
• Konstruktory i destruktory (463)
  
  • Deklarowanie i definiowanie konstruktorów (464)
  • Stosowanie konstruktorów (465)
  • Konstruktory domyślne (466)
  • Destruktory (467)
  • Ulepszenia klasy Stock (468)
  • Konstruktory i destruktory - podsumowanie (475)
• Tożsamość obiektu - wskaźnik this (476)
• Tablice obiektów (482)
• Zasięg klasy (485)
  
  • Stałe zasięgu klasy (486)
  • Wyliczenia z własnym zasięgiem (C++11) (487)
• Abstrakcyjne typy danych (488)
• Podsumowanie (492)
• Pytania sprawdzające (493)
• Ćwiczenia programistyczne (493)

Rozdział 11. Stosowanie klas (497)

• Przeciążanie operatorów (498)
• Raz, dwa, trzy - próba przeciążenia operatora (499)
  
  • Dodatkowy operator dodawania (502)
  • Ograniczenia przeciążania operatorów (505)
  • Jeszcze o przeciążaniu operatorów (506)
• Przyjaciele najważniejsi (509)
  
  • Deklarowanie przyjaźni (510)
  • Typowa przyjaźń - przeciążanie operatora << (512)
• Przeciążanie operatorów - metody kontra funkcje nieskładowe (518)
• Przeciążania ciąg dalszy - klasa Vector (519)
  
  • Składowa kodująca stan obiektu (526)
  • Przeciążanie operatorów arytmetycznych dla klasy Vector (528)
  • Nota implementacyjna (530)
  • Wektorowe błądzenie losowe (530)
• Automatyczne konwersje i rzutowanie typów klas (534)
  
  • O programie (539)
  • Funkcje konwersji (539)
  • Konwersja a zaprzyjaźnienie (544)
• Podsumowanie (547)
• Pytania sprawdzające (549)
• Ćwiczenia programistyczne (549)

Rozdział 12. Klasy a dynamiczny przydział pamięci (553)

• Klasy a pamięć dynamiczna (554)
  
  • Powtórka z pamięci dynamicznej i statyczne składowe klas (554)
  • Specjalne metody klasy (562)
  • W czym tkwi problem z konstruktorem kopiującym w Stringbad? (565)
  • Kolejne słabości Stringbad: operatory przypisania (568)
• Nowa, ulepszona klasa - String (571)
  
  • Nowa wersja konstruktora domyślnego (572)
  • Porównywanie ciągów (573)
  • Indeksowanie ciągu (574)
  • Statyczne metody klasy (575)
  • Dalsze przeciążanie operatora przypisania (576)
• O czym należy pamiętać, stosując new w konstruktorach? (581)
  
  • Zalecenia i przestrogi (582)
  • Kopiowanie obiektów składowa po składowej (583)
• Słów parę o zwracaniu obiektów (584)
  
  • Zwracanie niemodyfikowalnej (const) referencji obiektu (584)
  • Zwracanie modyfikowalnej (bez const) referencji do obiektu (585)
  • Zwracanie obiektu przez wartość (585)
  • Zwracanie przez wartość obiektu niemodyfikowalnego (const) (586)
• Wskaźniki obiektów (587)
  
  • Jeszcze o new i delete (589)
  • Wskaźniki obiektów - podsumowanie (590)
  • Jeszcze o miejscowej wersji new (592)
• Powtórka z poznanych technik (596)
  
  • Przeciążanie operatora << (596)
  • Funkcje konwersji (597)
  • Klasy wykorzystujące new w konstruktorach (597)
• Symulacja kolejki (598)
  
  • Klasa kolejki (598)
  • Klasa klienta (609)
  • Symulacja bankomatu (612)
• Podsumowanie (616)
• Pytania sprawdzające (617)
• Ćwiczenia programistyczne (619)

Rozdział 13. Klasy i dziedziczenie (623)

• Prosta klasa bazowa (624)
  
  • Dziedziczenie (626)
  • Konstruktory - zagadnienia związane z poziomem dostępu (628)
  • Korzystanie z klasy pochodnej (631)
  • Relacje między klasą pochodną a bazową (633)
• Dziedziczenie - relacja jest-czymś (635)
• Polimorficzne dziedziczenie publiczne (636)
  
  • Tworzenie klas Brass oraz BrassPlus (637)
• Wiązanie statyczne i dynamiczne (648)
  
  • Zgodność typów wskaźnikowych i referencyjnych (648)
  • Metody wirtualne i wiązanie dynamiczne (650)
  • Co trzeba wiedzieć o metodach wirtualnych? (653)
• Kontrola dostępu - poziom chroniony (656)
• Abstrakcyjne klasy bazowe (657)
  
  • Stosowanie abstrakcyjnych klas bazowych (659)
  • Filozofia abstrakcyjnych klas bazowych (665)
• Dziedziczenie i dynamiczny przydział pamięci (665)
  
  • Przypadek pierwszy - klasa pochodna bez dynamicznego przydziału pamięci (665)
  • Przypadek drugi - klasa pochodna z dynamicznym przydziałem pamięci (666)
  • Przykład dziedziczenia z wykorzystaniem dynamicznego przydziału pamięci oraz funkcji zaprzyjaźnionych (668)
• Projektowanie klas - przegląd zagadnień (673)
  
  • Metody automatycznie generowane przez kompilator (673)
  • Inne metody (675)
  • Dziedziczenie publiczne (678)
  • Metody klasy - podsumowanie (682)
• Podsumowanie (683)
• Pytania sprawdzające (683)
• Ćwiczenia programistyczne (684)

Rozdział 14. Wielokrotne użycie kodu w C++ (687)

• Klasy ze składowymi w postaci obiektów (688)
  
  • Krótka charakterystyka klasy valarray (688)
  • Projekt klasy Student (689)
  • Przykładowa klasa Student (691)
• Dziedziczenie prywatne (697)
  
  • Nowa wersja klasy Student (697)
• Dziedziczenie wielokrotne (706)
  
  • Podwójne egzemplarze klasy Worker (711)
  • Podwójne metody (714)
  • Przegląd zagadnień związanych z dziedziczeniem wielokrotnym (723)
• Szablony klas (724)
  
  • Definiowanie szablonu klasy (724)
  • Korzystanie z szablonu klasy (727)
  • Analiza szablonu klasy (729)
  • Szablon tablicy i argumenty pozatypowe szablonu (734)
  • Elastyczność szablonów (736)
  • Specjalizacja szablonu (739)
  • Szablony jako składowe (742)
  • Szablony jako parametry (744)
  • Szablony klas i zaprzyjaźnienie (746)
  • Szablonowe aliasy typów (C++11) (752)
• Podsumowanie (753)
• Pytania sprawdzające (755)
• Ćwiczenia programistyczne (757)

Rozdział 15. Zaprzyjaźnienie, wyjątki i nie tylko (763)

• Zaprzyjaźnienie (763)
  
  • Klasy zaprzyjaźnione (764)
  • Zaprzyjaźnione metody klas (768)
  • Inne relacje przyjaźni (771)
• Klasy zagnieżdżone (773)
  
  • Dostęp do klas zagnieżdżonych (774)
  • Zagnieżdżanie w szablonie (776)
• Wyjątki (779)
  
  • Wywoływanie funkcji abort() (779)
  • Zwracanie kodu błędu (780)
  • Mechanizm wyjątków (782)
  • Wyjątki w postaci obiektów (784)
  • Specyfikacje wyjątków a C++11 (788)
  • Rozwijanie stosu (789)
  • Inne właściwości wyjątków (793)
  • Klasa exception (796)
  • Wyjątki, klasy i dziedziczenie (799)
  • Problemy z wyjątkami (804)
  • Ostrożnie z wyjątkami (807)
• RTTI (808)
  
  • Po co nam RTTI? (808)
  • Jak działa RTTI? (809)
• Operatory rzutowania typu (816)
• Podsumowanie (820)
• Pytania sprawdzające (820)
• Ćwiczenia programistyczne (822)

Rozdział 16. Klasa string oraz biblioteka STL (823)

• Klasa string (823)
  
  • Tworzenie obiektu string (824)
  • Wprowadzanie danych do obiektów string (828)
  • Używanie obiektów string (830)
  • Co jeszcze oferuje klasa string? (835)
  • Warianty klasy string (837)
• Szablony klas inteligentnych wskaźników (837)
  
  • Stosowanie inteligentnych wskaźników (838)
  • Więcej o inteligentnych wskaźnikach (841)
  • Wyższość unique_ptr nad auto_ptr (844)
  • Wybór inteligentnego wskaźnika (845)
• Biblioteka STL (847)
  
  • Szablon klasy vector (847)
  • Metody klasy vector (849)
  • Inne możliwości klasy vector (853)
  • Zakresowe pętle for (C++11) (857)
• Programowanie uogólnione (858)
  
  • Do czego potrzebne są iteratory? (858)
  • Rodzaje iteratorów (862)
  • Hierarchia iteratorów (865)
  • Pojęcia, uściślenia i modele (866)
  • Rodzaje kontenerów (872)
  • Kontenery asocjacyjne (881)
  • Nieuporządkowane kontenery asocjacyjne (C++11) (887)
• Obiekty funkcyjne (funktory) (887)
  
  • Pojęcia związane z funktorami (888)
  • Funktory predefiniowane (891)
  • Funktory adaptowalne i adaptatory funkcji (892)
• Algorytmy (895)
  
  • Grupy algorytmów (895)
  • Ogólne właściwości algorytmów (896)
  • Biblioteka STL i klasa string (897)
  • Funkcje a metody kontenerów (898)
  • Używanie biblioteki STL (899)
• Inne biblioteki (903)
  
  • Klasy vector, valarray i array (903)
  • Szablon initializer_list (C++11) (908)
  • Stosowanie szablonu initializer_list (910)
  • Uwagi do programu (911)
• Podsumowanie (911)
• Pytania sprawdzające (913)
• Ćwiczenia programistyczne (914)

Rozdział 17. Obsługa wejścia, wyjścia oraz plików (917)

• Ogólna charakterystyka obsługi wejścia-wyjścia w języku C++ (918)
  
  • Strumienie i bufory (919)
  • Strumienie i bufory a plik iostream (921)
  • Przekierowanie (923)
• Realizacja operacji wyjścia z wykorzystaniem obiektu cout (924)
  
  • Przeciążony operator << (924)
  • Inne metody klasy ostream (927)
  • Opróżnianie bufora wyjściowego (930)
  • Formatowanie danych wyjściowych za pomocą obiektu cout (931)
• Realizacja operacji wejścia z wykorzystaniem obiektu cin (945)
  
  • Jak operator >> obiektu cin "widzi" dane wejściowe? (947)
  • Stany strumienia (949)
  • Inne metody klasy istream (953)
  • Pozostałe metody klasy istream (960)
• Wejście-wyjście plikowe (964)
  
  • Proste operacje wejścia-wyjścia plikowego (965)
  • Kontrola strumienia i metoda is_open() (968)
  • Otwieranie wielu plików (969)
  • Przetwarzanie argumentów wiersza polecenia (969)
  • Tryby otwarcia pliku (971)
  • Dostęp swobodny (981)
• Formatowanie wewnętrzne (988)
• Podsumowanie (991)
• Pytania sprawdzające (992)
• Ćwiczenia programistyczne (993)

Rozdział 18. Nowy standard C++ (997)

• Podsumowanie omawianych elementów C++11 (997)
  
  • Nowe typy (997)
  • Jednolita inicjalizacja (998)
  • Deklaracje (999)
  • nullptr (1001)
  • Inteligentne wskaźniki (1002)
  • Zmiany w specyfikacji wyjątków (1002)
  • Jawny zasięg elementów wyliczeń (1002)
  • Zmiany w klasach (1003)
  • Zmiany w szablonach i bibliotece STL (1004)
  • Referencje r-wartościowe (1006)
• Semantyka przeniesienia i referencje r-wartościowe (1007)
  
  • Potrzeba semantyki przeniesienia (1007)
  • Przykład przenoszenia (1008)
  • Konstruktor przenoszący - wnioski (1013)
  • Przypisania (1014)
  • Wymuszanie przeniesienia (1015)
• Nowe elementy klas (1018)
  
  • Specjalne metody klas (1018)
  • Metody domyślne i usunięte (1019)
  • Delegowanie konstruktorów (1021)
  • Dziedziczenie konstruktorów (1021)
  • Zarządzanie metodami wirtualnymi: ovverride i final (1023)
• Funkcje lambda (1024)
  
  • Wskaźniki do funkcji, funktory i lambdy (1024)
  • Po co nam lambdy? (1027)
• Adaptery (1030)
  
  • Adapter function a nieefektywność szablonów (1030)
  • Naprawa problemu (1032)
  • Dalsze możliwości (1034)
• Szablony o zmiennej liczbie parametrów (1035)
  
  • Pakiety parametrów szablonu i funkcji (1035)
  • Rozpakowywanie pakietów (1036)
  • Rekurencja w szablonach o zmiennej liczbie parametrów (1037)
• Pozostałe udogodnienia C++11 (1040)
  
  • Programowanie współbieżne (1040)
  • Uzupełnienia biblioteki (1040)
  • Programowanie niskopoziomowe (1041)
  • Inne (1042)
• Zmiany języka (1042)
  
  • Projekt Boost (1043)
  • TR1 (1043)
  • Korzystanie z bibliotek Boost (1043)
• Co dalej? (1044)
• Podsumowanie (1045)
• Pytania sprawdzające (1046)
• Ćwiczenia programistyczne (1049)

Dodatek A Systemy liczbowe (1051)

• Liczby dziesiętne (o podstawie 10) (1051)
• Liczby całkowite ósemkowe (o podstawie 8) (1051)
• Liczby szesnastkowe (1052)
• Liczby dwójkowe (o podstawie 2) (1052)
• Zapis dwójkowy a szesnastkowy (1053)

Dodatek B Słowa zastrzeżone języka C++ (1055)

• Słowa kluczowe języka C++ (1055)
• Leksemy alternatywne (1056)
• Nazwy zastrzeżone bibliotek języka C++ (1056)
• Identyfikatory o specjalnym znaczeniu (1057)

Dodatek C Zestaw znaków ASCII (1059)

Dodatek D Priorytety operatorów (1063)

Dodatek E Inne operatory (1067)

• Operatory bitowe (1067)
  
  • Operatory przesunięcia (1067)
  • Bitowe operatory logiczne (1069)
  • Alternatywne reprezentacje operatorów bitowych (1071)
  • Kilka typowych technik wykorzystujących operatory bitowe (1072)
• Operatory wyłuskania składowych (1073)
• alignof (C++11) (1077)
• noexcept (C++11) (1078)

Dodatek F Klasa szablonowa string (1079)

• Trzynaście typów i stała (1080)
• Informacje o danych, konstruktory i różne drobiazgi (1080)
  
  • Konstruktor domyślny (1083)
  • Konstruktory operujące na klasycznych łańcuchach C (1083)
  • Konstruktory operujące na fragmentach łańcuchów C (1084)
  • Konstruktory operujące na referencji l-wartościowej (1084)
  • Konstruktory operujące na referencji r-wartościowej (C++11) (1085)
  • Konstruktory wykorzystujące n kopii znaku (1086)
  • Konstruktory wykorzystujące zakres (1086)
  • Konstruktor operujący na liście inicjalizującej (C++11) (1086)
  • Metody zarządzające pamięcią (1087)
• Dostęp do łańcucha (1087)
• Proste przypisanie (1088)
• Przeszukiwanie łańcuchów (1089)
  
  • Rodzina funkcji find() (1089)
  • Rodzina funkcji rfind() (1089)
  • Rodzina funkcji find_first_of() (1090)
  • Rodzina funkcji find_last_of() (1090)
  • Rodzina funkcji find_first_not_of() (1091)
  • Rodzina funkcji find_last_not_of() (1091)
• Metody i funkcje porównania (1091)
• Modyfikatory łańcuchów (1093)
  
  • Metody dołączania i dodawania (1093)
  • Inne metody przypisania (1094)
  • Metody wstawiania (1094)
  • Metody usuwania (1095)
  • Metody zastępowania (1095)
  • Pozostałe metody modyfikujące: copy() oraz swap() (1096)
• Wejście i wyjście (1096)

Dodatek G Metody i funkcje z biblioteki STL (1099)

• STL a C++11 (1099)
  
  • Nowe kontenery (1099)
  • Zmiany w kontenerach C++98 (1100)
• Składowe wspólne dla wszystkich (lub większości) kontenerów (1101)
• Dodatkowe składowe dla kontenerów sekwencyjnych (1104)
• Dodatkowe operacje zbiorów i map (1107)
• Kontenery asocjacyjne nieporządkujące (C++11) (1109)
• Funkcje STL (1111)
  
  • Niemodyfikujące operacje sekwencyjne (1111)
  • Mutujące operacje sekwencyjne (1116)
  • Operacje sortowania i pokrewne (1125)
  • Operacje liczbowe (1139)

Dodatek H Wybrane pozycje książkowe i zasoby internetowe (1141)

• Wybrane pozycje książkowe (1141)
• Zasoby internetowe (1142)

Dodatek I Dostosowywanie do standardu ANSI/ISO C++ (1145)

• Unikanie nadużywania niektórych dyrektyw preprocesora (1145)
  
  • Do definiowania stałych lepiej używać modyfikatora const niż dyrektywy #define (1145)
  • Do definiowania niewielkich funkcji lepiej używać specyfikatora inline niż makrodefinicji #define (1147)
• Używanie prototypów funkcji (1148)
• Stosowanie rzutowania typów (1148)
• Poznawanie i wykorzystywanie mechanizmów języka C++ (1149)
• Używanie nowej organizacji plików nagłówkowych (1149)
• Korzystanie z przestrzeni nazw (1149)
• Używanie inteligentnych wskaźników (1150)
• Używanie klasy string (1151)
• Korzystanie z biblioteki STL (1151)

Dodatek J Odpowiedzi do pytań sprawdzających (1153)