C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II
- Autor: :
- Nicolai M. Josuttis
- Wydawnictwo:
- Helion
- Wydawnictwo:
- Helion
- Ocena:
- 4.9/6 Opinie: 19
- Stron:
- 1120
- Druk:
- oprawa twarda
- Dostępne formaty:
-
PDFePubMobi
Opis ebooka: C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II
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++!
Biblioteka standardowa C++ to zestaw klas oraz interfejsów znacznie rozszerzających język C++. Nie jest ona jednak łatwa do przyswojenia. W celu pełnego wykorzystania udostępnianych przez nią komponentów oraz skorzystania z jej możliwości, konieczne jest odwołanie się do materiałów zawierających nieco więcej informacji niż tylko listę klas oraz zawartych w nich funkcji.
Drugie wydanie ksiażki C++. Biblioteka standardowa. Podręcznik programisty opisuje tę bibliotekę w wersji wcielonej do nowego standardu ANSI/ISO języka C++ (znanego jako C++11). Książka zawiera wyczerpującą dokumentację wszystkich okmponentów bibliotecznych, od omówienia wprowadzającego przez wyjaśnienie przeznaczenia danego komponentu, zarys implementacji, jasne wytłumaczenia najbardziej skomplikowanych aspektów komponentu, szczegóły przydatne programistom do efektywnej pracy, pułapki i typowe błędy stosowania, dokładne sygnatury najważniejszych klas i funkcji, po liczne przykłady użycia w działającym kodzie. Opis skoncentrowany jest na standardowej bibliotece szablonów STL (ang. Standard Template Library), z kontenerami, iteratorami, obiektami funkcyjnymi i algorytmami STL włącznie.
Książka opisuje wszystkie nowe elementy biblioteki języka C++11, w tym:
- Współbieżność
- Statyczną arytmetykę liczb wymiernych
- Zegary i czasomierze
- Krotki
- Nowe kontenery STL
- Nowe algorytmy STL
- Nowe typy inteligentnych wskaźników
- Nowe aspekty ustawień konwersji lokalnych
- Generatory i rozkłady liczb losowych
- Cechy typowe i narzędzia pracy z typami
- Wyrażenia regularne
W książce nie zabrakło również analizy nowych elementów języka C++ i ich wpływu na kształt biblioteki standardowej; omawiane są więc lambdy, pętle zakresowe for, semantyka przeniesienia i szablony o dowolnej liczbie argumentów.
Książce towarzyszy strona internetowa www.cppstdlib.com, z dodatkowymi materiałami i kodami źródłowymi programów przykładowych.
Nicolai M. Josuttis jest niezależnym konsultantem technicznym, projektującym systemy średniej i większej skali dla branży telekomunikacyjnej, transportowej, finansowej i wytwórczej. Jako były członek grupy roboczej opracowującej bibliotekę standardową w łonie Komitetu Standaryzującego C++, jest w społeczności programistów ceniony za autorytatywne publikacje. Poza światowym best-sellerem, w postaci pierwszego wydania niniejszej książki z roku 1999, napisał również (wspólnie z Davidem Vandevoorde) C++ Templates: The Complete Guide (Addison-Wesley, 2003) oraz SOA in Practice: The Art of Distributed System Design (O-Reilly Media, 2007).
Wybrane bestsellery
-
This book demonstrates service-oriented architecture (SOA) as a concrete discipline rather than a hopeful collection of cloud charts. Built upon the author's firsthand experience rolling out a SOA at a major corporation, SOA in Practice explains how SOA can simplify the creation and maintenance o...(78.18 zł najniższa cena z 30 dni)
78.08 zł
129.00 zł(-39%) -
Naglący termin, niedoczas, permanentne opóźnienie - oto najwierniejsi towarzysze i zarazem najwięksi wrogowie kierownika projektu. Nawet certyfikowani project managerowie, ludzie z ogromną wiedzą i nie mniejszym doświadczeniem, raz po raz znajdują się w sytuacji, w której potrzeba naprawdę wielki...(35.40 zł najniższa cena z 30 dni)
41.30 zł
59.00 zł(-30%)
Ebooka "C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II" przeczytasz na:
-
czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
-
systemach Windows, MacOS i innych
-
systemach Windows, Android, iOS, HarmonyOS
-
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi
Masz pytania? Zajrzyj do zakładki Pomoc »
Audiobooka "C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II" posłuchasz:
-
w aplikacji Ebookpoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych
-
na dowolnych urządzeniach i aplikacjach obsługujących format MP3 (pliki spakowane w ZIP)
Masz pytania? Zajrzyj do zakładki Pomoc »
Kurs Video "C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II" zobaczysz:
-
w aplikacjach Ebookpoint i Videopoint na Android, iOS, HarmonyOs
-
na systemach Windows, MacOS i innych z dostępem do najnowszej wersji Twojej przeglądarki internetowej
Szczegóły ebooka
- Tytuł oryginału:
- The C++ Standard Library: A Tutorial and Reference (2nd Edition)
- Tłumaczenie:
- 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 Książki drukowanej:
- 978-83-246-5576-2, 9788324655762
- Data wydania książki drukowanej:
- 2014-04-14
- ISBN Ebooka:
- 978-83-246-5579-3, 9788324655793
- Data wydania ebooka:
- 2014-04-14 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
- Format:
- 164x239
- Numer z katalogu:
- 18835
- Rozmiar pliku Pdf:
- 7.1MB
- Rozmiar pliku ePub:
- 4.5MB
- Rozmiar pliku Mobi:
- 14.3MB
- Przykłady na ftp
Ebook zawiera materiały dodatkowe, które możesz pobrać z serwera FTP - link znajdziesz na stronie redakcyjnej.
Spis treści ebooka
- 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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)
- Grupy i fora dyskusyjne (1093)
- Książki i strony WWW (1094)
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)
2. Wprowadzenie do języka C++ i biblioteki standardowej (31)
3. Nowe elementy języka (37)
4. Pojęcia ogólne (65)
5. Narzędzia (87)
6. Standardowa biblioteka szablonów (STL) (197)
7. Kontenery STL (289)
8. Składowe kontenerów STL (435)
9. Iteratory STL (479)
10. Obiekty funkcyjne STL i lambdy (521)
11. Algorytmy STL (551)
12. Kontenery specjalne (667)
13. Łańcuchy znakowe (689)
14. Wyrażenia regularne (759)
15. Obsługa wejścia-wyjścia z wykorzystaniem klas strumieniowych (785)
16. Umiędzynarodowienie (899)
17. Komponenty numeryczne (963)
18. Współbieżność (1001)
19. Alokatory (1085)
Bibliografia (1093)
Skorowidz (1099)
Oceny i opinie klientów: C++. Biblioteka standardowa. Podręcznik programisty. Wydanie II Nicolai M. Josuttis (19) Weryfikacja opinii następuję na podstawie historii zamówień na koncie Użytkownika umieszczającego opinię. Użytkownik mógł otrzymać punkty za opublikowanie opinii uprawniające do uzyskania rabatu w ramach Programu Punktowego.
(5)
(11)
(1)
(1)
(0)
(1)
Oceny i opinie poprzedniego wydania
więcej opinii