Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00281 005141 12583252 na godz. na dobę w sumie
Język C++. Szkoła programowania. Wydanie VI - książka
Język C++. Szkoła programowania. Wydanie VI - książka
Autor: Liczba stron: 1200
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-4336-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).

Najlepsze źródło informacji o C++!

Język C++. Szkoła programowania to starannie sprawdzony, sumiennie przygotowany i kompletny przewodnik po programowaniu w C++, przeznaczony dla programistów. Ten klasyczny już materiał pomocniczy dla wykładowców uczy zasad programowania, począwszy od kodu strukturalnego i projektowania wedle metody dekompozycji i analizy, przez klasy, dziedziczenie, szablony i wyjątki, po wyrażenia lambda, inteligentne wskaźniki i semantykę przeniesienia. Stephen Prata jako autor i wykładowca proponuje przemyślane, przejrzyste i wnikliwe wprowadzenie do języka C++. Wraz z mechanizmami samego języka omawia fundamentalne pojęcia i techniki programowania.

Szóste wydanie książki zostało uaktualnione i rozszerzone o omówienie elementów wprowadzonych do języka w nowym standardzie C++11. Książka przyda się nie tylko studentom klas informatycznych, ale również programistom biegłym w innych językach programowania, którzy chcieliby poznać język C++ lub pogłębić swoją wiedzę dotyczącą niuansów stosowania tego języka.

Dzięki tej książce:

Kompletny podręcznik do nauki C++!


Stephen Prata uczył astronomii, fizyki i informatyki w College of Marin w Kenterfield (Kalifornia). Dyplom magisterski obronił w Kalifornijskim Instytucie Technologicznym, a doktorat na Uniwersytecie Kalifornijskim w Berkeley. Jest autorem i współautorem kilkunastu książek, w tym poprzednich wydań Języka C++. Szkoły programowania i Języka C. Szkoły programowania, nagrodzonych w 1990 roku wyróżnieniem Best How-to Computer Book Award stowarzyszenia Computer Press Association.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

• Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treści Podziökowania ..................................................................................... 19 Wstöp .................................................................................................. 21 Rozdziaä 1. Zaczynamy .......................................................................................... 31 Nauka C++ — co nas czeka? ............................................................................. 31 Pochodzenie jözyka C++ — krótka historia ........................................................... 32 Jözyk C ........................................................................................................ 32 Filozofia programowania w C ......................................................................... 33 Zmiana w C++ — programowanie obiektowe .................................................. 34 C++ i programowanie uogólnione ................................................................... 35 Pochodzenie C++ ......................................................................................... 36 PrzenoĈnoĈè i standardy .................................................................................... 37 Rozwój jözyka w liczbach ............................................................................... 38 Standardy C++ w niniejszej ksiñĔce ................................................................ 39 Mechanika tworzenia programu ........................................................................... 39 Pisanie kodu Ēródäowego ............................................................................... 40 Kompilacja i konsolidacja .............................................................................. 41 Podsumowanie .................................................................................................. 45 Rozdziaä 2. Pierwszy program w C++ ...................................................................... 47 C++ — poczñtek ................................................................................................ 47 Cechy funkcji main() ..................................................................................... 49 Komentarze w C++ ....................................................................................... 51 Preprocesor i plik iostream ............................................................................ 52 Nazwy plików nagäówkowych .......................................................................... 53 Przestrzenie nazw ......................................................................................... 53 Wypisywanie danych — cout .......................................................................... 55 Formatowanie kodu Ēródäowego C++ .............................................................. 57 Instrukcje C++ ................................................................................................... 59 Instrukcje deklaracji i zmienne ....................................................................... 60 Instrukcja przypisania ................................................................................... 61 Nowa sztuczka z cout .................................................................................... 62 6 Jözyk C++. Szkoäa programowania Inne instrukcje C++ ............................................................................................ 62 UĔycie obiektu cin ......................................................................................... 63 Zäñczanie za pomocñ cout ............................................................................. 64 cin i cout — klasy po raz pierwszy .................................................................. 64 Funkcje ............................................................................................................. 66 UĔycie funkcji zwracajñcej wartoĈè ................................................................. 66 Odmiany funkcji ............................................................................................ 69 Funkcje definiowane przez uĔytkownika .......................................................... 70 Funkcje uĔytkownika zwracajñce wartoĈè ........................................................ 73 Dyrektywa using w programach z wieloma funkcjami ........................................ 74 Podsumowanie .................................................................................................. 76 Pytania sprawdzajñce ......................................................................................... 77 çwiczenia programistyczne ................................................................................. 77 Rozdziaä 3. Dane .................................................................................................... 79 Zmienne proste ................................................................................................. 80 Nazwy zmiennych .......................................................................................... 80 Typy caäkowitoliczbowe .................................................................................. 81 Typy short, int, long i long long ...................................................................... 82 Typy bez znaku ............................................................................................. 87 Dobór wäaĈciwego typu ................................................................................. 89 Literaäy caäkowitoliczbowe ............................................................................. 90 Jak C++ ustala typ staäej? ............................................................................. 91 Typ char — znaki i maäe liczby caäkowite ........................................................ 92 Typ danych bool ......................................................................................... 100 Kwalifikator const ............................................................................................ 100 Liczby zmiennoprzecinkowe .............................................................................. 101 Zapis liczb zmiennoprzecinkowych ............................................................... 102 Zmiennoprzecinkowe typy danych ................................................................. 103 Staäe zmiennoprzecinkowe .......................................................................... 105 Zalety i wady liczb zmiennoprzecinkowych ................................................... 105 Operatory arytmetyczne C++ ............................................................................. 106 KolejnoĈè dziaäaþ — priorytety operatorów i äñcznoĈè .................................... 107 Odmiany dzielenia ...................................................................................... 108 Operator modulo ........................................................................................ 110 Konwersje typów ........................................................................................ 110 Automatyczne deklaracje typów w C++11 ..................................................... 116 Podsumowanie ................................................................................................ 117 Pytania sprawdzajñce ....................................................................................... 117 çwiczenia programistyczne ............................................................................... 118 Rozdziaä 4. Typy zäoĔone ...................................................................................... 121 Tablice w skrócie ............................................................................................. 122 Uwagi o programie ...................................................................................... 124 Inicjalizacja tablic ....................................................................................... 124 Inicjalizacja tablic w C++11 ......................................................................... 125 ãaþcuchy ........................................................................................................ 126 ãñczenie literaäów napisowych ..................................................................... 127 ãaþcuchy w tablicy ...................................................................................... 128 Problemy z wprowadzaniem äaþcuchów znakowych ........................................ 129 Spis treĈci 7 Wczytywanie äaþcuchów znakowych wierszami ............................................... 130 Mieszanie w danych wejĈciowych äaþcuchów i liczb ........................................ 134 Klasa string — wprowadzenie ........................................................................... 135 Inicjalizacja äaþcuchów znakowych w C++11 ................................................. 136 Przypisanie, konkatenacja i doäñczanie ......................................................... 136 Inne operacje klasy string ........................................................................... 138 Klasa string a wejĈcie i wyjĈcie .................................................................... 139 Inne odmiany literaäów napisowych .............................................................. 141 Struktury ......................................................................................................... 142 UĔycie struktury w programie ....................................................................... 143 Inicjalizacja struktur w C++11 ...................................................................... 145 Czy w strukturze moĔna uĔyè pola typu string? .............................................. 146 Inne cechy struktur ..................................................................................... 146 Tablice struktur .......................................................................................... 148 Pola bitowe ................................................................................................ 149 Unie ............................................................................................................... 149 Typy wyliczeniowe ............................................................................................ 151 Ustawianie wartoĈci enumeratorów .............................................................. 153 Zakresy wartoĈci w typach wyliczeniowych .................................................... 153 WskaĒniki i róĔne drobiazgi ............................................................................... 154 Deklarowanie i inicjalizacja wskaĒników ........................................................ 156 Niebezpieczeþstwa zwiñzane ze wskaĒnikami ............................................... 158 WskaĒniki i liczby ........................................................................................ 159 UĔycie operatora new do alokowania pamiöci ................................................ 159 Zwalnianie pamiöci za pomocñ delete .......................................................... 161 UĔycie new do tworzenia tablic dynamicznych ................................................ 162 WskaĒniki, tablice i arytmetyka wskaĒników ....................................................... 165 Podsumowanie informacji o wskaĒnikach ...................................................... 168 WskaĒniki i äaþcuchy ................................................................................... 170 UĔycie new do tworzenia struktur dynamicznych ............................................ 174 Alokacja pamiöci: automatyczna, statyczna i dynamiczna ............................... 177 Kombinacje typów ............................................................................................ 179 Tablice inaczej ................................................................................................. 181 Klasa szablonowa vector ............................................................................. 181 Klasa szablonowa array (C++11) ................................................................. 182 Porównanie tablic z obiektami vector i array .................................................. 183 Podsumowanie ................................................................................................ 184 Pytania sprawdzajñce ....................................................................................... 185 çwiczenia programistyczne ............................................................................... 186 Rozdziaä 5. Pötle i wyraĔenia relacyjne ................................................................. 189 Pötle for .......................................................................................................... 190 Elementy pötli for ....................................................................................... 191 Wracamy do pötli for ................................................................................... 196 Zmiana wielkoĈci kroku ............................................................................... 198 Pötla for i äaþcuchy znakowe ........................................................................ 198 Operatory inkrementacji (++) i dekrementacji (--) ........................................... 199 Efekty uboczne i punkty odniesienia ............................................................. 200 Formy przedrostkowe a formy przyrostkowe .................................................. 201 8 Jözyk C++. Szkoäa programowania Operatory inkrementacji i dekrementacji a wskaĒniki ..................................... 202 ZäoĔone operatory przypisania ...................................................................... 203 Instrukcje zäoĔone, czyli bloki ....................................................................... 203 Przecinek jako operator (i pewne sztuczki skäadniowe) ................................... 205 WyraĔenia relacyjne .................................................................................... 208 Przypisania, porównania i pomyäki ................................................................ 208 Porównywanie äaþcuchów w stylu C .............................................................. 210 Porównywanie obiektów klasy string ............................................................. 213 Pötla while ...................................................................................................... 213 Uwagi o programie ...................................................................................... 215 Pötla for a pötla while ................................................................................. 216 Chwileczkö — tworzymy pötlö opóĒnienia ..................................................... 217 Pötla do while .................................................................................................. 219 Zakresowe pötle for (C++11) ............................................................................ 221 Pötle i wprowadzanie danych tekstowych ........................................................... 221 Najprostsza wersja cin ................................................................................ 222 cin.get(char) na odsiecz .............................................................................. 223 Która wersja cin.get() jest lepsza? ............................................................... 224 Koniec pliku ............................................................................................... 224 Jeszcze inna wersja cin.get() ....................................................................... 227 Pötle zagnieĔdĔone i dwuwymiarowe tablice ....................................................... 230 Inicjalizacja tablic dwuwymiarowych .............................................................. 232 Stosowanie tablic dwuwymiarowych ............................................................. 232 Podsumowanie ................................................................................................ 234 Pytania sprawdzajñce ....................................................................................... 234 çwiczenia programistyczne ............................................................................... 235 Instrukcje warunkowe i operatory logiczne .......................................... 237 Instrukcja if ..................................................................................................... 237 Instrukcja if else ......................................................................................... 239 Formatowanie instrukcji if else .................................................................... 241 Konstrukcja if else if else ............................................................................ 241 WyraĔenia logiczne ........................................................................................... 243 Logiczny operator alternatywy — || ............................................................... 243 Logiczny operator koniunkcji — .............................................................. 245 Ustalanie zakresu za pomocñ operatora ................................................. 247 Operator negacji logicznej — ! ..................................................................... 248 O operatorach logicznych ............................................................................ 250 Zapis alternatywny ...................................................................................... 251 Biblioteka cctype ............................................................................................. 251 Operator ?: ...................................................................................................... 253 Instrukcja switch .............................................................................................. 255 UĔycie enumeratorów jako etykiet ................................................................ 258 switch versus if else ................................................................................... 259 Instrukcje break i continue ............................................................................... 259 Uwagi o programie ...................................................................................... 261 Pötle wczytywania liczb ..................................................................................... 262 Uwagi o programie ...................................................................................... 264 Rozdziaä 6. Spis treĈci 9 Proste wejĈcie-wyjĈcie z pliku ............................................................................. 265 Tekstowe wejĈcie-wyjĈcie i pliki tekstowe ..................................................... 265 Zapis do pliku tekstowego ........................................................................... 267 Odczyt danych z pliku tekstowego ................................................................ 270 Podsumowanie ................................................................................................ 274 Pytania sprawdzajñce ....................................................................................... 275 çwiczenia programistyczne ............................................................................... 276 Rozdziaä 7. Funkcje — skäadniki programów w C++ .............................................. 279 Funkcje w skrócie ............................................................................................ 280 Definiowanie funkcji .................................................................................... 281 Prototypowanie i wywoäywanie funkcji ........................................................... 283 Parametry funkcji i przekazywanie przez wartoĈè ................................................. 286 Wiele parametrów ....................................................................................... 287 Jeszcze jedna funkcja dwuargumentowa ....................................................... 289 Funkcje i tablice .............................................................................................. 291 Jak wskaĒniki umoĔliwiajñ tworzenie funkcji przetwarzajñcych tablice? ............ 292 Skutki uĔycia tablic jako parametrów ............................................................ 293 Dodatkowe przykäady funkcji i tablic ............................................................. 295 Funkcje korzystajñce z zakresów tablic ......................................................... 301 WskaĒniki i modyfikator const ...................................................................... 302 Funkcje i tablice dwuwymiarowe ........................................................................ 306 Funkcje i äaþcuchy w stylu C ............................................................................. 307 Funkcje z äaþcuchami w stylu C jako parametrami ......................................... 307 Funkcje zwracajñce äaþcuchy w formacie C ................................................... 309 Funkcje i struktury ........................................................................................... 310 Przekazywanie i zwracanie struktur ............................................................... 311 Inny przykäad uĔycia funkcji i struktur ............................................................ 312 Przekazywanie adresu struktury ................................................................... 317 Funkcje i obiekty klasy string ............................................................................ 318 Funkcje i obiekty typu array ......................................................................... 320 Uwagi o programie ...................................................................................... 321 Rekurencja ...................................................................................................... 322 Rekurencja w pojedynczym wywoäaniu .......................................................... 322 Rekurencja w wielu wywoäaniach .................................................................. 324 WskaĒniki na funkcje ........................................................................................ 325 WskaĒniki na funkcje — podstawy ............................................................... 325 Przykäad uĔycia wskaĒników na funkcje ......................................................... 327 Wariacje na temat wskaĒników funkcji .......................................................... 329 Uproszczenie poprzez typedef ...................................................................... 333 Podsumowanie ................................................................................................ 333 Pytania sprawdzajñce ....................................................................................... 334 çwiczenia programistyczne ............................................................................... 336 Rozdziaä 8. Funkcje — zagadnienia zaawansowane ............................................... 339 Funkcje inline .................................................................................................. 339 Zmienne referencyjne ....................................................................................... 342 Tworzenie zmiennej referencyjnej ................................................................. 342 Referencje jako parametry funkcji ................................................................ 345 WäaĈciwoĈci referencji ................................................................................. 348 10 Jözyk C++. Szkoäa programowania UĔycie referencji do struktur ........................................................................ 352 UĔycie referencji z obiektami ....................................................................... 358 Obiekty po raz wtóry — obiekty, dziedziczenie i referencje .............................. 361 Kiedy korzystaè z referencji jako parametrów? .............................................. 364 Parametry domyĈlne ........................................................................................ 365 Uwagi o programie ...................................................................................... 366 PrzeciñĔanie funkcji .......................................................................................... 367 Przykäad przeciñĔania funkcji ........................................................................ 370 Kiedy korzystaè z przeciñĔania funkcji? ......................................................... 372 Szablony funkcji ............................................................................................... 372 PrzeciñĔone szablony .................................................................................. 375 Ograniczenia szablonów .............................................................................. 377 Specjalizacje jawne ..................................................................................... 377 Konkretyzacje i specjalizacje ....................................................................... 380 Którñ wersjö funkcji wybierze kompilator? ..................................................... 382 Ewolucja szablonów funkcji .......................................................................... 388 Podsumowanie ................................................................................................ 392 Pytania sprawdzajñce ....................................................................................... 392 çwiczenia programistyczne ............................................................................... 393 Rozdziaä 9. Model pamiöci i przestrzenie nazw ...................................................... 397 Kompilacja rozäñczna ....................................................................................... 397 Czas Ĕycia, zasiög i äñczenie ............................................................................. 403 Zasiög i äñczenie ........................................................................................ 404 Przydziaä automatyczny ................................................................................ 404 Zmienne statyczne ..................................................................................... 409 Przydziaä statyczny, äñczenie zewnötrzne ....................................................... 411 Specyfikatory i kwalifikatory ......................................................................... 419 ãñczenie a funkcje ...................................................................................... 421 ãñczenie jözykowe ...................................................................................... 422 Kategorie przydziaäu a przydziaä dynamiczny .................................................. 423 Przestrzenie nazw ............................................................................................ 429 Tradycyjne przestrzenie nazw jözyka C++ ...................................................... 429 Nowe mechanizmy przestrzeni nazw ............................................................. 431 Przestrzenie nazw — przykäad ...................................................................... 438 PrzyszäoĈè przestrzeni nazw ......................................................................... 441 Podsumowanie ................................................................................................ 442 Pytania sprawdzajñce ....................................................................................... 442 çwiczenia programistyczne ............................................................................... 445 Rozdziaä 10. Obiekty i klasy ................................................................................... 447 Programowanie proceduralne a programowanie obiektowe .................................. 448 Klasy a abstrakcje ........................................................................................... 449 Czym jest typ? ............................................................................................ 449 Klasy w jözyku C++ ..................................................................................... 450 Implementowanie metod klas ...................................................................... 455 Stosowanie klas ......................................................................................... 459 Zmiany implementacji ................................................................................. 461 Podsumowanie poznanych wiadomoĈci ........................................................ 462 Spis treĈci 11 Konstruktory i destruktory ................................................................................. 463 Deklarowanie i definiowanie konstruktorów ................................................... 464 Stosowanie konstruktorów .......................................................................... 465 Konstruktory domyĈlne ............................................................................... 466 Destruktory ................................................................................................ 467 Ulepszenia klasy Stock ............................................................................... 468 Konstruktory i destruktory — podsumowanie ................................................ 475 ToĔsamoĈè obiektu — wskaĒnik this ................................................................. 476 Tablice obiektów .............................................................................................. 482 Zasiög klasy .................................................................................................... 485 Staäe zasiögu klasy ..................................................................................... 486 Wyliczenia z wäasnym zasiögiem (C++11) ..................................................... 487 Abstrakcyjne typy danych .................................................................................. 488 Podsumowanie ................................................................................................ 492 Pytania sprawdzajñce ....................................................................................... 493 çwiczenia programistyczne ............................................................................... 493 Rozdziaä 11. Stosowanie klas ................................................................................. 497 PrzeciñĔanie operatorów ................................................................................... 498 Raz, dwa, trzy — próba przeciñĔenia operatora .................................................. 499 Dodatkowy operator dodawania ................................................................... 502 Ograniczenia przeciñĔania operatorów .......................................................... 505 Jeszcze o przeciñĔaniu operatorów ............................................................... 506 Przyjaciele najwaĔniejsi .................................................................................... 509 Deklarowanie przyjaĒni ................................................................................ 510 Typowa przyjaĒþ — przeciñĔanie operatora .............................................. 512 PrzeciñĔanie operatorów — metody kontra funkcje nieskäadowe .......................... 518 PrzeciñĔania ciñg dalszy — klasa Vector ............................................................ 519 Skäadowa kodujñca stan obiektu .................................................................. 526 PrzeciñĔanie operatorów arytmetycznych dla klasy Vector ............................... 528 Nota implementacyjna ................................................................................ 530 Wektorowe bäñdzenie losowe ....................................................................... 530 Automatyczne konwersje i rzutowanie typów klas ................................................ 534 O programie ............................................................................................... 539 Funkcje konwersji ....................................................................................... 539 Konwersja a zaprzyjaĒnienie ........................................................................ 544 Podsumowanie ................................................................................................ 547 Pytania sprawdzajñce ....................................................................................... 549 çwiczenia programistyczne ............................................................................... 549 Rozdziaä 12. Klasy a dynamiczny przydziaä pamiöci .................................................. 553 Klasy a pamiöè dynamiczna .............................................................................. 554 Powtórka z pamiöci dynamicznej i statyczne skäadowe klas ............................ 554 Specjalne metody klasy .............................................................................. 562 W czym tkwi problem z konstruktorem kopiujñcym w Stringbad? ..................... 565 Kolejne säaboĈci Stringbad: operatory przypisania ......................................... 568 Nowa, ulepszona klasa — String ....................................................................... 571 Nowa wersja konstruktora domyĈlnego ......................................................... 572 Porównywanie ciñgów ................................................................................. 573 12 Jözyk C++. Szkoäa programowania Indeksowanie ciñgu .................................................................................... 574 Statyczne metody klasy ............................................................................... 575 Dalsze przeciñĔanie operatora przypisania .................................................... 576 O czym naleĔy pamiötaè, stosujñc new w konstruktorach? .................................. 581 Zalecenia i przestrogi .................................................................................. 582 Kopiowanie obiektów skäadowa po skäadowej ............................................... 583 Säów parö o zwracaniu obiektów ........................................................................ 584 Zwracanie niemodyfikowalnej (const) referencji obiektu ................................. 584 Zwracanie modyfikowalnej (bez const) referencji do obiektu ........................... 585 Zwracanie obiektu przez wartoĈè .................................................................. 585 Zwracanie przez wartoĈè obiektu niemodyfikowalnego (const) ........................ 586 WskaĒniki obiektów .......................................................................................... 587 Jeszcze o new i delete ................................................................................ 589 WskaĒniki obiektów — podsumowanie ......................................................... 590 Jeszcze o miejscowej wersji new .................................................................. 592 Powtórka z poznanych technik ........................................................................... 596 PrzeciñĔanie operatora ........................................................................... 596 Funkcje konwersji ....................................................................................... 597 Klasy wykorzystujñce new w konstruktorach .................................................. 597 Symulacja kolejki ............................................................................................. 598 Klasa kolejki .............................................................................................. 598 Klasa klienta .............................................................................................. 609 Symulacja bankomatu ................................................................................. 612 Podsumowanie ................................................................................................ 616 Pytania sprawdzajñce ....................................................................................... 617 çwiczenia programistyczne ............................................................................... 619 Rozdziaä 13. Klasy i dziedziczenie ........................................................................... 623 Prosta klasa bazowa ........................................................................................ 624 Dziedziczenie ............................................................................................. 626 Konstruktory — zagadnienia zwiñzane z poziomem dostöpu ........................... 628 Korzystanie z klasy pochodnej ..................................................................... 631 Relacje miödzy klasñ pochodnñ a bazowñ ..................................................... 633 Dziedziczenie — relacja jest-czymĈ .................................................................... 635 Polimorficzne dziedziczenie publiczne ................................................................ 636 Tworzenie klas Brass oraz BrassPlus ........................................................... 637 Wiñzanie statyczne i dynamiczne ....................................................................... 648 ZgodnoĈè typów wskaĒnikowych i referencyjnych ........................................... 648 Metody wirtualne i wiñzanie dynamiczne ....................................................... 650 Co trzeba wiedzieè o metodach wirtualnych? ................................................. 653 Kontrola dostöpu — poziom chroniony .............................................................. 656 Abstrakcyjne klasy bazowe ............................................................................... 657 Stosowanie abstrakcyjnych klas bazowych .................................................... 659 Filozofia abstrakcyjnych klas bazowych ......................................................... 665 Dziedziczenie i dynamiczny przydziaä pamiöci ...................................................... 665 Przypadek pierwszy — klasa pochodna bez dynamicznego przydziaäu pamiöci ... 665 Przypadek drugi — klasa pochodna z dynamicznym przydziaäem pamiöci ..... 666 Przykäad dziedziczenia z wykorzystaniem dynamicznego przydziaäu pamiöci oraz funkcji zaprzyjaĒnionych ......................................................... 668 Spis treĈci 13 Projektowanie klas — przeglñd zagadnieþ .......................................................... 673 Metody automatycznie generowane przez kompilator ..................................... 673 Inne metody ............................................................................................... 675 Dziedziczenie publiczne ............................................................................... 678 Metody klasy — podsumowanie .................................................................. 682 Podsumowanie ................................................................................................ 683 Pytania sprawdzajñce ....................................................................................... 683 çwiczenia programistyczne ............................................................................... 684 Rozdziaä 14. Wielokrotne uĔycie kodu w C++ .......................................................... 687 Klasy ze skäadowymi w postaci obiektów ........................................................... 688 Krótka charakterystyka klasy valarray ........................................................... 688 Projekt klasy Student .................................................................................. 689 Przykäadowa klasa Student ........................................................................... 691 Dziedziczenie prywatne ..................................................................................... 697 Nowa wersja klasy Student .......................................................................... 697 Dziedziczenie wielokrotne ................................................................................. 706 Podwójne egzemplarze klasy Worker ............................................................ 711 Podwójne metody ....................................................................................... 714 Przeglñd zagadnieþ zwiñzanych z dziedziczeniem wielokrotnym ....................... 723 Szablony klas .................................................................................................. 724 Definiowanie szablonu klasy ........................................................................ 724 Korzystanie z szablonu klasy ....................................................................... 727 Analiza szablonu klasy ................................................................................ 729 Szablon tablicy i argumenty pozatypowe szablonu ......................................... 734 ElastycznoĈè szablonów .............................................................................. 736 Specjalizacja szablonu ................................................................................ 739 Szablony jako skäadowe .............................................................................. 742 Szablony jako parametry ............................................................................. 744 Szablony klas i zaprzyjaĒnienie .................................................................... 746 Szablonowe aliasy typów (C++11) ................................................................ 752 Podsumowanie ................................................................................................ 753 Pytania sprawdzajñce ....................................................................................... 755 çwiczenia programistyczne ............................................................................... 757 Rozdziaä 15. ZaprzyjaĒnienie, wyjñtki i nie tylko ...................................................... 763 ZaprzyjaĒnienie ................................................................................................ 763 Klasy zaprzyjaĒnione ................................................................................... 764 ZaprzyjaĒnione metody klas ......................................................................... 768 Inne relacje przyjaĒni ................................................................................... 771 Klasy zagnieĔdĔone .......................................................................................... 773 Dostöp do klas zagnieĔdĔonych ................................................................... 774 ZagnieĔdĔanie w szablonie .......................................................................... 776 Wyjñtki ............................................................................................................ 779 Wywoäywanie funkcji abort() ......................................................................... 779 Zwracanie kodu bäödu ................................................................................. 780 Mechanizm wyjñtków .................................................................................. 782 Wyjñtki w postaci obiektów .......................................................................... 784 Specyfikacje wyjñtków a C++11 ................................................................... 788 Rozwijanie stosu ........................................................................................ 789 14 Jözyk C++. Szkoäa programowania Inne wäaĈciwoĈci wyjñtków .......................................................................... 793 Klasa exception .......................................................................................... 796 Wyjñtki, klasy i dziedziczenie ....................................................................... 799 Problemy z wyjñtkami .................................................................................. 804 OstroĔnie z wyjñtkami ................................................................................. 807 RTTI ................................................................................................................ 808 Po co nam RTTI? ........................................................................................ 808 Jak dziaäa RTTI? ......................................................................................... 809 Operatory rzutowania typu ................................................................................ 816 Podsumowanie ................................................................................................ 820 Pytania sprawdzajñce ....................................................................................... 820 çwiczenia programistyczne ............................................................................... 822 Rozdziaä 16. Klasa string oraz biblioteka STL .......................................................... 823 Klasa string ..................................................................................................... 823 Tworzenie obiektu string ............................................................................. 824 Wprowadzanie danych do obiektów string ..................................................... 828 UĔywanie obiektów string ............................................................................ 830 Co jeszcze oferuje klasa string? ................................................................... 835 Warianty klasy string ................................................................................... 837 Szablony klas inteligentnych wskaĒników ........................................................... 837 Stosowanie inteligentnych wskaĒników ......................................................... 838 Wiöcej o inteligentnych wskaĒnikach ............................................................ 841 WyĔszoĈè unique_ptr nad auto_ptr ............................................................... 844 Wybór inteligentnego wskaĒnika ................................................................... 845 Biblioteka STL ................................................................................................. 847 Szablon klasy vector ................................................................................... 847 Metody klasy vector .................................................................................... 849 Inne moĔliwoĈci klasy vector ........................................................................ 853 Zakresowe pötle for (C++11) ....................................................................... 857 Programowanie uogólnione ............................................................................... 858 Do czego potrzebne sñ iteratory? ................................................................. 858 Rodzaje iteratorów ...................................................................................... 862 Hierarchia iteratorów .................................................................................. 865 Pojöcia, uĈciĈlenia i modele ........................................................................ 866 Rodzaje kontenerów ................................................................................... 872 Kontenery asocjacyjne ................................................................................ 881 Nieuporzñdkowane kontenery asocjacyjne (C++11) ....................................... 887 Obiekty funkcyjne (funktory) .............................................................................. 887 Pojöcia zwiñzane z funktorami ..................................................................... 888 Funktory predefiniowane ............................................................................. 891 Funktory adaptowalne i adaptatory funkcji .................................................... 892 Algorytmy ........................................................................................................ 895 Grupy algorytmów ....................................................................................... 895 Ogólne wäaĈciwoĈci algorytmów ................................................................... 896 Biblioteka STL i klasa string ........................................................................ 897 Funkcje a metody kontenerów ..................................................................... 898 UĔywanie biblioteki STL ............................................................................... 899 Spis treĈci 15 Inne biblioteki .................................................................................................. 903 Klasy vector, valarray i array ........................................................................ 903 Szablon initializer_list (C++11) .................................................................... 908 Stosowanie szablonu initializer_list .............................................................. 910 Uwagi do programu ..................................................................................... 911 Podsumowanie ................................................................................................ 911 Pytania sprawdzajñce ....................................................................................... 913 çwiczenia programistyczne ............................................................................... 914 Rozdziaä 17. Obsäuga wejĈcia, wyjĈcia oraz plików .................................................. 917 Ogólna charakterystyka obsäugi wejĈcia-wyjĈcia w jözyku C++ .............................. 918 Strumienie i bufory ..................................................................................... 919 Strumienie i bufory a plik iostream ............................................................... 921 Przekierowanie ........................................................................................... 923 Realizacja operacji wyjĈcia z wykorzystaniem obiektu cout ................................... 924 PrzeciñĔony operator .............................................................................. 924 Inne metody klasy ostream ......................................................................... 927 OpróĔnianie bufora wyjĈciowego ................................................................... 930 Formatowanie danych wyjĈciowych za pomocñ obiektu cout ........................... 931 Realizacja operacji wejĈcia z wykorzystaniem obiektu cin ......................................... 945 Jak operator obiektu cin „widzi” dane wejĈciowe? .................................... 947 Stany strumienia ........................................................................................ 949 Inne metody klasy istream .......................................................................... 953 Pozostaäe metody klasy istream ................................................................... 960 WejĈcie-wyjĈcie plikowe .................................................................................... 964 Proste operacje wejĈcia-wyjĈcia plikowego .................................................... 965 Kontrola strumienia i metoda is_open() ........................................................ 968 Otwieranie wielu plików ............................................................................... 969 Przetwarzanie argumentów wiersza polecenia ............................................... 969 Tryby otwarcia pliku .................................................................................... 971 Dostöp swobodny ....................................................................................... 981 Formatowanie wewnötrzne ................................................................................ 988 Podsumowanie ................................................................................................ 991 Pytania sprawdzajñce ....................................................................................... 992 çwiczenia programistyczne ............................................................................... 993 Rozdziaä 18. Nowy standard C++ ............................................................................ 997 Podsumowanie omawianych elementów C++11 ................................................. 997 Nowe typy .................................................................................................. 997 Jednolita inicjalizacja .................................................................................. 998 Deklaracje ................................................................................................. 999 nullptr ...................................................................................................... 1001 Inteligentne wskaĒniki ............................................................................... 1002 Zmiany w specyfikacji wyjñtków .................................................................. 1002 Jawny zasiög elementów wyliczeþ .............................................................. 1002 Zmiany w klasach ..................................................................................... 1003 Zmiany w szablonach i bibliotece STL ......................................................... 1004 Referencje r-wartoĈciowe ........................................................................... 1006 16 Jözyk C++. Szkoäa programowania Semantyka przeniesienia i referencje r-wartoĈciowe .......................................... 1007 Potrzeba semantyki przeniesienia .............................................................. 1007 Przykäad przenoszenia ............................................................................... 1008 Konstruktor przenoszñcy — wnioski ........................................................... 1013 Przypisania .............................................................................................. 1014 Wymuszanie przeniesienia ........................................................................ 1015 Nowe elementy klas ....................................................................................... 1018 Specjalne metody klas .............................................................................. 1018 Metody domyĈlne i usuniöte ...................................................................... 1019 Delegowanie konstruktorów ....................................................................... 1021 Dziedziczenie konstruktorów ...................................................................... 1021 Zarzñdzanie metodami wirtualnymi: ovverride i final ..................................... 1023 Funkcje lambda ............................................................................................. 1024 WskaĒniki do funkcji, funktory i lambdy ....................................................... 1024 Po co nam lambdy? .................................................................................. 1027 Adaptery ....................................................................................................... 1030 Adapter function a nieefektywnoĈè szablonów ............................................. 1030 Naprawa problemu ................................................................................... 1032 Dalsze moĔliwoĈci .................................................................................... 1034 Szablony o zmiennej liczbie parametrów .......................................................... 1035 Pakiety parametrów szablonu i funkcji ........................................................ 1035 Rozpakowywanie pakietów ........................................................................ 1036 Rekurencja w szablonach o zmiennej liczbie parametrów ............................. 1037 Pozostaäe udogodnienia C++11 ...................................................................... 1040 Programowanie wspóäbieĔne ...................................................................... 1040 Uzupeänienia biblioteki .............................................................................. 1040 Programowanie niskopoziomowe ................................................................ 1041 Inne ........................................................................................................ 1042 Zmiany jözyka ................................................................................................ 1042 Projekt Boost ........................................................................................... 1043 TR1 ......................................................................................................... 1043 Korzystanie z bibliotek Boost ..................................................................... 1043 Co dalej? ...................................................................................................... 1044 Podsumowanie .............................................................................................. 1045 Pytania sprawdzajñce ..................................................................................... 1046 çwiczenia programistyczne ............................................................................. 1049 Dodatek A Systemy liczbowe ............................................................................. 1051 Liczby dziesiötne (o podstawie 10) .................................................................. 1051 Liczby caäkowite ósemkowe (o podstawie 8) ..................................................... 1051 Liczby szesnastkowe ...................................................................................... 1052 Liczby dwójkowe (o podstawie 2) ..................................................................... 1052 Zapis dwójkowy a szesnastkowy ..................................................................... 1053 Dodatek B Säowa zastrzeĔone jözyka C++ .......................................................... 1055 Säowa kluczowe jözyka C++ ............................................................................ 1055 Leksemy alternatywne .................................................................................... 1056 Nazwy zastrzeĔone bibliotek jözyka C++ ........................................................... 1056 Identyfikatory o specjalnym znaczeniu ............................................................. 1057 Spis treĈci 17 Dodatek C Zestaw znaków ASCII ...................................................................... 1059 Dodatek D Priorytety operatorów ....................................................................... 1063 Dodatek E Inne operatory .................................................................................. 1067 Operatory bitowe ........................................................................................... 1067 Operatory przesuniöcia ............................................................................. 1067 Bitowe operatory logiczne .......................................................................... 1069 Alternatywne reprezentacje operatorów bitowych ......................................... 1071 Kilka typowych technik wykorzystujñcych operatory bitowe ........................... 1072 Operatory wyäuskania skäadowych ................................................................... 1073 alignof (C++11) ............................................................................................. 1077 noexcept (C++11) .......................................................................................... 1078 Dodatek F Klasa szablonowa string ................................................................... 1079 TrzynaĈcie typów i staäa .................................................................................. 1080 Informacje o danych, konstruktory i róĔne drobiazgi .......................................... 1080 Konstruktor domyĈlny ............................................................................... 1083 Konstruktory operujñce na klasycznych äaþcuchach C .................................. 1083 Konstruktory operujñce na fragmentach äaþcuchów C .................................. 1084 Konstruktory operujñce na referencji l-wartoĈciowej ..................................... 1084 Konstruktory operujñce na referencji r-wartoĈciowej (C++11) ........................ 1085 Konstruktory wykorzystujñce n kopii znaku .................................................. 1086 Konstruktory wykorzystujñce zakres ........................................................... 1086 Konstruktor operujñcy na liĈcie inicjalizujñcej (C++11) ................................. 1086 Metody zarzñdzajñce pamiöciñ ................................................................... 1087 Dostöp do äaþcucha ....................................................................................... 1087 Proste przypisanie ......................................................................................... 1088 Przeszukiwanie äaþcuchów .............................................................................. 1089 Rodzina funkcji find() ................................................................................ 1089 Rodzina funkcji rfind() ............................................................................... 1089 Rodzina funkcji find_first_of() ..................................................................... 1090 Rodzina funkcji find_last_of() ..................................................................... 1090 Rodzina funkcji find_first_not_of() .............................................................. 1091 Rodzina funkcji find_last_not_of() ............................................................... 1091 Metody i funkcje porównania .......................................................................... 1091 Modyfikatory äaþcuchów ................................................................................. 1093 Metody doäñczania i dodawania ................................................................. 1093 Inne metody przypisania ............................................................................ 1094 Metody wstawiania ................................................................................... 1094 Metody usuwania ..................................................................................... 1095 Metody zastöpowania ............................................................................... 1095 Pozostaäe metody modyfikujñce: copy() oraz swap() ..................................... 1096 WejĈcie i wyjĈcie ............................................................................................ 1096 Dodatek G Metody i funkcje z biblioteki STL ...................................................... 1099 STL a C++11 ................................................................................................. 1099 Nowe kontenery ....................................................................................... 1099 Zmiany w kontenerach C++98 ................................................................... 1100 Skäadowe wspólne dla wszystkich (lub wiökszoĈci) kontenerów .......................... 1101 Dodatkowe skäadowe dla kontenerów sekwencyjnych ........................................ 1104 18 Jözyk C++. Szkoäa programowania Dodatkowe operacje zbiorów i map ................................................................. 1107 Kontenery asocjacyjne nieporzñdkujñce (C++11) .............................................. 1109 Funkcje STL ................................................................................................... 1111 Niemodyfikujñce operacje sekwencyjne ................................
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Język C++. Szkoła programowania. Wydanie VI
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ą: