C++. Biblioteka standardowa. Podręcznik programisty

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 ,  oraz  (192)
5.8.1. Definicje w pliku  (193)
5.8.2. Definicje w pliku  (193)
5.8.3. Definicje w pliku  (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 (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)