Cykly

1. Cyklus

Pomocí příkazů cyklu se předepisuje opakované provádění příkazu nebo posloupnosti příkazů na základě splnění určité podmínky. V přirozeném jazyce odpovídají cyklům následující výroky:

• Pokud je splněna určitá podmínka, prováděj určitou činnost
  
• Prováděj tuto činnost tak dlouho, dokud bude splněna určitá podmínka
• Prováděj určitou činnost n-krát
• Prováděj určitou činnost pro každý prvek dané množiny

C# nabízí k použití tyto základní typy cyklů:

• while   - cyklus s podmínkou na začátku
• do-while – cyklus s podmínkou na konci 
• for – cyklus s krokem (pevným počtem opakování) 
• foreach – cyklus s výčtem (pro procházení prvků v kolekci – dozvíme se později)

Příkaz (nebo složený příkaz), který se má opakovat se obecně nazývá tělo cyklu. Je vhodné příkazy v těle cyklu uzavírat do složených závorek, i když obsahují pouze jeden příkaz. Lze do něj někdy později přidávat další příkazy a rychle vizuálně oddělit příkazy patřící do cyklu. Toto opakování obvykle závisí na tzv. řídící podmínce. Průchod tělem cyklu nazýváme iterací. Opakování těla cyklu lze zamezit pomocí některého z příkazu skoku např. break, continue atd. (bude vysvětleno později).

2. Cyklus s podmínkou na začátku

Cyklus s podmínkou na začátku je prvním typem podmíněného cyklu, jehož tělo cyklu je prováděno do té doby, dokud je splněna podmínka, tzn. větev True za rozhodovacím blokem ve vývojovém diagramu – viz Obrázek 1. Pokud nastane situace, že podmínka není splněna, tělo uvnitř smyčky cyklu již není nadále prováděno. Opuštění cyklu symbolizuje větev False, kdy podmínka není splněna. Je vhodné podotknout, že tělo uvnitř cyklu nemusí být provedeno ani jednou, pokud by hned v počátku při průchodu podmínkou nastala situace, že podmínka není splněna.

Obrázek 1: Značka cyklu s podmínkou na začátku – vývojový diagram

Obecná syntaxe cyklu s podmínkou na začátku v jazyce C#:

while (řídícíPodmínka) těloCyklu

kde:

• řídícíPodmínka - logický výraz, který je vyhodnocen. řídícíPodmínka musí být zapsána do kulatých závorek a musí být logického typu
• těloCyklu - příkaz (nebo složený příkaz uzavřený do složených závorek), který je proveden pokud platí, že výsledek výrazu v řídící podmínce je true. Proces provádění těla cyklu se opakuje, pokud je splněna řídícíPodmínka

Velmi často se jako identifikátor řídící proměnné používá písmeno i. Cykly lze také zapouzdřovat do sebe, tak jak tomu bylo např. u rozhodování. Pak se jako identifikátory těchto řídících proměnných vnořených cyklů používají další písmena pokračující v abecedě za písmenem i, tedy j, k, l atd. My tento zvyk v následujících příkladech algoritmů porušíme. Jedná se nám zejména o zachycení podstaty proměnné pomocí jejího názvu.

Opakování je matka moudrosti, proto se vraťme zpět k modifikované verzi příkladu Kalkulacka, tentokráte však použijeme při aritmetické operaci dělení reálná čísla. 

Ilustrativní příklad VydelParametry

Algoritmus VydelParametry

• Popis: Vývojový diagram funkce pro dělení zadaných reálných čísel pomocí cyklu s podmínkou na začátku 
• Zadání: Na základě rozdělení aritmetických operací v algoritmu Kalkulacka do podprogramů, tj. KalkulackaPodprogramy, modifikujte funkci VydelParametry, která provádí aritmetickou operaci dělení dvou zadaných čísel, které jsou vstupními argumenty této funkce (formální parametry). Oproti předchozí verzi algoritmu však nyní bude pracovat s dvěma reálnými čísly. Řešte tento problém pomocí cyklu s podmínkou na začátku. Uvnitř cyklu opakujte zadání hodnoty jmenovatele pomocí funkce ZadejCislo, dokud je jmenovatel nulový

• Řešení: 

• Podprogramy - funkce:

• VydelParametry:
  https://phix.zcu.cz/moodle/pluginfile.php/389320/mod_book/chapter/99031/Algoritmus_Kalkulacka_VydelParametry.png?time=1580291738404
  

