C++. Biblioteka standardowa. Podręcznik programisty, C++. Biblioteka IOStreams i lokalizacja programów
(ebook)
(audiobook)
(audiobook)
- Autorzy:
- Nicolai M. Josuttis, Angelika Langer, Klaus Kreft
Niedostępna
- Ocena:
- Bądź pierwszym, który oceni tę książkę
- Stron:
- 1336
- Druk:
- oprawa miękka
Opis ebooka: C++. Biblioteka standardowa. Podręcznik programisty, C++. Biblioteka IOStreams i lokalizacja programów
>> Możesz kupić osobno:
C++. Biblioteka standardowa. Podręcznik programisty
C++. Biblioteka IOStreams i lokalizacja programów
C++. Biblioteka standardowa. Podręcznik programisty
C++. Biblioteka IOStreams i lokalizacja programów
Biblioteki są nieodzownym elementem każdego programisty zajmującego się programowaniem w C++. Warto więc dokładnie poznać ich działanie i możliwość wykorzystania w swoich projektach programistycznych.
Książka C++. Biblioteka standardowa. Podręcznik programisty zawiera:
- Krótkie wprowadzenie do C++ i biblioteki standardowej
- Standardowa biblioteka wzorców
- Kontenery STL
- Obiekty funkcyjne STL
- Algorytmy STL
- Kontenery specjalne: stosy, kolejki, klasa bitset
- Łańcuchy
- Kontenery numeryczne
- Operacje wejścia-wyjścia z wykorzystaniem klas strumieniowych
- Funkcje służące umiędzynarodowieniu aplikacji
- Alokatory
Książka ta dostarcza wyczerpującej dokumentacji każdego z komponentów biblioteki, jak również przystępnych wyjaśnień złożonych zagadnień; prezentuje praktyczne szczegóły programowania, niezbędne do skutecznego zastosowania omawianej biblioteki w praktyce.
Podręcznik opisuje aktualną wersję biblioteki standardowej C++, w tym jej najnowsze elementy dołączone do pełnego standardu języka ANSI/ISO C++. Opis skoncentrowany jest na standardowej bibliotece wzorców STL (ang. Standard Template Library), kontenerach, iteratorach, obiektach funkcyjnych oraz algorytmach STL. W książce tej znajdziesz również szczegółowy opis kontenerów specjalnych, łańcuchów znakowych, klas numerycznych, zagadnienia lokalizacji programów oraz omówienie biblioteki IOStream. Każdy z komponentów został dokładnie przedstawiony wraz z opisem jego przeznaczenia oraz założeń projektowych, przykładami, czyhającymi pułapkami, jak również definicją udostępnianych przez niego klas oraz funkcji.
Książka C++. Biblioteka IOStreams i lokalizacja programów zawiera:
- Formatowanie wejścia i wyjścia
- Operacje na strumieniach plikowych
- Synchronizowanie strumieni
- Architektura biblioteki IOStreams
- Internacjonalizacja i lokalizacja programów
- Szkielet lokalizacji
- Definiowanie własnych aspektów lokalizacji
Książka zawiera ona opis oraz dokumentację programistyczną klas biblioteki IOStreams i lokalizacji, a także prezentuje sposoby ich wykorzystywania i zaawansowane metody rozszerzania i dostosowywania do własnych potrzeb. Przedstawia zagadnienia związane z tworzeniem wersji językowych aplikacji i dostosowywania ich do lokalnych konwencji językowo-kulturowych.
Ebooka "C++. Biblioteka standardowa. Podręcznik programisty, C++. Biblioteka IOStreams i lokalizacja programów" 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, C++. Biblioteka IOStreams i lokalizacja programów" 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, C++. Biblioteka IOStreams i lokalizacja programów" 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 Referencee, Standard C++ IOStremas and Locales
- Tłumaczenie:
- Przemysław Steć, Rafał Szpoton, Przemysław Szeremiota
- ISBN Książki drukowanej:
- ZZ-ZZZ-ZZZZ-Z, ZZZZZZZZZZ
- Data wydania książki drukowanej:
- 2005-01-01
- Format:
- B5
- 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? (17)
- 1.2. Co należy wiedzieć przed przystąpieniem do lektury tej książki? (18)
- 1.3. Styl i struktura książki (18)
- 1.4. Jak czytać tę książkę? (21)
- 1.5. Stan obecny (21)
- 1.6. Przykładowy kod i dodatkowe informacje (22)
- 2.1. Historia (23)
- 2.2. Nowe możliwości języka (25)
- 2.2.1. Wzorce (25)
- 2.2.2. Jawna inicjalizacja typów podstawowych (30)
- 2.2.3. Obsługa wyjątków (30)
- 2.2.4. Przestrzenie nazw (32)
- 2.2.5. Typ bool (33)
- 2.2.6. Słowo kluczowe explicit (34)
- 2.2.7. Nowe operatory konwersji typu (35)
- 2.2.8. Inicjalizacja stałych składowych statycznych (36)
- 2.2.9. Definicja funkcji main() (36)
- 2.3. Złożoność algorytmów a notacja O (37)
- 3.1. Przestrzeń nazw std (39)
- 3.2. Pliki nagłówkowe (40)
- 3.3. Obsługa błędów i wyjątków (42)
- 3.3.1. Standardowe klasy wyjątków (42)
- 3.3.2. Składowe klas wyjątków (45)
- 3.3.3. Zgłaszanie wyjątków standardowych (46)
- 3.3.4. Tworzenie klas pochodnych standardowych klas wyjątków (46)
- 3.4. Alokatory (48)
- 4.1. Pary (49)
- 4.1.1. Wygodna funkcja make_pair() (51)
- 4.1.2. Przykłady użycia par (53)
- 4.2. Klasa auto_ptr (53)
- 4.2.1. Motywacja klasy auto_ptr (53)
- 4.2.2. Przenoszenie własności w przypadku klasy auto_ptr (55)
- 4.2.3. Wskaźniki auto_ptr jako składowe (59)
- 4.2.4. Niewłaściwe użycie wskaźników auto_ptr (61)
- 4.2.5. Przykłady zastosowania typu auto_ptr (62)
- 4.2.6. Klasa auto_ptr w szczegółach (64)
- 4.3. Ograniczenia liczbowe (71)
- 4.4. Funkcje pomocnicze (77)
- 4.4.1. Obliczanie wartości minimalnej oraz maksymalnej (77)
- 4.4.2. Zamiana dwóch wartości (78)
- 4.5. Dodatkowe operatory porównania (79)
- 4.6. Pliki nagłówkowe <cstddef> oraz <cstdlib> (81)
- 4.6.1. Definicje w pliku <cstddef> (81)
- 4.6.2. Definicje w pliku <cstdlib> (82)
- 5.1. Składniki biblioteki STL (83)
- 5.2. Kontenery (85)
- 5.2.1. Kontenery sekwencyjne (86)
- 5.2.2. Kontenery asocjacyjne (91)
- 5.2.3. Adaptatory kontenerów (92)
- 5.3. Iteratory (93)
- 5.3.1. Przykłady użycia kontenerów asocjacyjnych (96)
- 5.3.2. Kategorie iteratorów (102)
- 5.4. Algorytmy (103)
- 5.4.1. Zakresy (105)
- 5.4.2. Obsługa wielu zakresów (110)
- 5.5. Adaptatory iteratorów (112)
- 5.5.1. Iteratory wstawiające (112)
- 5.5.2. Iteratory strumieniowe (114)
- 5.5.3. Iteratory odwrotne (116)
- 5.6. Algorytmy modyfikujące (118)
- 5.6.1. Usuwanie elementów (118)
- 5.6.2. Algorytmy modyfikujące a kontenery asocjacyjne (121)
- 5.6.3. Algorytmy a funkcje składowe (123)
- 5.7. Funkcje ogólne definiowane przez użytkownika (124)
- 5.8. Funkcje jako argumenty algorytmów (125)
- 5.8.1. Przykłady użycia funkcji jako argumentów algorytmów (125)
- 5.8.2. Predykaty (126)
- 5.9. Obiekty funkcyjne (129)
- 5.9.1. Czym są obiekty funkcyjne? (129)
- 5.9.2. Predefiniowane obiekty funkcyjne (135)
- 5.10. Elementy kontenerów (138)
- 5.10.1. Wymagania wobec elementów kontenerów (138)
- 5.10.2. Semantyka wartości a semantyka referencji (139)
- 5.11. Obsługa błędów i wyjątków wewnątrz biblioteki STL (140)
- 5.11.1. Obsługa błędów (141)
- 5.11.2. Obsługa wyjątków (143)
- 5.12. Rozbudowa biblioteki STL (145)
- 6.1. Wspólne cechy i operacje kontenerów (148)
- 6.1.1. Wspólne cechy kontenerów (148)
- 6.1.2. Wspólne operacje kontenerów (148)
- 6.2. Wektory (151)
- 6.2.1. Możliwości wektorów (152)
- 6.2.2. Operacje na wektorach (154)
- 6.2.3. Używanie wektorów jako zwykłych tablic (158)
- 6.2.4. Obsługa wyjątków (159)
- 6.2.5. Przykłady użycia wektorów (160)
- 6.2.6. Klasa vector<bool> (161)
- 6.3. Kolejki o dwóch końcach (163)
- 6.3.1. Możliwości kolejek deque (164)
- 6.3.2. Operacje na kolejkach deque (165)
- 6.3.3. Obsługa wyjątków (166)
- 6.3.4. Przykłady użycia kolejek deque (167)
- 6.4. Listy (168)
- 6.4.1. Możliwości list (169)
- 6.4.2. Operacje na listach (170)
- 6.4.3. Obsługa wyjątków (174)
- 6.4.4. Przykłady użycia list (175)
- 6.5. Zbiory i wielozbiory (176)
- 6.5.1. Możliwości zbiorów i wielozbiorów (178)
- 6.5.2. Operacje na zbiorach i wielozbiorach (179)
- 6.5.3. Obsługa wyjątków (187)
- 6.5.4. Przykłady użycia zbiorów i wielozbiorów (187)
- 6.5.5. Przykład określania kryterium sortowania podczas wykonywania (191)
- 6.6. Mapy oraz multimapy (193)
- 6.6.1. Możliwości map oraz multimap (194)
- 6.6.2. Operacje na mapach oraz multimapach (195)
- 6.6.3. Zastosowanie map jako tablic asocjacyjnych (204)
- 6.6.4. Obsługa wyjątków (206)
- 6.6.5. Przykłady użycia map i multimap (206)
- 6.6.6. Przykład z mapami, łańcuchami oraz definiowaniem kryterium sortowania podczas wykonywania (210)
- 6.7. Inne kontenery STL (212)
- 6.7.1. Łańcuchy jako kontenery STL (213)
- 6.7.2. Zwykłe tablice jako kontenery STL (214)
- 6.7.3. Tablice mieszające (216)
- 6.8. Implementacja semantyki referencji (217)
- 6.9. Kiedy stosować poszczególne kontenery (220)
- 6.10. Typy kontenerowe i ich składowe w szczegółach (223)
- 6.10.1. Definicje typów (224)
- 6.10.2. Operacje tworzenia, kopiowania i niszczenia (225)
- 6.10.3. Operacje niemodyfikujące (227)
- 6.10.4. Operacje przypisania (230)
- 6.10.5. Bezpośredni dostęp do elementów (231)
- 6.10.6. Operacje generujące iteratory (233)
- 6.10.7. Wstawianie i usuwanie elementów (234)
- 6.10.8. Specjalne funkcje składowe list (239)
- 6.10.9. Obsługa alokatorów (241)
- 6.10.10. Omówienie obsługi wyjątków w kontenerach STL (242)
- 7.1. Pliki nagłówkowe iteratorów (245)
- 7.2. Kategorie iteratorów (245)
- 7.2.1. Iteratory wejściowe (246)
- 7.2.2. Iteratory wyjściowe (247)
- 7.2.3. Iteratory postępujące (248)
- 7.2.4. Iteratory dwukierunkowe (249)
- 7.2.5. Iteratory dostępu swobodnego (249)
- 7.2.6. Problem z inkrementacją i dekrementacją iteratorów wektorów (252)
- 7.3. Pomocnicze funkcje iteratorów (253)
- 7.3.1. Przesuwanie iteratorów za pomocą funkcji advance() (253)
- 7.3.2. Obliczanie odległości pomiędzy iteratorami za pomocą funkcji distance() (254)
- 7.3.3. Zamiana wartości iteratorów za pomocą funkcji iter_swap() (256)
- 7.4. Adaptatory iteratorów (257)
- 7.4.1. Iteratory odwrotne (257)
- 7.4.2. Iteratory wstawiające (262)
- 7.4.3. Iteratory strumieniowe (268)
- 7.5. Cechy iteratorów (273)
- 7.5.1. Definiowanie funkcji ogólnych dla iteratorów (275)
- 7.5.2. Iteratory definiowane przez użytkownika (277)
- 8.1. Pojęcie obiektów funkcyjnych (281)
- 8.1.1. Obiekty funkcyjne jako kryteria sortowania (282)
- 8.1.2. Obiekty funkcyjne ze stanem wewnętrznym (283)
- 8.1.3. Wartość zwracana algorytmu for_each() (287)
- 8.1.4. Predykaty a obiekty funkcyjne (288)
- 8.2. Predefiniowane obiekty funkcyjne (291)
- 8.2.1. Adaptatory funkcji (291)
- 8.2.2. Adaptatory funkcji składowych (293)
- 8.2.3. Adaptatory zwykłych funkcji (295)
- 8.2.4. Obiekty funkcyjne definiowane przez użytkownika dostosowane do adaptatorów funkcji (296)
- 8.3. Dodatkowe złożeniowe obiekty funkcyjne (298)
- 8.3.1. Jednoargumentowe złożeniowe adaptatory obiektów funkcyjnych (299)
- 8.3.2. Dwuargumentowe złożeniowe adaptatory obiektów funkcyjnych (302)
- 9.1. Pliki nagłówkowe algorytmów (305)
- 9.2. Przegląd algorytmów (306)
- 9.2.1. Krótkie wprowadzenie (306)
- 9.2.2. Klasyfikacja algorytmów (307)
- 9.3. Funkcje pomocnicze (316)
- 9.4. Algorytm for_each() (318)
- 9.5. Algorytmy niemodyfikujące (320)
- 9.5.1. Zliczanie elementów (321)
- 9.5.2. Wartość minimalna i maksymalna (322)
- 9.5.3. Wyszukiwanie elementów (324)
- 9.5.4. Porównywanie zakresów (335)
- 9.6. Algorytmy modyfikujące (340)
- 9.6.1. Kopiowanie elementów (341)
- 9.6.2. Przekształcenia i kombinacje elementów (344)
- 9.6.3. Wymienianie elementów (347)
- 9.6.4. Przypisywanie nowych wartości (348)
- 9.6.5. Zastępowanie elementów (350)
- 9.7. Algorytmy usuwające (353)
- 9.7.1. Usuwanie określonych wartości (353)
- 9.7.2. Usuwanie powtórzeń (356)
- 9.8. Algorytmy mutujące (360)
- 9.8.1. Odwracanie kolejności elementów (360)
- 9.8.2. Przesunięcia cykliczne elementów (361)
- 9.8.3. Permutacje elementów (363)
- 9.8.4. Tasowanie elementów (365)
- 9.8.5. Przenoszenie elementów na początek (367)
- 9.9. Algorytmy sortujące (368)
- 9.9.1. Sortowanie wszystkich elementów (369)
- 9.9.2. Sortowanie częściowe (371)
- 9.9.3. Sortowanie według n-tego elementu (374)
- 9.9.4. Algorytmy stogowe (375)
- 9.10. Algorytmy przeznaczone dla zakresów posortowanych (378)
- 9.10.1. Wyszukiwanie elementów (379)
- 9.10.2. Scalanie elementów (385)
- 9.11. Algorytmy numeryczne (393)
- 9.11.1. Obliczanie wartości (393)
- 9.11.2. Konwersje wartości względnych i bezwzględnych (397)
- 10.1. Stosy (401)
- 10.1.1. Interfejs (403)
- 10.1.2. Przykład użycia stosów (403)
- 10.1.3. Klasa stack<> w szczegółach (404)
- 10.1.4. Klasa stosu definiowanego przez użytkownika (406)
- 10.2. Kolejki (408)
- 10.2.1. Interfejs (410)
- 10.2.2. Przykład użycia kolejek (410)
- 10.2.3. Klasa queue<> w szczegółach (411)
- 10.2.4. Klasa kolejki definiowanej przez użytkownika (413)
- 10.3. Kolejki priorytetowe (416)
- 10.3.1. Interfejs (417)
- 10.3.2. Przykład użycia kolejek priorytetowych (418)
- 10.3.3. Klasa priority_queue<> w szczegółach (418)
- 10.4. Kontener bitset (421)
- 10.4.1. Przykłady użycia kontenerów bitset (422)
- 10.4.2. Szczegółowy opis klasy bitset (424)
- 11.1. Motywacja (431)
- 11.1.1. Przykład pierwszy: Pobieranie tymczasowej nazwy pliku (432)
- 11.1.2. Przykład drugi: Pobieranie słów i wypisywanie ich w odwrotnej kolejności (437)
- 11.2. Opis klas reprezentujących łańcuchy znakowe (440)
- 11.2.1. Typy łańcuchów znakowych (440)
- 11.2.2. Przegląd funkcji składowych (441)
- 11.2.3. Konstruktory oraz destruktory (443)
- 11.2.4. Łańcuchy znakowe zwykłe oraz języka C (444)
- 11.2.5. Rozmiar oraz pojemność (446)
- 11.2.6. Dostęp do elementów (448)
- 11.2.7. Porównania (449)
- 11.2.8. Modyfikatory (450)
- 11.2.9. Konkatenacja łańcuchów znakowych oraz ich fragmentów (453)
- 11.2.10. Operatory wejścia-wyjścia (454)
- 11.2.11. Poszukiwanie oraz odnajdywanie łańcuchów znakowych (455)
- 11.2.12. Wartość npos (457)
- 11.2.13. Obsługa iteratorów w przypadku łańcuchów znakowych (458)
- 11.2.14. Obsługa standardów narodowych (464)
- 11.2.15. Wydajność (466)
- 11.2.16. Łańcuchy znakowe a wektory (466)
- 11.3. Klasa string w szczegółach (467)
- 11.3.1. Definicje typu oraz wartości statyczne (467)
- 11.3.2. Funkcje składowe służące do tworzenia, kopiowania oraz usuwania łańcuchów znakowych (469)
- 11.3.3. Funkcje dotyczące rozmiaru oraz pojemności (470)
- 11.3.4. Porównania (471)
- 11.3.5. Dostęp do znaków (473)
- 11.3.6. Tworzenie łańcuchów znakowych języka C oraz tablic znaków (474)
- 11.3.7. Funkcje do modyfikacji zawartości łańcuchów znakowych (475)
- 11.3.8. Poszukiwanie oraz odnajdywanie (482)
- 11.3.9. Łączenie łańcuchów znakowych (485)
- 11.3.10. Funkcje wejścia-wyjścia (486)
- 11.3.11. Funkcje tworzące iteratory (487)
- 11.3.12. Obsługa alokatorów (488)
- 12.1. Liczby zespolone (491)
- 12.1.1. Przykład wykorzystania klasy reprezentującej liczby zespolone (492)
- 12.1.2. Funkcje operujące na liczbach zespolonych (494)
- 12.1.3. Klasa complex<> w szczegółach (501)
- 12.2. Klasa valarray (506)
- 12.2.1. Poznawanie klas valarray (507)
- 12.2.2. Podzbiory wartości umieszczonych w tablicy valarray (512)
- 12.2.3. Klasa valarray w szczegółach (525)
- 12.2.4. Klasy podzbiorów tablic typu valarray w szczegółach (530)
- 12.3. Globalne funkcje numeryczne (535)
- 13.1. Podstawy strumieni wejścia-wyjścia (538)
- 13.1.1. Obiekty strumieni (538)
- 13.1.2. Klasy strumieni (539)
- 13.1.3. Globalne obiekty strumieni (539)
- 13.1.4. Operatory strumieniowe (540)
- 13.1.5. Manipulatory (540)
- 13.1.6. Prosty przykład (541)
- 13.2. Podstawowe obiekty oraz klasy strumieniowe (542)
- 13.2.1. Klasy oraz hierarchia klas (542)
- 13.2.2. Globalne obiekty strumieni (545)
- 13.2.3. Pliki nagłówkowe (546)
- 13.3. Standardowe operatory strumieniowe << oraz >> (547)
- 13.3.1. Operator wyjściowy << (547)
- 13.3.2. Operator wejściowy >> (549)
- 13.3.3. Operacje wejścia-wyjścia dla specjalnych typów (549)
- 13.4. Stany strumieni (552)
- 13.4.1. Stałe służące do określania stanów strumieni (552)
- 13.4.2. Funkcje składowe operujące na stanie strumieni (553)
- 13.4.3. Warunki wykorzystujące stan strumienia oraz wartości logiczne (555)
- 13.4.4. Stan strumienia i wyjątki (557)
- 13.5. Standardowe funkcje wejścia-wyjścia (561)
- 13.5.1. Funkcje składowe służące do pobierania danych (562)
- 13.5.2. Funkcje składowe służące do wysyłania danych (565)
- 13.5.3. Przykład użycia (566)
- 13.6. Manipulatory (567)
- 13.6.1. Sposób działania manipulatorów (568)
- 13.6.2. Manipulatory definiowane przez użytkownika (569)
- 13.7. Formatowanie (570)
- 13.7.1. Znaczniki formatu (570)
- 13.7.2. Format wartości logicznych (572)
- 13.7.3. Szerokość pola znak wypełnienia oraz wyrównanie (573)
- 13.7.4. Znak wartości dodatnich oraz duże litery (576)
- 13.7.5. Podstawa numeryczna (576)
- 13.7.6. Notacja zapisu liczb zmiennoprzecinkowych (579)
- 13.7.7. Ogólne definicje formatujące (581)
- 13.8. Umiędzynarodawianie (582)
- 13.9. Dostęp do plików (583)
- 13.9.1. Znaczniki pliku (586)
- 13.9.2. Dostęp swobodny (589)
- 13.9.3. Deskryptory plików (592)
- 13.10. Łączenie strumieni wejściowych oraz wyjściowych (592)
- 13.10.1 Luźne powiązanie przy użyciu tie() (593)
- 13.10.2. Ścisłe powiązanie przy użyciu buforów strumieni (594)
- 13.10.3. Przekierowywanie strumieni standardowych (596)
- 13.10.4. Strumienie służące do odczytu oraz zapisu (597)
- 13.11. Klasy strumieni dla łańcuchów znakowych (599)
- 13.11.1. Klasy strumieni dla łańcuchów znakowych (600)
- 13.11.2. Klasy strumieni dla wartości typu char* (603)
- 13.12. Operatory wejścia-wyjścia dla typów zdefiniowanych przez użytkownika (605)
- 13.12.1. Implementacja operatorów wyjściowych (605)
- 13.12.2. Implementacja operatorów wejściowych (607)
- 13.12.3. Operacje wejścia-wyjścia przy użyciu funkcji pomocniczych (609)
- 13.12.4. Operatory definiowane przez użytkownika używające funkcji nieformatujących (610)
- 13.12.5. Znaczniki formatu definiowane przez użytkownika (612)
- 13.12.6. Konwencje operatorów wejścia-wyjscia definiowanych przez użytkownika (615)
- 13.13. Klasy bufora strumienia (616)
- 13.13.1. Spojrzenie użytkownika na bufory strumieni (616)
- 13.13.2. Iteratory wykorzystywane z buforem strumienia (618)
- 13.13.3. Bufory strumienia definiowane przez użytkownika (621)
- 13.14. Kwestie wydajności (632)
- 13.14.1. Synchronizacja ze standardowymi strumieniami używanymi w języku C (633)
- 13.14.2. Buforowanie w buforach strumieni (633)
- 13.14.3. Bezpośrednie wykorzystanie buforów strumieni (634)
- 14.1. Różne standardy kodowania znaków (638)
- 14.1.1. Reprezentacja za pomocą zestawu znaków szerokiego zakresu lub reprezentacja wielobajtowa (639)
- 14.1.2. Cechy znaków (640)
- 14.1.3. Umiędzynarodawianie specjalnych znaków (643)
- 14.2. Pojęcie obiektów ustawień lokalnych (644)
- 14.2.1. Wykorzystywanie ustawień lokalnych (646)
- 14.2.2. Aspekty ustawień lokalnych (650)
- 14.3. Klasa locale w szczegółach (653)
- 14.4. Klasa facet w szczegółach (656)
- 14.4.1. Formatowanie wartości numerycznych (657)
- 14.4.2. Formatowanie czasu oraz daty (661)
- 14.4.3. Formatowanie wartości walutowych (664)
- 14.4.4. Klasyfikacja oraz konwersja znaków (669)
- 14.4.5. Sortowanie łańcuchów znakowych (677)
- 14.4.6. Lokalizacja komunikatów (679)
- 15.1. Wykorzystywanie alokatorów przez programistów aplikacji (681)
- 15.2. Wykorzystywanie alokatorów przez programistów bibliotek (682)
- 15.3. Alokator domyślny (685)
- 15.4. Alokator zdefiniowany przez użytkownika (687)
- 15.5. Alokatory w szczegółach (689)
- 15.5.1. Definicje typu (689)
- 15.5.2. Funkcje składowe (691)
- 15.6. Funkcje stosowane w przypadku niezainicjalizowanej pamięci (692)
- 1.1. Wejście i wyjście (25)
- 1.2. Formatowanie wejścia i wyjścia (33)
- 1.2.1. Strumienie globalne biblioteki IOStreams (33)
- 1.2.2. Operatory wejścia i wyjścia (34)
- 1.2.3. Parametry formatowania strumienia (37)
- 1.2.4. Manipulatory (43)
- 1.2.5. Lokalizacja strumienia (47)
- 1.2.6. Formatowanie wejścia i wyjścia - porównanie (48)
- 1.2.7. Jeszcze o formatowaniu wejścia (49)
- 1.3. Stan strumienia (51)
- 1.3.1. Znaczniki stanu strumienia (52)
- 1.3.2. Kontrola stanu strumienia (54)
- 1.3.3. Przechwytywanie wyjątków strumieni (56)
- 1.3.4. Zerowanie stanu strumienia (58)
- 1.4. Operacje wejścia-wyjścia na strumieniach plikowych (59)
- 1.4.1. Tworzenie, otwieranie, zamykanie i usuwanie strumieni plikowych (60)
- 1.4.2. Tryby otwierania strumieni plikowych (61)
- 1.4.3. Dwukierunkowe strumienie plikowe (65)
- 1.5. Operacje wejścia-wyjścia na strumieniach w pamięci (67)
- 1.6. Wejście i wyjście bez formatowania (69)
- 1.7. Pozycjonowanie w strumieniu (71)
- 1.8. Synchronizacja strumieni (73)
- 1.8.1. Środki synchronizacji (74)
- 1.8.1.1. Synchronizacja wywołaniami flush() i sync() (74)
- 1.8.1.2. Synchronizacja za pośrednictwem znacznika formatu unitbuf (75)
- 1.8.1.3. Synchronizacja przez wiązanie strumieni (75)
- 1.8.2. Synchronizacja predefiniowanych strumieni standardowych (76)
- 1.8.2.1. Synchronizacja pomiędzy predefiniowanymi strumieniami standardowymi (77)
- 1.8.2.2. Synchronizacja predefiniowanego strumienia z jego analogiem w postaci standardowego pliku wejścia-wyjścia języka C (77)
- 1.8.2.3. Synchronizacja predefiniowanego strumienia standardowego ze skojarzonym z nim urządzeniem zewnętrznym (78)
- 1.8.2.4. Synchronizacja pomiędzy strumieniami znaków zwykłych i poszerzonych (78)
- 2.1. Klasy strumieni (80)
- 2.1.1. Hierarchia klas (81)
- 2.1.1.1. Bazowe klasy strumieni (81)
- 2.1.1.2. Ogólne klasy strumieni (84)
- 2.1.1.3. Konkretne klasy strumieni (85)
- 2.1.2. Zarządzanie buforem strumienia (86)
- 2.1.3. Kopiowanie i przypisania obiektów strumieni (89)
- 2.1.4. Zarządzanie lokalizacjami strumieni (92)
- 2.1.5. Współpraca obiektów strumieni, buforów strumieni i lokalizacji (96)
- 2.2. Klasy buforów strumieni (100)
- 2.2.1. Hierarchia klas (101)
- 2.2.2. Abstrakcja bufora strumienia (102)
- 2.2.3. Bufory strumieni ciągów znaków (107)
- 2.2.4. Bufory strumieni plikowych (113)
- 2.3. Typy i cechy znakowe (122)
- 2.3.1. Reprezentacje znaków (122)
- 2.3.2. Cechy znakowe (127)
- 2.3.2.1. Wymagania odnośnie typu cechy znakowej (127)
- 2.3.2.2 Predefiniowane standardowe typy cech znakowych (131)
- 2.3.3. Typy znakowe (132)
- 2.3.3.1. Wymagania dla typów znakowych (132)
- 2.4. Iteratory strumieni i buforów strumieni (135)
- 2.4.1. Koncepcja iteratorów w bibliotece standardowej (136)
- 2.4.2. Iteratory strumieni (138)
- 2.4.2.1. Iterator strumienia wyjściowego (139)
- 2.4.2.2. Iterator strumienia wejściowego (140)
- 2.4.2.3. Iteratory strumieni a jednoprzebiegowość (144)
- 2.4.3. Iteratory buforów strumieni (146)
- 2.4.3.1. Iterator bufora strumienia wyjściowego (146)
- 2.4.3.2. Iterator bufora strumienia wejściowego (147)
- 2.5. Dodatkowa pamięć obiektu strumienia i wywołania zwrotne (150)
- 2.5.1. Dodatkowa pamięć obiektu strumienia (151)
- 2.5.2. Wywołania zwrotne strumieni (153)
- 3.1. Wejście i wyjście dla typów definiowanych przez użytkownika (155)
- 3.1.1. Sygnatury inserterów i ekstraktorów (156)
- 3.1.2. Pierwsze własne insertery i ekstraktory (156)
- 3.1.3. Udoskonalenia (159)
- 3.1.3.1. Sterowanie formatowaniem (160)
- 3.1.3.2. Operacje wstępne i likwidacyjne (161)
- 3.1.3.3. Sygnalizowanie błędów (162)
- 3.1.3.4. Umiędzynarodowienie (163)
- 3.1.3.5. Operacje wejścia-wyjścia (165)
- 3.1.4. Udoskonalone wersje insertera i ekstraktora daty (165)
- 3.1.4.1. Umiędzynarodawianie daty (165)
- 3.1.4.2. Czynności wstępne i likwidacyjne (167)
- 3.1.4.3. Sterowanie formatowaniem (168)
- 3.1.4.4. Sygnalizacja błędów (169)
- 3.1.4.5. Zastosowanie udoskonalonego insertera i ekstraktora (176)
- 3.1.5. Ogólne wersje insertera i ekstraktora (177)
- 3.1.6. Wersja prosta a udoskonalona (182)
- 3.2. Manipulatory definiowane przez użytkownika (184)
- 3.2.1. Manipulatory bezparametrowe (185)
- 3.2.2. Manipulatory sparametryzowane (187)
- 3.2.2.1. Proste implementacje manipulatorów z parametrami (187)
- 3.2.2.2. Wersja uogólniona - szablon klasy bazowej manipulatora (188)
- 3.2.2.3. Warianty implementacji manipulatora (192)
- 3.2.2.4. Udoskonalenia (194)
- 3.2.2.5. Typ bazowy manipulatorów standardowych - smanip (198)
- 3.3. Rozszerzanie funkcji strumienia (199)
- 3.3.1. Własne zastosowania dodatkowej pamięci strumienia - iword, pword i xalloc (199)
- 3.3.1.1. Inicjalizacja i utrzymywanie indeksu pary iword-pword (202)
- 3.3.1.2. Implementacja insertera dat (202)
- 3.3.1.3. Implementacja manipulatora (204)
- 3.3.1.4. Zarządzanie pamięcią za pośrednictwem wywołań zwrotnych strumieni (206)
- 3.3.1.5. Sygnalizowanie błędów funkcji wywołań zwrotnych (211)
- 3.3.1.6. Stosowanie nowych funkcji (213)
- 3.3.1.7. Ocena metody wykorzystującej pola iword-pword (213)
- 3.3.2. Wyprowadzanie nowych klas strumieni (215)
- 3.3.2.1. Wyprowadzanie nowej klasy strumienia (216)
- 3.3.2.2. Implementacja insertera i manipulatora (223)
- 3.3.2.3. Podsumowanie (226)
- 3.3.3. Porównanie techniki iword-pword i rozbudowy hierarchii klas (227)
- 3.4. Rozszerzanie funkcji bufora strumienia (229)
- 3.4.1. Wyprowadzanie z klasy bazowej bufora strumienia (230)
- 3.4.1.1. Rdzenne funkcje buforów strumieni - transport znaków (230)
- 3.4.1.2. Opcjonalne funkcje buforów strumieni (246)
- 3.4.1.3. Udostępnianie nowych klas strumieni z nowymi klasami buforów strumieni (248)
- 3.4.2. Wyprowadzanie pochodnych konkretnych klas buforów strumieni (248)
- 4.1. Internacjonalizacja a lokalizacja (253)
- 4.2. Konwencje kulturowe (254)
- 4.2.1. Język (255)
- 4.2.2. Wartości liczbowe (255)
- 4.2.3. Wartości pieniężne (255)
- 4.2.4. Godziny i daty (256)
- 4.2.5. Porządek alfabetyczny (257)
- 4.2.6. Komunikaty (258)
- 4.2.7. Kodowanie znaków (258)
- 4.2.7.1. Pojęcia i definicje (258)
- 4.2.7.2. Zestawy znaków (259)
- 4.2.7.3. Metody kodowania znaków (260)
- 4.2.7.4. Zastosowania metod kodowania wielobajtowego i znaków poszerzonych (263)
- 4.2.7.5. Konwersje kodowania (264)
- 5.1. Tworzenie obiektów lokalizacji (269)
- 5.1.1. Nazwane obiekty lokalizacji (269)
- 5.1.2. Lokalizacje kombinowane (270)
- 5.1.3. Lokalizacja globalna (272)
- 5.2. Pobieranie aspektów z lokalizacji (273)
- 5.2.1. Funkcja has_facet (273)
- 5.2.2. Funkcja use_facet (274)
- 6.1. Aspekty językowe i alfabetyczne (278)
- 6.1.1. Klasyfikacja znaków (278)
- 6.1.1.1. Klasyfikacja znaków (278)
- 6.1.1.2. Konwersja znaków liter małych i wielkich (279)
- 6.1.1.3. Konwersja znaków pomiędzy typami charT i char (280)
- 6.1.1.4. Właściwości specjalne aspektu ctype<char> (281)
- 6.1.2. Porządkowanie ciągów (281)
- 6.1.3. Konwersja kodowania (283)
- 6.1.4. Katalogi komunikatów (287)
- 6.2. Aspekty formatowania i analizy leksykalnej (287)
- 6.2.1. Wartości liczbowe i logiczne (288)
- 6.2.1.1. Aspekt numpunct (288)
- 6.2.1.2. Aspekt num_put (289)
- 6.2.1.3. Aspekt num_get (290)
- 6.2.2. Wartości pieniężne (291)
- 6.2.2.1. Aspekt moneypunct (292)
- 6.2.2.2. Aspekt money_put (293)
- 6.2.2.3. Aspekt money_get (294)
- 6.2.3. Wartości daty i czasu (296)
- 6.2.3.1. Aspekt time_put (297)
- 6.2.3.2. Aspekt time_get (298)
- 6.3. Grupowanie aspektów standardowych w obiektach lokalizacji (300)
- 6.3.1. Rodziny aspektów standardowych (300)
- 6.3.1.1. Szablony klas bazowych aspektów standardowych (300)
- 6.3.1.2. Aspekty byname (301)
- 6.3.1.3. Zachowanie klasy bazowej aspektów (302)
- 6.3.1.4. Obowiązkowe typy aspektów (303)
- 6.3.2. Kategorie lokalizacji (305)
- 6.3.3. Diagram kategorii aspektów (305)
- 6.4. Zaawansowane zastosowania aspektów standardowych (307)
- 6.4.1. Użycie aspektu za pośrednictwem obiektu strumienia (307)
- 6.4.2. Użycie aspektu za pośrednictwem obiektu lokalizacji (308)
- 6.4.3. Użycie aspektu wprost, niezależnie od obiektu lokalizacji (310)
- 7.1. Hierarchia klas (313)
- 7.2. Identyfikacja i wyszukiwanie aspektów w lokalizacjach (313)
- 7.2.1. Identyfikacja aspektów (314)
- 7.2.2. Wyszukiwanie aspektów (317)
- 7.2.2.1. Pobieranie aspektu z obiektu lokalizacji (317)
- 7.2.2.2. Umieszczanie aspektów w obiekcie lokalizacji (321)
- 7.2.2.3. Uzasadnienie dla zastosowania polimorfizmu dwufazowego (321)
- 7.3. Zarządzanie pamięcią aspektów w obiektach lokalizacji (322)
- 7.3.1. Licznik odwołań aspektu (322)
- 7.3.2. Niezmienność aspektów w obiekcie lokalizacji (327)
- 8.1. Dodawanie własnego aspektu do istniejącej rodziny aspektów (329)
- 8.2. Definiowanie nowej rodziny aspektów (333)
- Lokalizacja (350)
- Plik nagłówkowy <locale> (350)
- Funkcje globalne (352)
- codecvt<internT, externT, stateT> (354)
- codecvt_base (359)
- codecvt_byname<internT, externT, stateT> (360)
- collate<charT> (362)
- collate_byname<charT> (364)
- ctype<charT> (366)
- ctype<char> (370)
- ctype_base (373)
- ctype_byname<charT> (374)
- locale (376)
- messages<charT> (381)
- messages_base (383)
- messages_byname<charT> (384)
- money_base (386)
- money_get<charT, InputIterator> (387)
- moneypunct<charT, Inter> (390)
- moneypunct_byname<charT, Inter> (394)
- money_put<charT, OutputIterator> (396)
- num_get<charT, InputIterator> (398)
- numpunct<charT> (403)
- numpunct_byname<charT> (406)
- num_put<charT, OutputIterator> (408)
- time_base (412)
- time_get<charT, InputIterator> (413)
- time_get_byname<charT, InputIterator> (417)
- time_put<charT, OutputIterator> (418)
- time_put_byname<charT, OutputIterator> (421)
- tm (423)
- Cechy znakowe (425)
- Plik nagłówkowy <string> (425)
- char_traits<charT> (427)
- char_traits<char> (428)
- char_traits<wchar_t> (431)
- IOStreams (434)
- Plik nagłówkowy <iosfwd> (434)
- Plik nagłówkowy <iostream> (437)
- Plik nagłówkowy <ios> (438)
- Plik nagłówkowy <streambuf> (440)
- Plik nagłówkowy <istream> (441)
- Plik nagłówkowy <ostream> (442)
- Plik nagłówkowy <iomanip> (443)
- Plik nagłówkowy <sstream> (444)
- Plik nagłówkowy <fstream> (445)
- Globalne definicje typów (446)
- Obiekty globalne (447)
- basic_filebuf<charT, traits> (449)
- basic_fstream<charT, traits> (453)
- basic_ifstream<charT, traits> (455)
- basic_ios<charT, traits> (457)
- basic_iostream<charT, traits> (461)
- basic_istream<charT, traits> (462)
- basic_istringstream<charT, traits, Allocator> (471)
- basic_ostream<charT, traits> (473)
- basic_ostream<charT, traits> (475)
- basic_ostringstream<charT, traits, Allocator> (483)
- basic_streamgbuf<charT, traits> (485)
- basic_stringbuf<charT, traits, Allocator> (492)
- basic_stringstream<charT, traits, Allocator> (495)
- fpos<stateT> (497)
- ios_base (498)
- Manipulatory (508)
- Iteratory strumieni (509)
- Plik nagłówkowy <iterator> (509)
- istreambuf_iterator<charT, traits> (511)
- istream_iterator<T, charT, traits, Distance> (515)
- iterator<Category, T, Distance, Pointer, Reference> (518)
- Znaczniki kategorii iteratorów (519)
- ostreambuf_iterator<charT, traits> (520)
- ostream_iterator<T, charT, traits, Distance> (522)
- Inne operacje wejścia-wyjścia (524)
- bitset<N> (524)
- complex<T> (525)
- basic_string<charT, traits, Allocator> (526)
- B.1. Analiza leksykalna wartości liczbowych (530)
- B.2. Analiza leksykalna wartości logicznych (531)
- B.3. Specyfikatory konwersji i modyfikatory długości (532)
- C.1. Formatowanie wartości liczbowych (535)
- C.2. Formatowanie wartości logicznych (538)
- C.3. Specyfikatory formatowania, kwalifikatory i modyfikatory długości (538)
- E.1. Tryby otwierania plików (543)
- E.2. Pozycjonowanie w strumieniu (544)
- F.1. Parametryzacja klas IOStreams (546)
- F.2. Podział klasy bazowej ios (547)
- F.3. Sygnalizowanie błędów (548)
- F.4. Umiędzynarodowienie biblioteki IOStreams (549)
- F.5. Brak klas _withassign (549)
- F.6. Brak deskryptorów plików (550)
- F.7. Strumienie ciągów znaków - stringstream zamiast strstream (551)
- F.8. Zmiany w klasach buforów strumieni (551)
- F.9. Zmiany pomniejsze (554)
- G.1. Kategorie lokalizacji w C i C++ (555)
- G.2. Globalne obiekty lokalizacji w C i C++ (555)
- H.1. Typy masek bitowych (559)
- H.2. POD (560)
- H.3. Konstruktory jawne (560)
- H.4. Specjalizacje szablonu (562)
- H.5. Domyślne argumenty szablonów (568)
- H.6. Jawna specyfikacja argumentu szablonu (571)
- H.7. Słowo typename (572)
- H.8. Rzutowanie dynamiczne (575)
- H.9. Funkcyjne bloki try (579)
- H.10. Wyjątki standardowe (582)
- H.11. Ograniczenia zakresów liczbowych (583)
- H.12. Ciągi języka C++ (583)
C++. Biblioteka standardowa. Podręcznik programisty
Podziękowania (13)
Przedmowa (15)
1 O książce (17)
2 Wprowadzenie do języka C++ i biblioteki standardowej (23)
3 Pojęcia ogólne (39)
4 Narzędzia (49)
5 Standardowa biblioteka wzorców (STL) (83)
6 Kontenery STL (147)
7 Iteratory STL (245)
8 Obiekty funkcyjne STL (281)
9 Algorytmy STL (305)
10 Kontenery specjalne (401)
11 Łańcuchy (431)
12 Kontenery numeryczne (491)
13 Obsługa wejścia-wyjścia z wykorzystaniem klas strumieniowych (537)
14 Umiędzynarodowienie (637)
15 Alokatory (681)
A Bibliografia (695)
B Skorowidz (697)
C++. Biblioteka IOStreams i lokalizacja programów
Słowo wstępne (11)
Wstęp (13)
Wskazówki dla Czytelników (17)
Część I Strumieniowe wejście-wyjście (23)
Rozdział 1. Podstawy biblioteki IOStreams (25)
Rozdział 2. Architektura biblioteki IOStreams (79)
Rozdział 3. Zaawansowane zastosowania biblioteki IOStreams (155)
Część II Internacjonalizacja (251)
Rozdział 4. Wprowadzenie do internacjonalizacji i lokalizacji (253)
Rozdział 5. Lokalizacja (267)
Rozdział 6. Aspekty standardowe (277)
Rozdział 7. Architektura szkieletu lokalizacji (313)
Rozdział 8. Aspekty definiowane przez użytkownika (329)
Dodatki (345)
Dodatek A Podręcznik programisty (347)
Dodatek B Analiza leksykalna i wyodrębnianie wartości liczbowych i logicznych (529)
Dodatek C Formatowanie wartości liczbowych i logicznych (535)
Dodatek D Specyfikatory formatu funkcji strftime() (541)
Dodatek E Podobieństwa elementów biblioteki IOStreams do biblioteki języka C (543)
Dodatek F IOStreams - różnice pomiędzy implementacją klasyczną a standardową (545)
Dodatek G Powiązania mechanizmów lokalizacji w C i C++ (555)
Dodatek H Nowe elementy i idiomy języka C++ (559)
Bibliografia (585)
Skorowidz (587)
Oceny i opinie klientów: C++. Biblioteka standardowa. Podręcznik programisty, C++. Biblioteka IOStreams i lokalizacja programów Nicolai M. Josuttis, Angelika Langer, Klaus Kreft (0)
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.