Lekce 7 - Cykly v C# .NET - for a while
V předešlém cvičení, Řešené úlohy k 6. lekci C# .NET, jsme si procvičili nabyté zkušenosti z předchozích lekcí.
Nyní přejdeme k cyklům, po dnešním C#.NET tutoriálu již budeme mít téměř kompletní výbavu základních konstrukcí a budeme schopni tvořit rozumné aplikace.
Cykly
Jak již slovo cyklus napoví, něco se bude opakovat. Když chceme v programu něco udělat 100x, jistě nebudeme psát pod sebe 100x ten samý kód, ale vložíme ho do cyklu. Cyklů máme několik druhů, vysvětlíme si, kdy který použít. Samozřejmě si ukážeme praktické příklady.
for
cyklus
Tento cyklus má stanovený pevný počet opakování a hlavně obsahuje tzv. řídící proměnnou (celočíselnou), ve které se postupně během běhu cyklu mění hodnoty. Syntaxe (zápis) cyklu for je následující:
for (promenna; podminka; prikaz)
promenna
je řídící proměnná cyklu, které nastavíme počáteční hodnotu (nejčastěji0
, protože v programování vše začíná od nuly, nikoli od jedničky). Např. tedyint i = 0
. Samozřejmě si můžeme proměnnou i vytvořit někde nad tím a už nemusíme psát slovíčkoint
, bývá ale zvykem používat právěint i
.podminka
je podmínka vykonání dalšího kroku cyklu. Jakmile nebude platit, cyklus se ukončí. Podmínka může být např(i < 10)
.prikaz
nám říká, co se má v každém kroku s řídící proměnnou stát. Tedy zda se má zvýšit nebo snížit. K tomu využijeme speciálních operátorů++
a--
, ty samozřejmě můžete používat i úplně běžně mimo cyklus, slouží ke zvýšení nebo snížení proměnné o1
.
Pojďme si udělat jednoduchý příklad, většina z nás jistě zná Sheldona z The Big Bang Theory. Pro ty co ne, budeme simulovat situaci, kdy klepe na dveře své sousedky. Vždy 3x zaklepe a poté zavolá: "Penny!". Náš kód by bez cyklů vypadal takto:
{CSHARP_CONSOLE}
Console.WriteLine("Knock");
Console.WriteLine("Knock");
Console.WriteLine("Knock");
Console.WriteLine("Penny!");
Console.ReadKey();
{/CSHARP_CONSOLE}
My ale už nic nemusíme otrocky opisovat:
{CSHARP_CONSOLE}
for (int i=0; i < 3; i++)
{
Console.WriteLine("Knock");
}
Console.WriteLine("Penny!");
Console.ReadKey();
{/CSHARP_CONSOLE}
Konzolová aplikace
Knock
Knock
Knock
Penny!
Cyklus proběhne 3x, zpočátku je v proměnné i
nula, cyklus
vypíše "Knock" a zvýší proměnnou i
o jedna. Poté běží
stejně s jedničkou a dvojkou. Jakmile je v i
trojka, již
nesouhlasí podmínka i < 3
a cyklus končí. O vynechávání
složených závorek platí to samé, co u podmínek. V tomto případě tam
nemusí být, protože cyklus spouští pouze jediný příkaz. Nyní můžeme
místo trojky napsat do deklarace cyklu desítku. Příkaz se spustí 10x aniž
bychom psali něco navíc. Určitě vidíte, že cykly jsou mocným
nástrojem.
Když někam potřebujeme napsat for
cyklus,
můžeme využít snippetu
ve Visual Studio. Napíšeme jen for
a dvakrát stiskneme
Tabulátor. Zbytek kódu se sám doplní. Zkuste si to.
Zkusme si nyní využít toho, že se nám proměnná inkrementuje. Vypišme
si čísla od jedné do deseti. Protože nebudeme chtít, aby se nám v konzoli
text vždy odřádkoval, použijeme místo WriteLine()
pouze
Write()
.
{CSHARP_CONSOLE}
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i);
Console.ReadKey();
{/CSHARP_CONSOLE}
Vidíme, že řídící proměnná má opravdu v každé iteraci (průběhu)
jinou hodnotu. Všimněte si, že v cyklu tentokrát nezačínáme na nule, ale
můžeme nastavit počáteční hodnotu 1
a koncovou
10
. V programování je ovšem zvykem začínat od nuly, později
zjistíme proč.
Nyní si vypíšeme malou násobilku (násobky čísel 1 až 10, vždy do
deseti). Stačí nám udělat cyklus od 1
do 10
a
proměnnou vždy násobit daným číslem. Mohlo by to vypadat asi takto:
{CSHARP_CONSOLE}
Console.WriteLine("Malá násobilka pomocí cyklu:");
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 2);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 3);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 4);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 5);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 6);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 7);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 8);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 9);
Console.WriteLine();
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * 10);
Console.ReadKey();
{/CSHARP_CONSOLE}
Konzolová aplikace
Malá násobilka pomocí cyklu:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Program funguje hezky, ale pořád jsme toho dost napsali. Pokud vás napadlo, že v podstatě děláme 10x to samé a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání vložit 2 cykly do sebe:
{CSHARP_CONSOLE}
Console.WriteLine("Malá násobilka pomocí dvou cyklů:");
for (int j = 1; j <= 10; j++)
{
for (int i = 1; i <= 10; i++)
Console.Write("{0} ", i * j);
Console.WriteLine();
}
Console.ReadKey();
{/CSHARP_CONSOLE}
Poměrně zásadní rozdíl, že? Pochopitelně nemůžeme použít u obou
cyklů i
, protože jsou vložené do sebe. Proměnná
j
nabývá ve vnějším cyklu hodnot 1
až
10
. V každé iteraci (rozumějte průběhu) cyklu je poté
spuštěn další cyklus s proměnnou i
. Ten je nám již známý,
vypíše násobky, v tomto případě násobíme proměnnou j
. Po
každém běhu vnitřního cyklu je třeba odřádkovat, to vykoná
Console.WriteLine()
. Můžete si zkusit vypsané řádky upravit
pomocí metody PadLeft()
tak, aby byla čísla hezky ve
sloupcích.
Udělejme si ještě jeden program, na kterém si ukážeme práci s vnější proměnnou. Aplikace bude umět spočítat libovolnou mocninu libovolného čísla:
{CSHARP_CONSOLE}
Console.WriteLine("Mocninátor");
Console.WriteLine("==========");
Console.WriteLine("Zadejte základ mocniny: ");
int a = int.Parse(Console.ReadLine());
Console.WriteLine("Zadejte exponent: ");
int n = int.Parse(Console.ReadLine());
int vysledek = a;
for (int i = 0; i < (n - 1); i++)
vysledek = vysledek * a;
Console.WriteLine("Výsledek: {0}", vysledek);
Console.WriteLine("Děkuji za použití mocninátoru");
Console.ReadKey();
{/CSHARP_CONSOLE}
Asi všichni tušíme, jak funguje mocnina. Pro jistotu připomenu, že
například 23 = 2 * 2 * 2. Tedy an spočítáme tak, že
n-1 krát vynásobíme číslo a
číslem a
. Výsledek
si samozřejmě musíme ukládat do proměnné. Zpočátku bude mít hodnotu
a
a postupně se bude v cyklu pronásobovat. Pokud jste to
nestihli, máme tu samozřejmě článek s
algoritmem výpočtu libovolné mocniny. Vidíme, že naše proměnná
vysledek
je v těle cyklu normálně přístupná. Pokud si však
nějakou proměnnou založíme v těle cyklu, po skončení cyklu zanikne a již
nebude přístupná.
Konzolová aplikace
Mocninátor
==========
Zadejte základ mocniny:
2
Zadejte exponent:
3
Výsledek: 8
Děkuji za použití mocninátoru
Už tušíme, k čemu se for cyklus využívá. Zapamatujme si, že je počet opakování pevně daný. Do proměnné cyklu bychom neměli nijak zasahovat ani dosazovat, program by se mohl tzv. zacyklit, zkusme si ještě poslední, odstrašující příklad:
{CSHARP_CONSOLE}
// tento kód je špatně
for (int i = 1; i <= 10; i++)
i = 1;
Console.ReadKey();
{/CSHARP_CONSOLE}
Au, vidíme, že program se zasekl. Cyklus stále inkrementuje proměnnou
i
, ale ta se vždy sníží na 1
. Nikdy tedy
nedosáhne hodnoty > 10
, cyklus nikdy neskončí. Okno programu
zavřeme nebo použijeme tlačítko Stop v lište Visual Studia.
while
cyklus
Cyklus while
funguje jinak, jednoduše opakuje příkazy v bloku
dokud platí podmínka. Syntaxe cyklu je následující:
while (podminka) { // příkazy }
Pokud vás napadá, že lze přes while
cyklus udělat i
for
cyklus, máte pravdu Cyklus
for
je vlastně speciální případ
while
cyklu. Cyklus while
se ale používá na trochu
jiné věci, často máme v jeho podmínce např. metodu vracející logickou
hodnotu true
/false
. Původní příklad z
for
cyklu bychom udělali pomocí while
následovně:
{CSHARP_CONSOLE}
int i = 1;
while (i <= 10)
{
Console.Write("{0} ", i);
i++;
}
Console.ReadKey();
{/CSHARP_CONSOLE}
To ale není ideální použití while
cyklu. Vezmeme si naši
kalkulačku z minulých lekcí a opět ji trochu vylepšíme, konkrétně o
možnost zadat více příkladů. Program tedy hned neskončí, ale zeptá se
uživatele, zda si přeje spočítat další příklad. Připomeňme si
původní verzi kódu (je to ta verze se switch
em, ale klidně
použijte i tu bez něj, záleží na vás):
{CSHARP_CONSOLE}
Console.WriteLine("Vítejte v kalkulačce");
Console.WriteLine("Zadejte první číslo:");
float a = float.Parse(Console.ReadLine());
Console.WriteLine("Zadejte druhé číslo:");
float b = float.Parse(Console.ReadLine());
Console.WriteLine("Zvolte si operaci:");
Console.WriteLine("1 - sčítání");
Console.WriteLine("2 - odčítání");
Console.WriteLine("3 - násobení");
Console.WriteLine("4 - dělení");
int volba = int.Parse(Console.ReadLine());
float vysledek = 0;
switch (volba)
{
case 1:
vysledek = a + b;
break;
case 2:
vysledek = a - b;
break;
case 3:
vysledek = a * b;
break;
case 4:
vysledek = a / b;
break;
}
if ((volba > 0) && (volba < 5))
Console.WriteLine("Výsledek: {0}", vysledek);
else
Console.WriteLine("Neplatná volba");
Console.WriteLine("Děkuji za použití kalkulačky, aplikaci ukončíte libovolnou klávesou.");
Console.ReadKey();
{/CSHARP_CONSOLE}
Nyní vložíme téměř celý kód do while
cyklu. Naší
podmínkou bude, že uživatel zadá "ano", budeme tedy kontrolovat obsah
proměnné pokracovat
. Zpočátku bude tato proměnná nastavena na
"ano", aby se program vůbec spustil, poté do ní necháme načíst volbu
uživatele:
Console.WriteLine("Vítejte v kalkulačce"); string pokracovat = "ano"; while (pokracovat == "ano") { Console.WriteLine("Zadejte první číslo:"); float a = float.Parse(Console.ReadLine()); Console.WriteLine("Zadejte druhé číslo:"); float b = float.Parse(Console.ReadLine()); Console.WriteLine("Zvolte si operaci:"); Console.WriteLine("1 - sčítání"); Console.WriteLine("2 - odčítání"); Console.WriteLine("3 - násobení"); Console.WriteLine("4 - dělení"); int volba = int.Parse(Console.ReadLine()); float vysledek = 0; switch (volba) { case 1: vysledek = a + b; break; case 2: vysledek = a - b; break; case 3: vysledek = a * b; break; case 4: vysledek = a / b; break; } if ((volba > 0) && (volba < 5)) Console.WriteLine("Výsledek: {0}", vysledek); else Console.WriteLine("Neplatná volba"); Console.WriteLine("Přejete si zadat další příklad? [ano/ne]"); pokracovat = Console.ReadLine(); } Console.WriteLine("Děkuji za použití kalkulačky, aplikaci ukončíte libovolnou klávesou."); Console.ReadKey();
Konzolová aplikace
Vítejte v kalkulačce
Zadejte první číslo:
12
Zadejte druhé číslo:
128
Zvolte si operaci:
1 - sčítání
2 - odčítání
3 - násobení
4 - dělení
1
Výsledek: 140
Přejete si zadat další příklad? [ano/ne]
ano
Zadejte první číslo:
-10,5
Zadejte druhé číslo:
Naši aplikaci lze nyní používat vícekrát a je již téměř hotová.
Již toho umíme docela dost, začíná to být zábava, že?
Operátor ++
Na závěr si ještě zmiňme něco více o operátoru ++
. Již
víme, že zvýší hodnotu libovolné číselné proměnné o 1
.
Můžeme jej tedy používat i mimo for
cyklus, v běžném kódu,
např.:
{CSHARP_CONSOLE}
int bodu = 0;
Console.WriteLine("Je Slunce koule žhavých plynů?");
string spravnaOdpoved = "ano";
string odpoved = Console.ReadLine();
if (odpoved.ToLower() == spravnaOdpoved.ToLower()) {
bodu++;
Console.WriteLine("Správně, máš celkem {0} bodů", bodu);
}
{/CSHARP_CONSOLE}
Pokud zadáme správnou odpověď, kód výše vypíše:
Konzolová aplikace
Je Slunce koule žhavých plynů?
ano
Správně, máš celkem 1 bodů
Pokud patříte k lidem, co si opravdu rádi zkracují svůj kód, můžete
využít toho, že operátory ++
a --
hodnotu čísla
i vrací. Lze je tedy použít přímo jako
hodnotu, i když je kód pak méně čitelný, protože se dělají na
jednom řádku 2 věci:
- hodnota se zvýší nebo sníží o
1
- hodnota se vrátí třeba k výpisu, který může být na tom samém řádku
Takto operátory můžeme použít dokonce dvěma způsoby a vrátit si tak buď novou hodnotu nebo tu před zvýšením/snížením:
promenna++
nebopromenna--
- Vrátí současnou hodnotu a až pak zvýší/sníží hodnotupromenna
o1
.++promenna
nebo--promenna
- Zvýší/sníží hodnotupromenna
o1
a vrátí novou hodnotu.
Tuto znalost nyní využijme u příkladu kvízu výše:
{CSHARP_CONSOLE}
int bodu = 0;
Console.WriteLine("Je Slunce koule žhavých plynů?");
string spravnaOdpoved = "ano";
string odpoved = Console.ReadLine();
if (odpoved.ToLower() == spravnaOdpoved.ToLower())
Console.WriteLine("Správně, předtím jsi měl {0} bodů a teď máš o 1 víc!", bodu++);
{/CSHARP_CONSOLE}
Výsledek je nyní následující:
Konzolová aplikace
Je Slunce koule žhavých plynů?
ano
Správně, předtím jsi měl 0 bodů a teď máš o 1 víc!
Hodnota proměnné bodu
je nyní opravdu 1
, ačkoli
ve výpisu máme 0
. Operátor ++
hodnotu proměnné na
daném řádku totiž nejprve vrátil a až potom zvýšil. Nám se ovšem hodí
spíše napsat operátor ++
před proměnnou, abychom
dosáhli toto samého výpisu jako předtím:
{CSHARP_CONSOLE}
int bodu = 0;
Console.WriteLine("Je Slunce koule žhavých plynů?");
string spravnaOdpoved = "ano";
string odpoved = Console.ReadLine();
if (odpoved.ToLower() == spravnaOdpoved.ToLower())
Console.WriteLine("Správně, máš celkem {0} bodů", ++bodu);
{/CSHARP_CONSOLE}
Nyní je výsledek stejný jako původně:
Konzolová aplikace
Je Slunce koule žhavých plynů?
ano
Správně, máš celkem 1 bodů
Kód funguje úplně stejně jako ten výše, nejdříve zvýší hodnotu
proměnné bodu
a pak se tato hodnota předá k výpisu.
Z hlediska přehlednosti doporučujeme tuto praktiku spíše nepoužívat. Že je proměnná modifikována a ne jen vypisována lze totiž velmi snadno přehlédnout, zejména, kdyby byl text delší a konec řádku tak nebyl vidět. Nicméně na podobné kódy můžete narazit v cizích projektech a proto je dobře, že jsme si zde tuto praktiku ukázali.
V následujícím cvičení, Řešené úlohy k 7. lekci C# .NET, si procvičíme nabyté zkušenosti z předchozích lekcí.
Stáhnout
Staženo 1059x (90.66 kB)
Aplikace je včetně zdrojových kódů v jazyce C#
Komentáře


Zobrazeno 10 zpráv z 175. Zobrazit vše