Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00665 008166 10499506 na godz. na dobę w sumie
C++. Biblioteka standardowa. Podręcznik programisty - książka
C++. Biblioteka standardowa. Podręcznik programisty - książka
Autor: Liczba stron: 728
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-144-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
>> Możesz kupić komplet w niższej cenie!

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: '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ć.

Nicolai M. Josuttis jest niezależnym konsultantem technicznym, projektującym oprogramowanie obiektowe dla firm telekomunikacyjnych, transportowych, instytucji finansowych oraz przemysłu. Jest on aktywnym członkiem Komitetu Standaryzującego C++, grupy roboczej opracowującej bibliotekę oraz partnerem w System Bauhaus, niemieckiej grupie zrzeszającej uznanych ekspertów w dziedzinie programowania obiektowego. Nicolai M. Josuttis jest autorem kilku książek dotyczących programowania obiektowego oraz C++.
Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl 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æ. Spis treści Podziękowania ...................................................n.................................................13 Przedmowa ...................................................n...................................................n....15 1 O książce ...................................................n...................................................n........17 1.1. Dlaczego powstała ta książka? ...................................................o...................................................... 17 1.2. Co należy wiedzieć przed przystąpieniem do lektury tej książki? ............................................ 18 Styl i struktura książki ...................................................o.................................................................... 18 1.3. Jak czytać tę książkę? ...................................................o...................................................................... 21 1.4. 1.5. Stan obecny...................................................o...................................................o......... ........................... 21 1.6. Przykładowy kod i dodatkowe informacje ...................................................o.................................22 2 Wprowadzenie do języka C++ i biblioteki standardowej............................23 2.1. Historia ...................................................o...................................................o............ ............................... 23 2.2. Nowe możliwości języka ...................................................o................................................................ 25 2.2.1. Wzorce...................................................o...................................................o............. ................. 25 2.2.2. Jawna inicjalizacja typów podstawowych...................................................o..................... 30 2.2.3. Obsługa wyjątków ...................................................o...................................................o... ...... 30 Przestrzenie nazw ...................................................o...................................................o.. 2.2.4. ........ 32 2.2.5. Typ bool ...................................................o...................................................o........... ................ 33 2.2.6. Słowo kluczowe explicit...................................................o................................................... 34 2.2.7. Nowe operatory konwersji typu...................................................o..................................... 35 2.2.8. Inicjalizacja stałych składowych statycznych ...................................................o............... 36 2.2.9. Definicja funkcji main() ...................................................o.................................................... 36 2.3. Złożoność algorytmów a notacja O ...................................................o.............................................. 37 4 3 SPIS TREŚCI Pojęcia ogólne ...................................................n...................................................n39 Przestrzeń nazw std ...................................................o...................................................o.. Pliki nagłówkowe ...................................................o...................................................o..... ................... 39 3.1. 3.2. .................... 40 3.3. Obsługa błędów i wyjątków ...................................................o.......................................................... 42 Standardowe klasy wyjątków ...................................................o......................................... 42 Składowe klas wyjątków...................................................o.................................................. 45 Zgłaszanie wyjątków standardowych ...................................................o........................... 46 Tworzenie klas pochodnych standardowych klas wyjątków ...................................... 46 ........................... 48 3.4. Alokatory ...................................................o...................................................o............ 3.3.1. 3.3.2. 3.3.3. 3.3.4. 4 Narzędzia ...................................................n...................................................n.......49 4.1. 4.2. Klasa auto_ptr ...................................................o...................................................o....... Pary ...................................................o...................................................o................. ................................ 49 4.1.1. Wygodna funkcja make_pair() ...................................................o............................................ 51 4.1.2. Przykłady użycia par ...................................................o............................................................ 53 ........................ 53 4.2.1. Motywacja klasy auto_ptr...................................................o................................................ 53 4.2.2. Przenoszenie własności w przypadku klasy auto_ptr ...................................................o 55 4.2.3. Wskaźniki auto_ptr jako składowe ...................................................o................................ 59 4.2.4. Niewłaściwe użycie wskaźników auto_ptr...................................................o................... 61 4.2.5. Przykłady zastosowania typu auto_ptr...................................................o......................... 62 4.2.6. Klasa auto_ptr w szczegółach ...................................................o......................................... 64 4.3. Ograniczenia liczbowe ...................................................o...................................................o................. 71 4.4. .................. 77 Funkcje pomocnicze ...................................................o...................................................o... 4.4.1. Obliczanie wartości minimalnej oraz maksymalnej ...................................................o.... 77 4.4.2. Zamiana dwóch wartości...................................................o................................................. 78 4.5. Dodatkowe operatory porównania...................................................o............................................... 79 Pliki nagłówkowe cstddef oraz cstdlib ...................................................o...............................81 4.6. 4.6.1. Definicje w pliku cstddef ...................................................o............................................. 81 4.6.2. Definicje w pliku cstdlib ...................................................o.............................................. 82 5 Standardowa biblioteka wzorców (STL)...................................................n......83 5.1. 5.2. Kontenery...................................................o...................................................o............ Składniki biblioteki STL...................................................o.................................................................. 83 ........................... 85 5.2.1. Kontenery sekwencyjne...................................................o.................................................... 86 5.2.2. Kontenery asocjacyjne ...................................................o...................................................... 91 5.2.3. Adaptatory kontenerów ...................................................o................................................... 92 Iteratory ...................................................o...................................................o............ .............................. 93 5.3.1. Przykłady użycia kontenerów asocjacyjnych ...................................................o............... 96 5.3.2. Kategorie iteratorów ...................................................o....................................................... 102 ........................ 103 5.4.1. ............... 105 5.4.2. Obsługa wielu zakresów...................................................o................................................110 5.4. Algorytmy...................................................o...................................................o............ Zakresy...................................................o...................................................o............ 5.3. SPIS TREŚCI 5 5.5.1. 5.5.2. 5.5.3. 5.7. 5.8. 5.5. Adaptatory iteratorów ...................................................o...................................................o............... 112 Iteratory wstawiające...................................................o...................................................... 112 Iteratory strumieniowe...................................................o................................................... 114 Iteratory odwrotne ...................................................o...................................................o. ...... 116 5.6. Algorytmy modyfikujące...................................................o.............................................................. 118 . 118 5.6.1. Usuwanie elementów ...................................................o...................................................o. 5.6.2. Algorytmy modyfikujące a kontenery asocjacyjne ...................................................o.... 121 5.6.3. Algorytmy a funkcje składowe ...................................................o..................................... 123 Funkcje ogólne definiowane przez użytkownika...................................................o..................... 124 Funkcje jako argumenty algorytmów...................................................o......................................... 125 5.8.1. Przykłady użycia funkcji jako argumentów algorytmów .......................................... 125 ............. 126 Predykaty...................................................o...................................................o.......... 5.8.2. .................... 129 5.9.1. Czym są obiekty funkcyjne?...................................................o.......................................... 129 5.9.2. Predefiniowane obiekty funkcyjne ...................................................o............................... 135 ............... 138 5.10.1. Wymagania wobec elementów kontenerów...................................................o............... 138 5.10.2. Semantyka wartości a semantyka referencji ...................................................o............... 139 5.11. Obsługa błędów i wyjątków wewnątrz biblioteki STL..................................................o............. 140 ........ 141 ..... 143 5.12. Rozbudowa biblioteki STL ...................................................o........................................................... 145 5.11.1. Obsługa błędów...................................................o...................................................o.... 5.11.2. Obsługa wyjątków ...................................................o...................................................o.. 5.10. Elementy kontenerów ...................................................o...................................................o. 5.9. Obiekty funkcyjne...................................................o...................................................o... 6 Kontenery STL...................................................n................................................147 6.2. Wektory ...................................................o...................................................o.............. 6.1. Wspólne cechy i operacje kontenerów ...................................................o....................................... 148 6.1.1. Wspólne cechy kontenerów...................................................o........................................... 148 6.1.2. Wspólne operacje kontenerów ...................................................o...................................... 148 .......................... 151 6.2.1. Możliwości wektorów ...................................................o...................................................o. 152 6.2.2. Operacje na wektorach ...................................................o................................................... 154 6.2.3. Używanie wektorów jako zwykłych tablic ...................................................o................. 158 6.2.4. Obsługa wyjątków ...................................................o...................................................o... .... 159 Przykłady użycia wektorów...................................................o.......................................... 160 6.2.5. 6.2.6. Klasa vector bool ...................................................o...................................................o. ..... 161 6.3. Kolejki o dwóch końcach...................................................o.............................................................. 163 6.3.1. Możliwości kolejek deque...................................................o..............................................164 6.3.2. Operacje na kolejkach deque...................................................o......................................... 165 6.3.3. Obsługa wyjątków ...................................................o...................................................o... .... 166 Przykłady użycia kolejek deque ...................................................o................................... 167 6.3.4. ............................... 168 Listy...................................................o...................................................o................ 6.4.1. Możliwości list ...................................................o...................................................o.... .......... 169 6.4.2. Operacje na listach ...................................................o...................................................o....... 170 6.4.3. Obsługa wyjątków ...................................................o...................................................o... .... 174 Przykłady użycia list...................................................o....................................................... 175 6.4.4. .................. 176 6.5.1. Możliwości zbiorów i wielozbiorów...................................................o............................ 178 6.5.2. Operacje na zbiorach i wielozbiorach ...................................................o.......................... 179 6.5.3. Obsługa wyjątków ...................................................o...................................................o... .... 187 6.5. Zbiory i wielozbiory...................................................o...................................................o. 6.4. 6 SPIS TREŚCI 6.5.4. 6.5.5. 6.6. Mapy oraz multimapy ...................................................o...................................................o.. Przykłady użycia zbiorów i wielozbiorów ...................................................o................. 187 Przykład określania kryterium sortowania podczas wykonywania.......................... 191 ............. 193 6.6.1. Możliwości map oraz multimap...................................................o................................... 194 6.6.2. Operacje na mapach oraz multimapach ...................................................o...................... 195 6.6.3. Zastosowanie map jako tablic asocjacyjnych...................................................o.............. 204 6.6.4. Obsługa wyjątków ...................................................o...................................................o... .... 206 Przykłady użycia map i multimap ...................................................o............................... 206 6.6.5. Przykład z mapami, łańcuchami oraz definiowaniem kryterium sortowania 6.6.6. podczas wykonywania ...................................................o...................................................o 210 6.7. ................. 212 Inne kontenery STL ...................................................o...................................................o... Łańcuchy jako kontenery STL ...................................................o....................................... 213 6.7.1. Zwykłe tablice jako kontenery STL ...................................................o.............................. 214 6.7.2. 6.7.3. Tablice mieszające ...................................................o...................................................o. ....... 216 Implementacja semantyki referencji ...................................................o........................................... 217 6.8. 6.9. Kiedy stosować poszczególne kontenery ...................................................o.................................. 220 6.10. Typy kontenerowe i ich składowe w szczegółach ...................................................o..................... 223 6.10.1. Definicje typów...................................................o...................................................o... .......... 224 6.10.2. Operacje tworzenia, kopiowania i niszczenia...................................................o............. 225 6.10.3. Operacje niemodyfikujące...................................................o.............................................. 227 6.10.4. Operacje przypisania ...................................................o...................................................... 230 6.10.5. Bezpośredni dostęp do elementów ...................................................o.............................. 231 6.10.6. Operacje generujące iteratory...................................................o........................................233 6.10.7. Wstawianie i usuwanie elementów...................................................o.............................. 234 6.10.8. Specjalne funkcje składowe list...................................................o..................................... 239 6.10.9. Obsługa alokatorów...................................................o...................................................o..... 241 6.10.10. Omówienie obsługi wyjątków w kontenerach STL...................................................o... 242 7 Iteratory STL ...................................................n...................................................n245 7.1. 7.2. Kategorie iteratorów...................................................o...................................................o. Pliki nagłówkowe iteratorów...................................................o....................................................... 245 .................. 245 Iteratory wejściowe ...................................................o...................................................o...... 246 7.2.1. Iteratory wyjściowe...................................................o...................................................o...... 247 7.2.2. Iteratory postępujące ...................................................o...................................................... 248 7.2.3. Iteratory dwukierunkowe...................................................o.............................................. 249 7.2.4. Iteratory dostępu swobodnego ...................................................o..................................... 249 7.2.5. 7.2.6. Problem z inkrementacją i dekrementacją iteratorów wektorów.............................. 252 Pomocnicze funkcje iteratorów ...................................................o................................................... 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 ...................................................o...................................................o............... 257 Iteratory odwrotne ...................................................o...................................................o. ...... 257 Iteratory wstawiające...................................................o...................................................... 262 Iteratory strumieniowe...................................................o................................................... 268 .................... 273 7.5.1. Definiowanie funkcji ogólnych dla iteratorów...................................................o........... 275 7.5.2. Iteratory definiowane przez użytkownika...................................................o.................. 277 7.5. Cechy iteratorów...................................................o...................................................o..... 7.3. 7.4.1. 7.4.2. 7.4.3. SPIS TREŚCI 8 7 Obiekty funkcyjne STL...................................................n..................................281 8.1. Pojęcie obiektów funkcyjnych...................................................o...................................................... 281 8.1.1. Obiekty funkcyjne jako kryteria sortowania...................................................o............... 282 8.1.2. Obiekty funkcyjne ze stanem wewnętrznym ...................................................o............. 283 8.1.3. Wartość zwracana algorytmu for_each()...................................................o..................... 287 8.1.4. Predykaty a obiekty funkcyjne...................................................o...................................... 288 Predefiniowane obiekty funkcyjne..................................................o............................................... 291 8.2.1. Adaptatory funkcji ...................................................o...................................................o. ...... 291 8.2.2. Adaptatory funkcji składowych...................................................o.................................... 293 8.2.3. Adaptatory zwykłych funkcji...................................................o........................................ 295 8.2.4. Obiekty funkcyjne definiowane przez użytkownika dostosowane 8.2. do adaptatorów funkcji ...................................................o.................................................. 296 8.3. Dodatkowe złożeniowe obiekty funkcyjne...................................................o................................ 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...................................................n...............................................305 9.1. 9.2. Pliki nagłówkowe algorytmów ...................................................o................................................... 305 Przegląd algorytmów...................................................o...................................................o.. ............... 306 9.2.1. Krótkie wprowadzenie...................................................o................................................... 306 9.2.2. Klasyfikacja algorytmów...................................................o................................................ 307 ................ 316 9.3. Funkcje pomocnicze ...................................................o...................................................o... 9.4. Algorytm for_each() ...................................................o...................................................o.. ................. 318 9.5. Algorytmy niemodyfikujące ...................................................o........................................................ 320 9.5.1. Zliczanie elementów ...................................................o...................................................o.... 321 9.5.2. Wartość minimalna i maksymalna ...................................................o............................... 322 9.5.3. Wyszukiwanie elementów...................................................o............................................. 324 9.5.4. Porównywanie zakresów...................................................o............................................... 335 9.6. Algorytmy modyfikujące...................................................o.............................................................. 340 9.6.1. Kopiowanie elementów...................................................o..................................................341 9.6.2. Przekształcenia i kombinacje elementów ...................................................o.................... 344 9.6.3. Wymienianie elementów...................................................o................................................ 347 9.6.4. Przypisywanie nowych wartości ...................................................o.................................. 348 Zastępowanie elementów ...................................................o.............................................. 350 9.6.5. .............. 353 9.7.1. Usuwanie określonych wartości ...................................................o................................... 353 9.7.2. Usuwanie powtórzeń...................................................o...................................................o. .. 356 ................ 360 9.8.1. Odwracanie kolejności elementów...................................................o............................... 360 Przesunięcia cykliczne elementów ...................................................o............................... 361 9.8.2. Permutacje elementów ...................................................o................................................... 363 9.8.3. 9.8.4. Tasowanie elementów ...................................................o...................................................o. 365 Przenoszenie elementów na początek ...................................................o......................... 367 9.8.5. ................. 368 Sortowanie wszystkich elementów ...................................................o.............................. 369 Sortowanie częściowe ...................................................o..................................................... 371 9.7. Algorytmy usuwające ...................................................o...................................................o.. 9.8. Algorytmy mutujące...................................................o...................................................o... 9.9. Algorytmy sortujące ...................................................o...................................................o.. 9.9.1. 9.9.2. 8 SPIS TREŚCI 9.9.3. 9.9.4. Algorytmy stogowe ...................................................o...................................................o.. Sortowanie według n-tego elementu ...................................................o........................... 374 ... 375 9.10. Algorytmy przeznaczone dla zakresów posortowanych...................................................o........ 378 9.10.1. Wyszukiwanie elementów...................................................o............................................. 379 9.10.2. Scalanie elementów...................................................o...................................................o...... 385 9.11. Algorytmy numeryczne...................................................o...................................................o............. 393 9.11.1. Obliczanie wartości...................................................o......................................................... 393 9.11.2. Konwersje wartości względnych i bezwzględnych...................................................o... 397 10 Kontenery specjalne...................................................n.......................................401 Interfejs...................................................o...................................................o......... 10.2. Kolejki...................................................o...................................................o............. Interfejs...................................................o...................................................o......... 10.1. Stosy...................................................o...................................................o............... ............................... 401 10.1.1. .................. 403 10.1.2. Przykład użycia stosów...................................................o.................................................. 403 10.1.3. Klasa stack w szczegółach...................................................o......................................... 404 10.1.4. Klasa stosu definiowanego przez użytkownika...................................................o......... 406 .............................. 408 .................. 410 10.2.1. 10.2.2. Przykład użycia kolejek...................................................o.................................................. 410 10.2.3. Klasa queue w szczegółach...................................................o....................................... 411 10.2.4. Klasa kolejki definiowanej przez użytkownika...................................................o.......... 413 10.3. Kolejki priorytetowe...................................................o...................................................o................... 416 10.3.1. .................. 417 10.3.2. Przykład użycia kolejek priorytetowych...................................................o..................... 418 10.3.3. Klasa priority_queue w szczegółach ...................................................o....................... 418 ....................... 421 10.4.1. Przykłady użycia kontenerów bitset...................................................o............................ 422 10.4.2. Szczegółowy opis klasy bitset ...................................................o....................................... 424 10.4. Kontener bitset ...................................................o...................................................o..... Interfejs...................................................o...................................................o......... 11 Łańcuchy ...................................................n...................................................n......431 11.1. Motywacja...................................................o...................................................o........... ......................... 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 ...................................................o........................ 440 11.2.1. Typy łańcuchów znakowych...................................................o......................................... 440 11.2.2. Przegląd funkcji składowych ...................................................o........................................ 441 11.2.3. Konstruktory oraz destruktory ...................................................o..................................... 443 11.2.4. Łańcuchy znakowe zwykłe oraz języka C ...................................................o.................. 444 11.2.5. Rozmiar oraz pojemność...................................................o................................................ 446 11.2.6. Dostęp do elementów...................................................o..................................................... 448 ........... 449 11.2.7. Porównania ...................................................o...................................................o........ 11.2.8. Modyfikatory ...................................................o...................................................o...... .......... 450 11.2.9. Konkatenacja łańcuchów znakowych oraz ich fragmentów...................................... 453 11.2.10. Operatory wejścia-wyjścia ...................................................o............................................. 454 11.2.11. Poszukiwanie oraz odnajdywanie łańcuchów znakowych........................................ 455 11.2.12. Wartość npos...................................................o...................................................o..... ............ 457 11.2.13. Obsługa iteratorów w przypadku łańcuchów znakowych ........................................ 458 SPIS TREŚCI 9 11.2.14. Obsługa standardów narodowych ...................................................o............................... 464 11.2.15. Wydajność ...................................................o...................................................o........ ............. 466 11.2.16. Łańcuchy znakowe a wektory...................................................o....................................... 466 11.3. Klasa string w szczegółach...................................................o........................................................... 467 11.3.1. Definicje typu oraz wartości statyczne ...................................................o........................ 467 11.3.2. Funkcje składowe służące do tworzenia, kopiowania oraz usuwania łańcuchów znakowych ...................................................o...................................................o 469 11.3.3. Funkcje dotyczące rozmiaru oraz pojemności...................................................o............ 470 ........... 471 11.3.4. Porównania ...................................................o...................................................o........ 11.3.5. Dostęp do znaków ...................................................o...................................................o.. ..... 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...................................................o................................ 482 11.3.9. Łączenie łańcuchów znakowych...................................................o................................... 485 11.3.10. Funkcje wejścia-wyjścia...................................................o.................................................. 486 11.3.11. Funkcje tworzące iteratory...................................................o............................................. 487 11.3.12. Obsługa alokatorów...................................................o........................................................ 488 12 Kontenery numeryczne...................................................n.................................491 12.2. Klasa valarray...................................................o...................................................o...... 12.1. Liczby zespolone...................................................o...................................................o.... ..................... 491 12.1.1. Przykład wykorzystania klasy reprezentującej liczby zespolone ............................. 492 12.1.2. Funkcje operujące na liczbach zespolonych...................................................o................ 494 12.1.3. Klasa complex w szczegółach...................................................o................................... 501 ........................ 506 12.2.1. Poznawanie klas valarray ...................................................o.............................................. 507 12.2.2. Podzbiory wartości umieszczonych w tablicy valarray.............................................. 512 12.2.3. Klasa valarray w szczegółach...................................................o........................................ 525 12.2.4. Klasy podzbiorów tablic typu valarray w szczegółach...................................................o. 530 12.3. Globalne funkcje numeryczne ...................................................o..................................................... 535 13 Obsługa wejścia-wyjścia z wykorzystaniem klas strumieniowych ..........537 13.1. Podstawy strumieni wejścia-wyjścia ...................................................o.......................................... 538 ........ 538 13.1.1. Obiekty strumieni...................................................o...................................................o. 13.1.2. Klasy strumieni...................................................o...................................................o... .......... 539 13.1.3. Globalne obiekty strumieni ...................................................o...........................................539 13.1.4. Operatory strumieniowe...................................................o................................................ 540 13.1.5. Manipulatory ...................................................o...................................................o...... .......... 540 ......... 541 13.1.6. Prosty przykład ...................................................o...................................................o... 13.2. Podstawowe obiekty oraz klasy strumieniowe ...................................................o........................ 542 13.2.1. Klasy oraz hierarchia klas...................................................o.............................................. 542 13.2.2. Globalne obiekty strumieni ...................................................o...........................................545 ....... 546 13.2.3. Pliki nagłówkowe...................................................o...................................................o.. 13.3. Standardowe operatory strumieniowe oraz ...................................................o...................... 547 13.3.1. Operator wyjściowy ...................................................o.................................................. 547 13.3.2. Operator wejściowy ...................................................o.................................................. 549 13.3.3. Operacje wejścia-wyjścia dla specjalnych typów...................................................o....... 549 10 SPIS TREŚCI 13.4. Stany strumieni ...................................................o...................................................o..... 13.6. Manipulatory...................................................o...................................................o........ 13.7. Formatowanie...................................................o...................................................o........ 13.8. Umiędzynarodawianie...................................................o...................................................o. 13.9. Dostęp do plików...................................................o...................................................o.... ...................... 552 13.4.1. Stałe służące do określania stanów strumieni ...................................................o............ 552 13.4.2. Funkcje składowe operujące na stanie strumieni...................................................o....... 553 13.4.3. Warunki wykorzystujące stan strumienia oraz wartości logiczne............................ 555 13.4.4. Stan strumienia i wyjątki ...................................................o............................................... 557 13.5. Standardowe funkcje wejścia-wyjścia ...................................................o........................................ 561 13.5.1. Funkcje składowe służące do pobierania danych...................................................o...... 562 13.5.2. Funkcje składowe służące do wysyłania danych...................................................o....... 565 13.5.3. Przykład użycia ...................................................o...................................................o... ......... 566 ....................... 567 13.6.1. Sposób działania manipulatorów ...................................................o................................. 568 13.6.2. Manipulatory definiowane przez użytkownika...................................................o......... 569 ...................... 570 13.7.1. Znaczniki formatu...................................................o...................................................o. ....... 570 13.7.2. Format wartości logicznych...................................................o...........................................572 13.7.3. Szerokość pola znak wypełnienia oraz wyrównanie ...................................................o 573 13.7.4. Znak wartości dodatnich oraz duże litery ...................................................o.................. 576 13.7.5. Podstawa numeryczna ...................................................o................................................... 576 13.7.6. Notacja zapisu liczb zmiennoprzecinkowych ...................................................o............ 579 13.7.7. Ogólne definicje formatujące...................................................o.........................................581 .............. 582 .................... 583 13.9.1. Znaczniki pliku...................................................o...................................................o... .......... 586 13.9.2. Dostęp swobodny...................................................o...................................................o... ...... 589 13.9.3. Deskryptory plików...................................................o...................................................o..... 592 13.10. Łączenie strumieni wejściowych oraz wyjściowych...................................................o................ 592 13.10.1 Luźne powiązanie przy użyciu tie()...................................................o............................. 593 13.10.2. Ścisłe powiązanie przy użyciu buforów strumieni...................................................o.... 594 13.10.3. Przekierowywanie strumieni standardowych...................................................o............ 596 13.10.4. Strumienie służące do odczytu oraz zapisu...................................................o................ 597 13.11. Klasy strumieni dla łańcuchów znakowych...................................................o.............................. 599 13.11.1. Klasy strumieni dla łańcuchów znakowych ...................................................o............... 600 13.11.2. Klasy strumieni dla wartości typu char* ...................................................o..................... 603 13.12. Operatory wejścia-wyjścia dla typów zdefiniowanych przez użytkownika .......................... 605 13.12.1. Implementacja operatorów wyjściowych...................................................o.................... 605 13.12.2. Implementacja operatorów wejściowych ...................................................o.................... 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 ...................................................o.. 612 13.12.6. Konwencje operatorów wejścia-wyjscia definiowanych przez użytkownika .......... 615 13.13. Klasy bufora strumienia ...................................................o............................................................... 616 13.13.1. Spojrzenie użytkownika na bufory strumieni ...................................................o............ 616 13.13.2. Iteratory wykorzystywane z buforem strumienia ...................................................o..... 618 13.13.3. Bufory strumienia definiowane przez użytkownika...................................................o. 621 ................... 632 13.14.1. Synchronizacja ze standardowymi strumieniami używanymi w języku C ............. 633 13.14.2. Buforowanie w buforach strumieni..................................................o............................... 633 13.14.3. Bezpośrednie wykorzystanie buforów strumieni ...................................................o...... 634 13.14. Kwestie wydajności ...................................................o...................................................o. SPIS TREŚCI 14 11 Umiędzynarodowienie...................................................n..................................637 14.1. Różne standardy kodowania znaków ...................................................o........................................ 638 14.1.1. Reprezentacja za pomocą zestawu znaków szerokiego zakresu lub reprezentacja wielobajtowa...................................................o..................................... 639 14.1.2. Cechy znaków...................................................o...................................................o...... ......... 640 14.1.3. Umiędzynarodawianie specjalnych znaków ...................................................o.............. 643 14.2. Pojęcie obiektów ustawień lokalnych...................................................o......................................... 644 14.2.1. Wykorzystywanie ustawień lokalnych...................................................o........................ 646 14.2.2. Aspekty ustawień lokalnych ...................................................o......................................... 650 14.3. Klasa locale w szczegółach...................................................o........................................................... 653 14.4. Klasa facet w szczegółach...................................................o............................................................. 656 14.4.1. Formatowanie wartości numerycznych...................................................o....................... 657 14.4.2. Formatowanie czasu oraz daty ...................................................o..................................... 661 14.4.3. Formatowanie wartości walutowych...................................................o........................... 664 14.4.4. Klasyfikacja oraz konwersja znaków ...................................................o........................... 669 14.4.5. Sortowanie łańcuchów znakowych...................................................o.............................. 677 14.4.6. Lokalizacja komunikatów ...................................................o..............................................679 15 Alokatory ...................................................n...................................................n.....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...................................................o...................................................o... .................. 685 15.4. Alokator zdefiniowany przez użytkownika...................................................o.............................. 687 15.5. Alokatory w szczegółach...................................................o.............................................................. 689 ............ 689 ....... 691 15.6. Funkcje stosowane w przypadku niezainicjalizowanej pamięci............................................... 692 15.5.1. Definicje typu...................................................o...................................................o.... 15.5.2. Funkcje składowe ...................................................o...................................................o.. A Bibliografia...................................................n...................................................n...695 B Skorowidz ...................................................n...................................................n....697 10 Kontenery specjalne Standardowa biblioteka C++ zawiera nie tylko kontenery szkieletu STL, lecz również kontenery służące do specjalnych celów oraz dostarczające prostych interfejsów prawie niewymagających opisu. Kontenery te mogą zostać podzielobne na: Tak zwane adaptatory kontenerów. • Tego rodzaju kontenery przystosowują standardowe kontenery STL do specjalnych celów. Wyróżniamy trzy rodzaje adaptatorów standardowbych kontenerów: 1. Stosy. 2. Kolejki. 3. Kolejki priorytetowe. Te ostatnie stanowią pewien rodzaj kolejki z elementami posortowanymi w sposób automatyczny według ustalonych kryteriów sortowania. Dlatego też „kolejnym” elementem w kolejce priorytetowej jest ten o „najwyżsbzej” wartości. Specjalny kontener nazwany bitset. • Kontener bitset jest polem bitowym, zawierającym dowolną, lecz ustaloną z góry liczbę bitów. Można traktować go jako kontener przechowujący wartości bitowe lub logiczne. Zwróć uwagę, że standardowa biblioteka C++ zawiera również specjalny kon- tener o zmiennym rozmiarze, przeznaczony dla wartości logicznych: vector bool . Został on opisany w podrozdziale 6.2.6., na stronie 161. 10.1. Stosy Stos (zwany również kolejką LIFO) zaimplementowany został w klasie o nazwie stack . Funkcja składowa push() służy do wkładania na stos dowolnej liczby elementów (patrz rysunek 10.1). Pobranie elementów ze stosu możliwe jest natomiast przy użyciu funkcji składowej o nazwie pop(). Pobieranie następuje w odwrotnej kolejności do ich umiesz- czania1. 1 „last in, first out”, co w dosłownym tłumaczeniu oznacza „ostatni wszedł, pierwszy wyszedł” — przyp. tłum. 402 10. KONTENERY SPECJALNE RYSUNEK 10.1. Interfejs stosu W celu wykorzystania stosu konieczne jest dołączenibe pliku nagłówkowego stack 2: #include stack Deklaracja klasy stack w pliku nagłówkowym stack wygląda następująco: namespace std { template class T, class Container = deque T class stack; } Pierwszy z parametrów wzorca określa rodzaj elementów. Drugi natomiast jest opcjonalny i definiuje kontener używany wewnętrznie w celu skolejkowania elementów umieszczo- nych we właściwym kontenerze stosu. Domyślnie przyjmowany jest kontener o nazwie deque3. Wybrany został właśnie ten kontener, ponieważ w przeciwieństwie do wektorów zwalnia on używaną przez siebie pamięć po usunięciu umieszczonych w nim elementów i nie musi przekopiowywać ich wszystkich w przypadku ponownego jej przydzielania (dokładne omówienie przypadków stosowania różnych kontenerów zostało umieszczone w podrozdziale 6.9., na stronie 220). Na przykład poniższy wiersz zawiera deklarację, okrebślającą stos liczb całkowitych4: std::stack int st; //stos przechowujacy liczby całkowite Implementacja stosu polega na prostym odwzorowaniu wykonywanych operacji na odpo- wiednie wywołania funkcji składowych używanego wewnętrznie kontenera (patrz rysu- nek 10.2). Możliwe jest użycie dowolnej klasy kontenera udostępniającej funkcje składowe o nazwie back(), push_back() oraz pop_back(). I tak na przykład w charakterze kontenera elementów możliwe byłoby wykorzystanie lisbty lub wektora: std::stack int,std::vector int st; //stos przechowujacy liczby calkowite wykorzystujaccy wektor 2 W oryginalnej bibliotece STL plik nagłówkowy zawierający deklarację stosu nosił nazwę: stack.h . 3 Kolejka o dwóch końcach — przyp. tłum. 4 W poprzednich wersjach biblioteki STL istniała konieczność przekazywania kontenera w cha- rakterze obowiązkowego argumentu wzorca. Dlatego też stos liczb całkowitych musiał być wtedy deklarowany w następujący sposób: stack deque int st; 10.1. STOSY 403 RYSUNEK 10.2. Wewnętrzny interfejs stosu 10.1.1. Interfejs W przypadku stosów interfejs tworzą funkcje składowe o nazwach push(), top() oraz pop(): • • • Funkcja składowa push() umieszcza element na stosie. Funkcja składowa top() zwraca kolejny element stosu. Funkcja składowa pop() usuwa element ze stosu. Zwróć uwagę, że funkcja składowa pop() usuwa kolejny element, lecz go nie zwraca, podczas gdy top() zwraca kolejny element bez jego usuwania. Dlatego też w celu prze- tworzenia oraz usunięcia kolejnego elementu na stosie konieczne jest wywołanie obu tych funkcji składowych. Opisany interfejs jest nieco niewygodny, lecz działa znacznie lepiej w przypadku, gdy chcesz jedynie usunąć kolejny element bez jego analizy i prze- twarzania. Zauważ, że działanie funkcji składowych top() oraz pop() jest niezdefi- niowane w przypadku, gdy stos nie zawiera żadnych elementów. W celu umożliwienia sprawdzenia, czy na stosie umieszczone są jakiekolwiek elementy, dodane zostały funkcje składowe size() oraz empty(). Jeśli standardowy interfejs kontenera stack nie przypadł ci do gustu, oczywiście możesz w łatwy sposób napisać swój własny i bardziej wygodny w użyciu. Odpowiedni przykład zostanie umieszczony w podrozdziale 10.1.4., nab stronie 406. 10.1.2. Przykład użycia stosów Poniższy przykład demonstruje wykorzystanie klasy stack : //cont/stack1.cpp #include iostream #include stack using namespace std; int main() { stack int st; // umiesc na stosie trzy elementy st.push(1); st.push(2); st.push(3); 404 10. KONTENERY SPECJALNE // pobierz ze stosu dwa elementy i je wypisz cout st.top() ; st.pop(); cout st.top() ; st.pop(); // zmien kolejny element st.top() = 77; // umiesc dwa dodatkowe elementy st.push(4); st.push(5); // pobierz jeden element bez jego przetwarzania st.pop(); // pobierz i wypisz pozostale elementy while (!st.empty()) { cout st.top() ; st.pop(); } cout endl; } Dane wyjściowe programu wyglądają następująco: 3 2 4 77 10.1.3. Klasa stack w szczegółach Interfejs klasy stack jest tak niewielki, iż można go w prosty sposób zrozumieć, ana- lizując jego typową implementację: namespace std { template class T, class Container = deque T class stack { public: typedef typename Container::value_type value_type ; typedef typename Container::size_type size_type; typedef Container contai ner_type; protected: Container c; //kontener public: explicit stack(const Container = Container()); bool empty() const { retur n c.empty(); } size_type size() const { return c.size(); } void push(const value_type x) { c.push_bac k(x); } void pop() { c.po p_back(); } value_type top() { return c.back(); } const value_type top() const { return c.back(); } }; template class T, class Container bool operator==(const stack T, Container , const stack T, Container ); template class T, class Container 10.1. STOSY 405 bool operator (const stack T, Container , const stack T, Container ); ...// (inne operatory porownania) } Poniższa część tego podrozdziału zawiera szczegółowy opbis pól oraz operacji. Definicje typu stack::value_type • • Rodzaj elementów umieszczonych w kontenerze. Składowa równoważna jest składowej container::value_type. stack::size_type • • Typ całkowity bez znaku, określający rozmiar umieszczbonych elementów. Składowa równoważna jest składowej container::size_type. stack::container_type • Rodzaj kontenera. Funkcje składowe stack::stack () • • Konstruktor domyślny. Tworzy pusty stos. explicit stack::stack (const Container cont) • • Tworzy stos inicjalizowany elementami umieszczonymi w bobiekcie cont. Kopiowane są wszystkie elementy umieszczone w kontenebrze cont. size_type stack::size () const • • Zwraca bieżącą liczbę elementów. W celu sprawdzenia, czy stos jest pusty, używaj funkcji składowej o nazwie empty(), ponieważ jej działanie może być szybsze. bool stack::empty () const • • Zwraca wartość logiczną, określającą, czy stos jest pubsty (nie zawiera elementów). Funkcja składowa równoważna konstrukcji postaci stack::size()==0, lecz może działać od niej szybciej. void stack::push (const value_type elem) • Wstawia jako pierwszy element stosu kopię elementu, okbreślonego przez wartość elem. value_type stack::top () const value_type stack::top () const • Obie postaci funkcji składowej zwracają kolejny element stosu. Będzie nim element wstawiony jako ostatni (po wszystkich innych elementbach stosu). • Przed wywołaniem funkcji składowej należy upewnić się, że stos zawiera jakiekol- wiek elementy (size() 0). W innym przypadku jej działanie jest nieokreślone. 406 10. KONTENERY SPECJALNE • Funkcja składowa w pierwszej postaci przeznaczona jest dla stosów, które nie są określone jako statyczne (nonconstant) i zwraca referencję. Dlatego też możliwe jest zmodyfikowanie kolejnego elementu jeszcze w chwili, gdy jest on umieszczony na stosie. Do ciebie należy podjęcie decyzji, czy jest tbo dobry styl programowania. void stack::pop () • Usuwa kolejny element stosu. Będzie nim element wstawiony jako ostatni (po wszyst- kich innych elementach stosu). • Funkcja nie zwraca wartości. W celu przetworzenia kolejnego elementu musisz wcze- śniej wywołać funkcję składową top(). • Przed wywołaniem funkcji składowej należy upewnić się, że stos zawiera jakiekolwiek elementy (size() 0). W innym przypadku jej działanie jest nieokreślone. bool comparison (const stack stack1, const stack stack2) • Zwraca wynik porównania dwóch stosów tego samego rodzabju. • comparison może być określony w jeden z poniższych sposobów: operator == operator != operator operator operator = operator = • Dwa stosy są jednakowe w przypadku, gdy zawierają taką samą liczbę identycz- nych elementów umieszczonych w tej samej kolejności (porównanie każdych dwóch odpowiadających sobie elementów musi dawać w rezultacbie wartość true). • W celu sprawdzenia, czy jeden stos jest mniejszy od drugiego, oba porównywane są leksykograficznie. Więcej informacji zostało umieszczonych na stronie 338 wraz z opisem algorytmu o nazwie lexicographical_compare(). 10.1.4. Klasa stosu definiowanego przez użytkownika Standardowa klasa stack preferuje szybkość działania nad wygodę oraz bezpieczeństwo użytkowania. Nie jest to tym, co zazwyczaj ja uważam za najlepsze podejście. Dlatego też napisałem własną klasę stosu. Ma ona dwie zalety: 1. pop() zwraca kolejny element. 2. pop() oraz top() zwraca wyjątek w przypadku, gdy stos jest pusty. Dodatkowo pominąłem wszystkie funkcje składowe, które nie są niezbędne dla zwykłego użytkownika stosu, jak chociażby operacje porównania. Moja klasa stosu zdefiniowana została w następujący sposób: //cont/Stack.hpp /* ************************************************c************ * Stack.hpp * - bezpieczniejsza oraz bardziej wygodna klasa cstosu * ************************************************c************/ #ifndef STACK_HPP #define STACK_HPP 10.1. STOSY #include deque #include exception 407 template class T class Stack { protected: std::deque T c; // kontener zawierajacy elementy public: /* klasa wyjatku dla funkcji składowych pop() oraz ctop() wywolanych w przypadku pustego stosu */ class ReadEmptyStack : public std::exception { public: virtual const char* what() const throw() { return proba odczytania pustego elementu ; } }; // liczba elementow typename std::deque T ::size_type size() const { return c.size(); } // czy stos jest pusty? bool empty() const { return c.empty(); } // umiesc element na stosie void push (const T elem) { c.push_back(elem); } // zdejmij element ze stosu i zwroc jego wartosc T pop () { if (c.empty()) { throw ReadEmptyStack(); } T elem(c.back()); c.pop_back(); return elem; } // zwroc wartosc kolejnego elementu T top () { if (c.empty()) { throw ReadEmptyStack(); } return c.back(); } }; #endif /* STACK_HPP */ W przypadku zastosowania tej klasy stosu poprzedni przykład powinien zostać napisany następująco: // cont/stack2.cpp #include iostream #include Stack.hpp // wykorzystaj specjalna klase stosu using namespace std; 408 10. KONTENERY SPECJALNE int main() { t
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++. Biblioteka standardowa. Podręcznik programisty
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: