Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00492 008524 10488592 na godz. na dobę w sumie
Programowanie w języku C++. Szybki start - książka
Programowanie w języku C++. Szybki start - książka
Autor: , Liczba stron: 528
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0447-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook, audiobook).

Błyskawiczny kurs tworzenia aplikacji
w jednym z najpopularniejszych języków programowania.

C++ to jeden z najpopularniejszych języków programowania. Mimo konkurencji ze strony innych, często nowocześniejszych języków, nadal jest powszechnie wykorzystywany, szczególnie przez twórców gier komputerowych, rozbudowanych aplikacji korporacyjnych i programów, od których wymaga się szczególnej szybkości i wydajności. Ten w pełni obiektowy język programowania, opracowany w połowie lat 80. w laboratoriach firmy Bell, jest stosunkowo łatwy do opanowania dzięki niewielkiemu zestawowi słów kluczowych, a oferuje ogromne możliwości.

'Programowanie w języku C++. Szybki start' to książka dla wszystkich osób, które chcą poznać ten język programowania, a nie mają czasu lub ochoty na wertowanie dziesiątek stron opisów teoretycznych. Przedstawia zasady pisania programów w C++ w sposób czytelny i obrazowy. Czytając ją, poznasz elementy języka C++, strukturę programów, zasady programowania obiektowego i sposoby realizacji różnych zadań programistycznych -- od prostych operacji wejścia i wyjścia poprzez manipulowanie ciągami tekstowymi i liczbami aż do korzystania z szablonów i obsługi błędów. Każde z omawianych zagadnień zaprezentowane jest w postaci bogato ilustrowanej sekwencji czynności, co sprawi, że łatwo będzie Ci opanować opisywane w książce problemy.

