Vytisknout celou knihuVytisknout celou knihu

Převod do soustav

Stránky: Moodle ZČU
Kurz: KPV/TI Technická informatika ve strojírenství - cvičení
Kniha: Převod do soustav
Vytiskl(a): Nepřihlášený host
Datum: pondělí, 9. listopadu 2026, 12.35

Obsah

1. PrevodDoSoustav

Vytvořte aplikaci pro převod zadaného celého čísla v desítkové soustavě do binární (dvojková), nebo hexadecimální (šestnáctkové) soustavy. U soustavy, do které se celé číslo převádí, si uživatel si vybere, na kolik bytů se má konvertované číslo zobrazit.  

Účel příkladu

  • Převod celého čísla na znak (v C# např. (char)65 → 'A' )
  • Převod znaku na celočíselnou hodnotu ordinálního typu (např. celého čísla, znaku, atd., v C# např. (int)'A' → 65)
  • Celočíselné dělení - /
  • Zbytek po celočíselném dělení - %
  • Cyklus s pevným krokem 
  • Podmínka 
  • Výpočet s použitím podprogramu – funkce
  • Konverze celého čísla na text 

Typ aplikace
  • Konzolová aplikace
Popis úkolu 
  • Převod čísel do binárního nebo hexadecimálního tvaru 
Funkčnosti

  • Při spuštění programu se provede výpis výzvy pro zadání celého čísla, které má být konvertováno do vybrané soustavy. Číslo je předáno podprogramu (funkce), která zajistí konverzi do uživatelem vybrané soustavy a zobrazení na specifikovaný počet bytů. Výsledek konverze je vypsán v hlavním programu. Pokud došlo k přetečení, je tato informace vypsána spolu s konvertovaným číslem 
  • Po výpisu konvertovaného čísla bude aplikace ukončena po stisku klávesy

Výstup programu

Ukázka výpisu převodu čísla do binární soustavy v hlavní metodě programu PrevodDoSoustav

Výstup programu: Ukázka výpisu převodu čísla do binární soustavy v hlavní metodě programu PrevodDoSoustav

1.1. Analýza a návrh řešení

V matematice dnes běžně používáme desítkovou soustavu. Jak již sám název napovídá, tato soustava obsahuje 10 prvků: číslice 0 ÷ 9. Tato soustava však není jedinou soustavou, kterou lze využít. Další soustavou je např. šedesátková soustava. Takovou soustavu využíváme pro měření minut, nebo sekund, kde časový okamžik lze zapsat jako údaj o třech číslicích - hodiny : minuty : sekundy. 

V oblasti informatiky se využívají různé soustavy např. dvojková, osmičková, šestnáctková. 

Celá čísla jsou vyjádřena posloupností 0 a 1 ve dvojkové soustavě. Při převodech mezi soustavami se vychází ze skutečnosti, že každé celé číslo lze vyjádřit polynomem mocnin základu číselné soustavy. Tedy:

n= \sum{c_i \ast d^i}

kde:

  • d ... základ číselné soustavy (např. 2, 8, 10, 16)
  • i ... řád
  • p ... počet číslic
  • ci ... jednotlivé číslice

Př.: 

V desítkové soustavě:

1234 = 1*103 + 2*102 + 3*101 + 4*100

Ve dvojkové soustavě:

1234 = 1*210 + 0*29 + 0*28 + 1*27 + 1*26 + 0*25 + 1*24 + 0*23 + 0*22 + 1*21 + 0*20 

V našem příkladu budeme konvertovat číslo z desítkové soustavy do:

  • Dvojkové (binární) soustavy - obsahuje 2 prvky: číslice 0 a 1. Hodnota vyjádřená v této soustavě je tedy rozepsána do jednotlivých pozic (bitů - bit je značen b), kde každá pozici obsahuje 0, nebo 1. Se zvyšováním počtu pozic, roste i možná hodnota, kterou lze uložit. 1 Byte (značen B) obsahuje 8 bitů, tedy 8 pozic. Na 1 B, tedy existuje 256 různých kombinací, protože 28=256. Následující obrázek ukazuje princip převodu čísla 90 v desítkové soustavě - označme jej následujícím způsobem (90)10 do dvojkové soustavy (?)2 - viz Obrázek 1.  Podstatou je využití celočíselného dělení čísla 90 v desítkové soustavě základem soustavy, do které chceme převádět, v našem případě základu 2. Dále je využita operace zbytku po celočíselném dělení. Díky tomu získáme hodnoty, které přepíšeme odzadu. Tím získáme číslo zapsané ve dvojkové soustavě (1011010)2. 

Princip převodu čísla z desítkové do dvojkové soustavy

Obrázek 1: Princip převodu čísla z desítkové do dvojkové soustavy

Jaký je opačný postup převodu z dvojkové do desítkové soustavy? Pro převod čísla z dvojkové soustavy do desítkové využijeme součet hodnot na všech pozicích, vzniklých násobením hodnot na jednotlivých pozicích základem 2 umocněného příslušnými exponenty představující řád na příslušné pozici. Počáteční řád 0 přísluší první pozici vpravo. Pokud bychom převáděli číslo z dvojkové soustavy např. (01011010)2=(?)10 do desítkové, použili bychom následující postup - viz Obrázek 2.
Princip převodu čísla z dvojkové do desítkové soustavy
Obrázek 2: Princip převodu čísla z dvojkové do desítkové soustavy
Vidíme, že číslo zapsané ve dvojkové soustavě jako (01011010)2 představuje v desítkové soustavě číslo 90, tj. (01011010)2 = (90)10 . Pro účely demonstrace konverze hodnoty uložené na 1 Byte, což znamená 8 pozic, jsme ponechali 0 na pozici úplně vlevo, která však při konverzi do desítkové soustavy znamená hodnotu 0, protože 0*27=0. To znamená, že tato vedoucí nula nemusí být v zápisu čísla ve dvojkové soustavě uváděna, tj. (1011010)2  (pokud bychom potřebovali zobrazit všechny pozice např. na dvou 2 B, tzn. 16 pozic, doplnili bychom před stávající řetězec dalších osm nul zleva).  
Nejmenší číslo které lze do 8 bitů ve dvojkové soustavě uložit jsou samé nuly, tj. osm nul za sebou (v desítkové soustavě představuje hodnotu 0). Největší hodnotu představuje osm jedniček za sebou (hodnota 255 v desítkové soustavě).
  • Šestnáctkové (hexadecimální) soustavy - obsahuje 16 prvků: číslice  0 ÷ 9 a písmena, která vyjadřují zbytek větší než 9, tzn. A (pro číslo 10), B(11), C(12), D(13), E(14) a F(15). Na následujícím obrázku je znázorněn princip převodu čísla z desítkové do šestnáctkové soustavy - viz Obrázek 3. Jak vidíme, je využit ten samý princip převodu jako u dvojkové soustavy s tím rozdílem, že základ (dělitel) je v tomto případě hodnota 16. U zbytku, který je větší než hodnota 9, je zbytek nahrazen písmeny, v našem případě je číslice 10 nahrazena písmenem A.

Princip převodu čísla z desítkové do šestnáctkové soustavy

Obrázek 3: Princip převodu čísla z desítkové do šestnáctkové soustavy

Pro zpětný převod je znovu využito předchozího principu. Zde však sčítáme hodnoty vzniklé násobením hodnot na všech pozicích násobených společným základem 16, který je však umocněn příslušným řádem. Namísto písmen dosazujeme příslušné celočíselné hodnoty. 

Princip převodu čísla z desítkové do šestnáctkové soustavy

Obrázek 4: Princip převodu čísla z šestnáctkové do desítkové soustavy

Zkusme si nyní popsat algoritmus PrevodDoSoustav zaznamenaný pomocí vývojového diagramu - viz Obrázek 5. V hlavním program je deklarována proměnná n, do které je uloženo číslo z desítkové soustavy, které má být konvertováno do dvojkové nebo šestnáctkové soustavy. V hlavním programu je volán podprogram (funkce) Prevod, který navrací konvertované vstupní číslo n v podobě textového řetězce reprezentující číslo ve vybrané soustavě. 

Hlavní program PrevodDoSoustav pro konverzi čísel z desítkové soustavy do dvojkové, nebo šestnáctkové soustavy

Obrázek 5: Hlavní program PrevodDoSoustav pro konverzi čísel z desítkové soustavy do dvojkové, nebo šestnáctkové soustavy

Funkce Prevod zajišťuje konverzi formálního parametru n, který reprezentuje číslo v desítkové soustavě. V této funkci jsou deklarovány následující proměnné:

  • p ... počet bitů
  • c ... zbytek po celočíselném dělení
  • d ... dělitel (základ soustavy)
  • i ... pozice bitu ve výstupním textu
  • s ... výstupní text (převedené číslo)
  • soustava ... index vybrané soustavy

Prvním krokem je inicializace textového řetězce s, do něhož budou postupně ukládány číslice (konvertovaná čísla), nebo také písmena (pokud bude prováděn převod do šestnáctkové soustavy). U podprogramu musíme zajistit validaci zvoleného typu soustavy. Ta je realizována pomocí cyklu s podmínkou na konci, v jehož těle se nachází příkazy pro výpis výzvy k výběru typu soustavy pomocí indexu (0 ... dvojková soustava, 1 ... šestnáctková soustava) a zároveň příkaz načtení hodnoty indexu do proměnné soustava. Pokud uživatel nezadá validní index, nedojde k opuštění cyklu a uživatel musí vybrat typ soustavy znovu. 

Další cyklus s podmínkou na konci slouží k validaci počtu bytů zvolené uživatelem. Uživatel může zadat pouze některou z přípustných variant čísel 1, 2, 4, nebo 8. Tyto hodnoty představují počet bytů, tj. 1 B, 2 B, 4 B, nebo 8 B. Tato hodnota určuje maximální hodnotu, kterou lze uložit. Pokud bude rozsah překročen, nastane tzv. přetečení. Pokud uživatel zadá jiný počet bytů, proběhne znovu cyklus, který zahrnuje výpis a načtení hodnoty do proměnné p. Do proměnné p je pouze dočasně uložena hodnota počtu bytů, kterou následně využijeme pro určení celkového počtu pozic u jednotlivých soustav (rozhodování jakou soustavu uživatel zvolil je realizováno pomocí rozhodovací bloku s podmínkou soustava == 0). Do těchto pozic budeme zapisovat jednotlivé hodnoty zbytku po celočíselném dělení konvertovaného čísla základem soustavy (dělitelem) vypočítané v každé iteraci (tedy pro každé i značící řád). Procházení jednotlivých pozic (příslušného řádu) je realizováno pomocí cyklu s krokem - víme dopředu, kolik iterací má proběhnout. U dvojkové soustavy lze jeden 1 B zobrazit na 8 pozicích (8 bitech). U šestnáctkové soustavy nám však postačí pro 1 B pouze 2 pozice (lze ukládat i písmena). Po vypočtení zbytku po celočíselném dělení (hodnoty zapsané do jednotlivé pozice) musíme rozhodnout, zda zbytek je menší než hodnota 10. Je to z důvodu zapisování písmen namísto celočíselné hodnoty v případě šestnáctkové soustavy - musíme nahradit např. číslo 10 písmenem "A" (ve Flowgorithm nelze používat jednotlivé znaky, ale musí být použit textový řetězec - v C# budeme používat znaky - typ char např. 'A'). Jak ale zapsat do výsledného textového řetězce jednotlivé znaky? 

Je více možností. První možností je např. využití konverze čísla na text pomocí ToString. Další možností je použití rozhodovací bloku, kde na základě hodnoty, kterou porovnáváme v podmínce, doplníme příslušnou číslici do výsledného textového řetězce. My však využijeme chytřejšího principu. Budeme používat jednotlivé číslice a znaky uložené v ASCII tabulce. Na pozici 48 se v tabulce ASCII nachází číslice '0'. Na pozici 49 se nachází číslice '1', atd. Tyto dvě číslice využijeme jak ve dvojkové, tak v šestnáctkové soustavě. Ostatní číslice a písmena budou vyžita pouze v šestnáctkové soustavě. Ve Flowgorithm pro účely vyhledávání znaku na určité pozici, nebo návratu pozice určitého znaku využijeme dvou příkazů:

  • ToChar(c) - provádí konverzi kódu znaku uloženého v celočíselné proměnné c na znak, tj. navrátí znak nacházející se na celočíselné pozici c v tabulce ASCII
  • ToCode(q) - provádí konverzi znaku uloženého v proměnné q (textovém řetězci) na kód znaku, tj. navrátí celočíselnou pozici znaku q v tabulce ASCII

Následující přiřazení znaku na určitou pozici provedeme pomocí příkazu (platí pro konverzi celočíselné hodnoty uložené v c na číslici): 

s = ToChar(c + ToCode("0")) & s

kde:

  • ToCode("0") ... návrat pozice číslice "0" v ASCII → číslo 48
  • c + ToCode("0") ... na kterou pozici (hodnota v c) se máme posunout
  • ToChar(c + ToCode("0")) ... návrat číslice (znaku), která se se nachází na pozici, na kterou jsme se posunuli, např. hodnota vypočteného zbytku po celočíselném dělení je rovna jedné, tzn. c = 1 → ToChar(49) ... návrat číslice "1" 
  • např. ToChar(49) & s ... připojení číslice "1" zleva ke stávajícímu textovému řetězci s
  • např. s = ToChar(49) & s ... přepsání starého řetězce uloženým v s novým, tj. stávající řetězec s připojenou číslicí "1"

Pokud byl vypočtený zbytek uložený v proměnné c větší než 9, musíme do stávajícího textového řetězce s připojit písmeno (platí pro konverzi celočíselné hodnoty uložené v c  na písmeno):

s = ToChar(c - 10 + ToCode("A")) & s

kde:

  • ToCode("A") ... návrat pozice znaku "A" v ASCII → číslo 65
  • c -10 ... o kolik pozic se máme posunout od čísla 10 (číslo 10 představuje písmeno "A")
  • (c -10 + ToCode("A") ... o kolik pozic se máme posunout od písmene "A" (pokud je zbytek po celočíselném dělení větší než 9, např. c = 11, musí být za něj dosazeno písmeno "B". Toto písmeno je o jednu pozici za písmenem "A", tzn. c - 10 = 11-10 = 1 ... písmeno "B" je o 1 pozici za "A"
  • např. ToChar(66) & s ... připojení písmene "B" zleva ke stávajícímu textovému řetězci
  • např. s = ToChar(66) & s ... přepsání starého řetězce uloženým v s novým, tj. stávající řetězec s připojeným písmenem "B" 

Kvůli vizuálnímu oddělení jednotlivých částí textového řetězce je použita podmínka, kde za každé 4 pozice je do textového řetězce vložena mezera. 

Pro další iteraci (další řád) musí být vypočtena nová hodnota konvertovaného čísla pomocí celočíselného dělení konvertovaného čísla základem soustavy, tj. pomocí příkazu n = n / d. 

Pokud jsme provedli zápis hodnot na všech pozicích a stále nám zbývá v proměnné n nějaká hodnota, tj. n > 0, znamená to, že jsme chtěli do čísla v soustavě uložit větší hodnotu, než je schopno pojmout (rozsah proměnné záleží na zvoleném počtu bytů). Jedná se o tzv. přetečení. 

Návratem funkce je výsledný textový řetězec. Podstata popisovaného principu je znázorněna v následujícím vývojovém diagramu - viz Obrázek 6.

Podprogram Prevod - funkce konverzi celého čísla z desítkové soustavy do zvolené soustavy (dvojkové, nebo šestnáctkové)

 Obrázek 6: Podprogram Prevod - funkce pro konverzi celého čísla z desítkové soustavy do zvolené soustavy (dvojkové, nebo šestnáctkové)

1.2. C#

Načtení celého čísla z desítkové soustavy do proměnné n (která je zároveň skutečným parametrem metody Prevod) ve statické hlavní metodě je realizováno pomocí příkazu TryParse - viz Kód 1. Pokud uživatel zadal nevalidní číslo např. text, je proměnná inicializována přednastavenou počáteční hodnotou specifikovanou pro datový typ int - jedná se totiž o metodu s výstupními parametry. Výsledek převodu ve formě textového řetězce je vypsán v následujícím příkazu Console.WriteLine, kde je před výsledný textový řetězec statické metody Prevod připojen text "Výsledek: ". 

static void Main(string[] args)
{
    /* Deklarace: 'n' ... číslo z desítkové soustavy, které má být převedeno
     * do vybrané soustavy (dvojkové - binární, šestnáctkové - hexadecimální) */
    int n;
 
    Console.WriteLine("Převod čísla do soustavy");
 
    // Výzva k zadání čísla
    Console.Write("Zadejte číslo, které má být převedeno: ");
    // Načtení konvertovaného čísla
    int.TryParse(Console.ReadLine(), out n);
    
    // Výpis konvertovaného čísla do požadované soustavy
    Console.WriteLine("Výsledek: " + Prevod(n));
}

Kód 1: Program PrevodDoSoustav - deklarace hlavní statické metody Main 

Do deklarované metody Prevod bylo posláno načtené číslo určené k převodu - viz Kód 2. Tento parametr je předán hodnotou, tzn. jeho hodnota je nakopírována do formálního parametru n. V úvodu těla metody jsou deklarovány následující proměnné:

  • p ... počet bitů
  • c ... zbytek po celočíselném dělení
  • d ... dělitel (základ soustavy)
  • s ... výstupní text (převedené číslo)
  • i ... pozice bitu ve výstupním textu
  • soustava ... index vybrané soustavy

Po inicializaci, tj. přiřazení prázdného textového řetězce výslednému textovému řetězci s, je pomocí cyklu s podmínkou na konci zajištěno načtení validního indexu typu soustavy (0 ... dvojková, 1 ... šestnáctková). Kontrola validity je provedena v podmínce cyklu pomocí operátoru nebo ||. Pokud index typu soustavy je menší než nula nebo větší než 1, je znovu proveden výpis výzvy k zadání indexu a jeho opětovné načtení.

Druhý cyklus s podmínkou na konci je určen pro výběr validního počtu bytů, který je uložen do proměnné p. Tato proměnná je zejména určena pro uložení počtu pozic s jednotlivými hodnotami uložených ve výsledném textu, obsahující převedené číslo do vybrané soustavy. Dočasně uložená hodnota počtu bytů je nahrazena novou hodnotou, která je vypočtena násobením této hodnoty počtem pozic, které jsou potřebné pro uložení jednoho bytu v konkrétní soustavě - pro dvojkovou soustavu je to 8 pozic (příklad týkající se uložení čísla 90 na 1 B ve dvojkové soustavě jsme uvedli v předchozí analýze). Výsledný textový řetězec bude vypadat takto: "0101 1010". Požadujeme, aby pro lepší čitelnost byla po každé 4 pozici do textového řetězce vložena mezera. U šestnáctkové soustavy je zapotřebí pouze 2 pozic pro uložení 1 B (pro zápis čísla 90 stačila pouze 1 číslice a 1 písmeno, tj. "5A").  

Jádrem výpočtu jednotlivých hodnot ve výsledném řetězci je cyklus s krokem. Řídící proměnná i tohoto cyklu symbolizuje jednotlivé pozice ve výsledném textovém řetězci. Tento cyklus probíhá od 1 do počtu vypočtených pozic, uložených v proměnné p. Hodnota na pozici je rovna zbytku celočíselného dělení konvertovaného čísla základem soustavy (dělitelem). Po vypočtení hodnoty na pozici je zapotřebí tuto hodnotu konvertovat na číslici, nebo písmeno. Rozhodnutí, zda se jedná o konverzi celočíselné hodnoty zbytku uložené v c na číslici, nebo na písmeno, je zajištěno pomocí podmínky c < 10. Pokud je zbytek menší než 10, jedná se o konverzi čísel v rozmezí 0 ÷ 9 na číslici. V opačném případě je hodnota ve zbytku převedena na písmeno: 

  • Konverze čísel na číslice je umístěna ve složeném příkazu za podmínkou. Konverze celočíselné hodnoty na znak je provedena pomocí přetypování (char). Podstatou konverze je nalezení znaku na určité pozici v ASCII. Tato celočíselná pozice znaku je vypočtena ze součtu zbytku po celočíselném dělení, ke kterému je přičteno celé číslo, reprezentující pozici znaku '0' v ASCII (získaného pomocí (int)'0'). Takto získaný znak připojíme ke stávajícímu výslednému řetězci
  • Konverze čísla na písmeno je umístěna ve složeném příkazu za else. Je zde použito stejného principu jako v předchozí konverzi s tím rozdílem, že je vypočteno, o kolik pozic se musíme v ASCII tabulce posunout od písmene 'A'

Pro vizuální přehlednost je ve výsledném textovém řetězci za každý výpis hodnot na čtyřech pozicích umístěna mezera. Tento trik je proveden pomocí podmínky i % 4 == 0.

Před vstupem do další iterace musí být přepočtena hodnota uložená v proměnné n. Tato hodnota je výsledkem celočíselného dělení základem soustavy. 

Pokud jsme provedli zápis hodnot na všech pozicích (tzn. proběhly všechny iterace v cyklu s krokem) a stále je v proměnné n hodnota větší než 0, tj. n > 0, znamená to, že došlo k přetečení. Uživatel chtěl do konvertovaného čísla ve vybrané soustavě uložit větší hodnotu, než je schopno pojmout (rozsah proměnné záleží na zvoleném počtu bytů). Informaci o přetečení připojíme do výsledného textového řetězce s, který je návratem volané statické metody Prevod - viz Kód 2.

/* Metoda s textovým návratem - převod čísla (parametr 'n') z desítkové soustavy 
 * do dvojkové (binární), nebo šestnáctkové (hexadecimální) soustavy */ 
static string Prevod(int n)
{
    /* Deklarace: 'p' ... počet bitů; 'c' ... zbytek po celočíselném dělení; 
     * 'd' ... dělitel (základ soustavy); 's' ... výstupní text (převedené číslo); 
     * 'i' ... pozice bitu ve výstupním textu; 'soustava' ... index vybrané soustavy */
    int p, c, d, i, soustava;
    string s;
 
    // Inicilizace - výstupní text je nastaven na prázdnou hodnotu
    s = "";
 
    // Validace indexu zvoleného typu soustavy
    do
    {
        // Výzva k výběru typu soustavy
        Console.Write("Zadejte index soustavy (0 ... dvojková, 1 ... šestnáctková): ");
 
        // Načtení indexu zvoleného typu soustavy
        int.TryParse(Console.ReadLine(), out soustava);
    }
    while (soustava < 0 || soustava > 1);
 
    // Validace zvoleného počtu bytů
    do
    {
 
        // Výzva k zadání počtu bytů (počet pozic ve výsledném řetězci)
        Console.Write("Zadejte počet bytů (1, 2, 4, 8): ");
 
        // Načtení počtu bytů - následně bude převeden na bity
        int.TryParse(Console.ReadLine(), out p);
    }
    while (p != 1 && p != 2 && p != 4 && p != 8);
 
    // Test, zda byla vybrána dvojková soustava
    if (soustava == 0)
    {
        /* Byla vybrána dvojková (binární) soustava - nastavení hodnoty 
         * počtu bitů v závislosti na počtech bytů (1 byte = 8 bitů v binární soustavě) */
        p = p * 8;
 
        // Nastavení dělitele na hodnotu 2
        d = 2;
    }
    else
    {
        /* Byla vybrána šestnáctková (hexadecimální) soustava - nastavení hodnoty počtu 
         * bitů v závislosti na počtech bytů (1 byte lze zobrazit na 2 pozice v šestnáctkové 
         * soustavě) */
        p = p * 2;
 
        // Nastavení dělitele na hodnotu 2
        d = 16;
    }
 
    // Cyklus s krokem – pro všechny bity (počet bitů uložen v proměnné 'p')
    for (i = 1; i <= p; i++)
    {
        // Nastavení zbytku = hodnota po celočíselném dělení konvertovaného čísla dělitelem
        c = n % d;
 
        // Test, zda se jedná o konverzi čísla na číslici, nebo čísla na písmeno (podle hodnoty v 'c')
        if (c < 10)
        {
            /* Pokud je zbytek menší než 10 (dvojková soustava) jedná se o konverzi čísla na číslici (znak)
             * Výstupní text = vložení znaku před stávající text (znak je v ASCII na pozici, která 
             * je rovna hodnotě zbytku + ordinální hodnota znaku '0') */
            s = (char)(c + (int)'0') + s;
        }
        else
        {
            /* Pokud je zbytek větší nebo roven 10 (šestnáctková soustava) jedná se o konverzi čísla 
             * na písmeno (znak) - výstupní text = vložení znaku před stávající text 
             * (znak je v ASCII na pozici, která je rovna hodnotě zbytku - 10 + 
             * ordinální hodnota znaku 'A') */
            s = (char)(c - 10 + (int)'A') + s;
        }
 
        // Pokud je bit na násobkem čtvrté pozice ...
        if (i % 4 == 0)
        {
            // Vložení mezery do výstupního textu před stávající text
            s = " " + s;
        }
 
        // Vstupní číslo = celočíselné dělení stávajícího konvertovaného čísla dělitelem
        n = n / d;
    }
 
    // Pokud je konvertované číslo větší než nula ...
    if (n > 0)
    {
        // Výstupní text = stávající výstupní text + "přetečení"
        s = s + " přetečení";
    }
 
    // Výstupní text je návratem metody
    return s;

}

Kód 2: Deklarace statické metody s textovým návratem s názvem Prevod 

1.3. Výsledný kód

Následující zdrojový kód je kompletací předešlých kódů programu PrevodDoSoustav, který je umístěn v souboru Program.cs - viz Kód 1.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace PrevodDoSoustav
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Deklarace: 'n' ... číslo z desítkové soustavy, které má být převedeno
             * do vybrané soustavy (dvojkové - binární, šestnáctkové - hexadecimální) */
            int n;
 
            Console.WriteLine("Převod čísla do soustavy");
 
            // Výzva k zadání čísla
            Console.Write("Zadejte číslo, které má být převedeno: ");
            // Načtení konvertovaného čísla
            int.TryParse(Console.ReadLine(), out n);
            
            // Výpis konvertovaného čísla do požadované soustavy
            Console.WriteLine("Výsledek: " + Prevod(n));
 
            // Čekání na stisk klávesy -> ukončení programu
            Console.ReadKey();
        }
 
        /* Metoda s textovým návratem - převod čísla (parametr 'n') z desítkové soustavy 
         * do dvojkové (binární), nebo šestnáctkové (hexadecimální) soustavy */ 
        static string Prevod(int n)
        {
            /* Deklarace: 'p' ... počet bitů; 'c' ... zbytek po celočíselném dělení; 
             * 'd' ... dělitel (základ soustavy); 's' ... výstupní text (převedené číslo); 
             * 'i' ... pozice bitu ve výstupním textu; 'soustava' ... index vybrané soustavy */
            int p, c, d, i, soustava;
            string s;
 
            // Inicilizace - výstupní text je nastaven na prázdnou hodnotu
            s = "";
 
            // Validace indexu zvoleného typu soustavy
            do
            {
                // Výzva k výběru typu soustavy
                Console.Write("Zadejte index soustavy (0 ... dvojková, 1 ... šestnáctková): ");
 
                // Načtení indexu zvoleného typu soustavy
                int.TryParse(Console.ReadLine(), out soustava);
            }
            while (soustava < 0 || soustava > 1);
 
            // Validace zvoleného počtu bytů
            do
            {
 
                // Výzva k zadání počtu bytů (počet pozic ve výsledném řetězci)
                Console.Write("Zadejte počet bytů (1, 2, 4, 8): ");
 
                // Načtení počtu bytů - následně bude převeden na bity
                int.TryParse(Console.ReadLine(), out p);
            }
            while (p != 1 && p != 2 && p != 4 && p != 8);
 
            // Test, zda byla vybrána dvojková soustava
            if (soustava == 0)
            {
                /* Byla vybrána dvojková (binární) soustava - nastavení hodnoty 
                 * počtu bitů v závislosti na počtech bytů (1 byte = 8 bitů v binární soustavě) */
                p = p * 8;
 
                // Nastavení dělitele na hodnotu 2
                d = 2;
            }
            else
            {
                /* Byla vybrána šestnáctková (hexadecimální) soustava - nastavení hodnoty počtu 
                 * bitů v závislosti na počtech bytů (1 byte lze zobrazit na 2 pozice v šestnáctkové 
                 * soustavě) */
                p = p * 2;
 
                // Nastavení dělitele na hodnotu 2
                d = 16;
            }
 
            // Cyklus s krokem – pro všechny bity (počet bitů uložen v proměnné 'p')
            for (i = 1; i <= p; i++)
            {
                // Nastavení zbytku = hodnota po celočíselném dělení konvertovaného čísla dělitelem
                c = n % d;
 
                // Test, zda se jedná o konverzi čísla na číslici, nebo čísla na písmeno (podle hodnoty v 'c')
                if (c < 10)
                {
                    /* Pokud je zbytek menší než 10 (dvojková soustava) jedná se o konverzi čísla na číslici (znak)
                     * Výstupní text = vložení znaku před stávající text (znak je v ASCII na pozici, která 
                     * je rovna hodnotě zbytku + ordinální hodnota znaku '0') */
                    s = (char)(c + (int)'0') + s;
                }
                else
                {
                    /* Pokud je zbytek větší nebo roven 10 (šestnáctková soustava) jedná se o konverzi čísla 
                     * na písmeno (znak) - výstupní text = vložení znaku před stávající text 
                     * (znak je v ASCII na pozici, která je rovna hodnotě zbytku - 10 + 
                     * ordinální hodnota znaku 'A') */
                    s = (char)(c - 10 + (int)'A') + s;
                }
 
                // Pokud je bit na násobkem čtvrté pozice ...
                if (i % 4 == 0)
                {
                    // Vložení mezery do výstupního textu před stávající text
                    s = " " + s;
                }
 
                // Vstupní číslo = celočíselné dělení stávajícího konvertovaného čísla dělitelem
                n = n / d;
            }
 
            // Pokud je konvertované číslo větší než nula ...
            if (n > 0)
            {
                // Výstupní text = stávající výstupní text + "přetečení"
                s = s + " přetečení";
            }
 
            // Výstupní text je návratem metody
            return s;
        }
 
    }
}

Kód 1: Program PrevodDoSoustav - deklarace hlavní statické metody Main včetně deklarace další metody

Výstup programu

Na následujícím výstupu programu vidíme výpis převedeného čísla 90 do dvojkové soustavy, které je zobrazeno (jakoby uloženo) na 1 B - viz Výstup programu 1 - Kód 1.   


Výstup programu 1 - Kód 1: Ukázka výpisu převodu čísla do binární soustavy v hlavní metodě programu PrevodDoSoustav

Pokud bychom číslo 90 chtěli převést do šestnáctkové soustavy, výsledek převodu by vypadal následovně - viz Výstup programu 2 - Kód 1. 


Výstup programu 2 - Kód 1: Ukázka výpisu převodu čísla do šestnáctkové soustavy v hlavní metodě programu PrevodDoSoustav

Posledním testovaným případem konverze je přetečení. Jak již z kapitole věnované analýze příkladu víme, do 1 Byte je možné uložit hodnotu 0 ÷ 255. Zkusme tedy vypsat hodnotu 256 na 1 Byte, tj. na 8 pozicích ve dvojkové soustavě, nebo na 2 pozicích v šestnáctkové soustavě - viz Výstup programu 3 - Kód 1. 


Výstup programu 3 - Kód 1: Ukázka výpisu přetečení při převodu čísla do dvojkové soustavy v hlavní metodě programu PrevodDoSoustav

Ve výpisu vidíme samé nuly, protože by teprve na 9. pozici byla zapsána číslice (znak) '1'. Hodnota 256 je ve dvojkové soustavě zapsána jako (1 0000 0000)2 a v šestnáctkové soustavě (100)16. Potřebovali bychom tedy minimálně 9 pozic pro výpis tohoto čísla ve dvojkové soustavě, nebo 3 pozice pro výpis v šestnáctkové, tzn. 2 B. 

2. PrevodDoSoustavWPF

Vytvořte aplikaci pro převod zadaného celého čísla v desítkové soustavě do binární (dvojková), nebo hexadecimální (šestnáctkové)  soustavy. U soustavy, do které se celé číslo převádí, si uživatel si vybere, na kolik bytů se má konvertované číslo zobrazit.  

Účel příkladu

  • Metoda s návratem pro převod celého čísla na znak: (char)65 → 'A' 
  • Metoda s návratem navracející celočíselnou hodnotu ordinální typu (např. celého čísla, znaku, atd.)  – (int)'A' → 65 
  • Zjištění indexu vybrané položky v seznamu 
  • Celočíselné dělení - div 
  • Zbytek po celočíselném dělení - mod 
  • Cyklus s pevným krokem 
  • Podmínka 
  • Výpočet s použitím podprogramu – funkce, procedura 
  • Konverze celého čísla na text 
  • Výpis textu do pole na formuláři 
  • Zavření formuláře 
  • Vlastnosti objektu 
  • Metody objektu 

Typ aplikace
  • WPF aplikace
Popis úkolu 
  • Převod čísel do binárního nebo hexadecimálního tvaru 
Funkčnosti

  • Při stisku tlačítka Převod se provede test na konverzi zadaného čísla uživatelem na formuláři. Pokud konverzi nelze provést provede se vypsání chybové hlášky a uživatel je přepnut zpět do objektu pro zadání čísla. Pokud konverzi lze provést, je předáno načtené číslo do metody s návratem, která zajistí konverzi do uživatelem vybrané soustavy a specifikovaného počtu bytů. Výsledek konverze je vypsán do objektu na formulář. Pokud došlo k přetečení, je tato informace vypsána spolu s konvertovaným číslem 
  • Při stisku tlačítka Konec se provede zavření formuláře   

Výstup programu


Výstup programu 1: Ukázka GUI při počátečním spuštění programu PrevodDoSoustavWPF

Výsledek:


Výstup programu 2: Ukázka převodu čísla do dvojkové soustavu programu PrevodDoSoustavWPF

2.1. Analýza a návrh řešení

V příkladu bude využit stejný princip převodu čísla do zvoleného typu soustavy jako v předchozím příkladu PrevodDoSoustav, proto již není zapotřebí provádět detailní analýzu. 

Pro rozložení jednotlivých prvků na formuláři použijeme Grid vložený do formuláře, který rozdělíme na 3 řádky - viz Obrázek 1. Do prvního řádku Grid  (s indexem 0) umístíme objekt typu GroupBox do něhož znovu vložíme objekt typu Grid, který tentokrát rozdělíme na dva sloupce. Do prvního sloupce vložíme objekt StackPanel, do něhož vložíme dva další objekty typu StackPanel. V prvním StackPanel vložíme popisek (Label) a objekt typu ComboBox, ve kterém si uživatel vybere typ soustavy. Ve druhém spodním StackPanel bude umístěn popisek (Label) a objekt typu ComboBox, ve kterém si uživatel vybere počet bytů, na které se převedené číslo bude vypisovat. 

Do druhého sloupce Gridu (umístěného v GroupBox) vložíme taktéž dva objekty typu StackPanel. Vnitřní StackPanel bude sloužit pro umístění popisku (Label) a vstupního pole typu TextBox pro specifikaci čísla, které bude převedeno do zvoleného typu soustavy.

Do druhého řádku řádku Grid ve formuláři GroupBox, do kterého umístíme StackPanel, do něhož vložíme objekt typu Label s popiskem "Výsledek". Pod tento objekt umístíme další objekt typu TextBox do něhož budeme vypisovat převedené číslo do zvoleného typu soustavy. 

Do posledního řádku Grid formuláře umístíme další StackPanel, do něhož umístíme dva objekty typu WrapPanel. Do prvního WrapPanel umístíme tlačítko pro konverzi zadaného čísla do zvoleného typu soustavy. Do druhého WrapPanel umístíme tlačítko pro ukončení aplikace.

Formulář bude obsahovat následující objekty (kontrolky), které budou vnořeny následujícím způsobem:

  • Grid
    • GroupBox
      • Grid
        • StackPanel
          • StackPanel
            • Label
            • ComboBox: CmbSoustava
          • StackPanel
            • Label
            • ComboBox: CmbBytu
        • StackPanel
          • StackPanel
            • Label
            • TextBox: TxtCislo
    • GroupBox
      • StackPanel
        • Label
        • TextBox: TxtVysledek
    • StackPanel
      • WrapPanel
        • Button: BtnPrevod
      • WrapPanel
        • Button: BtnKonec


Obrázek 1: Návrh GUI - rozložení prvků v mřížce formuláře (PrevodDoSoustavWPF)


Formulář bude obsahovat následující prvky - viz Obrázek 2.


Obrázek 2: Návrh GUI a účel jednotlivých objektů (PrevodDoSoustavWPF)


2.2. XAML

Na základě našich zkušeností s XAML bude již stručně popsán postup tvorby formuláře. Základní atributy (titulek, výšku a šířku) formuláře nastavíme následujícím způsobem - viz Kód 1.

Title="Převod čísla" Height="450" Width="500">

Kód 1: Nastavení atributů formuláře

Objekt typu Grid umístěného na formuláři rozdělíme na tři řádky. První a třetí řádek se přizpůsobí obsahu vložených prvků.  Výška druhého řádku se bude přizpůsobovat roztažení okna - viz Kód 2. 

Abychom následující XAML kód zjednodušili pro čtení a pochopení podstaty, využijeme komentáře v kódu XAML - viz Kód 3. Ten vytvoříme pomocí vložení dvou značek:

  • Počáteční značky, tj.  <!-- 
  • Koncové značky, tj. -->  
V kódu tak určíme sekce, které budeme postupně doplňovat.

<Grid.RowDefinitions>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="*"/>
    <RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<!-- Vstupní data -->

<!-- Výstupní data -->

<!-- Tlačítka -->

Kód 2: Rozdělení Grid na řádky a komentáře jednotlivých sekcí

Pod komentář s textem Vstupní data vložíme do prvního řádku objekt typu GroupBox, který využijeme pro vymezení oblasti, která bude zahrnovat výběr typu soustavy, do které budeme číslo převádět, na kolik bytů bude převáděné číslo zobrazeno a vstupní pole pro zadání konvertovaného čísla - viz Kód 3. Abychom vizuálně oddělily vkládané prvky, umístíme do GroupBox další objekt typu Grid, který rozdělí plochu na dva sloupce. V dalším kódu uvidíme, jaké objekty vložíme pod komentáře Typ soustavy, počet bytů a Převáděné číslo. 

<!-- Vstupní data -->
<GroupBox Header="Vstupní data" Margin="5">
    <!-- Mřížka v sekci vstupní data  -->
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <!-- Typ soustavy, počet bytů -->

        <!-- Převáděné číslo -->

        </Grid>
</GroupBox>

Kód 3: GroupBox - vložení objektu GroupBox do horního řádku a jeho rozdělení na dva sloupce pomocí objektu Grid

Pod komentář s textem Typ soustavy, počet bytů vložíme (do objektu Grid  v prvním řádku) objekt typu StackPanel,  má nastaven vnější obtékání 5 pixelů. Tento objekt bude umístěn do levého sloupce Grid (nemusíme nastavovat umístěn v Grid, protože je přednastavena tato pozice) - viz Kód 4.

<!-- Typ soustavy, počet bytů -->
<StackPanel Margin="5">
    <!-- Typ soustavy -->

    <!-- Počet bytů -->

</StackPanel>

Kód 4: Typ soustavy a počet bytů - StackPanel pro vložení dalších objektů StackPanel

Pod komentář Typ soustavy umístíme další StackPanel, který využijeme pro umístění titulku (Label) a rozevíracího seznamu (objekt ComboBox) pod sebe. Rozevírací seznam nazvaný cmbSoustava je určen pro výběr typu soustavy. Vložení položek do objektu ComboBox zajistíme pomocí prvků ComboBoxItem, u kterých budeme definovat obsah jednotlivých položek pomocí vlastnosti Content - viz Kód 5.

<!-- Typ soustavy -->
<StackPanel Margin="5,10,5,5">
    <Label Content="Soustava:" />
    <ComboBox Name="CmbSoustava" Margin="15,5,5,5">
        <ComboBoxItem Content="Dvojková"/>
        <ComboBoxItem Content="Šestnáctková"/>
    </ComboBox>
</StackPanel>

Kód 5: Typ soustavy - StackPanel - vložení titulku (Label) a rozevíracího seznamu (ComboBox)

Pod komentář Počet bytů umístíme další StackPanel, který využijeme pro umístění titulku (Label) a rozevíracího seznamu (objekt ComboBox) pod sebe. Rozevírací seznam nazvaný cmbBytu je určen pro výběr zobrazených počtu bytů u převedeného čísla (při zvolení malého počtu bytů může dojít k překročení rozsahu, tzn. že hodnota kterou potřebujeme uložit do proměnné je větší - přetečení). Vložení položek do objektu ComboBox znovu zajistíme pomocí prvků ComboBoxItem, u kterých budeme definovat obsah těchto položek pomocí vlastnosti Content - viz Kód 6.

<!-- Počet bytů -->
<StackPanel Margin="5,10,5,5">
    <Label Content="Počet bytů" />
    <ComboBox Name="CmbBytu" Margin="15,5,5,5">
        <ComboBoxItem Content="1"/>
        <ComboBoxItem Content="2"/>
        <ComboBoxItem Content="4"/>
        <ComboBoxItem Content="8"/>
    </ComboBox>
</StackPanel>

Kód 6: Počet bytů - StackPanel - vložení titulku (Label) a rozevíracího seznamu (ComboBox)

Pod komentář Převáděné číslo umístíme další StackPanel, který využijeme pro umístění titulku (Label) a vstupního pole pro zadání převáděného čísla (TextBox) pod sebe. Objekt StackPanel umístíme do levého sloupce Gridu - viz Kód 7. Do vstupního pole umístíme text "?" aby uživatel tušil, že má zadat hodnotu čísla určeného ke konverzi.

<!-- Převáděné číslo -->
<StackPanel Grid.Column="1" Margin="5">
    <StackPanel Margin="5,10,5,5">
        <Label Content="Číslo:" />
        <TextBox Name="TxtCislo" Text="?" Margin="15,5,5,5" FontSize="14" FontWeight="Bold"/>
    </StackPanel>
</StackPanel>

Kód 7: Převáděné číslo - StackPanel - vložení titulku (Label) a vstupního pole (TextBox)

Pod komentář Výstupní data vložíme do druhého řádku opět objekt typu GroupBox, který využijeme pro vymezení oblasti, která bude zahrnovat titulek (Label) a výstupní pole (TextBox) pro zobrazení výsledku, tj. převáděného čísla - viz Kód 8. Vypsaný výsledek v TextBox bude tučně (vlastnosti FontWeight), vycentrujeme jak v horizontální ose (HorizontalContentAlignment) tak i vertikální (VerticalContentAlignment). Podbarvíme pole modře (Background), zamkneme pro zadání hodnot (IsReadOnly), nastavíme vnější okraje (Margin) a vnitřní okraje (Padding) a umožníme zalamování obsahu na nový řádek (TextWrapping). 

<!-- Výstupní data -->
<GroupBox Header="Výstupní data" Grid.Row="1" Margin="5">
    <StackPanel>
        <Label Content="Výsledek:" FontWeight="Bold" FontSize="14" />
        <TextBox Name="TxtVysledek" Margin="20,5" Padding="5" Grid.Row="2" TextWrapping="Wrap" HorizontalContentAlignment="Center" 
                 VerticalContentAlignment="Center" FontSize="14" FontWeight="Bold" IsReadOnly="True" Background="AliceBlue"/>
    </StackPanel>
</GroupBox>

Kód 8: Výstupní data - StackPanel - vložení titulku (Label) a výstupního pole (TextBox)

Pod komentář Tlačítka vložíme StackPanel pro umístění dvou tlačítek pod sebe do posledního řádku Grid. Do objektu StackPanel proto umístíme dva objekty typu WrapPanel, do kterých umístíme jednotlivá tlačítka.

Do prvního objektu WrapPanel umístíme tlačítko Převod. Tento WrapPanel vystředíme v horizontální ose (HorizontalAlignment). Pro obě tlačítka vygenerujeme obsluhu události stisknutí tlačítka (událost Click) pomocí nastavení vlastnosti Click a zvolení položky <New Event Handler>. U obou tlačítek nastavíme vnitřní okraje (vlastnost Padding) a také vnější okraje (vlastnost Margin) u obou objektů. 

Po stisknutí tlačítka Převod bude převedeno zadané číslo v dekadické soustavě do zvolené soustavy a zobrazeno v požadovaného počtu bytů. 

Druhé tlačítko Konec umístíme do druhého WrapPanel, který zarovnáme k pravému okraji - viz Kód 9.

<!-- Tlačítka -->
<StackPanel Grid.Row="2">
    <WrapPanel HorizontalAlignment="Center">
        <Button Name="BtnPrevod" Content="Převod" Margin="5" Width="100" Padding="5" Click="BtnPrevod_Click"/>
    </WrapPanel>
    <WrapPanel HorizontalAlignment="Right">
        <Button Name="BtnKonec" Content="Konec" Margin="5" Width="100" Padding="5" Click="BtnKonec_Click"/>
    </WrapPanel>
</StackPanel>

Kód 9: Tlačítka - StackPanel - tlačítko pro převod čísla a tlačítko pro ukončení aplikace

Výsledný formulář

Navržené rozložení prvků na formuláři, včetně formuláře samotného, je vidět na následujícím obrázku - viz Obrázek 1.


Obrázek 1: Výsledný formulář WPF aplikace

Objekty na formuláři:

Formulář obsahuje následující objekty (kontrolky):

  • Grid
  • GroupBox
  • StackPanel
  • WrapPanel
  • Label
  • TextBox
    • TxtCislo
    • TxtVysledek
  • ComboBox
    • CmbSoustava
    • CmbBytu
  • Button
    • BtnPrevod
    • BtnKonec
které jsou umístěny následujícím způsobem - viz Obrázek 2.


Obrázek 2: VS - okno Document Outline - seznam objektů

2.3. XAML - prvky formuláře

Následující XAML kód obsahuje nastavení formuláře - viz Kód 1. Pokud je zapotřebí zkopírujte XAML kód a vložte jej namísto řádky s nastavením vlastností okna (řádek začíná Title=....).

Title="Převod čísla" Height="450" Width="500">

Kód 1: Nastavení vlastností formuláře

Grid

Následující zdrojový kód XAML obsahuje potřebné prvky na formuláři pro řešení úlohy, bez nastavení událostí - viz Kód 2. Pokud je zapotřebí, zkopírujte XAML kód a vložte jej mezi počáteční a koncovou značku prvku Grid.

<Grid.RowDefinitions>
    <RowDefinition Height="Auto"/>
    <RowDefinition Height="*"/>
    <RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
 
<GroupBox Header="Vstupní data" Margin="5">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="*"/>
        </Grid.ColumnDefinitions>
        <StackPanel Margin="5">
            <StackPanel Margin="5,10,5,5">
                <Label Content="Soustava:" />
                <ComboBox Name="CmbSoustava" Margin="15,5,5,5">
                    <ComboBoxItem Content="Dvojková"/>
                    <ComboBoxItem Content="Šestnácková"/>
                </ComboBox>
            </StackPanel>
            <StackPanel Margin="5,10,5,5">
                <Label Content="Počet bytů" />
                <ComboBox Name="CmbBytu" Margin="15,5,5,5">
                    <ComboBoxItem Content="1"/>
                    <ComboBoxItem Content="2"/>
                    <ComboBoxItem Content="4"/>
                    <ComboBoxItem Content="8"/>
                </ComboBox>
            </StackPanel>
        </StackPanel>
        <StackPanel Grid.Column="1" Margin="5">
            <StackPanel Margin="5,10,5,5">
                <Label Content="Číslo:" />
                <TextBox Name="TxtCislo" Text="?" Margin="15,5,5,5" FontSize="14" FontWeight="Bold"/>
            </StackPanel>
        </StackPanel>
    </Grid>
</GroupBox>
<GroupBox Header="Výstupní data" Grid.Row="1" Margin="5">
    <StackPanel>
        <Label Content="Výsledek:" FontWeight="Bold" FontSize="14" />
        <TextBox Name="TxtVysledek" Margin="20,5" Padding="5" Grid.Row="2" TextWrapping="Wrap" HorizontalContentAlignment="Center" 
                 VerticalContentAlignment="Center" FontSize="14" FontWeight="Bold" IsReadOnly="True" Background="AliceBlue"/>
    </StackPanel>
</GroupBox>
<StackPanel Grid.Row="2">
    <WrapPanel HorizontalAlignment="Center">
        <Button Name="BtnPrevod" Content="Převod" Margin="5" Width="100" Padding="5"/>
    </WrapPanel>
    <WrapPanel HorizontalAlignment="Right">
        <Button Name="BtnKonec" Content="Konec" Margin="5" Width="100" Padding="5"/>
    </WrapPanel>
</StackPanel>

Kód 2: Prvky v Grid

2.4. C#

V souboru MainWindow.xaml.cs obsahující kód na pozadí (Code Behind) byla vygenerována základní struktura našeho programu v C#. Vedle konstruktoru MainWindow této třídy byly také vygenerovány soukromé (private) metody bez návratu, které umístíme do oblasti Události:

  • BtnVypocti_Click
  • BtnKonec_Click
Do regionu Události umístíme první metodu bez návratu pro obsluhu události tlačítka BtnPrevod. V této metodě provedeme načtení zadaného čísla (v objektu TxtCislo typu TextBox) v dekadické soustavě určeného k převodu na číslo do zvolené soustavy. Výsledné číslo bude zobrazeno na formuláři ve výstupním poli TxtVysledek (TextBox) - viz Kód 1.

private void BtnPrevod_Click(object sender, RoutedEventArgs e)
{
    // Načtení zadaného čísla určeného ke konverzi 
    int.TryParse(this.TxtCislo.Text, out int n);
    // Výpis konvertovaného čísla na formulář
    this.TxtVysledek.Text = Prevod(n);
}

Kód 1: Deklarace metody pro převod čísla do zvolené soustavy (BtnPrevod_Click)

Do regionu Výpočty umístíme metodu, která bude převádět předané číslo v desítkové soustavě do zvolené soustavy na formuláři. 

Do deklarované metody Prevod s textovým návratem bylo předáno načtené číslo z formuláře, které je určeno k převodu - viz Kód 2. Tento parametr je předán hodnotou, tzn. jeho hodnota je nakopírována do formálního parametru n ve volané metodě. Na začátku těla metody jsou deklarovány následující proměnné. U některých z těchto proměnných je v deklaraci zároveň provedena inicializace:

  • p ... počet bitů, inicializace nulou
  • c ... zbytek po celočíselném dělení
  • d ... dělitel (základ soustavy), inicializace nulou 
  • s ... výstupní text (převedené číslo), inicializace prázdným textem
  • i ... pozice bitu ve výstupním textu (inicializace bude provedena v cyklu s krokem)

Vzhledem k tomu, že kód těla metody je poměrně dlouhý, budeme postupně doplňovat jeho části, které jsme rozdělili do několika komentářů - viz Kód 2.  

/// <summary>
/// Převod čísla z desítkové soustavy do dvojkové, nebo šestnáctkové soustavy
/// </summary>
/// <param name="n"> převáděné číslo (desítková soustava) </param>
/// <returns> textový řetězec převedeného čísla </returns>
private string Prevod(int n)
{
    /* Deklarace: 'p' ... počet bitů - inicializace; 'd' ... dělitel (základ soustavy) - inicializace;
     * 'c' ... zbytek po celočíselném dělení; 's' ... výstupní text (převedené číslo) - inicializace; 
     * 'i' ... pozice bitu ve výstupním textu */
    int p = 0;
    int d = 0;
    int c, i;
    string s = "";
 
    /* Pokud nebyl zvolen typ soustavy (index položky je roven -1), nebo nebyl zvolen
     * počet bytů (text v ComboBox je prázdný... */

    // Jinak...
  
    // Výstupní text je návratem metody
    return s; 
}

Kód 1: Základní struktura metody s textovým návratem pro převod čísla do zvolené soustavy na určitý počet bytů

Pod komentář /* Pokud nebyl zvolen typ soustavy ... umístíme kladnou větev (pokud je splněna podmínka) příkazu if. V podmínce rozhodování budeme testovat, zda je zvolen některý z typů soustavy. To provedeme pomocí testování hodnoty ve vlastnosti SelectedIndex v rozevíracím seznamu CmbSoustava (objekt typu ComboBox). Pokud nebyla zvolená žádná položka z rozevíracího seznamu, index zvolené položky je roven -1 (první položka seznamu je indexována hodnotou 0). V podmínce použijeme logický operátor nebo ||, pomocí níž testujeme zda došlo ke splnění první části podmínky (nezvolen typ soustavy), nebo druhé části v níž je testováno, zda nebyla zvolena hodnota počtu bytů, na které má být číslo zobrazeno. To provedeme pomocí porovnání hodnoty v rozevíracím seznamu s prázdnou textovou hodnotu (string.Empty) uložené ve vlastnosti Text.

Pokud je splněna podmínka, provede se další test, zda nebyl zvolen typ soustavy (nějaká položka ze seznamu). Pokud nebyl, tzn. je splněna podmínka, je otevřeno (příkaz Show) dialogové okno (objekt MessageBox) s ikonou informace (MessageBoxImage.Information) a s jedním tlačítkem OK (MessageBoxButton.OK). Po stisknutí tlačítka OK, je uživatel přepnut (příkaz Focus) na rozevírací seznam pro výběr typu soustavy (CmbSoustava). 

Pokud nebyl zvolen typ soustavy, nebo počet bytů, je testována ve větvi nesplnění podmínky další podmínka, zda nebyl zvolen počet bytů. Pokud ano, je postupováno stejným způsobem, jako v předchozím případu - viz Kód 2.

/* Pokud nebyl zvolen typ soustavy (index položky je roven -1), nebo nebyl zvolen
 * počet bytů (text v ComboBox je prázdný... */
if (this.CmbSoustava.SelectedIndex == -1 || this.CmbBytu.Text == string.Empty)
{
    // Pokud nebyl zvolen typ soustavy...
    if (this.CmbSoustava.SelectedIndex == -1)
    {
        // Výzva k výběru typu soustavy v dialogovém informačním okně
        MessageBox.Show("Vyberte soustavu", "Chybí nastavení", MessageBoxButton.OK, MessageBoxImage.Information);
        // Zacílení na ComboBox na formuláři
        this.CmbSoustava.Focus();
    }
    // Jinak, pokud nebyl zvolen počet bytů...
    else if (this.CmbBytu.Text == string.Empty)
    {
        // Výzva k výběru počtu bytů v dialogovém informačním okně
        MessageBox.Show("Vyberte počet bytů", "Chybí nastavení", MessageBoxButton.OK, MessageBoxImage.Information);
        // Zacílení na ComboBox na formuláři
        this.CmbBytu.Focus();
    }
}

Kód 2: Pokud nebyl zvolen typ soustavy, nebo nebyl zvolen počet bytů - rozhodování a příslušné akce

Pod komentář // Jinak... umístíme následující zdrojový kód, který bude proveden, pokud uživatel zvolil typ soustavy a zvolil počet bytů, na které má být převedené číslo zobrazeno - viz Kód 3. Jedná se tedy o větev else, která je součástí rozhodovacího příkazu if. Kód znovu rozdělíme do několika sekcí popsaných komentáři.

// Jinak...
else
{
    // Přepínač - pokud byla vybrána ze seznamu soustava, tj. index zvolené položky ze seznamu...
   
    // Cyklus s krokem – pro všechny bity (počet bitů uložen v proměnné 'p')...

    // Pokud je převáděné číslo větší než nula -> výstupní text = stávající výstupní text + "přetečení"

}

Kód 3: Pokud byl zvolen typ soustavy, nebo byl zvolen počet bytů

Pod komentář // Přepínač - ... umístíme vícenásobné větvení (příkaz switch - někdy též nazýváno přepínač), které bude rozhodovat o tom, co se má provést, pokud uživatel vybral v rozevíracím seznamu CmbBytu daný typ soustavy (větev bude vybrána na základě indexu zvolené položky v tomto seznamu). Pokud uživatel zvolil dvojkovou soustavu (index vybrané položky CmbBytu je roven 0) je provedeno nastavení hodnoty počtu bitů v závislosti na zvoleném počtu bytů na formuláři. Dále musí být nastavena hodnota dělitele na hodnotu 2 (dvojková soustava). Každá větev vícenásobného větvení je uzavřena příkazem break. Stejným způsobem je provedena větev, pokud index zvolené položky v CmbBytu je roven 1, tzn. šestnáctková soustava (byte lze zobrazit na 2 pozice a dělitel je 16).  

// Přepínač - pokud byla vybrána ze seznamu soustava, tj. index zvolené položky ze seznamu...
switch (this.CmbSoustava.SelectedIndex)
{
    // Je roven 0, tzn. je vybrána dvojková soustava...
    case 0:
        /* Nastavení hodnoty počtu bitů v závislosti na počtech bytů (1 byte = 8 bitů v binární soustavě) */
        p = int.Parse(this.CmbBytu.Text) * 8;
        // Nastavení dělitele na hodnotu 2
        d = 2;
        // Konec větve
        break;
    // Je roven 1, tzn. je vybrána šestnáctková (hexadecimální) soustava...
    case 1:
        /* Nastavení hodnoty počtu bitů v závislosti na počtech bytů (1 byte lze zobrazit na 2 pozice 
         * v šestnáctkové soustavě) */
        p = int.Parse(CmbBytu.Text) * 2;
        // Nastavení dělitele na hodnotu 2
        d = 16;
        break;
}

Kód 4: Vícenásobné větvení - přepínání v závislosti na zvoleném typu soustavy

Pod komentář // Cyklus s krokem - ... umístíme zdrojový kód pro výpočet jednotlivých pozic převáděného čísla pomocí cyklu s krokem. Princip je totožný s předchozím příkladem PrevodDoSoustav řešeným pro konzolovou aplikaci, proto jej není nutné znovu popisovat.

// Cyklus s krokem – pro všechny bity (počet bitů uložen v proměnné 'p')...
for (i = 1; i <= p; i++)
{
    // Nastavení zbytku = hodnota po celočíselném dělení konvertovaného čísla dělitelem
    c = n % d;
    /* Pokud se jedná o konverzi čísla na číslici, nebo čísla na písmeno (podle hodnoty v 'c'), 
     * tj, pokud je zbytek menší než 10 -> dvojková soustava... */
    if (c < 10)
    {
        /* Pokud je zbytek menší než 10 (dvojková soustava) jedná se o konverzi čísla na číslici (znak)
         * Výstupní text = vložení znaku před stávající text (znak je v ASCII na pozici, která 
         * je rovna hodnotě zbytku + ordinální hodnota znaku '0') */
        s = (char)(c + (int)'0') + s;
    }
    // Jinak...
    else
        /* Pokud je zbytek větší nebo roven 10 (šestnáctková soustava) jedná se o konverzi čísla 
         * na písmeno (znak) - výstupní text = vložení znaku před stávající text 
         * (znak je v ASCII na pozici, která je rovna hodnotě zbytku - 10 + 
         * ordinální hodnota znaku 'A') */
        s = (char)(c - 10 + (int)'A') + s;
    // Pokud je bit násobkem čtvrté pozice -> vložení mezery do výstupního textu před stávající text
    if (i % 4 == 0)  s = " " + s;
    // Vstupní číslo = celočíselné dělení stávajícího převáděného čísla dělitelem
    n = n / d; 
}
// Pokud je převáděné číslo větší než nula -> výstupní text = stávající výstupní text + "přetečení"
if (n > 0) s = s + " přetečení";

 Kód 5: Provedení výpočtu hodnot pro jednotlivé pozice (bity) výsledného převedeného čísla

Poslední metodou v regionu Události, kterou musíme upravit je metoda pro obsluhu události Click tlačítka Konec. Tato metoda nám zavře formulář - viz Kód 6.

private void BtnKonec_Click(object sender, RoutedEventArgs e)
{
    // Zavření formuláře
    this.Close();
}

Kód 6: Deklarace metody bez návratu pro zavření formuláře (BtnKonec_Click)


2.5. Výsledný kód

XAML kód

Výsledný XAML kód formuláře (MainWindow.xaml) - viz Kód 1.

<Window x:Class="PrevodDoSoustavWPF.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:PrevodDoSoustavWPF"
        mc:Ignorable="d"
        Title="Převod čísla" Height="450" Width="500">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <!-- Vstupní data -->
        <GroupBox Header="Vstupní data" Margin="5">
            <!-- Mřížka v sekci vstupní data  -->
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="*"/>
                    <ColumnDefinition Width="*"/>
                </Grid.ColumnDefinitions>
                <!-- Typ soustavy, počet bytů -->
                <StackPanel Margin="5">
                    <!-- Typ soustavy -->
                    <StackPanel Margin="5,10,5,5">
                        <Label Content="Soustava:" />
                        <ComboBox Name="CmbSoustava" Margin="15,5,5,5">
                            <ComboBoxItem Content="Dvojková"/>
                            <ComboBoxItem Content="Šestnáctková"/>
                        </ComboBox>
                    </StackPanel>
                    <!-- Počet bytů -->
                    <StackPanel Margin="5,10,5,5">
                        <Label Content="Počet bytů" />
                        <ComboBox Name="CmbBytu" Margin="15,5,5,5">
                            <ComboBoxItem Content="1"/>
                            <ComboBoxItem Content="2"/>
                            <ComboBoxItem Content="4"/>
                            <ComboBoxItem Content="8"/>
                        </ComboBox>
                    </StackPanel>
                </StackPanel>
                <!-- Převáděné číslo -->
                <StackPanel Grid.Column="1" Margin="5">
                    <StackPanel Margin="5,10,5,5">
                        <Label Content="Číslo:" />
                        <TextBox Name="TxtCislo" Text="?" Margin="15,5,5,5" FontSize="14" FontWeight="Bold"/>
                    </StackPanel>
                </StackPanel>
            </Grid>
        </GroupBox>
        <!-- Výstupní data -->
        <GroupBox Header="Výstupní data" Grid.Row="1" Margin="5">
            <StackPanel>
                <Label Content="Výsledek:" FontWeight="Bold" FontSize="14" />
                <TextBox Name="TxtVysledek" Margin="20,5" Padding="5" Grid.Row="2" TextWrapping="Wrap" HorizontalContentAlignment="Center" 
                         VerticalContentAlignment="Center" FontSize="14" FontWeight="Bold" IsReadOnly="True" Background="AliceBlue"/>
            </StackPanel>
        </GroupBox>
        <!-- Tlačítka -->
        <StackPanel Grid.Row="2">
            <WrapPanel HorizontalAlignment="Center">
                <Button Name="BtnPrevod" Content="Převod" Margin="5" Width="100" Padding="5" Click="BtnPrevod_Click"/>
            </WrapPanel>
            <WrapPanel HorizontalAlignment="Right">
                <Button Name="BtnKonec" Content="Konec" Margin="5" Width="100" Padding="5" Click="BtnKonec_Click"/>
            </WrapPanel>
        </StackPanel>
    </Grid>
</Window>

Kód 1: Výsledný XAML kód vytvořeného formuláře


C# kód

Code Behind - C# kód pro veškeré události vyvolané uživatelem při manipulaci s aplikací (MainWindow.xaml.cs) - viz Kód 2.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
 
namespace PrevodDoSoustavWPF
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
 
        #region Výpočty
        /// <summary>
        /// Převod čísla z desítkové soustavy do dvojkové, nebo šestnáctkové soustavy
        /// </summary>
        /// <param name="n"> převáděné číslo (desítková soustava) </param>
        /// <returns> textový řetězec převedeného čísla </returns>
        private string Prevod(int n)
        {
            /* Deklarace: 'p' ... počet bitů - inicializace; 'd' ... dělitel (základ soustavy) - inicializace;
             * 'c' ... zbytek po celočíselném dělení; 's' ... výstupní text (převedené číslo) - inicializace; 
             * 'i' ... pozice bitu ve výstupním textu */
            int p = 0;
            int d = 0;
            int c, i;
            string s = "";
 
            /* Pokud nebyl zvolen typ soustavy (index položky je roven -1), nebo nebyl zvolen
             * počet bytů (text v ComboBox je prázdný... */
            if (this.CmbSoustava.SelectedIndex == -1 || this.CmbBytu.Text == string.Empty)
            {
                // Pokud nebyl zvolen typ soustavy...
                if (this.CmbSoustava.SelectedIndex == -1)
                {
                    // Výzva k výběru typu soustavy v dialogovém informačním okně
                    MessageBox.Show("Vyberte soustavu", "Chybí nastavení", MessageBoxButton.OK, MessageBoxImage.Information);
                    // Zacílení na ComboBox na formuláři
                    this.CmbSoustava.Focus();
                }
                // Jinak, pokud nebyl zvolen počet bytů...
                else if (this.CmbBytu.Text == string.Empty)
                {
                    // Výzva k výběru počtu bytů v dialogovém informačním okně
                    MessageBox.Show("Vyberte počet bytů", "Chybí nastavení", MessageBoxButton.OK, MessageBoxImage.Information);
                    // Zacílení na ComboBox na formuláři
                    this.CmbBytu.Focus();
                }
            }
            // Jinak...
            else
            {
                // Přepínač - pokud byla vybrána ze seznamu soustava, tj. index zvolené položky ze seznamu...
                switch (this.CmbSoustava.SelectedIndex)
                {
                    // Je roven 0, tzn. je vybrána dvojková soustava...
                    case 0:
                        /* Nastavení hodnoty počtu bitů v závislosti na počtech bytů (1 byte = 8 bitů v binární soustavě) */
                        p = int.Parse(this.CmbBytu.Text) * 8;
                        // Nastavení dělitele na hodnotu 2
                        d = 2;
                        // Konec větve
                        break;
                    // Je roven 1, tzn. je vybrána šestnáctková (hexadecimální) soustava...
                    case 1:
                        /* Nastavení hodnoty počtu bitů v závislosti na počtech bytů (1 byte lze zobrazit na 2 pozice 
                         * v šestnáctkové soustavě) */
                        p = int.Parse(CmbBytu.Text) * 2;
                        // Nastavení dělitele na hodnotu 2
                        d = 16;
                        break;
                }
                // Cyklus s krokem – pro všechny bity (počet bitů uložen v proměnné 'p')...
                for (i = 1; i <= p; i++)
                {
                    // Nastavení zbytku = hodnota po celočíselném dělení konvertovaného čísla dělitelem
                    c = n % d;
                    /* Pokud se jedná o konverzi čísla na číslici, nebo čísla na písmeno (podle hodnoty v 'c'), 
                     * tj, pokud je zbytek menší než 10 -> dvojková soustava... */
                    if (c < 10)
                    {
                        /* Pokud je zbytek menší než 10 (dvojková soustava) jedná se o konverzi čísla na číslici (znak)
                         * Výstupní text = vložení znaku před stávající text (znak je v ASCII na pozici, která 
                         * je rovna hodnotě zbytku + ordinální hodnota znaku '0') */
                        s = (char)(c + (int)'0') + s;
                    }
                    // Jinak...
                    else
                        /* Pokud je zbytek větší nebo roven 10 (šestnáctková soustava) jedná se o konverzi čísla 
                         * na písmeno (znak) - výstupní text = vložení znaku před stávající text 
                         * (znak je v ASCII na pozici, která je rovna hodnotě zbytku - 10 + 
                         * ordinální hodnota znaku 'A') */
                        s = (char)(c - 10 + (int)'A') + s;
                    // Pokud je bit násobkem čtvrté pozice -> vložení mezery do výstupního textu před stávající text
                    if (i % 4 == 0)  s = " " + s;
                    // Vstupní číslo = celočíselné dělení stávajícího převáděného čísla dělitelem
                    n = n / d; 
                }
                // Pokud je převáděné číslo větší než nula -> výstupní text = stávající výstupní text + "přetečení"
                if (n > 0) s = s + " přetečení";
            }
            // Výstupní text je návratem metody
            return s;
 
        }
        #endregion
 
 
        #region Události
        private void BtnPrevod_Click(object sender, RoutedEventArgs e)
        {
            // Načtení zadaného čísla určeného ke konverzi 
            int.TryParse(this.TxtCislo.Text, out int n);
            // Výpis konvertovaného čísla na formulář
            this.TxtVysledek.Text = Prevod(n);
        }
 
        private void BtnKonec_Click(object sender, RoutedEventArgs e)
        {
            // Zavření formuláře
            this.Close();
        }
        #endregion
    }
}

