Rozhodování

1. Rozhodování

V kódu se velice často potřebujeme rozhodovat na základě specifikované podmínky. Jedná se o tzv. podmíněné příkazy. Tyto příkazy mohou být:

• Jednoduché větvení
• Úplné větvení, tj. příkaz if s else
• Neúplné – jednoduché větvení, tj. příkaz if bez else
• Vícenásobné větvení – příkaz case

Po aplikaci vyjmenovaných příkazů dochází k větvení, tzn., že jsou vytvořeny větve, kterými se program ubírá, pokud je daná podmínka splněna či nikoliv. Počet větví záleží na typu příkazu.

Logické hodnoty vznikají jako výsledky použití relačních operátorů – viz Tabulka 1.

Tabulka 1: Relační operátory

2. Úplné větvení

Jednoduché větvení se provádí příkazem if. Dejte si pozor, ať v logických výrazech nepoužíváte operátor přiřazení = namísto správného operátoru, který testuje rovnost, tj. == . Další důležitým pravidlem je, že výraz za příkaz if musí být uzavřen do závorek!

Úplné větvení má obě větve – True, tj. logický výraz (logická podmínka) je splněn a i větev False, tj. podmínka není splněna. Následující značka definuje, jak jsme ve vývojovém diagramu zaznamenali blok rozhodování – viz Obrázek 1.

Obrázek 1: Blok rozhodování - úplné větvení

Obecná syntaxe úplného větvení v C# je:

if (logickýVýraz)
	příkaz1;
else
	příkaz2;                

kde:

• logickýVýraz - představuje podmínku rozhodování 
• příkaz1 - příkaz (nebo složený příkaz, tj. blok příkazů), který je proveden, je-li logický výraz vyhodnocen jako true
• else - větev, která je vykonána, pokud logický výraz je vyhodnocen jako false
  
• příkaz2 - příkaz, nebo složený příkaz, který je proveden ve větvi else, tj. je-li logický výraz vyhodnocen jako false
  

V jazyce C# musíme přiřadit hodnotu logické proměnné dříve, než použijeme její obsah! Pokud se pokusíme přistoupit k obsahu proměnné dříve, která není naplněna, nebudeme moci program zkompilovat.

Ilustrativní příklad UplneVetveni

Algoritmus UplneVetveni

Při deklaraci proměnných využijeme úspornější variantu, kdy jednotlivé proměnné stejného datového typu oddělíme čárkou, tím ušetříme místo ve vývojovém diagramu (díky redukci dalších značek deklarace jednotlivých proměnných). Rozhodovací blok obsahuje testovanou podmínku. Pokud je podmínka splněna (tj. větev True), je vykonán přiřazovací příkaz, který proměnné logického typu přiřadí hodnotu true (pravda). Pokud podmínka splněna není, je vykonána druhá větev False, ve které přiřadíme logické proměnné boolPromenna hodnotu false. 

Program UplneVetveni

• Popis: Zdrojový kód úplného větvení
• Zadání: Vymyslete, jak byste v C# naprogramovali v hlavní metodě Main algoritmus UplneVetveni jako konzolovou aplikaci
• Řešení: Bude postupně probráno v následujícím textu

V redukovaném zdrojovém kódu (provedli jsme deklaraci lokálních proměnných včetně inicializace) jsou deklarovány dvě celočíselné proměnné, které jsou inicializovány (datový typ int) - viz Kód 1. Třetí deklarovanou proměnnou s názvem boolPromenna je logická proměnná (datový typ bool), která může nabývat hodnoty true nebo false. Ve čtvrtém řádku kódu dochází k testování podmínky, tj. zda platí tvrzení, že hodnota uložená v proměnné x je menší než hodnota uložená v proměnné y. Pokud je tato podmínka splněna přiřadíme logická proměnné boolPromenna hodnotu true. Pokud podmínka není splněna, logické proměnné přiřadíme hodnotu false.

static void Main(string[] args)
{
    //Deklarace celočíselné proměnné včetně inicializace
    int x = 2;
    //Deklarace celočíselné proměnné včetně inicializace
    int y = 3;
    //Deklarace logické proměnné
    bool boolPromenna;
    //Rozhodovací podmínka
    if (x < y)
        //Pokud podmínka je splněna -> přiřazení hodnoty true do logické proměnné
        boolPromenna = true;
    else
        //Pokud podmínka není splněna -> přiřazení hodnoty false
        boolPromenna = false;
}

Kód 1: Příklad úplného větvení

3. Neúplné větvení

V neúplném jednoduchém větvení chybí větev else. Neúplné větvení je zachyceno pomocí následujícího ilustrativního příkladu.

Ilustrativní příklad NeuplneVetveni

Algoritmus NeuplneVetveni

Rozhodovací blok obsahuje testovanou podmínku. Pokud je podmínka splněna (tj. větev True), je vykonán přiřazovací příkaz, který proměnné logického typu přiřadí hodnotu true (pravda). Druhá větev False (větev kdy podmínka není splněna) neobsahuje žádný příkaz, proto název neúplné větvení.

V aplikaci Flowgorithm nelze za blokem logické výrazu vypustit ani jednu z větví. V případě jiných aplikací, např. aplikace Visio, to však  lze. Proto je tento fakt důležité zmínit.

Program NeuplneVetveni

• Popis: Zdrojový kód neúplného větvení – příklad neúplného větvení příkazu if
• Zadání: Vymyslete, jak byste v C# naprogramovali v hlavní metodě Main algoritmus NeuplneVetveni jako konzolovou aplikaci
• Řešení: Bude postupně probráno v následujícím textu

V redukovaném zdrojovém kódu (provedli jsme deklaraci lokálních proměnných včetně inicializace) jsou deklarovány dvě celočíselné proměnné, které jsou inicializovány (datový typ int) - viz Kód 1. Třetí deklarovanou proměnnou s názvem boolPromenna je logická proměnná (datový typ bool), která může nabývat hodnoty true nebo false. Ve čtvrtém řádku kódu dochází k testování podmínky, tj. zda platí tvrzení, že hodnota uložená v proměnné x je menší než hodnota uložená v proměnné y. Pokud je tato podmínka splněna přiřadíme logická proměnné hodnotu true.

static void Main(string[] args)
{
    //Deklarace celočíselné proměnné včetně inicializace
    int x = 2;
    //Deklarace celočíselné proměnné včetně inicializace
    int y = 3;
    //Deklarace logické proměnné
    bool boolPromenna;
    //Rozhodovací podmínka -> pokud podmínka splněna -> logická proměnná je true
    if (x < y)
        //Přiřazení hodnoty do logické proměnné
        boolPromenna = true;
}

Kód 1: Příklad neúplného větvení

4. Možná chyba

Ilustrativní příklad ReverzniInzenyrstvi

• Popis: Tvorba vývojového diagramu na základě zdrojového kódu
• Zadání: Na základě následujícího zdrojového kódu  viz Kód 2 - vytvořte vývojový diagram hlavního programu (název Reverzní inženýrství byl použit z důvodu opačného provádění kroků při tvorbě programu. Doporučený postup je nejprve provést analýzu, vytvořit vývojový diagram a následně sestavit zdrojový kód, atd.)
• Řešení: Bude postupně probráno v následujícím textu
  

static void Main(string[] args)
{
    //Deklarace celočíselné proměnné včetně inicializace
    int x = 2;
    //Deklarace celočíselné proměnné včetně inicializace
    int y = 3;
    //Deklarace logické proměnné
    bool boolPromenna;
    //Rozhodovací podmínka
    if (x < y)
        //Přiřazení hodnoty do logické proměnné
        boolPromenna = true;
        //Inkrementace proměnné
        x = x + 1;
}

Kód 2: Příklad reverzního inženýrství

Začátečníci mohou při transformaci zdrojového kódu do vývojového diagramu velice snadno udělat následující chybu – viz Obrázek 2. 

Obrázek 2: Chybný vývojový diagram algoritmu ReverzniInzenyrstvi

Zdrojový kód vypadá, jako kdyby se v kladné větvi měly vykonávat dva příkazy, ale není to pravda. V kladné větvi bude pouze vykonáno přiřazení logické hodnoty true do logické proměnné. Následná inkrementace celočíselné proměnné bude vykonána vždy, protože tento příkaz následuje až za rozhodováním - viz Obrázek 3.

Obrázek 3: Vývojový diagram algoritmu ReverzniInzenyrství

5. Složený příkaz

Jak postupovat, pokud ve větvi potřebujeme vykonat více příkazů? Musíme použít tzv. složený příkaz (v anglické terminologii označován jako blok – „Block“), tj. uzavřeme více příkazů do složených závorek { }.

Ilustrativní příklad SlozenyPrikaz

Algoritmus SlozenyPrikaz

Vývojový digram je modifikací předchozí příkladu, u kterého jste možná udělali chybu ve vývojovém diagramu. Pokud ne, tak Vám gratuluji. Nyní je naším záměrem, aby ve větvi True byl proveden více jak 1 příkaz.

Program SlozenyPrikaz

• Popis: Zdrojový kód složeného příkazu
• Zadání: Vymyslete, jak byste v C# naprogramovali v hlavní metodě Main algoritmus SlozenyPrikaz jako konzolovou aplikaci
• Řešení: Bude postupně probráno v následujícím textu

V našem zdrojovém kódu musíme použít složený příkazu, tj. uzavřeme oba příkazy, které chceme vykonat, pokud je podmínka splněna do složených závorek { } – viz Kód 1.

static void Main(string[] args)
{
    //Deklarace celočíselné proměnné včetně inicializace
    int x = 2;
    //Deklarace celočíselné proměnné včetně inicializace
    int y = 3;
    //Deklarace logické proměnné
    bool boolPromenna;
    //Rozhodovací podmínka
    if (x < y)
    //začátek složeného příkazu
    {
        //Přiřazení hodnoty do logické proměnné
        boolPromenna = true;
        //Inkrementace proměnné
        x = x + 1;
    //Konec složeného příkazu
    }
    else
        //Pokud podmínka není splněna -> přiřazení hodnoty false
        boolPromenna = false;
}

Kód 1: Příklad složeného příkazu

6. Logické a relační operátory

Pro vytváření výrazů využíváme logické operátory – viz Tabulka 1.

Tabulka 2: Logické operátory

Následující tabulka obsahuje možné hodnoty, kterých může nabývat logická proměnná– true, tj. pravda vs false, tj. nepravda - viz Tabulka 2. Ve sloupcích jsou umístěny logické a relační operátory, jejichž aplikací na hodnoty těchto proměnných získáme výsledek. Pro zjednodušení si představte namísto false hodnotu 0 a namísto true hodnotu 1. Pak již u operátoru && stačí násobit (logický součin – konjunkce) nebo v případě || hodnoty sčítat (logický součet – disjunkce – pozor 1 + 1 je v tomto případě 1. Hodnota totiž může být 0 nebo 1). Poslední sloupec v tabulce znázorňuje porovnání hodnot dvou logických proměnných. V C# lze pro relační operace použít porovnání metoda CompareTo, která navrací celočíselnou hodnotu výsledku.

