Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00440 007853 11235436 na godz. na dobę w sumie
C++ w 24 godziny. Wydanie VI - ebook/pdf
C++ w 24 godziny. Wydanie VI - ebook/pdf
Autor: , Liczba stron: 456
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-3552-3 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook (-20%), audiobook).

C++ powstał w 1979 roku i doskonale przetrwał próbę czasu, a dziś oferuje programistom potężne możliwości i ogromną elastyczność. Co więcej, istnieją języki programowania, których twórcy inspirowali się właśnie C++; jednym z nich jest Java. Oznacza to, że opanowanie C++ daje wiele korzyści: ułatwia zrozumienie innych języków programowania, a przede wszystkim pozwala na tworzenie aplikacji praktycznie dla wszystkich platform, począwszy od komputerów i serwerów, przez urządzenia mobilne i konsole do gier, aż po komputery typu mainframe.

Dzięki tej książce w ciągu 24 godzinnych lekcji poznasz podstawy programowania w C++ i szybko zaczniesz tworzyć w pełni funkcjonalne aplikacje. Najpierw zapoznasz się z instalacją i użyciem kompilatora, później dowiesz się, jak debugować tworzony kod, aż wreszcie poznasz nowości wprowadzone w standardzie C++14. Dowiesz się, jak zarządzać wejściem i wyjściem oraz jak pracować z pętlami i tablicami. Nauczysz się programowania zorientowanego obiektowo i zobaczysz, jak wykorzystywać szablony. Każda lekcja kończy się zestawem pytań i odpowiedzi, warsztatami oraz ćwiczeniami do samodzielnego wykonania.

Najważniejsze zagadnienia:

C++. Programowanie na miarę wyobraźni!


Rogers Cadenhead jest pisarzem i programistą. Tworzy Drudge Retort oraz inne popularne witryny internetowe.

Jesse Liberty jest autorem wielu książek dotyczących programowania. Liberty jest prezesem spółki Liberty Associates, Inc., która zajmuje się tworzeniem oprogramowania, świadczeniem usług konsultingowych oraz szkoleniami.

Znajdź podobne książki Ostatnio czytane w tej kategorii

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)

Gdzie kupić całą publikację:

C++ w 24 godziny. Wydanie VI
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: