C#. Ćwiczenia

1. IDZ DO PRZYK£ADOWY ROZDZIA£ SPIS TRE CI C#. Æwiczenia KATALOG KSI¥¯EK Autor: Marcin Lis ISBN: 83-7361-128-2 Format: B5, stron: 166 KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK DODAJ DO KOSZYKA Jêzyk C# zosta³ opracowany w firmie Microsoft i wywodzi siê z rodziny C/C++, choæ zawiera równie¿ wiele elementów znanych programistom Javy, jak na przyk³ad mechanizmy automatycznego odzyskiwanie pamiêci. £¹czy wiêc w sobie wszystko to, CENNIK I INFORMACJE co najlepsze w Javie i C++, a dodatkowo pozwala na wygodne korzystanie z klas wchodz¹cych w sk³ad platformy .NET. ZAMÓW INFORMACJE Dziêki ksi¹¿ce „C#. Æwiczenia” nauczysz siê programowaæ w C# niezale¿nie od tego, O NOWO CIACH czy znasz ju¿ C++ lub Javê. Kilkadziesi¹t æwiczeñ pozwoli Ci poznaæ jêzyk C# od podstaw po zagadnienia zaawansowane. Zalet¹ ksi¹¿ki jest zwiêz³y i przystêpny opis ZAMÓW CENNIK prezentowanych zagadnieñ i nastawienie na praktykê programistyczn¹, a nie na rozwa¿ania teoretyczne. Poznasz: CZYTELNIA • rodowisko uruchomieniowe C# i Visual Studio FRAGMENTY KSI¥¯EK ONLINE • Zmienne, operatory i typy danych • Instrukcje C# • Podstawy programowania obiektowego, tworzenie klas, metod i konstruktorów • U¿ycie tablic w C# • Obs³ugê b³êdów za pomoc¹ wyj¹tków • Interfejsy i rzutowanie • Obs³ugê zdarzeñ • Korzystanie z komponentów interfejsu u¿ytkownika Windows Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl

2. Spis treści Wstęp...........................................................................................................................................................5 Część I Język programowania ................................................................................................................... 7 Rozdział 1. Pierwsza aplikacja................................................................................................................................9 Język C# ......................................................................................................................... 9 Środowisko uruchomieniowe........................................................................................... 10 Narzędzia ...................................................................................................................... 11 Najprostszy program ...................................................................................................... 11 Kompilacja i uruchamianie.............................................................................................. 12 Visual Studio ................................................................................................................. 13 Dyrektywa using ............................................................................................................ 16 Rozdział 2. Zmienne i typy danych........................................................................................................................17 Typy danych.................................................................................................................. 17 Typy arytmetyczne ................................................................................................... 17 Typ boolean ............................................................................................................. 19 Deklarowanie zmiennych .......................................................................................... 19 Typy referencyjne .................................................................................................... 22 Typ string ................................................................................................................ 23 Typ object ............................................................................................................... 23 Wartość null............................................................................................................. 23 Operatory ...................................................................................................................... 24 Operatory Arytmetyczne ........................................................................................... 24 Operatory bitowe...................................................................................................... 29 Operatory logiczne.................................................................................................... 30 Operatory przypisania ............................................................................................... 30 Operatory porównania............................................................................................... 31 Operator warunkowy (?) ........................................................................................... 31 Priorytety operatorów ............................................................................................... 32 Komentarze ................................................................................................................... 32 Rozdział 3. Instrukcje...............................................................................................................................................35 Instrukcje warunkowe .................................................................................................... 35 Instrukcja if...else ..................................................................................................... 35 Instrukcja if...else if .................................................................................................. 38 Instrukcja switch ...................................................................................................... 39 Instrukcja goto ............................................................................................................... 41 Pętle ............................................................................................................................. 43 Pętla for................................................................................................................... 43 Pętla while ............................................................................................................... 48 Pętla do while........................................................................................................... 49

3. 4 C#. Ćwiczenia Wprowadzanie danych.................................................................................................... 50 Argumenty wiersza poleceń....................................................................................... 51 Instrukcja ReadLine.................................................................................................. 54 Rozdział 4. Programowanie obiektowe.............................................................................................................61 Klasy ............................................................................................................................ 61 Metody ......................................................................................................................... 63 Konstruktory ................................................................................................................. 69 Specyfikatory dostępu .................................................................................................... 71 Dziedziczenie ................................................................................................................ 75 Rozdział 5. Tablice .......................................................................................................................................................77 Deklarowanie tablic........................................................................................................ 77 Inicjalizacja ................................................................................................................... 80 Pętla foreach.................................................................................................................. 81 Tablice wielowymiarowe ................................................................................................ 83 Rozdział 6. Wyjątki.....................................................................................................................................................89 Obsługa błędów ............................................................................................................. 89 Blok try...catch .............................................................................................................. 93 Hierarchia wyjątków ...................................................................................................... 97 Własne wyjątki .............................................................................................................. 99 Rozdział 7. Interfejsy ...............................................................................................................................................101 Prosty interfejs............................................................................................................. 101 Interfejsy w klasach potomnych .................................................................................... 104 Czy to interfejs?........................................................................................................... 110 Rzutowanie ............................................................................................................ 113 Słowo kluczowe as ................................................................................................. 115 Słowo kluczowe is .................................................................................................. 116 Część II Programowanie w Windows ................................................................................................117 Rozdział 8. Pierwsze okno .....................................................................................................................................119 Utworzenie okna .......................................................................................................... 119 Wyświetlanie komunikatu ............................................................................................. 122 Zdarzenie ApplicationExit............................................................................................. 123 Rozdział 9. Delegacje i zdarzenia......................................................................................................................125 Delegacje .................................................................................................................... 125 Zdarzenia .................................................................................................................... 128 Rozdział 10. Komponenty ........................................................................................................................................133 Etykiety (Label) ........................................................................................................... 133 Przyciski (klasa Button) ................................................................................................ 137 Pola tekstowe (TextBox)............................................................................................... 140 Pola wyboru (CheckBox, RadioButton).......................................................................... 143 Listy rozwijalne (ComboBox) ....................................................................................... 146 Listy zwykłe (ListBox) ................................................................................................. 149 Menu .......................................................................................................................... 151 Menu główne ......................................................................................................... 151 Menu kontekstowe ................................................................................................. 157 Właściwości Menu ................................................................................................. 159 Skróty klawiaturowe ............................................................................................... 162

