Spis treści

C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II -- spis treści

Przedmowa do drugiego wydania (17)

Podziękowania do drugiego wydania (19)

Przedmowa do pierwszego wydania (21)

Podziękowania do pierwszego wydania (23)

1. O książce (25)

• 1.1. Dlaczego powstała ta książka? (25)
• 1.2. Co należy wiedzieć przed przystąpieniem do lektury tej książki? (26)
• 1.3. Styl i struktura książki (26)
• 1.4. Jak czytać tę książkę? (30)
• 1.5. Stan obecny (30)
• 1.6. Przykładowy kod i dodatkowe informacje (30)

2. Wprowadzenie do języka C++ i biblioteki standardowej (31)

• 2.1. Historia standardów C++ (31)
  
  • 2.1.1. Typowe pytania o standard C++11 (32)
  • 2.1.2. Zgodność pomiędzy C++11 i C++98 (34)
• 2.2. Złożoność algorytmów a notacja O (34)

3. Nowe elementy języka (37)

• 3.1. Nowe elementy języka C++11 (37)
  
  • 3.1.1. Istotne pomniejsze porządki składniowe (37)
  • 3.1.2. Automatyczna dedukcja typu ze słowem auto (38)
  • 3.1.3. Jednolita składnia inicjalizacji i listy inicjalizacyjne (39)
  • 3.1.4. Pętle zakresowe (41)
  • 3.1.5. Semantyka przeniesienia i referencje do r-wartości (43)
  • 3.1.6. Nowe literały napisowe (48)
  • 3.1.7. Słowo noexcept (49)
  • 3.1.8. Słowo constexpr (51)
  • 3.1.9. Nowe elementy szablonów (51)
  • 3.1.10. Lambdy (53)
  • 3.1.11. Słowo decltype (57)
  • 3.1.12. Nowa składnia deklaracji funkcji (57)
  • 3.1.13. Klasy wyliczeniowe (58)
  • 3.1.14. Nowe typy podstawowe (58)
• 3.2. Starsze "nowości" języka C++ (59)
  
  • 3.2.1. Jawna inicjalizacja typów podstawowych (63)
  • 3.2.2. Definicja funkcji main() (63)

4. Pojęcia ogólne (65)

• 4.1. Przestrzeń nazw std (65)
• 4.2. Pliki nagłówkowe (66)
• 4.3. Obsługa błędów i wyjątków (68)
  
  • 4.3.1. Standardowe klasy wyjątków (68)
  • 4.3.2. Składowe klas wyjątków (72)
  • 4.3.3. Przekazywanie wyjątków z użyciem klasy exception_ptr (80)
  • 4.3.4. Zgłaszanie wyjątków standardowych (80)
  • 4.3.5. Tworzenie klas pochodnych standardowych klas wyjątków (81)
• 4.4. Obiekty wywoływalne (82)
• 4.5. Wielowątkowość i współbieżność (83)
• 4.6. Alokatory (85)

5. Narzędzia (87)

• 5.1. Pary i krotki (88)
  
  • 5.1.1. Pary (88)
  • 5.1.2. Krotki (96)
  • 5.1.3. Wejście-wyjście dla krotek (101)
  • 5.1.4. Konwersje pomiędzy krotkami a parami (103)
• 5.2. Inteligentne wskaźniki (103)
  
  • 5.2.1. Klasa shared_ptr (104)
  • 5.2.2. Klasa weak_ptr (112)
  • 5.2.3. Niepoprawne stosowanie wskaźników współdzielonych (118)
  • 5.2.4. Klasy wskaźników słabych i współdzielonych w szczegółach (120)
  • 5.2.5. Klasa unique_ptr (127)
  • 5.2.6. Klasa unique_ptr w szczegółach (140)
  • 5.2.7. Klasa auto_ptr (143)
  • 5.2.8. Podsumowanie inteligentnych wskaźników (144)
• 5.3. Ograniczenia liczbowe (145)
• 5.4. Cechy typowe i narzędzia pracy z typami (152)
  
  • 5.4.1. Przeznaczenie cech typowych (152)
  • 5.4.2. Cechy typowe w szczegółach (156)
  • 5.4.3. Ujęcia referencyjne (163)
  • 5.4.4. Ujęcia typów funkcyjnych (164)
• 5.5. Funkcje pomocnicze (165)
  
  • 5.5.1. Obliczanie wartości minimalnej oraz maksymalnej (165)
  • 5.5.2. Zamiana dwóch wartości (167)
  • 5.5.3. Dodatkowe operatory porównania (169)
• 5.6. Statyczna arytmetyka liczb wymiernych - klasa ratio<> (170)
• 5.7. Zegary i czasomierze (174)
  
  • 5.7.1. Przegląd biblioteki chrono (174)
  • 5.7.2. Okresy (176)
  • 5.7.3. Zegary i punkty w czasie (180)
  • 5.7.4. Funkcje daty i czasu języka C i standardu POSIX (189)
  • 5.7.5. Czasowe wstrzymywanie wykonania (191)
• 5.8. Pliki nagłówkowe <cstddef>, <cstdlib> oraz <cstring> (192)
  
  • 5.8.1. Definicje w pliku <cstddef> (193)
  • 5.8.2. Definicje w pliku <cstdlib> (193)
  • 5.8.3. Definicje w pliku <cstring> (195)

6. Standardowa biblioteka szablonów (STL) (197)

• 6.1. Składniki biblioteki STL (198)
• 6.2. Kontenery (199)
  
  • 6.2.1. Kontenery sekwencyjne (201)
  • 6.2.2. Kontenery asocjacyjne (210)
  • 6.2.3. Kontenery nieporządkujące (214)
  • 6.2.4. Tablice asocjacyjne (219)
  • 6.2.5. Inne kontenery (221)
  • 6.2.6. Adaptatory kontenerów (222)
• 6.3. Iteratory (223)
  
  • 6.3.1. Inne przykłady użycia kontenerów asocjacyjnych i nieporządkujących (228)
  • 6.3.2. Kategorie iteratorów (233)
• 6.4. Algorytmy (234)
  
  • 6.4.1. Zakresy (238)
  • 6.4.2. Obsługa wielu zakresów (242)
• 6.5. Adaptatory iteratorów (245)
  
  • 6.5.1. Iteratory wstawiające (245)
  • 6.5.2. Iteratory strumieni (247)
  • 6.5.3. Iteratory odwrotne (249)
  • 6.5.4. Iteratory przenoszące (251)
• 6.6. Własne uogólnione operacje na kontenerach (251)
• 6.7. Algorytmy modyfikujące (252)
  
  • 6.7.1. Usuwanie elementów (253)
  • 6.7.2. Algorytmy modyfikujące kontenery asocjacyjne i nieporządkujące (256)
  • 6.7.3. Algorytmy a funkcje składowe (258)
• 6.8. Funkcje jako argumenty algorytmów (259)
  
  • 6.8.1. Przykłady użycia funkcji jako argumentów algorytmów (259)
  • 6.8.2. Predykaty (261)
• 6.9. Stosowanie lambd (263)
• 6.10. Obiekty funkcyjne (267)
  
  • 6.10.1. Definicja obiektów funkcyjnych (267)
  • 6.10.2. Predefiniowane obiekty funkcyjne (273)
  • 6.10.3. Wiązanie wywołania (274)
  • 6.10.4. Obiekty funkcyjne i wiązanie kontra lambdy (277)
• 6.11. Elementy kontenerów (278)
  
  • 6.11.1. Wymagania wobec elementów kontenerów (278)
  • 6.11.2. Semantyka wartości a semantyka referencji (279)
• 6.12. Obsługa błędów i wyjątków wewnątrz biblioteki STL (280)
  
  • 6.12.1. Obsługa błędów (280)
  • 6.12.2. Obsługa wyjątków (282)
• 6.13. Rozbudowa biblioteki STL (286)
  
  • 6.13.1. Integrowanie dodatkowych typów (286)
  • 6.13.2. Dziedziczenie po typach STL (287)

7. Kontenery STL (289)

• 7.1. Wspólne cechy i operacje kontenerów (290)
  
  • 7.1.1. Wspólne cechy kontenerów (290)
  • 7.1.2. Wspólne operacje kontenerów (290)
  • 7.1.3. Typy kontenerów (297)
• 7.2. Tablice (298)
  
  • 7.2.1. Możliwości tablic (298)
  • 7.2.2. Operacje dotyczące tablic (301)
  • 7.2.3. Używanie klas array<> jako zwykłych tablic (305)
  • 7.2.4. Obsługa wyjątków (305)
  • 7.2.5. Interfejs krotki (306)
  • 7.2.6. Przykłady użycia tablic (306)
• 7.3. Wektory (307)
  
  • 7.3.1. Możliwości wektorów (308)
  • 7.3.2. Operacje na wektorach (310)
  • 7.3.3. Używanie wektorów jako zwykłych tablic (316)
  • 7.3.4. Obsługa wyjątków (317)
  • 7.3.5. Przykłady użycia wektorów (318)
  • 7.3.6. Klasa vector<bool> (319)
• 7.4. Kolejki o dwóch końcach (321)
  
  • 7.4.1. Możliwości kolejek deque (322)
  • 7.4.2. Operacje na kolejkach deque (323)
  • 7.4.3. Obsługa wyjątków (327)
  • 7.4.4. Przykłady użycia kolejek deque (327)
• 7.5. Listy (328)
  
  • 7.5.1. Możliwości list (329)
  • 7.5.2. Operacje na listach (330)
  • 7.5.3. Obsługa wyjątków (336)
  • 7.5.4. Przykłady użycia list (337)
• 7.6. Listy jednokierunkowe (338)
  
  • 7.6.1. Możliwości list jednokierunkowych (339)
  • 7.6.2. Operacje na listach jednokierunkowych (341)
  • 7.6.3. Obsługa wyjątków (351)
  • 7.6.4. Przykłady użycia list jednokierunkowych (351)
• 7.7. Zbiory i wielozbiory (352)
  
  • 7.7.1. Możliwości zbiorów i wielozbiorów (354)
  • 7.7.2. Operacje na zbiorach i wielozbiorach (355)
  • 7.7.3. Obsługa wyjątków (364)
  • 7.7.4. Przykłady użycia zbiorów i wielozbiorów (364)
  • 7.7.5. Przykład określania kryterium sortowania podczas wykonywania (367)
• 7.8. Mapy oraz multimapy (369)
  
  • 7.8.1. Możliwości map oraz multimap (370)
  • 7.8.2. Operacje na mapach oraz multimapach (371)
  • 7.8.3. Zastosowanie map jako tablic asocjacyjnych (382)
  • 7.8.4. Obsługa wyjątków (384)
  • 7.8.5. Przykłady użycia map i multimap (384)
  • 7.8.6. Przykład z mapami, łańcuchami oraz definiowaniem kryterium sortowania podczas wykonywania (388)
• 7.9. Kontenery nieuporządkowane (391)
  
  • 7.9.1. Możliwości kontenerów nieuporządkowanych (394)
  • 7.9.2. Tworzenie i kontrolowanie kontenerów nieuporządkowanych (397)
  • 7.9.3. Inne operacje kontenerów nieuporządkowanych (404)
  • 7.9.4. Interfejs kubełków (411)
  • 7.9.5. Zastosowanie map nieuporządkowanych jako tablic asocjacyjnych (412)
  • 7.9.6. Obsługa wyjątków (413)
  • 7.9.7. Przykłady użycia kontenerów nieuporządkowanych (413)
• 7.10. Inne kontenery STL (421)
  
  • 7.10.1. Łańcuchy jako kontenery STL (422)
  • 7.10.2. Zwykłe tablice jako kontenery STL (423)
• 7.11. Implementacja semantyki referencji (425)
• 7.12. Kiedy stosować poszczególne kontenery? (428)

8. Składowe kontenerów STL (435)

• 8.1. Definicje typów (435)
• 8.2. Operacje tworzenia, kopiowania i niszczenia (438)
• 8.3. Operacje niemodyfikujące (442)
  
  • 8.3.1. Operacje dotyczące rozmiaru (442)
  • 8.3.2. Operacje porównania (443)
  • 8.3.3. Operacje niemodyfikujące kontenerów asocjacyjnych i nieuporządkowanych (444)
