C++. Biblioteka standardowa. Podręcznik programisty, C++. Biblioteka IOStreams i lokalizacja programów Nicolai M. Josuttis, Angelika Langer, Klaus Kreft

Spis treści książki

C++. Biblioteka standardowa. Podręcznik programisty


Podziękowania (13)


Przedmowa (15)


1 O książce (17)


• 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 Wprowadzenie do języka C++ i biblioteki standardowej (23)


• 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 Pojęcia ogólne (39)


• 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 Narzędzia (49)


• 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 Standardowa biblioteka wzorców (STL) (83)


• 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 Kontenery STL (147)


• 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 Iteratory STL (245)


• 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 Obiekty funkcyjne STL (281)


• 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 Algorytmy STL (305)


• 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 Kontenery specjalne (401)


• 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 Łańcuchy (431)


• 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 Kontenery numeryczne (491)


• 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 Obsługa wejścia-wyjścia z wykorzystaniem klas strumieniowych (537)


• 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 Umiędzynarodowienie (637)


• 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 Alokatory (681)


• 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)

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)


• 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)

Rozdział 2. Architektura biblioteki IOStreams (79)


• 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)

Rozdział 3. Zaawansowane zastosowania biblioteki IOStreams (155)


• 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)

Część II Internacjonalizacja (251)


Rozdział 4. Wprowadzenie do internacjonalizacji i lokalizacji (253)


• 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)

Rozdział 5. Lokalizacja (267)


• 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)

Rozdział 6. Aspekty standardowe (277)


• 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)

Rozdział 7. Architektura szkieletu lokalizacji (313)


• 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)

Rozdział 8. Aspekty definiowane przez użytkownika (329)


• 8.1. Dodawanie własnego aspektu do istniejącej rodziny aspektów (329)
  
• 8.2. Definiowanie nowej rodziny aspektów (333)

Dodatki (345)


Dodatek A Podręcznik programisty (347)


• 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)

Dodatek B Analiza leksykalna i wyodrębnianie wartości liczbowych i logicznych (529)


• 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)

Dodatek C Formatowanie wartości liczbowych i logicznych (535)


• 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)

Dodatek D Specyfikatory formatu funkcji strftime() (541)


Dodatek E Podobieństwa elementów biblioteki IOStreams do biblioteki języka C (543)


• E.1. Tryby otwierania plików (543)
  
• E.2. Pozycjonowanie w strumieniu (544)

Dodatek F IOStreams - różnice pomiędzy implementacją klasyczną a standardową (545)


• 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)

Dodatek G Powiązania mechanizmów lokalizacji w C i C++ (555)


• G.1. Kategorie lokalizacji w C i C++ (555)
  
• G.2. Globalne obiekty lokalizacji w C i C++ (555)

Dodatek H Nowe elementy i idiomy języka C++ (559)


• 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)

Bibliografia (585)


Skorowidz (587)

pokaż cały spis treści

ukryj recenzje