Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00089 008455 10460871 na godz. na dobę w sumie
Język C++. Szkoła programowania. Wydanie V - książka
Język C++. Szkoła programowania. Wydanie V - książka
Autor: Liczba stron: 1306
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-958-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).

Doskonały podręcznik dla początkujących programistów

C++ to jeden z najpopularniejszych języków programowania, jego możliwości są ogromne. Używa się go do pisania aplikacji narzędziowych, gier, a nawet systemów operacyjnych. Nauka języka C++ jest jednak żmudnym i skomplikowanym procesem -- to prawdziwe wyzwanie dla programistów. Opanowanie potęgi C++ wymaga poznania zasad programowania obiektowego, korzystania z bibliotek i szablonów, obsługi błędów i wyjątków i wielu innych zagadnień. Ale odpowiednio napisany podręcznik, zawierający podstawową wiedzę na temat tego języka, zdecydowanie ułatwi przyswojenie sztuki programowania w C++.

Książka 'Język C++. Szkoła programowania. Wydanie V' to właśnie taki podręcznik. Jego autor Stephen Prata przedstawia C++ w sposób idealnie nadający się dla początkujących programistów chcących opanować tajniki tego języka. Czytając tę książkę, poznasz historię języka C i jego najważniejsze elementy, dowiesz się, czym różni się programowanie proceduralne od obiektowego i jak stosować te dwie techniki, korzystając z C++. Nauczysz się definiować klasy i obiekty, przydzielać zasoby pamięci dla aplikacji, korzystać ze wskaźników i implementować mechanizmy obsługi plików i strumieni wejścia-wyjścia.

Poznaj najważniejsze zasady programowania w 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 Jêzyk C++. Szko³a programowania. Wydanie V Autor: Stephen Prata T³umaczenie: Przemys³aw Steæ (rozdz. 17, dod. A–G), Przemys³aw Szeremiota (rozdz. 9–12), Tomasz Walczak (rozdz. 13–16), Tomasz ¯mijewski (rozdz. wstêp, 1–8) ISBN: 83-7361-958-5 Tytu³ orygina³u: C++ Primer Plus, 5th Edition Format: B5, stron: 1168 Doskona³y podrêcznik dla pocz¹tkuj¹cych programistów (cid:129) Typy danych i konstrukcje steruj¹ce (cid:129) Programowanie proceduralne i obiektowe (cid:129) Biblioteka STL (cid:129) Obs³uga plików C++ to jeden z najpopularniejszych jêzyków programowania, jego mo¿liwoœci s¹ ogromne. U¿ywa siê go do pisania aplikacji narzêdziowych, gier, a nawet systemów operacyjnych. Nauka jêzyka C++ jest jednak ¿mudnym i skomplikowanym procesem — to prawdziwe wyzwanie dla programistów. Opanowanie potêgi C++ wymaga poznania zasad programowania obiektowego, korzystania z bibliotek i szablonów, obs³ugi b³êdów i wyj¹tków i wielu innych zagadnieñ. Ale odpowiednio napisany podrêcznik, zawieraj¹cy podstawow¹ wiedzê na temat tego jêzyka, zdecydowanie u³atwi przyswojenie sztuki programowania w C++. Ksi¹¿ka „Jêzyk C++. Szko³a programowania. Wydanie V” to w³aœnie taki podrêcznik. Jego autor Stephen Prata przedstawia C++ w sposób idealnie nadaj¹cy siê dla pocz¹tkuj¹cych programistów chc¹cych opanowaæ tajniki tego jêzyka. Czytaj¹c tê ksi¹¿kê, poznasz historiê jêzyka C i jego najwa¿niejsze elementy, dowiesz siê, czym ró¿ni siê programowanie proceduralne od obiektowego i jak stosowaæ te dwie techniki, korzystaj¹c z C++. Nauczysz siê definiowaæ klasy i obiekty, przydzielaæ zasoby pamiêci dla aplikacji, korzystaæ ze wskaŸników i implementowaæ mechanizmy obs³ugi plików i strumieni wejœcia-wyjœcia. (cid:129) Kompilatory jêzyka C++ (cid:129) Struktura programu (cid:129) Proste i z³o¿one typy danych (cid:129) Pêtle i instrukcje warunkowe (cid:129) Definiowanie funkcji i korzystanie z nich (cid:129) Model pamiêci w C++ (cid:129) Podstawowe elementy programowania obiektowego — obiekty i klasy (cid:129) Dynamiczne przydzielanie pamiêci (cid:129) Mechanizmy dziedziczenia (cid:129) Obs³uga wyj¹tków (cid:129) Biblioteka STL (cid:129) Operacje wejœcia-wyjœcia Poznaj najwa¿niejsze zasady programowania w C++ SPIS TREŚCI WSTĘP ............................................................................................................................ 1 ROZDZIAŁ 1 Zaczynamy ............................................................................................ 11 Nauka C++ — co nas czeka? ......................................................................................... 11 Pochodzenie języka C++ — krótka historia .................................................................. 12 Język C ...................................................................................................................... 13 Filozofia programowania w C .................................................................................. 13 Zmiana w C++ — programowanie obiektowe ......................................................... 15 C++ i programowanie ogólne ................................................................................... 16 Pochodzenie C++ ...................................................................................................... 16 Przenośność i standardy ................................................................................................. 18 Mechanika tworzenia programu .................................................................................... 20 Pisanie kodu źródłowego .......................................................................................... 21 Kompilacja i konsolidacja ........................................................................................ 22 Podsumowanie ................................................................................................................ 27 ROZDZIAŁ 2 Pierwszy program w C++ ..................................................................... 29 C++ — początek ............................................................................................................ 29 Funkcja main() ......................................................................................................... 31 Komentarze w C++ .................................................................................................. 34 Preprocesor i plik iostream ....................................................................................... 35 Nazwy plików nagłówkowych .................................................................................. 36 Przestrzenie nazw ..................................................................................................... 37 Wypisywanie danych — cout ................................................................................... 38 Formatowanie kodu źródłowego C++ ...................................................................... 41 Instrukcje C++................................................................................................................ 43 Instrukcje deklaracji i zmienne ................................................................................ 43 Instrukcja przypisania .............................................................................................. 45 Nowa sztuczka z cout ............................................................................................... 46 Inne instrukcje C++ ....................................................................................................... 47 Użycie obiektu cin .................................................................................................... 48 Złączanie za pomocą cout ........................................................................................ 48 cin i cout — klasy po raz pierwszy .......................................................................... 49 Funkcje ........................................................................................................................... 51 Użycie funkcji zwracającej wartość .......................................................................... 51 Odmiany funkcji ....................................................................................................... 55 Funkcje definiowane przez użytkownika ................................................................. 55 Funkcje użytkownika zwracające wartość................................................................ 59 Dyrektywa using w programach z wieloma funkcjami ............................................ 61 Podsumowanie ................................................................................................................ 63 Pytania sprawdzające ..................................................................................................... 63 Ćwiczenia programistyczne ........................................................................................... 64 ROZDZIAŁ 3 Dane ...................................................................................................... 67 Zmienne proste ............................................................................................................... 68 Nazwy zmiennych .................................................................................................... 68 Typy całkowitoliczbowe............................................................................................ 70 Typy short, int i long ................................................................................................ 70 Typy bez znaku ......................................................................................................... 75 Dobór właściwego typu............................................................................................. 78 Stałe całkowitoliczbowe ........................................................................................... 79 Jak C++ ustala typ stałej? ......................................................................................... 81 Typ char — znaki i małe liczby całkowite ............................................................... 81 Typ danych bool ........................................................................................................ 89 Kwalifikator const .......................................................................................................... 90 Liczby zmiennoprzecinkowe .......................................................................................... 91 Zapis liczb zmiennoprzecinkowych ......................................................................... 92 Zmiennoprzecinkowe typy danych ........................................................................... 93 Stałe zmiennoprzecinkowe ....................................................................................... 96 Zalety i wady liczb zmiennoprzecinkowych ............................................................ 96 Operatory arytmetyczne C++ ......................................................................................... 97 Kolejność działań — priorytety operatorów i łączność ........................................... 99 Odmiany dzielenia .................................................................................................. 100 Operator modulo ..................................................................................................... 102 Konwersje typów .................................................................................................... 103 Podsumowanie .............................................................................................................. 109 Pytania sprawdzające ................................................................................................... 110 Ćwiczenia programistyczne ......................................................................................... 110 ROZDZIAŁ 4 Typy złożone ....................................................................................... 113 Tablice w skrócie .......................................................................................................... 114 Uwagi o programie ................................................................................................. 116 Inicjalizacja tablic ................................................................................................... 117 Łańcuchy ...................................................................................................................... 118 Łączenie stałych łańcuchowych ............................................................................. 120 Łańcuchy w tablicy ................................................................................................. 120 Problemy z wprowadzaniem łańcuchów znakowych ............................................. 122 Wczytywanie łańcuchów znakowych wierszami ................................................... 124 Mieszanie w danych wejściowych łańcuchów i liczb ............................................ 128 Klasa string — wprowadzenie ..................................................................................... 130 Przypisanie, konkatenacja i dołączanie.................................................................. 131 Inne operacje klasy string ....................................................................................... 133 Klasa string a wejście i wyjście .............................................................................. 135 Struktury ....................................................................................................................... 137 Użycie struktury w programie ................................................................................ 139 Czy w strukturze można użyć pola typu string? .................................................... 142 Inne cechy struktur ................................................................................................. 142 Tablice struktur ....................................................................................................... 144 Pola bitowe.............................................................................................................. 145 Unie .............................................................................................................................. 146 VIII Typy wyliczeniowe ....................................................................................................... 148 Ustawianie wartości enumeratorów ....................................................................... 150 Zakresy wartości w typach wyliczeniowych ........................................................... 150 Wskaźniki i różne drobiazgi ........................................................................................ 151 Deklarowanie i inicjalizacja wskaźników .............................................................. 154 Niebezpieczeństwa związane ze wskaźnikami ...................................................... 157 Wskaźniki i liczby .................................................................................................. 157 Użycie operatora new do alokowania pamięci ....................................................... 158 Zwalnianie pamięci za pomocą delete ................................................................... 160 Użycie new do tworzenia tablic dynamicznych ..................................................... 161 Wskaźniki, tablice i arytmetyka wskaźników .............................................................. 164 Uwagi o programie ................................................................................................. 166 Wskaźniki i łańcuchy ............................................................................................. 170 Użycie new do tworzenia struktur dynamicznych ................................................. 175 Alokacja pamięci: automatyczna, statyczna i dynamiczna .................................... 179 Podsumowanie .............................................................................................................. 181 Pytania sprawdzające ................................................................................................... 182 Ćwiczenia programistyczne ......................................................................................... 183 ROZDZIAŁ 5 Pętle i wyrażenia relacyjne ................................................................. 185 Pętle for ........................................................................................................................ 186 Elementy pętli for ................................................................................................... 187 Wracamy do pętli for .............................................................................................. 194 Zmiana wielkości kroku ......................................................................................... 195 Pętla for i łańcuchy znakowe .................................................................................. 196 Operatory inkrementacji (++) i dekrementacji (--) ................................................ 197 Efekty uboczne i punkty odniesienia ...................................................................... 199 Formy przedrostkowe a formy przyrostkowe ......................................................... 199 Operatory inkrementacji i dekrementacji a wskaźniki .......................................... 200 Złożone operatory przypisania ............................................................................... 201 Instrukcje złożone czyli bloki ................................................................................. 202 Przecinek jako operator (i pewne sztuczki składniowe) ........................................ 204 Wyrażenia relacyjne ..................................................................................................... 207 Bardzo typowy błąd ................................................................................................ 208 Porównywanie łańcuchów w stylu C ...................................................................... 211 Porównywanie łańcuchów klasy string .................................................................. 213 Pętla while .................................................................................................................... 215 Uwagi o programie ................................................................................................. 216 Pętla for a pętla while ............................................................................................. 217 Chwileczkę — tworzymy pętlę opóźnienia ............................................................ 219 Pętla do while ............................................................................................................... 221 Pętle i wprowadzanie danych tekstowych .................................................................... 224 Najprostsza wersja cin ............................................................................................ 224 cin.get(char) na odsiecz .......................................................................................... 225 Która cin.get()? ....................................................................................................... 227 IX Koniec pliku ........................................................................................................... 227 Jeszcze inna wersja cin.get() .................................................................................. 231 Pętle zagnieżdżone i dwuwymiarowe tablice............................................................... 234 Inicjalizacja tablic dwuwymiarowych .................................................................... 236 Podsumowanie .............................................................................................................. 238 Pytania sprawdzające ................................................................................................... 239 Ćwiczenia programistyczne ......................................................................................... 230 ROZDZIAŁ 6 Instrukcje warunkowe i operatory logiczne........................................ 243 Instrukcja if .................................................................................................................. 243 Instrukcja if else...................................................................................................... 245 Formatowanie instrukcji if else .............................................................................. 247 Konstrukcja if else if else ....................................................................................... 248 Wyrażenia logiczne ...................................................................................................... 250 Logiczny operator alternatywy — || ....................................................................... 250 Logiczny operator koniunkcji — .................................................................... 252 Operator negacji logicznej — ! .............................................................................. 257 O operatorach logicznych ....................................................................................... 259 Zapis alternatywny ................................................................................................. 260 Biblioteka cctype .......................................................................................................... 261 Operator ?: .................................................................................................................... 263 Instrukcja switch .......................................................................................................... 265 Użycie enumeratorów jako etykiet ......................................................................... 269 switch versus if else ................................................................................................ 270 Instrukcje break i continue ........................................................................................... 270 Uwagi o programie ................................................................................................. 272 Pętle wczytywania liczb ............................................................................................... 273 Uwagi o programie ................................................................................................. 277 Proste wejście-wyjście z pliku ...................................................................................... 277 Tekstowe wejście-wyjście i pliki tekstowe.............................................................. 277 Zapis do pliku tekstowego ...................................................................................... 279 Odczyt danych z pliku tekstowego ......................................................................... 283 Podsumowanie .............................................................................................................. 288 Pytania sprawdzające ................................................................................................... 289 Ćwiczenia programistyczne ......................................................................................... 291 ROZDZIAŁ 7 Funkcje — składniki programów w C++ ........................................... 295 Funkcje w skrócie ......................................................................................................... 295 Definiowanie funkcji .............................................................................................. 296 Prototypowanie i wywoływanie funkcji .................................................................. 299 Parametry funkcji i przekazywanie przez wartość ...................................................... 302 Wiele parametrów ................................................................................................... 304 Jeszcze jedna funkcja dwuargumentowa ................................................................ 306 Funkcje i tablice ........................................................................................................... 309 Jak wskaźniki umożliwiają tworzenie funkcji przetwarzających tablice? ............. 310 Skutki użycia tablic jako parametrów .................................................................... 311 X Dodatkowe przykłady funkcji i tablic..................................................................... 314 Funkcje korzystające z zakresów tablic .................................................................. 320 Wskaźniki i modyfikator const............................................................................... 322 Funkcje i tablice dwuwymiarowe ................................................................................. 325 Funkcje i łańcuchy w stylu C ....................................................................................... 327 Funkcje z łańcuchami w stylu C jako parametrami ............................................... 327 Funkcje zwracające łańcuchy w formacie C .......................................................... 329 Funkcje i struktury ....................................................................................................... 331 Przekazywanie i zwracanie struktur ....................................................................... 332 Inny przykład użycia funkcji i struktur .................................................................. 334 Przekazywanie adresu struktury ............................................................................. 339 Funkcje i obiekty klasy string ...................................................................................... 341 Rekurencja .................................................................................................................... 343 Rekurencja w pojedynczym wywołaniu ................................................................. 343 Rekurencja w wielu wywołaniach .......................................................................... 345 Wskaźniki na funkcje ................................................................................................... 347 Wskaźniki na funkcje — podstawy ........................................................................ 347 Przykład użycia wskaźników na funkcje ................................................................ 350 Podsumowanie .............................................................................................................. 351 Pytania sprawdzające ................................................................................................... 352 Ćwiczenia programistyczne ......................................................................................... 353 ROZDZIAŁ 8 Funkcje — zagadnienia zaawansowane ............................................. 357 Funkcje inline ............................................................................................................... 357 Zmienne referencyjne ................................................................................................... 361 Tworzenie zmiennej referencyjnej.......................................................................... 361 Referencje jako parametry funkcji.......................................................................... 364 Właściwości referencji ............................................................................................ 368 Ostrożnie ze zwracaniem referencji ....................................................................... 375 Użycie referencji z obiektami ................................................................................. 376 Obiekty po raz wtóry — obiekty, dziedziczenie i referencje.................................. 380 Kiedy korzystać z referencji jako parametrów? ..................................................... 383 Parametry domyślne ..................................................................................................... 384 Uwagi o programie ................................................................................................. 387 Przeciążanie funkcji ..................................................................................................... 387 Przykład przeciążania funkcji ................................................................................ 390 Kiedy korzystać z przeciążania funkcji? ................................................................ 392 Szablony funkcji ........................................................................................................... 393 Przeciążone szablony .............................................................................................. 397 Specjalizacje jawne ................................................................................................. 399 Tworzenie egzemplarzy i specjalizacje .................................................................. 404 Którą wersję funkcji kompilator wybierze? ........................................................... 406 Podsumowanie .............................................................................................................. 412 Pytania sprawdzające ................................................................................................... 413 Ćwiczenia programistyczne ......................................................................................... 414 XI ROZDZIAŁ 9 Model pamięci i przestrzenie nazw .................................................... 417 Kompilacja rozłączna ................................................................................................... 417 Czas życia, zasięg i łączenie ........................................................................................ 424 Zasięg i łączenie ..................................................................................................... 425 Przydział automatyczny .......................................................................................... 425 Zmienne statyczne .................................................................................................. 431 Specyfikatory i kwalifikatory.................................................................................. 443 Łączenie a funkcje .................................................................................................. 445 Łączenie językowe .................................................................................................. 446 Kategorie przydziału a przydział dynamiczny ....................................................... 447 Miejscowa wersja operatora new ................................................................................. 448 O programie ............................................................................................................ 451 Przestrzenie nazw......................................................................................................... 452 Tradycyjne przestrzenie nazw języka C++............................................................. 452 Nowe mechanizmy przestrzeni nazw ..................................................................... 454 Przestrzenie nazw — przykład ............................................................................... 463 Przyszłość przestrzeni nazw ................................................................................... 468 Podsumowanie .............................................................................................................. 468 Pytania sprawdzające ................................................................................................... 469 Ćwiczenia programistyczne ......................................................................................... 473 ROZDZIAŁ 10 Obiekty i klasy .................................................................................. 477 Programowanie proceduralne a programowanie obiektowe ........................................ 478 Klasy a abstrakcje ......................................................................................................... 479 Czym jest typ?......................................................................................................... 479 Klasy w języku C++ ............................................................................................... 480 Implementowanie metod klas ................................................................................. 485 Stosowanie klas ...................................................................................................... 491 Podsumowanie poznanych wiadomości ................................................................. 495 Konstruktory i destruktory ........................................................................................... 496 Deklarowanie i definiowanie konstruktorów ......................................................... 497 Stosowanie konstruktorów...................................................................................... 499 Konstruktory domyślne .......................................................................................... 500 Destruktory ............................................................................................................. 501 Ulepszenia klasy Stock ........................................................................................... 502 Konstruktory i destruktory — podsumowanie ....................................................... 511 Tożsamość obiektu — wskaźnik this ........................................................................... 512 Tablice obiektów ........................................................................................................... 519 Jeszcze o interfejsach i implementacji ......................................................................... 522 Zasięg klasy ............................................................................................................ 524 Stałe zasięgu klasy ....................................................................................................... 525 Abstrakcyjne typy danych ............................................................................................ 527 Podsumowanie .............................................................................................................. 533 Pytania sprawdzające ................................................................................................... 534 Ćwiczenia programistyczne ......................................................................................... 534 XII ROZDZIAŁ 11 Stosowanie klas ................................................................................. 539 Przeciążanie operatorów .............................................................................................. 540 Raz, dwa, trzy — próba przeciążenia operatora .......................................................... 541 Dodatkowy operator dodawania ............................................................................. 545 Ograniczenia przeciążania operatorów .................................................................. 549 Jeszcze o przeciążaniu operatorów ......................................................................... 551 Przyjaciele najważniejsi ............................................................................................... 554 Deklarowanie przyjaźni .......................................................................................... 556 Typowa przyjaźń — przeciążanie operatora .................................................... 557 Przeciążanie operatorów — metody kontra funkcje nieskładowe ............................... 565 Przeciążania ciąg dalszy — klasa Vector..................................................................... 566 Składowa kodująca stan obiektu............................................................................. 575 Przeciążanie operatorów arytmetycznych dla klasy Vector ................................... 577 Nota implementacyjna ............................................................................................ 580 Wektorowe błądzenie losowe .................................................................................. 580 Automatyczne konwersje i rzutowanie typów klas ...................................................... 585 O programie ............................................................................................................ 590 Funkcje konwersji ................................................................................................... 591 Konwersja a zaprzyjaźnienie .................................................................................. 597 Podsumowanie .............................................................................................................. 601 Pytania sprawdzające ................................................................................................... 603 Ćwiczenia programistyczne ......................................................................................... 603 ROZDZIAŁ 12 Klasy a dynamiczny przydział pamięci ............................................ 607 Klasy a pamięć dynamiczna ......................................................................................... 608 Powtórka z pamięci dynamicznej i statyczne składowe klas ................................. 608 Niejawne metody klasy ........................................................................................... 618 Nowa, ulepszona klasa — String ........................................................................... 628 O czym należy pamiętać, stosując new w konstruktorach? ................................... 641 Słów parę o zwracaniu obiektów ............................................................................ 643 Wskaźniki obiektów ............................................................................................... 647 Powtórka z poznanych technik ............................................................................... 659 Symulacja kolejki ......................................................................................................... 661 Klasa kolejki ........................................................................................................... 662 Klasa klienta ........................................................................................................... 673 Symulacja................................................................................................................ 677 Podsumowanie .............................................................................................................. 682 Pytania sprawdzające ................................................................................................... 684 Ćwiczenia programistyczne ......................................................................................... 686 ROZDZIAŁ 13 Klasy i dziedziczenie ........................................................................ 691 Prosta klasa bazowa ..................................................................................................... 692 Dziedziczenie.......................................................................................................... 694 Konstruktory — zagadnienia związane z poziomem dostępu ............................... 696 Korzystanie z klasy pochodnej ............................................................................... 699 Relacje między klasą pochodną a bazową .............................................................. 702 XIII Dziedziczenie — relacja jest-czymś ............................................................................ 705 Polimorficzne dziedziczenie publiczne ........................................................................ 706 Tworzenie klas Brass oraz BrassPlus ..................................................................... 707 Wiązanie statyczne i dynamiczne........................................................................... 721 Zgodność typów wskaźnikowych i referencyjnych ................................................ 721 Wirtualne funkcje składowe i wiązanie dynamiczne ............................................. 723 Co trzeba wiedzieć o metodach wirtualnych? ........................................................ 726 Kontrola dostępu — poziom chroniony ....................................................................... 729 Abstrakcyjne klasy bazowe .......................................................................................... 732 Stosowanie abstrakcyjnych klas bazowych ............................................................ 735 Filozofia abstrakcyjnych klas bazowych ................................................................ 740 Dziedziczenie i dynamiczny przydział pamięci .......................................................... 740 Przypadek pierwszy — klasa pochodna bez dynamicznego przydziału pamięci........ 740 Przypadek drugi — klasa pochodna z dynamicznym przydziałem pamięci ......... 742 Przykład dziedziczenia z wykorzystaniem dynamicznego przydziału pamięci oraz funkcji zaprzyjaźnionych ........................................................................................ 744 Projektowanie klas — przegląd zagadnień .................................................................. 750 Funkcje składowe automatycznie generowane przez kompilator .......................... 750 Inne metody ............................................................................................................ 754 Dziedziczenie publiczne ......................................................................................... 756 Funkcje klasy — podsumowanie ............................................................................ 761 Podsumowanie .............................................................................................................. 762 Pytania sprawdzające ................................................................................................... 762 Ćwiczenia ..................................................................................................................... 764 ROZDZIAŁ 14 Wielokrotne użycie kodu w C++ ...................................................... 767 Klasy ze składowymi w postaci obiektów .................................................................... 768 Krótka charakterystyka klasy valarray ................................................................... 768 Projekt klasy Student .............................................................................................. 769 Przykładowa klasa Student ..................................................................................... 771 Dziedziczenie prywatne ............................................................................................... 779 Nowa wersja klasy Student ..................................................................................... 780 Dziedziczenie wielokrotne ........................................................................................... 792 Podwójne egzemplarze klasy Worker ..................................................................... 798 Podwójne metody .................................................................................................... 802 Przegląd zagadnień związanych z dziedziczeniem wielokrotnym ........................ 814 Szablony klas ................................................................................................................ 815 Definiowanie szablonu klasy .................................................................................. 815 Korzystanie z szablonu klasy ................................................................................. 819 Analiza szablonu klasy ........................................................................................... 822 Szablon tablicy i argumenty niebędące typami ...................................................... 828 Elastyczność szablonów.......................................................................................... 831 Specjalizacja szablonu ............................................................................................ 835 Szablony jako składowe .......................................................................................... 838 Szablony jako parametry ........................................................................................ 841 XIV Szablony klas i zaprzyjaźnienie ............................................................................. 844 Podsumowanie .............................................................................................................. 852 Pytania sprawdzające ................................................................................................... 854 Ćwiczenia programistyczne ......................................................................................... 856 ROZDZIAŁ 15 Zaprzyjaźnienie, wyjątki i nie tylko ................................................. 863 Zaprzyjaźnienie ............................................................................................................ 863 Klasy zaprzyjaźnione .............................................................................................. 864 Zaprzyjaźnione funkcje składowe .......................................................................... 869 Inne relacje przyjaźni ............................................................................................. 873 Klasy zagnieżdżone ...................................................................................................... 875 Dostęp do klas zagnieżdżonych ............................................................................. 877 Zagnieżdżanie w szablonie ..................................................................................... 879 Wyjątki.......................................................................................................................... 883 Wywoływanie funkcji abort() ................................................................................. 884 Zwracanie kodu błędu ............................................................................................ 885 Mechanizm wyjątków ............................................................................................. 887 Wyjątki w postaci obiektów .................................................................................... 891 Rozwijanie stosu ..................................................................................................... 895 Inne właściwości wyjątków .................................................................................... 901 Klasa exception....................................................................................................... 904 Wyjątki, klasy i dziedziczenie ................................................................................ 909 Problemy z wyjątkami ............................................................................................ 915 Ostrożnie z wyjątkami ............................................................................................ 918 RTTI ............................................................................................................................. 920 Po co nam RTTI? .................................................................................................... 920 Jak działa RTTI? ..................................................................................................... 921 Operatory rzutowania typu ........................................................................................... 930 Podsumowanie .............................................................................................................. 934 Pytania sprawdzające ................................................................................................... 935 Ćwiczenia programistyczne ......................................................................................... 937 ROZDZIAŁ 16 Klasa string oraz biblioteka STL ...................................................... 939 Klasa string .................................................................................................................. 939 Tworzenie obiektu string ........................................................................................ 940 Wprowadzanie danych do obiektów string ............................................................ 944 Używanie obiektów string ...................................................................................... 947 Co jeszcze oferuje klasa string?.............................................................................. 953 Klasa auto_ptr .............................................................................................................. 956 Używanie obiektów klasy auto_ptr ......................................................................... 957 Zagadnienia związane z klasą auto_ptr ................................................................. 960 Biblioteka STL ............................................................................................................. 961 Szablon klasy vector ............................................................................................... 962 Metody klasy vector ................................................................................................ 965 Inne możliwości klasy vector ................................................................................. 970 Programowanie generyczne ......................................................................................... 975 XV Do czego potrzebne są iteratory? ............................................................................ 975 Rodzaje iteratorów .................................................................................................. 979 Hierarchia iteratorów .............................................................................................. 983 Pojęcia, uściślenia i modele .................................................................................... 984 Rodzaje kontenerów ............................................................................................... 991 Kontenery asocjacyjne .......................................................................................... 1002 Obiekty funkcyjne (funktory) ..................................................................................... 1009 Pojęcia związane z funktorami ............................................................................. 1011 Funktory predefiniowane ...................................................................................... 1014 Funktory adaptowalne i adaptatory funkcji .......................................................... 1016 Algorytmy ................................................................................................................... 1019 Grupy algorytmów ................................................................................................ 1019 Ogólne właściwości algorytmów .......................................................................... 1020 Biblioteka STL i klasa string ................................................................................ 1022 Funkcje a metody kontenerów .............................................................................. 1023 Używanie biblioteki STL ...................................................................................... 1025 Inne biblioteki ............................................................................................................ 1029 Klasy vector oraz valarray .................................................................................... 1030 Podsumowanie ............................................................................................................ 1036 Pytania sprawdzające ................................................................................................. 1038 Ćwiczenia programistyczne ....................................................................................... 1039 ROZDZIAŁ 17 Obsługa wejścia, wyjścia oraz plików ............................................ 1041 Ogólna charakterystyka obsługi wejścia-wyjścia w języku C++ ............................... 1042 Strumienie i bufory ............................................................................................... 1043 Strumienie i bufory a plik iostream...................................................................... 1045 Przekierowanie ..................................................................................................... 1047 Realizacja operacji wyjścia z wykorzystaniem obiektu cout ..................................... 1048 Przeciążony operator ....................................................................................... 1049 Inne metody klasy ostream ................................................................................... 1052 Opróżnianie bufora wyjściowego ......................................................................... 1055 Formatowanie danych wyjściowych za pomocą obiektu cout .............................. 1056 Realizacja operacji wejścia z wykorzystaniem obiektu cin ....................................... 1075 Jak operator obiektu cin „widzi” dane wejściowe .......................................... 1077 Stany strumienia ................................................................................................... 1079 Inne metody klasy istream .................................................................................... 1084 Pozostałe metody klasy istream ............................................................................ 1093 Wejście-wyjście plikowe ............................................................................................. 1098 Proste operacje wejścia-wyjścia plikowego .......................................................... 1098 Kontrola strumienia i metoda is_open() .............................................................. 1102 Otwieranie wielu plików ...................................................................................... 1103 Przetwarzanie argumentów wiersza polecenia .................................................... 1104 Tryby otwarcia pliku ............................................................................................. 1107 Dostęp swobodny .................................................................................................. 1118 Formatowanie wewnętrzne ........................................................................................ 1128 XVI I co dalej? ................................................................................................................... 1130 Podsumowanie ............................................................................................................ 1131 Pytania sprawdzające ................................................................................................. 1133 Ćwiczenia programistyczne ....................................................................................... 1134 DODATEK A Systemy liczbowe ............................................................................... 1139 Liczby dziesiętne (o podstawie 10) ............................................................................ 1139 Liczby całkowite ósemkowe (o podstawie 8) ............................................................. 1139 Liczby szesnastkowe .................................................................................................. 1140 Liczby dwójkowe (o podstawie 2) .............................................................................. 1141 Zapis dwójkowy a szesnastkowy ................................................................................ 1141 DODATEK B Słowa zastrzeżone języka C++ .......................................................... 1145 Słowa kluczowe języka C++ ...................................................................................... 1145 Leksemy alternatywne ................................................................................................ 1146 Nazwy zastrzeżone bibliotek języka C++ .................................................................. 1146 DODATEK C Zestaw znaków ASCII ....................................................................... 1149 DODATEK D Priorytety operatorów ........................................................................ 1155 DODATEK E Inne operatory .................................................................................... 1159 Operatory bitowe ........................................................................................................ 1159 Operatory przesunięcia ......................................................................................... 1159 Bitowe operatory logiczne .................................................................................... 1161 Alternatywne reprezentacje operatorów bitowych ............................................... 1164 Kilka typowych technik wykorzystujących operatory bitowe .............................. 1164 Operatory dereferencji składowych ............................................................................ 1166 DODATEK F Klasa szablonowa string .................................................................... 1171 Trzynaście typów i stała ............................................................................................. 1172 Informacje o danych, konstruktory i różne drobiazgi................................................ 1173 Konstruktory domyślne ........................................................................................ 1175 Konstruktory wykorzystujące tablice.................................................................... 1175 Konstruktory wykorzystujące fragment tablicy .................................................... 1176 Konstruktory kopiujące ........................................................................................ 1176 Konstruktory wykorzystujące n kopii znaku ........................................................ 1177 Konstruktory wykorzystujące zakres .................................................................... 1178 Metody zarządzające pamięcią ............................................................................. 1178 Dostęp do łańcucha .................................................................................................... 1179 Proste przypisanie ...................................................................................................... 1180 Przeszukiwanie łańcuchów ........................................................................................ 1180 Rodzina funkcji find() .......................................................................................... 1180 Rodzina funkcji rfind() ......................................................................................... 1181 Rodzina funkcji find_first_of()............................................................................. 1182 Rodzina funkcji find_last_of() ............................................................................. 1182 Rodzina funkcji find_first_not_of() ..................................................................... 1183 Rodzina funkcji find_last_not_of() ...................................................................... 1183 XVII Metody i funkcje porównania..................................................................................... 1184 Modyfikatory łańcuchów ............................................................................................ 1185 Metody dołączania i dodawania ........................................................................... 1185 Inne metody przypisania ...................................................................................... 1186 Metody wstawiania ............................................................................................... 1187 Metody usuwania .................................................................................................. 1188 Metody zastępowania ........................................................................................... 1188 Pozostałe metody modyfikujące: copy() oraz swap() ........................................... 1189 Wejście i wyjście ......................................................................................................... 1189 DODATEK G Metody i funkcje z biblioteki STL .................................................... 1191 Składowe wspólne dla wszystkich kontenerów ......................................................... 1191 Dodatkowe składowe wektorów, list i kolejek dwustronnych ................................... 1194 Dodatkowe składowe zbiorów i map.......................................................................... 1197 Funkcje STL ............................................................................................................... 1198 Niemodyfikujące operacje sekwencyjne ............................................................... 1199 Mutujące operacje sekwencyjne ........................................................................... 1203 Operacje sortowania i pokrewne .......................................................................... 1211 Operacje liczbowe ................................................................................................. 1224 DODATEK H Wybrane pozycje książkowe i zasoby internetowe ........................... 1227 Wybrane pozycje książkowe ....................................................................................... 1227 Zasoby internetowe..................................................................................................... 1229 DODATEK I Dostosowywanie do standardu ANSI/ISO C++ ................................. 1231 Stosuj rozwiązania alternatywne zamiast niektórych dyrektyw preprocesora .......... 1231 Do definiowania stałych używaj modyfikatora const zamiast dyrektywy #define .......................... 1231 Do definiowania niewielkich funkcji używaj specyfikatora inline zamiast makrodefinicji #define ... 1233 Używaj prototypów funkcji ........................................................................................ 1234 Stosuj rzutowanie typów ............................................................................................ 1235 Poznaj i wykorzystuj mechanizmy języka C++ ......................................................... 1236 Używaj nowej organizacji plików nagłówkowych ..................................................... 1236 Korzystaj z przestrzeni nazw ..................................................................................... 1236 Używaj szablonu autoptr ............................................................................................ 1237 Używaj klasy string .................................................................................................... 1238 Korzystaj z biblioteki STL ......................................................................................... 1238 DODATEK J Odpowiedzi do pytań kontrolnych ..................................................... 1241 Odpowiedzi do pytań z rozdziału 2 ........................................................................... 1241 Odpowiedzi do pytań z rozdziału 3 ........................................................................... 1242 Odpowiedzi do pytań z rozdziału 4 ........................................................................... 1243 Odpowiedzi do pytań z rozdziału 5 ........................................................................... 1244 Odpowiedzi do pytań z rozdziału 6 ........................................................................... 1245 Odpowiedzi do pytań z rozdziału 7 ........................................................................... 1247 Odpowiedzi do pytań z rozdziału 8 ........................................................................... 1249 Odpowiedzi do pytań z rozdziału 9 ........................................................................... 1250 Odpowiedzi do pytań z rozdziału 10 ......................................................................... 1252 XVIII Odpowiedzi do pytań z rozdziału 11.......................................................................... 1254 Odpowiedzi do pytań z rozdziału 12 ......................................................................... 1255 Odpowiedzi do pytań z rozdziału 13 ......................................................................... 1258 Odpowiedzi do pytań z rozdziału 14 ......................................................................... 1260 Odpowiedzi do pytań z rozdziału 15 ......................................................................... 1261 Odpowiedzi do pytań z rozdziału 16 ......................................................................... 1263 Odpowiedzi do pytań z rozdziału 17 ......................................................................... 1264 INDEKS ..................................................................................................................... 1267 XIX Rozdzia³ 2 Pierwszy program w C++ W rozdziale zajmiemy siê nastêpuj¹cymi zagadnieniami: • Tworzenie programu w C++. • Ogólna postaæ programu w C++. • Dyrektywa #include. • Funkcja main(). • U¿ycie obiektu cout do wyprowadzania danych. • Komentarze w programach C++. • U¿ycie endl. • Deklarowanie i u¿ycie z
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

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