• 8.4. Operacje przypisania (446)
• 8.5. Bezpośredni dostęp do elementów (448)
• 8.6. Operacje generujące iteratory (450)
• 8.7. Wstawianie i usuwanie elementów (452)
  
  • 8.7.1. Wstawianie pojedynczych elementów (452)
  • 8.7.2. Wstawianie wielu elementów (457)
  • 8.7.3. Usuwanie elementów (459)
  • 8.7.4. Zmiana rozmiaru (462)
• 8.8. Specjalne funkcje składowe list (462)
  
  • 8.8.1. Specjalne funkcje składowe list i list forward_list (462)
  • 8.8.2. Specjalne funkcje składowe list forward_list (466)
• 8.9. Interfejsy strategii obsługi kontenerów (470)
  
  • 8.9.1. Niemodyfikujące funkcje strategii (470)
  • 8.9.2. Modyfikujące funkcje strategii (471)
  • 8.9.3. Interfejs dostępu do kubełków kontenerów nieuporządkowanych (473)
• 8.10. Obsługa alokatorów (474)
  
  • 8.10.1. Podstawowe składowe alokatorów (474)
  • 8.10.2. Konstruktory z opcjonalnymi parametrami alokatorów (474)

9. Iteratory STL (479)

• 9.1. Pliki nagłówkowe iteratorów (479)
• 9.2. Kategorie iteratorów (479)
  
  • 9.2.1. Iteratory wyjściowe (480)
  • 9.2.2. Iteratory wejściowe (481)
  • 9.2.3. Iteratory postępujące (483)
  • 9.2.4. Iteratory dwukierunkowe (484)
  • 9.2.5. Iteratory dostępu swobodnego (484)
  • 9.2.6. Problem z inkrementacją i dekrementacją iteratorów wektorów (487)
• 9.3. Pomocnicze funkcje iteratorów (488)
  
  • 9.3.1. Funkcja advance() (488)
  • 9.3.2. Funkcje next() i prev() (490)
  • 9.3.3. Funkcja distance() (492)
  • 9.3.4. Funkcja iter_swap() (493)
• 9.4. Adaptatory iteratorów (494)
  
  • 9.4.1. Iteratory odwrotne (495)
  • 9.4.2. Iteratory wstawiające (499)
  • 9.4.3. Iteratory strumieni (506)
  • 9.4.4. Iteratory przenoszące (511)
• 9.5. Cechy typowe iteratorów (512)
  
  • 9.5.1. Definiowanie uogólnionych funkcji dla iteratorów (514)
• 9.6. Iteratory definiowane przez użytkownika (516)

10. Obiekty funkcyjne STL i lambdy (521)

• 10.1. Pojęcie obiektów funkcyjnych (521)
  
  • 10.1.1. Obiekty funkcyjne jako kryteria sortowania (522)
  • 10.1.2. Obiekty funkcyjne ze stanem wewnętrznym (524)
  • 10.1.3. Wartość zwracana algorytmu for_each() (527)
  • 10.1.4. Predykaty a obiekty funkcyjne (529)
• 10.2. Predefiniowane obiekty funkcyjne i obiekty wiązania wywołania (531)
  
  • 10.2.1. Predefiniowane obiekty funkcyjne (531)
  • 10.2.2. Adaptatory i obiekty wiązania wywołania (532)
  • 10.2.3. Obiekty funkcyjne definiowane przez użytkownika dla adaptatorów funkcji (541)
  • 10.2.4. Zarzucone adaptatory funkcji (542)
• 10.3. Lambdy (544)
  
  • 10.3.1. Lambdy a wiązanie wywołania (544)
  • 10.3.2. Lambdy a stanowe obiekty funkcyjne (545)
  • 10.3.3. Lambdy z wywołaniami funkcji globalnych i składowych (547)
  • 10.3.4. Lambdy jako funkcje mieszające, sortujące i kryteria równoważności (549)

11. Algorytmy STL (551)

• 11.1. Pliki nagłówkowe algorytmów (551)
• 11.2. Przegląd algorytmów (552)
  
  • 11.2.1. Krótkie wprowadzenie (552)
  • 11.2.2. Klasyfikacja algorytmów (553)
• 11.3. Funkcje pomocnicze (564)
• 11.4. Algorytm for_each() (566)
• 11.5. Algorytmy niemodyfikujące (570)
  
  • 11.5.1. Zliczanie elementów (570)
  • 11.5.2. Wartość minimalna i maksymalna (572)
  • 11.5.3. Wyszukiwanie elementów (574)
  • 11.5.4. Porównywanie zakresów (586)
  • 11.5.5. Predykaty zakresowe (593)
• 11.6. Algorytmy modyfikujące (599)
  
  • 11.6.1. Kopiowanie elementów (600)
  • 11.6.2. Przenoszenie elementów między zakresami (603)
  • 11.6.3. Przekształcenia i kombinacje elementów (605)
  • 11.6.4. Wymienianie elementów (608)
  • 11.6.5. Przypisywanie nowych wartości (610)
  • 11.6.6. Zastępowanie elementów (613)
• 11.7. Algorytmy usuwające (615)
  
  • 11.7.1. Usuwanie określonych wartości (616)
  • 11.7.2. Usuwanie powtórzeń (619)
• 11.8. Algorytmy mutujące (623)
  
  • 11.8.1. Odwracanie kolejności elementów (623)
  • 11.8.2. Przesunięcia cykliczne elementów (624)
  • 11.8.3. Permutacje elementów (627)
  • 11.8.4. Tasowanie elementów (629)
  • 11.8.5. Przenoszenie elementów na początek (631)
  • 11.8.6. Podział na dwa podzakresy (633)
• 11.9. Algorytmy sortujące (634)
  
  • 11.9.1. Sortowanie wszystkich elementów (635)
  • 11.9.2. Sortowanie częściowe (637)
  • 11.9.3. Sortowanie według n-tego elementu (640)
  • 11.9.4. Algorytmy stogowe (642)
• 11.10. Algorytmy przeznaczone dla zakresów posortowanych (645)
  
  • 11.10.1. Wyszukiwanie elementów (646)
  • 11.10.2. Scalanie elementów (651)
• 11.11. Algorytmy numeryczne (659)
  
  • 11.11.1. Obliczanie wartości (660)
  • 11.11.2. Konwersje wartości względnych i bezwzględnych (663)

12. Kontenery specjalne (667)

• 12.1. Stosy (668)
  
  • 12.1.1. Interfejs (669)
  • 12.1.2. Przykład użycia stosów (669)
  • 12.1.3. Własna klasa stosu (670)
  • 12.1.4. Klasa stack<> w szczegółach (673)
• 12.2. Kolejki (673)
  
  • 12.2.1. Interfejs (675)
  • 12.2.2. Przykład użycia kolejek (675)
  • 12.2.3. Własna klasa kolejki (676)
  • 12.2.4. Klasa queue<> w szczegółach (676)
• 12.3. Kolejki priorytetowe (676)
  
  • 12.3.1. Interfejs (678)
  • 12.3.2. Przykład użycia kolejek priorytetowych (678)
  • 12.3.3. Klasa priority_queue<> w szczegółach (679)
• 12.4. Adaptatory kontenerów w szczegółach (680)
  
  • 12.4.1. Definicje typów (680)
  • 12.4.2. Konstruktory (681)
  • 12.4.3. Konstruktory pomocnicze dla kolejki priorytetowej (681)
  • 12.4.4. Operacje (682)
• 12.5. Kontener bitset (684)
  
  • 12.5.1. Przykłady użycia kontenerów bitset (686)
  • 12.5.2. Klasa bitset w szczegółach (688)

13. Łańcuchy znakowe (689)

• 13.1. Przeznaczenie klas łańcuchów znakowych (690)
  
  • 13.1.1. Przykład pierwszy: konstruowanie tymczasowej nazwy pliku (691)
  • 13.1.2. Przykład drugi: wyodrębnianie słów i wypisywanie ich w odwrotnej kolejności (695)
