C Biblioteka standardowa Podrecznik programisty.pdf

(605 KB) Pobierz
IDZ DO
PRZYK£ADOWY ROZDZIA£
SPIS TRE CI
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
C++. Biblioteka
standardowa.
Podrêcznik programisty
Autor: Nicolai M. Josuttis
T³umaczenie: Przemys³aw Steæ (rozdz. 1 – 9),
Rafa³ Szpoton (rozdz. 10 – 15)
ISBN: 83-7361-144-4
Tytu³ orygina³u:
The C++ Standard Library:
A Tutorial and Referencee
Format: B5, stron: 726
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.
Ksi¹¿ka „C++. Biblioteka standardowa. Podrêcznik programisty” 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. Znajdziesz w niej równie¿ liczne przyk³ady dzia³aj¹cego kodu ród³owego.
Ksi¹¿ka „C++. Biblioteka standardowa. Podrêcznik programisty” 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.
Omówione w ksi¹¿ce zagadnienia to miêdzy innymi:
• 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
„C++. Biblioteka standardowa. Podrêcznik programisty” stanowi wyczerpuj¹c¹,
szczegó³ow¹, przystêpnie napisan¹ oraz praktyczn¹ ksi¹¿kê. Tworzy ona materia³
referencyjny C++, do którego bêdziesz stale powracaæ.
TWÓJ KOSZYK
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
O NOWO CIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Chopina 6
44-100 Gliwice
tel. (32)230-98-63
e-mail: helion@helion.pl
Spis treści
Podziękowania ....................................................................................................13
Przedmowa ..........................................................................................................15
1
O książce ..............................................................................................................17
1.1.
1.2.
1.3.
1.4.
1.5.
1.6.
Dlaczego powstała ta książka? ......................................................................................................... 17
Co należy wiedzieć przed przystąpieniem do lektury tej książki? ............................................ 18
Styl i struktura książki ....................................................................................................................... 18
Jak czytać tę książkę? ......................................................................................................................... 21
Stan obecny .......................................................................................................................................... 21
Przykładowy kod i dodatkowe informacje .................................................................................... 22
2
Wprowadzenie do języka C++ i biblioteki standardowej............................23
2.1.
2.2.
Historia ................................................................................................................................................. 23
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
Złożoność algorytmów a notacja O ................................................................................................. 37
2.3.
4
SPIS TREŚCI
3
Pojęcia ogólne ......................................................................................................39
3.1.
3.2.
3.3.
Przestrzeń nazw std ........................................................................................................................... 39
Pliki nagłówkowe ............................................................................................................................... 40
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
Alokatory ............................................................................................................................................. 48
3.4.
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
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
Ograniczenia liczbowe ....................................................................................................................... 71
Funkcje pomocnicze ........................................................................................................................... 77
4.4.1. Obliczanie wartości minimalnej oraz maksymalnej ....................................................... 77
4.4.2. Zamiana dwóch wartości .................................................................................................... 78
Dodatkowe operatory porównania.................................................................................................. 79
Pliki nagłówkowe <cstddef> oraz <cstdlib>.................................................................................. 81
4.6.1. Definicje w pliku <cstddef>................................................................................................ 81
4.6.2. Definicje w pliku <cstdlib>................................................................................................. 82
4.2.
4.3.
4.4.
4.5.
4.6.
5
Standardowa biblioteka wzorców (STL).........................................................83
5.1.
5.2.
Składniki biblioteki STL..................................................................................................................... 83
Kontenery............................................................................................................................................. 85
5.2.1. Kontenery sekwencyjne....................................................................................................... 86
5.2.2. Kontenery asocjacyjne ......................................................................................................... 91
5.2.3. Adaptatory kontenerów ...................................................................................................... 92
Iteratory ................................................................................................................................................ 93
5.3.1. Przykłady użycia kontenerów asocjacyjnych .................................................................. 96
5.3.2. Kategorie iteratorów .......................................................................................................... 102
Algorytmy .......................................................................................................................................... 103
5.4.1. Zakresy................................................................................................................................. 105
5.4.2. Obsługa wielu zakresów ................................................................................................... 110
5.3.
5.4.
SPIS TREŚCI
5
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
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
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
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
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.2.
6.3.
6.4.
6.5.
6
SPIS TREŚCI
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.
7.2.
Pliki nagłówkowe iteratorów.......................................................................................................... 245
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
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
Adaptatory iteratorów ..................................................................................................................... 257
7.4.1. Iteratory odwrotne ............................................................................................................. 257
7.4.2. Iteratory wstawiające ......................................................................................................... 262
7.4.3. Iteratory strumieniowe...................................................................................................... 268
Cechy iteratorów............................................................................................................................... 273
7.5.1. Definiowanie funkcji ogólnych dla iteratorów.............................................................. 275
7.5.2. Iteratory definiowane przez użytkownika..................................................................... 277
7.3.
7.4.
7.5.

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin