Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00220 004927 13084020 na godz. na dobę w sumie
C#. Ćwiczenia. Wydanie IV - książka
C#. Ćwiczenia. Wydanie IV - książka
Autor: Liczba stron: 264
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-283-1455-9 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c# - programowanie
Porównaj ceny (książka, ebook, audiobook).

Poznaj C# — to Ci się przyda!

C# to obiektowy język programowania, dość podobny do Javy i C++, choć jednocześnie nieco prostszy, a jego możliwości są naprawdę imponujące. Coraz większa popularność i wygoda jego używania sprawiają, że programiści chętnie sięgają po to narzędzie. Niezależnie od tego, czy umiesz już programować w Javie i C++ czy dopiero przystępujesz do nauki programowania, ta książka pomoże Ci szybko opanować najważniejsze elementy C#!

Znajdziesz tu bez mała półtorej setki ćwiczeń, które pozwolą Ci zrozumieć, jak używać zmiennych i operatorów, stosować instrukcje i wprowadzać dane. Zobaczysz, jak deklarować klasy i tablice, zapewniać obsługę wyjątków i błędów, tworzyć obiekty i całe, działające aplikacje — konsolowe i z graficznym interfejsem użytkownika. Możesz to zrobić w sposób całkowicie praktyczny i od razu zobaczyć efekty swoich działań. Sprawdź, jakie cuda da się stworzyć w języku C# i wykorzystaj tę wiedzę w swojej pracy!

Przećwicz C# i zacznij w nim programować!

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