• 13.2. Opis klas reprezentujących łańcuchy znakowe (699)
  
  • 13.2.1. Typy łańcuchów znakowych (699)
  • 13.2.2. Przegląd funkcji składowych (700)
  • 13.2.3. Konstruktory oraz destruktory (704)
  • 13.2.4. Łańcuchy znakowe zwykłe oraz języka C (705)
  • 13.2.5. Rozmiar oraz pojemność (707)
  • 13.2.6. Dostęp do elementów (708)
  • 13.2.7. Porównania (710)
  • 13.2.8. Modyfikatory (711)
  • 13.2.9. Konkatenacja łańcuchów znakowych oraz ich fragmentów (714)
  • 13.2.10. Operatory wejścia-wyjścia (715)
  • 13.2.11. Poszukiwanie oraz odnajdywanie łańcuchów znakowych (716)
  • 13.2.12. Wartość npos (719)
  • 13.2.13. Konwersje liczbowe (720)
  • 13.2.14. Obsługa iteratorów łańcuchów znakowych (722)
  • 13.2.15. Obsługa standardów narodowych (728)
  • 13.2.16. Wydajność (730)
  • 13.2.17. Łańcuchy znakowe a wektory (730)
• 13.3. Klasa string w szczegółach (731)
  
  • 13.3.1. Definicje typu oraz wartości statyczne (731)
  • 13.3.2. Funkcje składowe służące do tworzenia, kopiowania oraz usuwania łańcuchów znakowych (732)
  • 13.3.3. Funkcje dotyczące rozmiaru oraz pojemności (734)
  • 13.3.4. Porównania (735)
  • 13.3.5. Dostęp do znaków (737)
  • 13.3.6. Tworzenie łańcuchów znakowych języka C oraz tablic znaków (739)
  • 13.3.7. Funkcje do modyfikacji zawartości łańcuchów znakowych (739)
  • 13.3.8. Wyszukiwanie (748)
  • 13.3.9. Łączenie łańcuchów znakowych (752)
  • 13.3.10. Funkcje wejścia-wyjścia (753)
  • 13.3.11. Konwersje liczbowe (754)
  • 13.3.12. Funkcje tworzące iteratory (755)
  • 13.3.13. Obsługa alokatorów (756)

14. Wyrażenia regularne (759)

• 14.1. Interfejs dopasowywania i wyszukiwania wyrażeń regularnych (759)
• 14.2. Obsługa podwyrażeń (762)
• 14.3. Iteratory dopasowań (768)
• 14.4. Iteratory podciągów (769)
• 14.5. Zastępowanie wyrażeń regularnych (771)
• 14.6. Flagi wyrażeń regularnych (773)
• 14.7. Wyjątki związane z wyrażeniami regularnymi (777)
• 14.8. Gramatyka wyrażeń regularnych ECMAScript (779)
• 14.9. Inne gramatyki (781)
• 14.10. Sygnatury podstawowych funkcji (782)

15. Obsługa wejścia-wyjścia z wykorzystaniem klas strumieniowych (785)

• 15.1. Podstawy strumieni wejścia-wyjścia (786)
  
  • 15.1.1. Obiekty strumieni (786)
  • 15.1.2. Klasy strumieni (787)
  • 15.1.3. Globalne obiekty strumieni (787)
  • 15.1.4. Operatory strumieniowe (788)
  • 15.1.5. Manipulatory (788)
  • 15.1.6. Prosty przykład (789)
• 15.2. Podstawowe obiekty oraz klasy strumieniowe (790)
  
  • 15.2.1. Klasy oraz hierarchia klas (790)
  • 15.2.2. Globalne obiekty strumieni (794)
  • 15.2.3. Pliki nagłówkowe (795)
• 15.3. Standardowe operatory strumieniowe << oraz >> (796)
  
  • 15.3.1. Operator wyjściowy << (796)
  • 15.3.2. Operator wejściowy >> (798)
  • 15.3.3. Operacje wejścia-wyjścia dla specjalnych typów (799)
• 15.4. Stany strumieni (802)
  
  • 15.4.1. Stałe służące do określania stanów strumieni (802)
  • 15.4.2. Funkcje składowe operujące na stanie strumieni (803)
  • 15.4.3. Warunki wykorzystujące stan strumienia oraz wartości logiczne (805)
  • 15.4.4. Stan strumienia i wyjątki (808)
• 15.5. Standardowe funkcje wejścia-wyjścia (812)
  
  • 15.5.1. Funkcje składowe służące do pobierania danych (813)
  • 15.5.2. Funkcje składowe służące do wysyłania danych (817)
  • 15.5.3. Przykład użycia (818)
  • 15.5.4. Obiekty sentry (819)
