Darmowy fragment publikacji:
Tytuł oryginału: C++ For Dummies, 7th edition
Tłumaczenie: Michał Sternik
ISBN: 978-83-283-5987-1
Original English language edition Copyright © 2014 by John Wiley Sons, Inc., Hoboken, New Jersey
All rights reserved including the right of reproduction in whole or in part in any form. This translation
published by arrangement with John Wiley Sons, Inc.
Oryginalne angielskie wydanie Copyright © 2014 by John Wiley Sons, Inc., Hoboken, New Jersey
Wszelkie prawa, włączając prawo do reprodukcji całości lub części w jakiejkolwiek formie, zarezerwowane.
Tłumaczenie opublikowane na mocy porozumienia z John Wiley Sons, Inc.
Translation copyright © 2019 by Helion S.A.
Wiley, the Wiley Publishing logo, For Dummies, Dla Bystrzaków, the Dummies Man logo, Dummies.com,
Making Everything Easier, and related trade dress are trademarks or registered trademarks of John Wiley
Sons, Inc. and/or its affiliates in the United States and/or other countries. Used by permission.
All other trademarks are the property of their respective owners.
Wiley, the Wiley Publishing logo, For Dummies, Dla Bystrzaków, the Dummies Man logo, Dummies.com,
Making Everything Easier, i związana z tym szata graficzna są markami handlowymi John Wiley Sons,
Inc. i/lub firm stowarzyszonych w Stanach Zjednoczonych i/lub innych krajach. Wykorzystywane na
podstawie licencji.
Wszystkie pozostałe marki handlowe są własnością poszczególnych właścicieli.
Media and software compilation copyright © 2014 by John Wiley Sons, Inc. All rights reserved.
Autor oraz HELION SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne
i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym
ewentualne naruszenie praw patentowych lub autorskich. Autor oraz HELION SA nie ponoszą również
żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce.
Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC.
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://dlabystrzakow.pl/user/opinie/cppby7
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/cppby7.zip
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 Gliwice
tel. 32 231 22 19, 32 230 98 63
e-mail: dlabystrzakow@dlabystrzakow.pl
WWW: http://dlabystrzakow.pl
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treści
O autorze .........................................................................15
Podziękowania od autora ..............................................17
Wprowadzenie .................................................................19
CZĘŚĆ I: PODSTAWY PROGRAMOWANIA W C++ ......................25
ROZDZIAŁ 1: Pierwszy program w C++ .................................................27
Pojęcia dotyczące języka C++ ..................................................................................28
Instalacja Code::Blocks ............................................................................................29
Windows ..............................................................................................................29
Ubuntu Linux ......................................................................................................32
Macintosh ............................................................................................................34
Tworzenie pierwszego programu w C++ ...............................................................37
Tworzenie projektu ............................................................................................38
Wprowadzanie kodu w języku C++ ...................................................................39
Korzystanie ze ściągawki ...................................................................................41
Budowanie programu ........................................................................................42
Uruchamianie programu .........................................................................................43
Przeglądanie programu z komentarzami ..............................................................44
Analiza struktury programów w C++ ................................................................45
Opatrywanie kodu źródłowego komentarzami ..............................................45
Tworzenie programów z instrukcji C++ ............................................................46
Deklaracja zmiennych ........................................................................................47
Generowanie wyjścia programu .......................................................................48
Obliczanie wyrażeń ..................................................................................................48
Przechowywanie wyników wyrażenia ..............................................................48
Pozostała część programu Conversion ............................................................49
Spis treści
5
Poleć książkęKup książkęROZDZIAŁ 2: Stałe deklarowanie zmiennych ......................................51
Deklaracja zmiennych ..............................................................................................52
Deklarowanie różnych typów zmiennych .............................................................52
Przegląd ograniczeń liczb całkowitych w C++ ..................................................53
Rozwiązywanie problemu zaokrągleń ..............................................................54
Ograniczenia liczb zmiennoprzecinkowych .....................................................55
Deklarowanie typów zmiennych ............................................................................57
Typy stałych .........................................................................................................58
Zakres typów liczbowych ...................................................................................59
Znaki specjalne ...................................................................................................60
Szerokie ładunki na autostradzie typu Char .........................................................61
Czy te obliczenia są logiczne? .................................................................................62
Wyrażenia mieszane ................................................................................................63
Deklaracje automatyczne ........................................................................................64
ROZDZIAŁ 3: Operacje matematyczne .................................................67
Wykonywanie prostych obliczeń binarnych ..........................................................68
Dekomponowanie wyrażeń ....................................................................................69
Określanie kolejności operacji ................................................................................69
Wykonywanie operacji jednoargumentowych .....................................................70
Korzystanie z operatorów przypisania ..................................................................72
ROZDZIAŁ 4: Operacje logiczne .............................................................75
Po co wykonujemy operacje logiczne? ..................................................................76
Korzystanie z prostych operatorów logicznych ....................................................76
Przechowywanie wartości logicznych ..............................................................77
Używanie logicznych zmiennych typu int ........................................................79
Zawiłości wykonywania operacji logicznych
na zmiennych zmiennoprzecinkowych .........................................................79
Wyrażanie liczb binarnych .......................................................................................81
System liczb dziesiętnych ..................................................................................81
Inne systemy liczbowe .......................................................................................82
System liczb binarnych ......................................................................................82
Wykonywanie bitowych operacji logicznych .........................................................84
Operatory jednobitowe .....................................................................................84
Używanie operatorów bitowych .......................................................................86
Prosty test ............................................................................................................86
6
C++ dla bystrzaków
Poleć książkęKup książkęROZDZIAŁ 5: Sterowanie przepływem programu ...............................89
Sterowanie przepływem programu za pomocą instrukcji rozgałęzienia ...........90
Wykonywanie pętli ...................................................................................................92
Wykonywanie pętli, gdy warunek jest prawdziwy ..........................................92
Wykorzystanie autoinkrementacji i autodekrementacji ................................94
Pętle for ...............................................................................................................95
Unikanie budzącej strach pętli nieskończonej ................................................98
Pętla for zależna od zakresu .............................................................................98
Instrukcje zarządzania pętlami .........................................................................99
Zagnieżdżanie instrukcji sterujących ...................................................................102
Przełączanie na inny temat? .................................................................................104
CZĘŚĆ II: PROGRAMOWANIE
W C++ Z WYKORZYSTANIEM FUNKCJI .....................................107
ROZDZIAŁ 6: Tworzenie funkcji ..........................................................109
Pisanie i używanie funkcji ......................................................................................110
Definiowanie funkcji .........................................................................................112
Definiowanie funkcji sumujSekwencje() ........................................................112
Wywoływanie funkcji sumujSekwencje() ........................................................113
Dziel i rządź .......................................................................................................113
Funkcje w szczegółach ...........................................................................................113
Funkcje proste ..................................................................................................114
Funkcje z argumentami ...................................................................................115
Przeciążanie funkcji ................................................................................................117
Definiowanie prototypów funkcji .........................................................................119
Argumenty domyślne ............................................................................................120
Przekazywanie przez wartość i przekazywanie przez referencję .....................122
Typy przechowywania zmiennych ........................................................................123
ROZDZIAŁ 7: Przechowywanie sekwencji w tablicach .....................125
Szeregowanie argumentów w tablicach ..............................................................126
Korzystanie z tablic ...........................................................................................127
Inicjowanie tablic ..............................................................................................130
Sięganie poza zakres tablicy ............................................................................131
Pętle bazujące na zakresach ...........................................................................131
Definiowanie i używanie tablic w tablicach ...................................................132
Korzystanie z tablic znaków ..................................................................................133
Tworzenie tablicy znaków ................................................................................133
Tworzenie ciągu znaków ..................................................................................134
Spis treści
7
Poleć książkęKup książkęManipulowanie ciągami znaków ..........................................................................136
Niektóre funkcje biblioteki standardowej ...........................................................138
Miejsce dla ciągów złożonych z szerokich znaków .............................................139
ROZDZIAŁ 8: Wskaźniki w C++ .............................................................141
Rozmiar zmiennej ..................................................................................................141
Czym jest adres? .....................................................................................................143
Operatory adresu ...................................................................................................143
Używanie wskaźników ...........................................................................................145
Używanie różnych typów wskaźników ...........................................................146
Przekazywanie wskaźników do funkcji ................................................................147
Przekazywanie przez wartość .........................................................................147
Przekazywanie wartości wskaźnikowych .......................................................148
Przekazywanie przez referencję .....................................................................148
Zmienne stałe .........................................................................................................149
Korzystanie ze sterty ..............................................................................................151
Ograniczony zasięg ...........................................................................................151
Analiza problemu zakresu ważności ..............................................................152
Użycie sterty ......................................................................................................153
ROZDZIAŁ 9: Drugie spojrzenie na wskaźniki w C++ ........................155
Definiowanie operacji na wskaźnikach ................................................................155
Użycie wskaźników w tablicach .......................................................................156
Użycie operatorów do adresu tablicy ............................................................158
Operacje wskaźnikowe na ciągach znaków ...................................................159
Uzasadnienie użycia wskaźników ...................................................................161
Stosowanie operatorów do wskaźników innych typów niż char ................161
Porównanie wskaźnika z tablicą .....................................................................162
Wskaźnik null ...........................................................................................................164
Deklaracja i użycie tablic wskaźników ..................................................................165
Wykorzystanie tablic ciągów znaków .............................................................166
Dostęp do argumentów funkcji main() ..........................................................168
ROZDZIAŁ 10: Preprocesor C++ .............................................................173
Co to jest preprocesor? .........................................................................................173
Dołączanie plików ..................................................................................................174
#Definiowanie ........................................................................................................177
A może by tak nie definiować? ........................................................................180
Wyliczeniowy typ danych .................................................................................181
Dołączanie warunkowe z użyciem instrukcji #if .................................................183
Obiekty zdefiniowane wewnętrznie .....................................................................184
Typedef ....................................................................................................................186
8
C++ dla bystrzaków
Poleć książkęKup książkęCZĘŚĆ III: WPROWADZENIE DO KLAS .....................................187
ROZDZIAŁ 11: Programowanie obiektowe ..........................................189
Abstrakcyjne kuchenki mikrofalowe ....................................................................189
Przygotowanie funkcjonalnego nachos .........................................................190
Przygotowywanie nachos w sposób obiektowy ............................................191
Klasyfikacja kuchenki mikrofalowej .....................................................................191
Po co klasyfikujemy przedmioty? .........................................................................192
ROZDZIAŁ 12: Klasy w C++ .....................................................................195
Wprowadzenie do klas ..........................................................................................195
Kształt klasy .............................................................................................................196
Dostęp do elementów klasy ..................................................................................197
Aktywacja obiektów ...............................................................................................197
Symulowanie rzeczywistych obiektów ...........................................................198
Po co zawracać sobie głowę funkcjami składowymi? ...................................198
Dodawanie funkcji składowej ...............................................................................199
Wywoływanie funkcji składowych ........................................................................200
Dostęp do pól z funkcji składowej ..................................................................202
Ustalanie zakresu ...................................................................................................203
Definiowanie funkcji składowych w klasie ..........................................................204
Umieszczanie funkcji składowych poza klasą .....................................................206
Przeciążanie funkcji składowych ..........................................................................208
ROZDZIAŁ 13: Wskazywanie na obiekty ..............................................211
Deklarowanie tablic obiektów ..............................................................................211
Deklarowanie wskaźników do obiektów .............................................................212
Dereferencja wskaźnika obiektu .....................................................................213
Wskazywanie w kierunku strzałek ..................................................................214
Przekazywanie obiektów do funkcji .....................................................................214
Wywoływanie funkcji z wartością obiektu .....................................................215
Wywoływanie funkcji ze wskaźnikiem na obiekt ...........................................216
Wywoływanie funkcji za pomocą operatora referencji ................................217
Po co przejmować się wskaźnikami i referencjami? ..........................................218
Zwracanie do sterty ...............................................................................................219
Alokowanie obiektów ze sterty .......................................................................220
Kiedy kompilator alokuje za Ciebie pamięć? .................................................220
Listy ..........................................................................................................................221
Wykonywanie innych operacji na listach .......................................................222
Wykorzystanie list w programie DaneListyJed ..............................................223
Promyk nadziei: lista kontenerów w bibliotece C++ ..........................................226
Spis treści
9
Poleć książkęKup książkęROZDZIAŁ 14: Chronione elementy składowe klasy ..........................227
Ochrona składowych .............................................................................................227
Dlaczego potrzebujesz składowych chronionych? .......................................228
Jak działają składowe chronione? ...................................................................228
Po co chronić składowe klasy? ..............................................................................230
Ochrona wewnętrznego stanu klasy ..............................................................230
Używanie klasy z ograniczonym interfejsem ................................................231
Dostęp do elementów chronionych z zewnątrz .................................................231
ROZDZIAŁ 15: „Po co mnie tworzysz,
skoro za chwilę chcesz mnie zniszczyć?” ....................235
Tworzenie obiektów ...............................................................................................236
Korzystanie z konstruktorów ................................................................................237
Konstruowanie pojedynczego obiektu ..........................................................237
Konstruowanie wielu obiektów ......................................................................238
Konstruowanie dupleksu .................................................................................239
Dekonstrukcja obiektu ..........................................................................................241
Do czego służy destruktor? .............................................................................241
Praca z destruktorami ......................................................................................242
ROZDZIAŁ 16: Argumenty przekazywane przez konstruktor ...........247
Wyposażenie konstruktorów w argumenty ........................................................248
Korzystanie z konstruktora .............................................................................248
Przeciążanie konstruktora .....................................................................................250
Automatyczne konstruktory domyślne ...............................................................253
Konstruowanie składowych klasy ........................................................................255
Konstruowanie składowej typu złożonego ....................................................255
Konstruowanie składowej, która jest stałą ....................................................261
Rekonstrukcja kolejności konstruowania ............................................................261
Kolejność konstrukcji obiektów lokalnych .....................................................262
Obiekty statyczne są konstruowane tylko raz ...............................................262
Wszystkie obiekty globalne są konstruowane przed funkcją main() ..........263
Obiekty globalne są konstruowane bez określonej kolejności ...................264
Składowe są konstruowane w kolejności,
w jakiej zostały zadeklarowane ....................................................................265
Destruktory niszczą obiekty
w kolejności odwrotnej do kolejności ich tworzenia .................................265
Konstruowanie tablic .............................................................................................265
Konstruktory jako forma konwersji .....................................................................266
10
C++ dla bystrzaków
Poleć książkęKup książkęROZDZIAŁ 17: Konstruktory kopiujący i przenoszący ........................269
Kopiowanie obiektu ...............................................................................................269
Do czego służy konstruktor kopiujący? ..........................................................270
Korzystanie z konstruktora kopiującego .......................................................270
Automatyczny konstruktor kopiujący ..................................................................272
Kopiowanie głębokie i kopiowanie płytkie ..........................................................273
Obiekty tymczasowe ..............................................................................................277
Trwałe unikanie obiektów tymczasowych .....................................................279
Konstruktor przenoszący .................................................................................280
ROZDZIAŁ 18: Składowe statyczne:
czy zmiękczacz tkanin może pomóc? ..........................283
Definiowanie składowej statycznej ......................................................................284
Do czego służą składowe statyczne? ..............................................................284
Używanie składowych statycznych .................................................................284
Odwoływanie się do składowych statycznych ...............................................285
Przypadki użycia składowych statycznych .....................................................287
Deklarowanie statycznych funkcji składowych ...................................................287
O czym to w ogóle jest? .........................................................................................290
CZĘŚĆ IV: DZIEDZICZENIE .........................................................293
ROZDZIAŁ 19: Dziedziczenie ..................................................................295
Czy potrzebuję dziedziczenia? ..............................................................................297
Jak dziedziczy klasa? ...............................................................................................297
Używanie podklasy ...........................................................................................299
Konstruowanie podklasy .................................................................................299
Niszczenie podklasy .........................................................................................301
Dziedziczenie konstruktorów ..........................................................................301
Relacja MA ...............................................................................................................302
ROZDZIAŁ 20: Wirtualne funkcje składowe. Czy są realne? ..............303
Do czego jest potrzebny polimorfizm? ................................................................306
Jak działa polimorfizm? ..........................................................................................307
Kiedy funkcja nie jest wirtualna? ..........................................................................308
Wirtualne rozważania ............................................................................................310
Spis treści
11
Poleć książkęKup książkęROZDZIAŁ 21: Faktoryzacja klas ...........................................................313
Faktoryzacja ............................................................................................................314
Implementacja klas abstrakcyjnych .....................................................................318
Opisywanie koncepcji klasy abstrakcyjnej .....................................................318
Tworzenie klasy konkretnej z klasy abstrakcyjnej ........................................320
Przekazywanie klas abstrakcyjnych ................................................................320
CZĘŚĆ V: BEZPIECZEŃSTWO .....................................................323
ROZDZIAŁ 22: Czy zaakceptujesz nowy operator przypisania? ........325
Porównanie operatorów z funkcjami ..................................................................326
Wstawianie nowego operatora ............................................................................327
Tworzenie płytkich kopii to poważny problem ...................................................327
Przeciążanie operatora przypisania .....................................................................329
Przeciążenie operatora indeksu ...........................................................................333
Konstruktor i operator przenoszący ....................................................................334
ROZDZIAŁ 23: Strumienie wejścia-wyjścia ..........................................337
Jak działa strumień wejścia-wyjścia? ....................................................................338
Domyślne obiekty strumienia .........................................................................338
Strumienie wejścia-wyjścia ....................................................................................340
Tryby otwierania ...............................................................................................341
Hej, pliku, w jakim jesteś stanie? .....................................................................342
Czy możesz mi pokazać przykład? ..................................................................343
Inne metody klas obsługi strumieni .....................................................................346
Bezpośrednie czytanie i zapisywanie strumieni ...........................................348
Zarządzanie formatem .....................................................................................350
O co chodzi z endl? ...........................................................................................351
Umieszczanie wskaźnika w pliku ....................................................................352
Korzystanie z podklas klasy stringstream ...........................................................353
Manipulowanie manipulatorami ..........................................................................356
ROZDZIAŁ 24: Obsługa błędów — wyjątki ...........................................359
Uzasadnienie dla nowego mechanizmu obsługi błędów ..................................361
Działanie mechanizmu wyjątków .........................................................................362
Czym można rzucać? ..............................................................................................365
Uwaga, przechodzę! ...............................................................................................367
12
C++ dla bystrzaków
Poleć książkęKup książkęROZDZIAŁ 25: Dziedziczenie wielokrotne ............................................369
Mechanizm dziedziczenia wielokrotnego ............................................................370
Jak sobie poradzić z niejasnościami dotyczącymi dziedziczenia? .....................371
Dziedziczenie wirtualne .........................................................................................372
Konstruowanie obiektów dziedziczenia wielokrotnego ....................................378
Wyrażanie sprzecznych opinii ...............................................................................379
ROZDZIAŁ 26: Szablony w C++ ...............................................................381
Uogólnianie funkcji do szablonu ..........................................................................382
Szablony klas ..........................................................................................................384
Wskazówki dotyczące korzystania z szablonów .................................................387
Instancje szablonów zewnętrznych .....................................................................388
Implementowanie listy inicjalizacyjnej ................................................................388
ROZDZIAŁ 27: Standaryzacja w bibliotece STL ....................................391
Kontener typu string ..............................................................................................392
Iterowanie po listach .............................................................................................397
Przeglądanie listy ..............................................................................................398
Operacje na całej liście .....................................................................................400
Czy możesz mi pokazać przykład? ..................................................................400
ROZDZIAŁ 28: Pisanie bezpiecznego kodu ...........................................403
Motywy działania hakerów ....................................................................................404
Na czym polega wstrzyknięcie kodu? ..................................................................406
Przykładowe wstrzyknięcie SQL ......................................................................406
Unikanie wstrzykiwania kodu .........................................................................408
Przepełnianie bufora dla zabawy i zysku ............................................................409
Czy mogę zobaczyć przykład? .........................................................................410
Hakerskie wykorzystanie przepełnienia bufora ............................................412
Unikanie przepełnienia bufora — pierwsza próba .......................................416
Unikanie przepełnienia bufora — druga próba ............................................418
Kolejna zaleta klasy string ...............................................................................420
Dlaczego nie zawsze należy używać klasy string? .........................................422
CZĘŚĆ VI: DEKALOGI .................................................................425
ROZDZIAŁ 29: Dziesięć sposobów na zapobieganie błędom .............427
Włączaj wszystkie ostrzeżenia i komunikaty o błędach .....................................427
Koduj w jasnym i spójnym stylu ...........................................................................428
Ograniczaj widoczność ..........................................................................................429
Dodawaj komentarze do kodu w trakcie pisania ...............................................430
Spis treści
13
Poleć książkęKup książkęWykonuj krok po kroku każdą ścieżkę przynajmniej raz ...................................431
Unikaj przeciążania operatorów ...........................................................................431
Zarządzaj stertą systematycznie ..........................................................................431
Używaj wyjątków do obsługi błędów ...................................................................432
Deklaruj wirtualne destruktory ............................................................................432
Unikaj dziedziczenia wielokrotnego .....................................................................434
ROZDZIAŁ 30: Dziesięć sposobów na ochronę programów
przed hakerami ..............................................................435
Nie zakładaj niczego w odniesieniu
do danych wprowadzanych przez użytkowników ...........................................436
Obsługuj awarie z wdziękiem ...............................................................................437
Zapisuj logi programu ............................................................................................438
Postępuj zgodnie z dobrymi zasadami wytwarzania oprogramowania ..........439
Wdrożenie kontroli wersji .....................................................................................440
Bezpiecznie uwierzytelniaj użytkowników ..........................................................441
Zarządzaj zdalnymi sesjami ..................................................................................444
Zaciemniaj swój kod ...............................................................................................445
Podpisz swój kod za pomocą certyfikatu cyfrowego .........................................448
Użyj bezpiecznego szyfrowania wszędzie tam, gdzie jest to konieczne ..........449
CZĘŚĆ VII: DODATKI .................................................................451
Skorowidz .......................................................................453
14
C++ dla bystrzaków
Poleć książkęKup książkęW TYM ROZDZIALE:
Podstawy C++.
Instalowanie Code::Blocks w systemach
Windows, Ubuntu Linux lub Macintosh
OS X.
Tworzenie pierwszego programu w C++.
Uruchamianie programu.
Rozdział 1
Pierwszy program
w C++
O
to jesteśmy: tylko Ty i ja. Nie zwlekajmy, czas zacząć. Na początek przed-
stawię kilka podstawowych pojęć.
Komputer to niesamowicie szybka, ale zarazem niezwykle głupia maszyna. Kom-
puter może zrobić wszystko, co mu powiesz (w granicach rozsądku), ale robi do-
kładnie to, co mu powiesz — nic więcej ani nic mniej.
Zła wiadomość dla nas, ludzi, jest taka, że komputery nie rozumieją niestety
żadnego rozsądnego języka ludzkiego — nie mówią też po polsku. No dobrze,
wiem, co powiesz: „Widziałem komputery, które rozumiały polski”. Właściwie
jednak widziałeś komputer wykonujący program, który potrafił zrozumieć język
polski.
Komputery rozumieją język, który nazywamy językiem komputerowym lub ję-
zykiem maszynowym. Człowiek mógłby posługiwać się językiem maszynowym,
ale byłoby to bardzo trudne. Dlatego komputery i ludzie spotykają się pośrodku
i używają języków pośrednich, takich jak C++. Ludzie rozumieją C++ (poniekąd),
a C++ może zostać przekonwertowany na język maszynowy, aby mógł go zro-
zumieć komputer.
ROZDZIAŁ 1 Pierwszy program w C++
27
Poleć książkęKup książkęPojęcia dotyczące języka C++
Program w C++ jest plikiem tekstowym zawierającym sekwencję komend C++
zgodnych z gramatyką języka C++. Ten plik tekstowy jest określany jako plik źró-
dłowy (prawdopodobnie dlatego, że jest źródłem wszystkich frustracji). Pliki
źródłowe w C++ zwykle zawierają rozszerzenie .CPP, podobnie jak pliki Adobe
Acrobat zawierają rozszerzenie .PDF, a pliki wsadowe MS-DOS (pamiętasz je?)
mają rozszerzenie .BAT.
Celem programowania w C++ jest napisanie sekwencji poleceń, które można
przekształcić na program w języku maszynowym. Dopiero on faktycznie robi to,
co chcemy. Ta konwersja nazywana jest kompilacją i jest zadaniem kompilatora.
Kod maszynowy, który napisałeś, musi być połączony z pewnymi instrukcjami
instalacji i usuwania oraz niektórymi standardowymi procedurami biblioteczny-
mi w procesie zwanym łączeniem lub konsolidacją (ang. linking). Kompilacja razem
z konsolidacją to budowanie. Powstałe pliki wykonywalne maszynowo mają w sys-
temie Windows rozszerzenie .EXE. W systemie Linux lub w komputerach Macintosh
nie zawierają one żadnego konkretnego rozszerzenia.
To brzmi dość prosto — co w tym trudnego? Zatem czytaj dalej.
Aby napisać program, potrzebujesz dwóch specjalistycznych programów kom-
puterowych. Jeden (edytor) służy do pisania kodu podczas tworzenia pliku źró-
dłowego .CPP. Drugi (kompilator) konwertuje plik źródłowy na plik wykonywal-
ny, który faktycznie wykonuje polecenia (otwórz arkusz kalkulacyjny, wydawaj
nieprzyzwoite odgłosy, odbijaj nadlatujące asteroidy czy cokolwiek innego).
Obecnie twórcy narzędzi zazwyczaj łączą kompilator i edytor w jeden pakiet,
nazywany zintegrowanym środowiskiem programistycznym. W takim środo-
wisku, po zakończeniu wprowadzania poleceń, które tworzą program, wystarczy
kliknąć jeden przycisk, aby utworzyć plik wykonywalny.
Na szczęście istnieją darmowe środowiska dla języka C++. W tej książce używam
jednego z nich — Code::Blocks. Ten edytor działa z wieloma różnymi kompila-
torami, ale wersja Code::Blocks w połączeniu z kompilatorem GNU gcc użytym
do napisania tej książki jest dostępna dla systemów Windows i Macintosh oraz dla
różnych wersji systemu Linux — tak jak zostało to opisane w punkcie niniej-
szego rozdziału poświęconym instalacji.
Code::Blocks jest darmową aplikacją Jednak jeśli chcesz, możesz wesprzeć jej
dalszy rozwój. Zachęcam do wpłacenia niewielkiej darowizny na ten cel. Wcale
nie musisz płacić, żeby używać Code::Blocks, ale możesz mieć swój wkład, jeśli
chcesz. Szczegółowe informacje można znaleźć w witrynie Code::Blocks.
Przetestowałem programy w tej książce za pomocą Code::Blocks 13.12, który jest
wyposażony w gcc w wersji 4.7.1. Ta wersja gcc implementuje większość dodat-
ków ze standardu C++ 2011.
28
CZĘŚĆ I Podstawy programowania w C++
Poleć książkęKup książkęMożesz użyć innych wersji gcc lub nawet innych kompilatorów, ale mogą one nie
implementować pełnego standardu 2011. Z tego powodu rozszerzenia 2011 są
oznaczone ikoną „11” widoczną tutaj.
Użyty w tej książce kompilator gcc nie implementuje żadnego z rozszerzeń do-
danych w standardzie C++ 2014, ale uwzględniłem je tam, gdzie ma to zastoso-
wanie, ponieważ są już dostępne nowsze wersje.
Muszę się do czegoś przyznać: ta książka jest w pewnym sensie ukierunkowana
na Windowsa. Wszystkie programy w książce przetestowałem w systemach Win-
dows 2000/XP/Vista/7/8, Ubuntu Linux i Macintosh OS X. Różnice występujące
pomiędzy systemami operacyjnymi zaznaczyłem w tekście.
Dodatkowo w tym rozdziale zamieściłem instrukcje instalacji dla każdego z trzech
wymienionych powyżej systemów operacyjnych. Wersje Code::Blocks i gcc są
dostępne dla innych odmian systemu Linux i innych wersji systemu operacyj-
nego Macintosh. Programy powinny także z nimi współpracować.
Pakiet Code::Blocks/gcc generuje programy 32-bitowe. Nie umożliwia jednak
łatwego tworzenia programów „okienkowych”. Programy w tej książce urucha-
miane są z wiersza poleceń i wyświetlają wynik w wierszu poleceń. Mimo że
wydaje się to nudne, stanowczo zalecam, abyś najpierw zapoznał się z przykła-
dami z tej książki, aby nauczyć się C++, zanim zajmiesz się tworzeniem aplikacji
okienkowych. C++ i programowanie w systemie Windows to dwie różne rzeczy
i (z uwagi na Twoje zdrowie psychiczne) powinny jako takie pozostać w Twojej
głowie.
Postępuj zgodnie z procedurą opisaną w następnym podrozdziale, aby zainsta-
lować Code::Blocks, a następnie zbuduj swój pierwszy program w C++. Zadaniem
tego programu jest konwersja temperatury wprowadzonej przez użytkownika ze
stopni Celsjusza na stopnie Fahrenheita.
Instalacja Code::Blocks
Ze strony http://www.codeblocks.org/downloads/binaries możesz pobrać najnowszą
wersję środowiska Code::Blocks dla systemów: Windows, Ubuntu Linux i Ma-
cintosh OS X. Postępuj zgodnie z zamieszczonymi poniżej instrukcjami instalacji
dotyczącymi Twojego systemu operacyjnego.
Windows
Środowisko Code::Blocks jest dostępne w łatwym do zainstalowania, skompreso-
wanym pliku wykonywalnym, który jest zgodny ze wszystkimi wersjami systemu
Windows począwszy od wersji Windows 2000. Oto sposób instalacji środowiska:
ROZDZIAŁ 1 Pierwszy program w C++
29
Poleć książkęKup książkę 1. Pobierz plik wykonywalny codeblocks-13.12.mingw-setup.exe ze strony
http://www.codeblocks.org/downloads/source/5.
Zapisz plik wykonywalny na pulpicie lub w innym miejscu, które można łatwo znaleźć.
Wspomniany plik wykonywalny zawiera wersję kompilatora GCC 4.71. Nie jest to
najnowsza wersja GCC, ale właśnie tej wersji użyłem podczas pisania tej książki.
W chwili powstawania jej tłumaczenia najnowszą dostępną wersją Code::Blocks
jest wersja 17.12. Można ją pobrać ze strony
http://www.codeblocks.org/downloads/binaries. Ostatnia dostępna wersja dla Mac
OS X to 13.12. To tej wersji będziemy używać.
2. Po zakończeniu pobierania kliknij dwukrotnie ikonę programu.
3. W zależności od używanej wersji systemu Windows może pojawić się
wyskakujące okienko „Niezidentyfikowany program chce uzyskać dostęp
do komputera”. Jeśli tak się stanie, kliknij Zezwól, aby rozpocząć instalację.
4. Po zamknięciu wszystkich aplikacji zewnętrznych, tak jak zostanie to
wyświetlone w oknie dialogowym Welcome to the CodeBlocks Setup Wizard
(witaj w instalatorze CodeBlocks), kliknij przycisk Next (dalej).
5. Przeczytaj Umowę licencyjną użytkownika końcowego (powszechnie znaną
jako EULA), a następnie kliknij przycisk I Agree, jeśli zgadzasz się z jej
postanowieniami.
Nie masz dużego wyboru — jeśli nie zaakceptujesz licencji, pakiet się nie
zainstaluje. Załóżmy jednak, że się zgodzisz. Instalator Code::Blocks otworzy
okno dialogowe z opcjami instalacji. Opcje domyślne są dla nas wystarczające.
6. Kliknij przycisk Next.
Program instalacyjny pozwala zainstalować tylko niektóre podzbiory funkcjonalności.
Musisz wybrać przynajmniej instalację domyślną i pakiet MinGW Compiler Suite.
Najlepszym wyjściem jest zainstalowanie wszystkich opcji, tak jak jest to
zaznaczone domyślnie.
Jeśli nie ma opcji MinGW Compiler Suite, prawdopodobnie pobrałeś wersję
Code::Blocks, która nie zawiera gcc. Ta wersja nie będzie działać poprawnie.
7. Po kolejnym kliknięciu przycisku Next pojawi się zapytanie o folder
instalacji; kliknij Install, aby zaakceptować domyślny folder docelowy.
Instalator Code::Blocks rozpocznie kopiowanie wszystkich potrzebnych plików
na Twój dysk twardy. Po zakończeniu zapyta: Do you want to run Code::Blocks now?
(Czy chcesz teraz uruchomić Code::Blocks?).
8. Kliknij Yes (lub Tak), aby uruchomić Code::Blocks.
Code::Blocks zapyta teraz, którego kompilatora użyć. Domyślny kompilator to
GNU GCC. To jest właściwy wybór.
9. Z poziomu okna głównego Code::Blocks wybierz Settings/Compiler.
30
CZĘŚĆ I Podstawy programowania w C++
Poleć książkęKup książkę 10. Wybierz zakładkę Compiler Flags (flagi kompilatora).
11. Upewnij się, że wybrano następujące trzy flagi (patrz rysunek 1.1):
Enable All Compiler Warnings (włącz wszystkie ostrzeżenia kompilatora);
Have g++ Follow the Coming C++0x ISO C++ Language Standard (niech g++
postępuje zgodnie z nadchodzącym standardem C++ 0x ISO C++);
Have g++ Follow the C++11 ISO C++ Language Standard (niech g++ postępuje
zgodnie ze standardem C++11 ISO C++).
Standard C++ 2011 pierwotnie miał być standardem C++ 2008 lub 2009. Ponieważ
nie było to jasne, standard zyskał popularność pod nazwą 0x. Standard nie został
całkowicie zaakceptowany do 2011 roku. W środowisku kompilatora gcc języki C++ 0x
i C++ 11 odnoszą się do tego samego standardu.
RYSUNEK 1.1.
Upewnij się,
że ustawiona jest
flaga Enable All
Compiler Warnings
12. Wybierz zakładkę Toolchain Executables (pliki wykonywalne zestawu
narzędzi). Upewnij się, że wygląda tak, jak pokazano na rysunku 1.2.
Domyślną lokalizacją kompilatora gcc jest podkatalog MinGW\bin katalogu
Code::Blocks.
Jeśli domyślna lokalizacja jest pusta, Code::Blocks nie będzie wiedział, gdzie jest
kompilator gcc, i nie będzie mógł budować programów. Upewnij się, że pobrałeś
wersję Code::Blocks, która zawiera gcc, oraz że zaznaczyłeś właściwą opcję
podczas instalacji. Jeśli używasz kompilatora gcc zainstalowanego wcześniej,
powinieneś wskazać programowi Code::Blocks miejsce na dysku twardym, w którym
się on znajduje.
ROZDZIAŁ 1 Pierwszy program w C++
31
Poleć książkęKup książkęRYSUNEK 1.2.
Upewnij się,
że katalog
instalacyjny
kompilatora jest
poprawny
13. Zamknij okno dialogowe ustawień — Compiler Settings.
14. Kliknij Next w oknie dialogowym instalatora Code::Blocks, a następnie kliknij
Finish (zakończ), aby zakończyć program instalacyjny.
Program instalacyjny zakończy działanie.
Ubuntu Linux
W systemie Linux instalacja jest procesem dwuetapowym, ponieważ Code::Blocks
dla Linuksa nie zawiera gcc. Najpierw trzeba zainstalować gcc, a następnie Code::
Blocks.
Instalacja gcc
Kompilator gcc dla Linuksa jest łatwo dostępny. Aby go zainstalować, uruchom
terminal i wykonaj następujące czynności:
1. Wprowadź następujące polecenia z wiersza poleceń:
sudo apt-get update
sudo apt-get upgrade
sudo apt-get install g++
Standardowa dystrybucja Ubuntu Linux zawiera kompilator GNU C, ale nie
obejmuje rozszerzeń C++. W szczególności nie zawiera rozszerzeń standardu C++
2011. Pierwsze dwa polecenia aktualizują narzędzia, które już masz. Trzecie
polecenie instaluje C++.
32
CZĘŚĆ I Podstawy programowania w C++
Poleć książkęKup książkę 2. Wprowadź następujące polecenie z wiersza poleceń:
gcc –-version
Mój Ubuntu 18.04 pobrał GNU C++ w wersji 7.4.0. Na potrzeby przykładów z tej
książki wersja 4.7.1 jest wystarczająca. Jeśli masz wcześniejszą wersję, niektóre
funkcje C++ 2011 mogą nie działać poprawnie. Poza tym wszystko powinno działać
jak należy.
Jeśli używasz Debiana, polecenia są takie same. Jeśli używasz Red Hata, zamiast
programu apt-get zastosuj program yum. Polecenie instalacji dla Red Hata
wygląda następująco:
sudo yum install g++
Instalacja Code::Blocks
Wersja Code::Blocks gotowa do użycia w Ubuntu jest dostępna w Ubuntu Software
Center (Centrum Oprogramowania Ubuntu). Na szczęście dla wszystkich zainte-
resowanych wiele innych wersji systemu Linux zawiera coś podobnego do Centrum
Oprogramowania. Aby zainstalować Code::Blocks, wykonaj poniższe czynności:
1. Kliknij ikonę Centrum Oprogramowania na pulpicie Ubuntu.
2. Wybierz Code::Blocks z listy dostępnego oprogramowania.
Rozpocznie się proces instalacji.
Code::Blocks przeszukuje dysk twardy w poszukiwaniu kompilatora C++. Powinien
być w stanie go znaleźć bez problemu, ale jeśli tego nie zrobi, wykonaj poniższe
kroki.
3. Uruchom Code::Blocks.
4. Wybierz Settings/Compiler (ustawienia kompilatora).
5. Wybierz zakładkę Compiler Flags (flagi kompilatora).
6. Upewnij się, że wybrałeś następujące trzy flagi (patrz rysunek 1.1):
Enable All Compiler Warnings (włącz wszystkie ostrzeżenia kompilatora);
Have g++ Follow the Coming C++0x ISO C++ Language Standard (niech g ++
postępuje zgodnie z nadchodzącym standardem C++ 0x ISO C++);
Have g++ Follow the C++11 ISO C++ Language Standard (niech g++ postępuje
zgodnie ze standardem C++11 ISO C++).
7. Wybierz zakładkę Toolchain Executables (pliki wykonywalne zestawu
narzędzi).
8. Kliknij przycisk ....
9. Przejdź do /usr, chyba że zainstalowałeś kompilator gcc w innym miejscu niż
domyślna lokalizacja /usr/bin.
ROZDZIAŁ 1 Pierwszy program w C++
33
Poleć książkęKup książkę 10. W formularzu, w polu C compiler należy wpisać gcc, w polu C++ compiler
należy wybrać g++, w polu Linker for dynamic libs również należy wybrać g++.
11. Wybierz OK, aby zamknąć okno dialogowe.
Macintosh
Wersja Code::Blocks dla komputerów Macintosh używa dystrybucji Xcode firmy
Apple jako kompilatora. Z tego powodu podzieliłem instalację na trzy części.
Instalacja Xcode
Potrzebne jest darmowe środowisko programistyczne oferowane przez Apple,
czyli Xcode. Aby je zainstalować, wykonaj poniższe czynności:
1. Otwórz przeglądarkę Safari i przejdź na stronę http://developer.apple.com.
2. Kliknij Download Xcode (pobierz Xcode), aby pobrać najnowszą wersję
programu.
Spowoduje to otwarcie okna dialogowego pobierania Xcode, pokazanego na
rysunku 1.3.
RYSUNEK 1.3.
Okno dialogowe
pobierania Xcode
pozwala zainstalować
Xcode za darmo
3. Kliknij przycisk Free, aby zmienił się na Install App (zainstaluj aplikację).
4. Możesz zostać poproszony o wprowadzenie hasła systemowego (którym
logujesz się podczas uruchamiania komputera Mac).
Ikona zmieni się na Installing.
Pobieranie i instalacja zajmuje trochę czasu (w chwili pisania przeze mnie tego
tekstu archiwum z Xcode miało nieco ponad 2 GB).
34
CZĘŚĆ I Podstawy programowania w C++
Poleć książkęKup książkęInstalowanie narzędzi wiersza polecenia
Można by się spodziewać, że tak duży program jak Xcode ma wszystko, czego
potrzebuje. Nic bardziej mylnego. Do uzyskania działającego kompilatora gcc na
komputerze Macintosh potrzebny jest jeszcze jeden pakiet firmy Apple. Aby za-
instalować narzędzia wiersza poleceń dla Xcode, postępuj zgodnie z poniższą
procedurą:
1. Otwórz przeglądarkę Safari i przejdź na stronę http://developer.apple.com/
downloads.
Możesz zostać poproszony o zarejestrowanie identyfikatora Apple Developer ID.
Bez obaw, to nic nie kosztuje.
2. Wyszukaj narzędzia wiersza poleceń dla Xcode. Wybierz aplikację pokazaną
na rysunku 1.4. Następnie kliknij ikonę Download.
RYSUNEK 1.4.
Aby przygotować
kompilator dla
macintosha, musisz
zainstalować zarówno
Xcode, jak
i Command Line
Tools dla Xcode
3. Kliknij dwukrotnie pobrany pakiet mpkg, aby go zainstalować.
4. Zaakceptuj wszystkie wartości domyślne.
Instalacja powinna zakończyć się powodzeniem.
ROZDZIAŁ 1 Pierwszy program w C++
35
Poleć książkęKup książkęInstalacja Code::Blocks
Teraz możesz dokończyć instalację, pobierając i instalując edytor Code::Blocks:
1. Otwórz przeglądarkę Safari i przejdź na stronę www.codeblocks.org/
downloads.
2. Kliknij Downloads/Binaries (pobierz/binaria).
3. Kliknij Mac OS X.
4. Wybierz jedno ze źródeł plików, aby pobrać najnowszą wersję.
W chwili powstawania tego tekstu najnowsza dostępna wersja to CodeBlocks-
13.12-mac.zip.
5. Zainstaluj pobrany plik Zip w folderze Applications.
Jeśli nigdy nie instalowałeś aplikacji z witryny innej firmy, zanim będziesz mógł
to zrobić, być może będziesz musiał wykonać poniższe dodatkowe operacje:
a) kliknąć System Preferences (preferencje systemowe);
b) kliknąć Security and Privacy (bezpieczeństwo i prywatność);
c) kliknąć kłódkę w lewym dolnym rogu okna dialogowego, aby zezwolić na zmiany;
d) w formularzu Allow applications downloaded from (zezwalaj na pobieranie aplikacji
z) kliknąć opcję Anywhere (skądkolwiek), tak jak pokazano na rysunku 1.5.
RYSUNEK 1.5.
Przed instalacją
Code::Blocks
w Twoim systemie
Macintosh trzeba
zainstalować inne
aplikacje
Po zakończeniu instalacji Code::Blocks możesz powrócić do tego okna
dialogowego i przywrócić domyślną wartość ustawień (Mac App Store).
36
CZĘŚĆ I Podstawy programowania w C++
Poleć książkęKup książkę 6. Kliknij dwukrotnie ikonę Code::Blocks.
Przy pierwszym uruchomieniu system Mac OS zapyta Cię, czy na pewno chcesz go
otworzyć.
7. Wybierz Don’t Warn Me When Opening Applications on This Disk Image (nie
ostrzegaj mnie przy otwieraniu aplikacji na obrazie dysku) i kliknij Open
(otwórz).
Code::Blocks powinien się uruchomić i znaleźć zainstalowany kompilator gcc wraz
z narzędziami wiersza polecenia.
8. Wybierz kompilator gcc, jak pokazano na rysunku 1.6. Kliknij Set as Default
(ustaw jako domyślny). Aby kontynuować uruchamianie Code::Blocks, kliknij OK.
Code::Blocks otworzy stronę z banerem, a następnie wyświetli menu w górnej
części okna dialogowego.
RYSUNEK 1.6.
Code::Blocks przy
pierwszym
uruchomieniu
automatycznie
znajduje
zainstalowany
kompilator gcc
9. Wybierz Settings/Compiler (ustawienia kompilatora), następnie kliknij opcję
Have g ++ Follow the Coming C++ 0x ISO C++ Language Standard (niech g++
postępuje zgodnie z nadchodzącym standardem C++ 0x ISO C++). Kliknij OK,
aby zamknąć okno dialogowe.
Teraz jesteś gotowy do utworzenia pierwszego programu w C++.
Tworzenie pierwszego programu w C++
W tym podrozdziale utworzysz swój pierwszy program w C++. Kod C++ wpro-
wadzimy w pliku o nazwie CONVERT.CPP, a następnie skonwertujemy ten kod na
program wykonywalny.
ROZDZIAŁ 1 Pierwszy program w C++
37
Poleć książkęKup książkęTworzenie projektu
Pierwszym krokiem na drodze do stworzenia programu w C++ jest opracowanie
projektu. Projekt w Code::Blocks definiuje nazwy plików źródłowych .CPP, które
mają zostać dołączone, oraz typ programu do utworzenia. Większość programów
w książce składa się z jednego pliku źródłowego i jest uruchamiana z wiersza
poleceń.
1. Uruchom środowisko Code::Blocks.
2. W oknie Code::Blocks wybierz File/New/Project (plik/nowy/projekt).
3. Wybierz ikonę Console Application (aplikacji konsoli), a następnie kliknij
przycisk Go (przejdź).
4. W następnym oknie dialogowym wybierz C++ jako język, którego chcesz
używać. Kliknij Next (następny).
Code::Blocks i gcc umożliwiają również pisanie programów w języku C.
5. W polu Folder to Build Project In (folder do budowy projektu) wybierz ikonę ....
6. W systemie Windows kliknij Ten Komputer, a następnie dysk C:.
W systemach Linux i Macintosh możesz wybrać Pulpit.
7. Wybierz przycisk Utwórz nowy folder w lewym dolnym rogu ekranu.
8. Nazwij nowy folder CPP_Programs.
Wynik powinien wyglądać tak, jak pokazano na rysunku 1.7.
RYSUNEK 1.7.
W systemie Windows
umieść swój projekt
w folderze
C:\CPP_Programs
38
CZĘŚĆ I Podstawy programowania w C++
Poleć książkęKup książkę 9. W polu Project title (tytuł projektu) wpisz nazwę projektu, w tym przypadku
Conversion.
Ekran wynikowy w systemie Windows pokazano na rysunku 1.8. Wersje dla
systemów Linux i Macintosh nie niczym się od niego różnią, z wyjątkiem ścieżki.
RYSUNEK 1.8.
Tworzenie projektu
Conversion dla
pierwszego programu
10. Kliknij Next.
Następne okno dialogowe pozwala na modyfikację nazwy pliku i ścieżki, gdzie
będą zapisywały się skompilowane pliki programu, zarówno wersji do testowania,
jak i ostatecznej. Możesz zostawić domyślne wartości.
11. Kliknij przycisk Finish (zakończ), aby utworzyć projekt Conversion.
Wprowadzanie kodu w języku C++
Projekt Conversion, który stworzył Code::Blocks, składa się z pojedynczego pliku
main.cpp, wyświetlającego komunikat Hello, world. Teraz wprowadź kod programu:
1. Kliknij dwukrotnie plik main.cpp, który znajduje się w oknie dialogowym
Management (zarządzanie) po lewej stronie. Plik jest zagnieżdżony w węzłach
Conversion/Sources.
Jak pokazano na rysunku 1.9, Code::Blocks otwiera w edytorze kodu domyślny
program main.cpp.
ROZDZIAŁ 1 Pierwszy program w C++
39
Poleć książkęKup książkęRYSUNEK 1.9.
Okno dialogowe
Management
wyświetla strukturę
katalogów wszystkich
dostępnych
programów
2. Zastąp zawartość pliku main.cpp kodem podanym poniżej.
Nie przejmuj się zbytnio wcięciami lub odstępami — nie ma znaczenia, czy dana
linia jest wcięta na dwie spacje, czy na trzy. Tak samo nie ma znaczenia, czy między
słowami jest jedna spacja, czy są dwie spacje. Musisz się upewnić, że wszystkie
litery są małe, ponieważ kompilator C++ rozróżnia wielkość liter.
Możesz użyć ściągawki dostępnej w plikach na stronie www.dummies.com/extra/
cplusplus, tak jak to zostało opisane w następnym punkcie.
//
// Conversion — Program do konwersji temperatury ze
// Stopni Celsjusza na stopnie Fahrenheita:
// Fahrenheit = Celsjusz * (212 - 32)/100 + 32
//
#include cstdio
#include cstdlib
#include iostream
using namespace std;
int main(int nNumberofArgs, char* pszArgs[])
{
// wprowadź temperaturę w stopniach Celsjusza
int celsius;
cout Wprowadź temperaturę w stopniach Celsjusza: ;
cin celsius;
// dokonaj konwersji stopni Celsjusza
// na stopnie Fahrenheita
int factor;
factor = 212 - 32;
// użyj przelicznika do przeliczenia stopni Celsjusza
// na stopnie Fahrenheita
int fahrenheit;
fahrenheit = factor * celsius/100 + 32;
40
CZĘŚĆ I Podstawy programowania w C++
Poleć książkęKup książkę // wyświetl wyniki (a następnie znak przejścia do nowego wiersza)
cout Wartość w stopniach Fahrenheita to: ;
cout fahrenheit endl;
// Aby pozwolić użytkownikowi zobaczyć wyniki programu,
// poczekaj, aż użytkownik będzie gotowy przed zakończeniem programu.
cout Naciśnij Enter, aby kontynuować... endl;
cin.ignore(10, \n );
cin.get();
return 0;
}
3. Wybierz File/Save, aby zapisać plik źródłowy.
Może nie wydaje Ci się to ekscytujące, ale właśnie stworzyłeś swój pierwszy
program C++!
Korzystanie ze ściągawki
Wszystkie programy w książce są dostępne online wraz z plikami projektu do ich
tworzenia. Aby z nich skorzystać, musisz je pobrać i zainstalować. Następnie
postępuj zgodnie z poniższą procedurą:
Poniższe instrukcje dotyczą systemu Windows. Czynności, które należy wykonać
dla Linuksa czy Macintosha, są bardzo podobne.
1. Otwórz przeglądarkę internetową.
2. Przejdź na stronę https://www.dummies.com/store/product/C-For-Dummies-6th-Edition.
productCd-0470317264,navId-322468,descCd-DOWNLOAD.html.
3. Kliknij link do C++ Code files.
Może wyświetlić się okno dialogowe z pytaniem, gdzie zapisać pobrany plik.
4. Kliknij Zapisz plik.
System operacyjny skopiuje plik CPP_programs.zip do wskazanej w poprzednim
kroku lokalizacji lub do domyślnej lokalizacji pobierania.
5. Kliknij prawym przyciskiem myszy plik CPP_programs.zip i wybierz Otwórz.
Otworzy się okno dialogowe zawierające pojedynczy katalog CPP_Programs.
6. Skopiuj ten folder na dysk C.
Spowoduje to skopiowanie wszystkich plików źródłowych użytych w książce do
katalogu C:\CPP_Programs.
Możesz umieścić folder CPP_Programs w innym miejscu. Pamiętaj, aby nie umiesz-
czać plików źródłowych w katalogu, do którego ścieżka zawiera spację. W syste-
mie Windows uważaj, żeby nie umieszczać plików, których używa Code::Blocks,
w folderach takich jak Moje dokumenty czy Pulpit, ponieważ ścieżka do nich za-
wiera spację.
ROZDZIAŁ 1 Pierwszy program w C++
41
Poleć książkęKup książkęSą dwa sposoby korzystania z tych plików. Jednym z nich jest utworzenie pro-
gramu ręcznie poprzez wykonanie procedury opisanej w tej książce. W razie popeł-
nienia błędu możesz skopiować i wkleić kod z pobranych plików do swojego pro-
gramu. Jest to sposób zalecany.
Drugie podejście polega na korzystaniu bezpośrednio z pobranych źródeł i pliku
projektu:
1. Kliknij dwukrotnie plik AllPrograms.workspace w folderze C:\CPP_Programs.
Rozszerzenie workspace charakteryzuje plik, który odwołuje się do jednego
lub większej liczby projektów. Plik AllPrograms.workspace zawiera odwołania
do wszystkich projektów z tej książki.
2. Kliknij prawym przyciskiem myszy projekt Conversion w oknie dialogowym
Management po lewej stronie. Następnie z wyświetlonego menu
kontekstowego wybierz Activate project.
Program, który jest aktywny, ma pogrubioną etykietę. W tym przypadku jest to
projekt Conversion. Gdy wydajesz polecenie budowania — Build, Code::Blocks
zawsze tworzy aktywny projekt.
3. Aby otworzyć plik w edytorze, kliknij dwukrotnie plik main.cpp.
Problem z tym podejściem polega na tym, że jeśli sam nie wprowadzasz kodu
w C++, nie uczysz się języka zbyt skutecznie.
Budowanie programu
Po zapisaniu pliku źródłowego w C++ na dysku twardym nadszedł czas na wyge-
nerowanie wykonywalnych instrukcji maszynowych.
Aby zbudować program Conversion, wybierz polecenie Build/Build z paska poleceń
lub wciśnij Ctrl+F9. Niemal natychmiast Code::Blocks rozpocznie proces kompi-
lacji programu. Jeśli wszystko pójdzie dobrze, w prawym dolnym oknie dialogowym
wyświetli się komunikat z liczbą błędów i liczbą ostrzeżeń równymi 0. Przykład
pr
Pobierz darmowy fragment (pdf)