Darmowy fragment publikacji:

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Opieka redakcyjna: Ewelina Burska Projekt okładki: Studio Gravite/Olsztyn Obarek, Pokoński, Pazdrijowski, Zaprucki Materiały graficzne na okładce zostały wykorzystane za zgodą Shutterstock. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/cwcsh4 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. ISBN: 978-83-283-1455-9 Copyright © Helion 2016 Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:282)ci Rozdzia(cid:257) 1. Rozdzia(cid:257) 2. Wst(cid:216)p Cz(cid:216)(cid:282)(cid:198) I J(cid:216)zyk programowania Pierwsza aplikacja J(cid:218)zyk C# Jak w(cid:239)a(cid:258)ciwie nazywa si(cid:218) ten j(cid:218)zyk? (cid:165)rodowisko uruchomieniowe Narz(cid:218)dzia Najprostszy program Kompilacja i uruchamianie Visual Studio Dyrektywa using Zmienne i typy danych Typy danych Operatory Komentarze 3 7 11 11 12 12 14 15 16 20 24 25 25 37 50 Poleć książkęKup książkę 4 Rozdzia(cid:257) 3. C# • (cid:193)wiczenia Instrukcje Instrukcje warunkowe P(cid:218)tle Instrukcja goto Wprowadzanie danych Rozdzia(cid:257) 4. Rozdzia(cid:257) 5. Cz(cid:216)(cid:282)(cid:198) II Programowanie obiektowe Klasy i obiekty Klasy Metody Konstruktory Specyfikatory dost(cid:218)pu Dziedziczenie S(cid:239)owo kluczowe this Tablice Deklarowanie tablic Inicjalizacja tablic Rozmiar tablicy P(cid:218)tla foreach Tablice wielowymiarowe Rozdzia(cid:257) 6. Wyj(cid:196)tki i obs(cid:257)uga b(cid:257)(cid:216)dów Obs(cid:239)uga b(cid:239)(cid:218)dów Blok try…catch Hierarchia wyj(cid:200)tków W(cid:239)asne wyj(cid:200)tki Sekcja finally Filtrowanie wyj(cid:200)tków Interfejsy Prosty interfejs Interfejsy w klasach potomnych Czy to interfejs? Rozdzia(cid:257) 7. 53 53 61 72 76 93 93 96 109 113 120 124 127 128 130 132 135 138 145 145 151 157 160 163 165 169 169 173 180 Poleć książkęKup książkę Spis tre(cid:282)ci Rozdzia(cid:257) 8. Cz(cid:216)(cid:282)(cid:198) III Programowanie w Windows Pierwsze okno Utworzenie okna Wy(cid:258)wietlanie komunikatu Zdarzenie ApplicationExit Rozdzia(cid:257) 9. Delegacje i zdarzenia Czym s(cid:200) delegacje? Jak obs(cid:239)ugiwa(cid:202) zdarzenia? Rozdzia(cid:257) 10. Komponenty Etykiety (Label) Przyciski (Button) Pola tekstowe (TextBox) Pola wyboru (CheckBox, RadioButton) Listy rozwijane (ComboBox) Listy zwyk(cid:239)e (ListBox) Menu 5 193 193 197 199 201 201 206 213 213 219 222 226 232 235 238 Poleć książkęKup książkę 6 C# • (cid:193)wiczenia Poleć książkęKup książkę 5 Tablice Tablice to jedne z podstawowych struktur danych; znane s(cid:200) zapewne nawet pocz(cid:200)tkuj(cid:200)cym programistom. Warto jednak w kilku s(cid:239)owach przypomnie(cid:202) podstawowe wiadomo(cid:258)ci i poj(cid:218)cia z nimi zwi(cid:200)zane. Ta- blica to stosunkowo prosta struktura danych pozwalaj(cid:200)ca na przecho- wanie uporz(cid:200)dkowanego zbioru elementów danego typu — mo(cid:285)na j(cid:200) sobie wyobrazi(cid:202) tak, jak zaprezentowano na rysunku 5.1. Sk(cid:239)ada si(cid:218) z ponumerowanych kolejno komórek, a ka(cid:285)da taka komórka mo(cid:285)e prze- chowywa(cid:202) pewn(cid:200) porcj(cid:218) danych. Rysunek 5.1. Schemat struktury tablicy Jakiego rodzaju b(cid:218)d(cid:200) to dane, okre(cid:258)la typ tablicy. Je(cid:258)li zatem zadekla- rujemy tablic(cid:218) typu ca(cid:239)kowitoliczbowego (int), b(cid:218)dzie mog(cid:239)a ona za- wiera(cid:202) liczby ca(cid:239)kowite, a je(cid:258)li b(cid:218)dzie to typ znakowy (char), poszcze- gólne komórki b(cid:218)d(cid:200) mog(cid:239)y zawiera(cid:202) ró(cid:285)ne znaki. Nale(cid:285)y zwróci(cid:202) uwag(cid:218), (cid:285)e w C# (podobnie jak w wi(cid:218)kszo(cid:258)ci wspó(cid:239)czesnych popu- larnych j(cid:218)zyków programowania) numerowanie komórek zaczyna si(cid:218) od 0, czyli pierwsza komórka ma indeks 0, druga — indeks 1 itd. 127 Poleć książkęKup książkę 128 C# • (cid:193) wiczenia Deklarowanie tablic Przed skorzystaniem z tablicy nale(cid:285)y zadeklarowa(cid:202) zmienn(cid:200) tabli- cow(cid:200). Poniewa(cid:285) w C# tablice s(cid:200) obiektami, nale(cid:285)y równie(cid:285) utworzy(cid:202) odpowiedni obiekt. Schematycznie robi si(cid:218) to w sposób nast(cid:218)puj(cid:200)cy: typ_tablicy[] nazwa_tablicy = new typ_tablicy[liczba_elementów]; Deklaracj(cid:218) zmiennej tablicowej oraz przypisanie jej nowo utworzonego elementu mo(cid:285)na przy tym wykona(cid:202) w osobnych instrukcjach, np. w ten sposób: typ_tablicy[] nazwa_tablicy; // tutaj mog(cid:261) si(cid:266) znale(cid:296)(cid:252) inne instrukcje nazwa_tablicy = new typ_tablicy[liczba_elementów]; Pisz(cid:200)c zatem: int tablica[]; zadeklarujemy odniesienie do tablicy, która b(cid:218)dzie mog(cid:239)a zawiera(cid:202) elementy typu int, czyli 32-bitowe liczby ca(cid:239)kowite. Samej tablicy jed- nak jeszcze nie b(cid:218)dzie (odwrotnie ni(cid:285) w przypadku prostych typów warto(cid:258)ciowych, takich jak int, byte czy char) i konieczne jest jej utwo- rzenie. (cid:109) W I C Z E N I E 5.1 Utworzenie tablicy Zadeklaruj i zainicjalizuj tablic(cid:218) elementów typu ca(cid:239)kowitego. Przypisz pierwszemu elementowi tablicy dowoln(cid:200) warto(cid:258)(cid:202). Wy(cid:258)wietl zawarto(cid:258)(cid:202) tego elementu na ekranie. using System; public class Program { public static void Main() { int[] tablica = new int[5]; tablica[0] = 10; Console.WriteLine( Pierwszy element tablicy: + tablica[0]); } } Wyra(cid:285)enie new tablica[5] oznacza utworzenie nowej, jednowymiaro- wej, 5-elementowej tablicy liczb typu int. Ta nowa tablica zosta(cid:239)a przy- Poleć książkęKup książkę Rozdzia(cid:253) 5. • Tablice 129 pisana zmiennej odno(cid:258)nikowej o nazwie tablica. Od miejsca tego przypisania mo(cid:285)na odwo(cid:239)ywa(cid:202) si(cid:218) do kolejnych elementów tej tablicy, pisz(cid:200)c: tablica[index] W tym przypadku pierwszemu elementowi (o indeksie 0) zosta(cid:239)a przy- pisana warto(cid:258)(cid:202) 10. O tym, (cid:285)e takie przypisanie faktycznie mia(cid:239)o miej- sce, przekonali(cid:258)my si(cid:218), wy(cid:258)wietlaj(cid:200)c warto(cid:258)(cid:202) tej komórki na ekranie. Warto w tym miejscu ponownie przypomnie(cid:202), (cid:285)e elementy tablicy numerowane s(cid:200) od 0, a nie od 1. Oznacza to, (cid:285)e pierwszy element ta- blicy 10-elementowej ma indeks 0, a ostatni 9 (nie 10!). Co si(cid:218) stanie, je(cid:258)li nieprzyzwyczajeni do takiego sposobu indeksowania odwo(cid:239)amy si(cid:218) do indeksu o numerze 10? (cid:109) W I C Z E N I E 5.2 Odwo(cid:239)anie do nieistniej(cid:200)cego elementu tablicy Zadeklaruj i zainicjalizuj tablic(cid:218) 10-elementow(cid:200). Spróbuj przypisa(cid:202) elementowi o indeksie 10 dowoln(cid:200) liczb(cid:218) ca(cid:239)kowit(cid:200). using System; public class Program { public static void Main() { int[] tablica = new int[10]; tablica[10] = 1; Console.WriteLine( Element o indeksie 10 to: + tablica[10]); } } Powy(cid:285)szy kod da si(cid:218) bez problemu skompilowa(cid:202), jednak przy próbie uruchomienia takiego programu na ekranie zobaczymy okno z infor- macj(cid:200) o wyst(cid:200)pieniu b(cid:239)(cid:218)du. Mo(cid:285)e ono mie(cid:202) ró(cid:285)n(cid:200) posta(cid:202), w zale(cid:285)no(cid:258)ci od tego, w jakiej wersji systemu zosta(cid:239)a uruchomiona aplikacja. Na rysunku 5.2 jest widoczne okno z systemu Windows 8. Równie(cid:285) na kon- soli (w Windows XP dopiero po zamkni(cid:218)ciu okna dialogowego) uj- rzymy komunikat podaj(cid:200)cy konkretne informacje o typie b(cid:239)(cid:218)du oraz miejscu programu, w którym wyst(cid:200)pi(cid:239) (rysunek 5.3). Poleć książkęKup książkę 130 C# • (cid:193) wiczenia Rysunek 5.2. Próba odwo(cid:239)ania si(cid:218) do nieistniej(cid:200)cego elementu tablicy powoduje b(cid:239)(cid:200)d aplikacji Rysunek 5.3. Systemowa informacja o b(cid:239)(cid:218)dzie Wbrew pozorom nie sta(cid:239)o si(cid:218) nic strasznego. Program co prawda nie dzia(cid:239)a, ale b(cid:239)(cid:200)d zosta(cid:239) wychwycony przez (cid:258)rodowisko uruchomienio- we. Konkretnie mówi(cid:200)c, zosta(cid:239) wygenerowany tzw. wyj(cid:200)tek i aplikacja zako(cid:241)czy(cid:239)a dzia(cid:239)anie. Taki wyj(cid:200)tek mo(cid:285)na jednak przechwyci(cid:202) i tym samym zapobiec niekontrolowanemu zako(cid:241)czeniu wykonywania kodu. To jednak odr(cid:218)bny temat, który zostanie przedstawiony w rozdziale 6. Wa(cid:285)ne jest to, (cid:285)e próba odwo(cid:239)ania si(cid:218) do nieistniej(cid:200)cego elementu zo- sta(cid:239)a wykryta i to odwo(cid:239)anie nie wyst(cid:200)pi(cid:239)o! Program nie naruszy(cid:239) wi(cid:218)c obszaru pami(cid:218)ci niezarezerwowanej dla niego. Inicjalizacja tablic Tablic(cid:218) mo(cid:285)na zainicjalizowa(cid:202) ju(cid:285) w momencie jej tworzenia. Dane, które maj(cid:200) si(cid:218) znale(cid:283)(cid:202) w poszczególnych komórkach, podaje si(cid:218) w na- wiasie klamrowym po deklaracji tablicy. Schematycznie wygl(cid:200)da to nast(cid:218)puj(cid:200)co: typ[] nazwa = new typ [liczba_elementów]{dana1, dana2,…,danaN} Je(cid:258)li zatem chcieliby(cid:258)my utworzy(cid:202) 5-elementow(cid:200) tablic(cid:218) liczb ca(cid:239)kowi- tych i od razu zainicjalizowa(cid:202) j(cid:200) liczbami od 1 do 5, mo(cid:285)emy zrobi(cid:202) to w taki sposób: int[] tablica = new int[5] {1, 2, 3, 4, 5}; Poleć książkęKup książkę Rozdzia(cid:253) 5. • Tablice 131 (cid:109) W I C Z E N I E 5.3 Inicjalizacja tablicy Zadeklaruj tablic(cid:218) 5-elementow(cid:200) typu int i zainicjalizuj j(cid:200) liczbami od 1 do 5. Zawarto(cid:258)(cid:202) tablicy wy(cid:258)wietl na ekranie. using System; public class Program { public static void Main() { int[] tablica = new int[5]{1, 2, 3, 4, 5}; for(int i = 0; i 5; i++) { Console.WriteLine( tablica[{0}] = {1} , i, tablica[i]); } } } Wynik dzia(cid:239)ania kodu z powy(cid:285)szego (cid:202)wiczenia widoczny jest na ry- sunku 5.4. Nie jest niespodziank(cid:200), (cid:285)e wy(cid:258)wietlone zosta(cid:239)y liczby od 1 do 5, natomiast indeksy kolejnych komórek zmieniaj(cid:200) si(cid:218) od 0 do 4. Powsta(cid:239)a tu bowiem 5-elementowa tablica liczb typu int. Skoro ma 5 elementów, to pierwszy z nich ma indeks 0, a ostatni — 4. Dlatego zmienna steruj(cid:200)ca p(cid:218)tli for, która odczytuje dane z tablicy, ma pocz(cid:200)t- kow(cid:200) warto(cid:258)(cid:202) 0, a warunek zako(cid:241)czenia p(cid:218)tli to i 5. Tym samym i zmienia si(cid:218) te(cid:285) od 0 do 4. Rysunek 5.4. Zawarto(cid:258)(cid:202) kolejnych komórek tablicy utworzonej w (cid:202)wiczeniu 5.3 Kiedy inicjalizowana jest tablica o z góry znanej liczbie elementów, dopuszcza si(cid:218) pomini(cid:218)cie fragmentu kodu zwi(cid:200)zanego z tworzeniem obiektu. Kompilator sam wykona odpowiednie uzupe(cid:239)nienia. Zamiast pisa(cid:202): typ[] nazwa = new typ [liczba_elementów]{dana1, dana2,…,danaN} Poleć książkęKup książkę 132 C# • (cid:193) wiczenia mo(cid:285)na zatem równie dobrze u(cid:285)y(cid:202) konstrukcji: typ[] nazwa = {dana1, dana2,…,danaN} Oba sposoby s(cid:200) równowa(cid:285)ne i nale(cid:285)y u(cid:285)ywa(cid:202) tego, który jest wy- godniejszy. (cid:109) W I C Z E N I E 5.4 Bezpo(cid:258)rednia inicjalizacja tablicy Zadeklaruj tablic(cid:218) 5-elementow(cid:200) typu int i zainicjalizuj j(cid:200) liczbami od 6 do 2. U(cid:285)yj drugiego z poznanych sposobów inicjalizacji. Zawar- to(cid:258)(cid:202) tablicy wy(cid:258)wietl na ekranie. using System; public class Program { public static void Main() { int[] tablica = {6, 5, 4, 3, 2}; for(int i = 0; i 5; i++) { Console.WriteLine( tablica[{0}] = {1} , i, tablica[i]); } } } Rozmiar tablicy Ka(cid:285)da tablica posiada w(cid:239)a(cid:258)ciwo(cid:258)(cid:202) Length, która okre(cid:258)la bie(cid:285)(cid:200)c(cid:200) liczb(cid:218) komórek. Aby uzyska(cid:202) t(cid:218) informacj(cid:218), piszemy: tablica.Length Przy tym dopuszczalny jest tylko odczyt, czyli prawid(cid:239)owa jest kon- strukcja: int rozmiar = tablica.Length; ale nieprawid(cid:239)owy jest zapis: tablica.Length = 10; Poleć książkęKup książkę Rozdzia(cid:253) 5. • Tablice 133 (cid:109) W I C Z E N I E 5.5 Odczyt rozmiaru tablicy Utwórz tablic(cid:218) o dowolnym rozmiarze. Odczytaj warto(cid:258)(cid:202) w(cid:239)a(cid:258)ciwo(cid:258)ci Length i wy(cid:258)wietl j(cid:200) na ekranie. using System; public class Program { public static void Main() { int[] tablica = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 }; Console.Write( Liczba elementów tablicy: ); Console.WriteLine(tablica.Length); } } (cid:109) W I C Z E N I E 5.6 W(cid:239)a(cid:258)ciwo(cid:258)(cid:202) Length i p(cid:218)tla for Utwórz tablic(cid:218) zawieraj(cid:200)c(cid:200) pewn(cid:200) liczb(cid:218) warto(cid:258)ci ca(cid:239)kowitych. Za- warto(cid:258)(cid:202) tablicy wy(cid:258)wietl na ekranie za pomoc(cid:200) p(cid:218)tli for. Do okre(cid:258)lenia rozmiaru tablicy u(cid:285)yj w(cid:239)a(cid:258)ciwo(cid:258)ci Length. using System; public class Program { public static void Main() { int[] tab = { 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; for(int i = 0; i tab.Length; i++) { Console.WriteLine( tab[ + i + ] = + tab[i]); } } } Zasada odczytu danych w tym przyk(cid:239)adzie jest taka sama jak w (cid:202)wi- czeniach 5.3 i 5.4, z t(cid:200) ró(cid:285)nic(cid:200), (cid:285)e rozmiar tablicy jest okre(cid:258)lany za Poleć książkęKup książkę 134 C# • (cid:193) wiczenia pomoc(cid:200) w(cid:239)a(cid:258)ciwo(cid:258)ci Length (tab.Length). Dzi(cid:218)ki temu mo(cid:285)na np. do- pisa(cid:202) dowoln(cid:200) liczb(cid:218) nowych danych w instrukcji inicjalizuj(cid:200)cej ta- blic(cid:218), a kod p(cid:218)tli for nie b(cid:218)dzie wymaga(cid:239) (cid:285)adnych zmian. Nowy rozmiar zostanie uwzgl(cid:218)dniony automatycznie. Do zapisywania danych (podobnie jak do odczytu) w tablicach cz(cid:218)- sto u(cid:285)ywa si(cid:218) p(cid:218)tli (przedstawionych w rozdziale 2.). Jest to wr(cid:218)cz niezb(cid:218)dne, gdy(cid:285) trudno si(cid:218) spodziewa(cid:202), (cid:285)e mo(cid:285)na by(cid:239)oby „r(cid:218)cznie” zapisa(cid:202) warto(cid:258)ci z wi(cid:218)cej ni(cid:285) kilkunastu czy kilkudziesi(cid:218)ciu komórek. Wielko(cid:258)(cid:202) tablicy nie musi te(cid:285) by(cid:202) z góry znana, mo(cid:285)e wynika(cid:202) z danych uzyskanych w trakcie dzia(cid:239)ania programu. Z tablicami mog(cid:200) wspó(cid:239)- pracowa(cid:202) dowolne rodzaje p(cid:218)tli. W niektórych przypadkach bardzo wy- godna jest omówiona w kolejnym podrozdziale p(cid:218)tla foreach. (cid:109) W I C Z E N I E 5.7 U(cid:285)ycie p(cid:218)tli do zapisu danych w tablicy U(cid:285)yj p(cid:218)tli for do zapisania w 10-elementowej tablicy 10 kolejnych liczb ca(cid:239)kowitych. using System; public class Program { public static void Main() { int[] tab = new int[10]; for(int i = 0; i tab.Length; i++) { tab[i] = i + 1; } Console.WriteLine( Zawarto(cid:258)(cid:202) tablicy: ); for(int i = 0; i tab.Length; i++) { Console.WriteLine( tab[{0}] = {1} , i, tab[i]); // w C# 6.0 mo(cid:298)na równie(cid:298) tak //Console.WriteLine($ tab[{i}] = {tab[i]} ); } } } Powsta(cid:239)a 10-elementowa tablica liczb typu int. Mamy w niej zapisa(cid:202) warto(cid:258)ci od 1 do 10, czyli komórka o indeksie 0 ma mie(cid:202) warto(cid:258)(cid:202) 1, o indeksie 1 — warto(cid:258)(cid:202) 2 itd. A zatem warto(cid:258)(cid:202) komórki ma by(cid:202) zawsze Poleć książkęKup książkę Rozdzia(cid:253) 5. • Tablice 135 o 1 wi(cid:218)ksza ni(cid:285) warto(cid:258)(cid:202) indeksu (zmiennej i). Dlatego instrukcja we- wn(cid:200)trz p(cid:218)tli ma posta(cid:202): tab[i] = i + 1; Druga p(cid:218)tla for s(cid:239)u(cid:285)y tylko do wy(cid:258)wietlania danych zawartych w ta- blicy. Jej konstrukcja jest taka sama jak w pierwszym przypadku. Wewn(cid:200)trz p(cid:218)tli znajduje si(cid:218) instrukcja wy(cid:258)wietlaj(cid:200)ca warto(cid:258)ci kolej- nych komórek. P(cid:216)tla foreach Dotychczas poznali(cid:258)my trzy rodzaje p(cid:218)tli: for, while i do…while (by(cid:239)a o nich mowa w rozdziale 3.). W przypadku tablic (jak równie(cid:285) kolekcji, które w tej ksi(cid:200)(cid:285)ce nie by(cid:239)y omawiane1) mo(cid:285)na równie(cid:285) skorzysta(cid:202) z p(cid:218)tli typu foreach. Jest ona bardzo wygodna, gdy(cid:285) umo(cid:285)liwia prost(cid:200) iteracj(cid:218) po wszystkich elementach tablicy; nie trzeba wtedy wpro- wadza(cid:202) dodatkowej zmiennej iteracyjnej. P(cid:218)tla foreach ma nast(cid:218)puj(cid:200)c(cid:200) posta(cid:202): foreach(typ identyfikator in wyra(cid:285)enie) { // instrukcje } Je(cid:285)eli zatem mamy tablic(cid:218) o nazwie tab zawieraj(cid:200)c(cid:200) liczby typu int, mo(cid:285)emy zastosowa(cid:202) konstrukcj(cid:218): foreach(int val in tab) { // instrukcje } Wtedy w kolejnych przebiegach p(cid:218)tli pod val b(cid:218)d(cid:200) podstawiane kolej- ne elementy tablicy. S(cid:239)owo val jest tu identyfikatorem odczytywanej warto(cid:258)ci (mo(cid:285)na je traktowa(cid:202) jak zmienn(cid:200)). Oczywi(cid:258)cie nic nie stoi na przeszkodzie, aby zmieni(cid:202) je na dowolne inne. 1 (cid:165)ci(cid:258)lej rzecz ujmuj(cid:200)c, p(cid:218)tli foreach mo(cid:285)na u(cid:285)y(cid:202) z ka(cid:285)dym obiektem udost(cid:218)pniaj(cid:200)cym tzw. iterator. Ten temat nie b(cid:218)dzie jednak poruszany w ksi(cid:200)(cid:285)ce. Poleć książkęKup książkę 136 (cid:109) W I C Z E N I E 5.8 C# • (cid:193) wiczenia U(cid:285)ycie p(cid:218)tli foreach do wy(cid:258)wietlenia zawarto(cid:258)ci tablicy Wykorzystaj p(cid:218)tl(cid:218) foreach do wy(cid:258)wietlenia wszystkich elementów tablicy przechowuj(cid:200)cej liczby ca(cid:239)kowite. using System; public class Program { public static void Main() { int[] tab = new int[10]; for(int i = 0; i 10; i++) { tab[i] = i; } foreach(int i in tab) { Console.WriteLine(i); } } } Tablica tab zosta(cid:239)a zainicjalizowana w p(cid:218)tli for kolejnymi liczbami od 0 do 9. Do wy(cid:258)wietlenia danych zosta(cid:239)a natomiast u(cid:285)yta p(cid:218)tla foreach. W ka(cid:285)dym jej przebiegu pod identyfikator i jest podstawiana warto(cid:258)(cid:202) kolejnego elementu tablicy. W pierwszym przebiegu jest to pierwszy element (o indeksie 0), w drugim — drugi element (o indeksie 1) itd. P(cid:218)tla ko(cid:241)czy si(cid:218) po osi(cid:200)gni(cid:218)ciu ostatniego elementu (o indeksie 9). (cid:109) W I C Z E N I E 5.9 Zliczanie warto(cid:258)ci w p(cid:218)tli foreach Wype(cid:239)nij tablic(cid:218) losowymi liczbami ca(cid:239)kowitymi typu int. Wykorzystaj p(cid:218)tl(cid:218) foreach do sprawdzenia, ile jest w tej tablicy liczb parzystych, a ile nieparzystych. using System; public class Program { public static void Main() { int[] tab = new int[100]; int parzyste = 0, nieparzyste = 0; Random rand = new Random(); Poleć książkęKup książkę Rozdzia(cid:253) 5. • Tablice 137 for(int i = 0; i 100; i++) { tab[i] = rand.Next(); } foreach(int i in tab) { if(i 2 == 0) { parzyste++; } else { nieparzyste++; } } Console.WriteLine( Parzyste: {0} , parzyste); Console.WriteLine( Nieparzyste: {0} , nieparzyste); } } Powsta(cid:239)a tablica tab typu int, 100-elementowa. Do wype(cid:239)nienia jej danymi zosta(cid:239)y u(cid:285)yte p(cid:218)tla for oraz obiekt rand typu Random, za pomoc(cid:200) którego uzyskujemy warto(cid:258)ci pseudolosowe. Dok(cid:239)adniej rzecz ujmuj(cid:200)c, kolejn(cid:200) pseudolosow(cid:200) liczb(cid:218) ca(cid:239)kowit(cid:200) otrzymujemy, wywo(cid:239)uj(cid:200)c me- tod(cid:218) Next tego obiektu. W p(cid:218)tli foreach badamy, które z komórek tablicy tab zawieraj(cid:200) warto(cid:258)ci parzyste, a które — nieparzyste. Aby to stwier- dzi(cid:202), u(cid:285)ywamy operatora dzielenia modulo (reszty z dzielenia; por. tabela 2.4 z rozdzia(cid:239)u 2. i (cid:202)wiczenia 3.10 – 3.11 z rozdzia(cid:239)u 3.). Gdy wynikiem tego dzielenia jest 0, dana komórka zawiera liczb(cid:218) parzyst(cid:200) (jest wtedy zwi(cid:218)kszana warto(cid:258)(cid:202) pomocniczej zmiennej parzyste), na- tomiast gdy wynik dzielenia jest ró(cid:285)ny od 0, komórka zawiera warto(cid:258)(cid:202) nieparzyst(cid:200) (jest wtedy zwi(cid:218)kszana warto(cid:258)(cid:202) pomocniczej zmiennej nie- parzyste). Po zako(cid:241)czeniu p(cid:218)tli na ekranie wy(cid:258)wietlany jest komunikat z poszukiwan(cid:200) informacj(cid:200), co pokazano na rysunku 5.5 (w komunika- tach u(cid:285)ywane s(cid:200) warto(cid:258)ci pobrane ze zmiennych parzyste i nieparzyste). Rysunek 5.5. Wynik kilku uruchomie(cid:241) programu zliczaj(cid:200)cego liczb(cid:218) warto(cid:258)ci parzystych i nieparzystych Poleć książkęKup książkę 138 C# • (cid:193) wiczenia Tablice wielowymiarowe Tablice nie musz(cid:200) by(cid:202) jednowymiarowe, jak by(cid:239)o w dotychczas pre- zentowanych przyk(cid:239)adach. Tych wymiarów mo(cid:285)e by(cid:202) wi(cid:218)cej, np. dwa — otrzymujemy wtedy struktur(cid:218) widoczn(cid:200) na rysunku 5.6, czyli ro- dzaj tabeli o zadanej liczbie wierszy i kolumn. W tym przypadku s(cid:200) dwa wiersze oraz cztery kolumny. (cid:146)atwo zauwa(cid:285)y(cid:202), (cid:285)e aby w takiej sytuacji jednoznacznie wyznaczy(cid:202) komórk(cid:218), trzeba poda(cid:202) dwie liczby: indeks wiersza i indeks kolumny. Rysunek 5.6. Przyk(cid:239)ad tablicy dwuwymiarowej W jaki sposób mo(cid:285)na zadeklarowa(cid:202) tego typu tablic(cid:218)? Zacznijmy od deklaracji samej zmiennej tablicowej. Dla tablicy dwuwymiarowej ma ona posta(cid:202): typ_tablicy[,] nazwa_tablicy; Sam(cid:200) tablic(cid:218) tworzy si(cid:218) za pomoc(cid:200) instrukcji: new int[wiersze, kolumny]; Przyk(cid:239)adow(cid:200) dwuwymiarow(cid:200) tablic(cid:218) widoczn(cid:200) na rysunku 5.6 utwo- rzymy nast(cid:218)puj(cid:200)co (przy za(cid:239)o(cid:285)eniu, (cid:285)e ma przechowywa(cid:202) liczby ca(cid:239)- kowite): int[,] tablica = new tablica[2, 5]; Inicjalizacja komórek mo(cid:285)e odbywa(cid:202) si(cid:218) (cid:127) podobnie jak by(cid:239)o w przy- padku tablic jednowymiarowych (cid:127) ju(cid:285) w trakcie deklaracji: typ_tablicy[,] nazwa_tablicy = { (dana1, dana2), (dana3, dana4), …, (danaM, danaN) }; Zobaczmy na konkretnym przyk(cid:239)adzie, jak b(cid:218)dzie to wygl(cid:200)da(cid:239)o. Poleć książkęKup książkę
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

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