• 15.6. Manipulatory (820)
  
  • 15.6.1. Przegląd dostępnych manipulatorów (820)
  • 15.6.2. Sposób działania manipulatorów (822)
  • 15.6.3. Manipulatory definiowane przez użytkownika (824)
• 15.7. Formatowanie (825)
  
  • 15.7.1. Znaczniki formatu (825)
  • 15.7.2. Format wartości logicznych (827)
  • 15.7.3. Szerokość pola, znak wypełnienia oraz wyrównanie (828)
  • 15.7.4. Znak wartości dodatnich oraz duże litery (831)
  • 15.7.5. Podstawa numeryczna (832)
  • 15.7.6. Notacja zapisu liczb zmiennoprzecinkowych (834)
  • 15.7.7. Ogólne definicje formatujące (836)
• 15.8. Umiędzynarodawianie (837)
• 15.9. Dostęp do plików (838)
  
  • 15.9.1. Klasy strumieni plikowych (838)
  • 15.9.2. Semantyka r-wartości i przeniesienia dla strumieni plikowych (842)
  • 15.9.3. Znaczniki pliku (843)
  • 15.9.4. Dostęp swobodny (847)
  • 15.9.5. Deskryptory plików (849)
• 15.10. Klasy strumieni dla łańcuchów znakowych (850)
  
  • 15.10.1. Klasy strumieni dla łańcuchów znakowych (851)
  • 15.10.2. Semantyka przeniesienia dla strumieni z łańcuchów znakowych (854)
  • 15.10.3. Klasy strumieni dla wartości typu char* (855)
• 15.11. Operatory wejścia-wyjścia dla typów zdefiniowanych przez użytkownika (858)
  
  • 15.11.1. Implementacja operatorów wyjściowych (858)
  • 15.11.2. Implementacja operatorów wejściowych (860)
  • 15.11.3. Operacje wejścia-wyjścia przy użyciu funkcji pomocniczych (862)
  • 15.11.4. Znaczniki formatu definiowane przez użytkownika (863)
  • 15.11.5. Konwencje operatorów wejścia-wyjścia definiowanych przez użytkownika (866)
• 15.12. Łączenie strumieni wejściowych oraz wyjściowych (867)
  
  • 15.12.1. Luźne powiązanie przy użyciu tie() (867)
  • 15.12.2. Ścisłe powiązanie przy użyciu buforów strumieni (869)
  • 15.12.3. Przekierowywanie strumieni standardowych (871)
  • 15.12.4. Strumienie służące do odczytu oraz zapisu (872)
• 15.13. Klasy bufora strumienia (874)
  
  • 15.13.1. Interfejsy buforów strumieni (875)
  • 15.13.2. Iteratory wykorzystywane z buforem strumienia (877)
  • 15.13.3. Bufory strumienia definiowane przez użytkownika (881)
• 15.14. Kwestie wydajności (893)
  
  • 15.14.1. Synchronizacja ze standardowymi strumieniami języka C (893)
  • 15.14.2. Buforowanie w buforach strumieni (894)
  • 15.14.3. Bezpośrednie wykorzystanie buforów strumieni (895)

16. Umiędzynarodowienie (899)

• 16.1. Kodowanie znaków i zestawy znaków (901)
  
  • 16.1.1. Znaki wielobajtowe i znaki szerokiego zakresu (901)
  • 16.1.2. Różne zestawy znaków (902)
  • 16.1.3. Obsługa zestawów znaków w C++ (903)
  • 16.1.4. Cechy znaków (904)
  • 16.1.5. Umiędzynarodawianie specjalnych znaków (908)
• 16.2. Pojęcie obiektów ustawień lokalnych (909)
  
  • 16.2.1. Wykorzystywanie ustawień lokalnych (911)
  • 16.2.2. Aspekty ustawień lokalnych (917)
• 16.3. Klasa locale w szczegółach (919)
• 16.4. Klasa facet w szczegółach (922)
  
  • 16.4.1. Formatowanie wartości liczbowych (923)
  • 16.4.2. Formatowanie wartości pieniężnych (928)
  • 16.4.3. Formatowanie czasu oraz daty (938)
  • 16.4.4. Klasyfikacja oraz konwersja znaków (945)
  • 16.4.5. Sortowanie łańcuchów znakowych (959)
  • 16.4.6. Lokalizacja komunikatów (960)

17. Komponenty numeryczne (963)

• 17.1. Liczby i rozkłady losowe (963)
  
  • 17.1.1. Pierwszy przykład (964)
  • 17.1.2. Mechanizmy losowości (969)
  • 17.1.3. Mechanizmy losowości w szczegółach (972)
  • 17.1.4. Rozkłady (973)
  • 17.1.5. Dystrybucje w szczegółach (977)
• 17.2. Liczby zespolone (981)
  
  • 17.2.1. complex<> w ujęciu ogólnym (981)
  • 17.2.2. Przykład wykorzystania klasy reprezentującej liczby zespolone (982)
  • 17.2.3. Funkcje operujące na liczbach zespolonych (984)
  • 17.2.4. Klasa complex<> w szczegółach (992)
• 17.3. Globalne funkcje numeryczne (997)
• 17.4. Klasa valarray (999)

18. Współbieżność (1001)

• 18.1. Interfejs wysokiego poziomu: async() i futury (1003)
  
  • 18.1.1. Pierwszy przykład użycia funkcji async() i futur (1003)
  • 18.1.2. Przykład oczekiwania na dwa zadania (1013)
  • 18.1.3. Współdzielone futury (1017)
• 18.2. Interfejs niskiego poziomu: wątki i promesy (1021)
  
  • 18.2.1. Klasa std::thread (1021)
  • 18.2.2. Promesy (1027)
  • 18.2.3. Klasa packaged_task<> (1029)
• 18.3. Uruchamianie wątku w szczegółach (1030)
  
  • 18.3.1. Funkcja async() w szczegółach (1031)
  • 18.3.2. Futury w szczegółach (1033)
  • 18.3.3. Futury współdzielone w szczegółach (1034)
  • 18.3.4. Klasa std::promise w szczegółach (1035)
  • 18.3.5. Klasa std::packaged_task w szczegółach (1036)
  • 18.3.6. Klasa std::thread w szczegółach (1038)
  • 18.3.7. Przestrzeń nazw this_thread (1039)
• 18.4. Synchronizacja wątków, czyli największy problem współbieżności (1040)
  
  • 18.4.1. Uwaga na współbieżność! (1041)
  • 18.4.2. Przyczyna problemu jednoczesnego dostępu do danych (1042)
  • 18.4.3. Zakres problemu, czyli co może pójść źle? (1043)
  • 18.4.4. Mechanizmy pozwalające na rozwiązanie problemów (1047)
• 18.5. Muteksy i blokady (1049)
  
  • 18.5.1. Wykorzystywanie muteksów i blokad (1049)
  • 18.5.2. Muteksy i blokady w szczegółach (1058)
  • 18.5.3. Wywoływanie funkcjonalności raz dla wielu wątków (1062)
• 18.6. Zmienne warunkowe (1063)
  
  • 18.6.1. Przeznaczenie zmiennych warunkowych (1064)
  • 18.6.2. Pierwszy kompletny przykład wykorzystania zmiennych warunkowych (1065)
  • 18.6.3. Wykorzystanie zmiennych warunkowych do zaimplementowania kolejki dla wielu wątków (1067)
  • 18.6.4. Zmienne warunkowe w szczegółach (1070)
• 18.7. Atomowe typy danych (1072)
  
  • 18.7.1. Przykład użycia atomowych typów danych (1073)
  • 18.7.2. Atomowe typy danych i ich interfejs wysokiego poziomu w szczegółach (1077)
  • 18.7.3. Interfejs atomowych typów danych w stylu języka C (1080)
  • 18.7.4. Niskopoziomowy interfejs atomowych typów danych (1081)

19. Alokatory (1085)

• 19.1. Wykorzystywanie alokatorów przez programistów aplikacji (1085)
• 19.2. Alokator definiowany przez użytkownika (1086)
• 19.3. Wykorzystywanie alokatorów przez programistów bibliotek (1088)

Bibliografia (1093)

• Grupy i fora dyskusyjne (1093)
• Książki i strony WWW (1094)

Skorowidz (1099)