Lekce 6 - Cykly v C# .NET - for a while

V předešlém cvičení, Řešené úlohy k 5. 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ídá, něco se bude opakovat. Když chceme v programu něco udělat 100x, jistě nebudeme psát pod sebe 100x tentýž 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. řídicí proměnnou (celočíselnou), ve které se postupně při běhu cyklu mění hodnoty. Syntaxe (zápis) cyklu for je následující:

for (promenna; podminka; prikaz)

• promenna je řídicí proměnná cyklu, které nastavíme počáteční hodnotu (nejčastěji 0, protože v programování vše začíná od nuly, nikoli od jedničky). Např. tedy int i = 0. Samozřejmě si můžeme proměnnou vytvořit i někde nad tím a už nemusíme psát slovo int, bývá ale zvykem používat právě int i.
• podminka je podmínka vykonání dalšího kroku cyklu. Jakmile podmínka 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 řídicí 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 úplně běžně i mimo cyklus, slouží ke zvýšení nebo snížení proměnné o 1.

Pojďme si uvést jednoduchý příklad: většina z nás jistě zná Sheldona z The Big Bang Theory. Pro ty, kteří ne, budeme simulovat situaci, kdy Sheldon 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 už ale nemusíme nic 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 se ukončí. O vynechávání složených závorek platí totéž co u podmínek. V tomto případě tam nemusí být, protože cyklus spouští pouze jediný příkaz. Nyní můžeme do deklarace cyklu místo trojky napsat desítku. Příkaz se spustí 10x, aniž musíme psát 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 snippet ve Visual Studiu. Napíšeme jen for a dvakrát stiskneme Tabulátor. Zbytek kódu se sám doplní. Zkuste si to.

Zkusme 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 řídicí 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 totéž a pouze zvyšujeme číslo, kterým násobíme, máte pravdu. Nic nám nebrání, abychom vložili 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řipomeneme, že například 2³ = 2 * 2 * 2. Tedy aⁿ spočítáme tak, že n-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 (více v lekci Výpočet 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ž přístupná nebude.

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 počet opakování je pevně daný. Do proměnné cyklu bychom neměli nijak zasahovat ani do ní nic 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ště 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, v jeho podmínce často máme 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. Vezměme si naši kalkulačku z minulých lekcí a opět ji trochu vylepšeme, 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, 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 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ě zmíní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, tedy 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, kteří 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 na jednom řádku probíhají 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 témže řádku.

Operátory takto 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++ nebo promenna-- – Vrátí současnou hodnotu a až pak zvýší/sníží hodnotu promenna o 1.
• ++promenna nebo --promenna – Zvýší/sníží hodnotu promenna o 1 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 spíše hodí napsat operátor ++ před proměnnou, abychom dosáhli té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 když je text delší a konec řádku tak není 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 6. lekci C# .NET, si procvičíme nabyté zkušenosti z předchozích lekcí.

 

Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.