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)
