Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00456 005405 19041336 na godz. na dobę w sumie
Język C++. Owoce programowania. Wydanie IX - książka
Język C++. Owoce programowania. Wydanie IX - książka
Autor: Liczba stron: 1408
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-4680-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c++ - programowanie
Porównaj ceny (książka, ebook (-35%), audiobook).

C++ powstał w 1979 roku. Od tej pory cały czas się rozwija. Mimo że wymaga od programisty pewnej dyscypliny i staranności w pracy, jest chętnie wykorzystywany, daje bowiem ogromne możliwości i cechuje się elastycznością. W języku tym zaimplementowano mechanizmy programowania obiektowego. Opanowanie C++ nie tylko pozwala programistom tworzyć aplikacje dla praktycznie wszystkich platform, komputerów, serwerów i urządzeń mobilnych, ale również ułatwia naukę innych języków programowania. Aby w pełni skorzystać z tych zalet, trzeba od początku przykładać się do nauki pisania kodu z poszanowaniem dobrych praktyk.

To kolejne wydanie lubianego podręcznika programowania w języku C++; książka przeznaczona dla osób, które dopiero rozpoczynają naukę kodowania, i tych, które mają już doświadczenie z innymi językami. Znalazło się tu przystępne wyjaśnienie podstaw działania komputera oraz wprowadzenie do samego języka, a także mnóstwo pożytecznych wskazówek dla początkujących. Bardziej zaawansowani programiści docenią szczegółowe opisy niuansów, zawiłości i źródeł możliwych problemów. Książka jest napisana prostym, zrozumiałym językiem i zawiera wiele świetnie dobranych przykładów ilustrujących nie tylko funkcje i konstrukcje języka C++, ale również przypadki i sposoby ich użycia.

Najważniejsze zagadnienia:

Idź i programuj w C++!

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

Darmowy fragment publikacji:

Tytuł oryginału: Starting Out with C++ from Control Structures through Objects (9th Edition) Tłumaczenie: Patryk Wierzchoń (rozdz. 1 – 6, dodatki), Andrzej Watrak (rozdz. 7 – 21) ISBN: 978-83-283-4680-2 Authorized translation from the English language edition, entitled: STARTING OUT WITH C++ FROM CONTROL STRUCTURES THROUGH OBJECTS, Ninth Edition; ISBN 0134498372; by Tony Gaddis; published by Pearson Education, Inc. Copyright © 2018, 2015, 2012, 2009 Pearson Education, Inc. Hoboken, NJ 07030. 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 SA, Copyright © 2019. 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 Helion SA dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Helion SA nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock Images LLC. Helion SA 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) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/jezcow 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 Przedmowa ...................................................................... 15 ROZDZIAŁ 1. Wprowadzenie do komputerów i programowania ...... 29 1.1. Dlaczego tworzymy oprogramowanie? .................................29 Systemy komputerowe: sprzęt i oprogramowanie .................31 1.2. Programy i języki programowania .........................................37 1.3. 1.4. Z czego składa się program? ................................................43 Przyjmowanie danych, ich przetwarzanie i wynik ...................47 1.5. 1.6. Proces programowania .........................................................48 1.7. Programowanie proceduralne i obiektowe ............................52 Pytania i ćwiczenia kontrolne ...........................................................54 ROZDZIAŁ 2. Wprowadzenie do języka C++ ...................................... 57 2.1. Elementy programu w języku C++ .......................................57 2.2. Obiekt cout ..........................................................................61 2.3. Dyrektywa #include .............................................................66 Zmienne, literały i wyrażenia przypisania ...............................67 2.4. Identyfikatory .......................................................................71 2.5. Typy danych liczb całkowitych ..............................................73 2.6. 2.7. Typ char ...............................................................................78 Klasa string w C++ .............................................................82 2.8. 2.9. Typy danych liczb zmiennoprzecinkowych .............................84 2.10. Typ danych bool ...................................................................87 2.11. Określanie rozmiaru typu danych ..........................................88 2.12. Więcej o inicjowaniu zmiennych i przypisywaniu wartości .....90 2.13. Zasięg zmiennych .................................................................92 5 Poleć książkęKup książkę 6 Spis treści 2.14. Operatory arytmetyczne .......................................................93 2.15. Komentarze .......................................................................100 2.16. Stałe nazwane ...................................................................102 2.17. Styl programowania ...........................................................105 Pytania i ćwiczenia kontrolne .........................................................107 Wyzwania programistyczne ...........................................................111 ROZDZIAŁ 3. Wyrażenia i interaktywność ......................................... 115 3.1. Obiekt cin ..........................................................................115 3.2. Wyrażenia matematyczne ...................................................121 3.3. Gdy pomylisz jabłka z pomarańczami: konwersja typów ......129 3.4. Przepełnienie i zaniżenie .....................................................132 3.5. Rzutowanie typów .............................................................133 3.6. Wielokrotne przypisania i przypisania łączone .....................136 3.7. Formatowanie wyjścia ........................................................140 3.8. Operacje na znakach i obiekcie string .................................149 3.9. Więcej matematycznych funkcji bibliotecznych ....................155 3.10. Rzecz o debugowaniu: ręczne śledzenie programu ..............161 3.11. Rozwiązywanie problemu: analiza przypadku ......................162 Pytania i ćwiczenia kontrolne .........................................................166 Wyzwania programistyczne ...........................................................172 ROZDZIAŁ 4. Podejmowanie decyzji .................................................. 181 4.1. Operatory relacji .................................................................181 4.2. Instrukcja if ........................................................................186 Rozszerzanie instrukcji if .....................................................194 4.3. Instrukcja if/else .................................................................197 4.4. 4.5. Zagnieżdżone struktury warunkowe ...................................200 Instrukcja if/else if ..............................................................207 4.6. 4.7. Flagi ..................................................................................212 4.8. Operatory logiczne .............................................................213 4.9. Sprawdzanie przedziału liczbowego za pomocą operatorów logicznych .......................................................220 4.10. Menu .................................................................................222 4.11. Rzecz o inżynierii oprogramowania: walidacja wejścia użytkownika .......................................................................224 4.12. Porównywanie typów char i string ......................................226 4.13. Operator warunkowy .........................................................230 Poleć książkęKup książkę Spis treści 7 4.14. Instrukcja switch ................................................................233 4.15. Więcej o blokach i zasięgu zmiennych .................................241 Pytania i ćwiczenia kontrolne .........................................................244 Wyzwania programistyczne ...........................................................250 ROZDZIAŁ 5. Pętle i pliki ..................................................................... 261 5.1. Operatory inkrementacji i dekrementacji .............................261 5.2. Wprowadzenie do pętli: pętla while ....................................266 5.3. Walidacja wejścia za pomocą pętli while .............................273 Liczniki ...............................................................................275 5.4. Pętla do-while ....................................................................276 5.5. 5.6. Pętla for .............................................................................281 5.7. Obliczanie sumy bieżącej ....................................................291 5.8. Wartownik .........................................................................293 5.9. Rzecz o inżynierii oprogramowania: której pętli użyć? .........295 5.10. Pętle zagnieżdżone ............................................................296 5.11. Zastosowanie plików do przechowywania danych ...............298 5.12. Temat dodatkowy: przerywanie i kontynuowanie pętli ........318 Pytania i ćwiczenia kontrolne .........................................................322 Wyzwania programistyczne ...........................................................327 ROZDZIAŁ 6. Funkcje ........................................................................... 335 6.1. Rzecz o inżynierii oprogramowania: programowanie modułowe .........................................................................335 6.2. Definicja i wywoływanie funkcji ..........................................336 Prototypy funkcji ................................................................344 6.3. Przekazywanie danych do funkcji ........................................346 6.4. Przekazywanie danych przez wartość ..................................350 6.5. 6.6. Rzecz o inżynierii oprogramowania: zastosowanie funkcji w programie sterowanym przez menu ................................352 Instrukcja return .................................................................356 6.7. Zwracanie wartości z funkcji ...............................................357 6.8. 6.9. Zwracanie wartości boolowskiej ..........................................365 6.10. Zmienne lokalne i globalne .................................................367 6.11. Statyczne zmienne lokalne ..................................................374 6.12. Argumenty domyślne .........................................................378 6.13. Zastosowanie wskaźników jako parametrów .......................381 6.14. Przeciążanie funkcji ............................................................386 6.15. Funkcja exit() ......................................................................390 Poleć książkęKup książkę 8 Spis treści 6.16. Funkcje wirtualne i sterowniki .............................................392 Pytania i ćwiczenia kontrolne .........................................................394 Wyzwania programistyczne ...........................................................398 Projekt grupowy ............................................................................406 ROZDZIAŁ 7. Tablice i wektory ........................................................... 409 7.1. Tablica jako zbiór wartości ..................................................409 7.2. Dostęp do elementów tablicy .............................................411 7.3. Brak kontroli zakresów w języku C++ ................................422 Zakresowa pętla for ............................................................425 7.4. Przetwarzanie zawartości tablicy .........................................429 7.5. 7.6. Rozwiązywanie problemu i projektowanie programu: tablice równoległe ..............................................................437 Tablice w argumentach funkcji ...........................................440 Tablice dwuwymiarowe ......................................................450 Tablice o trzech i większej liczbie wymiarów ........................457 7.7. 7.8. 7.9. 7.10. Rozwiązywanie problemu i projektowanie programu: analiza przypadku ..............................................................459 7.11. Wprowadzenie do typu STL vector ......................................461 Pytania i ćwiczenia kontrolne .........................................................474 Wyzwania programistyczne ...........................................................480 ROZDZIAŁ 8. Przeszukiwanie i sortowanie tablic ............................. 489 8.1. 8.2. 8.3. Rozwiązywanie problemu i projektowanie programu: wprowadzenie do algorytmów wyszukiwania danych ..........489 Rozwiązywanie problemu i projektowanie programu: analiza przypadku ..............................................................496 Rozwiązywanie problemu i projektowanie programu: wprowadzenie do algorytmów sortowania .........................502 Rozwiązywanie problemu i projektowanie programu: analiza przypadku ..............................................................512 Sortowanie i przeszukiwanie wektorów (kontynuacja podrozdziału 7.11) ........................................520 Pytania i ćwiczenia kontrolne .........................................................523 Wyzwania programistyczne ...........................................................524 8.5. 8.4. ROZDZIAŁ 9. Wskaźniki ....................................................................... 529 9.1. Uzyskiwanie adresu zmiennej .............................................529 9.2. Zmienne wskaźnikowe .......................................................531 Poleć książkęKup książkę Spis treści 9 9.3. Relacja pomiędzy tablicą a wskaźnikiem ..............................538 9.4. Działania na wskaźnikach ...................................................542 Inicjowanie wskaźników .....................................................543 9.5. 9.6. Porównywanie wskaźników ................................................545 9.7. Wskaźniki jako argumenty funkcji .......................................546 9.8. Dynamiczne przydzielanie pamięci ......................................554 9.9. Wskaźniki jako wyniki funkcji ..............................................558 9.10. Inteligentne wskaźniki i zapobieganie wyciekom pamięci ....565 9.11. Rozwiązywanie problemu i projektowanie programu: analiza przypadku ..............................................................569 Pytania i ćwiczenia kontrolne .........................................................574 Wyzwania programistyczne ...........................................................578 ROZDZIAŁ 10. O znakach, C-ciągach i więcej o klasie string ............. 581 10.1. Sprawdzanie znaków .........................................................581 10.2. Zmiana wielkości liter .........................................................585 10.3. C-ciągi ...............................................................................588 10.4. Standardowe funkcje przetwarzające C-ciągi .......................592 10.5. Funkcje konwertujące ciągi i liczby ......................................602 10.6. Rozwiązywanie problemu i projektowanie programu: tworzenie własnych funkcji przetwarzających C-ciągi ..........609 10.7. Więcej o klasie string ..........................................................614 10.8. Rozwiązywanie problemu i projektowanie programu: analiza przypadku ..............................................................627 Pytania i ćwiczenia kontrolne .........................................................628 Wyzwania programistyczne ...........................................................631 ROZDZIAŁ 11. Dane strukturalne ......................................................... 637 11.1. Typy abstrakcyjne ...............................................................637 11.2. Struktury ............................................................................639 11.3. Dostęp do składników struktury ..........................................642 11.4. Inicjowanie struktury ..........................................................645 11.5. Tablice struktur ..................................................................648 11.6. Inżynieria oprogramowania: struktury zagnieżdżone ...........651 11.7. Struktury jako argumenty funkcji ........................................654 11.8. Struktury jako wyniki funkcji ...............................................657 11.9. Wskaźniki do struktur .........................................................659 11.10. Inżynieria oprogramowania: kiedy stosować kropkę, strzałkę i gwiazdkę? ...........................................................662 Poleć książkęKup książkę 10 Spis treści 11.11. Typy wyliczeniowe ..............................................................664 Pytania i ćwiczenia kontrolne .........................................................675 Wyzwania programistyczne ...........................................................680 ROZDZIAŁ 12. Zaawansowane operacje na plikach ........................... 687 12.1. Operacje na plikach ............................................................687 12.2. Formatowanie danych wyjściowych ....................................693 12.3. Umieszczanie obiektów plikowych w argumentach funkcji ....695 12.4. Dokładniejsze sprawdzanie błędów ....................................697 12.5. Funkcje do odczytywania i zapisywania danych ...................700 12.6. Inżynieria oprogramowania: praca z wieloma plikami ..........707 12.7. Pliki binarne .......................................................................709 12.8. Tworzenie rekordów danych za pomocą struktur ................714 12.9. Swobodny dostęp do plików ..............................................718 12.10. Otwieranie pliku w trybach wejściowym i wyjściowym jednocześnie .................................................725 Pytania i ćwiczenia kontrolne .........................................................730 Wyzwania programistyczne ...........................................................734 ROZDZIAŁ 13. Wprowadzenie do klas ................................................. 739 13.1. Programowanie proceduralne i obiektowe ..........................739 13.2. Wprowadzenie do klas .......................................................746 13.3. Definiowanie instancji klasy ................................................751 13.4. Po co są prywatne elementy? .............................................763 13.5. Inżynieria oprogramowania: rozdzielenie specyfikacji i implementacji klasy ..........................................................764 13.6. Metody śródwierszowe ......................................................770 13.7. Konstruktory ......................................................................772 13.8. Umieszczanie wartości w argumentach konstruktorów ........778 13.9. Destruktory ........................................................................784 13.10. Przeciążanie konstruktora ...................................................788 13.11. Metody prywatne ...............................................................793 13.12. Tablice obiektów ................................................................794 13.13. Rozwiązywanie problemu i projektowanie programu: przykład programowania obiektowego ...............................798 13.14. Programowanie obiektowe: symulowanie rzutów kostką za pomocą obiektów ..........................................................805 13.15. Projektowanie kodu obiektowego: język UML .....................808 Poleć książkęKup książkę Spis treści 11 13.16. Projektowanie kodu obiektowego: dobór klas i określanie ich przeznaczenia ...............................................................811 Pytania i ćwiczenia kontrolne .........................................................820 Wyzwania programistyczne ...........................................................825 ROZDZIAŁ 14. Więcej o klasach ............................................................ 837 14.1. Instancje klasy i statyczne elementy członkowskie ................837 14.2. Klasy zaprzyjaźnione ...........................................................844 14.3. Przypisanie obiektowe ........................................................849 14.4. Konstruktor kopiujący .........................................................850 14.5. Przeciążanie operatorów ....................................................856 14.6 Konwersja typów ...............................................................882 14.7. Agregacja obiektów ...........................................................884 14.8. Projektowanie kodu obiektowego: współpraca klas .............889 14.9. Programowanie obiektowe: symulacja gry Cho-Han ............893 14.10. Referencje do r-wartości i przenoszenie danych ...................903 Pytania i ćwiczenia kontrolne .........................................................912 Wyzwania programistyczne ...........................................................917 ROZDZIAŁ 15. Dziedziczenie klas, polimorfizm i funkcje wirtualne ... 925 15.1. Co to jest dziedziczenie klas? ..............................................925 15.2. Chronione elementy członkowskie i dostęp do klasy ............933 15.3. Konstruktory i destruktory w klasach bazowych i pochodnych .....................................................................940 15.4. Redefiniowanie funkcji klasy bazowej ..................................952 15.5. Hierarchia klas ....................................................................956 15.6. Polimorfizm i metody wirtualne ..........................................962 15.7. Abstrakcyjne klasy bazowe i funkcje czysto wirtualne ..........977 15.8. Wielodziedziczenie klas ......................................................984 Pytania i ćwiczenia kontrolne .........................................................990 Wyzwania programistyczne ...........................................................995 ROZDZIAŁ 16. Wyjątki i szablony ....................................................... 1003 16.1. Wyjątki ............................................................................1003 16.2. Szablony funkcji ...............................................................1021 16.3. Inżynieria oprogramowania: od czego zacząć definiowanie szablonów funkcji? ......................................1027 16.4. Szablony klas ...................................................................1027 Poleć książkęKup książkę 12 Spis treści Pytania i ćwiczenia kontrolne .......................................................1036 Wyzwania programistyczne .........................................................1039 ROZDZIAŁ 17. Biblioteka STL .............................................................. 1041 17.1. Wprowadzenie do biblioteki STL .......................................1041 17.2. Podstawowe informacje o kontenerach i iteratorach STL ...1042 17.3. Klasa vector ......................................................................1053 17.4. Klasy map, multimap i unordered_map .............................1066 17.5. Klasy set, multiset i unordered_set ....................................1091 17.6. Algorytmy ........................................................................1099 17.7. Wprowadzenie do obiektów funkcyjnych i wyrażeń lambda ...1120 Pytania i ćwiczenia kontrolne .......................................................1126 Wyzwania programistyczne .........................................................1131 ROZDZIAŁ 18. Listy łączone ................................................................ 1137 18.1. Wprowadzenie do list łączonych .......................................1137 18.2. Operacje na listach łączonych ...........................................1139 18.3. Szablon listy łączonej .......................................................1155 18.4. Odmiany listy łączonej ......................................................1166 18.5. Standardowe kontenery list i forward_list .........................1166 Pytania i ćwiczenia kontrolne .......................................................1172 Wyzwania programistyczne .........................................................1174 ROZDZIAŁ 19. Stosy i kolejki .............................................................. 1177 19.1. Wprowadzenie do stosów ................................................1177 19.2. Stosy dynamiczne .............................................................1193 19.3. Kontener stack .................................................................1203 19.4. Wprowadzenie do kolejek ................................................1205 19.5. Kolejki dynamiczne ...........................................................1216 19.6. Kontenery deque i queue ..................................................1223 Pytania i ćwiczenia kontrolne .......................................................1226 Wyzwania programistyczne .........................................................1228 ROZDZIAŁ 20. Rekurencja ................................................................... 1231 20.1. Wprowadzenie do rekurencji ............................................1231 20.2. Rozwiązywanie problemów za pomocą rekurencji .............1235 20.3. Rozwiązywanie problemu i projektowanie programu: rekurencyjna funkcja gcd() ................................................1242 Poleć książkęKup książkę Spis treści 13 20.4. Rozwiązywanie problemu i projektowanie programu: zadania rekurencyjne ........................................................1243 20.5. Rozwiązywanie problemu i projektowanie programu: rekurencyjne operacje na listach łączonych ........................1245 20.6. Rozwiązywanie problemu i projektowanie programu: rekurencyjna funkcja wyszukiwania binarnego ..................1248 20.7. Rozwiązywanie problemu i projektowanie programu: Wieże Hanoi ....................................................................1250 20.8. Rozwiązywanie problemu i projektowanie programu: algorytm sortowania szybkiego .........................................1254 20.9. Rozwiązywanie problemu i projektowanie programu: algorytm wyszukiwania wyczerpującego ...........................1258 20.10. Rozwiązywanie problemu i projektowanie programu: rekurencja a iteracja .........................................................1260 Pytania i ćwiczenia kontrolne .......................................................1261 Wyzwania programistyczne .........................................................1263 ROZDZIAŁ 21. Drzewa binarne ........................................................... 1265 21.1. Definicja i zastosowanie drzew binarnych .........................1265 21.2. Operacje przeszukiwania drzewa binarnego ......................1269 21.3. Szablon klasy do obsługi drzewa binarnego ......................1285 Pytania i ćwiczenia kontrolne .......................................................1290 Wyzwania programistyczne .........................................................1291 DODATEK A Zestaw znaków ASCII .................................................. 1295 DODATEK B Hierarchia operatorów ............................................... 1299 DODATEK C Odpowiedzi do punktów kontrolnych ....................... 1307 DODATEK D Odpowiedzi do pytań i ćwiczeń kontrolnych ............ 1343 Skorowidz .................................................................... 1397 Poleć książkęKup książkę 14 Spis treści Poleć książkęKup książkę Wyrażenia i interaktywność Ł A I Z D Z O R 3 TEMATYKA 3.1. Obiekt cin 3.2. Wyrażenia matematyczne 3.3. Gdy pomylisz jabłka z pomarańczami: 3.7. Formatowanie wyjścia 3.8. Operacje na znakach i obiekcie string 3.9. Więcej matematycznych funkcji konwersja typów bibliotecznych 3.4. Przepełnienie i zaniżenie 3.5. Rzutowanie typów 3.6. Wielokrotne przypisania i przypisania łączone 3.10. Rzecz o debugowaniu: ręczne śledzenie programu 3.11. Rozwiązywanie problemu: analiza przypadku Pytania i ćwiczenia kontrolne 3.1. Obiekt cin 3.1. Obiekt cin WYJAŚNIENIE: Obiekt cin możemy wykorzystać do odczytu informacji wpi- sywanych na klawiaturze. Jak dotąd pisałeś programy, które miały dane wbudowane w kod. Użytkownik nie miał możliwości wprowadzenia własnych danych, a początkowe wartości zmiennych zostały zainicjowane przez twórcę kodu. Tego typu programy ograniczają się tylko do jednego zestawu początkowych danych. Każda zmiana danych oznacza modyfi- kację kodu i ponowną kompilację. W praktyce większość programów wymaga wprowadzenia do nich danych, które zostaną przypisane do zmiennych. Oznacza to, że nie trzeba modyfikować programu za każdym razem, gdy użytkownik chce zmienić zestaw danych. Na przykład program, który oblicza wynagrodzenia w małej firmie, będzie wymagał od użytkownika wprowadzenia imienia i nazwiska pracownika, liczby przepracowanych godzin i wynagrodzenia za 115 Poleć książkęKup książkę 116 Rozdział 3. Wyrażenia i interaktywność godzinę pracy. Po wydrukowaniu informacji o wysokości wypłaty pracownika program może zacząć od początku i poprosić o wpisanie danych dla kolejnego pracownika. Tak jak cout jest standardowym obiektem wyjścia języka C++, tak cin jest stan- dardowym obiektem wejścia. Odczytuje on wejście z konsoli (lub z klawiatury) w sposób pokazany w programie na listingu 3.1. Zamiast obliczać pole tylko jednego prostokąta, program może obliczyć pole dowol- nego prostokąta. Wartości zapisywane w zmiennych length i width wprowadzane są przez użytkownika w trakcie pracy programu. Spójrz na wiersze 13. – 14.: cout Jaka jest długość prostokąta? ; cin length; Listing 3.1 1 // Program prosi użytkownika o wpisanie długości i szerokości 2 // prostokąta. Oblicza jego pole i wyświetla 3 // obliczoną wartość na ekranie. 4 #include iostream 5 using namespace std; 6 7 int main() 8 { 9 int length, width, area; 10 11 cout Ten program oblicza pole ; 12 cout prostokąta.\n ; 13 cout Jaka jest długość prostokąta? ; 14 cin length; 15 cout Jaka jest szerokość prostokąta? ; 16 cin width; 17 area = length * width; 18 cout Pole prostokąta wynosi area .\n ; 19 return 0; 20 } Wyjście programu (wprowadzone dane są wyróżnione pogrubioną czcionką) Ten program oblicza pole prostokąta. Jaka jest długość prostokąta? 10 [Enter] Jaka jest szerokość prostokąta? 20 [Enter] Pole prostokąta wynosi 200. W wierszu 13. wyrażenie cout zostało wykorzystane do wyświetlenia pytania Jaka jest długość prostokąta? . To pytanie nazywamy zachętą. Wskazuje ono użytkownikowi, jakie dane powinny zostać wprowadzone. Program zawsze powinien wyświetlić zachętę, zanim użyje obiektu cin. W ten sposób użytkownik będzie wiedział, że musi wpisać wartość za pomocą klawiatury. W wierszu 14. wykorzystano cin do odczytania wartości z klawiatury. Symbol nazywamy operatorem ekstrakcji strumienia. Pobiera on znaki z obiektu strumienia, który znajduje się po lewej, i zapisuje je w zmiennej, po prawej stronie operatora. W tym wierszu wartość zostaje pobrana z obiektu cin (a ten pobiera ją z klawiatury) i zapisana w zmiennej length. Poleć książkęKup książkę 3.1. Obiekt cin 117 Pobieranie wejścia od użytkownika to zazwyczaj proces dwuetapowy: 1. Wyświetlenie zachęty za pomocą cout. 2. Pobranie wejścia z klawiatury za pomocą cin. Zachęta powinna być pytaniem do użytkownika albo wskazaniem, jaką wartość powi- nien wpisać. Na przykład kod z listingu 3.1 wyświetla następującą zachętę: Jaka jest długość prostokąta? Użytkownik, widząc takie pytanie, wie, że musi wprowadzić długość prostokąta. Po wyświetleniu zachęty program wykorzystuje obiekt cin do pobrania wartości z kla- wiatury i zapisania jej w zmiennej length. Zauważ, że operatory i wskazują na kierunek, w którym przepływają dane. W wyra- żeniu korzystającym z cout operator zawsze wskazuje na cout. Wskazuje więc, że dane przepływają ze zmiennej do obiektu. W wyrażeniu korzystającym z cin operator zawsze wskazuje zmienną, która otrzymuje wartość, zatem przepływ danych odbywa się od obiektu cin do zmiennej. Zostało to przedstawione na rysunku 3.1. Rysunek 3.1. Operatory i Obiekt cin powoduje wstrzymanie programu do czasu wpisania danych i naciśnięcia klawisza Enter. Program nie przejdzie do wykonywania kolejnych wierszy, dopóki cin nie otrzyma danych. Obiekt cin automatycznie konwertuje dane odczytane z klawiatury na typ odpowia- dający zmiennej wskazanej w wyrażeniu. Jeżeli użytkownik wpisze 10, cin odczyta to jako znaki 1 i 0 . Jest to na tyle sprytny obiekt, że sam zamieni wpisane znaki na typ int, zanim zapisze je w zmiennej. Jest on również na tyle sprytny, że nie zapisze wartości 10.7 w zmiennej typu int. Jeśli użytkownik wprowadzi liczbę zmiennoprze- cinkową w wyrażeniu wpisującym wejście użytkownika w zmiennej int, cin pomi- nie część ułamkową. UWAGA. W każdym programie, który korzysta z cin, trzeba załączyć plik nagłów- kowy iostream . Poleć książkęKup książkę 118 Rozdział 3. Wyrażenia i interaktywność Wprowadzanie wielu wartości Obiekt cin możemy wykorzystać do zebrania kilku wartości jednocześnie. Przyjrzyjmy się listingowi 3.2, na którym znajduje się nieco zmodyfikowany program z listingu 3.1. Listing 3.2 1 // Program prosi użytkownika o wpisanie długości i szerokości 2 // prostokąta. Oblicza jego pole i wyświetla 3 // obliczoną wartość na ekranie. 4 #include iostream 5 using namespace std; 6 7 int main() 8 { 9 int length, width, area; 10 11 cout Ten program oblicza pole ; 12 cout prostokąta.\n ; 13 cout Wprowadź długość i szerokość prostokąta, ; 14 cout rozdzielając je spacją.\n ; 15 cin length width; 16 area = length * width; 17 cout Pole prostokąta wynosi area . endl; 18 return 0; 19 } Wyjście programu (wprowadzone dane są wyróżnione pogrubioną czcionką) Ten program oblicza pole prostokąta. Wprowadź długość i szerokość prostokąta, rozdzielając je spacją. 10 20 [Enter] Pole prostokąta wynosi 200. W wierszu 15. program oczekuje na wpisanie przez użytkownika dwóch wartości. Pierwsza z nich zostanie zapisana w zmiennej length, a druga w width. cin length width; W przykładowym wyjściu użytkownik wprowadził wartości 10 i 20, więc program wpisał 10 w zmiennej length i 20 w width. Zwróć uwagę, że wprowadzone wartości są rozdzielone spacjami. W ten sposób cin może rozróżnić początek i koniec każdej z liczb. Liczba spacji nie ma znaczenia. Użyt- kownik mógłby wpisać przykładowo: 10 20 UWAGA. Klawisz Enter należy nacisnąć po wprowadzeniu ostatniej wartości. Obiekt cin jest w stanie odczytać również kilka wartości różnych typów, jak na listingu 3.3. Listing 3.3 1 // Program przedstawia, jak cin może odczytać wiele wartości 2 // danych różnego typu. 3 #include iostream Poleć książkęKup książkę 3.1. Obiekt cin 119 4 using namespace std; 5 6 int main() 7 { 8 int whole; 9 double fractional; 10 char letter; 11 12 cout Wpisz liczbę całkowitą, liczbę z ułamkiem i literę: ; 13 cin whole fractional letter; 14 cout Liczba całkowita: whole endl; 15 cout Liczba z ułamkiem: fractional endl; 16 cout Litera: letter endl; 17 return 0; 18 } Wyjście programu (wprowadzone dane są wyróżnione pogrubioną czcionką) Wpisz liczbę całkowitą, liczbę z ułamkiem i literę: 4 5.7 b [Enter] Liczba całkowita: 4 Liczba z ułamkiem: 5.7 Litera: b Na powyższym przykładzie możemy zobaczyć, że wartości zostają przypisane do odpo- wiednich zmiennych. Co by się jednak stało, gdyby użytkownik odpowiedział w następu- jący sposób? Wpisz liczbę całkowitą, liczbę z ułamkiem i literę: 5.7 4 b [Enter] Wartości wpisane przez użytkownika trafiłyby najpierw do lokalizacji w pamięci nazy- wanej buforem klawiatury. Zatem wartości 5.7, 4 i b przechowywane są w buforze klawiatury tak, jak zilustrowano to na rysunku 3.2. Rysunek 3.2. Bufor klawiatury Gdy użytkownik naciśnie Enter, cin zapisze wartość 5 w zmiennej whole. Nie odczyta kropki dziesiętnej, ponieważ zmienna jest typu int. Następnie odczyta wartość .7 i zapisze ją w zmiennej fractional. Spacja zostaje pominięta, natomiast liczba 4, jako kolejna odczytana wartość, zostaje wpisana jako znak do zmiennej letter. Ponieważ wyrażenie cin odczytuje tylko trzy wartości, wartość b pozostanie w buforze nieod- czytana. Dlatego niezwykle ważne jest wprowadzenie wartości w odpowiedniej kolejności. Punkt kontrolny 3.1. Jaki plik nagłówkowy należy załączyć w programach korzystających z cin? Poleć książkęKup książkę 120 Rozdział 3. Wyrażenia i interaktywność 3.2. Prawda czy fałsz? Po wprowadzeniu danych za pomocą cin użytkownik musi nacisnąć Enter. 3.3. Przyjmij, że zmienna wartosc jest typu int. Co zostanie zapisane w zmiennej, jeżeli użytkownik wpisze 3.14 w poniższym wyrażeniu? cin wartosc; A) 3.14 B) 3 C) 0 D) Nic. Pojawi się komunikat błędu 3.4. W programie znajdują się następujące definicje zmiennych: long mile; int stopy; float cale; Napisz wyrażenie cin, które wpisuje wartości do każdej z tych zmiennych. 3.5. Poniższy program uruchomi się, jednak użytkownik będzie miał problem ze zrozumieniem, co ma zrobić. Jak można go poprawić? // Ten program mnoży dwie liczby i wyświetla wynik. #include iostream using namespace std; int main() { double first, second, product; cin first second; product = first * second; cout product; return 0; } 3.6. Uzupełnij poniższy szkielet programu tak, aby prosił on o wprowadzenie wagi użytkownika w kilogramach i wyświetlał wartość przeliczoną na funty. #include iostream using namespace std; int main() { double pounds, kilograms; // Napisz kod, który prosi użytkownika o wpisanie swojej wagi i zapisuje wejście // w zmiennej kilograms. // Poniższy wiersz odpowiada za konwersję jednostek. pounds = kilograms * 2.2; // Napisz wyrażenie, które wyświetli wagę użytkownika w funtach. return 0; } Poleć książkęKup książkę 3.2. Wyrażenia matematyczne 3.2. Wyrażenia matematyczne 3.2. Wyrażenia matematyczne 121 WYJAŚNIENIE: C++ pozwala na tworzenie złożonych wyrażeń matematycz- nych poprzez użycie wielu operatorów i grupowanie symboli. W rozdziale 2. poznałeś podstawowe operatory matematyczne stosowane do budo- wania wyrażeń. Wyrażenie to instrukcja programu, która zwraca wartość. Wyraże- nie zazwyczaj składa się z operatora i argumentów. Spójrz na poniższą instrukcję: suma = 21 + 3; Ponieważ 21 + 3 zwraca wartość, możemy nazwać je wyrażeniem. Jego wartość, czyli 24, zostanie zapisana w zmiennej suma. Wyrażenia nie muszą być działaniami mate- matycznymi. W poniższej instrukcji liczba 3 jest wyrażeniem: liczba = 3; Poniżej umieszczono przykłady instrukcji programistycznych, w których do zmiennej wynik przypisywane są wartości wyrażeń. wynik = x; wynik = 4; wynik = 15 / 3; wynik = 22 * liczba; wynik = sizeof(int); wynik = a + b + c; W każdym z tych wyrażeń po prawej stronie operatora = pojawia się liczba, zmienna lub wyrażenie matematyczne. Zwracana przez nie wartość zapisywana jest w zmiennej. Wszystkie powyższe przykłady pokazują wpisywanie do zmiennej wartości wyrażenia. Na listingu 3.4 przedstawiono możliwości wykorzystania wyrażeń matematycznych z obiektem cout. Listing 3.4 1 // Program prosi użytkownika o wpisanie 2 // licznika i mianownika ułamka, 3 // a następnie wyświetla wartość dziesiętną. 4 5 #include iostream 6 using namespace std; 7 8 int main() 9 { 10 double numerator, denominator; 11 12 cout Ten program pokazuje wartość dziesiętną ; 13 cout ułamka.\n ; 14 cout Wpisz licznik: ; 15 cin numerator; 16 cout Wpisz mianownik: ; 17 cin denominator; 18 cout Wartość dziesiętna wynosi ; 19 cout (numerator / denominator) . endl; Poleć książkęKup książkę 122 Rozdział 3. Wyrażenia i interaktywność 20 return 0; 21 } Wyjście programu (wprowadzone dane są wyróżnione pogrubioną czcionką) Ten program pokazuje wartość dziesiętną ułamka. Wpisz licznik: 3 [Enter] Wpisz mianownik: 16 [Enter] Wartość dziesiętna wynosi 0.1875. Obiekt cout wyświetli każdą poprawną wartość wyrażenia w C++. Program z lis- tingu 3.4 wyświetla wartość wyrażenia numerator / denominator. UWAGA. W przykładzie z listingu 3.4 użytkownik wpisuje 3 i 16. Ponieważ wartości te przypisywane są do zmiennych double, będą przechowywane jako 3.0 i 16.0. UWAGA. Jeśli wysyła się wyrażenie zawierające operator do obiektu cout, dobrym pomysłem jest umieszczenie go w nawiasie. W przeciwnym razie kilka bardziej zaawansowanych operatorów może zwrócić nieoczekiwane wyniki. Kolejność działań Możemy tworzyć wyrażenia matematyczne zawierające kilka operatorów. W poniż- szym przykładzie w zmiennej odpowiedz zapisywana jest suma 17, x, 12 i y. odpowiedz = 17 + x + 12 + y; Niektóre wyrażenia nie są jednak tak oczywiste. Rozważ poniższe wyrażenie: wynik = 12 + 6 / 3; Jaka wartość zostanie zapisana w zmiennej wynik? Liczba 6 jest argumentem i ope- ratora dodawania, i dzielenia. Wynikiem może być zarówno 6, jak i 14, w zależności od kolejności umiejscowienia operatorów. Tak naprawdę wynikiem tego działania będzie 14, ponieważ dzielenie ma pierwszeństwo przed dodawaniem. Wyrażenia matematyczne są sprawdzane od lewej do prawej. Jeżeli argument jest współdzielony przez dwa operatory, pierwszy operację wykona operator o wyższym pierw- szeństwie. Mnożenie i dzielenie mają pierwszeństwo przed dodawaniem i odejmowa- niem, zatem powyższy przykład wykona się w następującej kolejności: 1. 6 zostaje podzielone przez 3, co zwraca wynik 2. 2. 12 zostaje dodane do 2, co zwraca wynik 14. Możemy ten przykład zilustrować za pomocą diagramu: wynik = 12 + 6 / 3 \ / wynik = 12 + 2 wynik = 14 Kolejność działań została przedstawiona w tabeli 3.1. Operatory na szczycie tabeli mają pierwszeństwo przed operatorami niżej. Poleć książkęKup książkę Tabela 3.1. Priorytet operatorów arytmetycznych (od najwyższego do najniższego) 3.2. Wyrażenia matematyczne 123 (negacja jednoargumentowa) - * / + - Mnożenie, dzielenie oraz modulo mają taki sam priorytet, podobnie jak operatory dodawania i odejmowania. W tabeli 3.2 przedstawiono kilka wyrażeń z wynikami. Tabela 3.2. Proste wyrażenia i ich wartości Wyrażenie Wartość 5 + 2 * 4 10 / 2 - 3 8 + 12 * 2 - 4 4 + 17 2 - 1 6 - 3 * 2 + 7 - 1 13 2 28 4 6 Łączność Łączność operatora występuje albo od lewej do prawej, albo od prawej do lewej. Jeżeli dwa operatory w wyrażeniu mają taki sam priorytet, będą działały na podstawie swojej łączności. Łączność operatorów arytmetycznych została przedstawiona w tabeli 3.3. W celu lepszego zrozumienia spójrz na poniższy przykład: 5 - 3 + 2 Operatory - i + mają takie samo pierwszeństwo oraz łączność od lewej do prawej. Powyższe wyrażenie możemy zapisać jako: ((5 - 3) + 2) Kolejny przykład: 12 / 6 * 4 Ponieważ operatory / i * mają taki sam priorytet i łączność od lewej do prawej, powyższe wyrażenie możemy zapisać jako: ((12 / 6) * 4) Tabela 3.3. Łączność operatorów arytmetycznych Łączność Operator (negacja jednoargumentowa) - Od prawej do lewej Od lewej do prawej * / Od lewej do prawej + - Poleć książkęKup książkę 124 Rozdział 3. Wyrażenia i interaktywność Grupowanie za pomocą nawiasów Części wyrażeń matematycznych mogą zostać pogrupowane za pomocą nawiasów, aby wymusić wykonanie jednych operacji przed drugimi. W poniższym wyrażeniu suma a + b zostaje podzielona przez 4. wynik = (a + b) / 4; Bez nawiasów najpierw b zostałoby podzielone przez 4, a wynik dodany do a. Więcej wyrażeń i wartości znajduje się w tabeli 3.4. Tabela 3.4. Więcej prostych wyrażeń i ich wartości Wyrażenie Wartość (5 + 2) * 4 10 / (5 - 3) 8 + 12 * (6 – 2) (4 + 17) 2 - 1 (6 - 3) * (2 + 7) / 3 28 5 56 0 9 Zamiana wyrażeń algebraicznych na instrukcje programu W algebrze nie zawsze używamy operatora mnożenia. Jednak C++ wymaga operato- rów dla każdej operacji matematycznej. Tabela 3.5 zawiera wyrażenia algebraiczne wykonujące mnożenie oraz ich odpowiedniki w wyrażeniach C++. Tabela 3.5. Algebraiczne wyrażenia mnożenia oraz ich zapis w C++ Wyrażenie algebraiczne Działanie 6B (3)(12) 4xy 6 razy B 3 razy 12 4 razy x razy y Wyrażenie w C++ 6 * B 3 * 12 4 * x * y Zamieniając wyrażenia algebraiczne na wyrażenia C++, będziesz musiał czasami wsta- wiać nawiasy, których nie ma w oryginalnym wyrażeniu. Przeanalizujmy poniższy przykład: x ba  c Zamieniając go na instrukcję C++, będziesz musiał umieścić wyrażenie a + b w nawiasie: x = (a + b) / c; Więcej wyrażeń algebraicznych i ich równoważników w języku C++ znajdziesz w tabeli 3.6. Poleć książkęKup książkę 3.2. Wyrażenia matematyczne 125 Tabela 3.6. Wyrażenia algebraiczne i ich odpowiedniki w C++ Wyrażenie algebraiczne Wyrażenie w C++ y  3 x 2 z = 3bc + 4 a  x 3 a 4   2 1 y = x / 2 * 3 z = 3 * b * c + 4 a = (3 * x + 2) / (4 * a - 1) Proszę, żadnych wykładników! W przeciwieństwie do wielu języków programowania C++ nie ma operatora wykładnika. Potęgowanie wymaga zastosowania funkcji bibliotecznej. Biblioteka C++ to nie miejsce, w którym wypożyczasz książki, ale zbiór wyspecjalizowanych funkcji. Pomyśl o funkcji bibliotecznej jako o procedurze wykonującej określone operacje. Jedna z takich funkcji nazywa się pow() i służy do potęgowania liczb. Oto przykład jej zastosowania: pole = pow(4.0, 2.0); Powyższa instrukcja zawiera wywołanie funkcji pow(). Liczby w nawiasie to argumenty, czyli dane wysyłane do funkcji. Funkcja pow() zawsze podnosi pierwszy argument do potęgi wyrażonej przez drugi argument. W tym przypadku 4 jest podniesione do potęgi 2. Funkcja ta zwraca wynik, który można wykorzystać w instrukcji, w której została użyta. W tym przypadku zwróci ona 16, a wynik zostanie wpisany do zmiennej pole. Działanie omówionej instrukcji zilustrowano na rysunku 3.3. Rysunek 3.3. Funkcja pow() Wyrażenie pole = pow(4.0, 2.0) jest równoważne z poniższym wyrażeniem alge- braicznym: pole = 42 Oto kolejny przykład wyrażenia wykorzystującego funkcję pow(). Przypisuje wartość działania 3 razy 63 do zmiennej x: x = 3 * pow(6.0, 3.0); Natomiast poniższe wyrażenie wyświetla wartość 5 podniesioną do potęgi 4: cout pow(5.0, 4.0); Pomocne może być rozpatrywanie funkcji pow() jako „czarnej skrzynki”, do której wkłada się dwie liczby, a następnie wyjmuje się z niej wynik, którym jest wartość pierwszej liczby podniesionej do potęgi określonej przez drugą liczbę. Zostało to przedstawione na rysunku 3.4. Poleć książkęKup książkę 126 Rozdział 3. Wyrażenia i interaktywność Rysunek 3.4. Funkcja pow() jako „czarna skrzynka” Korzystając z funkcji pow(), powinieneś przestrzegać kilku wytycznych. Po pierwsze, należy dołączyć plik nagłówkowy cmath . Po drugie, argumenty przekazywane do funkcji powinny być typu double. Po trzecie, zmienna przechowująca wynik zwró- cony przez funkcję również powinna być typu double. Przykładowo, w poniższym wyrażeniu zmienna pole powinna być typu double: pole = pow(4.0, 2.0); Program z listingu 3.5 rozwiązuje prosty problem algebraiczny. Prosi użytkownika o wprowadzenie promienia koła, a następnie oblicza jego pole. Wzór jest taki: P = r2 co zapisujemy w programie jako: area = PI * pow(radius, 2.0); Listing 3.5 1 // Program oblicza pole koła. 2 // Wzór na pole koła to pi razy 3 // promień do kwadratu. Pi wynosi 3,14159. 4 #include iostream 5 #include cmath // Potrzebne do zastosowania funkcji pow() 6 using namespace std; 7 8 int main() 9 { 10 const double PI = 3.14159; 11 double area, radius; 12 13 cout Ten program oblicza pole koła.\n ; 14 cout Ile wynosi promień koła? ; 15 cin radius; 16 area = PI * pow(radius, 2.0); 17 cout Pole wynosi area . endl; 18 return 0; 19 } Wyjście programu (wprowadzone dane są wyróżnione pogrubioną czcionką) Ten program oblicza pole koła. Ile wynosi promień koła? 10 [Enter] Pole wynosi 314.159. UWAGA. Program z listingu 3.5 wykorzystuje funkcję pow() tylko w ramach demon- stracji. Nie ma jednak powodu stosowania jej w tak prostych obliczeniach. Wyra- żenie algebraiczne obliczające pole możemy zapisać jako: area = PI * radius * radius; Funkcja pow() jest jednak bardzo przydatna w wyrażeniach stosujących większe wykładniki. Poleć książkęKup książkę 3.2. Wyrażenia matematyczne 127 W centrum uwagi Obliczanie średniej Obliczanie wartości średniej grupy liczb to bardzo proste działanie: dzielimy sumę wartości przez ich liczbę. Chociaż to proste, łatwo pomylić się podczas pisania pro- gramu obliczającego średnią. Załóżmy na przykład, że zmienne a, b i c są typu double. Każda z nich przechowuje jakąś wartość. Chcielibyśmy obliczyć średnią z tych wartości. Z powodu niedbalstwa moglibyśmy zapisać wyrażenie w następujący sposób: average = a + b + c / 3.0; Zauważyłeś już błąd? Jako pierwsze wykona się dzielenie. Wartość c zostanie podzie- lona przez 3.0. Następnie wynik zostanie dodany do a i b. Nie jest to prawidłowy sposób obliczania średniej. W celu poprawnego obliczenia średniej należy umieścić sumę w nawiasie: average = (a + b + c) / 3.0; Prześledźmy proces pisania programu obliczającego średnią. Załóżmy, że zdałeś trzy testy na lekcjach informatyki i chciałbyś napisać program, który obliczy średnią ocen z tych testów. Oto algorytm w pseudokodzie: Pobierz pierwszą ocenę. Pobierz drugą ocenę. Pobierz trzecią ocenę. Oblicz średnią, sumując oceny i dzieląc je przez trzy. Wyświetl średnią. W pierwszych trzech krokach każemy użytkownikowi wpisać trzy oceny z testów. Załóżmy, że zmienne do ich przechowywania nazwiemy test1, test2 i test3. Następnie, w czwartym kroku, obliczamy średnią ocen za pomocą poniższego wyrażenia. Wynik zapisujemy w zmiennej typu double o nazwie average. average = (a + b + c) / 3.0; Ostatni krok to wyświetlenie średniej. Całość programu znajduje się na listingu 3.6. Listing 3.6 1 // Program oblicza średnią 2 // trzech ocen z testów. 3 #include iostream 4 #include cmath 5 using namespace std; 6 7 int main() 8 { 9 double test1, test2, test3; // Przechowywanie ocen 10 double average; // Przechowywanie średniej 11 12 // Pobranie trzech ocen 13 cout Wpisz pierwszą ocenę: ; 14 cin test1; 15 cout Wpisz drugą ocenę: ; 16 cin test2; 17 cout Wpisz trzecią ocenę: ; Poleć książkęKup książkę 128 Rozdział 3. Wyrażenia i interaktywność 18 cin test3; 19 20 // Obliczenie średniej ocen 21 average = (test1 + test2 + test3) / 3.0; 22 23 // Wyświetlenie średniej 24 cout Średnia ocen: average endl; 25 return 0; 26 } Wyjście programu (wprowadzone dane są wyróżnione pogrubioną czcionką) Wpisz pierwszą ocenę: 4 [Enter] Wpisz drugą ocenę: 5 [Enter] Wpisz trzecią ocenę: 3 [Enter] Średnia ocen: 4 Punkt kontrolny 3.7. Uzupełnij poniższą tabelę, określając wartości każdego z wyrażeń. Wartość Wyrażenie 6 + 3 * 5 12 / 2 - 4 9 + 14 * 2 - 6 5 + 19 3 - 1 (6 + 2) * 3 14 / (11 - 4) 9 + 12 * (8 - 3) (6 + 17) 2 - 1 (9 - 3) * (6 + 9) / 3 3.8. Napisz wyrażenia w C++ odpowiadające poniższym wyrażeniom algebraicznym: y = 6x a = 2b + 4c y = x2 x  g z 2 x z y  2 2 2 3.9. Przeanalizuj poniższy program i uzupełnij tabelę. #include iostream #include cmath using namespace std; Poleć książkęKup książkę 3.3. Gdy pomylisz jabłka z pomarańczami: konwersja typów 129 int main() { double value1, value2, value3; cout Wpisz liczbę: ; cin value1; value2 = 2 * pow(value1, 2.0); value3 = 3 + value2 / 2 − 1; cout value3 endl; return 0; } Jeśli użytkownik wpisze… program wyświetli (wartość zmiennej value3)… 2 5 4.3 6 3.10. Uzupełnij szkielet programu, aby wyświetlał objętość zbiornika paliwa w kształcie walca. Oto wzór na objętość: V = r2h gdzie: π wynosi 3,14159, r to promień zbiornika, h to wysokość zbiornika. #include iostream #include cmath using namespace std; int main() { double volume, radius, height; cout Ten program oblicza objętość\n ; cout zbiornika paliwa w kształcie walca.\n ; cout Jaka jest wysokość zbiornika? ; cin height; cout Ile wynosi promień zbiornika? ; cin radius; // Dokończ program. } 3.3. Gdy pomylisz jabłka z pomarańczami: konwersja typów 3.3. Gdy pomylisz jabłka z pomarańczami: konwersja typów WYJAŚNIENIE: Jeżeli argumenty operatora są różnych typów, C++ automa- tycznie zmieni je na ten sam typ. Może to wpłynąć na wynik wyrażeń matematycznych. Poleć książkęKup książkę 130 Rozdział 3. Wyrażenia i interaktywność Jakiego typu będzie wynik, jeżeli wartość typu int pomnożymy przez wartość typu float? Co się stanie, jeżeli wartość typu double pomnożymy przez unsigned int? Czy jest jakikolwiek sposób, aby przewidzieć, co się stanie w powyższych sytuacjach? Odpowiedź brzmi: tak. C++ posiada zestaw reguł, którymi kieruje się przy wykony- waniu operacji matematycznych na zmiennych o różnych typach. Wszystkie typy danych mają swoje rangi, tak jak żołnierze w armii. Typ danych, który może pomieścić większą ilość danych, stoi wyżej w hierarchii. Typ float ma wyższą rangę niż int. Tabela 3.7 zawiera typy danych uszeregowane od najwyższej rangi do najniższej. Tabela 3.7. Typy danych według rang long double double float unsigned long long int long long int unsigned long int long int unsigned int int Jedynym wyjątkiem od rankingu z tabeli 3.7 jest sytuacja, gdy int i long są tego samego rozmiaru. W tym przypadku unsigned int ma wyższą rangę niż long, ponieważ może przechowywać wyższą wartość. Gdy C++ korzysta z operatorów, dąży do sprowadzenia argumentów do tego samego typu. Ten typ automatycznej konwersji znany jest jako koercja typów. Konwersję wartości na typ stojący wyżej w rankingu nazywamy promocją. Konwersję na typ danych będący niżej w rankingu nazywamy degradacją. Przyjrzyjmy się teraz zasadom ewaluacji wyrażeń matematycznych. Zasada 1. Typy char, short, unsigned short są automatycznie promowane do int. Zwróć uwagę, że w tabeli 3.7 nie ma typów char, short, unsigned short. Jest tak, ponieważ promowane są do int automatycznie za każdym razem, gdy używa się ich w wyrażeniach matematycznych. Jedynym wyjątkiem jest sytuacja, gdy unsigned short przechowuje wartość większą niż int. Może się to zdarzyć w systemach, w któ- rych typ short jest tego samego rozmiaru co int. W takim przypadku unsigned short jest promowany do unsigned int. Zasada 2. Gdy operator działa na argumentach dwóch różnych typów danych, typ o niższej randze jest promowany do typu o wyższej randze. Załóżmy, że w poniższym wyrażeniu zmienna lata jest typu int, a zmienna stopaOpro centowania jest typu float: lata * stopaOprocentowania Poleć książkęKup książkę 3.3. Gdy pomylisz jabłka z pomarańczami: konwersja typów 131 Przed wykonaniem mnożenia zmienna lata zostanie wypromowana do float. Zasada 3. Jeżeli wartość wyrażenia przypisywana jest do zmiennej, jej typ zostanie zmieniony na typ tej zmiennej. Przyjmijmy, że w poniższym wyrażeniu zmienna pole jest typu long, a zmienne dlugosc i szerokosc są typu int. pole = dlugosc * szerokosc; Ponieważ dlugosc i szerokosc są typu int, nie zostaną zamienione na inny typ danych. Natomiast wynik mnożenia zostanie zamieniony na long, aby można było zapisać go w zmiennej. Uważaj na sytuacje, w których wynik będący liczbą z ułamkiem miałby zostać zapi- sany w zmiennej typu int. Oto przykład: int x, y = 4; float z = 2.7; x = y * z; W wyrażeniu y * z, zmienna y zostanie zamieniona na typ float. Wynikiem mno- żenia będzie 10.8. Jednak ponieważ zmienna x jest typu int, zostanie w niej zapisana wartość 10. Dzielenie liczb całkowitych Wynikiem dzielenia liczby całkowitej przez liczbę całkowitą będzie zawsze liczba cał- kowita. Reszta zostanie odrzucona. Na przykład w poniższym kodzie do zmiennej czesci zostanie wpisana wartość 2.0. double czesci; czesci = 15 / 6; Chociaż 15 / 6 to 2.5, ułamek zostanie odrzucony, ponieważ dzielimy liczbę całkowitą przez liczbę całkowitą. Deklaracja zmiennej jako double nie ma w tym przypadku żad- nego znaczenia, ponieważ ułamek jest odrzucany jeszcze przed przypisaniem do niej wartości. Żeby działanie zwróciło liczbę zmiennoprzecinkową, co najmniej jeden argu- ment musi być liczbą zmiennoprzecinkową. Poprzedni przykład moglibyśmy napisać w taki sposób: double czesci; czesci = 15.0 / 6; W tym przykładzie wartość literału 15.0 jest traktowana jako liczba zmiennoprzecinkowa. Dlatego do zmiennej zostanie przypisana liczba 2.5. Poleć książkęKup książkę 132 Rozdział 3. Wyrażenia i interaktywność 3.4. Przepełnienie i zaniżenie 3.4. Przepełnienie i zaniżenie WYJAŚNIENIE: Jeżeli wartość przypisana do zmiennej jest poniżej lub powyżej jej pojemności, mamy do czynienia z przepełnieniem lub zani- żeniem. Jeżeli do zmiennej próbujemy przypisać wartość wykraczającą poza jej zakres, możemy napotkać problemy. Spójrz na to przykładowe wyrażenie, w którym zmienne a, b i c są typu short int: a = b * c; Jeżeli wartości b i c są dostatecznie duże, wynik mnożenia może okazać się zbyt duży, aby mógł być wpisany do a. Aby uniknąć błędów, zmienna a powinna zostać zdekla- rowana jako int albo longint. Gdy do zmiennej przypiszemy liczbę przekraczającą zakres jej typu, spowodujemy przepełnienie. Analogicznie wpisanie liczby zbyt małej, leżącej poza zakresem zmiennej, spowoduje zaniżenie (wyjście listingu 3.7 przedstawia wyniki z systemu, w którym typ short zajmuje 2 bajty). Listing 3.7 1 // Program pokazuje przepełnienie i zaniżenie w zmiennej typu short. 2 #include iostream 3 using namespace std; 4 5 int main() 6 { 7 // testVar zostaje zainicjowana maksymalną wartością dla typu short. 8 short testVar = 32767; 9 10 // Wyświetlenie testVar 11 cout testVar endl; 12 13 // Dodanie 1 do testVar, aby spowodować przepełnienie 14 testVar = testVar + 1; 15 cout testVar endl; 16 17 // Odjęcie 1 od testVar, aby spowodować zaniżenie 18 testVar = testVar - 1; 19 cout testVar endl; 20 return 0; 21 } Wyjście programu 32767 −32768 32767 Zazwyczaj przepełnienie zmiennej typu całkowitego powoduje przejście do najniższej wartości danego typu. Na listingu 3.7 testVar przechodzi z 32 767 do –32 768 po dodaniu 1. Po odjęciu 1 od testVar w kolejnym kroku nastąpiło zaniżenie i jej wartość Poleć książkęKup książkę 3.5. Rzutowanie typów 133 wróciła z powrotem do 32 767. Nie zostanie zwrócony żaden komunikat, więc zachowaj ostrożność, pracując z liczbami bliskimi maksymalnych i minimalnych zakresów zmien- nych. Przepełnienia i zaniżenia powodują, że wartości zwracane przez program będą niepoprawne. Wyniki przepełnień i zaniżeń liczb zmiennoprzecinkowych zależą od konfiguracji kompi- latora. W zależności od systemu program może zachować się w jeden z następujących sposobów:  Zwróci zły wynik i będzie działał dalej.  Wyświetli komunikat błędu i przestanie działać w momencie przepełnienia lub zaniżenia wartości zmiennej typu zmiennoprzecinkowego.  Wyświetli komunikat błędu i przestanie działać w przypadku przepełnienia, jednak w przypadku zaniżenia wartości do zmiennej zostanie przypisane 0.  Da Ci możliwość wyboru różnych zachowań w przypadku przepełnienia lub zaniżenia. Zachowanie swojego systemu sprawdzisz, kompilując kod z listingu 3.8. Listing 3.8 1 // Ten program możemy wykorzystać, aby sprawdzić zachowanie systemu 2 // w przypadku przepełnienia lub zaniżenia zmiennej typu zmiennoprzecinkowego. 3 #include iostream 4 using namespace std; 5 6 int main() 7 { 8 float test; 9 10 test = 2.0e38 * 1000; // Test przepełnienia 11 cout test endl; 12 test = 2.0e-38 / 2.0e38; // Test zaniżenia 13 cout test endl; 14 return 0; 15 } 3.5. Rzutowanie typów 3.5. Rzutowanie typów WYJAŚNIENIE: Rzutowanie typów pozwala na ręczną konwersję danych. Rzutowanie typów umożliwia ręczne promowanie lub degradowanie wartości. Wyra- żenie rzutujące wygląda tak: static_cast TypDanych (Wartość) Wartość to zmienna lub literał, który chcesz rzutować, a TypDanych to typ, na który zmieniona ma zostać wartość. Spójrz na poniższy przykład wykorzystujący rzutowa- nie typów: Poleć książkęKup książkę 134 Rozdział 3. Wyrażenia i interaktywność double number = 3.7; int val; val = static_cast int (number); Kod definiuje dwie zmienne: number typu double i val typu int. Wyrażenie rzutujące w trzecim wierszu zwraca kopię wartości zapisanej w number, zmienioną na int. Kon- wersja double na int polega na przycięciu części ułamkowej. Dlatego ta instrukcja przypisze wartość 3 do zmiennej val, zaś wartość zmiennej number nie zostanie zmo- dyfikowana. Rzutowanie typów przydaje się w sytuacjach, w których C++ nie wykona popraw- nej konwersji automatycznie. Na listingu 3.9 pokazano sytuację, w której rzutowanie typu zostało użyte, aby zapobiec dzieleniu liczb całkowitych. Wyrażenie korzystające z rzutowania typów to: perMonth = static_cast double (books) / months; Listing 3.9 1 // Ten program stosuje rzutowanie typów, aby zapobiec dzieleniu liczb całkowitych. 2 #include iostream 3 using namespace std; 4 5 int main() 6 { 7 int books; // Liczba książek do przeczytania 8 int months; // Liczba miesięcy spędzonych na czytaniu 9 double perMonth; // Średnia liczba książek na miesiąc 10 11 cout Ile książek planujesz przeczytać? ; 12 cin books; 13 cout Ile miesięcy zajmie Ci ich przeczytanie? ; 14 cin months; 15 perMonth = static_cast double (books) / months; 16 cout To jest perMonth książki na miesiąc.\n ; 17 return 0; 18 } Wyjście programu (wprowadzone dane są wyróżnione pogrubioną czcionką) Ile książek planujesz przeczytać? 30 [Enter] Ile miesięcy zajmie Ci ich przeczytanie? 7 [Enter] To jest 4.28571 książki na miesiąc. Zmienna books jest typu int, lecz jej wartość jest rzutowana na double przed podziele- niem. Bez rzutowania typów w wierszu 15. miałoby miejsce dzielenie liczb całkowitych, co dałoby zły wynik. Listing 3.10 przedstawia inne zastosowanie rzutowania typów. Listing 3.10 1 // Ten program wykorzystuje wyrażenie rzutowania typu, aby wyświetlić 2 // znak na podstawie liczby. 3 #include iostream 4 using namespace std; 5 Poleć książkęKup książkę 3.5. Rzutowanie typów 135 6 int main() 7 { 8 int number = 65; 9 10 // Wyświetlenie wartości zmiennej number 11 cout number endl; 12 13 // Wyświetlenie wartości zmiennej number zamienionej 14 // na typ char 15 cout static_cast char (number) endl; 16 return 0; 17 } Wyjście programu 65 A OSTRZEŻENIE! Jeżeli w kodzie z listingu 3.9 zastosowalibyśmy następującą instruk- cję, miałoby miejsce również dzielenie liczb całkowitych: perMonth = static_cast double (books / months); Wynikiem dzielenia zmiennej books przez months jest 4. Po konwersji 4 na double będzie to 4.0. Aby zapobiec dzieleniu liczb całkowitych, jedna z wartoś
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Język C++. Owoce programowania. Wydanie IX
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ą: