Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00032 003678 21342109 na godz. na dobę w sumie
wyszukaj dokładnie | pobierz wtyczkę
C++ bez obaw - książka
C++ bez obaw - książka
Autor: Liczba stron: 520
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0410-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).
Czytaj online.
Komentuj

Rozpocznij przygodę z programowaniem

C++ to język programowania wykorzystywany do wielu zadań. Programiści stosują go do tworzenia aplikacji użytkowych, gier, a nawet części systemów operacyjnych. Może więc wydawać się, że opanowanie zasad programowania w tym języku przekracza możliwości przeciętnego człowieka. Tak jednak nie jest -- programowanie to nie wiedza tajemna, dostępna jedynie dla wybranych, a programiści znający C++ nie są nadludźmi. Z odpowiednią pomocą można bez kłopotów zdobyć wiedzę o wszystkich sztuczkach i ciekawostkach C++, a nauka programowania w tym języku nie powinna sprawić Ci problemów.

Książka 'C++ bez obaw' może być Twoim asystentem, gdy będziesz się uczył programowania w języku C++. Dzięki niej przekonasz się, że opanowanie tej sztuki leży w Twoim zasięgu. Znajdziesz w niej omówienie elementów C++ zilustrowane praktycznymi przykładami. Dowiesz się, z czego zbudowany jest program w C++ i jak sprawić, aby kod źródłowy stał się aplikacją możliwą do uruchomienia na Twoim komputerze. Przeczytasz o przetwarzaniu danych, operacjach na plikach, sortowaniu, obliczeniach matematycznych i programowaniu obiektowym. Poznasz wiele przydatnych zagadnień związanych z tworzeniem oprogramowania.