Tabulka 2: Logické a relační operátory

Ilustrativní příklad LogickySoucin

Algoritmus LogickySoucin

Rozhodovací blok v algoritmu obsahuje logický výraz (testovanou podmínku, která se skládá ze dvou částí). První část logické výrazu (x < y) v rozhodovacím bloku je splněna, tj. (2 < 3). Zároveň také došlo ke splnění druhé části logického výrazu (y < z), tj. (3 < 4). Protože první část logického výrazu nabyla hodnoty true a zároveň druhá část výrazu také nabyla hodnoty true, logický součin ve formě operátoru && navrací výsledek true (můžeme si představit aritmetickou operaci 1 * 1 = 1). Musí být tedy vykonán přiřazovací příkaz umístěný ve větvi True. Po přiřazení hodnoty logické proměnné následně dojde k vypsání její hodnoty, tedy true. 

Program LogickySoucin

• Popis: Zdrojový kód úplného větvení s použitím logických a relačních operátorů
• Zadání: Vymyslete, jak byste v C# naprogramovali v hlavní metodě Main algoritmus LogickySoucin jako konzolovou aplikaci
• Řešení: Bude postupně probráno v následujícím textu

V následujícím kódu jsou použity 3 celočíselné proměnné a jedna logická proměnná datového typu bool – viz Kód 1. Z příkazu if vycházejí dvě větve. Pokud složená podmínka platí, pak se provede v kódu příkaz pod podmínkou. Pokud podmínka neplatí, provede se kód za else. Uvnitř podmínky jsme použili operátor logického součinu &&, kde musí platit zároveň obě definované části logického výrazu.