• ZadejCislo:
  https://phix.zcu.cz/moodle/pluginfile.php/389320/mod_book/chapter/99031/Algoritmus_Kalkulacka_ZadejCislo.png?time=1580291760113
  
  

Program VydelParametry

• Popis: Deklarace metody s návratem s použitím cyklu s podmínkou na začátku
• Zadání: Vymyslete, jak byste na základě předchozích algoritmů podprogramů ZadejKodOperace a ZadejCislo v C# naprogramovali obě statické metody (s identickým názvem) jako konzolovou aplikaci
  
• Řešení: Bude postupně probráno v následujícím textu

V následujícím zdrojovém kódu je implementována metoda s návratem VydelParametry, která zajišťuje zadání nenulového jmenovatele – viz Kód 1. Validace na nenulový jmenovatel je realizováno pomocí cyklu s podmínkou na začátku pomocí logického výrazu (podmínky) bb == 0. V těle cyklu je prováděno načtení hodnoty reálného čísla pomocí metody s návratem s názvem ZadejCislo – viz Kód 2. Toto zadávání reálného čísla se bude provádět do té doby, dokud platí řídící podmínka uvedená v kulatých závorkách za příkazem while, tj. pokud uživatel zadá nulové reálné číslo.

//Metoda s návratem - navrací hodnotu podílu dvou reálných předaných hodnot
public static double VydelParametry(double aa, double bb)
{
    /* Deklarace lokální proměnné 'cc' ... slouží pro uložení hodnoty podílu načtených hodnot 
     * předaných z hlavního programu uložených do formálních parametrů 'aa' a 'bb' */
    double cc;
    // Test, zda nebyl načten nulový jmenovatel
    while (bb == 0)
    {
        // Pokud je jmenovatel nulový následuje zadání nového jmenovatele
        bb = ZadejCislo("nenulové B");
    }
    // Provedení podílu hodnot uložených v formálních parametrech funkce a uložení do lokální proměnné 'cc'
    cc = aa / bb;
    // Hodnota v 'cc' je výstupem metody
    return cc;
}

Kód 1: Deklarace metody VydelParametry - příklad cyklu s podmínkou na začátku 

//Metoda s návratem - navrací zadané reálné číslo
public static double ZadejCislo(string nazevParametru)
{
    //Deklarace lokální proměnné 'cc' ... výstupní reálné číslo 
    double xx;
    // Výpis definovaného textu spolu s textem uloženým v 'NazevParametru'
    Console.WriteLine("Zadejte " + nazevParametru + ":");
    // Načtení textu a konverze na reálnou hodnotu a uložení do proměnné 'xx'
    xx = double.Parse(Console.ReadLine());
    // Přiřazení hodnoty v 'xx' do výstupu metody
    return xx;
}

Kód 2: Deklarace metody ZadejCislo

3. Cyklus s podmínkou na konci

Cyklus s podmínkou na konci je dalším typem podmíněného cyklu, jehož tělo cyklu je prováděno do té doby, dokud je splněna podmínka, tzn., větev True za rozhodovacím blokem ve vývojovém diagramu – viz Obrázek 1. Pokud nastane situace, že podmínka není splněna, tělo uvnitř smyčky cyklu již není nadále prováděno. Opuštění cyklu je tedy pomocí větve False, tzn., že podmínka není splněna. Je vhodné podotknout, že tělo uvnitř cyklu musí být provedeno vždy minimálně jednou, protože testování řídící podmínky, která určuje, zda bude cyklus dále prováděn, následuje až po vykonání příkazů uvnitř těla cyklu.

Obrázek 1: Značka cyklu s podmínkou na konci – vývojový diagram

Obecná syntaxe cyklu s podmínkou na konci v jazyce C#:

do 
	těloCyklu
while (řídícíPodmínka);

kde:

• řídícíPodmínka - představuje logický výraz, který je vyhodnocen. řídícíPodmínka musí být zapsána do kulatých závorek a musí být logického typu
• těloCyklu - příkaz (nebo složený příkaz uzavřený do složených závorek), který je proveden pokud platí, že výsledek výrazu v řídící podmínce je true. Proces provádění těla cyklu se opakuje, dokud je splněna řídícíPodmínka. Opuštění cyklu nastává tehdy, pokud řídící podmínka je vyhodnocena jako false

Pro ilustraci principu použití cyklu s podmínkou na konci využijeme modifikovanou verzi příkladu Kalkulacka s reálnými čísly. 

Ilustrativní příklad ZadejKodOperace

Algoritmus ZadejKodOperace

• Popis: Vývojový diagram funkce pro zadání číselného kódu operace pomocí cyklu s podmínkou na konci
• Zadání: Zkuste navrhnout funkci ZadejKodOperace, která řeší zadání platného číselného kódu podle vypsaného číselníku kódů aritmetických operací pomocí cyklu s podmínkou na konci. Zadání číselného kódu bude probíhat neustále, dokud nebude definován validní (správný) číselný kód aritmetické operace (1 … sčítání, 2 … odečítání, 3 … násobení, 4 … dělení)
• Řešení: https://phix.zcu.cz/moodle/pluginfile.php/286373/mod_book/chapter/61254/Algoritmus_Kalkulacka_Podprogram_ZadejKodOperace.png

Program ZadejKodOperace

• Popis: Deklarace metody s návratem s použitím cyklu s podmínkou na konci
• Zadání: Vymyslete, jak byste na základě předchozího algoritmu ZadejKodOperace v C# naprogramovali statickou metodu s návratem (se stejným názvem) jako konzolovou aplikaci
• Řešení: Bude postupně probráno v následujícím textu

V následujícím zdrojovém kódu vidíme, že metoda navrací kód aritmetické operace jako celé číslo - viz Kód 1. Podmínkou tohoto číselného kódu (uloženého v proměnné kodOperace) je, že se jeho hodnota musí pohybovat v rozmezí 1 až 4. Toho docílíme tak, že v podmínce za klíčovým slovo while uvedeme do kulatých závorek logický výraz (kodOperace < 1 || kodOperace > 4). Tento výraz představuje podmínku, že pokud načtená hodnota uložená v kódu operace splní kritérium, tj., že je menší než 1, nebo že je hodnota větší než 4, bude řídící podmínka splněna a příkazy uvnitř těla cyklu (výpis textu pro uživatele a načtení kódu z klávesnice) proběhnou znovu. Pokud tato podmínka splněna není (logický výraz v řídící podmínce nabyde hodnoty false), je cyklus ukončen a metoda vrací načtenou validní hodnotu aritmetické operace.

//Metoda s návratem - zadání kódu aritmetické operace
public static int ZadejKodOperace()
{
    //Deklarace proměnné: 'kodOperace' ... číselný kód aritmetické operace
    int kodOperace;
    //Cyklus s podmínkou na konci - zadání číselného kódu aritmetické operace
    do
    {
        //Výpis textu pro uživatele - výzva k zadání kódu číselné operace
        Console.WriteLine("Zadejte kód operace (1 … sčítání, 2 … odečítání, 3 … násobení, 4 … dělení):");
        //Načtení kódu aritmetické operace
        kodOperace = int.Parse(Console.ReadLine());
    }
    // Testování podmínky, pokud zadaný kód operace je menší než 1 nebo větší než 4, zadávání se znovu opakuje
    while (kodOperace < 1 || kodOperace > 4);
    //Validní číselný kód aritmetické operace je výstupem funkce
    return kodOperace;
}

Kód 1: Deklarace metody ZadejKodOperace - příklad cyklu s podmínkou na začátku 

4. Cyklus s krokem

Tento typ nepodmíněného cyklu se používá v případě, že je explicitně znám počet provedení příkazu (víme, kolik proběhne smyček uvnitř cyklu, tedy je znám počet iterací). Dá se říci, že tento typ cyklu je formálnější verzi cyklu while, ve kterém jsou inicializace, logický výraz řídící podmínky a aktualizace řídící proměnné zkombinovány do jedné kulaté závorky. Značka cyklu s krokem, ve vývojovém diagramu aplikace Flowgorithm byla následující - viz Obrázek 1. Jak vidíme, v cyklu je definována tzv. řídící proměnná, která je inicializována na počáteční hodnotu. Hodnota řídící proměnné je definována intervalem <počatečníHodnota, konečnáHodnota>. Po každém provedení iterace (smyčka Next) je hodnota této řídící proměnné zvýšena (nebo snížena) o hodnotu definovaného kroku. Pokud je hodnota řídící proměnné je mimo interval (větev Done), cyklus je ukončen, tzn., již není prováděno tělo cyklu.

Obrázek 1: Značka cyklu s krokem – vývojový diagram

Obecná syntaxe příkazu for v jazyce C# je následující:

for (inicializačníVýraz; řídícíPodmínka; aktualizaceŘídícíProměnné)
	těloCyklu;