Poszerz swoje możliwości, programuj w języku 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. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl C++ bez obaw Autor: Brian Overland T³umaczenie: £ukasz Suma ISBN: 83-246-0410-3 Tytu³ orygina³u: C++ Without Fear: A Beginners Guide That Makes You Feel Smart Format: B5, stron: 520 Rozpocznij przygodê z programowaniem (cid:129) Poznaj elementy jêzyka C++. (cid:129) Naucz siê przetwarzaæ dane tekstowe i liczbowe. (cid:129) Opanuj zasady programowania obiektowego. C++ to jêzyk programowania wykorzystywany do wielu zadañ. Programiœci stosuj¹ go do tworzenia aplikacji u¿ytkowych, gier, a nawet czêœci systemów operacyjnych. Mo¿e wiêc wydawaæ siê, ¿e opanowanie zasad programowania w tym jêzyku przekracza mo¿liwoœci przeciêtnego cz³owieka. Tak jednak nie jest — programowanie to nie wiedza tajemna, dostêpna jedynie dla wybranych, a programiœci znaj¹cy C++ nie s¹ nadludŸmi. Z odpowiedni¹ pomoc¹ mo¿na bez k³opotów zdobyæ wiedzê o wszystkich sztuczkach i ciekawostkach C++, a nauka programowania w tym jêzyku nie powinna sprawiæ Ci problemów. Ksi¹¿ka „C++ bez obaw” mo¿e byæ Twoim asystentem, gdy bêdziesz siê uczy³ programowania w jêzyku C++. Dziêki niej przekonasz siê, ¿e opanowanie tej sztuki le¿y w Twoim zasiêgu. Znajdziesz w niej omówienie elementów C++ zilustrowane praktycznymi przyk³adami. Dowiesz siê, z czego zbudowany jest program w C++ i jak sprawiæ, aby kod Ÿród³owy sta³ siê aplikacj¹ mo¿liw¹ do uruchomienia na Twoim komputerze. Przeczytasz o przetwarzaniu danych, operacjach na plikach, sortowaniu, obliczeniach matematycznych i programowaniu obiektowym. Poznasz wiele przydatnych zagadnieñ zwi¹zanych z tworzeniem oprogramowania. (cid:129) Struktura programu w C++ (cid:129) Wyœwietlanie danych na ekranie (cid:129) Typy danych (cid:129) Pêtle i instrukcje warunkowe (cid:129) Korzystanie ze wskaŸników (cid:129) Operacje na plikach (cid:129) Programowanie obiektowe Poszerz swoje mo¿liwoœci, programuj w jêzyku C++ Wstęp ............................................................................................ 13 Po co nowa książka o języku C++? ..................................................................................13 Co nowego jest jeszcze w tej książce? .............................................................................14 Wiele ścieżek nauczania. Co jest dla Ciebie najlepsze? ..................................................15 A co, jeśli masz już pewne podstawowe wiadomości na temat programowania? ...........16 Czego w tej książce nie ma? ............................................................................................16 Dlaczego warto zaczynać naukę języka C++? .................................................................17 Aby rozpocząć… ..............................................................................................................18 Sztuczki i chwyty. Na co powinieneś uważać? ................................................................19 Rozdział 1. Twoje pierwsze programy w C++ ..................................................... 21 Myśleć jak programista ....................................................................................................21 Komputery robią tylko to, co im każesz ....................................................................21 Określanie, co ma robić program ...............................................................................22 Pisanie odpowiednich wyrażeń C++ ..........................................................................23 Przegląd kilku specjalistycznych definicji .................................................................24 Co wyróżnia język C++? ..................................................................................................27 Ciekawostka — Co z Javą i C#? ................................................................................28 Tworzenie programu w języku C++ ................................................................................29 Wprowadzanie wyrażeń tworzących program ...........................................................30 Budowanie programu (kompilowanie i łączenie) ......................................................30 Testowanie programu .................................................................................................31 Poprawianie w miarę potrzeby ...................................................................................32 Instalowanie Twojego własnego kompilatora ..................................................................33 Przykład 1.1. Wyświetlanie komunikatu ..........................................................................33 Jeśli używasz środowiska RHIDE .............................................................................34 Jeśli używasz Microsoft Visual Studio ......................................................................35 Jak to działa? ..............................................................................................................36 Ćwiczenia ...................................................................................................................37 Ciekawostka — Co z wyrażeniami #include i using? ................................................38 Przechodzenie do kolejnej linii wyświetlania ..................................................................39 Przykład 1.2. Wyświetlanie wielu linii ............................................................................39 Jak to działa? ..............................................................................................................40 Ćwiczenia ...................................................................................................................41 Ciekawostka — Co to jest łańcuch tekstowy? ............................................................42 Przechowywanie danych — zmienne w C++ ..................................................................42 Wprowadzenie do typów danych .....................................................................................44 Ciekawostka — Dlaczego podwójna precyzja zamiast pojedynczej? ........................45 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc 5 6 C++ bez obaw Przykład 1.3. Konwertowanie temperatur ........................................................................46 Jak to działa? ..............................................................................................................47 Wariacje na temat przykładu .....................................................................................49 Ćwiczenia ...................................................................................................................51 Słowo na temat nazw zmiennych i słów kluczowych ......................................................51 Ćwiczenie ...................................................................................................................52 Podsumowanie rozdziału 1. ..............................................................................................52 Rozdział 2. Decyzje, decyzje ............................................................................. 55 Najpierw jednak kilka słów na temat typów danych ........................................................55 Ciekawostka — Dla programistów znających C .......................................................59 Podejmowanie decyzji w programach ..............................................................................59 Instrukcje if oraz if-else ....................................................................................................60 Ciekawostka — Po co dwa operatory (= i ==)? .......................................................62 Przykład 2.1. Nieparzysty czy parzysty? .........................................................................63 Jak to działa? ..............................................................................................................64 Optymalizowanie programu .......................................................................................65 Ćwiczenie ...................................................................................................................66 Podstawy działania pętli ...................................................................................................66 Ciekawostka — Nieskończone zapętlenie ..................................................................70 Przykład 2.2. Wyświetlanie liczb od 1 do N ....................................................................70 Jak to działa? ..............................................................................................................71 Ćwiczenia ...................................................................................................................72 Prawda i fałsz w C++ .......................................................................................................72 Ciekawostka — Typ danych bool ...............................................................................73 Operator inkrementacji (++) ............................................................................................74 Polecenia kontra wyrażenia ..............................................................................................75 Wprowadzenie do algebry Boole’a (układów logicznych) ..............................................76 Ciekawostka — Czym jest wartość „prawda” („true”)? ..........................................78 Przykład 2.3. Sprawdzanie wieku ludzi ...........................................................................78 Jak to działa? ..............................................................................................................79 Ćwiczenie ...................................................................................................................79 Wprowadzenie do biblioteki math ...................................................................................79 Przykład 2.4. Sprawdzanie, czy wartość jest liczbą pierwszą ..........................................80 Jak to działa? ..............................................................................................................82 Optymalizowanie programu .......................................................................................83 Ćwiczenie ...................................................................................................................83 Podsumowanie rozdziału 2. ..............................................................................................84 Rozdział 3. Wygodna i wszechstronna instrukcja for .......................................... 87 Pętle opracowane w celu zliczania ...................................................................................88 Wprowadzenie do pętli for ...............................................................................................89 Worek z przykładami .......................................................................................................90 Ciekawostka — Czy pętla for zawsze zachowuje się tak samo jak while? .................91 Przykład 3.1. Wyświetlanie kolejnych liczb naturalnych od 1 do N przy użyciu pętli for ....92 Jak to działa? ..............................................................................................................92 Ćwiczenie ...................................................................................................................93 Bloki poleceń w pętli for ..................................................................................................93 Deklarowanie zmiennych sterujących pętlą „w locie” .....................................................94 Przykład 3.2. Sprawdzanie, czy wartość jest liczbą pierwszą, z wykorzystaniem pętli for ..95 Jak to działa? ..............................................................................................................96 Ćwiczenie ...................................................................................................................98 Porównanie języków — instrukcja for w języku Basic ...................................................99 Podsumowanie rozdziału 3. ............................................................................................100 6 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc Spis treści 7 Rozdział 4. Funkcje — wiele jest wywoływanych ............................................. 103 Pojęcie funkcji ................................................................................................................103 Wywołania funkcji i przepływ sterowania w programie ...............................................105 Podstawy korzystania z funkcji ......................................................................................107 Krok pierwszy: deklaracja (prototyp) funkcji ..........................................................108 Krok drugi: definicja funkcji ...................................................................................109 Krok trzeci: wywołanie funkcji ...............................................................................110 Przykład 4.1. Funkcja wyznaczająca liczbę trójkątną ....................................................111 Jak to działa? ............................................................................................................112 Optymalizowanie programu .....................................................................................113 Ćwiczenia .................................................................................................................114 Przykład 4.2. Funkcja sprawdzająca, czy podana wartość jest liczbą pierwszą ............115 Jak to działa? ............................................................................................................116 Ćwiczenia .................................................................................................................118 Zmienne lokalne i globalne ............................................................................................118 Funkcje rekurencyjne .....................................................................................................120 Przykład 4.3. Największy wspólny dzielnik (NWD) .....................................................121 Jak to działa? ............................................................................................................124 Ćwiczenia .................................................................................................................125 Przykład 4.4. Rozkładanie liczb na czynniki pierwsze ..................................................125 Jak to działa? ............................................................................................................127 Ciekawostka — Dla matematycznych oszołomów ...................................................129 Ćwiczenia .................................................................................................................130 Przykład 4.5. Generator liczb losowych .........................................................................130 Jak to działa? ............................................................................................................131 Ćwiczenie .................................................................................................................133 Podsumowanie rozdziału 4. ............................................................................................133 Rozdział 5. Tablice — znamy ich liczbę ........................................................... 135 Pierwsze spojrzenie na tablice w języku C++ ................................................................135 Inicjalizowanie tablic .....................................................................................................137 Indeksowanie rozpoczynające się od zera ......................................................................138 Ciekawostka — Dlaczego używać indeksów rozpoczynających się od zera? ..........139 Przykład 5.1. Wyświetlanie elementów .........................................................................139 Jak to działa? ............................................................................................................140 Ćwiczenia .................................................................................................................141 Przykład 5.2. Jak bardzo losowe są liczby losowe? .......................................................141 Jak to działa? ............................................................................................................144 Ćwiczenia .................................................................................................................145 Łańcuchy znakowe i tablice łańcuchów znakowych ......................................................146 Przykład 5.3. Krupier nr 1 ..............................................................................................147 Jak to działa? ............................................................................................................149 Ćwiczenie .................................................................................................................150 Przykład 5.4. Krupier nr 2 ..............................................................................................150 Jak to działa? ............................................................................................................151 Ćwiczenie .................................................................................................................153 Przykład 5.5. Krupier nr 3 ..............................................................................................153 Jak to działa? ............................................................................................................155 Optymalizowanie programu .....................................................................................156 Ćwiczenie .................................................................................................................157 Słowo do dociekliwych ..................................................................................................158 Tablice dwuwymiarowe — witamy w świecie macierzy ...............................................159 Podsumowanie rozdziału 5. ............................................................................................160 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc 7 8 C++ bez obaw Rozdział 6. Wskaźniki — sposób na uchwycenie danych .................................. 163 Pojęcie wskaźnika ..........................................................................................................164 Ciekawostka — Jak naprawdę wyglądają adresy? ..................................................165 Deklarowanie i używanie wskaźników ..........................................................................167 Przykład 6.1. Funkcja podwajająca ................................................................................169 Jak to działa? ............................................................................................................170 Ćwiczenia .................................................................................................................172 Zamiana wartości, czyli kolejna funkcja wykorzystująca wskaźniki ............................172 Przykład 6.2. Program sortujący zawartość tablicy .......................................................174 Jak to działa? ............................................................................................................177 Ćwiczenia .................................................................................................................179 Arytmetyka wskaźników ................................................................................................179 Wskaźniki i przetwarzanie elementów tablic .................................................................182 Przykład 6.3. Zerowanie elementów tablicy ..................................................................184 Jak to działa? ............................................................................................................184 Optymalizowanie programu .....................................................................................185 Ćwiczenia .................................................................................................................187 Podsumowanie rozdziału 6. ............................................................................................187 Rozdział 7. Łańcuchy znakowe — analizowanie tekstu ...................................... 189 Przechowywanie tekstu na komputerze .........................................................................190 Ciekawostka — W jaki sposób komputer tłumaczy kody programów? ....................190 Mam tekst, czy go nie mam? ..........................................................................................192 Funkcje pozwalające na działania na łańcuchach znakowych .......................................193 Przykład 7.1. Budowanie łańcuchów znakowych ..........................................................195 Jak to działa? ............................................................................................................196 Ćwiczenia .................................................................................................................198 Ciekawostka — Co z tymi sekwencjami specjalnymi? .............................................198 Pobieranie tekstu z wejścia ............................................................................................199 Przykład 7.2. Pobieranie liczby ......................................................................................202 Jak to działa? ............................................................................................................203 Ćwiczenie .................................................................................................................204 Przykład 7.3. Konwertowanie tekstów na wielkie litery ................................................204 Jak to działa? ............................................................................................................205 Ćwiczenia .................................................................................................................206 Pojedyncze znaki kontra łańcuchy znakowe ..................................................................206 Przykład 7.4. Analizowanie danych wejściowych .........................................................208 Jak to działa? ............................................................................................................209 Ćwiczenia .................................................................................................................212 Nowa klasa łańcuchów znakowych w C++ ...................................................................213 Zapewnienie możliwości obsługi klasy string .........................................................214 Deklarowanie i inicjalizowanie zmiennych typu string ...........................................215 Korzystanie ze zmiennych typu string .....................................................................215 Wejście i wyjście .....................................................................................................217 Przykład 7.5. Budowanie łańcuchów znakowych za pomocą zmiennych typu string ...217 Jak to działa? ............................................................................................................218 Ćwiczenia .................................................................................................................219 Inne operacje na danych typu string ...............................................................................219 Podsumowanie rozdziału 7. ............................................................................................221 Rozdział 8. Pliki — elektroniczne magazyny .................................................... 225 Wprowadzenie do obiektów strumieni plików ...............................................................226 Jak odwoływać się do plików na dysku? .......................................................................228 Przykład 8.1. Zapisywanie tekstu w pliku ......................................................................229 Jak to działa? ............................................................................................................230 Ćwiczenia .................................................................................................................231 8 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc Spis treści 9 Przykład 8.2. Wyświetlanie zawartości pliku tekstowego .............................................232 Jak to działa? ............................................................................................................233 Ćwiczenia .................................................................................................................234 Pliki tekstowe kontra pliki „binarne” .............................................................................234 Ciekawostka — Czy pliki „binarne” są w rzeczywistości bardziej binarne od tekstowych? ......................................................................................................237 Wprowadzenie do operacji binarnych ............................................................................238 Przykład 8.3. Bezpośredni zapis danych do pliku ..........................................................240 Jak to działa? ............................................................................................................242 Ćwiczenia .................................................................................................................243 Przykład 8.4. Bezpośredni odczyt danych z pliku .........................................................243 Jak to działa? ............................................................................................................245 Ćwiczenia .................................................................................................................245 Podsumowanie rozdziału 8. ............................................................................................246 Rozdział 9. Niektóre z zaawansowanych technik programistycznych ................ 249 Argumenty linii poleceń .................................................................................................250 Przykład 9.1. Wyświetlanie zawartości pliku o nazwie podanej w linii poleceń ...........251 Jak to działa? ............................................................................................................253 Ćwiczenia .................................................................................................................253 Przeładowanie funkcji ....................................................................................................254 Ciekawostka — Przeładowanie i OOPS ..................................................................255 Przykład 9.2. Wyświetlanie różnych rodzajów tablic ....................................................256 Jak to działa? ............................................................................................................257 Ćwiczenie .................................................................................................................258 Pętla do-while .................................................................................................................258 Wyrażenie switch-case ...................................................................................................260 Korzystanie z wielu modułów ........................................................................................261 Obsługa wyjątków ..........................................................................................................265 Wyjątkom powiedz: „Dzień dobry!” .......................................................................265 Obsługa wyjątków: próba pierwsza .........................................................................266 Wprowadzenie do obsługi wyjątków za pomocą instrukcji try-catch .....................267 Przykład 9.3. Obsługa wyjątków przy obliczaniu NWD ...............................................270 Jak to działa? ............................................................................................................271 Ćwiczenie .................................................................................................................272 Ciekawostka — Czy można korzystać z wielu bloków try-catch? ............................272 Podsumowanie rozdziału 9. ............................................................................................273 Rozdział 10. Orientowanie się na obiekty .......................................................... 275 Dlaczego orientować się obiektowo? .............................................................................276 Parser łańcuchów znakowych ........................................................................................277 Obiekty kontra klasy ......................................................................................................279 Inny przykład: klasa Ulamek ..........................................................................................279 Tworzenie i niszczenie obiektów ...................................................................................280 Dziedziczenie .................................................................................................................281 Tworzenie wspólnych interfejsów .................................................................................283 Polimorfizm — prawdziwa niezależność obiektów .......................................................285 Polimorfizm i funkcje wirtualne ....................................................................................287 Ciekawostka — Polimorfizm i tradycyjne języki programowania ...........................288 A co z wielokrotnym wykorzystywaniem kodu? ...........................................................289 Podsumowanie rozdziału 10. ..........................................................................................291 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc 9 10 C++ bez obaw Rozdział 11. Klasa Ulamek ............................................................................... 293 Punkt — prosta klasa ......................................................................................................293 Ciekawostka — Dla programistów używających języka C — struktury i klasy .......295 Teren prywatny — tylko dla swoich, czyli rzecz o ochronie danych ............................296 Przykład 11.1. Testowanie klasy Punkt .........................................................................298 Jak to działa? ............................................................................................................299 Ćwiczenia .................................................................................................................300 Wprowadzenie klasy Ulamek .........................................................................................300 Funkcje inline .................................................................................................................303 Znajdowanie największego wspólnego dzielnika ..........................................................305 Znajdowanie najmniejszej wspólnej wielokrotności ......................................................307 Przykład 11.2. Funkcje pomocnicze klasy Ulamek .......................................................308 Jak to działa? ............................................................................................................309 Ćwiczenia .................................................................................................................311 Przykład 11.3. Testowanie klasy Ulamek ......................................................................311 Jak to działa? ............................................................................................................313 Ćwiczenie .................................................................................................................314 Ciekawostka — Nowy rodzaj dyrektywy #include? .................................................314 Przykład 11.4. Arytmetyka ułamków — dodawanie i mnożenie ...................................315 Jak to działa? ............................................................................................................317 Ćwiczenia .................................................................................................................318 Podsumowanie rozdziału 11. ..........................................................................................319 Rozdział 12. Konstruktory — jeśli już budujesz… .............................................. 321 Wprowadzenie do konstruktorów ..................................................................................321 Definiowanie wielu konstruktorów (przeładowanie) .....................................................323 Konstruktor domyślny… i związane z nim ostrzeżenie .................................................324 Ciekawostka — Czy w kwestii domyślnego konstruktora język C++ bawi się z Tobą w kotka i myszkę? ........................................................................326 Przykład 12.1. Konstruktory klasy Punkt .......................................................................327 Jak to działa? ............................................................................................................328 Ćwiczenia .................................................................................................................328 Przykład 12.2. Konstruktory klasy Ulamek ...................................................................328 Jak to działa? ............................................................................................................330 Ćwiczenia .................................................................................................................331 Referencje do zmiennych i argumenty przekazywane przez referencje ( ) .................331 Konstruktor kopiujący ....................................................................................................333 Ciekawostka — Konstruktor kopiujący i referencje ................................................335 Przykład 12.3. Konstruktor kopiujący klasy Ulamek ....................................................336 Jak to działa? ............................................................................................................338 Ćwiczenia .................................................................................................................338 Podsumowanie rozdziału 12. ..........................................................................................339 Rozdział 13. Funkcje operatorowe — zrób to z klasą ......................................... 341 Wprowadzenie do funkcji operatorów działających na klasach ....................................341 Globalne funkcje operatorowe .......................................................................................344 Poprawienie wydajności działania kodu za pomocą referencji ......................................346 Przykład 13.1. Operatory klasy Punkt ............................................................................349 Jak to działa? ............................................................................................................350 Ćwiczenia .................................................................................................................351 Przykład 13.2. Operatory klasy Ulamek ........................................................................352 Jak to działa? ............................................................................................................354 Ćwiczenia .................................................................................................................355 Praca z innymi typami danych .......................................................................................355 Funkcja operatora przypisania (=) dla klasy Ulamek .....................................................356 10 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc Spis treści 11 Funkcja operatora porównania (==) dla klasy Ulamek ..................................................358 Ciekawostka — Co z tym typem boolowskim (bool)? ..............................................359 Funkcja wyświetlająca dla klasy Ulamek ......................................................................359 Przykład 13.3. Kompletna klasa Ulamek .......................................................................361 Jak to działa? ............................................................................................................364 Ćwiczenia .................................................................................................................366 Podsumowanie rozdziału 13. ..........................................................................................366 Rozdział 14. Czym jest „new”? Klasa ParserTekstu ........................................... 369 Operator new ..................................................................................................................370 Obiekty i operator new ...................................................................................................371 Tworzenie tablic dynamicznych .....................................................................................373 Ciekawostka — Radzenie sobie z problemami związanymi z alokacją pamięci ......375 Przykład 14.1. Dynamiczne przydzielanie pamięci w akcji ...........................................376 Jak to działa? ............................................................................................................376 Ćwiczenie .................................................................................................................377 Projektowanie parsera (analizatora leksykalnego) .........................................................377 Przykład 14.2. Klasa ParserTekstu .................................................................................382 Jak to działa? ............................................................................................................384 Poprawianie kodu .....................................................................................................386 Ćwiczenia .................................................................................................................387 Podsumowanie rozdziału 14. ..........................................................................................388 Rozdział 15. Czym jest „this”? Klasa String ...................................................... 391 Wprowadzenie do klasy String ......................................................................................392 Wprowadzenie do destruktorów klasy ...........................................................................393 Przykład 15.1. Prosta klasa String ..................................................................................394 Jak to działa? ............................................................................................................396 Ćwiczenia .................................................................................................................398 „Głębokie” kopiowanie i konstruktor kopiujący ............................................................398 Słowo kluczowe this .......................................................................................................401 Tworzenie operatora przypisania ...................................................................................402 Tworzenie funkcji konkatenacji (łączenia) ....................................................................405 Przykład 15.2. Kompletna klasa String ..........................................................................407 Jak to działa? ............................................................................................................409 Ćwiczenia .................................................................................................................410 Podsumowanie rozdziału 15. ..........................................................................................411 Rozdział 16. Dziedziczenie. Cóż to za spadek? .................................................. 413 Dziedziczenie, czyli przyjemne z pożytecznym ............................................................414 Ciekawostka — Dlaczego nazwy klas bazowych poprzedzone są słowem „public”? ................................................................... 417 Przykład 16.1. Klasa UlamekZmp .................................................................................418 Jak to działa? ............................................................................................................421 Ćwiczenia .................................................................................................................421 Problemy związane z klasą UlamekZmp .......................................................................422 Konstruktory domyślne klas pochodnych ................................................................423 Konstruktory kopiujące dla klas pochodnych ..........................................................424 Funkcja operatora przypisania dla klas pochodnych ...............................................424 Dodawanie brakujących konstruktorów ..................................................................424 Rozwiązywanie konfliktów typów z klasą bazową .................................................425 Przykład 16.2. Kompletna klasa UlamekZmp ...............................................................426 Jak to działa? ............................................................................................................426 Ćwiczenia .................................................................................................................427 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc 11 12 C++ bez obaw Przykład 16.3. Klasa UlamekPrawidl ............................................................................427 Jak to działa? ............................................................................................................429 Ćwiczenia .................................................................................................................431 Składniki prywatne (private) i chronione (protected) ....................................................432 Przykład 16.4. Elementy składowe będące obiektami — klasa UlamekJedn ................434 Jak to działa? ............................................................................................................436 Ćwiczenie .................................................................................................................438 Podsumowanie rozdziału 16. ..........................................................................................438 Rozdział 17. Polimorfizm — niezależność obiektów ........................................... 441 Inna metoda opracowania klasy UlamekZmp ................................................................442 Funkcje wirtualne idą z odsieczą! ..................................................................................444 Ciekawostka — Jaka jest cena za stosowanie funkcji wirtualnych? ........................445 Przykład 17.1. Zmieniona klasa UlamekZmp ................................................................447 Jak to działa? ............................................................................................................448 Poprawianie kodu .....................................................................................................449 Ćwiczenie .................................................................................................................451 „Czysta wirtualność” i inne skomplikowane zagadnienia .............................................451 Klasy abstrakcyjne i interfejsy .......................................................................................453 Dlaczego obiekt cout nie jest prawdziwie polimorficzny? ............................................454 Przykład 17.2. Prawdziwy polimorfizm — klasa Drukowalny .....................................456 Jak to działa? ............................................................................................................458 Ćwiczenie .................................................................................................................459 Słowo (lub dwa słowa) na zakończenie .........................................................................460 Słowo na zakończenie zakończenia ...............................................................................461 Podsumowanie rozdziału 17. ..........................................................................................463 Dodatek A Operatory oferowane przez język C++ ............................................ 465 Dodatek B Wbudowane typy danych należące do języka C++ .......................... 469 Dodatek C Podsumowanie składni wyrażeń w języku C++ ............................... 471 Stałe dosłowne ................................................................................................................471 Podstawowa składnia wyrażeń .......................................................................................472 Podstawowa składnia poleceń ........................................................................................473 Struktury kontrolne ........................................................................................................473 Specjalne polecenia kontrolne ........................................................................................476 Deklaracje danych ..........................................................................................................477 Deklaracje funkcji ..........................................................................................................477 Deklaracje klas ...............................................................................................................478 Dodatek D Kody znaków ASCII ....................................................................... 481 Dodatek E Często używane funkcje biblioteczne ............................................. 483 Funkcje umożliwiające działania na łańcuchach znakowych ........................................483 Funkcje do konwersji danych .........................................................................................485 Funkcje wykonujące operacje na pojedynczych znakach ..............................................486 Funkcje matematyczne ...................................................................................................487 Funkcje związane z wyznaczaniem wartości losowych .................................................488 Dodatek F Słownik trudnych terminów używanych w tej książce ..................... 489 Skorowidz ..................................................................................... 501 12 D:Roboczy!!!!makiety poprawki druk pdfC++ bez obaw!spis.doc Rozdział 1. Naprawdę nie ma się czego obawiać w programowaniu w języku C++! Podobnie jak wszystkie inne języki programowania stanowi on sposób na określenie logicznych i precyzyjnych wskazówek dla komputera, które dotyczą jego działania. Kod C++ możesz oczywiście dowolnie skomplikować, lecz najprostszą metodą nauczenia się tego języka jest rozwiązywanie pewnych podstawowych zadań programistycznych. Jest to też sposób, z którego będziemy korzystać w tej książce. W kilku pierwszych podrozdziałach dokonam przeglądu podstawowych koncepcji związanych z programowaniem. Jeśli pisałeś już jakieś programy, korzystając z in- nych języków, możesz pominąć tę część rozdziału lub jedynie pobieżnie się z nią za- poznać. Jeżeli jednak zechcesz się wgłębić w tę treść, obiecuję nie zanudzić Cię na śmierć. Myśleć jak programista Programowanie może nie przypominać czynności, które zwykłeś wykonywać na co dzień. W ogólnym zarysie chodzi w nim o to, że powinieneś wydawać komputerowi pewne instrukcje, robiąc to w bardzo logiczny i usystematyzowany sposób. Komputery robią tylko to, co im każesz Komputery wykonują tylko te czynności, których od nich wymagasz — to najważ- niejsza zasada w tej książce, która przyda Ci się, szczególnie jeśli nie miałeś dotąd żadnych doświadczeń z programowaniem. Korzystając z języka programowania, ta- kiego jak C++, Visual Basic, Pascal czy FORTRAN, określasz listę zadań do wyko- nania i ta właśnie lista stanowi program. 22 C++ bez obaw Prowadziłem kiedyś praktyczne zajęcia z programowania w położonym w stanie Wa- szyngton mieście Tacoma, które znane jest chyba tylko z tego, że stanowi najbardziej stresujące miasto Ameryki. Jednym z moich studentów był mały człowieczek noszący słomkowy kapelusz i zniszczone ubrania. Każdego dnia odwiedzał mnie ze stosem egzemplarzy codziennego zestawienia wyników gonitw konnych i przekonywał, że dzięki wpisaniu wszystkich tych informacji do komputera i przewidywaniu za jego pomocą numerów koni wygrywających wyścigi możemy szybko stać się milionerami. Niestety, sprawy nie mają się tak świetnie i żadna maszyna elektroniczna nie jest w stanie podołać tego typu zadaniu. Oczywiście, każdy komputer potrzebuje informacji, które nazywane są danymi dla programu. Musi jednak dodatkowo wiedzieć, co począć z tymi informacjami. Instrukcje opisujące operacje, które mają być przeprowadzane na danych (cele tych działań opiszę w dalszej części rozdziału), nazywane są kodem programu. Określanie, co ma robić program Aby komputer wykonał dla Ciebie jakiekolwiek zadanie, musisz dokładnie zdefiniować, co właściwie ma on robić. Jak dotąd miałeś prawdopodobnie okazję uruchamiać na swoim komputerze progra- my napisane przez innych ludzi, takich jak Bill Gates i jego kumple. Byłeś więc do tej pory tak zwanym użytkownikiem końcowym, nazywanym też w skrócie po prostu użytkownikiem. Pisząc własne programy, wzniesiesz się teraz na wyższy szczebel w hierarchii kom- puterowców. Od teraz to Ty będziesz decydował, co program ma robić. To Ty bę- dziesz sprawiał, że coś się będzie działo. Pamiętać jednak musisz, że komputer jest skończonym, choć genialnym idiotą i to w dużo większym stopniu niż Dustin Hoffman w filmie Rain Man. Nigdy sam nie przewidzi, czego od niego chcesz. Nigdy też nie będzie w stanie podejmować samodzielnych de- cyzji. Jest do bólu dosłowny i bardzo dokładnie będzie przeprowadzał operacje, które każesz mu wykonać, niezależnie od tego, jak głupie by one nie były. Z tego też powodu musisz być niezwykle skrupulatny w zapisywaniu instrukcji określających działania, o które Ci chodzi. Może się zdarzyć, że wydasz komputerowi polecenie, które będzie się wydawało zu- pełnie zrozumiałe dla przeciętnego człowieka, takie jak na przykład „Zmień daną tem- peraturę wyrażoną w stopniach Celsjusza na temperaturę w skali Fahrenheita”. Niestety, nawet to jest dla maszyny zbyt ogólną instrukcją. Musisz zatem określić swe wyma- gania w bardziej precyzyjny sposób, podając komputerowi kolejne kroki działania, podobne do wymienionych poniżej: 1. Wyświetl komunikat: „Wprowadź temperaturę w stopniach Celsjusza”. 2. Pobierz liczbę wprowadzoną za pomocą klawiatury i zapisz ją w zmiennej o nazwie ctemp. Rozdział 1. ¨ Twoje pierwsze programy w C++ 23 3. Skonwertuj temperaturę na skalę Fahrenheita, korzystając z następującego wzoru: ftemp = (ctemp * 1.8) + 32. 4. Wyświetl komunikat: „Temperatura w skali Fahrenheita wynosi:”. 5. Wyświetl wartość przechowywaną w zmiennej ftemp. Jeśli to proste zadanie wymaga od Ciebie przejścia przez tak skomplikowaną proce- durę, możesz zacząć się zastanawiać nad tym, po co w ogóle trudzić się w ten sposób. Odpowiedź jest prosta: raz napisany program można uruchamiać wielokrotnie. I cho- ciaż pisanie programu zajmuje nieraz sporo czasu, będzie się on zwykle wykonywał z szybkością błyskawicy. Pisanie odpowiednich wyrażeń C++ Po dokładnym sprecyzowaniu zadania, które program ma wykonywać krok po kroku, powinieneś przystąpić do zapisania odpowiednich instrukcji języka C++. Polecenie jest w C++, ogólnie rzecz biorąc, ekwiwalentem zdania zapisanego w języku polskim — może zatem określać jedną lub większą ilość operacji lub tworzyć jakąś daną, jak przekonasz się, czytając dalszą część niniejszego rozdziału. Powiedzmy, że chcesz, aby Twój program wykonywał następujące działania: 1. Wyświetlał komunikat: „Temperatura w skali Fahrenheita wynosi:”. 2. Wyświetlał wartość zmiennej ftemp. Kroki te możesz przełożyć na następujące wyrażenia języka C++: cout Temperatura w skali Fahrenheita wynosi: ; cout ftemp; Pamiętaj, że celem programowania jest wykorzystanie komputera do przeprowadza- nia serii określonych operacji. Komputery rozumieją jednak jedynie swój własny we- wnętrzny język — kod maszynowy — który zapisywany jest w postaci ciągów wielu zer i jedynek. W latach 50. zeszłego wieku programiści zapisywali poszczególne in- strukcje za pomocą kodu maszynowego, jest to jednak niezwykle trudne i zajmuje bardzo dużo czasu. Aby ułatwić to zadanie, inżynierowie rozwijający oprogramowanie komputerowe opracowali języki programowania, takie jak FORTRAN, Basic i C, które umożliwiły ludziom tworzenie programów w sposób nieco zbliżony do pisania tekstów w języku angielskim. Pisanie programu możesz rozpocząć od utworzenia tak zwanego pseudokodu — w książce tej będę nieraz korzystał z tej właśnie metody. Pseudokod jest bardzo po- dobny do języka naturalnego, jednak pozwala na opisanie działań wykonywanych przez program w ścisły sposób, odzwierciedlający przepływ sterowania w programie. Poniżej znajdziesz przykładowy program zapisany w postaci pseudokodu. 24 C++ bez obaw Jeżeli a jest większe niż b, Wyświetl „a jest większe niż b.”. W innym przypadku Wyświetl „a nie jest większe niż b.”. Po utworzeniu pseudokodu będziesz już bardzo blisko napisania programu w języku C++. Wszystko, co będziesz musiał w tym celu zrobić, to odnaleźć odpowiednie wyrażenia języka C++ odpowiadające określonym działaniom zapisanym w pseudokodzie i za- stąpić ten pseudokod właściwymi poleceniami przy zachowaniu reguł składni języka. if (a b) cout a jest większe niż b. ; else cout a nie jest większe niż b. ; Przewagą zapisu za pomocą języka programowania jest to, że podlega on zasadom, które nie dopuszczają żadnych niejednoznaczności. Wyrażenia C++ są tak precyzyjne, że mogą być przetłumaczone na ciąg zer i jedynek kodu maszynowego, bez koniecz- ności jakiegokolwiek zgadywania intencji piszącego. Nie powinno być dla Ciebie żadnym zaskoczeniem, że języki programowania mają ści- słe reguły określające składnię wyrażeń. Reguły te są bardziej konsekwentne i zwykle również dużo prostsze niż zasady rządzące naturalnymi językami ludzkimi. Od czasu do czasu będę podawał Ci te reguły. Oto na przykład składnia wyrażenia if-else: if (warunek) polecenie else polecenie Słowa wyróżnione w powyższym zapisie pogrubioną czcionką to słowa kluczowe, które muszą się znaleźć w programie dokładnie w takiej postaci, w jakiej zostały za- pisane. Słowa zapisane zwykłą czcionką, nazywane również słowami zastępczymi, reprezentują elementy, które zależą od Ciebie. Aplikacja, która tłumaczy wyrażenia języka C++ na kod maszynowy, nazywana jest kompilatorem. Na temat kompilatorów dużo więcej informacji znajdziesz w podroz- dziale „Budowanie programu w C++”. Najpierw jednak omówmy niektóre kluczowe definicje. Przegląd kilku specjalistycznych definicji Chciałbym za wszelką cenę uniknąć specjalistycznego żargonu, ale bądźmy szczerzy — kiedy zaczynasz uczyć się programowania, wchodzisz w świat, który wymaga od Ciebie używania zupełnie nowej terminologii. To trochę tak jak z przysłowiowym wej- ściem między wrony… Poniżej znajdziesz zatem szereg definicji, które okażą się nie- zbędne, abyś mógł przetrwać w tym trudnym świecie. Rozdział 1. ¨ Twoje pierwsze programy w C++ 25 aplikacja Jest dokładnie tym samym co program, ale widziany z punktu widzenia użytkownika. Aplikacja to program, który jest uruchamiany przez użytkownika w celu wykonania określonego zadania. Edytor tekstu jest zatem aplikacją, podobnie jak przeglądarka internetowa czy program dostępu do bazy danych. Jak przekonasz się niebawem, na- wet kompilator (patrz niżej) jest aplikacją, jednak jest to aplikacja bardzo szczególnego rodzaju, ponieważ jest ona używana przez programistów. Aby uprościć sprawę — Twój program będzie aplikacją, gdy zostanie napisany, zbudowany oraz przetestowany. dane kod To informacje przechowywane przez program, które mają być przetwarzane lub wy- świetlane w czasie jego działania. W najprostszym ujęciu dane zawierają słowa lub liczby, choć mogą też tworzyć bardziej skomplikowane i interesujące struktury danych, zwane „klasami” i „obiektami”. To kolejny synonim słowa „program”, ale akcent położony jest tu na punkt widzenia programisty. Kod jest serią wyrażeń zapisanych zgodnie z zasadami składni, używa- nymi przy tworzeniu programu. Określenie to może się odnosić zarówno do kodu maszynowego, czyli ciągu zer i jedynek, jak i kodu źródłowego, a więc zestawu in- strukcji języka C++. Używanie terminu „kod” wiąże się z czasami, gdy wszyscy pro- gramiści pisali swoje programy wyłącznie w kodzie maszynowym. Każda z instrukcji maszynowych jest zapisywana w postaci niepowtarzalnej kombinacji zer i jedynek, dzięki czemu stanowi kod definiujący odpowiednią akcję podejmowaną przez kom- puter. Pomimo korzystania z języków wysokiego poziomu, takich jak C++, Java, FORTRAN czy Visual Basic, programiści w dalszym ciągu używali słowa „kod”. Więcej informacji na ten temat znajdziesz w definicji terminu kod źródłowy. Słowo „kod” bywa również czasami używane do odróżniania pasywnych informacji występujących w programie, czyli jego danych, od części programu, która jest odpo- wiedzialna za przeprowadzanie działań, czyli właśnie kodu. kod maszynowy To naturalny język procesora (CPU). W tym języku każda instrukcja procesora składa się z unikatowej kombinacji (lub kodu) zer i jedynek. W dalszym ciągu możliwe jest programowanie w kodzie maszynowym, jednak wymaga to dobrej znajomości po- szczególnych kodów instrukcji oraz posiadania dużej wiedzy na temat architektury jednostki centralnej, czyli wszystkiego tego, co nie należy do tematyki niniejszej książki. Języki programowania, takie jak C++, pozwalają na pisanie programów w sposób po- dobny do tworzenia tekstów w języku angielskim, ale na tyle precyzyjnie, iż mogą one być tłumaczone na kod maszynowy. Język C++ oferuje również sporo ciekawych możliwości i ułatwień. 26 kod źródłowy C++ bez obaw To program napisany w języku wysokiego poziomu, takim jak właśnie C++. Kod źródłowy składa się z szeregu wyrażeń języka C++, które stanowią właściwy program. Kod taki musi zostać przetłumaczony na kod maszynowy, zanim będzie mógł być wykonany przez komputer. Kod maszynowy, jak już pisałem, zawiera tylko zera i jedynki, ale jest zwykle zapi- sywany za pomocą kodu szesnastkowego, zwanego też heksadecymalnym, który sta- nowi ciąg liczb o podstawie 16. Kod maszynowy wygląda zatem mniej więcej tak: 08 A7 C3 9E 58 6C 77 90 Trochę trudno stwierdzić, jakie zadanie wykonuje ten kod, prawda? Dopóki nie poznasz kodów wszystkich instrukcji, program taki będzie dla Ciebie zupełnie niezrozumiały i to właśnie stanowi powód, dla którego bardzo niewielu ludzi używa w obecnych czasach kodu maszynowego do tworzenia programów. Kod źródłowy, dla odmiany, przy- najmniej w pewnej mierze wykazuje podobieństwo do języka angielskiego, a więc i do innych języków naturalnych. Fragment kodu może na przykład wyglądać tak: if(wynagrodzenie 0) wyswietl_komunikat_bledu(); kompilator Jest to translator języka zamieniający wyrażenia C++ (czyli kod języka C++) na pro- gram w postaci kodu maszynowego. Działanie to jest niezbędne, ponieważ sam kom- puter, a dokładniej jego jednostka centralna (CPU — ang. Central Processing Unit) jest w stanie zrozumieć jedynie kod maszynowy. polecenie Stanowi przeważnie jedną linię programu C++. Wyrażenie w C++ odpowiada z grubsza zdaniu w języku naturalnym, takim jak na przykład język angielski. C++ dopuszcza stosowanie bardzo skomplikowanych struktur językowych składających się z jednego lub z wielu mniejszych wyrażeń, co również przypomina zasady tworzenia zdań w ję- zyku angielskim. Większość poleceń języka C++ powoduje wykonanie pojedynczego działania, ale istnieją również takie, które przeprowadzają całe serie operacji. program Jest serią instrukcji, które ma wykonać komputer w stosunku do danych wejściowych. Tak jak wspomniałem wcześniej, napisanie programu może zająć sporo czasu, jednak po ukończeniu tej pracy okazuje się zwykle, że wykonuje się on niezwykle szybko i można go nieustannie uruchamiać. użytkownik Osoba uruchamiająca program, czyli człowiek, który korzysta z komputera w celu wykonania jakiegoś pożytecznego zadania, takiego jak edytowanie pliku tekstowego, przeczytanie wiadomości e-mail, przejrzenie stron WWW czy też przelanie jakieś kwoty pieniędzy z konta bankowego. Bardziej oficjalna nazwa użytkownika to użyt- kownik końcowy. Rozdział 1. ¨ Twoje pierwsze programy w C++ 27 W czasie, gdy pracowałem w firmie Microsoft, użytkownik był osobą powodującą większość istniejących na świecie problemów, był jednak również człowiekiem, który płacił wszystkie rachunki i generował wszystkie zyski przedsiębiorstwa. Rozpoczy- nając projektowanie poważnych programów, musisz bardzo uważnie przyjrzeć się po- trzebom użytkownika i spróbować przewidzieć wszystkie potencjalne kłopoty, które mogą mu się przytrafić w związku z korzystaniem z Twojej aplikacji. Mimo że jako programiście będzie Ci się zdarzać patrzeć z góry na użytkowników, musisz mieć świadomość, że pierwszym użytkownikiem aplikacji jest zawsze… sam programista! Po napisaniu programu będziesz bowiem prawdopodobnie pierwszą osobą, a nieraz i jedyną osobą, która uruchomi program i sprawdzi jego działanie. Pamiętaj więc, że będąc programistą, jesteś też jednocześnie normalnym użytkownikiem. Co wyróżnia język C++? Większość rzeczy, które właśnie
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C++ bez obaw
Autor:
Sklep
Format
Cena
Helion.pl Helion.pl
książka
59,00 zł
Idź do sklepu »

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ą: