Lekce 4 — Cykly

Základy programování v C# · čtvrtá dvouhodinovka

Minule se program naučil rozhodnout. Pořád ale platí, že každý řádek proběhne nejvýš jednou. Chcete vypsat čísla 1 až 10? Deset řádků Console.WriteLine. Do tisíce? Tisíc řádků. Chcete se ptát na heslo, dokud ho uživatel nezadá správně? To nejde vůbec — nevíte předem, kolikrát se splete.

Dnes se program naučí opakovat. Konstrukci, která opakuje kus kódu, se říká cyklus (anglicky loop, uslyšíte i „smyčka“).

1. while — opakuj, dokud platí

int i = 1;

while (i <= 5)
{
    Console.WriteLine(i);
    i++;
}

Console.WriteLine("Hotovo.");

Vypadá to skoro jako if a čte se podobně: „Dokud je i nejvýš 5, proveď tělo.“ Rozdíl je v tom, co se stane po těle. if jde dál. while se vrátí nahoru a zeptá se znovu. Teprve když podmínka neplatí, cyklus skončí a program pokračuje pod ním.

Projděte si to krok po kroku. Tomuhle se říká krokování a u cyklů je to nejlepší způsob, jak pochopit, co se děje:

Všimněte si posledního řádku: podmínka se vyhodnotí šestkrát, tělo proběhne pětkrát. A po cyklu je v i šestka, ne pětka.

Každý takový cyklus potřebuje tři věci:

1. začátek — int i = 1; před cyklem,
2. podmínku — i <= 5, dokud platí, jede se dál,
3. krok — i++ v těle, který podmínku jednou shodí.

while (i <= 5);          // ← tenhle středník je chyba
{
    Console.WriteLine(i);
    i++;
}

2. Dokud to uživatel nezadá správně

Počítání do pěti je hezké na vysvětlení, ale hlavní síla while je jinde: v situacích, kdy předem nevíte, kolikrát se to bude opakovat.

Console.Write("Heslo: ");
string heslo = Console.ReadLine();

while (heslo != "tajne123")
{
    Console.WriteLine("Špatně, zkus to znovu.");
    Console.Write("Heslo: ");
    heslo = Console.ReadLine();
}

Console.WriteLine("Vítej!");

Uživatel může heslo trefit napoprvé (tělo neproběhne ani jednou) nebo napodesáté. Cyklu je to jedno. Tady není žádné počítadlo — krok, který jednou shodí podmínku, je heslo = Console.ReadLine();.

Jedna věc tu ale skřípe: řádky Console.Write("Heslo: ") a Console.ReadLine() jsou tam dvakrát. Jednou před cyklem, aby bylo co porovnat, a jednou v něm. Na to je další druh cyklu.

3. do … while — nejdřív udělej, pak se ptej

string heslo;

do
{
    Console.Write("Heslo: ");
    heslo = Console.ReadLine();
}
while (heslo != "tajne123");

Console.WriteLine("Vítej!");

Podmínka je až na konci, takže tělo proběhne vždycky aspoň jednou. To je přesně to, co u zadávání chceme: nejdřív se zeptat, pak zkontrolovat. Žádné zdvojené řádky.

Dvě věci, které tu vypadají divně a mají svůj důvod:

• Středník za while (...) — tady patří. Je to jediné místo, kde za while středník je, protože tím celá konstrukce končí.
• string heslo; nahoře, bez hodnoty — proměnná musí vzniknout před do. Kdybyste ji vytvořili uvnitř složených závorek, podmínka dole by ji neviděla. Proměnná žije jen v těch { }, ve kterých vznikla. K tomu se ještě vrátíme v pasti č. 4.

Stejný vzor použijete pokaždé, když chcete číslo z nějakého rozsahu:

int cislo;

do
{
    Console.Write("Zadej číslo od 1 do 10: ");
    cislo = int.Parse(Console.ReadLine());
}
while (cislo < 1 || cislo > 10);

Podmínka popisuje, kdy je vstup špatně — dokud je špatně, ptej se znovu. Tohle je častý zdroj zmatku: while vždycky říká, kdy pokračovat, ne kdy skončit.

4. for — když víte kolikrát

Cyklus z kapitoly 1 — začátek, podmínka, krok — je tak častý, že pro něj existuje zkratka. Tohle dělá úplně totéž:

for (int i = 1; i <= 5; i++)
{
    Console.WriteLine(i);
}

Všechny tři části jsou na jednom řádku v závorce, oddělené středníky:

Výhoda není v tom, že je to kratší. Výhoda je, že na krok nemůžete zapomenout — má v závorce své místo a prázdné místo je vidět na první pohled.

Pozpátku a po dvou:

for (int i = 10; i >= 1; i--)        // 10, 9, 8, … 1
{
    Console.WriteLine(i);
}

for (int i = 0; i <= 20; i += 2)     // 0, 2, 4, … 20
{
    Console.WriteLine(i);
}

for (int i = 0; i < 10; i++)     // proběhne 10× (0 až 9)
for (int i = 0; i <= 10; i++)    // proběhne 11× (0 až 10)
for (int i = 1; i < 10; i++)     // proběhne 9×  (1 až 9)

Který cyklus kdy?

• Víte předem, kolikrát (10×, n×, od 1 do 100)? → for.
• Opakujete, dokud se něco nestane (správné heslo, uhodnuté číslo, „konec“)? → while.
• …a má to proběhnout aspoň jednou? → do … while.

5. Střádání výsledku

Cyklus nemusí jen vypisovat. Často během něj něco sčítáte, počítáte nebo hledáte. Třeba součet čísel od 1 do n:

Console.Write("Do kolika sčítat? ");
int n = int.Parse(Console.ReadLine());

int soucet = 0;                              // PŘED cyklem: připravit

for (int i = 1; i <= n; i++)
{
    soucet += i;                             // V cyklu: přidat
}

Console.WriteLine($"Součet je {soucet}.");   // PO cyklu: vypsat

Ten vzor před — v — po si zapamatujte, budete ho psát pořád. Proměnné, která sbírá výsledek, se říká akumulátor (střádač). Stejně se počítá i počet (pocet++ místo soucet += i) nebo hledá největší hodnota (if v těle cyklu).

for (int i = 1; i <= n; i++)
{
    int soucet = 0;                  // ← v každém kole znovu od nuly
    soucet += i;
}
Console.WriteLine(soucet);           // nepřeloží se

6. break a continue

break cyklus okamžitě ukončí — program pokračuje pod ním. Hodí se, když se o konci rozhodujete uprostřed těla, ne v podmínce. Typický příklad je menu, které se točí, dokud uživatel neřekne dost:

while (true)
{
    Console.Write("Příkaz (ahoj / cas / konec): ");
    string prikaz = Console.ReadLine().Trim().ToLower();

    if (prikaz == "konec")
    {
        break;                       // vyskoč z cyklu
    }

    if (prikaz == "ahoj")
    {
        Console.WriteLine("Ahoj!");
    }
    else if (prikaz == "cas")
    {
        Console.WriteLine(DateTime.Now.ToShortTimeString());
    }
    else
    {
        Console.WriteLine("Neznámý příkaz.");
    }
}

Console.WriteLine("Nashle.");

while (true) je naschvál nekonečný cyklus — jediná cesta ven je break. Není to chyba, je to běžný vzor. Podívejte se na něj pořádně: tohle je kostra té textové hry, kterou budeme psát v druhém pololetí. Hra není nic jiného než cyklus „přečti příkaz, udělej něco, opakuj“.

continue přeskočí zbytek tohohle kola a jde rovnou na další. Třeba čísla od 1 do 20 kromě násobků tří:

for (int i = 1; i <= 20; i++)
{
    if (i % 3 == 0)
    {
        continue;                    // tohle kolo přeskoč
    }
    Console.WriteLine(i);
}

7. Náhodné číslo

Na hry budete potřebovat náhodu:

int tajne = Random.Shared.Next(1, 101);    // náhodné číslo 1 až 100
int kostka = Random.Shared.Next(1, 7);     // 1 až 6

8. Cyklus v cyklu

Tělo cyklu může obsahovat cokoliv — i další cyklus:

for (int radek = 1; radek <= 3; radek++)
{
    for (int sloupec = 1; sloupec <= 5; sloupec++)
    {
        Console.Write("* ");
    }
    Console.WriteLine();
}

Vnitřní cyklus proběhne celý pro každé kolo vnějšího: pět hvězdiček, odřádkování, pět hvězdiček, odřádkování… Dohromady 3 × 5 = 15 hvězdiček.

Dvě drobnosti, na kterých to stojí: Console.Write (bez Line) píše bez odřádkování, takže hvězdičky jsou vedle sebe. A Console.WriteLine() s prázdnými závorkami nevypíše nic, jen odřádkuje. Všimněte si taky, že počítadla mají jména radek a sloupec — u dvou cyklů v sobě by vás i a j mátly.

9. Úkoly

Od nejlehčího. U každého cyklu si před spuštěním řekněte, kolikrát proběhne — a pak to ověřte.

Shrnutí — co byste měli umět říct vlastními slovy

• Čím se liší while od if.
• Jaké tři věci potřebuje každý cyklus s počítadlem a co se stane, když jedna chybí.
• Kdy použít while, kdy do … while a kdy for.
• Kolikrát proběhne for (int i = 0; i < 10; i++) a jakou hodnotu má i v posledním kole.
• Proč musí akumulátor vzniknout před cyklem.
• Co dělá break a co continue.
• Proč Random.Shared.Next(1, 100) nikdy nevrátí 100.