Ilustrativní příklad GrafickyPrvek

Algoritmus GrafickyPrvek

• Popis: Vývojový diagram pro vytvoření grafického prvku ve výpisu pomocí cyklu s krokem
• Zadání: Vytvořte algoritmus funkce GrafickyPrvek, která vytvoří textový řetězec (grafika), který bude použit jako grafický prvek ve výpisu výzvy. Tento grafický prvek se skládá ze znaků hvězdiček, tj. "*" umístěné v řádce za sebou. Pro postupné vkládání hvězdiček použijte cyklus s krokem. Počet hvězdiček (uložený v proměnné delkaVyzvy) v řádce je roven počtu znaků výzvy, která je vstupním argumentem (formální parametr vyzva) této funkce
• Řešení: 
  https://phix.zcu.cz/moodle/pluginfile.php/389320/mod_book/chapter/99033/Algoritmus_GrafickyPrvek.png?time=1580329500052
  
  

Program GrafickyPrvek

• Popis: Deklarace metody s návratem s použitím cyklu s podmínkou na konci
• Zadání: Vymyslete, jak byste na základě předchozího algoritmu GrafickyPrvek v C# naprogramovali statickou metodu s návratem (se stejným názvem) jako konzolovou aplikaci
• Řešení: Bude postupně probráno v následujícím textu

Deklarovaná metoda přijímá text výzvy, který je vypsán uživateli pro zadání číselného kódu aritmetické operace (formální parametr vyzva) - viz Kód 1. Díky tomuto formálnímu parametru lze určit počet hvězdiček. K tomu účelu použijeme metodu s návratem Length, určující počet znaků ve výzvě. Tuto metodu jsme zavolali pomocí tečkové notace u proměnné vyzva. Tato metoda a také další metody jsou definovány pro datový typ string (vyzva je datového typu string). Základním kamenem metody GrafickyPrvek je využití cyklu s krokem - for. Zde pokud logický výraz i <= delkaVyzvy (řídící proměnná i určuje aktuální index hvězdičky) nabývá hodnoty true, má být přidána pomoci příkazu grafika = grafika + "*"; další hvězdička do stávající grafiky.  Jinými slovy řečeno, pokud ještě nebylo dosaženo potřebného počtu hvězdiček v řádce (hodnota řídící proměnné ještě nebyla tolikrát zvýšena o krok 1 pomocí příkazu i++ aby dosáhla své konečné hodnoty),  příkaz umístěný v těle cyklu cyklus má znovu proběhnout. Pokud platí, že i > delkaVyzvy (logický výraz i <= delkaVyzvy nabývá hodnoty false) nedochází již k dalšímu přidání hvězdičky do řádku. Metoda navrací výsledný textový řetězec tvořený potřebným počtem hvězdiček.

//Metoda s návratem - vytvoření grafického prvku na základě textu výzvy (formálního parametru)
public static string GrafickyPrvek(string vyzva)
{
    /* Deklarace proměnné: 'grafika' ... znaky (hvězdička, tj. "*") umístěné v řádce 
     * za sebou v délce počtu znaků výzvy, 'delkaVyzvy' ... počet znaků ve výzvě,  
     * 'i' ... čítač, tj. aktuální index "*", tj. pořadí hvězdičky v řádku */
    string grafika;
    int delkaVyzvy, i;
    // Uložení počtu znaků ve výzvě do proměnné 'delkaVyzvy'
    delkaVyzvy = vyzva.Length;
    // Inicializace grafiky (přiřazení prázdného textu)
    grafika = "";
    // Cyklus s krokem - příkaz uvnitř těla cyklu proběhne tolikrát, kolik je znaků ve výzvě
    for (i = 1; i <= delkaVyzvy; i++)
    {
        // Připojení znaku "*" k předchozím znakům umístěných v grafika - vytvoření grafiky (hvězdiček v řádce)
        grafika = grafika + "*";
    }
    //Návrat grafického prvku
    return grafika;
}

5. Řízení cyklů

V některých případech je vhodné, aby byl cyklus ukončen předčasně. K tomu můžeme použít dva příkazy:

• continue – vynechání zbytku těla cyklu
• break – přerušení cyklu

 Příkaz continue vynechá zbytek těla cyklu a skočí přímo na začátek další iterace (v cyklu for je aktualizována řídící proměnná). V cyklu while a do-while je třeba dát pozor, aby došlo ke změně podmínky cyklu, jinak by mohlo dojít k nekonečné smyčce. Příkaz continue by měl být použit jen s velkou opatrností (jeho přítomnost značně komplikuje čitelnost principu kódu).

Příkaz break přeruší cyklus a program pokračuje prvním příkazem, který následuje za tělem cyklu. Nedojde ani k aktualizaci řídící proměnné a ani k vyhodnocení řídící podmínky.

Ilustrativní příklad DalsiIterace

Program DalsiIterace

• Popis: Deklarace statické hlavní metody s vynecháním zbytku těla cyklu a přeskočení do další iterace cyklu
• Zadání: Vymyslete, jak byste naprogramovali hlavní statickou metodu jako konzolovou aplikaci, která vypíše čísla od 1 do 10 s vynecháním čísla 5 ve výpisu. Čísla budou oddělena od sebe čárkou
• Řešení: Bude postupně probráno v následujícím textu

Ve výpisu vynecháme číslo 5. To provedeme pomocí příkazu continue umístěného ve větvi true, tzn., pokud je splněna podmínka, že i == 5. Příkaz continue zajistí přeskočení zbytku těla cyklu do další iterace. 

Inkrementace řídící proměnné i cyklu (tzv. čítače) se děje automaticky pro každém proběhnutí iterace.

static void Main(string[] args)
{
    /* Deklarace: 'rada' ... řada čísel určených k výpisu oddělených čárkami - inicializace; 
     * 'i' ... řídící proměnná cyklu - čítač (vypisované číslo) */
    string rada = "";
 
    // Cyklus s krokem (proběhne 10x)
    for (int i = 1; i <= 10; i++)
    {
        // Pokud je řídící proměnná rovna 5, pak...
        if (i == 5)
        {
            // Přeskočení do další iterace
            continue;
        }
        // Připojení konvertovaného čísla na text a čárky do řady čísel
        rada += i.ToString() + ", ";
    }
 
    // Výpis číselné řady
    Console.WriteLine(rada);
 
    // Načtení stisknuté klávesy
    Console.ReadKey();
}

Kód 1: Deklarace hlavní metody pro výpis řady čísel s využitím příkazu pro přeskočení zbytku těla cyklu

Na následujícím výpisu v konzoli vidíme podobu výpisu výsledného textového řetězce, ve kterém chybí číslo 5  – viz Výstup programu - Kód 1. 

1, 2, 3, 4, 6, 7, 8, 9, 10,

Ilustrativní příklad PreruseniCyklu

Program PreruseniCyklu

• Popis: Deklarace statické hlavní metody s přerušením cyklu
• Zadání: Vymyslete, jak byste naprogramovali hlavní statickou metodu jako konzolovou aplikaci, která vypíše čísla od 1 do 10 s vynecháním čísel 5 a výše ve výsledném výpisu řady čísel. Čísla budou oddělena od sebe čárkou
• Řešení: Bude postupně probráno v následujícím textu

static void Main(string[] args)
{
    /* Deklarace: 'rada' ... řada čísel určených k výpisu oddělených čárkami - inicializace; 
     * 'i' ... řídící proměnná cyklu - čítač (vypisované číslo) */
    string rada = "";
 
    // Cyklus s krokem (proběhne 10x)
    for (int i = 1; i <= 10; i++)
    {
        // Pokud je řídící proměnná rovna 5, pak...
        if (i == 5)
        {
            // Opuštění cyklu
            break;
        }
        // Připojení konvertovaného čísla na text a čárky do řady čísel
        rada += i.ToString() + ", ";
    }
 
    // Výpis číselné řady
    Console.WriteLine(rada);
 
    // Načtení stisknuté klávesy
    Console.ReadKey();
}

Kód 2: Deklarace hlavní metody pro výpis řady čísel s využitím příkazu pro opuštění cyklu

Na následujícím výpisu v konzoli vidíme podobu výpisu výsledného textového řetězce, ve kterém chybí čísla od 5 do 10 – viz Výstup programu - Kód 2. 

1, 2, 3, 4,

6. Stručné shrnutí

promenna++;

promenna += hodnota;

int i = 0;
while (i < 10)
{
    Console.WriteLine(i);
    i++;            
}

for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

int i = 0;
do
{
    Console.WriteLine(i);
    i++;
}
while (i < 10);

for (int i = 0; i < 10; i++)
{
    if (i > 8)
    {
        continue;
    }
    Console.WriteLine(i);
}

for (int i = 0; i < 10; i++)
{
    if (i > 5)
    {
        break;
    }
    Console.WriteLine(i);
}