static void Main(string[] args)
{
    //Deklarace celočíselné proměnné včetně inicializace
    int x = 2;
    //Deklarace celočíselné proměnné včetně inicializace
    int y = 3;
    //Deklarace celočíselné proměnné včetně inicializace
    int z = 4;
    //Deklarace logické proměnné
    bool boolPromenna;
    //Rozhodovací podmínka - platí tvrzení?
    if ((x < y) && (y < z))
        //Přiřazení hodnoty logické proměnné - pravda
        boolPromenna = true;
    else
        //Přiřazení hodnoty logické proměnné - nepravda
        boolPromenna = false;
    //Výpis výsledné hodnoty logické proměnné
    Console.WriteLine("Výsledek je: {0}", boolPromenna);
    //Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 1: Příklad logického součinu

Na následujícím výpisu v konzoli vidíme výsledek rozhodování – viz Výstup programu - Kód 1.

Výsledek je: True

Výstup programu - Kód 1: Ukázka výsledku u příkladu logického součinu

7. Ternární podmíněný operátor

Příkaz if nelze použít jako součást výrazu. Jazyk C# nabízí tzv. ternární podmíněný operátor ?: .Obecná syntaxe tohoto operátoru podmíněného výrazu vypadá následovně:

podmínka ? výraz1 : výraz2

kde:

• podmínka - podmínka, která musí být vyhodnocena jako true nebo false
• ?: - ternární podmíněný operátor
  
• výraz1 - návrat pokud je podmínka splněna
• výraz2 - návrat pokud není podmínka splněna (oba výrazy musí být stejného typu, nebo musí být převedeny na stejný typ)

Podmíněný operátor je asociativní zprava, to znamená že výraz:

a ? b : c ? d : e

by byl vyhodnocen následujícím způsobem:

a ? b : (c ? d : e)

Ilustrativní příklad Maximum

• Popis: Příklad podmíněného výrazu výběru většího čísla ze dvou čísel
• Zadání: Ve statické metodě Maximum s návratem zkuste naprogramovat příklad úplného větvení příkazu if pro výběr většího ze dvou čísel. Metoda přijímá dva celočíselné formální parametry a a b. Pokud platí že a > b, pak je metody navrací parametr a a pokud definovaná podmínka neplatí, výstupem metody je parametr b. V hlavní metodě Main použijte skutečné parametry nazvané jako x a y. Parametrům přiřaďte hodnotu x = 2 a y = 3. V metodě Main zavolejte metodu Maximum a předejte jí oba skutečné parametry v pořadí x a y. Vypište získané maximum v metodě Main 
• Řešení: Bude postupně probráno v následujícím textu

Následující zdrojový kód obsahuje tělo metody Maximum, která vrací maximum ze dvou vstupních čísel, tedy formální parametr s větší hodnotou – viz Kód 1.

//Deklarace metody pro nalezení většího čísla (maxima ze dvou čísel)
static int Maximum(int a, int b)
    {
        //Jestliže je větší 'a' výstupem je 'a'
        if (a > b) return a;
        //jinak je výstupem 'b'
        else return b;
    }

Kód 1: Příklad podmíněného výrazu v metodě Maximum

Ve statické metodě Main bychom metodu Maximum volali a vypsali její návrat přiřazený do lokální proměnné výsledek následujícím způsobem - viz Kód 2.

static void Main(string[] args)
{
    //Deklarace celočíselné proměnné včetně inicializace
    int x = 2;
    //Deklarace celočíselné proměnné včetně inicializace
    int y = 3;
    //Deklarace celočíselné proměnné
    int vysledek;
    //Přířazeni maximální hodnoty (výstupu funkce) do proměnné 
    vysledek = Maximum(x, y);
    //Výpis hodnoty maxima
    Console.WriteLine("Výsledek je: {0}", vysledek);
    //Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 2: Příklad zavolání metody Maximum s výstupem

Na základě výpisu v konzole vidíme, že vypsaná hodnota maxima je 3 - viz Výstup programu - Kód 2.

Výsledek je: 3

Výstup programu - Kód 2: Ukázka výsledku podmíněného výrazu

Ilustrativní příklad MaximumOperator

• Popis: Příklad použití operátoru ? : u podmíněného výrazu pro výběr většího čísla ze dvou čísel
• Zadání: Modifikujte předchozí statickou metodu Maximum za pomoci operátoru ? : tak, aby princip této metody zůstal stejný, tj. metoda přijímá dva celočíselné parametry a a b. Pokud platí že a > b, pak je metody navrací parametr a a pokud definovaná podmínka neplatí, výstupem metody je parametr b. Metodu s návratem nazvěte MaximumOperator. V hlavní metodě Main použijte skutečné parametry nazvané jako x a y. Parametrům přiřaďte hodnotu x = 2 a y = 3. V metodě Main zavolejte metodu Maximum a předejte jí oba skutečné parametry v pořadí x a y. Vypište získané maximum v metodě Main 
• Řešení: Bude postupně probráno v následujícím textu

Pokud bychom využili operátor ? : pro předchozí příklad, zdrojový kód metody s návratem nazvané jako MaximumOperator by vypadal následovně – viz Kód 3. Jak vidíme, došlo ke značné redukci zdrojového kódu, o což by měla usilovat většina programátorů.

//Deklarace metody pro nalezení většího čísla s použitím operátoru ? :
static int MaximumOperator(int a, int b)
{
    //Jestliže je větší 'a' výstupem je 'a' jinak 'b'
    return a > b ? a : b;
}

Kód 3: Příklad použití ternárního podmíněného operátoru ? : u podmíněného výrazu v metodě MaximumOperator

V následujícím zdrojovém kódu, je demonstrováno volání statické metody MaximumOperator ve statické metodě Main, které je naprosto totožné, jako v předchozím případě volání metody Maximum - viz Kód 4. 

static void Main(string[] args)
{
    //Deklarace celočíselné proměnné včetně inicializace
    int x = 2;
    //Deklarace celočíselné proměnné včetně inicializace
    int y = 3;
    //Deklarace celočíselné proměnné
    int vysledek;
    //Přířazeni maximální hodnoty (výstupu funkce) do proměnné 
    vysledek = MaximumOperator(x, y);
    //Výpis hodnoty maxima
    Console.WriteLine("Výsledek je: {0}", vysledek);
    //Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 4: Příklad zavolání metody MaximumOperator s výstupem

Výsledek je: 3

Výstup programu - Kód 4: Ukázka výsledku ternárního podmíněného operátoru

8. Kaskádování

Příkazy if se dají vnořit do jiných příkazů if. Takto je možné zřetězit posloupnost logických výrazů, které budou postupně vyhodnocovány, dokud jeden z nich nenabyde hodnoty true. [6]

Tomuto principu se říká kaskádování (anglicky – „Cascading“). Jedná se o podmíněné vykonání části kódu definované pro zápornou větev else. Pro tento účel se využívá příkaz else if. K příkazu if můžeme definovat libovolný počet těchto příkazů else if a žádný nebo maximálně jeden příkaz else. Syntaxe takového výrazu může být např.:

if (logickýVýraz1) 
	příkaz1;
else if (logickýVýraz2) 
	příkaz2; 
else if (logickýVýraz3) 
	příkaz3;

//… další else if (logickýVýrazX)

else
	příkazN;

kde:

• if - klíčové slovo pro specifikaci prvního rozhodování
• logickýVýraz1 - představuje první podmínku rozhodování 
• příkaz1 - příkaz (nebo složený příkaz, tj. blok příkazů), který je proveden, je-li logickýVýraz1  vyhodnocen jako true
• else - větev, která je vykonána, pokud logickýVýraz1 je vyhodnocen jako false
• if (logickýVýraz2) - představuje další testované rozhodování se specifikací podmínky testování logickýVýraz2 
• příkaz2 - příkaz (nebo složený příkaz, tj. blok příkazů), který je proveden, je-li logickýVýraz1  vyhodnocen jako false a logickýVýraz2 je vyhodnocen jako true
• else if (logickýVýraz3) - stejný princip jako u else if (logickýVýraz2)
• else - větev, která je vykonána, pokud byly všechny předchozí logické výrazy vyhodnoceny jako false
• příkazN - poslední příkaz (nebo složený příkaz, tj. blok příkazů), který je proveden, pokud byly všechny předchozí logické výrazy vyhodnoceny jako false

Pokud potřebujeme provést ve větvi více příkazů, tyto příkazy uzavřeme do složených závorek { }, tj. využijeme složený příkaz. 

Ilustrativní příklad KalkulackaKaskadovani

Algoritmus KalkulackaKaskadovani

• Popis: Vývojový diagram pro řešení aritmetických operací u dvou zadaných čísel - kaskádování
• Zadání: Zkuste navrhnout v hlavním programu algoritmus KalkulackaKaskadovani, který řeší základní aritmetické operace podle zadaného číselného kódu (1 … sčítání, 2 … odečítání, 3 … násobení a 4 … dělení) u dvou uživatelem zadaných čísel a a b. Rozhodování o provedení aritmetické operace bude provedeno pomocí vnořeného větvení v rozhodovacích blocích na základě proměnné kod. Výsledek aritmetické operace vypište v hlavním programu
• Řešení: 
  https://phix.zcu.cz/moodle/pluginfile.php/389319/mod_book/chapter/99026/Algoritmus_Kalkulacka_Kaskadovani.png?time=1580074890232

Program KalkulackaKaskadovani

Pokud jste překopírovali zdrojový kód z aplikace Flowgorithm, asi jste byli překvapeni výpisem chyby: "Use of unassigned local variable 'c'." Tento výpis nás upozorňuje, že ve zdrojovém kódu není ošetřen případ výpisu výsledku výpočtu uložený v proměnné c, když by uživatel zadal nepovolený číselný kód aritmetické operace, např. 5. Tuto chybu lze napravit tak, že za výpis chyby "Zadali jste špatný číselný kód!", v případě zadání špatného kódu operace, umístíme příkaz return. Všimněte si použití příkazu return, kde neuvádíme žádný argument (nebude žádný návrat výsledku). Tento příkaz nám opustí právě vykonávanou metodu (v tomto případě, hlavní metodu). Díky tomu už nebude proveden výpis vypočteného výsledku aritmetické operace, který ani vypočten nebyl - viz Kód 1.

V aplikaci Flowgorithm bylo možné deklarovat obě zadávaná čísla jako Integer, ale pokud jste si zkopírovali vygenerovaný kód v C# z této aplikace, zjistili jste, že u aritmetické operace dělení bylo provedeno tzv. přetypování - konverze datového typu na jiný datový typ. V našem případě se jednalo o konverzi na datový typ double. Poněvadž se konverzí budeme zabývat v pozdější kapitole tohoto kurzu, nyní budeme deklarovat proměnné a, b a c jako datový typ double - reálné číslo.  Pokud bychom v C# deklarovali a a b jako typ int (Integer), aritmetická operace dělení by prováděla celočíselné dělení a poskytovala by jako výsledek výpočtu celé číslo namísto reálného čísla. 

Pojďme dále prozkoumat mírně upravený zdrojový kód programu KalkulackaKaskadovani. Úprava znamenala odstranění přebytečných závorek ve větvích else, které znamenali složený příkaz. V každém rozhodovacím bloku týkající se testování číselného kódu aritmetické operace je větvích else (ve vývojovém diagramu tyto větve představují větve False) umístěn pouze jeden vnořený if a ne více příkazů. 

Závěrečný else nám představuje variantu číselného kódu, která byla zadána špatně (mimo platný rozsah).  Pokud Vás napadlo, že testování číselného kódu operace jsme mohli provést před zadáním obou čísel, na nichž mají být provedeny aritmetické operace, tak Vám gratuluji. Je vhodné uživatele oprostit od zbytečného zadávání dat, když ve finále tyto vstupy nebudou využity.

Dále jsme ve zdrojovém kódu, oproti kódu generovaného pomocí Flowgorithm, nahradili statickou metodu readValue, která je generována aplikaci Flowgorithm. Tuto metodu jsme nahradili konverzemi u jednotlivých datových typů int.Parse.

Ve vývojovém diagramu nezaznamenáváme příkaz Console.ReadKey(), který čeká na stisk nějaké klávesy, abychom si mohli přečíst výpis a došlo k ukončení algoritmu!

static void Main(string[] args)
{
    /*Deklarace proměnných: 'kod' ... celočíselný kód aritmetické operace, 
     * 'a' ... první zadané číslo, 'b' ... druhé zadané číslo; 
     * 'c' ... výsledek aritmetické operace*/
    int kod;
    double a, b, c;
    //Výpis výzvy k zadání operace
    Console.Write("Zadejte kód operace (1 ... sčítání, 2 ... odečítání, " +
        "3 ... násobení, 4 ... dělení): ");
    //Načtení kódu operace
    kod = int.Parse(Console.ReadLine());
    //Výpis výzvy k zadání prvního čísla
    Console.Write("Zadejte A: ");
    //Načtení prvního zadaného čísla
    a = double.Parse(Console.ReadLine());
    //Výpis výzvy k zadání druhého čísla
    Console.Write("Zadejte B: ");
    //Načtení druhého zadaného čísla
    b = double.Parse(Console.ReadLine());
    //Operace sčítání
    if (kod == 1)
        //Sečtení dvou zadaných čísel
        c = a + b;
    //Operace odečtení
    else if (kod == 2)
        //Odečtení dvou zadaných čísel
        c = a - b;
    //Operace násobení
    else if (kod == 3)
        //Násobení dvou zadaných čísel
        c = a * b;
    //Operace dělení
    else if (kod == 4)
        //Podíl dvou zadaných čísel
        c = a / b;
    //Zadání špatného číselného kódu operace
    else
    {
        //Výpis chyby v zadávání kódu
        Console.WriteLine("Zadali jste špatný číselný kód!");
        //Zamezení provádění dalších příkazů - opuštění metody
        return;
    }
    //Výpis textu s hodnotou výsledku
    Console.WriteLine("Výsledek C: {0}", c);
 
    //Čekání na stisk klávesy -> Ukončení programu
    Console.ReadKey();
}

Kód 1: Kód těla hlavní metody programu Kalkulacka – příklad kaskádového příkazu else if a vnořeného rozhodovacího bloku

Na základě výpisu v konzole vidíme, jak by mohl vypadat případ sečtení dvou čísel pomocí metody hlavní metody Main – viz Výstup programu 1 - Kód 1. 

Zadejte kód operace (1 ... sčítání, 2 ... odečítání, 3 ... násobení, 4 ... dělení): 1
Zadejte A: 7
Zadejte B: 5
Výsledek C: 12

Výstup programu 1 - Kód 1: Ukázka výsledku - součet

Zkusme si otestovat dělení dvou čísel – viz Výstup programu 2 - Kód 1: Ukázka výsledku - dělení.

Zadejte kód operace (1 ... sčítání, 2 ... odečítání, 3 ... násobení, 4 ... dělení): 4 
Zadejte A: 7 
Zadejte B: 5 
Výsledek C: 1,4

Výstup programu 2 - Kód 1: Ukázka výsledku - dělení

A nyní zkusíme trochu škodit a otestovat funkčnost naší aplikace. Nastavme hodnotu číselného kódu aritmetické operace mimo povolené meze – viz Výstup programu 3 - Kód 1.

Zadejte kód operace (1 ... sčítání, 2 ... odečítání, 3 ... násobení, 4 ... dělení): 5 
Zadejte A: 7 
Zadejte B: 5 
Zadali jste špatný číselný kód!

Výstup programu 3 - Kód 1: Ukázka výsledku - chybný číselný kód aritmetické operace

9. Vícenásobné větvení

Příkaz se hodí zejména, pokud se rozhodujeme mezi dvěma možnostmi. Pokud máme na výběr z většího počtu možností, jako v předchozím zdrojovém kódu algoritmu KalkulackaKaskadovani (viz kapitola Kaskádování), kde jsme zvolili kaskádové členění podmínek za pomoci příkazu else if. Další možností, jak zvýšit přehlednost a čitelnost je použití příkazu switch. Tento příkaz nahrazuje příliš členité rozdělení podmínek. Obecná syntaxe tohoto příkazu v jazyce C# vypadá následovně:

switch (řídícíVýraz)
{
	case konstanta1:
			příkazy;
                        break;
	case konstanta2:
			příkazy;
			break;

               // … další větve case konstantaX
	default:
		příkazy;
		break;
}

kde:

• switch - klíčové slovo uvozující vícenásobné větvení
• řídícíVýraz - představuje datový typ jako celočíselný, znak, výčtový, textový řetězec nebo logická hodnota, který bude vyhodnocen pouze jednou a pak budou spuštěny příkazy za klíčovým slovem case
• case - testování, zda hodnota řídícího výrazu odpovídá specifikované konstantě konstanta1
• konstanta1 - specifikovaná konstanta pro první sekci. Datový typ konstant uvedených v jednotlivých sekcích (case konstantaX) – tzv. návěštích, musí odpovídat datovému typu řídícího výrazu. Konstanta se v žádném návěští nesmí opakovat
• break - klíčové slovo ukončující část příkazů uvedených za návěštími (v jednotlivých sekcích). Pokud bude dosaženo klíčového slova break, je ukončení provádění bloku switch. Tento příkaz lze nahradit příkazem return, nebo goto – příkaz skoku na určité místo v programu
• default - pokud ani jedna hodnota z konstant uvedených v návěštích neodpovídá hodnotě řídícího výrazu, budou provedeny příkazy za příkazem default. Část default je volitelná, tzn., že není povinná

Každý příkaz switch musí splňovat následující pravidla:

• V řídícím výrazu lze použít jen primitivní datové typy např. int, string (více o datových typech se dozvíte později). U jiných datových typů např. float a double je nutné použít příkaz if
• Návěští case musí obsahovat konstantní výrazy (hodnoty nelze počítat dynamicky za běhu programu), jinak se musí použít příkaz if
• Hodnoty návěští case musí být jedinečné
• V případě potřeby lze spustit jednu skupinu příkazů pro několik návěští tak, že uvedeme několik návěští pod sebou (mezi návěštími v tomto případě nesmí být žádné příkazy). Kód uvedený za posledním z těchto návěští bude spuštěn, bude-li mít řídícíVýraz hodnotu libovolného návěští z celého uvedeného seznamu. Následuje-li však za návěštím alespoň jeden příkaz a není-li tato skupina ukončena příkazem break (nebo jiným z příkazů pro přenos řízení – např. return, goto), ohlásí kompilátor chybu [6]

Ilustrativní příklad KalkulackaVicenasobneVetveni

Algoritmus KalkulackaVicenasobneVetveni

• Popis: Vývojový diagram pro řešení aritmetických operací u dvou zadaných čísel - vícenásobné větvení
• Zadání: Zkuste navrhnout v hlavním programu algoritmus KalkulackaVicenasobneVetveni, který řeší základní aritmetické operace podle zadaného číselného kódu (1 … sčítání, 2 … odečítání, 3 … násobení a 4 … dělení) u dvou uživatelem zadaných čísel a a b. Rozhodování o provedení aritmetické operace bude provedeno pomocí vícenásobného větvení proměnné kod. Výsledek aritmetické operace vypište v hlavním programu
• Řešení: 
  https://phix.zcu.cz/moodle/pluginfile.php/389319/mod_book/chapter/99027/Algoritmus_KalkulaceVicenasobneVetveni.png?time=1580076468995
  
  

Na základě vývojového diagramu KalkulackaVicenasobneVetveni vytvoříme v konzolové aplikaci program, na kterém si vysvětlíme princip vícenásobného větvení. Vývojový diagram algoritmu KalkulackaVicenasobneVetveni byl vytvořen v aplikaci Visio s použitím dodatečně vytvořených vlastních značek deklarace proměnných, které využíváme v aplikaci Flowgorithm.

Program KalkulackaVicenasobneVetveni

Začátek zdrojového kódu je stejný jako v předchozím případě kaskádování algoritmu KalkulackaKaskadovani. Rozdíl spočívá v použití switch pro přehlednějšího členění jednotlivých aritmetických operací umístěných za jednotlivými návěštími – viz Kód 1. V těle switch je také definována větev default, které obsahuje příkazy, které jsou prováděny tehdy, pokud uživatele zadal jinou než povolenou hodnotu číselného kódu operace. 

static void Main(string[] args)
{
    /*Deklarace proměnných: 'kod' ... celočíselný kód aritmetické operace, 
     * 'a' ... první zadané číslo, 'b' ... druhé zadané číslo, 
     * 'c' ... výsledek aritmetické operace*/
    int kod;
    double a, b, c;
    //Výpis výzvy k zadání operace
    Console.Write("Zadejte kód operace (1 ... sčítání, 2 ... odečítání, " +
        "3 ... násobení, 4 ... dělení): ");
    //Načtení kódu operace
    kod = int.Parse(Console.ReadLine());
    //Výpis výzvy k zadání prvního čísla
    Console.Write("Zadejte A: ");
    //Načtení prvního zadaného čísla
    a = double.Parse(Console.ReadLine());
    //Výpis výzvy k zadání druhého čísla
    Console.Write("Zadejte B: ");
    //Načtení druhého zadaného čísla
    b = double.Parse(Console.ReadLine());
    //Přepnutí do příslušné sekce podle hodnoty 'kod'
    switch (kod)
    {
        //Operace sečtení
        case 1:
            //Sečtení dvou zadaných čísel
            c = a + b;
            //Ukončení sekce pro kod == 1
            break;
        //Operace odečtení
        case 2:
            //Odečtení dvou zadaných čísel
            c = a - b;
            break;
        //Operace násobení
        case 3:
            //Násobení dvou zadaných čísel
            c = a * b;
            break;
        //Operace dělení
        case 4:
            //Podíl dvou zadaných čísel
            c = a / b;
            break;
        //Zadání špatného číselného kódu operace
        default:
            //Výpis chyby v zadávání kódu
            Console.WriteLine("Zadali jste špatný číselný kód!");
            //Zamezení provádění dalších příkazů - opuštění metody
            return;
    }
    //Výpis textu s hodnotou výsledku
    Console.WriteLine("Výsledek C: {0}", c);
 
    //Čekání na stisk klávesy -> Ukončení programu
    Console.ReadKey();
}

Kód 1: Kód těla hlavní metody programu KalkulackaVicenasobneVetveni – příklad vícenásobného větvení

Na základě výpisu v konzoli vidíme, jak by vypadal případ odečtení dvou reálných čísel pomocí programu KalkulackaVicenasobneVetveni spuštěného v hlavní metodě Main – viz Výstup programu - Kód 1.

Zadejte kód operace (1 ... sčítání, 2 ... odečítání, 3 ... násobení, 4 ... dělení): 2
Zadejte A: 7
Zadejte B: 5
Výsledek C: 2

Výstup programu 1: Ukázka výsledku programu KalkulackaVicenasobneVetveni

10. Příkaz skoku

Na začátek této kapitoly bychom měli zdůraznit, že užívání příkazu skoku by se měl moderní programátor v C# vyhnout, pokud k tomu není nějakým způsobem nucen! Bez skoků se lze obejít (matematicky dokázáno) a programy jsou pak všeobecně přehlednější a bezpečnější. 

Příkaz skoku slouží ke skoku z jednoho místa ve zdrojovém kódu na jiné místo, které je označeno návěštím. Používá se např. k předčasnému ukončení nějakého strukturovaného příkazu, např. hluboce zapouzdřeného cyklu nebo u vícenásobného větvení. Nedoporučuje se používat pro běžné větvení programu!

Obecná syntaxe příkazu skoku v jazyce C#:

goto IdentifikátorNávěští

kde:

•  goto - klíčové slovo pro příkaz skoku 
• IdentifikátorNávěští - identifikátor návěští, kam se má přemístit vykonávání kódu z daného místa, kde byl kód vykonáván (místo kde je umístěn příkaz skoku)

Obecná syntaxe návěští je:

IdentifikátorNávěští:
	příkaz;

kde:

• IdentifikátorNávěští: - definuje místo v kódu (návěští), odkud se mají vykonávat další příkazy, umístěné za tímto identifikátorem. Oborem platnosti návěští je tělo metody, ve které je návěští definováno

Ilustrativní příklad KalkulackaSkok

Algoritmus KalkulackaSkok

Začátek algoritmu hlavního programu je stejný jako v předchozím algoritmu KalkulackaVicenasobneVetveni. Rozdíl spočívá v použití prvků s názvy návěští, tj. NavestiKonec, NavestiVypis. NavestiVypis využijeme tehdy, pokud má být dalším krokem vypsání vypočtené hodnoty uložené v lokální proměnné c. NavestiKonec využijeme k ukončení algoritmu v případě nesprávného zadání číselného kódu aritmetické operace. 

Na základě vývojového diagramu KalkulackaSkok vytvoříme v konzolové aplikaci program, na kterém si vysvětlíme příkaz skoku používaný v jazyce C#. Vývojový diagram algoritmu KalkulackaSkok byl vytvořen v aplikaci Visio s použitím dodatečně vytvořených vlastních značek deklarace proměnných, kterou využíváme v aplikaci Flowgorithm.

Program KalkulackaSkok

Začátek zdrojového kódu je stejný jako v předchozím případu programu KalkulackaVicenasobneVetveni. Rozdíl spočívá v použití využity spojovací prvky s názvy návěští, tj. NavestiKonec, NavestiVypis. Pokud se v algoritmu přemístíme na návěští NavestiVypis bude proveden výpis v konzoli – viz Kód 1. V těle switch je také definována větev default, která obsahuje příkazy, pokud uživatele zadal jinou než povolenou hodnotu číselného kódu operace. 

Ve zdrojovém kódu, oproti předchozímu programu KalkulackaVicenasobneVetveni, jsme nahradili příkaz break (sloužící k ukončení složeného příkazu ve větvi vícenásobného větvení) a return (ukončující hlavní metodu) pomocí příkazu skoku, tj. pomocí klíčového slova goto. Ke konci zdrojového kódu jsme umístili dvě návěští – NavestiVypis a NavestiKonec. Kód nacházející se za návěštím NavestiVypis provede vypsání výsledku pomocí příkazu WriteLine. Po výpisu textu a hodnoty výsledku program se následně provede příkaz, který je umístěn za návěštím NavestiKonec (za návěštím musí být umístěn vždy nějaký příkaz. Lze použít i prázdný příkaz, tj. ;). Proto dbejte zvýšené opatrnosti s používáním příkazu skoku. Program je po provedení příkazu za návěštím NavestiVypis sekvenčně prováděn dál, tj. prochází další příkaz, který je umístěn za dalším návěštím NavestiKonec. Toto návěští jsme umístili těsně před konec těla metody a tím dojde k ukončení programu. Toto návěští využijeme jako nahrazení příkazu return.

Pokud nepožadujeme vypsat žádnou vypočtenou hodnotu v důsledku chyby (špatně zadaný číselný kód), stačí ukončit program. To provedeme pomocí skoku na návěští NavestiKonec.

Příkaz skoku lze také využít např. k přemístění do první sekce vícenásobného větvení v našem kódu použitím goto case 1.

static void Main(string[] args)
{
    /*Deklarace proměnných: 'kod' ... celočíselný kód aritmetické operace, 
     * 'a' ... první zadané číslo, 'b' ... druhé zadané číslo, 
     * 'c' ... výsledek aritmetické operace*/
    int kod;
    double a, b, c;
    //Výpis výzvy k zadání operace
    Console.Write("Zadejte kód operace (1 ... sčítání, 2 ... odečítání, " +
        "3 ... násobení, 4 ... dělení): ");
    //Načtení kódu operace
    kod = int.Parse(Console.ReadLine());
    //Výpis výzvy k zadání prvního čísla
    Console.Write("Zadejte A: ");
    //Načtení prvního zadaného čísla
    a = int.Parse(Console.ReadLine());
    //Výpis výzvy k zadání druhého čísla
    Console.Write("Zadejte B: ");
    //Načtení druhého zadaného čísla
    b = int.Parse(Console.ReadLine());
    //Přepnutí do příslušné sekce podle hodnoty kod
    switch (kod)
    {
        //Operace sečtení
        case 1:
            //Sečtení dvou zadaných čísel
            c = a + b;
            //Příkaz skoku na definované návěští
            goto NavestiVypis;
        //Operace odečtení
        case 2:
            //Odečtení dvou zadaných čísel
            c = a - b;
            //Příkaz skoku na definované návěští
            goto NavestiVypis;
 
        //Operace násobení
        case 3:
            //Násobení dvou zadaných čísel
            c = a * b;
            //Příkaz skoku na definované návěští
            goto NavestiVypis;
        //Operace dělení
        case 4:
            //Podíl dvou zadaných čísel
            c = a / b;
            //Příkaz skoku na definované návěští
            goto NavestiVypis;
        //Zadání špatného číselného kódu operace
        default:
            //Výpis chyby v zadávání kódu
            Console.WriteLine("Zadali jste špatný číselný kód!");
            //Příkaz skoku na definované návěští
            goto NavestiKonec;
    }
 
    //Definování návěští -> výpis -> ukončení
    NavestiVypis:
    //Výpis textu s hodnotou výsledku
    Console.WriteLine("Výsledek C: {0}", c);
 
    //Definování návěští -> ukončení
    NavestiKonec:
    //Čekání na stisk klávesy -> Ukončení programu
    Console.ReadKey();
}

Kód 1: Kód těla hlavní metody programu KalkulackaSkok – příklad použití skoku namísto příkazů return a break

Na základě výpisu v konzole vidíme, jak by mohl vypadat případ násobení dvou reálných čísel pomocí hlavní metody Main – viz Výstup programu 1 - Kód 1. 

Zadejte kód operace (1 ... sčítání, 2 ... odečítání, 3 ... násobení, 4 ... dělení): 3
Zadejte A: 7
Zadejte B: 5
Výsledek C: 30

Výstup programu 1 - Kód 1: Ukázka výsledku - násobení

Zadejte kód operace (1 ... sčítání, 2 ... odečítání, 3 ... násobení, 4 ... dělení): 5
Zadejte A: 7
Zadejte B: 5
Zadali jste špatný číselný kód!

Výstup programu 2 - Kód 1: Ukázka výsledku - chybný číselný kód aritmetické operace

11. Stručné shrnutí

vek == 16;

vek => 15;

bool mladistvy;

mladistvy = (vek >= 15) && (vek < 18);

neniMladistvy = (vek < 15) || (vek >= 18);

if (mladistvy)
    Sleva();

if (mladistvy) 
{
    Sleva();
    ...
}

int Minimum(int a, int b)
{
    return a < b ? a : b;
}

if (a < b) 
    return a;
else 
    return b;

switch (vek)
{
    case 0:
        ...
        break;
    default:
        ...
        break;
}