Kód 2: Výsledný C# kód vytvořeného formuláře a metod jeho prvků


Výstup programu

Na následujícím obrázku vidíme výstup naší aplikace pro převod zadaného čísla v dekadické soustavě a jeho následného převodu do zvolené soustavy a jeho výpisem na požadovaným počet bitů. Pro ilustraci jsme vybrali případ převodu čísla 90 do dvojkové soustavy, které má být zobrazeno na 1 B - viz Výstup programu 1 - Kód 1 a 2. Provedení konverze a výpis čísla je pomocí stisknutí tlačítka Převod umístěného v dolní středové části formuláře. 


Výstup programu 1 - Kód 1 a 2: Ukázka výpisu převedeného čísla do binární soustavy (PrevodDoSoustavWPF)

Pokud bychom číslo 90 chtěli převést do šestnáctkové soustavy, výsledek převodu by vypadal následovně - viz Výstup programu 2 - Kód 1 a 2. 


Výstup programu 2 - Kód 1 a 2: Ukázka výpisu převodu čísla do šestnáctkové soustavy (PrevodDoSoustavWPF)

Posledním testovaným případem konverze je přetečení. Jak již z kapitole věnované analýze příkladu víme, do 1 Byte je možné uložit hodnotu 0 ÷ 255. Zkusme tedy vypsat hodnotu 256 na 1 Byte, tj. na 8 pozicích ve dvojkové soustavě, nebo na 2 pozicích v šestnáctkové soustavě - viz Výstup programu 3 - Kód 1 a 2. 


Výstup programu 3 - Kód 1: Ukázka výpisu přetečení při převodu čísla do dvojkové soustavy (PrevodDoSoustavWPF)

Ve výpisu vidíme samé nuly, protože by teprve na 9. pozici byla zapsána číslice (znak) '1'. Hodnota 256 je ve dvojkové soustavě zapsána jako (1 0000 0000)2 a v šestnáctkové soustavě (100)16. Potřebovali bychom tedy minimálně 9 pozic pro výpis tohoto čísla ve dvojkové soustavě, nebo 3 pozice pro výpis v šestnáctkové, tzn. 2 B. 

Aplikaci lze ukončit pomocí tlačítka Konec, nebo pomocí zavíracího tlačítka umístěného v pravém rohu aplikace.