Zostań programistą C++ w ekspresowym tempie.

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREœCI SPIS TREœCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOœCIACH O NOWOœCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Programowanie w jêzyku C++. Szybki start Autorzy: Larry Ullman, Andreas Signer T³umaczenie: Przemys³aw Szeremiota, Andrzej Zawadzki ISBN: 83-246-0447-2 Tytu³ orygina³u: C++ Programming: Visual QuickStart Guide Format: B5, stron: 528 B³yskawiczny kurs tworzenia aplikacji w jednym z najpopularniejszych jêzyków programowania C++ to jeden z najpopularniejszych jêzyków programowania. Mimo konkurencji ze strony innych, czêsto nowoczeœniejszych jêzyków, nadal jest powszechnie wykorzystywany, szczególnie przez twórców gier komputerowych, rozbudowanych aplikacji korporacyjnych i programów, od których wymaga siê szczególnej szybkoœci i wydajnoœci. Ten w pe³ni obiektowy jêzyk programowania, opracowany w po³owie lat 80. w laboratoriach firmy Bell, jest stosunkowo ³atwy do opanowania dziêki niewielkiemu zestawowi s³ów kluczowych, a oferuje ogromne mo¿liwoœci. „Programowanie w jêzyku C++. Szybki start” to ksi¹¿ka dla wszystkich osób, które chc¹ poznaæ ten jêzyk programowania, a nie maj¹ czasu lub ochoty na wertowanie dziesi¹tek stron opisów teoretycznych. Przedstawia zasady pisania programów w C++ w sposób czytelny i obrazowy. Czytaj¹c j¹, poznasz elementy jêzyka C++, strukturê programów, zasady programowania obiektowego i sposoby realizacji ró¿nych zadañ programistycznych — od prostych operacji wejœcia i wyjœcia poprzez manipulowanie ci¹gami tekstowymi i liczbami a¿ do korzystania z szablonów i obs³ugi b³êdów. Ka¿de z omawianych zagadnieñ zaprezentowane jest w postaci bogato ilustrowanej sekwencji czynnoœci, co sprawi, ¿e ³atwo bêdzie Ci opanowaæ opisywane w ksi¹¿ce problemy. (cid:129) Kompilowanie i uruchamianie programów (cid:129) Typy danych i zmienne (cid:129) Instrukcje steruj¹ce (cid:129) Operacje na plikach (cid:129) Definiowanie i stosowanie funkcji (cid:129) Programowanie obiektowe (cid:129) Zarz¹dzanie pamiêci¹ (cid:129) Modularyzacja kodu (cid:129) Szablony Zostañ programist¹ C++ w ekspresowym tempie Spis treści Wprowadzenie 9 Rozdział 1. 17 Tworzymy prosty program Podstawy składni C++ ....................................................................................... 18 Kompilowanie programu w C++ ...................................................................... 22 Wyświetlanie tekstu ........................................................................................... 26 Uruchamianie skompilowanego programu ..................................................... 30 Wstrzymywanie wykonania .............................................................................. 32 Jak działają odstępy? ......................................................................................... 34 Dodawanie komentarzy do kodu źródłowego .................................................. 36 Używanie środowiska programistycznego ....................................................... 39 Rozdział 2. 45 Proste zmienne i typy danych Deklarowanie zmiennych .................................................................................. 46 Przypisywanie wartości zmiennym ................................................................... 52 Wypisywanie zmiennych ................................................................................... 54 Formatowanie liczb ............................................................................................ 57 Jak działa konwersja typu? ............................................................................... 60 Poznajemy znaki ................................................................................................. 64 Poznajemy łańcuchy znaków ............................................................................ 67 Poznajemy stałe .................................................................................................. 70 Rozdział 3. Operatory i instrukcje sterujące 73 Operatory arytmetyczne .................................................................................... 74 Instrukcja warunkowa if ................................................................................... 80 Zastosowanie else i else if ................................................................................... 84 Operator trójwartościowy ................................................................................. 88 Operatory logiczne i porównania ..................................................................... 92 Instrukcja switch ................................................................................................ 98 Operatory inkrementacji i dekrementacji ..................................................... 104 Pętla while ......................................................................................................... 108 Pętla for ............................................................................................................. 112 S p i s t r e ś c i 5 Spis treści Rozdział 4. Wejście, wyjście i pliki 115 Wczytywanie znaku ......................................................................................... 116 Odrzucanie wejścia .......................................................................................... 121 Wczytywanie liczb ............................................................................................ 124 Wczytywanie łańcuchów znaków ................................................................... 127 Wczytywanie wielu danych ............................................................................. 130 Wczytywanie całego wiersza ........................................................................... 134 Weryfikacja poprawności wejścia .................................................................. 137 Zapisywanie do pliku ....................................................................................... 143 Używanie pliku jako wejścia ........................................................................... 148 Rozdział 5. Definiowanie własnych funkcji 153 Tworzenie prostych funkcji ............................................................................. 154 Tworzenie funkcji pobierających argumenty ............................................... 159 Ustalanie domyślnych wartości argumentów ................................................ 165 Tworzenie funkcji zwracających wartości ..................................................... 170 Przeciążanie funkcji ......................................................................................... 176 Zasięg zmiennych ............................................................................................. 180 i c ś e r t s i p S Rozdział 6. Rozdział 7. Złożone typy danych 185 Praca z tablicami .............................................................................................. 186 Praca ze wskaźnikami ...................................................................................... 192 Struktury ........................................................................................................... 210 Powtórka z definiowania własnych funkcji ................................................... 215 Przedstawiamy obiekty 223 Tworzymy prostą klasę .................................................................................... 224 Dodawanie metod do klas ................................................................................ 228 Tworzenie i używanie obiektów ...................................................................... 233 Definiowanie konstruktorów ........................................................................... 237 Definiowanie destruktorów ............................................................................. 242 Wskaźnik this ................................................................................................... 248 Rozdział 8. Dziedziczenie klas 253 Podstawy dziedziczenia .................................................................................... 254 Dziedziczenie konstruktorów i destruktorów ................................................ 260 Kontrola dostępu .............................................................................................. 265 Przesłanianie metod ......................................................................................... 270 Przeciążanie metod ........................................................................................... 274 Nawiązywanie przyjaźni .................................................................................. 277 6 Rozdział 9. Spis treści Zaawansowane programowanie obiektowe 283 Metody i atrybuty statyczne ............................................................................ 284 Metody wirtualne ............................................................................................. 291 Metody abstrakcyjne ....................................................................................... 298 Przeciążanie operatorów ................................................................................. 304 Operator ...................................................................................................... 312 Dziedziczenie wielobazowe .............................................................................. 317 Dziedziczenie wirtualne ................................................................................... 324 Rozdział 10. Diagnostyka i obsługa błędów 329 Techniki diagnostyczne .................................................................................... 330 Kody błędów ..................................................................................................... 336 Narzędzie assert() ............................................................................................. 342 Przechwytywanie wyjątków ............................................................................ 348 Rozdział 11. Dynamiczne zarządzanie pamięcią 355 Pamięć statyczna a pamięć dynamiczna ........................................................ 356 Przydzielanie obiektów .................................................................................... 360 Dynamiczny przydział tablic ........................................................................... 365 Zwracanie pamięci z funkcji i metod ............................................................. 370 Konstruktor kopiujący i operator przypisania ............................................. 375 Statyczne rzutowanie typu obiektu ................................................................ 384 Dynamiczne rzutowanie typu obiektu ............................................................ 388 Unikanie wycieków pamięci ............................................................................ 392 S p i s t r e ś c i Rozdział 12. Przestrzenie nazw i modularyzacja kodu 395 Praca z włączanymi plikami ............................................................................ 396 Preprocesor C ................................................................................................... 410 Przestrzenie nazw ............................................................................................. 414 Zasięg a łączenie ............................................................................................... 422 Rozdział 13. Praca z szablonami 431 Podstawy składni szablonów ........................................................................... 432 Szablony z rozwinięciami w miejscu wywołania ........................................... 444 Kontenery i algorytmy ..................................................................................... 448 Rozdział 14. Zagadnienia dodatkowe 459 Znowu o ciągach ............................................................................................... 460 Operacje na plikach binarnych ...................................................................... 474 Pobieranie argumentów z wiersza poleceń .................................................... 489 7 Spis treści Dodatek A Narzędzia C++ 495 Dev-C++ dla Windows ..................................................................................... 496 Xcode dla systemu Mac OS X ......................................................................... 501 Narzędzia uniksowe ......................................................................................... 502 Debugowanie z GDB ........................................................................................ 503 Dodatek B Zasoby dodatkowe 505 Strony WWW ................................................................................................... 506 Tabele ................................................................................................................ 508 Skorowidz 513 i c ś e r t s i p S 8 Definiowanie własnych funkcji Rozdział 5. Definiowanie własnych funkcji We wszystkich językach programowania funkcje służą do tego samego celu — grupowania instrukcji pod pewną etykietą. Późniejsze powtarzanie tych instrukcji jest bardzo łatwe, ponieważ do tego celu wystarczy użycie nazwy nadanej funkcji (czyli wywołanie jej). Spotkaliśmy się już z tym w praktyce, używając dostarczanej przez język C++ funkcji cin.get() i stosowanej przy pracach z plikami funkcji close(). W tym rozdziale dowiemy się, jak definiować i wywoływać własne funkcje. Chociaż składnia potrzebna do definiowania funkcji jest prosta i logiczna, daje wiele możliwości. Na początek zdefiniujemy prostą funkcję, która nie pobiera argumentów i nie zwraca żadnych wartości. Następnie zajmiemy się takimi funkcjami, które zawsze wymagają przekazania im argumentów, oraz takimi, które pobierają je opcjonalnie. Potem utworzymy funkcje, które zwracają wartości pewnych obliczeń. Wychodząc od tych podstawowych tematów, przejdziemy do bardziej zaawansowanego zagadnienia — przeciążania funkcji. Rozdział kończy się omówieniem kwestii zasięgu zmiennych, czyli zasad, które opisują, w jakich miejscach w programie dostępna jest określona zmienna. Pojawią się także inne zagadnienia: funkcje rozwijane w miejscu wywołania i funkcje rekurencyjne oraz dodatkowe kwestie związane z deklarowaniem zmiennych. D e f i n i o w a n i e w ł a s n y c h f u n k c j i 153 Rozdział 5. Tworzenie prostych funkcji Definiowanie funkcji w C++ składa się z dwóch kroków. Najpierw określa się składnię wywołania funkcji przez zadeklarowanie jej prototypu. Prototyp określa nazwę funkcji, liczbę i typ ewentualnie pobieranych przez nią argumentów oraz typ zwracanej wartości. Nie zawiera on jednak samej treści funkcji. Prototyp jest konieczny, by kompilator mógł sprawdzić, czy funkcja jest poprawnie używana w miejscach wywołania (kompilator porównuje prototyp z wywołaniami funkcji). Składnia prototypu jest następująca: typZwracany nazwaFunkcji (argumenty); Jeśli funkcja nie zwraca żadnej wartości, to w miejscu wyrazu typZwracany umieścimy void. Wszystkie funkcje zdefiniowane w tym rozdziale będą zwracać co najwyżej proste wartości liczbowe, np. liczby typu int lub float. W kolejnych dwóch rozdziałach dowiemy się więcej o złożonych typach danych i o tym, jak sprawić, by funkcje zwracały wartości takich typów. Warto zauważyć, że nie ma znaczenia, czy pomiędzy nazwą funkcji a jej otwierającym nawiasem znajduje się spacja. W książce będziemy je czasem dodawać, aby uczynić kod bardziej czytelnym. Reguły nazywania funkcji są takie same jak reguły nazywania zmiennych: można używać znaków alfanumerycznych oraz znaku podkreślenia. Należy pamiętać, że w języku C++ w nazwach funkcji rozróżniana jest wielkość liter. Wskazane jest więc obranie i konsekwentne trzymanie się jednej konwencji używania w nich wielkich liter. Zarówno w przypadku nazw zmiennych, jak i nazw funkcji niemożliwe jest używanie słów kluczowych języka (int, break itd.). Dozwolone jest natomiast dublowanie nazw istniejących już funkcji, ale dopóki nie zostanie omówione, kiedy i w jaki sposób można to wykorzystać, lepiej jest pozostać przy unikalnych i oczywistych nazwach. 154 i j c k n u f h c y t s o r p e i n e z r o w T Definiowanie własnych funkcji Pobieranie przez funkcję argumentów jest samo w sobie dość skomplikowanym zagadnieniem i zajmiemy się nim na następnych kilku stronach. Tymczasem musimy pamiętać, że jeśli funkcja nie pobiera argumentów, to nawiasy pozostawiamy puste. Mając na uwadze powyższe informacje, utworzymy prototyp funkcji saysello (ang. przywitaj się), która nie pobiera argumentów i nie zwraca żadnej wartości: void sayHello(); Drugim krokiem przy tworzeniu własnej funkcji po zadeklarowaniu prototypu jest zdefiniowanie jej. Nazywa się to implementowaniem funkcji. Składnia przypomina deklarację prototypu, ale kończy się zapisaniem ciała funkcji, w którym znajduje się właściwa definicja wykonywanych instrukcji. void sayHello() { std::cout Halo. ; } Gdy mamy już za sobą zapisanie prototypu i zdefiniowanie funkcji, możemy ją wywoływać tak samo jak każdą inną: sayHello(); Zanim przejdziemy do przykładowego programu, warto powiedzieć, gdzie w pliku źródłowym należałoby umieścić powyższy kod. Prototyp funkcji zazwyczaj powinien znajdować się przed definicją funkcji main(). Dzięki temu kompilator zna składnię funkcji w momencie jej wywołania w głównej funkcji programu. Definicje zdefiniowanych przez użytkownika funkcji umieszcza się za definicją funkcji main(). Szkielet kodu naszego programu mógłby więc wyglądać następująco: #include biblioteki prototypy funkcji int main() { // Zrób coś. // Wywołanie funkcji użytkownika. } definicje funkcji 155 T w o r z e n i e p r o s t y c h f u n k c j i Listing 5.1. Zdefiniowana przez użytkownika funkcja promptAndWait() obejmuje często wykorzystywany fragment kodu. W razie potrzeby można ją wywołać w funkcji main(), używając instrukcji promptAndWait() 1 // prompt.cpp - Listing 5.1 2 3 // Potrzebujemy pliku iostream, by móc 4 // korzystać z cout i cin. 5 #include iostream 6 7 /* Prototyp funkcji. 8 * Funkcja nie pobiera argumentów. 9 * Funkcja nie zwraca żadnej wartości. 10 */ 11 void promptAnd11it v 12 13 // Początek funkcji main(). 14 int main() { 15 16 // Zrób coś. 17 std::cout Funkcja main() Äwykonuje jakieś Äinstrukcje... ; 18 19 // Wywołanie funkcji promptAndWait(). 20 promptAnd11it v 21 22 // Zwrócenie wartości 0, by zaznaczyć Äbrak problemów. 23 return 0; 24 25 } // Koniec funkcji main(). 26 27 28 // Definicja funkcji promptAndWait(). 29 void promptAnd11it { 30 31 // Oczekiwanie, aż użytkownik naciśnie ÄEnter lub Return. 32 std::cout N1ciśnij Enter lub ÄReturn, 1by kontynuow1ć. v 33 std::cin.get v 34 35 } // Koniec funkcji promptAndWait(). Rozdział 5. Właściwym w tym miejscu pytaniem jest: „Kiedy powinno się deklarować własne funkcje?”. Zazwyczaj sekwencję instrukcji zamienia się w funkcję wtedy, gdy chce się jej wielokrotnie używać lub gdy stanowi ona odrębną logicznie całość. Jednocześnie nie należy definiować własnych funkcji, jeśli ich odpowiedniki istnieją już w C++. W tym rozdziale stworzymy kilka funkcji. Pierwszy przykład będzie wykonywał to, co robią prawie wszystkie programy w tej książce: wypisze komunikat i wstrzyma wykonanie programu do momentu naciśnięcia klawisza Enter lub Return. Powtarzany już wielokrotnie kod zamienimy tym razem w funkcję. Aby zdefiniować własne funkcje i używać ich: 1. Utwórz nowy, pusty dokument tekstowy w edytorze tekstu lub środowisku programistycznym (listing 5.1). // prompt.cpp - Listing 5.1 #include iostream 2. Dodaj prototyp funkcji. void promptvnddait(); Definiowana funkcja nosi nazwę promptAndWait (ang. zgłoś i czekaj). Nie pobiera argumentów (nawiasy są puste) i nie zwraca żadnej wartości (co zaznacza się użyciem słowa void). 3. Rozpocznij definicję funkcji main(). int main() { Pomimo że w aplikacji używamy utworzonych przez siebie funkcji, to i tak musimy zdefiniować funkcję main(). Powinno być już utrwalone, że to właśnie ona jest wywoływana automatycznie, gdy uruchamiany jest program. W main() należy więc umieścić główne instrukcje każdego programu. 4. Spraw, aby w funkcji main() wykonywane były jakieś instrukcje. std::cout Funkcja main() wykonuje jakieś instrukcje... ; 156 i j c k n u f h c y t s o r p e i n e z r o w T Definiowanie własnych funkcji Ponieważ celem tej aplikacji jest zademonstrowanie, w jaki sposób definiuje się i wywołuje własne funkcje, to nie skupiamy się w niej na niczym innym. Jeśli zaszłaby taka potrzeba, można sprawić, aby funkcja main() wykonywała coś pożytecznego, np. zamieniała jednostki pewnych wartości, wczytywała dane itd. 5. Wywołaj zdefiniowaną przez nas funkcję. promptvnddait(); Do wywołania funkcji wystarczy zapisanie jej nazwy, po której umieszcza się puste nawiasy. Tak jak w przypadku wszystkich instrukcji w języku C++, wiersz kończy się średnikiem. 6. Zakończ funkcję main(). return 0; } // Koniec funkcji main(). Jeśli programy zawierają więcej niż jedną funkcję, użyteczną konwencją jest zaznaczanie komentarzem, gdzie się kończy każda z nich. 7. Za funkcją main() rozpocznij definicję funkcji promptAndWait(). void promptvnddait() { Definicja rozpoczyna się dokładnie tak samo jak prototyp, ale potem zawiera nawias klamrowy, który zaznacza początek ciała funkcji. 8. Dodaj ciało funkcji. std::cout Naciśnij Enter lub Return, Äaby kontynuować. ; std::cin.get(); Funkcja wypisuje komunikat, w którym prosi o naciśnięcie klawisza i czeka aż to nastąpi. Gdyby funkcja main() wczytywała jakieś dane (nie robi tego w przykładowym programie), to celowe byłoby dodanie w pierwszym wierszu funkcji instrukcji: std::cin.ignore(100, ); lub std::cin.ignore(std::gcount()+1); 157 T w o r z e n i e p r o s t y c h f u n k c j i Rozdział 5. Powyższe wiersze stanowią zabezpieczenie na wypadek, gdyby np. nadmiarowy znak nowego wiersza pozostawał w buforze przed wywołaniem naszej funkcji (poprzedni rozdział zawiera omówienie składni i przyczyn użycia wspomnianych instrukcji). 9. Zakończ funkcję promptAndWait(). } // Koniec funkcji promptAndWait(). Zamykający nawias klamrowy zaznacza koniec definicji funkcji. Dopisany za nim komentarz dodatkowo pomaga zorientować się, gdzie zaczynają się, a gdzie kończą definicje poszczególnych funkcji. Ponieważ funkcja nie zwraca żadnej wartości, nie pojawia się w niej instrukcja return. 10. Zapisz plik jako prompt.cpp, po czym skompiluj i uruchom program (rysunek 5.1). Wskazówki n Jeśli program kilkakrotnie używa tej samej funkcji lub jeśli mamy zbiór funkcji, których używamy w wielu aplikacjach, to celowe jest umieszczenie ich w osobnym pliku bibliotecznym. Więcej informacji na ten temat pojawi się w rozdziale 12. („Przestrzenie nazw i modularyzacja kodu”). n Ponieważ programiści zajmują się głównie teoretycznymi rozważaniami na rozmaite tematy, to powstało wśród nich wiele teorii dotyczących tego, w jaki sposób należy nadawać nazwy definiowanym funkcjom. Jedyną powszechnie akceptowaną zasadą jest konsekwentne trzymanie się obranej konwencji nazewniczej (zarówno promptAndWait, prompt_and_wait, jak i PromptAndWait są zupełnie poprawne; nie należy jednak jednej funkcji nazwać PromptAndWait, a drugiej — zrób_to_i_tamto). Z oczywistych względów nazwy funkcji powinny też wskazywać na to, co funkcja robi. i j c k n u f h c y t s o r p e i n e z r o w T 158 Rysunek 5.1. Mimo że program po uruchomieniu nie wydaje się robić nić nadzwyczajnego, to odbywające się za kulisami operacje — czyli wywoływanie zdefiniowanych przez nas funkcji — są naprawdę istotne n Możliwość definiowania własnych funkcji jest ważnym aspektem programowania obiektowego. Jak pokażemy w rozdziale 7. („Przedstawiamy obiekty”), obiektowe typy danych mogą mieć swoje własne funkcje, które nazywa się metodami. Definiowanie własnych funkcji Tworzenie funkcji pobierających argumenty Chociaż prosta funkcja promptAndWait() dobrze realizuje swoje zadanie, to ilustruje jedynie drobną część wszystkich możliwości, jakie dają funkcje definiowane przez użytkownika. Kolejnym zagadnieniem, jakim się zajmiemy, jest pobieranie przez funkcje argumentów. Dla ścisłości — argumenty są wartościami, które mogą być przekazywane do funkcji i przez nie używane. Z zagadnieniem tym zetknęliśmy się już przy okazji używania getline(), którą stosowaliśmy, przekazując jej dwa argumenty: źródło danych (np. cin) oraz zmienną typu string, do której zapisywane były wprowadzone znaki. Jeśli chcemy, aby funkcja pobierała argumenty, należy wymienić ich typy oraz nazwy wewnątrz nawiasów w prototypie i definicji: // Prototyp: void factorial (unsigned svort num); // Definicja: void factorial (unsigned svort num) { // Ciało funkcji. // Użycie zmiennej num. } Jeśli funkcja ma pobierać więcej argumentów, należy je kolejno oddzielić przecinkami, wypisując typ i nazwę: void exponent (int num, int power); Powyższa funkcja jest już zdefiniowana w C++ jako pow() (zobacz rozdział 3., „Operatory i instrukcje sterujące”) i stanowi jedynie przykład składni. T w o r z e n i e f u n k c j i p o b i e r a j ą c y c h a r g u m e n t y 159 Listing 5.2. Zdefiniowana przez użytkownika funkcja convertTemperature() pobiera dwa argumenty i wypisuje wynik konwersji 1 // temperature.cpp - Listing 5.2 2 3 // Potrzebujemy pliku iostream, by móc 4 // korzystać z cout i cin. 5 #include iostream 6 7 /* Prototyp pierwszej funkcji. 8 * Funkcja nie pobiera argumentów. 9 * Funkcja nie zwraca żadnej wartości. 10 */ 11 void promptvnddait(); 12 13 /* Prototyp drugiej funkcji. 14 * Funkcja pobiera dwa argumenty: 15 * jeden typu float i jeden typu char. 16 * Funkcja nie zwraca żadnej wartości. 17 */ 18 void convertTemper1ture flo1t temp1n, Äch1r type1n v 19 20 // Początek funkcji main(). 21 int main() { 22 23 // Deklaracja zmiennych. 24 float temperatureIn; 25 cvar tempTypeIn; 26 27 // Prośba o podanie temperatury. 28 std::cout Podaj temperaturę Äi określ, czy jest ona wyrażona w stopniacv Favrenveita, czy elsjusza: Ä[##.# /F] ; 29 std::cin temperatureIn ÄtempTypeIn; 30 31 // Sprawdzenie poprawności wartości Äzmiennej tempTypeIn. 32 if ( 33 (tempTypeIn == ) || Rozdział 5. Przy wywołaniu funkcji pobierającej argumenty, należy przesłać jej odpowiednie wartości. Mieliśmy już okazję zobaczyć, że można to robić na wiele sposobów: od przekazywania literałów aż po wyniki obliczeń. Wszystkie poniższe wywołania są poprawne: int n = 2; int x = 3; exponent (n, x); exponent (n, 5); exponent (3, 4); Należy koniecznie zapamiętać, że przekazywane do funkcji wartości muszą być zawsze poprawnego typu i zapisane w dobrej kolejności. Wynika to stąd, iż pierwsza z wartości będzie przypisana pierwszemu z jej argumentów, druga — drugiemu itd. Nie ma możliwości przekazania jedynie drugiego argumentu do funkcji, bez uprzedniego przekazania pierwszego. W kolejnym przykładowym programie zdefiniowana przez nas funkcja będzie pobierać dwa argumenty: temperaturę i pojedynczy znak, który wskaże, czy jest ona wyrażona w stopniach Celsjusza, czy Fahrenheita. Funkcja wykona następnie odpowiednie konwersje i wypisze wyniki w znany nam już sposób. Aby zdefiniować funkcje, które pobierają argumenty, i używać ich: 1. Utwórz nowy, pusty dokument tekstowy w edytorze tekstu lub środowisku programistycznym (listing 5.2). // temperature.cpp - Listing 5.2 #include iostream 2. Dodaj prototypy funkcji. void promptvnddait(); void convertTemperature(float tempIn, cvar ÄtypeIn); Nowozdefiniowana funkcja nosi nazwę convertTemperature (ang. zamień temperaturę). Pobiera dwa argumenty, z których pierwszy jest liczbą typu float, a drugi znakiem. W tym programie użyjemy również funkcji promptAndWait(). 160 y t n e m u g r a h c y c ą j a r e i b o p i j c k n u f e i n e z r o w T Listing 5.2. — ciąg dalszy 3. Rozpocznij definicję funkcji main(). Definiowanie własnych funkcji 34 (tempTypeIn == c ) || 35 (tempTypeIn == F ) || 36 (tempTypeIn == f ) 37 ) { 38 39 // Wywołanie funkcji konwertującej. 40 convertTemper1ture Ä temper1ture1n, ÄtempType1n v 41 42 } else { // Niepoprawny typ danych, Äwypisanie komunikatu Ä o błędzie. 43 std::cout Obliczenia nie Ämogły zostać przeprowadzone ze względu na Äniepoprawne dane Äwejściowe. ; 44 } 45 46 // Wywołanie funkcji promptAndWait(). 47 promptvnddait(); 48 49 // Zwrócenie wartości 0, by zaznaczyć Äbrak problemów. 50 return 0; 51 52 } // Koniec funkcji main(). 53 54 55 // Definicja funkcji promptAndWait(). 56 void promptvnddait() { 57 std::cin.ignore(100, ); 58 std::cout Naciśnij Enter lub ÄReturn, aby kontynuować. ; 59 std::cin.get(); 60 } // Koniec funkcji promptAndWait(). 61 62 63 // Definicja funkcji convertTemperature(). 64 void convertTemper1ture flo1t temp1n, Äch1r type1n { 65 int main() { float temperatureIn; cvar tempTypeIn; W funkcji main() będziemy potrzebować dwóch zmiennych do przechowywania wprowadzonych przez użytkownika wartości. 4. Poproś użytkownika o wprowadzenie temperatury. std::cout Podaj temperaturę i określ, Äczy jest ona wyrażona w stopniacv Favrenveita, czy elsjusza: [##.# /F] ; std::cout temperatureIn tempTypeIn; Powyższe instrukcje są bliźniaczo podobne do tych, które pojawiły się w rozdziale 4. („Wejście, wyjście i pliki”). W pierwszym wierszu z cin nastąpi próba wczytania wartości zmiennoprzecinkowej i przypisania jej do zmiennej temperatureIn. Następnie do zmiennej tempTypeIn wczytany zostanie pojedynczy znak. 5. Jeśli wprowadzone dane są poprawnego typu, wywołaj nową funkcję. if ( ( tempTypeIn == ) || ( tempTypeIn == c ) || ( tempTypeIn == F ) || ( tempTypeIn == f ) ) { convertTemperature (temperatureIn, ÄtempTypeIn); W tej wersji programu wykonujemy podstawowe sprawdzenie poprawności danych, aby upewnić się, że zmienna tempTypeIn ma dopuszczalną wartość. Oczywiście, można by dokonać dużo więcej tego typu sprawdzeń (ich przykłady zawiera rozdział 4). Rzeczą wartą zapamiętania jest jednak to, że przed użyciem swojej funkcji należałoby w jakiś sposób upewnić się co do poprawności pobieranych przez nią argumentów (pomijamy przypadek funkcji sprawdzającej poprawność danych). 161 T w o r z e n i e f u n k c j i p o b i e r a j ą c y c h a r g u m e n t y Rozdział 5. 6. Dokończ instrukcję if. Listing 5.2. — ciąg dalszy } else { std::cout Obliczenia nie mogły Äzostać przeprowadzone ze względu na Äniepoprawne dane wejściowe. ; } Jeśli zmienna tempTypeIn nie będzie miała dozwolonej wartości, to funkcja convertTemperature() nie zostanie wywołana i ukaże się komunikat o błędzie (rysunek 5.2). Posiłkując się przykładem z rozdziału 4., można by spowodować, że program ponownie zapyta o dane wejściowe i je wczyta. 7. Dokończ funkcję main(). promptvnddait(); return 0; } 8. Za ciałem funkcji main() zdefiniuj funkcję promptAndWait(). void promptvnddait() { std::cin.ignore(100, ); std::cout Naciśnij Enter lub Return, Äaby kontynuować. ; std::cin.get(); } Choć powyższy kod różni się nieznacznie od pojawiającego się w programie z listingu 5.1, to używa się go w ten sam sposób. Ponieważ program wczytuje dane od użytkownika, wywoływana jest funkcja ignore(), która pozwala pozbyć się ewentualnego nadmiarowego wejścia. 9. Rozpocznij definicję funkcji convertTemperature(). void convertTemperature(float tempIn, cvar ÄtypeIn) { y t n e m u g r a h c y c ą j a r e i b o p i j c k n u f e i n e z r o w T 66 // Definicja stałych 67 // używanych w obliczeniach. 68 const unsigned short ADD_SUBTRACT Ä= 32v 69 const flo1t RAT1O = 5.0/9.0v 70 71 // Deklaracja zmiennych. 72 flo1t tempOutv 73 ch1r typeOutv 74 75 // Wykonanie odpowiedniej konwersji Äw zależności od wartości tempTypeIn. 76 switch type1n { 77 78 c1se C : 79 c1se c : 80 // Obliczenia: 81 tempOut = temp1n / ÄRAT1O + ADD_SUBTRACTv 82 // Dla celów informacyjnych: 83 typeOut = F v 84 bre1kv 85 86 c1se F : 87 c1se f : 88 // Obliczenia: 89 tempOut = temp1n - ÄADD_SUBTRACT * RAT1Ov 90 // Dla celów informacyjnych: 91 typeOut = C v 92 bre1kv 93 94 } // Koniec instrukcji switch. 95 96 // Wypisanie wyników. 97 std::cout temp1n stopni 98 type1n jest r9wne 99 tempOut stopniom 100 typeOut . v 101 102 } // Koniec funkcji convertTemperature(). 162 Rysunek 5.2. Sprawdzanie poprawności wejścia, którym zajmowaliśmy się w rozdziale 4., jest bardzo ważnym aspektem każdego programu wczytującego dane Definiowanie własnych funkcji Zgodnie z informacjami umieszczonymi w swoim prototypie funkcja pobiera dwa argumenty. Pierwszy z nich jest liczbą typu float o nazwie tempIn. Zostanie do niego przypisana wartość zmiennej temperatureIn, która jest pierwszym argumentem wywołania funkcji w main(). Analogicznie zmiennej typeIn zostanie przypisana wartość zmiennej tempTypeIn użytej w wywołaniu funkcji. 10. Zadeklaruj zmienne i stałe. const unsigned svort vDD_SUBTRv T = 32; const float RvTIO = 5.0/9.0; float tempOut; cvar typeOut; Dwie zdefiniowane stałe są używane do obliczeń związanych z zamianą jednostek; zmienne używane są przy wypisywaniu wyników działania programu. Kod jest bardzo podobny do tego, który pojawił się w poprzednim rozdziale. 11. Wykonaj konwersję. switcv (typeIn) { case : case c : tempOut = (tempIn / RvTIO) + ÄvDD_SUBTRv T; typeOut = F ; break; case F : case f : tempOut = (tempIn - vDD_SUBTRv T) * ÄRvTIO; typeOut = ; break; } Nie pojawiają się tu żadne nowe elementy. W zależności od tego, w jakich jednostkach jest zadana temperatura wejściowa (Celsjusza lub Fahrenheita), wykonane zostaną odpowiednie obliczenia. T w o r z e n i e f u n k c j i p o b i e r a j ą c y c h a r g u m e n t y 163 Rozdział 5. 12. Wypisz wyniki i zakończ definicję funkcji. std::cout tempIn stopni typeIn jest równe tempOut stopniom typeOut . ; } 13. Zapisz plik jako temperature.cpp, po czym skompiluj i uruchom program (rysunek 5.3 i 5.4). Wskazówki n Technicznie rzecz biorąc, nadawanie nazw argumentom w prototypach funkcji nie jest konieczne — jest to jednak bardzo dobra praktyka. n Bardzo często można się spotkać z terminami parametry i argumenty używanymi jako synonimy. Oba stosuje się do oznaczenia wartości przekazywanych do funkcji i pobieranych przez nie w momencie wywołania. Rysunek 5.3. Zamiana stopni Fahrenheita na stopnie Celsjusza Rysunek 5.4. Zamiana stopni Celsjusza na stopnie Fahrenheita n Osoby mające doświadczenia z językiem n Nawet jeśli funkcji pobiera wiele C na pewno zauważą istotną różnicę między C a C++ dotyczącą deklaracji argumentów funkcji. Rozważmy przykładową deklarację: argumentów tego samego typu, to nie można używać skrótowego zapisu z oddzielającym zmienne przecinkiem: void nazwaFunkcji(); W języku C oznacza ona funkcję o nieustalonych liczbie i typie argumentów. W C++ mówi ona, że funkcja nie pobiera żadnych argumentów. Właściwym odpowiednikiem w języku C byłoby więc: void nazwaFunkcji (void); Możesz pisać w ten sposób także w języku C++, jeśli bardziej odpowiedni wydaje Ci się jednoznaczny styl. int n1, n2; // Poprawne Wiersz niepoprawny: void nazwaFunkcji (int n1, n2); Wiersz poprawny: void nazwaFunkcji (int n1, int n2); y t n e m u g r a h c y c ą j a r e i b o p i j c k n u f e i n e z r o w T 164 Definiowanie własnych funkcji Ustalanie domyślnych wartości argumentów Innym sposobem, w jaki można modyfikować definicje swoich funkcji, jest wyznaczenie domyślnej wartości dla argumentu, dzięki czemu staje się on opcjonalny. Wykonuje się to przez dodanie przypisania wybranej wartości do argumentu w prototypie funkcji (nie w definicji): void fN (int n1, int n2 = 6); Dzięki takiej deklaracji oba poniższe wywołania są prawidłowe: fN (1); fN (5, 20); Jeśli w wywołaniu funkcji dla argumentu o określonej wartości domyślnej przekażemy jakąś wartość, to zostanie ona przypisana do argumentu. Jeśli zaś nie przekażemy nic, to argumentowi zostanie przypisana wartość domyślna. W pierwszym z powyższych przykładów argument n2 przyjmie więc wartość 6, a w drugim — 20. Funkcje mogą zawierać dowolną liczbę argumentów z domyślnymi wartościami, jednak należy pamiętać o jednej zasadzie: wszystkie argumenty wymagane muszą wystąpić w deklaracji przed argumentami opcjonalnymi. Przykładowe dwa prototypy są poprawne: void fN (int n1, int n2 = 6, int n3 = 4); void fN (int n1 = 1, int n2 = 6); Poniższe zaś są nieprawidłowe: void fN (int n1 = 1, int n2); // ŹLE! void fN (int n1, int n2 = 6, int n3); // ŹLE! W kolejnym programie zdefiniujemy funkcję, która będzie dokonywać przewalutowania sumy w dolarach na sumę w euro, a następnie wypisze wyniki konwersji. Funkcja będzie pobierać dwa argumenty: współczynnik wymiany oraz liczbę zamienianych dolarów o domyślnej wartości 1. 165 D o m y ś l n e w a r t o ś c i a r g u m e n t ó w Rozdział 5. Aby użyć domyślnych wartości: 1. Utwórz nowy, pusty dokument tekstowy w edytorze tekstu lub środowisku programistycznym (listing 5.3). // currency.cpp - Listing 5.3 #include iostream 2. Dodaj dwa prototypy funkcji. void promptvnddait(); void dollarsToEuros(float rate, unsigned Ädollars = 1); Jedyną istotną różnicą pomiędzy funkcjami convertTemperature() z poprzedniego programu oraz dollarsToEuros() jest użycie domyślnej wartości argumentu. Zmienna dollars będzie domyślnie równa 1, chyba że do funkcji w miejscu wywołania przekazana zostanie nowa wartość. 3. Rozpocznij definicję funkcji main(). int main() { float conversionRate = 0.832339; unsigned dollarsIn; Kurs wymiany (conversionRate) jest zdefiniowany w programie jako niezmienna wartość, aby uniknąć wczytywania go za każdym razem przez użytkownika. Do przechowywania wczytanej kwoty w dolarach posłuży nam zmienna dollarsIn typu unsigned int. 4. Wypisz współczynnik wymiany, wywołując funkcję. dollarsToEuros(conversionRate); Wywołanie funkcji z jednym tylko argumentem spowoduje, że użyta zostanie domyślna wartość zmiennej dollars, czyli 1. Wynikiem tej operacji będzie wypisanie nagłówka zawierającego współczynnik zamiany (rysunek 5.5). w ó t n e m u g r a i c ś o t r a w e n l ś y m o D Listing 5.3. Drugi argument funkcji dollarsToEuros() jest opcjonalny, ponieważ ma domyślną wartość 1 1 // currency.cpp - Listing 5.3 2 3 // Potrzebujemy pliku iostream, by móc 4 // korzystać z cout i cin. 5 #include iostream 6 7 /* Prototyp pierwszej funkcji. 8 * Funkcja nie pobiera argumentów. 9 * Funkcja nie zwraca żadnej wartości. 10 */ 11 void promptvnddait(); 12 13 /* Prototyp drugiej funkcji. 14 * Funkcja pobiera dwa argumenty: 15 * jeden typu float i jeden typu unsigned int. 16 * Argument typu unsigned int ma domyślną Äwartość 1. 17 * Funkcja nie zwraca żadnej wartości. 18 */ 19 void doll1rsToEuros flo1t r1te, Äunsigned doll1rs = 1 v 20 21 // Początek funkcji main(). 22 int main() { 23 24 // Definicja zmiennych. 25 float conversionRate = 0.832339; Ä// $1 = 0.832339 Euro Rysunek 5.5. Przy wywołaniu funkcji dollarsToEuros() bez podania drugiego argumentu wypisywany jest pierwszy wiersz z domyślną kwotą jednego dolara 166 Listing 5.3. — ciąg dalszy 26 unsigned dollarsIn; 27 28 // Wypisanie kursu walut przez wywołanie Äfunkcji. 29 doll1rsToEuros conversionR1te v 30 31 // Prośba o podanie kwoty pieniędzy i Äwczytanie jej. 32 std::cout Podaj kwotę Äpieniędzy w dolaracv (bez znaku Ädolara, przecinka ani kropki): Ä[###] ; 33 std::cin dollarsIn; 34 35 // Wypisanie wysokości sumy po zamianie Äwalut. 36 dollarsToEuros(conversionRate, ÄdollarsIn); 37 38 // Wywołanie funkcji promptAndWait(). 39 promptvnddait(); 40 41 // Zwrócenie wartości 0, by zaznaczyć Äbrak problemów. 42 return 0; 43 44 } // Koniec funkcji main(). 45 46 47 // Definicja funkcji promptAndWait(). 48 void promptvnddait() { 49 std::cin.ignore(100, ); 50 std::cout Naciśnij Enter lub ÄReturn, aby kontynuować. ; Rysunek 5.6. Pytanie o liczbę zamienianych dolarów Definiowanie własnych funkcji 5. Poproś użytkownika o wprowadzenie wymienianej kwoty. std::cout Podaj kwotę pieniędzy w dolaracv (bez znaku dolara, przecinka Äani kropki): [###] ; std::cin dollarsIn; Celem działania programu jest wczytanie kwoty w dolarach od użytkownika i zamiana jej na euro. Powyższy fragment kodu pyta użytkownika o dane wejściowe i wczytuje je (rysunek 5.6). 6. Wywołaj funkcję wykonującą zamianę. dollarsToEuros(conversionRate, dollarsIn); Funkcja dollarsToEuros() jest wywoływana ponownie, jednak tym razem z argumentem równym wprowadzonej przez użytkownika liczbie dolarów. Funkcja konwertująca użyje więc tyle dolarów, ile przypisano do zmiennej dollarsIn (zamiast domyślnej wartości 1). 7. Dokończ funkcję main(). promptvnddait(); return 0; } 8. Zdefiniuj funkcję promptAndWait(). void promptvnddait() { std::cin.ignore(100, ); std::cout Naciśnij Enter lub Return, Äaby kontynuować. ; std::cin.get(); } 9. Rozpocznij definicję funkcji dollarsToEuros(). void dollarsToEuros(float rate, unsigned dolars) { Należy pamiętać, żeby nie umieszczać w definicji funkcji domyślnych wartości argumentów, ponieważ skutkuje to błędami składniowymi. Wartości domyślne określa się jedynie w prototypach funkcji. D o m y ś l n e w a r t o ś c i a r g u m e n t ó w 167 Rozdział 5. 10. Ustaw formatowanie wyjścia. Listing 5.3. — ciąg dalszy std::cout.setf(std::ios_base::fixed); std::cout.setf(std::ios_base::svowpoint); std::cout.precision(2); Ponieważ wynikiem operacji będzie liczba zmiennoprzecinkowa (otrzymana przez pomnożenie współczynnika wymiany będącego liczbą rzeczywistą przez całkowitą liczbę dolarów), to celowe jest dodatkowe sformatowanie wyjścia. Powyższy kod pojawił się już w rozdziale 2. („Proste zmienne i typy danych”). Oznacza on, że wyświetlana ma być stała liczba cyfr po przecinku, przecinek dziesiętny ma być zawsze widoczny, a część całkowita ma być wyświetlana z dokładnością do dwóch miejsc po przecinku. w ó t n e m u g r a i c ś o t r a w e n l ś y m o D 11. Wypisz wyniki i zakończ definicję funkcji. std::cout $ dollars US = (rate * dollars) Euro. ; } Ta część funkcji powinna być dość oczywista, ponieważ jej sednem jest jedynie mnożenie współczynnika wymiany przez liczbę dolarów. Aby wypisywany na ekranie tekst był nieco bardziej estetyczny, na początku i na końcu komunikatów znalazły się znaki nowego wiersza. 12. Zapisz plik jako currency.cpp, po czym skompiluj i uruchom program (rysunek 5.7). 51 std::cin.get(); 52 } // Koniec funkcji promptAndWait(). 53 54 55 // Definicja funkcji dollarsToEuros(). 56 void doll1rsToEuros flo1t r1te, Äunsigned doll1rs { 57 58 // Ustawianie formatowania. 59 std::cout.setf Ä(std::ios_base::fixed); 60 std::cout.setf Ä(std::ios_base::svowpoint); 61 std::cout.precision(2); 62 63 // Wypisanie wyników. 64 std::cout $ dollars 65 US = (rate * dollars) 66 Euro. ; 67 68 } // Koniec funkcji dollarsToEuros(). Rysunek 5.7. Podana przez użytkownika kwota w dolarach jest zamieniana na euro i wypisywana na ekranie 168 Definiowanie własnych funkcji Wskazówki n Możliwość ustalania domyślnych wartości argumentów jest kolejnym z elementów języka C++ niedostępnym w C. n Niektórzy programiści preferują, aby domyślna wartość była zapisywana także w definicji funkcji. Robi się to, wykomentowując przypisanie wartości: void fN (int n1, int n2 /* = 6 */) { // Ciało funkcji. } D o m y ś l n e w a r t o ś c i a r g u m e n t ó w Funkcje rozwijane w miejscu wywołania W C++ istnieje także inny typ funkcji możliwy do zdefiniowania przez użytkownika — funkcje rozwijane w miejscu wywołania, z atrybutem inline. Są one definiowane w inny sposób niż pozostałe funkcje pojawiające się w tym rozdziale i inaczej traktowane przez kompilator. Najprostszym sposobem utworzenia funkcji z atrybutem inline jest użycie słowa kluczowego inline i zdefiniowanie jej przed definicją funkcji main(). #include iostream inline void fN() { // Ciało funkcji. } int main (void) {... Ponieważ w przypadku funkcji rozwijanych w miejscu wywołania całość definicji pojawia się przed funkcją main(), to nie ma potrzeby osobnego zapisywania prototypów. Jasne scharakteryzowanie zysków, jakie wiążą się z używaniem takich funkcji, jest samo w sobie dość trudnym zadaniem. Czasami mogą być one szybsze. Jednocześnie często takimi nie są. W tej książce nie pojawia się chyba drugie, równie niejasne zdanie, więc pokrótce przybliżymy, co ono właściwie oznacza. Po pierwsze, kompilator, rozpoczynając pracę z naszym kodem, może potraktować zdefiniowane przez nas funkcje w dowolny sposób — tak jakby miały nadany atrybut inline lub nie. Nie musi tu mieć nawet znaczenia miejsce ani sposób, w jaki je zdefiniowaliśmy. Wynika stąd fakt, że nawet jeśli użyjemy atrybutu inline, to kompilator może go zignorować. Po drugie, zwiększenie wydajności, jakie daje rozwinięcie funkcji w miejscu wywołania, bardzo się różni w zależności od konkretnej funkcji i programu. Jeśli nadamy funkcji atrybut inline, to efektem tego będzie zastąpienie instrukcji wywołania tej funkcji całością jej kodu, tak jakby był on napisany w miejscu wywołania. Podsumowując: kiedy tworzy się własne funkcje na etapie nauki C++, dobrze jest pamiętać o istnieniu funkcji z atrybutem inline, ale nie należy ich używać. Dopiero po nauczeniu się języka oraz — co ważniejsze — zdobyciu wiedzy, jak skutecznie poprawia się efektywność kodu, można zacząć eksperymentować z poruszonym zagadnieniem i sprawdzać, czy jego stosowanie powoduje jakąkolwiek poprawę działania programu. 169 Rozdział 5. Tworzenie funkcji zwracających wartości Została nam do omówienia jeszcze jedna ważna kwestia dotycząca funkcji: możliwość zwracania wartości. Spotkaliśmy się już z tym zagadnieniem wcześniej, ponieważ funkcja size() używana wraz ze zmiennymi typu string zwracała ilość znaków w łańcuchu, a zdefiniowana w pliku cmath funkcja pow() zwracała liczbę podniesioną do zadanej potęgi. Aby sprawić, że funkcja zwraca wartości, musimy użyć instrukcji return (jak już robiliśmy w przypadku funkcji main()). Może to być dowolna pojedyncza wartość: return 1; Zwracana wartość może być nawet wyrażona w postaci zmiennej: int num = 6.25; return num; Poza poprawnym użyciem instrukcji return niezbędne jest także wskazanie w prototypie i definicji funkcji typu wartości zwracanej. Robi się to przez poprzedzenie nazwy funkcji identyfikatorem typu: // Prototyp: float multiply (float x, float y); // Definicja: float multiply (float x, float y) { return x * y; } Wartości zwróconych przez funkcję można używać w przypisaniach do zmiennych, w obliczeniach lub nawet jako argumentów wywołania innych funkcji: float num = multiply (2.6, 890.245); float sum = num + multiply (0.32, 6874.1); std::cout multiply (0.5, 32.2); i c ś o t r a w h c y c ą j a c a r w z i j c k n u f e i n e z r o w T 170 Listing 5.4. Program używa osobnej funkcji do obliczenia i zwrócenia wartości silni liczby wprowadzonej przez użytkownika 1 // factorial.cpp - Listing 5.4 2 3 // Potrzebujemy pliku iostream, by móc 4 // korzystać z cout i cin. 5 #include iostream 6 7 /* Prototyp pierwszej funkcji. 8 * Funkcja nie pobiera argumentów. 9 * Funkcja nie zwraca żadnej wartości. 10 */ 11 void promptvnddait(); 12 13 /* Prototyp drugiej funkcji. 14 * Funkcja pobiera jeden argument typu Äunsigned short. 15 * Funkcja zwraca wartość typu unsigned long. 16 */ 17 unsigned long returnF1ctori1l unsigned Äshort num v 18 19 // Początek funkcji main(). 20 int main() { 21 22 // Deklaracja zmiennych. 23 unsigned svort numberIn; 24 25 // Prośba o wprowadzenie liczby i Äwczytanie jej. 26 std::cout dprowadź nieujemną Äliczbę całkowitą o małej Äwartości: [##] ; 27 std::cin numberIn; 28 29 // Miejsce na sprawdzenie poprawności Ädanych - 30 // np. czy liczba mieści się w zakresie od 1 do 13. 31 Definiowanie własnych funkcji Kolejny przykładowy program zaprezentuje w praktyce zwracanie wartości przez funkcje. Zdefiniujemy funkcję pobierającą pojedynczy argument typu całkowitego, zwracającą jego silnię. Program w rozdziale 3. demonstrował już, czym jest silnia: operacja ta jest oznaczana w matematyce jako n!, a jej wynik jest równy iloczynowi wszystkich liczb od 1 do n (tak więc 4! jest równe 1 * 2 * 3 * 4). Aby zdefiniować funkcje zwracające wartości: 1. Utwórz nowy, pusty dokument tekstowy w edytorze tekstu lub środowisku programistycznym (listing 5.4). // factorial.cpp - Listing 5.4 #include iostream 2. Dodaj dwa prototypy funkcji. void promptvnddait(); unsigned long returnFactorial(unsigned svort num); Nowa funkcja returnFactorial() pobiera jeden argument o nazwie num typu unsigned short oraz zwraca wartość typu unsigned long. Typy te są dopasowane do wielkości liczb, ponieważ silnia nawet bardzo małej liczby bardzo szybko osiągnie górną granicę zakresu typu long. 3. Rozpocznij definicję funkcji main(). int main() { unsigned svort numberIn; Główna część programu wymaga użycia tylko jednej zmiennej, w której zapisywać będziemy wprowadzoną przez użytkownika liczbę. Jej typ jest celowo taki sam, jak typ argumentu funkcji returnFactorial(). T w o r z e n i e f u n k c j i z w r a c a j ą c y c h w a r t o ś c i 171 Rozdział 5. 4. Poproś użytkownika o wprowadzenie liczby Listing 5.4. — ciąg dalszy 32 // Wypisanie wyników. 33 std::cout Silni1 liczby Änumber1n 34 wynosi returnF1ctori1l Ä number1n . v 35 36 // Wywołanie funkcji promptAndWait(). 37 promptvnddait(); 38 39 // Zwrócenie wartości 0, by zaznaczyć Äbrak problemów. 40 return 0; 41 42 } // Koniec funkcji main(). 43 44 45 // Definicja funkcji promptAndWait(). 46 void promptvnddait() { 47 std::cin.ignore(100, ); 48 std::cout Naciśnij Enter lub ÄReturn, aby kontynuować. ; 49 std::cin.get(); 50 } // Koniec funkcji promptAndWait(). 51 52 53 // Definicja funkcji returnFactorial(). 54 unsigned long returnF1ctori1l unsigned Äshort num { 55 56 unsigned long sum = 1v 57 58 // Pętla przechodzi przez wszystkie liczby 59 // od 1 do num, wyznaczając iloczyn. 50 for (int i = 1; i = num; ++i) { 61 62 // Mnożenie sumarycznego wyniku Äprzez współczynnik. 63 sum *= i; i przypisz ją do zmiennej numberIn. std::cout dprowadź nieujemną liczbę Äcałkowitą o małej wartości: [##] ; std::cin numberIn; Moglibyśmy w tym miejscu wykonać operacje sprawdzające poprawność wprowadzonych danych (np. zweryfikować, czy wprowadzona wartość jest liczbą całkowitą mieszczącą się w przedziale od 1 do 12). Na górną granicę wybrano liczbę 12, ponieważ 13! przekracza zakres zmiennych typu unsigned int na 32-bitowych komputerach (nie należy się martwić, jeśli ostatnie zdanie wydaje się nie mieć większego sensu — po lekturze rozdziału 10., „Diagnostyka i obsługa błędów”, wszystko powinno stać się jasne). 5. Wypisz silnię wprowadzonej liczby. std::cout Silnia liczby numberIn wynosi returnFactorial (numberIn) . ; Wprowadzona wartość jest ponownie wysyłana na wyjście wraz z obliczonym wynikiem działania (rysunek 5.8). Ponieważ funkcja returnFactorial() zwraca wartość, to jej wywołanie można umieścić bezpośrednio w instrukcji wysyłania danych do strumienia cout. Wynikiem działania instrukcji będzie wypisanie liczby na ekranie. 6. Dokończ funkcję main(). promptvnddait(); return 0; } 7. Zdefiniuj funkcję promptAndWait(). void promptvnddait() { std::cin.ignore(100, ); std::cout Naciśnij Enter lub Return, Äaby kontynuować. ; std::cin.get(); } i c ś o t r a w h c y c ą j a c a r w z i j c k n u f e i n e z r o w T 172 Listing 5.4. — ciąg dalszy 64 65 } // Koniec pętli. 66 67 return sumv 68 69 } // Koniec funkcji returnFactorial(). Rysunek 5.8. Wprowadzona liczba i jej silnia są wyświetlane na ekranie Rysunek 5.9. Funkcja obliczy i zwróci wartości dowolnej nieujemnej liczby całkowitej o małej wartości Definiowanie własnych funkcji 8. Rozpocznij definicję funkcji returnFactorial(). unsigned long returnFactorial (unsigned Äsvort num) { Definicja rozpoczyna się dokładnie tak samo jak prototyp. 9. Oblicz wartość silni. unsigned long sum = 1; for (int i = 1; i = num; ++i) { sum *= i; } Powyższy kod został już przedstawiony w rozdziale 3. Wynik otrzymywany jest przez pomnożenie wszystkich liczb od 1 aż do wprowadzonej wartości. W tym celu zmienna sum inicjalizowana jest wartością 1, której następnie przypisywany jest wynik mnożenia jej samej przez współczynnik i. 10. Zwróć wynik obliczeń i zakończ funkcję. return sum; } Zwracana zmienna sum zawiera obliczoną wartość silni. Zauważmy, że typ zmiennej (unsigned long) jest taki sam, jak zadeklarowany typ wartości zwracanej przez funkcję. 11. Zapisz plik jako factorial.cpp, po czym skompiluj i uruchom program (rysunek 5.9). T w o r z e n i e f u n k c j i z w r a c a j ą c y c h w a r t o ś c i 173 Rozdział 5. Wskazówki n W funkcji możemy zapisać kilka instrukcji return, zawsze jednak wykona się tylko jedna z nich. Często można się spotkać z kodem podobnym do poniższego: if (warunek) { return 1; } else { return 0; } n Instrukcja return zatrzymuje działanie funkcji. Jakikolwiek kod występujący po instrukcji return nie będzie już wykonany: int myF () { return 1; std::cout Funkcja zwróciła liczbę 1 ; } Komunikat Funkcja zwróciła liczbę 1 nie pojawi się na ekranie, ponieważ program nie wykona wiersza zawierającego odwołanie do cout. n Prawdziwi formaliści mogą zapisywać: return; nawet w funkcjach, które nie zwracają żadnej wartości. i c ś o t r a w h c y c ą j a c a r w z i j c k n u f e i n e z r o w T 174 Definiowanie własnych funkcji Funkcje rekurencyjne Innym rodzajem funkcji, które można zdefiniować w C++, a które nie są szczegółowo omawiane w książce, są funkcje rekurencyjne (ang. recursive). Rekurencja polega na wywoływaniu przez funkcję samej siebie i stworzeniu swoistej pętli. Funkcji takich raczej nie spotyka się zbyt często, ale czasami mogą w zdecydowany sposób uprościć rozwiązywanie złożonych problemów. Załóżmy, że chcemy napisać program obliczający następną liczbę pierwszą większą od pewnej wczytanej wartości (podanie liczby 3 ma sprawić, że program zwróci liczbę 5 jako kolejną liczbę pierwszą, a wczytanie liczby 13 spowodować ma zwrócenie wartości 17). Szkielet algorytmu można przedstawić następująco: 1. Zwiększ wczytaną wartość o 1 (ponieważ zależy nam na liczbie pierwszej większej od wczytanej wartości). 2. Sprawdź, czy nowa wartość jest liczbą pierwszą (sprawdzając resztę z dzielenia przez wszystkie mniejsze od bieżącej wartości liczby pierwsze). 3. Jeśli wartość nie jest liczbą pierwszą, wróć do kroku 1. 4. Jeśli wartość jest liczbą pierwszą, zwróć ją. Powyższe instrukcje można by zapisać w postaci funkcji rekurencyjnej: unsigned int findPrime(unsigned int num) { bool isPrime = false; // Znacznik zakończenia obliczeń. ++num; // Inkrementacja. // Obliczenia sprawdzające, // czy liczba jest pierwsza. if (isPrime) { // Stop. return num; } else { // Sprawdzenie kolejnej liczby. findPrime(num); } } Powyższy kod utworzy zapętlone wywołanie, które będzie się wykonywać dopóki zmienna isPrime ma wartość true. Każde kolejne wywołanie funkcji findPrime() sprawdzać będzie, czy następna liczba nie jest szukaną. Innym przykładem używania wywołań rekurencyjnych jest odczytywanie struktury katalogów na dysku. Można zdefiniować funkcję, która przegląda zawartość całego katalogu i w momencie napotkania innego katalogu wywoła samą siebie, używając znalezionego katalogu jako swojego nowego punktu startowego. Najważniejszym zagadnieniem związanym z funkcjami rekurencyjnymi jest poprawne zdefiniowanie warunku zakończenia wywołań. W innym przypadku program wpadnie w pętlę nieskończoną lub po prostu zakończy pracę, gdyż zabraknie mu pamięci. T w o r z e n i e f u n k c j i z w r a c a j ą c y c h w a r t o ś c i 175 Rozdział 5. Przeciążanie funkcji Przeciążanie funkcji w C++ jest trochę bardziej skomplikowanym zagadnieniem niż to, czym zajmowaliśmy się do tej pory, ale stanowi w dużej mierze o sile i elastyczności języka. Przeciążanie polega na zdefiniowaniu więcej niż jednej funkcji o takiej samej nazwie (i tym samym przeznaczeniu), ale o innej liście argumentów (zarówno co do typu, jak i liczby argumentów). Pobieżna analiza funkcji convertTemperature() (zobacz listing 5.2) pozwala dostrzec, dlaczego może być to przydatne. Nasza funkcja pobiera zasadniczo jeden argument typu float oraz jeden typu char. Próba konwersji liczby całkowitej byłaby niemożliwa, ponieważ aktualna wersja funkcji oczekuje wartości typu float (kompilator dopuściłby takie wywołanie, jednak wartość 64 byłaby traktowana jako 64.0 — liczba rzeczywista, a nie całkowita). Moglibyśmy utworzyć nową funkcję, np. o nazwie convertIntegerTemperature(), ale wtedy w programie należałoby pamiętać o tym, aby dla jednego typu argumentów wywoływać funkcje o jednej nazwie, a dla innego o drugiej. Lepszym rozwiązaniem jest ponowne zdefiniowanie tej funkcji, ale w taki sposób, aby mogła pobierać także wartości całkowite. Dwa prototypy deklarowanych funkcji mogłyby wyglądać następująco: void convertTemperature (float tempIn, cvar ÄtypeIn); void convertTemperature (int tempIn, cvar ÄtypeIn); Wybór odpowiedniej funkcji przy wywołaniu odbywa się na podstawie sprawdzenia typów argumentów. convertTemperature (54.9, F ); convertTemperature (16, ); i j c k n u f e i n a ż ą i c e z r P Listing 5.5. Dzięki dodaniu kolejnej definicji funkcji dollarsToEuros() funkcje o tej samej nazwie mogą być wykorzystywane do działania z liczbami rzeczywistymi oraz całkowitymi 1 // overload.cpp - Listing 5.5 2 3 // Potrzebujemy pliku iostream, by móc 4 // korzystać z cout i cin. 5 #include iostream 6 7 /* Prototyp pierwszej funkcji. 8 * Funkcja nie pobiera argumentów. 9 * Funkcja nie zwraca żadnej wartości. 10 */ 11 void promptvnddait(); 12 13 /* Prototyp drugiej funkcji. 14 * Funkcja pobiera dwa argumenty: 15 * jeden typu foat i jeden typu char. 16 * Funkcja nie zwraca żadnej wartości. 17 */ 18 void doll1rsToEuros flo1t r1te, Äunsigned doll1rs v 19 20 /* Prototyp trzeciej funkcji (przeciążenie). 21 * Funkcja pobiera dwa argumenty, oba typu Äfloat. 22 * Funkcja nie zwraca żadnej wartości. 23 */ 24 void doll1rsToEuros flo1t r1te, flo1t Ädoll1rs v 25 26 // Początek funkcji main(). 27 int main() { 28 29 // Deklaracja zmiennych. 30 float conversionRate = 0.832339; Ä// $1 = 0.832339 Euro 31 unsigned dollarsIn; 32 flo1t doll1rs1nFlo1tv 33 Pomimo że obie funkcje wykonują w tym przypadku te same operacje, kompilator na podstawie typów przekazywanych argumentów wygeneruje odpowiednie wywołania dwóch różnych funkcji. Możemy sobie zadać pytanie, kiedy ta składnia mogłaby się nam przydać? Najczęściej przeciążonych funkcji używa się do zapewnienia, aby ten sam kod mógł operować na różnych typach danych. 176 Listing 5.5. — ciąg dalszy 34 // Prośba o podanie kwoty pieniędzy i Äwczytanie jej. 35 std::cout Podaj kwotę Äpieniędzy w dolaracv (bez znaku Ädolara, przecinka ani kropki): Ä[###] ; 36 std::cin dollarsIn; 37 38 // Wypisanie kwoty po zamianie walut. 39 dollarsToEuros(conversionRate, ÄdollarsIn); 40 41 // Powtórzenie dla zmiennej typu float. 42 std::cout Podaj kwotę Äpieniędzy w dolaracv (bez znaku Ädolara, przecinka ani kropki): Ä[###] ; 43 std::cin dollarsInFloat; 44 45 // Wypisanie wysokości sumy po zamianie Äwalut. 46 doll1rsToEuros conversionR1te, Ädoll1rs1nFlo1t v 47 48 // Wywołanie funkcji promptAndWait(). 49 promptvnddait(); 50 51 // Zwrócenie wartości 0, by zaznaczyć Äbrak problemów. 52 return 0; 53 54 } // Koniec funkcji main(). 55 56 57 // Definicja funkcji promptAndWait(). 58 void promptvnddait() { 59 std::cin.ignore(100, ); 60 std::cout Naciśnij Enter lub ÄReturn, aby kontynuować. ; 61 std::cin.get(); 62 } // Koniec funkcji promptAndWait(). 63 Definiowanie własnych funkcji Moglibyśmy zdefiniować jedną wersję pewnej funkcji tak, aby pobierała liczby całkowite, inną — żeby oczekiwała liczb rzeczywistych itd. Podobne działanie demonstrował poprzedni przykład. W prak
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie w języku C++. Szybki start
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ą: