Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
01301 012100 11047067 na godz. na dobę w sumie
C#. Ćwiczenia - książka
C#. Ćwiczenia - książka
Autor: Liczba stron: 168
Wydawca: Helion Język publikacji: polski
ISBN: 83-7361-128-2 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).
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, co najlepsze w Javie i C++, a dodatkowo pozwala na wygodne korzystanie z klas wchodzących w skład platformy .NET.

Dzięki książce 'C#. Ćwiczenia' nauczysz się programować w C# niezależnie od tego, 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 prezentowanych zagadnień i nastawienie na praktykę programistyczną, a nie na rozważania teoretyczne.

Poznasz:

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

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREĎCI SPIS TREĎCI C#. Æwiczenia KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE Autor: Marcin Lis ISBN: 83-7361-128-2 Format: B5, stron: 166 ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOĎCIACH O NOWOĎCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Chopina 6 44-100 Gliwice tel. (32)230-98-63 e-mail: helion@helion.pl 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, co najlepsze w Javie i C++, a dodatkowo pozwala na wygodne korzystanie z klas wchodz¹cych w sk³ad platformy .NET. Dziêki ksi¹¿ce „C#. Æwiczenia” nauczysz siê programowaæ w C# niezale¿nie od tego, 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 prezentowanych zagadnieñ i nastawienie na praktykê programistyczn¹, a nie na rozwa¿ania teoretyczne. Poznasz: • Ďrodowisko uruchomieniowe C# i Visual Studio • 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 Spis treści Wstęp..............................................z...................................................z..........................................................5 Część I Język programowania ...................................................k................................................................ 7 Rozdział 1. Pierwsza aplikacja...................................................z.............................................................................9 Język C# ...................................................9...................................................9...................9 Środowisko uruchomieniowe...................................................9........................................ 10 Narzędzia ...................................................9...................................................9................11 Najprostszy program ...................................................9...................................................9 11 Kompilacja i uruchamianie...................................................9........................................... 12 Visual Studio ...................................................9...................................................9........... 13 Dyrektywa using ...................................................9...................................................9...... 16 Rozdział 2. Rozdział 3. Zmienne i typy danych...................................................z.....................................................................17 Typy danych...................................................9...................................................9............ 17 Typy arytmetyczne ...................................................9................................................ 17 Typ boolean...................................................9...................................................9....... 19 Deklarowanie zmiennych ...................................................9....................................... 19 Typy referencyjne ...................................................9................................................. 22 Typ string ...................................................9...................................................9.......... 23 Typ object ...................................................9...................................................9......... 23 Wartość null...................................................9...................................................9....... 23 Operatory...................................................9...................................................9................24 Operatory Arytmetyczne ...................................................9........................................ 24 Operatory bitowe...................................................9...................................................9 29 Operatory logiczne...................................................9................................................. 30 Operatory przypisania ...................................................9............................................ 30 Operatory porównania...................................................9............................................ 31 Operator warunkowy (?) ...................................................9........................................ 31 Priorytety operatorów ...................................................9............................................ 32 Komentarze ...................................................9...................................................9............. 32 Instrukcje...................................................z...................................................z.........................................35 Instrukcje warunkowe ...................................................9................................................. 35 Instrukcja if...else ...................................................9.................................................. 35 Instrukcja if...else if ...................................................9............................................... 38 Instrukcja switch ...................................................9...................................................9 39 Instrukcja goto...................................................9...................................................9......... 41 Pętle ...................................................9...................................................9....................... 43 Pętla for...................................................9...................................................9............. 43 Pętla while ...................................................9...................................................9......... 48 Pętla do while...................................................9...................................................9..... 49 4 C#. Ćwiczenia Wprowadzanie danych...................................................9................................................. 50 Argumenty wiersza poleceń...................................................9.................................... 51 Instrukcja ReadLine...................................................9............................................... 54 Rozdział 4. Programowanie obiektowe...................................................z..........................................................61 Klasy ...................................................9...................................................9...................... 61 Metody ...................................................9...................................................9...................63 Konstruktory ...................................................9...................................................9........... 69 Specyfikatory dostępu ...................................................9................................................. 71 Dziedziczenie ...................................................9...................................................9.......... 75 Rozdział 5. Tablice ...................................................z...................................................z.................................................77 Deklarowanie tablic...................................................9...................................................9.. 77 Inicjalizacja ...................................................9...................................................9............. 80 Pętla foreach........................................9...................................................9.......................81 Tablice wielowymiarowe ...................................................9............................................. 83 Rozdział 6. Wyjątki...................................................z...................................................z...............................................89 Rozdział 7. Obsługa błędów ...................................................9...................................................9....... 89 Blok try...catch ...................................................9...................................................9........ 93 Hierarchia wyjątków ...................................................9...................................................9 97 Własne wyjątki ...................................................9...................................................9........ 99 Interfejsy ...................................................z...................................................z.........................................101 Prosty interfejs...................................................9...................................................9....... 101 Interfejsy w klasach potomnych ...................................................9................................. 104 Czy to interfejs?...................................................9...................................................9..... 110 Rzutowanie ...................................................9...................................................9...... 113 Słowo kluczowe as ...................................................9.............................................. 115 Słowo kluczowe is ...................................................9............................................... 116 Część II Programowanie w Windows ...................................................k.............................................117 Rozdział 8. Pierwsze okno ...................................................z...................................................z...............................119 Utworzenie okna ...................................................9...................................................9.... 119 Wyświetlanie komunikatu ...................................................9.......................................... 122 Zdarzenie ApplicationExit..................................................9........................................... 123 Rozdział 9. Delegacje i zdarzenia...................................................z...................................................................125 Delegacje ...................................................9...................................................9.............. 125 Zdarzenia ...................................................9...................................................9.............. 128 Rozdział 10. Komponenty ...................................................z...................................................z..................................133 Etykiety (Label) ...................................................9...................................................9..... 133 Przyciski (klasa Button)...................................................9............................................. 137 Pola tekstowe (TextBox)...................................................9............................................ 140 Pola wyboru (CheckBox, RadioButton)...................................................9....................... 143 Listy rozwijalne (ComboBox) ...................................................9.................................... 146 Listy zwykłe (ListBox) ...................................................9.............................................. 149 Menu ...................................................9...................................................9.................... 151 Menu główne ...................................................9...................................................9... 151 Menu kontekstowe ...................................................9.............................................. 157 Właściwości Menu ...................................................9.............................................. 159 Skróty klawiaturowe ...................................................9............................................ 162 Rozdział 3. 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ľGPKGYCTWPMQYG ] +PUVTWMELGFQY[MQPCPKCLGľGNKYCTWPGMLGUVRTCYGF\KY[ _ GNUG] +PUVTWMELGFQY[MQPCPKCLGľGNKYCTWPGMLGUVHCđUG\[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. WUKPI5[UVGO ENCUU*GNNQ ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU 36 Część I (cid:1) Język programowania ] KPV\OKGPPCŌ KH \OKGPPC ]  QPUQNG9TKVG.KPG  OKGPPCLGUVOPKGLU\GCQF\GTC  _ GNUG]  QPUQNG9TKVG.KPG  OKGPPCPKGLGUVOPKGGLU\CQF\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: xA +∗+∧∗ CxB 2 = 0 , aby obliczyć jego rozwiązanie liczymy tzw. deltę (∆), która równa jest: B ∗−∧ 42 CA ∗ . Jeżeli delta jest większa od zera, mamy dwa pierwiastki: (1 x ∆+−= B 2) ∗ A 2 x ∆−−= 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 pier- wiastek 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.: KPVRKGTYU\C.KE\DC KPVFTWIC.KE\DC/CVJ5STV RKGTYU\C.KE\DC  QPUQNG9TKVG.KPG FTWIC.KE\DC  Rozdział 3. (cid:1) Instrukcje Ćwiczenie 3.2. 37 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). WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVRCTCOGVT#RCTCOGVT$ŌRCTCOGVT G  QPUQNG9TKVG.KPG 2CTCOGVT[TÎYPCPKC P   QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVGT$ å  RCTCOGVT   P  KH RCTCOGVT# ]  QPUQNG9TKVG.KPG 6QPKGLGUVTÎYPCPKGGMYCFTCVQYG#  _ GNUG] FQWDNGFGNVCRCTCOGVT$ RCTCOGVT$ŌG RCTCOGVT# RCTCOGVT  KH FGNVC ]  QPUQNG9TKVG.KPG  GNVC   QPUQNG9TKVG.KPG 6QTÎYPCPKGPKGGOCTQ\YKæ\CPKC åY\DKQT\GNKE\DT\GE\[YKUV[EJ  _ GNUG] FQWDNGY[PKM KH FGNVC ] Y[PKMŌRCTCOGVT$G RCTCOGVT#  QPUQNG9TKVG.KPG 4Q\YKGæ\CPKGZ Y[PKM  _ GNUG] Y[PKM ŌRCTCOGVT$ G/CVJ5STV FGNVC  å RCTCOGVT#  QPUQNG9TKVG 4Q\YKæ\CPGKGZ Y[PKM  Y[PKM ŌRCTCOGVT$ŌG/CVJ5STV FGNVC  å RCTCOGVT#  QPUQNG9TKVG.KPG ZG Y[PKM  _ _ _ _ _ Rysunek 3.1. Wynik działania programu obliczającego pierwiastki równania kwadratowego 38 Część I (cid:1) 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ŗGNUGKH. 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 _ GNUGKH YCTWPGM ] KPUVTWMELG _ GNUGKH YCTWPGM ] KPUVTWMELG _ GNUG] KPUVTWMELG _ Ćwiczenie 3.3. Zmodyfikuj program napisany w ćwiczeniu 3.2 tak, aby wykorzystywał on instrukcję if… else if. WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVRCTCOGVT#RCTCOGVT$ŌRCTCOGVT G  QPUQNG9TKVG.KPG 2CTCOGVT[TÎYPCPKC P   QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVGT$ å  RCTCOGVT   P  KH RCTCOGVT# ]  QPUQNG9TKVG.KPG 6QPKGLGUVTÎYPCPKGGMYCFTCVQYG#  Rozdział 3. (cid:1) Instrukcje 39 _ GNUG] FQWDNGFGNVCRCTCOGVT$ RCTCOGVT$ŌG RCTCOGVT# RCTCOGVT  FQWDNGY[PKM KH FGNVC ]  QPUQNG9TKVG.KPG  GNVC   QPUQNG9TKVG.KPG 6QTÎYPCPKGPKGGOCTQ\YKæ\CPKC åY\DKQT\GNKE\DT\GE\[YKUV[EJ  _ GNUGKH FGNVC ] Y[PKMŌRCTCOGVT$ RCTCOGGVT#  QPUQNG9TKVG.KPG 4Q\YKæ\CPKGZG Y[PKM  _ GNUG] Y[PKM ŌRCTCOGVT$ /CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG 4Q\YKæ\CPKGZ GY[PKM  Y[PKM ŌRCTCOGVT$Ō/CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG.KPG Z Y[PKMG  _ _ _ _ Instrukcja switch Jeżeli mamy do sprawdzenia wiele warunków, instrukcja UYKVEJ pozwoli nam wygodnie zastąpić ciągi instrukcji KHŗGNUGKH. Jeśli mamy następujący fragment kodu: KH C ] KPUVTWMELG _ GNUGKH C ] KPUVTWMELG _ GNUGKH C ] KPUVTWMELG _ GNUG] KPUVTWMELG _ możemy zastąpić poniższym: UYKVEJ C ] ECUG KPUVTWMELG DTGCM ECUG KPUVTWMELG DTGCM ECUG KPUVTWMELG DTGCM FGHCWNV KPUVTWMELG DTGCM _ 40 Część I (cid:1) 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 in- strukcji switch, sprawdź, czy wartość ta równa jest 1 lub 2. Wyświetl odpowiedni komu- nikat na ekranie. WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVC UYKVEJ C ] ECUG  QPUQNG9TKVG.KPG C  DTGCM ECUG  QPUQNG9TKVG.KPG C  DTGCM FGHCWNV  QPUQNG9TKVG.KPG  OKGPPCCPKGGLGUVTÎYPCCPKCPK  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 in- strukcji 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 kon- strukcji znajduje się przy opisie instrukcji IQVQ. Rysunek 3.2. Próba pominięcia instrukcji break kończy się błędem kompilacji Rozdział 3. (cid:1) 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 IQVQGV[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 KPVLLL ] KH L IQVQNCDGN _ HQT KPVKKK ] NCDGN _ Nic jednak nie stoi na przeszkodzie, aby zdefiniować etykietę przed lub za druga pętlą, pisząc: HQT KPVLLL ] KH L IQVQNCDGN _ NCDGN HQT KPVKKK ] _ 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. WUKPI5[UVGO RWDNKE ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP ] HQT KPVLLL ] HQT KPVKKK ] KH L  K  ] IQVQNCDGN _ _ _ TGVWTP NCDGN  QPUQNG9TKVG.KPG 2úVNC\QUVCđCRT\GTYCPC  _ _ 42 Część I (cid:1) 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đCRT\GTYCPC 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. WUKPI5[UVGO RWDNKE ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP ] 4CPFQOTPGY4CPFQO  KPVKT0GZV    QPUQNG9TKVG.KPG 9[NQUQYCPQYCTVQħèK K  UYKVEJ K ] ECUG  QPUQNG9TKVG.KPG KLGUVOPKGLGU\GQF  DTGCM ECUG IQVQECUG ECUG  QPUQNG9TKVG.KPG KLGUVOPKGLGU\GQF  IQVQFGHCWNV ECUG IQVQECUG ECUG IQVQECUG FGHCWNV  QPUQNG9TKVG.KPG 0KG\QUVCđY[GMQPCP[CPKDNQMECUG åCPKDNQMECUG  DTGCM _ _ _ Rozdział 3. (cid:1) 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 KPVKT0GZV  , 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: (cid:1) K jest równe  — wyświetlamy napis 0KG\QUVCđY[MQPCP[CPKDNQMECUG CPKDNQMECUG (cid:1) K jest równe  lub  — wyświetlamy napis KLGUVOPKGLU\GQF (cid:1) K jest równe ,  lub  — wyświetlamy napis KLGUVOPKGLU\GQF oraz 0KG\QUVCđY[MQPCP[CPKDNQMECUGCPKDNQMECUG 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ľGPKGRQE\æVMQYGY[TCľGPKGYCTWPMQYGY[TCľGGPKGOQF[HKMWLæEG ] KPUVTWMELGFQY[MQPCPKC _ 9[TCľGPKG RQE\æVMQYG jest stosowane do zainicjalizowania zmiennej używanej jako licznik ilości wykonań pętli. 9[TCľGPKGYCTWPMQYG 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. 44 Ćwiczenie 3.7. Część I (cid:1) Język programowania Wykorzystując pętlę typu for, napisz program wyświetlający na ekranie 100 razy napis C#. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] HQT KPVKKK ]  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ľGPKGRQE\æVMQYGY[TCľGPKGYCTWPMQYG ] KPUVTWMELGFQY[MQPCPKC Y[TCľGPKGOQF[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. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] HQT KPVKK ]  QPUQNG9TKVG    K  _ _ _ Rozdział 3. (cid:1) 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. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] HQT KPVKK  ]  QPUQNG9TKVG    _ _ _ W podobny sposób jak w poprzednich przykładach możemy się w pozbyć również wy- rażenia początkowego. Należy je przenieść przed pętlę. Schematyczna konstrukcja wy- gląda następująco: Y[TCľGPKGRQE\æVMQYG HQT Y[TCľGPKGYCTWPMQYG ] KPUVTWMELGFQY[MQPCPKC Y[TCľGPKGOQF[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. 46 Część I (cid:1) Język programowania WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVK 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. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVK 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. Rozdział 3. (cid:1) Instrukcje 47 WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] HQT KPVKKK ] 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ą podziel- ne 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. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] HQT KPVKKK ] KH K ]  QPUQNG9TKVG.KPG K  _ _ _ _ 48 Część I (cid:1) 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 przy- padku 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ľGPKGYCTWPMQYG ] 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#. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVK 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. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVK YJKNG K  ]  QPUQNG9TKVG    _ _ _ Rozdział 3. (cid:1) Instrukcje Ćwiczenie 3.16. 49 Korzystając z pętli while, napisz program wyświetlający na ekranie liczby od 1 do 20 niepodzielne przez 2. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVK 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 nie- podzielne 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#. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVK FQ]  QPUQNG9TKVG    50 Część I (cid:1) 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 in- strukcje 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. WUKPI5[UVGO ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVK 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. Rozdział 3. (cid:1) 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: RWDNKEUVCVKEXQKFOCKP 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ń. WUKPI5[UVGO RWDNKE ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ]  QPUQNG9TKVG.KPG .KE\DCYRTQYCF\QP[EJCTIWOGPVGÎY]_CTIU.GPIVJ  HQT KPVKKCTIU.GPIVJK ]  QPUQNG9TKVG.KPG RCTCOGVT=]_?]_KGCTIU=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ń 52 Część I (cid:1) Język programowania Przy pracy z argumentami przekazywanymi z wiersza poleceń napotkamy na pewien pro- blem. 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: WUKPI5[UVGO RWDNKE ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KH CTIU.GPIVJ ]  QPUQNG9TKVG.KPG 0CNGľ[RQFCèFYCCTIWGOGPV[YYKGTU\WRQNGEGē  TGVWTP _  QPUQNG9TKVG.KPG 9[PKMKGOF\KCđCPKCLGUV]_GCTIU=? 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 NKE\DC  Ćwiczenie 3.20. Napisz program dokonujący dodawania dwóch liczb podanych jako parametry w wierszu poleceń. WUKPI5[UVGO RWDNKE ENCUUOCKP ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVCD KH CTIU.GPIVJ ]  QPUQNG9TKVG.KPG 0CNGľ[RQFCèFYCCTIWGOGPV[YYKGTU\WRQNGEGē  TGVWTP _ VT[] C+PV2CTUG CTIU=?  D+PV2CTUG CTIU=?  _ ECVEJ ZEGRVKQP ]  QPUQNG9TKVG.KPG ,GFGP\CTIWOGPVÎYPKGGLGUVRQRTCYPæNKE\Dæ  TGVWTP _  QPUQNG9TKVG.KPG 9[PKMKGOF\KCđCPKCLGUV]_GC D  _ _ Rozdział 3. (cid:1) 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 pier- wiastki 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). WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVRCTCOGVT#RCTCOGVT$RCTCOGVT  KH CTIU.GPIVJ ]  QPUQNG9TKVG.KPG 9[YQđCPKGRTQITCOWRGTQITCORCTCOGVT åRCTCOGVTRCTCOGVT  TGVWTP _ VT[] RCTCOGVT#+PV2CTUG CTIU=?  RCTCOGVT$+PV2CTUG CTIU=?  RCTCOGVT +PV2CTUG CTIU=?  _ ECVEJ ZEGRVKQP ]  QPUQNG9TKVG.KPG ,GFGP\RCTCOGVTÎYTÎYGPCPKCPKGLGUVRQRTCYPæ åNKE\DæECđMQYKVæ  TGVWTP _  QPUQNG9TKVG.KPG 9RTQYCF\QPGRCTCOGVT[TÎYPCPGKC P   QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVGT$   å RCTCOGVT   P  KH RCTCOGVT# ]  QPUQNG9TKVG.KPG 6QPKGLGUVTÎYPCPKGGMYCFTCVQYG#  _ GNUG] FQWDNGFGNVCRCTCOGVT$ RCTCOGVT$ŌG RCTCOGVT# RCTCOGVT  FQWDNGY[PKM KH FGNVC ]  QPUQNG9TKVG.KPG  GNVC  54 Część I (cid:1) Język programowania  QPUQNG9TKVG.KPG 6QTÎYPCPKGPKGGOCTQ\YKæ\CPKCY\DKQT\G åNKE\DT\GE\[YKUV[EJ  _ GNUGKH FGNVC ] Y[PKMŌRCTCOGVT$ RCTCOGGVT#  QPUQNG9TKVG.KPG 4Q\YKæ\CPKGZG Y[PKM  _ GNUG] Y[PKM ŌRCTCOGVT$ /CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG 4Q\YKæ\CPKGZ GY[PKM  Y[PKM ŌRCTCOGVT$Ō/CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG.KPG Z Y[PKMG  _ _ _ _ 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żyt- kownika i wyświetla je na ekranie. Program powinien zakończyć działanie po odczytaniu ciągu znaków quit. WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEXQKF/CKP ] UVTKPIU YJKNG  U QPUQNG4GCF.KPG  SWCNU SWKV ]  QPUQNG9TKVG.KPG U  _ _ _ Rozdział 3. (cid:1) Instrukcje 55 Warunek w pętli YJKNG zapisaliśmy w bardzo skondensowanej formie. Kolejność wyko- nywania 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ż wy- generowanie 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. WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEXQKF/CKP ] UVTKPIU YJKNG VTWG ] U QPUQNG4GCF.KPG  KH UPWNNU 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 wprowa- dzane 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 . 56 Część I (cid:1) 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 wpro- wadzanie 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. WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEKPVRQDKGT\.KE\DG UVTKPIRCTCO ] KPVNKE\DC DQQNUWMEGU FQ]  QPUQNG9TKVG.KPG 2TQU\úRQFCè]_RCTCOGGVTTÎYPCPKCRCTCO  VT[] NKE\DC+PV2CTUG QPUQNG4GCF.KGPG  UWMEGUVTWG _ ECVEJ ZEGRVKQP ]  QPUQNG9TKVG.KPG 2QFCP[RCTCOGGVTPKGLGUVRTCYKFđQYæ åNKE\DæECđMQYKVæ  UWMEGUHCNUG _ _ YJKNG UWMEGU  TGVWTPNKE\DC _ RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] KPVRCTCOGVT#RCTCOGVT$RCTCOGVT  RCTCOGVT#RQDKGT\.KE\DG RKGTYU\[  RCTCOGVT$RQDKGT\.KE\DG FTWIK  RCTCOGVT RQDKGT\.KE\DG VT\GEK   QPUQNG9TKVG.KPG 9RTQYCF\QPGRCTCOGVT[TÎYPCPGKC P   QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVGT$   å RCTCOGVT   P  KH RCTCOGVT# ]  QPUQNG9TKVG.KPG 6QPKGLGUVTÎYPCPKGGMYCFTCVQYG#  _ Rozdział 3. (cid:1) Instrukcje 57 GNUG] FQWDNGFGNVCRCTCOGVT$ RCTCOGVT$ŌG RCTCOGVT# RCTCOGVT  FQWDNGY[PKM KH FGNVC ]  QPUQNG9TKVG.KPG  GNVC   QPUQNG9TKVG.KPG 6QTÎYPCPKGPKGGOCTQ\YKæ\CPKC åY\DKQT\GNKE\DT\GE\[YKUV[EJ  _ GNUGKH FGNVC ] Y[PKMŌRCTCOGVT$ RCTCOGGVT#  QPUQNG9TKVG.KPG 4Q\YKæ\CPKGZG Y[PKM  _ GNUG] Y[PKM ŌRCTCOGVT$ /CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG 4Q\YKæ\CPKGZ GY[PKM  Y[PKM ŌRCTCOGVT$Ō/CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG.KPG Z Y[PKMG  _ _ _ _ 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 da- nych 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ń. WUKPI5[UVGO ENCUU2KGTYKCUVGM ] RWDNKEUVCVKEFQWDNGRQDKGT\.KE\DG UVTKPIRCTCO ] FQWDNGNKE\DC DQQNUWMEGU FQ] 58 Część I (cid:1) Język programowania  QPUQNG9TKVG.KPG 2TQU\úRQFCè]_RCTCOGGVTTÎYPCPKCRCTCO  VT[] NKE\DC QWDNG2CTUG QPUQNG4GCFG.KPG  UWMEGUVTWG _ ECVEJ ZEGRVKQP ]  QPUQNG9TKVG.KPG 2QFCP[RCTCOGVTPKGLGUVRTCYKFđQYæNKE\Dæ  UWMEGUHCNUG _ _ YJKNG UWMEGU  TGVWTPNKE\DC _ RWDNKEUVCVKEXQKF/CKP UVTKPI=?CTIU ] DQQNNKPKC-QOGPFVTWG FQWDNGRCTCOGVT#RCTCOGVT$RCTCOGVT G KH CTIU.GPIVJ ] NKPKC-QOGPFHCNUG _ KH NKPKC-QOGPF ] VT[] RCTCOGVT# QWDNG2CTUG CTIU=?  RCTCOGVT$ QWDNG2CTUG CTIU=?  RCTCOGVT  QWDNG2CTUG CTIU=?  _ ECVEJ ZEGRVKQP ]  QPUQNG9TKVG.KPG ,GFGP\YRTQYGCF\QP[EJRCTCOGVTÎY åPKGLGUVRQRTCYPæNKE\Dæ  NKPKC-QOGPFHCNUG _ _ KH NKPKC-QOGPF ] RCTCOGVT#RQDKGT\.KE\DG RKGTYU\[  RCTCOGVT$RQDKGT\.KE\DG FTWIK  RCTCOGVT RQDKGT\.KE\DG VT\GEK  _  QPUQNG9TKVG.KPG 9RTQYCF\QPGRCTCOGVT[TÎYPCPGKC P   QPUQNG9TKVG.KPG # RCTCOGVT# $ RCTCOGVGT$ å  RCTCOGVT   P  KH RCTCOGVT# ]  QPUQNG9TKVG.KPG 6QPKGLGUVTÎYPCPKGGMYCFTCVQYG#  _ GNUG] FQWDNGFGNVCRCTCOGVT$ RCTCOGVT$ŌG RCTCOGVT# RCTCOGVT  FQWDNGY[PKM KH FGNVC ]  QPUQNG9TKVG.KPG  GNVC   QPUQNG9TKVG.KPG 6QTÎYPCPKGPKGGOCTQ\YKæ\CPKC åY\DKQT\GNKE\DT\GE\[YKUV[EJ  _ GNUGKH FGNVC ] Y[PKMŌRCTCOGVT$ RCTCOGGVT#  QPUQNG9TKVG.KPG 4Q\YKæ\CPKGZG Y[PKM  Rozdział 3. (cid:1) Instrukcje 59 _ GNUG] Y[PKM ŌRCTCOGVT$ /CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG 4Q\YKæ\CPKGZ GY[PKM  Y[PKM ŌRCTCOGVT$Ō/CVJ5STV GFGNVC  RCTCOGVT#  QPUQNG9TKVG.KPG Z Y[PKMG  _ _ _ _ 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.
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

C#. Ćwiczenia
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ą: