Деталі електронної книги

C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II

C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II

Nicolai M. Josuttis

Eлектронна книга

Lektura obowiązkowa dla każdego programisty C++!

Pomimo olbrzymiej konkurencji ze strony platformy .NET oraz języka Java język C++ wciąż jest niezastąpiony w wielu dziedzinach. Wszędzie tam, gdzie wymagane są najwyższa wydajność, pełna kontrola nad sprzętem oraz przewidywalność, C++ jest bezkonkurencyjny. Biblioteka standardowa C++ to zestaw klas i interfejsów, które w znaczny sposób zwiększają możliwości tego języka. Warto wykorzystać jej potencjał!

Biblioteka standardowa C++ poza wieloma niewątpliwymi zaletami ma jedną poważną wadę - jest trudna do opanowania. Właśnie dlatego potrzebny Ci jest ten podręcznik! W trakcie lektury poznasz nowe elementy języka C++ w wersji 11. Następnie dowiesz się, czym jest standardowa biblioteka szablonów (STL), oraz zobaczysz, jak wykorzystać w codziennej pracy: mapy, multimapy, iteratory, listy oraz wiele innych elementów. Na sam koniec nauczysz się poprawnie korzystać ze współbieżności oraz tworzyć aplikacje obsługujące różne wersje językowe. Każdy z komponentów biblioteki został dokładnie przedstawiony: z opisem przeznaczenia, przykładami oraz problemami, których może przysporzyć. Książka ta jest obowiązkową lekturą każdego programisty C++!

Dzięki tej książce:

  • poznasz nowości języka C++ w wersji 11
  • wykorzystasz możliwości kontenerów STL
  • zrozumiesz zastosowanie iteratorów
  • zobaczysz na praktycznych przykładach, jak działają komponenty
  • błyskawicznie opanujesz możliwości biblioteki standardowej C++

Odkryj potęgę C++!

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)

  • Назва: C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II
  • Автор: Nicolai M. Josuttis
  • Оригінальна назва: The C++ Standard Library: A Tutorial and Reference (2nd Edition)
  • Переклад: Przemysław Szeremiota, Radosław Meryk, Rafał Jońca z wykorzystaniem fragmentów książki „C++. Biblioteka standardowa. Podręcznik programisty” w tłumaczeniu Przemysława Stecia i Rafała Szpotona
  • ISBN: 978-83-246-5579-3, 9788324655793
  • Дата видання: 2014-04-14
  • Формат: Eлектронна книга
  • Ідентифікатор видання: cpbsp2
  • Видавець: Helion