c++-bez-obaw scan.pdf

(16811 KB) Pobierz
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
IDZ DO
PRZYK£ADOW Y ROZDZIA£
C++ bez obaw
SPIS TREœCI
Autor: Brian Overland
T³umaczenie: £ukasz Suma
ISBN: 83-246-0410-3
Tytu³ orygina³ u: C++ Without Fear:
Format: B5, stron: 520
KATALOG KSI¥¯EK
KATALOG ONLINE
ZAMÓW DRUKOWANY KATALOG
TWÓJ KOSZYK
Rozpocznij przygodê z programowaniem
Poznaj elementy jêzyka C++.
Naucz siê przetwarzaæ dane tekstowe i liczbowe.
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.
Struktura programu w C++
Wyœwietlanie danych na ekranie
Typy danych
Pêtle i instrukcje warunkowe
Korzystanie ze wskaŸników
Operacje na plikach
Programowanie obiektowe
Poszerz swoje mo¿liwoœci, programuj w jêzyku C++
DODAJ DO KOSZYKA
CENNIK I INFORMACJE
ZAMÓW INFORMACJE
ONOWOœCIACH
ZAMÓW CENNIK
CZYTELNIA
FRAGMENTY KSI¥¯EK ONLINE
Wydawnictwo Helion
ul. Koœciuszki 1c
44-100 Gliwice
tel. 032 230 98 63
e-mail: helion@helion.pl
855706252.018.png 855706252.019.png 855706252.020.png 855706252.021.png 855706252.001.png 855706252.002.png 855706252.003.png 855706252.004.png 855706252.005.png 855706252.006.png 855706252.007.png 855706252.008.png 855706252.009.png 855706252.010.png 855706252.011.png 855706252.012.png 855706252.013.png 855706252.014.png 855706252.015.png 855706252.016.png
 
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
855706252.017.png
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
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
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

Plik z chomika:

Inne pliki z tego folderu:

Inne foldery tego chomika:

Zgłoś jeśli naruszono regulamin