Darmowy fragment publikacji:
Tytuł oryginału: Sams Teach Yourself C++ in 24 Hours, 6th Edition
Tłumaczenie: Robert Górczyński
Projekt okładki: Studio Gravite / Olsztyn
Obarek, Pokoński, Pazdrijowski, Zaprucki
ISBN: 978-83-283-3551-6
Authorized translation from the English language edition: SAMS TEACH YOURSELF C++
IN 24 HOURS, 6TH EDITION; ISBN 0672337460; by Rogers Cadenhead and Jesse Liberty;
published by Pearson Education, Inc, publishing as SAMS Publishing.
Copyright © 2017 by Pearson Education, Inc.
All rights reserved. No part of this book may be reproduced or transmitted in any form
or by any means, electronic or mechanical, including photocopying, recording or by any
information storage retrieval system, without permission from Pearson Education Inc.
Polish language edition published by HELION S.A. Copyright © 2017.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym
powoduje naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi
bądź towarowymi ich właścicieli.
Autor oraz Wydawnictwo HELION 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
Wydawnictwo HELION 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.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/cpp246.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/cpp246
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis treści
CZĘŚĆ I
Godzina 1. Twój pierwszy program ............................................................. 17
Godzina 2. Organizacja elementów programu ............................................ 25
O autorach ................................................................................ 11
Wprowadzenie .......................................................................... 13
PODSTAWY C++
Użycie C++ ............................................................................................................................17
Kompilacja i linkowanie kodu źródłowego ...........................................................18
Utworzenie pierwszego programu ...........................................................................19
Podsumowanie ...................................................................................................................21
Pytania i odpowiedzi .......................................................................................................21
Warsztaty ..............................................................................................................................22
Dlaczego warto używać C++? ......................................................................................25
Poszczególne elementy programu ............................................................................29
Komentarze .........................................................................................................................31
Funkcje ...................................................................................................................................32
Podsumowanie ...................................................................................................................35
Pytania i odpowiedzi .......................................................................................................35
Warsztaty ..............................................................................................................................36
Czym jest zmienna? ..........................................................................................................39
Definiowanie zmiennej ...................................................................................................43
Przypisanie wartości zmiennej ...................................................................................45
Użycie definicji typu .........................................................................................................46
Stałe .........................................................................................................................................47
Zmienne o automatycznie ustalanym typie ..........................................................50
Podsumowanie ...................................................................................................................52
Pytania i odpowiedzi .......................................................................................................52
Warsztaty ..............................................................................................................................54
Godzina 3. Tworzenie zmiennych i stałych .................................................. 39
Poleć książkęKup książkę4
Spis treści
Godzina 6. Sterowanie przebiegiem działania programu ............................ 95
Godzina 7. Przechowywanie informacji w tablicach
Godzina 5. Wywoływanie funkcji ................................................................ 77
Godzina 4. Użycie wyrażeń, poleceń i operatorów ...................................... 57
Polecenia ...............................................................................................................................57
Wyrażenia .............................................................................................................................58
Operatory ..............................................................................................................................59
Konstrukcja warunkowa if‐else .................................................................................66
Operatory logiczne ...........................................................................................................70
Trudne do obliczenia wartości wyrażeń ................................................................72
Podsumowanie ...................................................................................................................72
Pytania i odpowiedzi .......................................................................................................73
Warsztaty ..............................................................................................................................74
Czym jest funkcja? ............................................................................................................77
Deklarowanie i definiowanie funkcji .......................................................................77
Użycie zmiennych w funkcjach ...................................................................................80
Parametry funkcji .............................................................................................................83
Zwrot wartości z funkcji ................................................................................................84
Parametry domyślne funkcji ........................................................................................86
Przeciążanie funkcji .........................................................................................................88
Automatyczne ustalenie typu wartości zwrotnej ..............................................89
Podsumowanie ...................................................................................................................91
Pytania i odpowiedzi .......................................................................................................91
Warsztaty ..............................................................................................................................92
Pętle .........................................................................................................................................95
Pętla while ............................................................................................................................95
Pętla do‐while .....................................................................................................................99
Pętla for ...............................................................................................................................100
Konstrukcja switch .........................................................................................................105
Podsumowanie .................................................................................................................107
Pytania i odpowiedzi .....................................................................................................108
Warsztaty ............................................................................................................................109
Czym jest tablica? ............................................................................................................111
Zapis za końcem tablicy ...............................................................................................113
Inicjalizacja tablicy .........................................................................................................114
Tablica wielowymiarowa ............................................................................................115
i ciągach tekstowych ............................................................... 111
Poleć książkęKup książkę5
CZĘŚĆ II
Godzina 8. Tworzenie prostych klas .......................................................... 127
KLASY
Spis treści
Tablica znaków ...............................................................................................................118
Kopiowanie ciągu tekstowego .................................................................................120
Odczytywanie tablicy za pomocą pętli foreach ................................................121
Podsumowanie ................................................................................................................122
Pytania i odpowiedzi ....................................................................................................123
Warsztaty ...........................................................................................................................124
Czym jest typ? ..................................................................................................................127
Utworzenie nowego typu ...........................................................................................127
Klasy i elementy składowe ........................................................................................128
Dostęp do elementów składowych klasy ............................................................130
Dostęp prywatny kontra publiczny .......................................................................130
Implementacja metod składowych ........................................................................131
Tworzenie i usuwanie obiektów .............................................................................134
Podsumowanie ................................................................................................................138
Pytania i odpowiedzi ....................................................................................................138
Warsztaty ...........................................................................................................................139
Metody składowe typu const ....................................................................................141
Interfejs kontra implementacja ...............................................................................142
Sposób zorganizowania deklaracji klasy i definicji metod .........................142
Implementacja inline ....................................................................................................142
Klasy, których danymi składowymi są inne klasy ..........................................145
Podsumowanie ................................................................................................................149
Pytania i odpowiedzi ....................................................................................................150
Warsztaty ...........................................................................................................................151
Poznajemy wskaźnik i jego przeznaczenie ........................................................153
Stos i sterta ........................................................................................................................163
Wskaźnik null ..................................................................................................................167
Podsumowanie ................................................................................................................169
Pytania i odpowiedzi ....................................................................................................169
Warsztaty ...........................................................................................................................170
CZĘŚĆ III ZARZĄDZANIE PAMIĘCIĄ
Godzina 10. Tworzenie wskaźników ........................................................... 153
Godzina 9. Przejście do klas zaawansowanych .......................................... 141
Poleć książkęKup książkę6
Spis treści
Godzina 11. Praca z zaawansowanymi wskaźnikami .................................. 173
Godzina 12. Tworzenie referencji ................................................................ 185
Tworzenie obiektów na stercie ................................................................................173
Usuwanie obiektów ze sterty ....................................................................................173
Dostęp do danych składowych za pomocą wskaźników ..............................175
Dane składowe na stercie ...........................................................................................176
Wskaźnik this ....................................................................................................................178
Utracone wskaźniki ........................................................................................................179
Wskaźniki const ...............................................................................................................180
Wskaźniki const i metody składowe const .........................................................181
Podsumowanie .................................................................................................................182
Pytania i odpowiedzi .....................................................................................................183
Warsztaty ............................................................................................................................183
Czym jest referencja? ....................................................................................................185
Utworzenie referencji ...................................................................................................185
Użycie operatora adresu ( ) z referencją ...........................................................187
Kiedy można stosować referencję? ........................................................................189
Zerowe wskaźniki i zerowe referencje .................................................................190
Przekazywanie argumentów funkcji przez referencję ..................................190
Nagłówki i prototypy funkcji .....................................................................................194
Zwracanie kilku wartości ............................................................................................195
Podsumowanie .................................................................................................................198
Pytania i odpowiedzi .....................................................................................................198
Warsztaty ............................................................................................................................199
Przekazywanie przez referencje zwiększa
efektywność działania programu ........................................................................201
Przekazywanie wskaźnika const .............................................................................204
Referencje jako alternatywa dla wskaźników ...................................................207
Kiedy używać wskaźników, a kiedy referencji ..................................................209
Zwracanie referencji do obiektu, którego nie ma w danym zasięgu .......209
Problem związany ze zwracaniem referencji do obiektu na stercie .......210
Wskaźnik, wskaźnik, kto ma wskaźnik? ...............................................................212
Podsumowanie .................................................................................................................213
Pytania i odpowiedzi .....................................................................................................213
Warsztaty ............................................................................................................................214
Godzina 13. Zaawansowane referencje i wskaźniki ..................................... 201
Poleć książkęKup książkę
Spis treści
7
CZĘŚĆ IV ZAAWANSOWANY C++
Godzina 14. Wywoływanie funkcji zaawansowanych ................................. 217
Godzina 15. Przeciążanie operatorów ......................................................... 231
Przeciążanie metod składowych .............................................................................217
Użycie wartości domyślnych ....................................................................................219
Inicjalizacja obiektów ..................................................................................................221
Konstruktor kopiujący .................................................................................................222
Wyrażenia stałych podczas kompilacji ................................................................226
Podsumowanie ................................................................................................................228
Pytania i odpowiedzi ....................................................................................................228
Warsztaty ...........................................................................................................................229
Przeciążanie operatorów ...........................................................................................231
Operatory konwersji ....................................................................................................241
Podsumowanie ................................................................................................................244
Pytania i odpowiedzi ....................................................................................................245
Warsztaty ...........................................................................................................................246
Czym jest dziedziczenie? ............................................................................................249
Prywatne kontra chronione ......................................................................................252
Konstruktory i destruktory .......................................................................................254
Przekazywanie argumentów do konstruktorów bazowych ......................256
Nadpisywanie funkcji ...................................................................................................261
Podsumowanie ................................................................................................................266
Pytania i odpowiedzi ....................................................................................................266
Warsztaty ...........................................................................................................................267
Polimorfizm implementowany za pomocą wirtualnych
metod składowych .....................................................................................................269
Jak działają metody wirtualne? ...............................................................................273
Podsumowanie ................................................................................................................281
Pytania i odpowiedzi ....................................................................................................281
Warsztaty ...........................................................................................................................282
CZĘŚĆ V DZIEDZICZENIE I POLIMORFIZM
Godzina 16. Rozszerzanie klas za pomocą dziedziczenia ............................ 249
Godzina 17. Użycie polimorfizmu i klas potomnych .................................... 269
Poleć książkęKup książkę8
Spis treści
Godzina 18. Wykorzystanie polimorfizmu zaawansowanego ..................... 285
CZĘŚĆ VI
Godzina 19. Przechowywanie informacji na liście ....................................... 305
TEMATY SPECJALNE
Problem z pojedynczym dziedziczeniem .............................................................285
Abstrakcyjne typy danych ...........................................................................................289
Podsumowanie .................................................................................................................301
Pytania i odpowiedzi .....................................................................................................301
Warsztaty ............................................................................................................................302
Listy i inne struktury .....................................................................................................305
Studium przypadku struktury listy ........................................................................306
Struktura listy jako obiekt ..........................................................................................315
Podsumowanie .................................................................................................................316
Pytania i odpowiedzi .....................................................................................................316
Warsztaty ............................................................................................................................317
Statyczne dane składowe ............................................................................................319
Statyczna metoda składowa ......................................................................................321
Zawieranie się klas .........................................................................................................323
Zaprzyjaźnione klasy i metody .................................................................................330
Podsumowanie .................................................................................................................344
Pytania i odpowiedzi .....................................................................................................344
Warsztaty ............................................................................................................................345
Najnowsza wersja C++ ..................................................................................................347
Użycie auto w typie wartości zwrotnej funkcji .................................................348
Słowo kluczowe constexpr .........................................................................................352
Wyrażenia lambda ..........................................................................................................354
Podsumowanie .................................................................................................................355
Pytania i odpowiedzi .....................................................................................................355
Warsztaty ............................................................................................................................356
Cykl programistyczny ...................................................................................................359
Symulacja systemu alarmowego ..............................................................................360
PostMaster — studium przypadku .........................................................................366
Podsumowanie .................................................................................................................385
Godzina 20. Użycie specjalnych klas, funkcji i wskaźników ......................... 319
Godzina 21. Użycie nowych funkcji standardu C++14 ............................... 347
Godzina 22. Analiza i projekt zorientowany obiektowo .............................. 359
Poleć książkęKup książkę
Godzina 24. Obsługa wyjątków i błędów ................................................... 405
Spis treści
9
Pytania i odpowiedzi ....................................................................................................386
Warsztaty ...........................................................................................................................386
Czym są szablony? .........................................................................................................389
Egzemplarze szablonu .................................................................................................390
Definicja szablonu ..........................................................................................................390
Użycie elementów szablonu ......................................................................................396
Podsumowanie ................................................................................................................402
Pytania i odpowiedzi ....................................................................................................402
Warsztaty ...........................................................................................................................403
Pluskwy, błędy, pomyłki i „psujący się” kod ......................................................405
Sytuacje wyjątkowe ......................................................................................................406
Wyjątki ................................................................................................................................407
Użycie bloków try i catch ............................................................................................411
Tworzenie kodu o profesjonalnej jakości ...........................................................416
Podsumowanie ................................................................................................................422
Pytania i odpowiedzi ....................................................................................................422
Warsztaty ...........................................................................................................................422
Inne podstawy .................................................................................................................425
Konwertowanie na inną podstawę ........................................................................426
Szesnastkowo ..................................................................................................................429
DODATKI
Godzina 23. Tworzenie szablonów ............................................................. 389
Dodatek A Systemy dwójkowy i szesnastkowy ......................................... 425
Dodatek B Słowniczek .............................................................................. 433
Dodatek D Użycie kompilatora MinGW C++ w Windows ........................ 443
Dodatek C Witryna internetowa książki .................................................... 441
Pobieranie MinGW‐w64 ..............................................................................................443
Konfiguracja zmiennej środowiskowej Path .....................................................444
Przetestowanie instalacji ...........................................................................................447
Skorowidz ............................................................................... 451
Poleć książkęKup książkę10
Spis treści
Poleć książkęKup książkęGodzina 2.
Organizacja
elementów programu
W trakcie tej godziny nauczysz się:
dlaczego warto używać języka C++;
w jaki sposób są zorganizowane programy C++;
dlaczego komentarze ułatwiają zrozumienie sposobu działania
programu;
do czego można wykorzystać funkcje.
Wprawdzie ma już prawie 40 lat, ale język programowania C++ starzeje się znacznie
wolniej niż inne rzeczy pochodzące z końca lat 70. ubiegłego wieku. W przeciwień-
stwie do disco, embarga na dostawy ropy naftowej, włochatych dywanów i kolo-
rowych lodówek C++ nadal się cieszy popularnością i pozostaje światowej klasy
językiem programowania.
Powodem zaskakującej długowieczności tego języka jest fakt, że C++ umożliwia
utworzenie szybko wykonywanych programów za pomocą niewielkiej ilości kodu,
który może być uruchamiany w różnych środowiskach informatycznych. Obecne
narzędzia programistyczne C++ pozwalają na tworzenie skomplikowanych i potęż-
nych aplikacji w środowiskach komercyjnych, biznesowych i open source.
Dlaczego warto używać C++?
Od czasu pierwszych komputerów języki programowania przebyły długą drogę. C++
jest uznawany za ewolucyjne usprawnienie języka programowania o nazwie C, który
pojawił się w 1972 r.
Na początku programiści używali najbardziej prymitywnych poleceń komputera: języka
maszynowego. Te polecenia zapisywane były jako długie ciągi zer i jedynek. Dlatego
wymyślono tzw. asemblery zamieniające instrukcje maszynowe na czytelne dla czło‐
wieka i łatwiejsze do zapamiętania mnemoniki, takie jak ADD czy MOV.
Polecenia tworzące program komputerowy są określane mianem jego kodu źródłowego.
Z czasem pojawiły się języki wyższego poziomu, takie jak BASIC czy COBOL. Te języki
umożliwiały tworzenie programów za pomocą języka bliższego rzeczywistym słowom
Poleć książkęKup książkę26
Godzina 2. Organizacja elementów programu
i zdaniom, np. Let Average = 0.366. Te instrukcje były tłumaczone z powrotem na ję‐
zyk maszynowy przez narzędzia nazywane interpreterami lub kompilatorami.
Język interpretowany tłumaczy program bezpośrednio podczas odczytywania kolejnych
wierszy i działa na poszczególnych poleceniach.
Z kolei język kompilowany tłumaczy program na tzw. kod obiektowy w trakcie proce‐
su nazywanego kompilacją. Wspomniany kod jest przechowywany w pliku obiekto‐
wym. Następnie linker przekształca ten plik obiektowy na program wykonywalny, który
może być uruchomiony przez system operacyjny.
Ponieważ interpretery bezpośrednio odczytują kod źródłowy programu i wykonują go
na bieżąco, są łatwiejsze w użyciu dla programistów. Kompilatory wymagają przepro‐
wadzenia dodatkowych niewygodnych kroków kompilacji programów i dołączania do
nich niezbędnych bibliotek. Jednak zaletą tego podejścia jest to, że programy skompilo‐
wane są wykonywane znacznie szybciej niż uruchamiane przez interpretera.
Przez wiele lat głównym celem programistów było tworzenie krótkich fragmentów kodu,
które mogłyby być szybko wykonywane. Programy musiały być małe, ponieważ pamięć
komputera była niezwykle droga. Ponadto musiały być szybkie, ponieważ moc oblicze‐
niowa komputerów również była kosztowna. Gdy komputery stały się tańsze, szybsze
i zaoferowały znacznie potężniejsze możliwości, a koszt pamięci operacyjnej i masowej
znacznie spadł, wymienione wcześniej priorytety utraciły swoją wagę.
Obecnie największym kosztem w programowaniu jest praca programisty. Nowoczesne
języki programowania, takie jak C++, pozwalają na szybsze tworzenie doskonale napi‐
sanych i łatwych w późniejszej obsłudze programów, które mogą być rozbudowywane
i usprawniane.
W toku ewolucji powstawały nowe języki, aby umożliwić stosowanie różnych stylów pro‐
gramowania.
W stylu programowania proceduralnego program był traktowany jako seria procedur
działających na danych. Programowanie strukturalne zostało wprowadzone w celu dostar‐
czenia systematycznego podejścia do organizacji tych procedur i zarządzania ogrom‐
nymi ilościami danych.
Główną ideą programowania strukturalnego jest „dziel i rządź”. Program komputerowy
może być uważany za zestaw zadań. Każde zbyt skomplikowane zadanie, aby można było je
łatwo opisać, jest rozbijane na zestaw mniejszych zadań składowych, aż do momentu
gdy wszystkie zadania są wystarczająco łatwe do zrozumienia.
Przykładowo przyjmujemy założenie, że otrzymałeś od wydawcy polecenie utworzenia
programu monitorującego średnie wynagrodzenie zespołu składającego się z niezwykle
utalentowanych i charyzmatycznych autorów książek informatycznych. Tego rodzaju
zadanie można jednak podzielić na następujące podzadania:
1. Obliczenie, ile zarabiają poszczególni autorzy.
2. Obliczenie liczby autorów pracujących dla wydawcy.
Style programowania
Poleć książkęKup książkęDlaczego warto używać C++?
27
3. Zsumowanie wszystkich pensji.
4. Podzielenie tej sumy przez liczbę autorów.
Sumowanie pensji można podzielić na następujące kroki:
1. Odczytanie danych dotyczących każdego autora.
2. Odwołanie się do danych dotyczących honorarium i zaliczek pobranych przez
danego autora.
3. Potrącenie kosztu porannej kawy, okularów korekcyjnych i osteoterapii.
4. Dodanie pensji do naliczanej sumy.
5. Przejście do danych dotyczących następnego autora.
Z kolei uzyskanie danych na temat autora można rozbić na:
1. Otwarcie pliku pracowników.
2. Przejście do właściwych danych.
3. Odczytanie danych z dysku.
Wprawdzie programowanie strukturalne było powszechnie stosowane, ale ograniczenia
takiej metody programowania objawiły się aż nazbyt jasno. Oddzielenie danych od zadań
przeprowadzających operacje na tych danych staje się coraz trudniejsze do wykonania
i późniejszej obsługi wraz ze wzrostem ilości danych. Im więcej rzeczy trzeba zrobić
z użyciem danych, tym bardziej zawiły staje się program.
Podczas stosowania tego rodzaju podejścia programiści bardzo często wyważali otwarte
drzwi i tworzyli nowe rozwiązania dla starych problemów, zamiast opracowywać pro‐
gramy przeznaczone do wielokrotnego zastosowania. Idea wielokrotnego użycia polega
na takim utworzeniu komponentów programu, aby można było je stosować w innych
programach, gdy zachodzi potrzeba. Tego rodzaju podejście jest znane z rzeczywistości,
gdzie urządzenia są budowane z poszczególnych elementów, które są już wcześniej wy‐
produkowane i przeznaczone do wykonywania określonych zadań. Przykładowo inżynier
tworzący rower nie musi zupełnie od zera opracowywać układu hamulcowego. Zamiast
tego w swoim projekcie może użyć istniejącego układu i tym samym wykorzystać zalety
płynące z już znanej funkcjonalności.
Po raz pierwszy podejście oparte na komponentach stało się dostępne dla programi‐
stów wraz z wprowadzeniem programowania zorientowanego obiektowo.
Język C++ pomógł w spopularyzowaniu rewolucyjnego stylu programowania zoriento‐
wanego obiektowo dzięki akronimowi OOP (ang. object-oriented programming).
Istotą programowania zorientowanego obiektowo jest potraktowanie danych i procedur
działających na tych danych jako pojedynczego obiektu. Powstaje w ten sposób samo‐
dzielna jednostka wraz z własną tożsamością i cechami charakterystycznymi.
Język C++ obsługuje programowanie zorientowane obiektowo i obejmuje swym działa‐
niem trzy podstawowe koncepcje takiego stylu programowania: hermetyzację, dziedzi‐
czenie oraz polimorfizm.
C++ i programowanie zorientowane obiektowo
Poleć książkęKup książkę28
Godzina 2. Organizacja elementów programu
Hermetyzacja
Dziedziczenie i ponowne wykorzystanie
Gdy wspomniany wcześniej inżynier pracuje nad nowym rowerem, łączy ze sobą dostęp‐
ne komponenty, takie jak ramę, kierownicę, koła, przednie światło (kolorowe dodatki
umieszczane w szprychach są opcjonalne). Każdy komponent ma określone właściwości
i charakteryzuje się konkretnym zachowaniem. Inżynier może użyć komponent, np. przed‐
nią lampę, bez zastanawiania się nad szczegółami sposobu jego działania, jeśli tylko wie,
do czego on służy.
W tym celu komponent (tutaj: wspomniana lampa) musi być samozawierający się. To ozna‐
cza, że musi być jedną doskonale przygotowaną rzeczą, która całkowicie wykonuje sta‐
wiane przed nią zadanie. Właściwość samozawierania się jest nazywana hermetyzacją.
Wszystkie właściwości przykładowej lampy są hermetyzowane w obiekcie lampy. Nie
są porozrzucane po całym rowerze.
C++ obsługuje hermetyzację poprzez tworzenie typów zdefiniowanych przez użytkow‐
nika, zwanych klasami. Po stworzeniu dobrze zdefiniowana klasa działa jako spójna całość
— jest używana jako jednostka lub w ogóle nie jest używana. Wewnętrzne działanie kla‐
sy powinno być ukryte. Użytkownicy dobrze zdefiniowanych klas nie muszą wiedzieć, w ja‐
ki sposób one działają; muszą jedynie umieć z nich korzystać. O tym, jak tworzyć klasy,
dowiesz się z godziny 8.
Teraz dowiesz się nieco więcej o inżynierze, który pracuje nad naszym nowym rowerem.
Przyjmujemy założenie, że to jest Jan Kowalski. Janek chce jak najszybciej wprowadzić
na rynek nowy rower, ponieważ narobił sobie ogromnych długów hazardowych u osób,
które są znane ze swojej niecierpliwości.
Skoro czas go goni, Janek rozpoczyna projektowanie nowego roweru od wykorzystania
już istniejącego i usprawnia go nowymi świetnymi dodatkami, takimi jak uchwyt na kubek
i licznik. Przygotowany przez niego rower jest przedstawiany jako pojazd wraz z dodat‐
kowymi funkcjami. Janek ponownie wykorzystał wszystkie funkcje zwykłego roweru i do‐
dał nowe, aby w ten sposób rozszerzyć możliwości oferowane przez dwukołowy pojazd.
C++ obsługuje tego rodzaju ponowne wykorzystanie przez koncepcję o nazwie dziedzi-
czenie. Można dzięki niemu deklarować nowe typy będące rozszerzeniem już istnieją‐
cych typów. Mówi się, że nowa podklasa wywodzi się z istniejącego typu i czasem nazywa
się ją typem pochodnym. Rower opracowany przez Janka wywodzi się ze zwykłego ro‐
weru i tym samym dziedziczy po nim wszystkie możliwości, choć jednocześnie można
w nim dodać nowe funkcje, jeśli zachodzi potrzeba. Dziedziczenie i jego zastosowania
w języku C++ zostaną omówione w godzinie 16.
Ostatnią cechą, która ma przyciągnąć nabywców nowego roweru Janka, jest odmienne
zachowanie sygnału dźwiękowego w zależności od sposobu jego użycia. Zamiast dźwięku
podobnego do odgłosu kaczki pojazd wydaje dźwięk znany z klaksonu samochodowego,
gdy przycisk zostanie lekko naciśnięty. Natomiast mocne naciśnięcie przycisku powo‐
Polimorfizm
Poleć książkęKup książkę29
Poszczególne elementy programu
duje wydanie dźwięku przypominającego syrenę. Klakson wykonuje tutaj właściwe za‐
danie i dobiera dźwięk w zależności od sposobu użycia przycisku przez rowerzystę.
C++ sprawia, że różne obiekty „robią odpowiednie rzeczy” poprzez mechanizm zwany
polimorfizmem funkcji i polimorfizmem klas. Pojęcie „polimorfizm” oznacza, że ta sama rzecz
może przybierać wiele form. Dokładne omówienie polimorfizmu znajdziesz w godzinie 17.
Ucząc się języka C++, poznasz pełny zakres programowania zorientowanego obiekto‐
wo. Wymienione powyżej koncepcje staną się dla Ciebie jasne, zanim ukończysz wszyst‐
kie 24 godziny przedstawione w tej książce i rozpoczniesz tworzenie własnych progra‐
mów w C++.
Uwaga! Z tej książki nie dowiesz się, jak projektować rowery lub jak wyjść z długów ha‐
zardowych.
Program utworzony w godzinie 1., Motto.cpp, składał się z prostego frameworka przed‐
stawiającego typowy program w języku C++. W listingu 2.1 ponownie zaprezentowałem
program Motto.cpp, aby móc go tutaj szczegółowo omówić.
Poszczególne elementy programu
LISTING 2.1. Pełny kod źródłowy programu Motto.cpp
1: #include iostream
2:
3: int main()
4: {
5: std::cout Solidum petit in profundis!\n ;
6: return 0;
7: }
Solidum petit in profundis!
Podczas wpisywania kodu programu w edytorze takim jak Netbeans pamiętaj o pomi‐
nięciu numerów wierszy w listingu. Zamieściłem je tylko po to, aby z poziomu tekstu
móc łatwiej odwoływać się do poszczególnych poleceń kodu źródłowego.
Po uruchomieniu programu powoduje on wygenerowanie motta Aarhus University:
W wierszu 1. kodu przedstawionego w listingu 2.1 następuje dołączenie pliku o nazwie
iostream do kodu źródłowego. Ten wiersz powoduje, że kompilator działa tak, jakby
cała zawartość wymienionego pliku została umieszczona w miejscu wiersza 1. progra‐
mu Motto.cpp.
Pierwszą operacją kompilatora C++ jest wywołanie innego narzędzia o nazwie prepro‐
cesor analizującego kod źródłowy. To jest przeprowadzane automatycznie w trakcie
każdego uruchomienia kompilatora.
Dyrektywy preprocesora
Poleć książkęKup książkę30
Godzina 2. Organizacja elementów programu
Pierwszym znakiem w wierszu 1. jest # oznaczający, że ten wiersz stanowi polecenie prze‐
znaczone dla preprocesora. Tego rodzaju polecenia są nazywane dyrektywami pre-
procesora. Zadanie preprocesora polega na odczytaniu kodu źródłowego, wyszukaniu
dyrektyw oraz zmodyfikowaniu kodu zgodnie ze znalezionymi dyrektywami. Dopiero
tak zmodyfikowany kod źródłowy jest przekazywany kompilatorowi.
Preprocesor działa więc jak redaktor sprawdzający kod tuż przed jego kompilacją. Każ‐
da dyrektywa jest poleceniem dla wspomnianego redaktora.
Dyrektywa #include nakazuje preprocesorowi dołączenie w miejscu tej dyrektywy całej
zawartości wskazanego pliku. Jak się dowiedziałeś podczas godziny 1., język C++ zawie‐
ra standardową bibliotekę kodu źródłowego, którą można używać we własnych pro‐
gramach, aby uzyskać dostęp do pewnych użytecznych funkcjonalności. Kod umieszczo‐
ny w pliku iostream jest odpowiedzialny za wykonywanie zadań związanych z operacjami
wejścia‐wyjścia, takich jak wyświetlanie informacji na ekranie oraz pobieranie danych
wejściowych od użytkownika.
Znaki nawiasu ostrego wokół nazwy pliku nakazują preprocesorowi szukanie tego pliku
w standardowych lokalizacjach. Z powodu użycia nawiasów ostrych preprocesor będzie
szukał pliku iostream w katalogu zawierającym pliki nagłówkowe dla tego kompilatora.
Te pliki są również określane mianem plików dołączanych, ponieważ są dołączane do
kodu źródłowego programu.
Pełna zawartość pliku iostream zajmie miejsce wiersza 1.
Nazwy plików nagłówkowych tradycyjnie mają rozszerzenie .h, były nazywane rów-
nież plikami h i mogły być używane w dyrektywie o postaci include iostream.h .
Nowoczesne kompilatory nie wymagają tego rozszerzenia, ale jeśli odwołujesz się
do plików z jego użyciem, dyrektywa nadal będzie działała w celu zapewnienia
wstecznej zgodności. W tej książce pomijam rozszerzenia .h w nazwach plików
nagłówkowych.
Zawartość pliku iostream jest używana przez znajdujące się w wierszu 5. polecenie cout,
które wyświetla informacje na ekranie.
W omawianym tutaj kodzie źródłowym nie ma więcej żadnych dyrektyw, więc to kom‐
pilator zajmuje się obsługiwaniem pozostałej części pliku Motto.cpp.
Wiersz 3. rozpoczyna rzeczywisty program od deklaracji funkcji o nazwie main(). Funkcja
jest blokiem kodu wykonującym jedną lub więcej operacji. Funkcja wykonuje pewne
zadanie, a po zakończeniu jej działania następuje powrót do miejsca, w którym została
wywołana.
Funkcję main() ma każdy program C++. Gdy program rozpoczyna działanie, jest ona
wywoływana automatycznie.
Kod źródłowy wiersz po wierszu
Poleć książkęKup książkęKomentarze
31
Po zakończeniu działania, każda funkcja w języku C++ musi zwracać pewnego rodzaju
wartość. W przypadku funkcji main() wartością zwrotną zawsze jest liczba całkowita.
Do zdefiniowania liczby całkowitej używamy słowa kluczowego int.
Podobnie jak inne bloki kodu w programie C++, polecenia definiujące funkcję są umieszcza‐
ne wewnątrz nawiasów klamrowych. Dlatego też blok każdej funkcji rozpoczyna się od
nawiasu otwierającego {, a kończy nawiasem zamykającym }.
W pliku kodu źródłowego Motto.cpp otwierający i zamykający nawias klamrowy należą‐
cy do funkcji main() znajdują się odpowiednio w wierszach 4. i 7. Wszystkie polecenia
umieszczone między nawiasami otwierającym i zamykającym są częścią funkcji.
W wierszu 5. mamy polecenie cout używane do wyświetlenia komunikatu na ekranie.
Na początku tego polecenia znajduje się prefiks std:: informujący kompilator o koniecz‐
ności użycia standardowej biblioteki języka C++ odpowiedzialnej za obsługę wejścia‐
wyjścia. Szczegóły dotyczące sposobu działania tego polecenia są zbyt skomplikowane,
aby je wyjaśnić w tej lekcji, i gdybym zaczął je teraz przedstawiać, prawdopodobnie wy‐
rzuciłbyś tę książkę przez okno. Aby zapewnić bezpieczeństwo Twojemu otoczeniu,
powrócę do tego tematu w dalszej części książki. Teraz potraktuj std::cout jako nazwę
obiektu odpowiadającego za obsługę danych wyjściowych generowanych przez pro‐
gram. Z kolei std::cin potraktuj jako obiekt zapewniający obsługę danych wejściowych
programu wprowadzanych przez użytkownika.
Po odwołaniu do std::cout w wierszu 5. znajdują się znaki , które nazywamy opera-
torem przekierowania danych wyjściowych. Wspomniany operator to znaki umiesz‐
czone w wierszu kodu — przeprowadza on określoną operację w reakcji na pewnego
rodzaju informacje. Zadanie operatora polega na wyświetleniu danych znajdujących
się po tym operatorze. W wierszu 5. tekst Solidum petit in profundis!\n został ujęty
w cudzysłów. Dlatego też podany ciąg tekstowy będzie wyświetlony wraz ze znakiem
specjalnym \n, który oznacza znak nowego wiersza. Ewentualne kolejne dane wyjścio‐
we programu zostaną umieszczone w nowym wierszu.
W wierszu 6. program zwraca wartość 0. Ta wartość jest otrzymywana przez system
operacyjny po zakończeniu działania programu. Zwykle program zwraca wartość 0, aby
wskazać, że jego działanie zakończyło się sukcesem. Każda inna wartość wskazuje na
pewnego rodzaju niepowodzenie.
Nawias zamykający w wierszu 7. kończy funkcję main(), co jednocześnie powoduje za‐
kończenie działania programu. Wszystkie tworzone przez Ciebie programy będą uży‐
wały tego prostego frameworka zaprezentowanego w omawianym programie.
Gdy piszesz program, wówczas to, co chcesz osiągnąć, zawsze jest jasne i oczywiste. Jednak
gdy do niego wracasz po upływie pewnego czasu w celu usunięcia błędu lub dodania
nowej funkcji, kod może się okazać całkiem niezrozumiały.
Komentarze
Poleć książkęKup książkę32
// Kolejny wiersz to prowizorka (brr!).
Godzina 2. Organizacja elementów programu
Aby sobie z tym poradzić, a także by pomóc innym w zrozumieniu Twojego kodu, powinie‐
neś używać komentarzy. Komentarze są tekstem całkowicie ignorowanym przez kompila‐
tor, mogą natomiast informować czytającego o tym, co robisz w danym punkcie programu.
Komentarze w C++ występują w dwóch odmianach: jako komentarze umieszczone w poje‐
dynczym wierszu oraz komentarze umieszczone w wielu wierszach. Komentarz umiesz‐
czony w jednym wierszu jest oznaczony za pomocą podwójnego ukośnika (//), który infor‐
muje kompilator, by zignorował wszystko, co po nim następuje aż do końca wiersza.
Poniżej przedstawiłem przykład tego rodzaju komentarza.
Komentarze umieszczone w wielu wierszach są oznaczane za pomocą ukośnika i gwiazdki
(/*). Takie oznaczenie informuje kompilator, by zignorował wszystko to, co jest zawarte
pomiędzy znakami /* oraz */. Wymienione znaki mogą się znajdować w tym samym
wierszu lub między nimi mogą się znajdować inne wiersze. Każdemu znakowi /* musi od‐
powiadać zamykający komentarz znak */, w przeciwnym razie kompilator zgłosi błąd.
Poniżej przedstawiłem przykład tego rodzaju komentarza.
W powyższym komentarzu tekst ma ustawiony lewy margines, aby zapewnić lepszą czytel‐
ność. Oczywiście to nie jest wymagane. Ponieważ kompilator ignoruje wszystko, co jest
umieszczone między znakami /* i */, w komentarzu możesz umieścić cokolwiek: listę
zakupów, listy miłosne, nieopowiedziane nikomu wcześniej tajemnice z Twojego życia itd.
/* Ten fragment programu nie działa zbyt dobrze. Pamiętaj o konieczności
poprawienia tego kodu przed wydaniem aplikacji –– ewentualnie znajdź ofiarę,
którą będzie można obarczyć winą za problem. Dobrą kandydaturą na kozła
ofiarnego jest tutaj nasz nowy pracownik, Janek. */
Trzeba koniecznie pamiętać, że nie wolno zagnieżdżać w sobie komentarzy wie-
lowierszowych. Jeżeli użyjesz znaków /* rozpoczynających komentarz, a następnie
kilka wierszy później ponownie umieścisz znaki /*, wtedy pierwszy napotkany
ciąg */ zakończy wszystkie komentarze wielowierszowe, a drugi ciąg tekstowy
*/ spowoduje wygenerowanie komunikatu błędu przez kompilator. Większość
edytorów programistycznych dla C++ wyświetla komentarze innym kolorem,
aby wyraźnie pokazać ich początek i koniec.
Kolejny utworzony tutaj projekt będzie zawierał oba rodzaje komentarzy. W swoich pro‐
gramach umieszczaj wiele komentarzy. Im więcej czasu poświęcisz na pisanie komenta‐
rzy wyjaśniających sposób działania kodu źródłowego, tym łatwiejsze będzie zrozumie‐
nie tego kodu, gdy powrócisz do niego po kilku tygodniach, miesiącach lub nawet latach.
Funkcja main() nie jest zwykłą funkcją, ponieważ jest wywoływana automatycznie po
rozpoczęciu działania programu.
Funkcje
Poleć książkęKup książkęFunkcje
33
Program jest wykonywany „wiersz po wierszu” — w kolejności występowania poleceń
w kodzie źródłowym, począwszy od początku funkcji main(). Po napotkaniu wywołania
funkcji, działanie programu „rozgałęzia” się w celu wykonania danej funkcji. Gdy funkcja
zakończy działanie, następuje powrót do wiersza kodu znajdującego się bezpośrednio
po wierszu, w którym funkcja została wywołana. Funkcja może, ale nie musi zwrócić
wartość. Wyjątkiem jest tutaj funkcja main(), która zawsze zwraca liczbę całkowitą.
Funkcja składa się z nagłówka oraz części głównej. Nagłówek zbudowany jest z wymie‐
nionych poniżej elementów:
zwracanego typu danych,
nazwy funkcji,
parametrów otrzymywanych przez funkcję.
Nazwa funkcji to krótki identyfikator opisujący jej przeznaczenie.
Jeżeli funkcja nie zwraca wartości, wówczas używa typu danych void. Śpieszę tutaj z wyja‐
śnieniem, że typ void nie jest bez znaczenia. Po prostu oznacza „nic”, podobnie jak gwiaz‐
dy w Kosmosie znajdują się w ogromnych odległościach nicości nazywanej „pustką”
(ang. the void).
Argumenty to przekazywane funkcji dane kontrolujące jej sposób działania. Te argumenty
są otrzymywane przez funkcję w postaci parametrów. Funkcja może mieć zero, jeden lub
więcej parametrów. Kolejny utworzony przez nas program ma funkcję o nazwie add() obli‐
czającą sumę dwóch liczb. Poniżej przedstawiłem deklarację tego rodzaju funkcji.
}Parametry są umieszczone w nawiasie, na rozdzielonej przecinkami liście elementów.
W powyższym przypadku parametrami są liczby całkowite x i y.
Nazwa funkcji, jej parametry i kolejność tych parametrów nosi nazwę deklaracji po‐
zwalającej na unikatowe zidentyfikowanie danej funkcji.
Funkcja bez parametrów ma pusty nawias po nazwie, jak pokazałem poniżej.
}Nazwa funkcji nie może zawierać spacji, więc w przypadku nazwy takiej jak getServer
Status() pierwsza litera każdego słowa, począwszy od drugiego, jest zapisywana du‐
żą literą. Tego rodzaju konwencja jest powszechnie stosowana przez programistów C++
i została przyjęta w tej książce.
Treść funkcji składa się z otwierającego nawiasu klamrowego, żadnego lub więcej pole‐
ceń oraz zamykającego nawiasu klamrowego. Funkcja zwracająca wartość używa pole‐
cenia return, podobnie jak to mogłeś zobaczyć we wcześniejszym programie Motto.cpp.
int add(int x, int y)
{
// Miejsce na polecenia tworzące tę funkcję.
int getServerStatus()
{
// Miejsce na polecenia tworzące tę funkcję.
return 0;
Poleć książkęKup książkę34
Godzina 2. Organizacja elementów programu
Polecenie return kończy działanie funkcji. Jeżeli w funkcji nie umieścisz przynajmniej
jednego polecenia return, automatycznie będzie zwrócona wartość void. W takim przypad‐
ku konieczne jest podanie void jako typu wartości zwrotnej funkcji.
Przedstawiony w listingu 2.2 program Calculator.cpp zawiera wspomnianą wcześniej
funkcję add(), która oblicza sumę dwóch liczb i wyświetla tę wartość. Ten program po‐
kazuje, jak utworzyć funkcję pobierającą dwa argumenty w postaci liczb całkowitych,
która to funkcja zwróci wartość również w postaci liczby całkowitej.
Użycie argumentów wraz z funkcją
LISTING 2.2. Pełny kod źródłowy programu Calculator.cpp
1: #include iostream
2:
3: int add(int x, int y)
4: {
5: // Dodanie liczb x oraz y, a następnie zwrócenie obliczonej sumy.
6: std::cout Uruchomienie kalkulatora...\n ;
7: return (x+y);
8: }
9:
10: int main()
11: {
12: /* Ten program wywołuje funkcję add() w celu obliczenia
13: i wyświetlenia sumy dwóch różnych zbiorów liczb. Funkcja
14: add() nic nie robi, dopóki nie zostanie wywołana przez
15: odpowiednie polecenie w funkcji main(). */
16: std::cout Ile wynosi suma liczb 867 + 5309?\n ;
17: std::cout Suma wynosi add(867, 5309) .\n\n ;
18: std::cout Ile wynosi suma liczb 777 + 9311?\n ;
19: std::cout Suma wynosi add(777, 9311) .\n ;
20: return 0;
21: }Omawiany program powoduje wygenerowanie poniższych danych wyjściowych.
Ile wynosi suma liczb 867 + 5309?
Uruchomienie kalkulatora...
Suma wynosi 6176.
Ile wynosi suma liczb 777 + 9311?
Uruchomienie kalkulatora...
Suma wynosi 10088.
Program Calculator.cpp zawiera komentarz jednowierszowy w wierszu 5. i wielowier‐
szowy w wierszach od 12. do 15. Wszystkie komentarze zostają zignorowane przez
kompilator.
Zdefiniowana w wierszach od 3. do 8. funkcja add() pobiera dwa parametry w postaci
liczb całkowitych o nazwach x i y, a następnie oblicza ich sumę w poleceniu return.
Poleć książkęKup książkęPodsumowanie
35
Podsumowanie
Wykonywanie programu rozpoczyna się w funkcji main(). Pierwsze polecenie w wier‐
szu 16. używa obiektu std::cout i operatora przekierowania w celu wyświetlenia
komunikatu Ile wynosi suma liczb 867 + 5309? i znaku nowego wiersza.
W kolejnym wierszu mamy wyświetlenie ciągu tekstowego Suma wynosi i wywołanie
funkcji add() wraz z argumentami 867 i 5309. Wykonywanie programu odbywa się teraz
w funkcji add(), na co wskazuje komunikat Uruchomienie kalkulatora... wyświetlo‐
ny w danych wyjściowych.
Zwrócona przez funkcję wartość w postaci liczby całkowitej zostaje wyświetlona wraz
z dwoma znakami nowego wiersza.
W wierszach 18. i 19. omówiony powyżej proces zostaje powtórzony, ale tym razem dla
kolejnego zbioru liczb.
Element (x+y) nosi nazwę wyrażenia. Więcej informacji na temat tworzenia wyrażeń
matematycznych znajdziesz w godzinie 4.
Z tej lekcji dowiedziałeś się, jak język C++ ewoluował z innych stylów języków kompu‐
terowych i stosuje metodologię określaną mianem programowania zorientowanego
obiektowo. Ta metodologia odniosła tak ogromny sukces w informatyce, że język C++
dzisiaj nadal pozostaje równie nowoczesny, co w 1979 r., gdy został opracowany.
Żałuję, że moja czupryna z czasów studenckich równie dobrze nie przetrwała próby
czasu. Zamiast tego pozostała jedynie na zdjęciach, które moi przyjaciele udostępniają
w serwisie Facebook.
W dwóch programach opracowanych w trakcie tej lekcji wykorzystałeś trzy fragmenty
programu w języku C++: dyrektywy preprocesora, komentarze i funkcje.
Wszystkie kolejne programy, które utworzysz, będą stosowały ten sam prosty frame‐
work użyty w programach Motto.cpp i Calculator.cpp. Będą jedynie znacznie bardziej
skomplikowane z powodu wykorzystania większej liczby funkcji, niezależnie od tego, czy
opracujesz je zupełnie od początku, czy też będziesz wywoływać funkcje z plików na‐
główkowych dołączonych za pomocą dyrektyw #include.
O.: Ten znak oznacza dyrektywę dla preprocesora uruchamianego w trakcie działania
kompilatora. Przykładowo dyrektywa #include powoduje odczytanie pliku, którego na‐
zwa została umieszczona po niej. Kompilator nigdy nie ma styczności z dyrektywą. Za‐
wartość tego pliku jest traktowana tak samo, jakby została wpisana w kodzie źródło‐
wym w miejscu dyrektywy.
Pytania i odpowiedzi
P.: Do czego służy znak # w programie C++?
Poleć książkęKup książkę36
Godzina 2. Organizacja elementów programu
P.: Jaka jest różnica między komentarzami w stylu // i /*?
P.: Jaka jest różnica między argumentami i parametrami funkcji?
O.: Komentarz rozpoczynający się od podwójnego ukośnika (//) wygasa wraz z końcem
wiersza, w którym został umieszczony. Z kolei komentarz rozpoczynający się od uko‐
śnika i gwiazdki (/*) jest komentarzem wielowierszowym, rozciąga się aż do końcowe‐
go znacznika komentarza (*/). Należy pamiętać, że nawet koniec funkcji nie powoduje
zakończenia komentarza wielowierszowego. Jeśli nie chcesz otrzymać błędu w trakcie
kompilacji, nie zapominaj o umieszczeniu znacznika zamykającego komentarz.
O.: Te dwa pojęcia są dwiema stronami tego samego procesu zachodzącego w trakcie
wywoływania funkcji. Argument to informacje przekazywane funkcji. Z kolei parametry
to te same informacje otrzymane przez funkcję. Wywołujesz funkcję wraz z argumentami.
Natomiast wewnątrz funkcji te argumenty są otrzymywane w postaci parametrów.
O.: Prowizorka to tymczasowe rozwiązanie problemu, które później ma być zastąpione
czymś lepszym. To pojęcie zostało spopularyzowane przez techników marynarki USA,
programistów i inżynierów, a następnie rozprzestrzeniło się w innych profesjach.
W programie komputerowym prowizorka to kod źródłowy, który wprawdzie działa, ale
jeśli poświęcić mu więcej czasu, to można utworzyć go znacznie lepiej. Prowizorka z re‐
guły pozostaje w użyciu znacznie dłużej, niż można oczekiwać.
Kosmonauci z promu Apollo 13 utworzyli prowizorkę wszech czasów — składający się
z taśmy klejącej i skarpetek system, który filtrował dwutlenek węgła z powietrza i po‐
mógł załodze w powrocie na Ziemię.
Pierwsze znane użycie pojęcia prowizorki jest datowane na 1962 r. i przypisywane Jackso‐
nowi W. Granholmowi. W artykule zamieszczonym w magazynie „Datamation” użył on
eleganckiej definicji, która przetrwała próbę czasu: „Źle dobrany zestaw niedopasowa‐
nych części tworzących niepewną całość”.
Skoro poznałeś fragmenty tworzące program C++, poświęć teraz nieco czasu i odpo‐
wiedz na zamieszczone poniżej pytania, a także wykonaj kilka ćwiczeń, aby upewnić się
o przyswojeniu materiału omówionego w tej lekcji.
1. Jakiego typu danych jest wartość zwrotna funkcji main()?
a) void.
b) int.
c) Ta funkcja nie zwraca wartości.
P.: Co to jest prowizo
Pobierz darmowy fragment (pdf)