4. 3. Rozdział Instrukcje Instrukcje warunkowe Instrukcja if...else Bardzo często w programie zachodzi potrzeba sprawdzenia jakiegoś warunku i, w zale no- ści od tego, czy jest on prawdziwy czy fałszywy, dalsze wykonywanie ró nych instrukcji. Do takiego sprawdzania słu y właśnie instrukcja warunkowa KH GNUG. Ma ona ogólną postać: KH Y[TC GPKG YCTWPMQYG] +PUVTWMELG FQ Y[MQPCPKC LG GNK YCTWPGM LGUV RTCYFKY[ _ GNUG] +PUVTWMELG FQ Y[MQPCPKC LG GNK YCTWPGM LGUV HC U[Y[ _ Spróbujmy zatem wykorzystać taką instrukcję do sprawdzenia, czy zmienna całkowita jest mniejsza od zera. Ćwiczenie 3.1. Wykorzystaj instrukcję warunkową if…else do stwierdzenia, czy wartość zmiennej aryt- metycznej jest mniejsza od zera. Wyświetl odpowiedni komunikat na ekranie. WUKPI 5[UVGO ENCUU *GNNQ ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU

5. 36 Część I Język programowania ] KPV OKGPPC KH OKGPPC ] %QPUQNG9TKVG.KPG OKGPPC LGUV OPKGLUC QF GTC _ GNUG] %QPUQNG9TKVG.KPG OKGPPC PKG LGUV OPKGLUC QF GTC _ _ _ Spróbujmy teraz czegoś nieco bardziej skomplikowanego. Zajmijmy się klasycznym przy- kładem liczenia pierwiastków równania kwadratowego. Przypomnijmy, e jeśli mamy równanie w postaci: A∗ x ∧ 2 + B ∗ x + C = 0, aby obliczyć jego rozwiązanie liczymy tzw. deltę (∆), która równa jest: B ∧ 2 − 4 ∗ A ∗C . Je eli delta jest większa od zera, mamy dwa pierwiastki: x1 = ( − B + ∆ ) 2 ∗ A x2 = ( − B − ∆ ) 2 ∗ A . Je eli delta jest równa zero, istnieje tylko jedno rozwiązanie, a mianowicie: x = − B 2∗ A . W przypadku trzecim, je eli delta jest mniejsza od zera, równanie takie nie ma rozwią- zań w zbiorze liczb rzeczywistych. Skoro jest tutaj tyle warunków do sprawdzenia, jest to doskonały przykład do potrenowania zastosowania instrukcji KH GNUG. Przy tym, aby nie komplikować sprawy, nie będziemy się w tej chwili zajmować wczytywaniem parame- trów równania z klawiatury, ale podamy je bezpośrednio w kodzie. Przed przystąpieniem do realizacji tego zadania musimy się tylko jeszcze dowiedzieć, w jaki sposób uzyskać pierwiastek z danej liczby? Na szczęście nie jest to wcale skomplikowane, wystarczy skorzystać z instrukcji /CVJ5STV . Aby zatem dowiedzieć się, jaki jest pierwiastek kwadratowy z liczby 4, nale y napisać: /CVJ5STV Oczywiście zamiast liczby mo emy te podać w takim wywołaniu zmienną, a wynik działa- nia wypisać na ekranie np.: KPV RKGTYUC.KEDC KPV FTWIC.KEDC /CVJ5STV RKGTYUC.KEDC %QPUQNG9TKVG.KPG FTWIC.KEDC

6. Rozdział 3. Instrukcje 37 Ćwiczenie 3.2. Wykorzystaj operacje arytmetyczne oraz instrukcje if…else do obliczenia pierwiastków równania kwadratowego o parametrach podanych bezpośrednio w kodzie programu. Wyniki wyświetl na ekranie (rysunek 3.1). WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV RCTCOGVT# RCTCOGVT$ RCTCOGVT% %QPUQNG9TKVG.KPG 2CTCOGVT[ TÎYPCPKCP %QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVT$ å % RCTCOGVT% P KH RCTCOGVT# ] %QPUQNG9TKVG.KPG 6Q PKG LGUV TÎYPCPKG MYCFTCVQYG # _ GNUG] FQWDNG FGNVC RCTCOGVT$

7. RCTCOGVT$

8. RCTCOGVT#

9. RCTCOGVT% KH FGNVC ] %QPUQNG9TKVG.KPG GNVC %QPUQNG9TKVG.KPG 6Q TÎYPCPKG PKG OC TQYKæCPKC åY DKQTG NKED TGE[YKUV[EJ _ GNUG] FQWDNG Y[PKM KH FGNVC ] Y[PKM RCTCOGVT$

10. RCTCOGVT# %QPUQNG9TKVG.KPG 4QYKæCPKG Z Y[PKM _ GNUG] Y[PKM RCTCOGVT$ /CVJ5STV FGNVC å

11. RCTCOGVT# %QPUQNG9TKVG 4QYKæCPKG Z Y[PKM Y[PKM RCTCOGVT$ /CVJ5STV FGNVC å

12. RCTCOGVT# %QPUQNG9TKVG.KPG Z Y[PKM _ _ _ _ _ Rysunek 3.1. Wynik działania programu obliczającego pierwiastki równania kwadratowego

13. 38 Część I Język programowania Instrukcja if...else if Jak pokazało nam ćwiczenie 3.2, instrukcję warunkową mo na zagnie d ać, to znaczy po jednym KH mo e występować kolejne, po nim następne itd. Jednak e taka budowa kodu powoduje, e przy wielu zagnie d eniach staje się on bardzo nieczytelny. Aby tego unik- nąć, mo emy wykorzystać instrukcję KH GNUG KH. Zamiast tworzyć niewygodną konstruk- cję, taką jak przedstawiona poni ej: KH YCTWPGM] +PUVTWMELG _ GNUG] KH YCTWPGM] KPUVTWMELG _ GNUG] KH YCTWPGM] KPUVTWMELG _ GNUG] KPUVTWMELG _ _ _ Całość mo emy zapisać du o prościej i czytelniej w następującej postaci: KH YCTWPGM] +PUVTWMELG _ GNUG KH YCTWPGM] KPUVTWMELG _ GNUG KH YCTWPGM] KPUVTWMELG _ GNUG] KPUVTWMELG _ Ćwiczenie 3.3. Zmodyfikuj program napisany w ćwiczeniu 3.2 tak, aby wykorzystywał on instrukcję if… else if. WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV RCTCOGVT# RCTCOGVT$ RCTCOGVT% %QPUQNG9TKVG.KPG 2CTCOGVT[ TÎYPCPKCP %QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVT$ å % RCTCOGVT% P KH RCTCOGVT# ] %QPUQNG9TKVG.KPG 6Q PKG LGUV TÎYPCPKG MYCFTCVQYG #

14. Rozdział 3. Instrukcje 39 _ GNUG] FQWDNG FGNVC RCTCOGVT$

15. RCTCOGVT$

16. RCTCOGVT#

17. RCTCOGVT% FQWDNG Y[PKM KH FGNVC ] %QPUQNG9TKVG.KPG GNVC %QPUQNG9TKVG.KPG 6Q TÎYPCPKG PKG OC TQYKæCPKC åY DKQTG NKED TGE[YKUV[EJ _ GNUG KH FGNVC ] Y[PKM RCTCOGVT$

18. RCTCOGVT# %QPUQNG9TKVG.KPG 4QYKæCPKG Z Y[PKM _ GNUG] Y[PKM RCTCOGVT$ /CVJ5STV FGNVC

19. RCTCOGVT# %QPUQNG9TKVG 4QYKæCPKG Z Y[PKM Y[PKM RCTCOGVT$ /CVJ5STV FGNVC

20. RCTCOGVT# %QPUQNG9TKVG.KPG Z Y[PKM _ _ _ _ Instrukcja switch Je eli mamy do sprawdzenia wiele warunków, instrukcja UYKVEJ pozwoli nam wygodnie zastąpić ciągi instrukcji KH GNUG KH. Jeśli mamy następujący fragment kodu: KH C ] KPUVTWMELG _ GNUG KH C ] KPUVTWMELG _ GNUG KH C ] KPUVTWMELG _ GNUG] KPUVTWMELG _ mo emy zastąpić poni szym: UYKVEJ C] ECUG KPUVTWMELG DTGCM ECUG KPUVTWMELG DTGCM ECUG KPUVTWMELG DTGCM FGHCWNV KPUVTWMELG DTGCM _

21. 40 Część I Język programowania Sprawdzamy tu po kolei, czy C nie jest przypadkiem równe jeden, potem dwa i w końcu trzy. Je eli tak, wykonywane są instrukcje po odpowiedniej klauzuli ECUG. Je eli C nie jest równe adnej z wymienionych liczb, wykonywane są instrukcje po słowie FGHCWNV. Instrukcja DTGCM powoduje wyjście z bloku UYKVEJ. Czyli, jeśli C będzie równe jeden, zostaną wykonane instrukcje KPUVTWMELG, jeśli C będzie równe dwa, zostaną wykonane instrukcje KPUVTWMELG, jeśli C będzie równe trzy, zostaną wykonane instrukcje KPUVTWM ELG. W przypadku gdyby C nie było równe ani jeden, ani dwa, ani trzy, zostaną wykonane instrukcje KPUVTWMELG. Ćwiczenie 3.4. Zadeklaruj zmienną typu całkowitego i przypisz jej dowolną wartość. Korzystając z instrukcji switch, sprawdź, czy wartość ta równa jest 1 lub 2. Wyświetl odpowiedni komunikat na ekranie. WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV C UYKVEJ C] ECUG %QPUQNG9TKVG.KPG C DTGCM ECUG %QPUQNG9TKVG.KPG C DTGCM FGHCWNV %QPUQNG9TKVG.KPG OKGPPC C PKG LGUV TÎYPC CPK CPK DTGCM _ _ _ Warto w tym miejscu zauwa yć, e w przypadku C#, odmiennie ni w językach takich jak C, C++ czy Java, nie mo emy pominąć instrukcji DTGCM, powodującej wyjście z instrukcji UYKVEJ. Próba taka skończy się błędem kompilacji (rysunek 3.2). Ściślej rzecz biorąc, nie musi być to dokładnie instrukcja DTGCM, ale dowolna instrukcja, w wyniku któ- rej zostanie opuszczony blok UYKVEJ. Dokładniejsze wyjaśnienie i przykład takiej konstrukcji znajduje się przy opisie instrukcji IQVQ. Rysunek 3.2. Próba pominięcia instrukcji break kończy się błędem kompilacji

22. Rozdział 3. Instrukcje 41 Instrukcja goto Instrukcja IQVQ, czyli instrukcja umo liwiająca skok do określonego miejsca w programie, od dawna jest uznawana za niebezpieczną i powodująca wiele problemów. Niemniej w C# jest ona obecna, choć zaleca się jej stosowanie jedynie w przypadku bloków UYKVEJ ECUG oraz wychodzenia z zagnie d onych pętli, w których to sytuacjach jest faktycznie u yteczna. U ywamy jej w postaci IQVQ GV[MKGVC gdzie GV[MKGVC jest zdefiniowanym miejscem w programie. Nie mo emy jednak w ten sposób wskoczyć do bloku instrukcji, tzn. nie jest mo liwa konstrukcja: HQT KPV L L L ] KH L IQVQ NCDGN _ HQT KPV K K K ] NCDGN _ Nic jednak nie stoi na przeszkodzie, aby zdefiniować etykietę przed lub za druga pętlą, pisząc: HQT KPV L L L ] KH L IQVQ NCDGN _ NCDGN HQT KPV K K K ] _ Taki kod jest ju jak najbardziej poprawny. Ćwiczenie 3.5. Napisz przykładowy program, w którym instrukcja goto jest wykorzystywana do wyjścia z zagnie d onej pętli for. WUKPI 5[UVGO RWDNKE ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP ] HQT KPV L L L ] HQT KPV K K K ] KH L K ] IQVQ NCDGN _ _ _ TGVWTP NCDGN %QPUQNG9TKVG.KPG 2úVNC QUVC C RTGTYCPC _ _

23. 42 Część I Język programowania Wykorzystujemy tutaj dwie pętle, zewnętrzną, gdzie zmienną iteracyjną jest L, oraz we- wnętrzną, gdzie zmienną iteracyjną jest K. Wewnątrz drugiej pętli znajduje się warunek, który nale y odczytywać następująco: je eli L równe jest 100 oraz K jest większe od 200, idź do miejsca w kodzie oznaczonego etykietą NCDGN. Zatem po osiągnięciu warunku na ekranie zostanie wyświetlony napis 2úVNC QUVC C RTGTYCPC oraz aplikacja zakończy działanie. Zauwa my, e przed etykietą znajduje się instrukcja TGVWTP powodująca zakończenie dzia- łania funkcji /CKP. Gdyby jej nie było, napis o przerwaniu pętli wyświetlany byłby zawsze, niezale nie od spełnienia warunku wewnątrz pętli. Oczywiście w tym przypadku warunek zawsze zostanie spełniony, tak e TGVWTP nie jest niezbędne, ale ju w prawdziwej aplikacji zapomnienie o tym drobnym z pozoru fakcie mogłoby przysporzyć nam wielu problemów. Spróbujmy teraz wykorzystać instrukcję IQVQ w drugim z zalecanych przypadków jej u ycia, to znaczy w bloku UYKVEJ ECUG. Ćwiczenie 3.6. Napisz przykładowy kod, w którym instrukcja goto jest wykorzystywana w połączeniu z blokiem switch…case. WUKPI 5[UVGO RWDNKE ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP ] 4CPFQO T PGY 4CPFQO KPV K T0GZV %QPUQNG9TKVG.KPG 9[NQUQYCPQ YCTVQ è K K UYKVEJ K] ECUG %QPUQNG9TKVG.KPG K LGUV OPKGLUG QF DTGCM ECUG IQVQ ECUG ECUG %QPUQNG9TKVG.KPG K LGUV OPKGLUG QF IQVQ FGHCWNV ECUG IQVQ ECUG ECUG IQVQ ECUG FGHCWNV %QPUQNG9TKVG.KPG 0KG QUVC Y[MQPCP[ CPK DNQM ECUG åCPK DNQM ECUG DTGCM _ _ _

24. Rozdział 3. Instrukcje 43 Przykładowe wyniki działania tej prostej aplikacji widoczne są na rysunku 3.3. Zmiennej K typu KPV przypisujemy losową liczbę całkowitą z zakresu . Odpowiada za to linia KPV K T0GZV , gdzie T jest zmienną wskazującą na obiekt klasy 4CPFQO. Klasa ta słu y właśnie do generowania losowych, a dokładniej pseudolosowych, liczb. Rysunek 3.3. Przykładowe wyniki działania programu z ćwiczenia 3.6 Następnie w bloku UYKVEJ ECUG rozpatrujemy następujące sytuacje: K jest równe — wyświetlamy napis 0KG QUVC Y[MQPCP[ CPK DNQM ECUG CPK DNQM ECUG K jest równe lub — wyświetlamy napis K LGUV OPKGLUG QF K jest równe , lub — wyświetlamy napis K LGUV OPKGLUG QF oraz 0KG QUVC Y[MQPCP[ CPK DNQM ECUG CPK DNQM ECUG Pętle Pętle w językach programowania pozwalają na wykonywanie powtarzających się czynności. Dokładnie w ten sam sposób działają one równie w C#. Jeśli chcemy, na przykład, wypisać na ekranie 10 razy napis % , to mo emy zrobić to, pisząc 10 razy %QPUQNG9TKVG .KPG % . Je eli jednak chcielibyśmy mieć, na przykład, 100 takich napisów, to, pomija- jąc oczywiście sensowność takiej czynności, byłby to ju problem. Na szczęście z pomocą przychodzą nam właśnie pętle. Pętla for Pętla typu HQT ma następująca składnię: HQT Y[TC GPKG RQEæVMQYG Y[TC GPKG YCTWPMQYG Y[TC GPKG OQF[HKMWLæEG] KPUVTWMELG FQ Y[MQPCPKC _ 9[TC GPKG RQEæVMQYG jest stosowane do zainicjalizowania zmiennej u ywanej jako licznik ilości wykonań pętli. 9[TC GPKG YCTWPMQYG określa warunek, jaki musi być speł- niony, aby dokonać kolejnego przejścia w pętli, Y[TC GPKG OQF[HKMWLæEG u ywane jest zwykle do modyfikacji zmiennej będącej licznikiem.

25. 44 Część I Język programowania Ćwiczenie 3.7. Wykorzystując pętlę typu for, napisz program wyświetlający na ekranie 100 razy napis C#. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] HQT KPV K K K ] %QPUQNG9TKVG % _ _ _ Wynik działania tego prostego programu widoczny jest na rysunku 3.4. Rysunek 3.4. Wynik działania pętli for z ćwiczenia 3.7 Zmienna K to tzw. zmienna iteracyjna, której na początku przypisujemy wartość (KPV K ). Następnie, w ka dym przebiegu pętli jest ona zwiększana o jeden (K ) oraz wykonywana jest instrukcja %QPUQNG9TKVG.KPG % Wszystko trwa tak długo, a K osiągnie wartość 100 (K ). Wyra enie modyfikujące jest zwykle u ywane do modyfikacji zmiennej iteracyjnej. Takiej modyfikacji mo emy jednak dokonać równie wewnątrz pętli. Struktura tego typu wygląda następująco: HQT Y[TC GPKG RQEæVMQYG Y[TC GPKG YCTWPMQYG] KPUVTWMELG FQ Y[MQPCPKC Y[TC GPKG OQF[HKMWLæEG _ Ćwiczenie 3.8. Zmodyfikuj pętle typu for z ćwiczenia 3.7 tak, aby wyra enie modyfikujące znalazło się w bloku instrukcji for. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] HQT KPV K K ] %QPUQNG9TKVG % K _ _ _

26. Rozdział 3. Instrukcje 45 Zwracam uwagę, e mimo i wyra enie modyfikujące jest teraz wewnątrz pętli, średnik znajdujący się po K jest niezbędny! Jeśli o nim zapomnimy, kompilator zgłosi błąd (rysunek 3.5). Rysunek 3.5. Pominięcie średnika w pętli for powoduje błąd kompilacji Kolejna ciekawą mo liwością jest połączenie wyra enia warunkowego i modyfikującego. Konkretnie nale y spowodować, aby wyra enie warunkowe było jednocześnie wyra eniem modyfikującym. Tworzenie takich konstrukcji umo liwiają nam, na przykład, operatory inkrementacji i dekrementacji. Ćwiczenie 3.9. Napisz taką pętlę typu for, aby wyra enie warunkowe było jednocześnie wyra eniem modyfikującym. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] HQT KPV K K ] %QPUQNG9TKVG % _ _ _ W podobny sposób jak w poprzednich przykładach mo emy się w pozbyć równie wyra enia początkowego. Nale y je przenieść przed pętlę. Schematyczna konstrukcja wy- gląda następująco: Y[TC GPKG RQEæVMQYG HQT Y[TC GPKG YCTWPMQYG] KPUVTWMELG FQ Y[MQPCPKC Y[TC GPKG OQF[HKMWLæEG _ Ćwiczenie 3.10. Zmodyfikuj pętle typu for w taki sposób, aby wyra enie początkowe znalazło się przed pętlą, a wyra enie modyfikujące wewnątrz pętli.

27. 46 Część I Język programowania WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV K HQT K ] %QPUQNG9TKVG % K _ _ _ Skoro zaszliśmy ju tak daleko w pozbywaniu się wyra eń sterujących, usuńmy równie wyra enie warunkowe. Jest to jak najbardziej mo liwe! Ćwiczenie 3.11. Zmodyfikuj pętle typu for w taki sposób, aby wyra enie początkowe znalazło się przed pętlą, natomiast wyra enie modyfikujące i warunkowe wewnątrz pętli. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV K HQT ] %QPUQNG9TKVG % KH K DTGCM _ _ _ Jak mo na zauwa yć, taka pętla te jest mo liwa. Przypominam raz jeszcze, e średniki (tym razem ju dwa) w nawisach po HQT są niezbędne! Warto te zwrócić uwagę na zmianę kierunku nierówności. Wcześniej sprawdzaliśmy, czy K jest mniejsze bądź równe 100, a teraz, czy jest większe bądź równe. Dzieje się tak dlatego, e we wcześniejszych ćwiczeniach sprawdzaliśmy, czy pętla ma się dalej wykonywać, natomiast w obecnym, czy ma się za- kończyć. W zasadzie, zamiast nierówności moglibyśmy napisać równie KH K DTGCM. Przy okazji nauczyliśmy się, w jaki sposób wykorzystuje się instrukcję DTGCM w przypadku pętli. Słu y ona oczywiście do natychmiastowego przerwania wykonywania pętli. Kolejna przydatna instrukcja, EQPVKPWG, powoduje rozpoczęcie kolejnej iteracji — w miejscu jej wystąpienia wykonywanie bie ącej iteracji jest przerywane i rozpoczyna się kolejny obieg. Najlepiej zobaczyć to na konkretnym przykładzie. Ćwiczenie 3.12. Napisz program wyświetlający na ekranie liczby od 1 do 20, które nie są podzielne przez 2. Skorzystaj z pętli for i instrukcji continue.

28. Rozdział 3. Instrukcje 47 WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] HQT KPV K K K ] KH K EQPVKPWG %QPUQNG9TKVG.KPG K _ _ _ Wynik działania takiej aplikacji widoczny jest na rysunku 3.6. Przypominam, e % to operator dzielenia modulo — dostarcza on resztę z dzielenia. W ka dym zatem przebiegu sprawdzamy, czy K modulo nie jest przypadkiem równe . Jeśli jest (zatem K jest podzielne przez ), przerywamy bie ącą iterację instrukcją EQPVKPWG. W przeciwnym przypadku (K modulo jest ró ne od zera) wykonujemy instrukcję %QPUQNG9TKVG.KPG K. Ostatecz- nie na ekranie otrzymamy wszystkie liczby od jeden do dwadzieścia, które nie są podzielne przez dwa. Rysunek 3.6. Program wyświetlający liczby od 1 do 20 niepodzielne przez 2 Ten sam program mo na by oczywiście napisać bez u ycia instrukcji EQPVKPWG. Jak tego dokonać, poka e nam kolejne ćwiczenie. Ćwiczenie 3.13. Zmodyfikuj kod z ćwiczenia 3.12 tak, aby nie było konieczności u ycia instrukcji continue. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] HQT KPV K K K ] KH K ] %QPUQNG9TKVG.KPG K _ _ _ _

29. 48 Część I Język programowania Pętla while O ile pętla typu HQT słu yła raczej do wykonywania z góry znanej ilości operacji, w przypadku pętli YJKNG zwykle nie jest ona znana. Nie jest to oczywiście obligatoryjne. Tak na- prawdę pętlę YJKNG mo na napisać tak, by była dokładnym funkcjonalnym odpowiednikiem pętli HQT, a pętle HQT tak, by była odpowiednikiem pętli YJKNG. Ogólna konstrukcja pętli typu YJKNG jest następująca: YJKNG Y[TC GPKG YCTWPMQYG] KPUVTWMELG _ Instrukcje są wykonywane tak długo, dopóki wyra enie warunkowe jest prawdziwe. Ozna- cza to, e gdzieś w pętli musi nastąpić modyfikacja warunku, bądź te instrukcja DTGCM. Inaczej pętla będzie się wykonywała w nieskończoność! Ćwiczenie 3.14. U ywając pętli typu while, napisz program wyświetlający na ekranie 100 razy napis C#. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV K YJKNG K ] %QPUQNG9TKVG % K _ _ _ Ćwiczenie 3.15. Zmodyfikuj kod z ćwiczenia 3.14 tak, aby wyra enie warunkowe zmieniało jednocześnie wartość zmiennej i. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV K YJKNG K ] %QPUQNG9TKVG % _ _ _

30. Rozdział 3. Instrukcje 49 Ćwiczenie 3.16. Korzystając z pętli while, napisz program wyświetlający na ekranie liczby od 1 do 20 niepodzielne przez 2. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV K YJKNG K ] KH K ] %QPUQNG9TKVG.KPG K _ K _ _ _ Zauwa my, e w tym przypadku nie mo emy skorzystać z konstrukcji takiej jak w poprzed- nim ćwiczeniu. Tym razem zmienna iteracyjna K musi być modyfikowana we wnętrzu pętli. Dzieje się tak dlatego, e wewnątrz korzystamy z jej wartości. Gdybyśmy zatem napisali pętlę tę w postaci YJKNG K , otrzymalibyśmy na ekranie liczby od 2 do 21 niepodzielne przez 2, co byłoby niezgodne z zało eniami programu. Pętla do while Oprócz przedstawionych dotychczas istnieje jeszcze jedna odmiana pętli. Mianowicie FQ YJKNG. Jej konstrukcja jest następująca: FQ] KPUVTWMELG _ YJKNG YCTWPGM Zapis ten nale y rozumieć jako: wykonuj KPUVTWMELG, dopóki YCTWPGM jest prawdziwy. Spróbujmy zatem wykonać zadanie przedstawione ćwiczeniu 3.14, ale korzystając z pętli typu FQ YJKNG. Ćwiczenie 3.17. Korzystając z pętli do…while, napisz program wyświetlający na ekranie 100 razy napis C#. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV K FQ] %QPUQNG9TKVG %

31. 50 Część I Język programowania _ YJKNG K _ _ Wydawać by się mogło, e to przecie to samo, co zwykła pętla YJKNG. Wydaje się wręcz, e to po prostu odwrócona pętla YJKNG. Jest jednak pewna ró nica powodująca, e YJKNG i FQ YJKNG nie są dokładnymi odpowiednikami. Otó w przypadku pętli FQ YJKNG instrukcje wykonane będą co najmniej jeden raz, nawet jeśli warunek jest na pewno fałszy- wy. Dzieje się tak oczywiście dlatego, e sprawdzenie warunku zakończenia pętli od- bywa się dopiero po jej pierwszym przebiegu. Ćwiczenie 3.18. Zmodyfikuj kod z ćwiczenia 3.17 w taki sposób, aby wyra enie warunkowe na pewno było fałszywe. Zaobserwuj wyniki działania programu. WUKPI 5[UVGO ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV K FQ] %QPUQNG9TKVG % _ YJKNG K _ _ Tym razem, mimo e warunek był fałszywy (początkowa wartość zmiennej K to 101, które na pewno jest większe ni u yte w wyra eniu warunkowym 100), na ekranie pojawi się jeden napis % . Jeszcze dobitniej fakt wykonania jednego przebiegu pętli niezale nie od prawdziwości warunku mo na pokazać, stosując konstrukcję: FQ] %QPUQNG9TKVG % _ YJKNG HCNUG W tym przypadku ju na pierwszy rzut oka widać, e warunek jest fałszywy. Prawda? Wprowadzanie danych Wiemy, jak wyprowadzać dane na konsolę, czyli po prostu jak wyświetlać je na ekranie. Bardzo przydałaby się jednak mo liwość ich wprowadzania do programu. Nie jest to bardzo skomplikowane zadanie, choć napotkamy pewne trudności związane z koniecznością do- konywania konwersji typów danych.

32. Rozdział 3. Instrukcje 51 Argumenty wiersza poleceń Przekazywanie danych do aplikacji jako argumentów w wierszu poleceń przy wywoływaniu programu jest dobrze znanym większości programistów sposobem. Taka mo liwość wy- stępuje prawdopodobnie w większości popularnych języków programowania. Nie inaczej jest w C#, gdzie, aby z tych danych skorzystać, nale y odpowiednio zadeklarować funkcję /CKP. Konkretnie deklaracja powinna wyglądać następująco: RWDNKE UVCVKE XQKF OCKP UVTKPI=? CTIU ] KPUVTWMELG _ Jak widać, argumenty są przekazywane do aplikacji w postaci tablicy obiektów UVTKPI. Poniewa w C#, podobnie jak w Javie, tablice są obiektami, nie ma potrzeby dodatkowego przekazywania parametru określającego liczbę argumentów, jak ma to miejsce w C i C++. Jej rozmiar określany jest parametrem .GPIVJ (bli sze informacje o tablicach znajdują się w rozdziale piątym). Ćwiczenie 3.19. Wyświetl na ekranie wszystkie argumenty podane przez u ytkownika w wierszu poleceń. WUKPI 5[UVGO RWDNKE ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] %QPUQNG9TKVG.KPG .KEDC YRTQYCFQP[EJ CTIWOGPVÎY ]_ CTIU.GPIVJ HQT KPV K K CTIU.GPIVJ K ] %QPUQNG9TKVG.KPG RCTCOGVT=]_? ]_ K CTIU=K? _ _ _ Dane są wyprowadzane na ekran przy u yciu typowej pętli HQT. Przykładowy efekt dzia- łania programu widoczny jest na rysunku 3.7. Rysunek 3.7. Program wyświetlający argumenty podane w wierszu poleceń

33. 52 Część I Język programowania Przy pracy z argumentami przekazywanymi z wiersza poleceń napotkamy na pewien problem. Załó my bowiem, e chcielibyśmy napisać program, który dodaje do siebie dwie liczby całkowite i wyświetla wynik tego działania na ekranie. Wydawać by się mogło, e najprostsze rozwiązanie wygląda tak jak na poni szym listingu: WUKPI 5[UVGO RWDNKE ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KH CTIU.GPIVJ ] %QPUQNG9TKVG.KPG 0CNG [ RQFCè FYC CTIWOGPV[ Y YKGTUW RQNGEG TGVWTP _ %QPUQNG9TKVG.KPG 9[PKMKGO FKC CPKC LGUV ]_ CTIU=? CTIU=? _ _ Oczywiście nie jest ono prawidłowe, gdy dokonujemy tutaj operacji na dwóch ciągach znaków, a nie dwóch liczbach! Zatem wynikiem dodawania, na przykład, 12 i 8 będzie w powy szym programie 128, zamiast spodziewanego 20. Aby aplikacja działała popraw- nie, nale y najpierw dokonać konwersji argumentów z typu UVTKPI do typu KPV, a dopiero potem wykonywać działanie. Konwersji takiej dokonamy przy wykorzystaniu statycznej metody 2CTUG w postaci: KPV OKGPPC +PV2CTUG NKEDC Ćwiczenie 3.20. Napisz program dokonujący dodawania dwóch liczb podanych jako parametry w wierszu poleceń. WUKPI 5[UVGO RWDNKE ENCUU OCKP ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV C D KH CTIU.GPIVJ ] %QPUQNG9TKVG.KPG 0CNG [ RQFCè FYC CTIWOGPV[ Y YKGTUW RQNGEG TGVWTP _ VT[] C +PV2CTUG CTIU=? D +PV2CTUG CTIU=? _ ECVEJ 'ZEGRVKQP] %QPUQNG9TKVG.KPG ,GFGP CTIWOGPVÎY PKG LGUV RQRTCYPæ NKEDæ TGVWTP _ %QPUQNG9TKVG.KPG 9[PKMKGO FKC CPKC LGUV ]_ C D _ _

34. Rozdział 3. Instrukcje 53 Konwersji z typu UVTKPI do typu KPV dokonuje wspomniana ju instrukcja +PV2CTUG. Dodatkowo sprawdzamy równie , czy konwersja ta zakończyła się sukcesem poprzez zastosowanie bloku VT[ ECVEJ. Dokładniejsze wytłumaczenie tej konstrukcji znajduje się w rozdziale szóstym, w którym opisane jest stosowanie wyjątków. Przypomnijmy sobie teraz aplikację napisaną w ćwiczeniach 3.2 i 3.3. Obliczała ona pierwiastki równania kwadratowego, jednak argumenty tego równania były podawane bezpo- średnio w kodzie. Za ka dym razem, kiedy następowała konieczność ich zmiany, musieliśmy ponownie kompilować program. Na pewno nie było to zbyt wygodne. Teraz, kiedy wiemy ju , w jaki sposób stosować argumenty, podając je w wierszu poleceń, i wiemy, w jaki sposób dokonać konwersji danych, mo emy pokusić się o spore usprawnienie tamtych aplikacji. Ćwiczenie 3.21. Napisz program obliczający pierwiastki równania kwadratowego, w którym parametry równania są wprowadzane w wierszu poleceń (rysunek 3.8). WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV RCTCOGVT# RCTCOGVT$ RCTCOGVT% KH CTIU.GPIVJ ] %QPUQNG9TKVG.KPG 9[YQ CPKG RTQITCOW RTQITCO RCTCOGVT åRCTCOGVT RCTCOGVT TGVWTP _ VT[] RCTCOGVT# +PV2CTUG CTIU=? RCTCOGVT$ +PV2CTUG CTIU=? RCTCOGVT% +PV2CTUG CTIU=? _ ECVEJ 'ZEGRVKQP] %QPUQNG9TKVG.KPG ,GFGP RCTCOGVTÎY TÎYPCPKC PKG LGUV RQRTCYPæ åNKEDæ EC MQYKVæ TGVWTP _ %QPUQNG9TKVG.KPG 9RTQYCFQPG RCTCOGVT[ TÎYPCPKCP %QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVT$ % å RCTCOGVT% P KH RCTCOGVT# ] %QPUQNG9TKVG.KPG 6Q PKG LGUV TÎYPCPKG MYCFTCVQYG # _ GNUG] FQWDNG FGNVC RCTCOGVT$

35. RCTCOGVT$

36. RCTCOGVT#

37. RCTCOGVT% FQWDNG Y[PKM KH FGNVC ] %QPUQNG9TKVG.KPG GNVC

38. 54 Część I Język programowania %QPUQNG9TKVG.KPG 6Q TÎYPCPKG PKG OC TQYKæCPKC Y DKQTG åNKED TGE[YKUV[EJ _ GNUG KH FGNVC ] Y[PKM RCTCOGVT$

41. RCTCOGVT# %QPUQNG9TKVG.KPG Z Y[PKM _ _ _ _ Rysunek 3.8. Równania kwadratowe o parametrach podanych w wierszu poleceń Instrukcja ReadLine Wprowadzanie danych do programu w wierszu poleceń nie zawsze jest wygodne. Często chcielibyśmy wykonywać tę czynność ju w trakcie działania programu. Pomo e nam w tym instrukcja %QPUQNG4GCF.KPG , która zwraca wprowadzoną przez u ytkownika jedną linię tekstu (ciąg znaków zakończony znakiem końca linii). Ćwiczenie 3.22. Napisz program, który w pętli wczytuje kolejne wiersze tekstu wprowadzane przez u ytkownika i wyświetla je na ekranie. Program powinien zakończyć działanie po odczytaniu ciągu znaków quit. WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE XQKF /CKP ] UVTKPI U YJKNG U %QPUQNG4GCF.KPG 'SWCNU SWKV ] %QPUQNG9TKVG.KPG U _ _ _

42. Rozdział 3. Instrukcje 55 Warunek w pętli YJKNG zapisaliśmy w bardzo skondensowanej formie. Kolejność wykonywania instrukcji jest tu następująca: 1. Odczytanie linii znaków z konsoli (%QPUQNG4GCF.KPG ). 2. Przypisanie odczytanej wartości do zmiennej s (U). 3. Wywołanie metody 'SWCNU na rzecz obiektu wskazywanego przez s ('SWCNU SWKV ). Nale y w tym miejscu zwrócić równie uwagę, e taki zapis mo e w pewnych sytuacjach spowodować błąd w działaniu aplikacji, konkretnie wygenerowanie wyjątku 0WNN4GHG TGPEG'ZEGRVKQP. Dlaczego? Otó mo e się zdarzyć, e metoda 4GCF.KPG zamiast ciągu znaków zwróci wartość PWNN. W takim wypadku wartością przypisaną do zmiennej U rów- nie będzie PWNN. Skoro tak, nie będzie mo liwe wykonanie metody 'SWCNU, stąd te wygenerowanie wyjątku. Zapobiec takiej sytuacji mo na na dwa sposoby. Albo rozbijając warunek pętli YJKNG na klika oddzielnych instrukcji i sprawdzając, czy U nie jest równe PWNN, albo przez odwró- cenie kolejności wykonywania instrukcji, czyli zamiast pisać U %QPUQNG4GCF.KPG 'SWCNU SWKV mo na zastosować konstrukcję SWKV 'SWCNU U %QPUQNG4GCF.KPG Ćwiczenie 3.23. Popraw kod z ćwiczenia 3.22, usuwając warunek z pętli while, i przenieś go do wnętrza pętli. WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE XQKF /CKP ] UVTKPI U YJKNG VTWG] U %QPUQNG4GCF.KPG KH U PWNN U'SWCNU SWKV ] %QPUQNG9TKVG.KPG U _ GNUG] DTGCM _ _ _ _ Skoro potrafimy ju wykorzystywać instrukcję 4GCF.KPG , mo emy poprawić program do obliczania pierwiastków równania kwadratowego tak, aby parametry były wprowadzane w trakcie działania programu. Będzie on teraz prosił u ytkownika o podanie ko- lejnych liczb i podstawiał je pod zmienne RCTCOGVT#, RCTCOGVT$ i RCTCOGVT%.

43. 56 Część I Język programowania Oczywiście przed przypisaniem danych do wspomnianych zmiennych musimy dokonać konwersji z typu UVTKPI na typ KPV. Co jednak powinniśmy zrobić w sytuacji, kiedy u ytkownik nie poda prawidłowej liczby, ale, na przykład, wpisze dowolną kombinację znaków? Najlepiej byłoby poprosić o ponowne wprowadzenie parametru. Jak tego dokonać? Najwygodniej będzie skorzystać z pętli YJKNG lub FQ YJKNG i prosić u ytkownika o wprowadzanie liczby tak długo, dopóki nie poda poprawnej. Skoro jednak mamy trzy zmienne, a tym samym trzy parametry do wprowadzenia, nie ma sensu pisać trzech pętli wyglądających praktycznie tak samo. Lepiej utworzyć dodatkową funkcję, której zadaniem będzie właśnie dostarczenie prawidłowej liczby całkowitej wpro- wadzonej przez u ytkownika. Ćwiczenie 3.24. Napisz program obliczający pierwiastki równania kwadratowego, w którym parametry są wprowadzane w trakcie działania programu. WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE KPV RQDKGT.KEDG UVTKPI RCTCO ] KPV NKEDC DQQN UWMEGU FQ] %QPUQNG9TKVG.KPG 2TQUú RQFCè ]_ RCTCOGVT TÎYPCPKC RCTCO VT[] NKEDC +PV2CTUG %QPUQNG4GCF.KPG UWMEGU VTWG _ ECVEJ 'ZEGRVKQP] %QPUQNG9TKVG.KPG 2QFCP[ RCTCOGVT PKG LGUV RTCYKF QYæ åNKEDæ EC MQYKVæ UWMEGU HCNUG _ _ YJKNG UWMEGU TGVWTP NKEDC _ RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] KPV RCTCOGVT# RCTCOGVT$ RCTCOGVT% RCTCOGVT# RQDKGT.KEDG RKGTYU[ RCTCOGVT$ RQDKGT.KEDG FTWIK RCTCOGVT% RQDKGT.KEDG VTGEK %QPUQNG9TKVG.KPG 9RTQYCFQPG RCTCOGVT[ TÎYPCPKCP %QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVT$ % å RCTCOGVT% P KH RCTCOGVT# ] %QPUQNG9TKVG.KPG 6Q PKG LGUV TÎYPCPKG MYCFTCVQYG # _

44. Rozdział 3. Instrukcje 57 GNUG] FQWDNG FGNVC RCTCOGVT$

45. RCTCOGVT$

46. RCTCOGVT#

50. RCTCOGVT# %QPUQNG9TKVG.KPG Z Y[PKM _ _ _ _ Na tym w zasadzie moglibyśmy zakończyć ćwiczenia z wprowadzania danych i rozwią- zywania równań kwadratowych, ale spróbujmy wykonać jeszcze jeden przykład. Zauwa my bowiem, e wygodnie byłoby, aby nasz program umo liwiał zarówno podawanie para- metrów w wierszu poleceń, jak i w trakcie swojego działania. Dzięki temu u ytkownik mógłby wybrać bardziej wygodny dla niego sposób. Co więcej, jeśli przy podawaniu danych w wierszu poleceń pomyli się, aplikacja pozwoli na ponowne ich wprowadzenie. Musimy zatem połączyć kod z ćwiczenia 3.21 z kodem z ćwiczenia 3.24. Dodatkowo po- winniśmy wprowadzić jeszcze jedno usprawnienie. Do tej pory zakładaliśmy bowiem, e parametry równania muszą być liczbami rzeczywistymi. Nie ma jednak adnego powodu, aby dalej utrzymywać takie ograniczenie. Pozwólmy, aby nasza aplikacja potrafiła równie rozwiązywać równania, w których parametrami są liczby rzeczywiste. Dodatkowymi zmianami będzie więc zmiana typu zmiennych RCTCOGVT#, RCTCOGVT$ i RCTCOGVT% z KPV na FQWDNG oraz skorzystanie z metody 2CTUG klasy QWDNG. Ćwiczenie 3.25. Napisz program rozwiązujący równanie kwadratowe o zadanych parametrach, będących dowolnymi liczbami rzeczywistymi. Parametry mogą być wprowadzane zarówno w trakcie działania programu, jak i w wierszu poleceń. WUKPI 5[UVGO ENCUU 2KGTYKCUVGM ] RWDNKE UVCVKE FQWDNG RQDKGT.KEDG UVTKPI RCTCO ] FQWDNG NKEDC DQQN UWMEGU FQ]

51. 58 Część I Język programowania %QPUQNG9TKVG.KPG 2TQUú RQFCè ]_ RCTCOGVT TÎYPCPKC RCTCO VT[] NKEDC QWDNG2CTUG %QPUQNG4GCF.KPG UWMEGU VTWG _ ECVEJ 'ZEGRVKQP] %QPUQNG9TKVG.KPG 2QFCP[ RCTCOGVT PKG LGUV RTCYKF QYæ NKEDæ UWMEGU HCNUG _ _ YJKNG UWMEGU TGVWTP NKEDC _ RWDNKE UVCVKE XQKF /CKP UVTKPI=? CTIU ] DQQN NKPKC-QOGPF VTWG FQWDNG RCTCOGVT# RCTCOGVT$ RCTCOGVT% KH CTIU.GPIVJ ] NKPKC-QOGPF HCNUG _ KH NKPKC-QOGPF] VT[] RCTCOGVT# QWDNG2CTUG CTIU=? RCTCOGVT$ QWDNG2CTUG CTIU=? RCTCOGVT% QWDNG2CTUG CTIU=? _ ECVEJ 'ZEGRVKQP] %QPUQNG9TKVG.KPG ,GFGP YRTQYCFQP[EJ RCTCOGVTÎY åPKG LGUV RQRTCYPæ NKEDæ NKPKC-QOGPF HCNUG _ _ KH NKPKC-QOGPF] RCTCOGVT# RQDKGT.KEDG RKGTYU[ RCTCOGVT$ RQDKGT.KEDG FTWIK RCTCOGVT% RQDKGT.KEDG VTGEK _ %QPUQNG9TKVG.KPG 9RTQYCFQPG RCTCOGVT[ TÎYPCPKCP %QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVT$ å % RCTCOGVT% P KH RCTCOGVT# ] %QPUQNG9TKVG.KPG 6Q PKG LGUV TÎYPCPKG MYCFTCVQYG # _ GNUG] FQWDNG FGNVC RCTCOGVT$

52. RCTCOGVT$

53. RCTCOGVT#

55. RCTCOGVT# %QPUQNG9TKVG.KPG 4QYKæCPKG Z Y[PKM

56. Rozdział 3. Instrukcje 59 _ GNUG] Y[PKM RCTCOGVT$ /CVJ5STV FGNVC

58. RCTCOGVT# %QPUQNG9TKVG.KPG Z Y[PKM _ _ _ _ Nasz program potrafi ju skorzystać z liczb rzeczywistych (rysunek 3.9). Je eli w wierszu poleceń podane zostały trzy parametry i ka dy z nich jest prawidłową liczba całkowitą, zostaną one u yte do rozwiązania równania. Jeśli jednak parametrów jest mniej lub przy wprowadzaniu któregokolwiek z nich został popełniony błąd, aplikacja poprosi o ponowne ich wprowadzenie. Rysunek 3.9. Parametry równania mogą być podawane w postaci liczb rzeczywistych Nale y zwrócić uwagę, e sposób wprowadzania liczb z przecinkiem zale y od ustawień regionalnych systemu! Konkretnie od tego, jaki symbol został ustalony jako separator dzie- siętny. W przypadku ustawień polskich domyślnie jest to przecinek, przy ustawieniach an- gielskich — kropka.

C#. Ćwiczenia

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (13)

Similar to C#. Ćwiczenia

Similar to C#. Ćwiczenia (20)

More from Wydawnictwo Helion

More from Wydawnictwo Helion (20)

C#. Ćwiczenia