Hodnotové typy

1. Rozdělení datových typů

Jak jsme si již v minulosti říkali, jazyk C# má několik vestavěných datový typů:

• Hodnotové typy - obsahují skupiny tzv. primitivních (atomické) datových typů (anglicky „Primitive Data Types“ nebo též označované jako „Simple Types“) vyjadřující čísla – celá a reálná i s vysokou přesností, znaky (např. $), logické hodnoty. Dále tato skupina obsahuje výčtové typy (nyní berme tento typ jako typ, jehož položky si může nadefinovat uživatel, např. dny v týdnu, skládající se z pondělí až neděle; struktury a tzv. nulovatelný typ, který představuje prázdnou hodnotu (null) - viz Obrázek 1

Obrázek 1: Rozdělení hodnotových datových typů

• Referenční typy (reference, odkazy) – odkazy na instance tříd (objekty které zdědily vlastnosti a metody třídy, kterou můžeme považovat za jejich vzor), pole (jde v podstatě o seznam prvků stejného datového typu), atd. - viz Obrázek 2

Obrázek 2: Rozdělení referenčních datových typů

• Ukazatele – uvádíme jen pro úplnost, protože leží mimo směr programování v C# – lze je používat v nezabezpečeném kódu (anglicky „Unsafe Code“) [3]

Ilustrativní příklad HodnotovyReferencniTyp

Program HodnotovyReferencniTyp

• Popis: Příklad hodnotového a referenčního typu - deklarace proměnné datového typu int a proměnné datového typu string včetně jejich inicializace
• Zadání: Deklarujte v hlavní metodě Main celočíselnou proměnou pocet (datový typ int) a inicializujte ji hodnotou 8. Dále deklarujte proměnnou text (datový typ string) jež bude obsahovat textové řetězec "Ahoj světe"
• Řešení: Bude postupně probráno v následujícím textu

Na příkladu si ukažme, jaký je rozdíl mezi hodnotovým typem uloženým přímo v paměti a referenčním typem. Deklarujme si dvě proměnné: první bude mít název pocet a uložíme do ní hodnotu 8 (datový typ int). Do druhé proměnné s názvem text budeme ukládat textový řetězec (datový typ je string), který představuje textový řetězec (skládá z jednotlivých písmen, číslic a znaků). Do této proměnné uložíme text "Ahoj světe". Znak @ představuje odkaz na adresu v paměti.

static void Main(string[] args)
{
    //Deklarace proměnné pro uložení celých čísel včetně její inicializace
    int pocet = 8;
    //Deklarace proměnné pro uložení textu včetně její inicializace
    string text = "Ahoj světe";
}

Kód 1: Příklad deklarace celočíselné a textové proměnné včetně její inicializace

Identifikátor pocet označuje přímo místo v paměti, kde je hodnota 8 uložena - viz Obrázek 3. U proměnné typu string, který je referenčního typu, identifikátor text označuje místo v paměti, v němž je uložen odkaz na jiné místo v paměti obsahující instanci (objekt) třídy string s uvedeným řetězcem.

Obrázek 3: Hodnotový a referenční typ - uložení v paměti

2. Hodnotové typy

Na následujícím obrázku vidíme základní členění jednoduchých datových typů - viz Obrázek 1.

Obrázek 1: Rozdělení jednoduchých datových typů

Měli bychom zmínit, že hodnotové datové a referenční typy jsou ukládány v paměti rozdílně. Zatímco hodnotové typy jsou ukládány do tzv. zásobníku (anglicky „Stack“, kde postup ukládání je takový, že prvek tohoto datového typu, který se uložil do zásobníku jako poslední, je ze zásobníku vyjmut jako první – metoda LIFO – zkratka anglického „Last In First Out“). Výhoda tohoto typu je v jejím rychlém přidělení paměti oproti referenčním typů.

Většina hodnotových typů např. int, float, double a char (nikoliv string) mají svoji pevnou velikost bloku v paměti odpovídající jejímu datovému typu. Když deklarujeme proměnnou hodnotového typu, kompilátor vygeneruje kód, který přidělí blok paměti, který jak tak velký, aby se do něj vešel rozsah odpovídajícího datové typu (např. datový typ int vytýčí 4 Byte paměti). Proměnná pocet a text byly na obrázku v předchozí kapitole zobrazeny pouze schematicky (viz https://phix.zcu.cz/moodle/pluginfile.php/389329/mod_book/chapter/99047/Hodnotovy_referencni_typ.png?time=1580463909144). Ve skutečnosti je proměnná pocet datového typu int, který zabírá v paměti vždy 4 Byte. Na následujícím obrázku je detailně zobrazen pouze informace na 1 Byte, ostatní předchozí bity obsahují nuly – viz Obrázek 2. Pokud si spočteme hodnotu v desítkové soustavě, tj. přepočet binárního kódu do desítkové soustavy vychází hodnota 8, tj. 8 =1*2³.

Obrázek 2: Uložení proměnné hodnotového typu v zásobníku

2.1. Celá čísla

První skupinou hodnotových typů, které ve výčtu byla uvedena, jsou celá čísla. V tabulce jsou uvedeny datové typy pro celá čísla, včetně velikosti, kterou vždy zabírá daný typ, rozsah hodnot, které lze do daného datového typu uložit. Dále tabulka obsahuje přípony specifikované u literálu (tento princip bude vysvětlen v následujícím textu) – viz Tabulka 1. Rozsah hodnot je uveden s čárkami, které oddělují řády tisíců. V tabulce si lze povšimnout, že některé typy umožňují pouze ukládat nezáporné hodnoty. Jedná se o typy: byte, ushort, uint, ulong (předpona u je zkratka anglického „unsigned“, což znamená celá čísla bez znaménka „+“ nebo „-“). Ostatní typy obsahují znaménka „+“ nebo „-“ (anglicky „signed“ - uváděné bez předpony, u datového typu byte předpona s, tj. sbyte).

Tabulka 1: Datové typy celých čísel

Jak již několikrát bylo uvedeno, datový typ specifikuje typ dat, který budeme do proměnné ukládat. Je zřejmé, že do celočíselného typu nebudeme ukládat textový řetězec "Ahoj světe!".

V některých případech však typ hodnoty přiřazený do proměnné nemusí být vždy jednoznačný. Uveďme např. hodnotu 45. Je to číselná hodnota, detailněji řečeno celé číslo, které můžeme přiřadit do celočíselné proměnné. Co se však stane, pokud se pokusíte tuto hodnotu přiřadit neceločíselnému typu, například proměnné s pohyblivou řádovou čárkou? Odpověď je, že C# v tichosti převede celočíselnou hodnotu na hodnotu s pohyblivou řádovou čárkou. To je relativně neškodné, ale nemusí to být vždy žádoucí. Měli bychom tedy opravdu určit, že jsme měli v úmyslu považovat literální hodnotu 42 za číslo s pohyblivou řádovou čárkou a omylem jsme ji nepřiřadili nesprávnému datovému typu proměnné. To můžeme zajistit připojením přípony k číselnému literálu. [6]

Literál tedy představuje zápis přímého zadání hodnoty, jejíž zápis není během kompilace měněn.

C# obsahuje různé číselné typy jako např. dlouhá celá čísla (dat typ long), která mají větší rozsah než celá čísla (datový typ int). Proto by měl být pro datový typ long použita přípona L pokud chceme zachovat tento velký rozsah – viz Kód 1.

//Deklarace proměnné pro uložení velkých celých čísel
long longPromenna;
//Přiřazení hodnoty proměnné s použitím literálu
longPromenna = 42L;

Kód 1: Příklad deklarace celočíselné proměnné s použitím přípony u literálu

Dalším případem, kdy je vhodné použití literálu, je u tzv. anonymního typu, kde datový typ je odvozen až při kompilaci kódu (není tedy dopředu známé, o jaký datový typ se jedná) - viz Kód 2.

//Deklarace proměnné s použitím anonymního typu (nutná inicializace)
var longPromenna = 42L;

Kód 2: Příklad deklarace proměnné anonymního typu s použitím přípony u literálu

2.2. Přetypování

Jazyk C# dovoluje přiřadit proměnné, jejíž datový typ má větší rozsah hodnot, proměnnou, jejíž typ má menší rozsah hodnot. Přiřazovaná hodnota se automaticky převede na hodnotu cílového typu, proběhne tzv. implicitní konverze neboli implicitní přetypování (přetypování – anglicky „Casting“). Přesněji: Jestliže se všechny hodnoty typu výrazu na pravé straně přiřazení vejdou do rozsahu typu proměnné na levé straně, bude vše v pořádku. Jinak nám překladač toto přiřazení nepovolí. [3]

Ilustrativní příklad ImplicitniKonverze

Program ImplicitniKonverze

• Popis: Příklad implicitní konverze
• Zadání: Deklarujte v hlavní metodě Main proměnnou s názvem intPromenna datového typu int a inicializujte ji hodnotou 63840. Dále deklarujte další proměnnou s názvem longPromenna datového typu long. Vyzkoušejte vzájemné přiřazení obou proměnných, tj. druhé první a poté první druhé
• Řešení: Bude postupně probráno v následujícím textu

static void Main(string[] args)
{
    //Deklarace proměnné typu int včetně inicializace – menší rozsah než long
    int intPromenna = 63840;
    //Deklarace proměnné typu long včetně inicializace – větší rozsah než int
    long longPromenna;
    //Přiřazení proměnné typu int do proměnné typu long – O. K.
    longPromenna = intPromenna;
    //Toto přiřazení proměnné typu long do proměnné typu int nelze provést – K. O.
    intPromenna = longPromenna;
}

Kód 1: Příklad implicitního přetypování

Dále nás také překladač upozorní, že "Existuje explicitní převod." Pokud bychom přeci jen na tomto přiřazení trvali, musíme použití tzv. explicitní přetypování. 

Ilustrativní příklad ExplicitniKonverze

Program ExplicitniKonverze

• Popis: Příklad explicitní konverze
• Zadání: Deklarujte v hlavní metodě Main proměnnou s názvem longPromenna datového typu long a inicializujte ji hodnotou 63840. Proveďte přetypování (explicitní konverzi datového typu) této proměnné na datový typ int. Uložte hodnotu v této proměnné do jiné proměnné s názvem intPromenna, která je datového typu  int
• Řešení: Bude postupně probráno v následujícím textu

static void Main(string[] args)
{
    //Deklarace proměnné typu int – menší rozsah než dat. typ long
    int intPromenna;
    //Deklarace proměnné typu long včetně inicializace – větší rozsah než int
    long longPromenna = 63840;
    //Explicitní přetypování – lze pokud bude hodnota long v rozsahu int –> O. K.
    intPromenna = (int)longPromenna;
}

2.3. Reálná čísla

Program RealnaCislaLiteral

static void Main(string[] args)
{
    <span style="color: green;">//Deklarace proměnné pro uložení reálných čísel - typ double</span>
    <span style="color: blue;">double</span> <span style="color: #1f377f;">doublePromenna</span> = 0.42D;
    <span style="color: green;">//Deklarace proměnné typu double - bez uvedení přípony u literálu</span>
    <span style="color: blue;">double</span> <span style="color: #1f377f;">doublePromenna2</span> = 0.42;
 
    <span style="color: green;">//Deklarace proměnné pro uložení reálných čísel - typ float </span>
    <span style="color: blue;">float</span> <span style="color: #1f377f;">floatPromenna</span> = 0.42F;
    <span style="color: green;">//Deklarace proměnné typu float - nelze bez uvedení přípony u literálu -> K.O.</span>
    <span style="color: blue;">float</span> <span style="color: #1f377f;">floatPromenna2</span> = 0.42;
}

Program FloatLiteral

static void Main(string[] args)
{
    <span style="color: green;">//Deklarace proměnné typ float - semilogaritmický tvar</span>
    <span style="color: blue;">float</span> <span style="color: #1f377f;">floatPromenna</span> = 42e-2F;
    <span style="color: green;">//Výpis hodnoty proměnné</span>
    <span style="color: #2b91af;">Console</span>.<span style="color: #74531f;">WriteLine</span>(<span style="color: #a31515;">"floatPromenna: {0}", floatPromenna);
    //Čekání na stisk klávesy -> Ukončení programu
    Console.ReadKey();
}

floatPromenna: 0,42

2.4. Znaky

Pro práci se znaky lze v C# použít datový typ char. Proměnná typu char zabírá 2 Byte (tj. 16 bitů), nebo používá šestnáctibitové kódování UNICODE (proto také zvládne nejen angličtinu, jiné jazyky, ale i český jazyk). Znakové konstanty (konstanty datového typu char) můžeme v programu zapsat několika způsoby:

• Běžné znaky uzavřeme mezi apostrofy, např. 'a', 'Ž' (na rozložení české klávesnice zapíšete apostrof kombinací kláves Alt+039)
• Řídící znaky, jako je přechod na nový řádek, tabulátor apod., můžeme vyjádřit některou z řídících posloupností uzavřených mezi apostrofy např. '\t' (anglicky „Escape Sequence“) – viz Tabulka 1
• Můžeme také použít řídící posloupnost ve tvaru \xhhhh, kde hhhh jsou nejvýše 4 šestnáctkové číslice (z hexadecimální soustavy) vyjadřující kód daného znaku. Tak lze vyjádřit libovolný znak, např. zápis '\x41' představuje znak 'A' – viz Obrázek 1. 

Tabulka 1: Řídící posloupnosti v C# [3]

Obrázek 1: Výřez ASCII tabulka – rozsah znaků 0 ÷127 [4]

Následující tabulka obsahuje kódy UNICODE se znaky českých a slovenských znaků např. 'Á' získáme v kódu zápisem '\x00C1' – viz Tabulka 2. Pro zobrazení znaků můžeme také využít zápis '\uhhhh', kde hhhh jsou přesně 4 šestnáctkové číslice vyjadřující kód znaku v tabulce UNICODE.

Tabulka 2: České znaky UNICODE [11]

V C# můžeme využívat dva druhy řetězcových literálů:

• Běžné (anglicky „Regular“) – skládá se z posloupností znakových konstant zapsaných buď přímo, nebo pomocí řídících posloupností (znaky z tabulky řídících posloupností – viz Tabulka 1 - musíme vyjádřit pomocí řídících posloupností)
• Doslovné (anglicky „Verbatim String Literals“) – může obsahovat jakýkoliv zobrazitelný znak kromě uvozovek a k tomu přechod na nový řádek a tabulátor. Řídící posloupnosti se v něm ignorují. [3]

Ve výpisu lze použít tzv. modifikátor pomocí znaku @, který ignoruje řídící posloupnosti a vypisuje text (uzavřený v uvozovkách), jak byly zapsány v textovém řetězci.

Ilustrativní příklad Znaky

Program Znaky

• Popis: Příklad výpisu textu pomocí řídící posloupnosti a modifikátoru
• Zadání: V hlavní metodě Main vypište text "Výpis znaku: " a za ním se byl vypsán znak 'Á' pomocí řídící posloupnosti. Na nové řádky v konzolové aplikaci vypište text

  "Ignorace: '\x00C1'

  text na novém řádku

  zase text na novém řádku" 
  kde ve zdrojovém kódu použijete modifikátor @ pro ignoraci řídící posloupnosti, která by namísto '\x00C1' vypsala v textu znak 'Á'
• Řešení: Bude postupně probráno v následujícím textu

V následujícím kódu vyžadujeme, aby se na prvním řádku vypsal požadovaný text včetně připojení (pomocí operátoru +) znaku vypsaného pomocí řídící posloupnosti. Na dalším řádku kódu jsme specifikovali že @, představující tzv. modifikátor, ignoruje řídící posloupnosti a vypisuje text (uzavřený v uvozovkách), jak jsme jej zapsali v kódu (nepoužili jsme WriteLine, ale jen Write, tudíž nedojde k přechodu na nový řádek) – viz Kód 1.

static void Main(string[] args)
{
    //Výpis znaku 'Á' 
    Console.WriteLine("Výpis znaku: " + '\x00C1');
    //Ignorace řídící posloupnosti
    Console.Write("Ignorace: " + @"'\x00C1'
    text na novém řádku
    zase text na novém řádku");
}

Kód 1: Příklad využití řídící posloupnosti a modifikátoru

Výsledný výpis v konzoli vidíme v následujícím výstupu – viz Výstup programu - Kód 1.

Výpis znaku: Á
Ignorace: '\x00C1'
            text na novém řádku
            zase text na novém řádku

Výstup programu - Kód 1: Ukázka výpisu znaků a textu

2.5. Logický datový typ

Hodnoty tohoto datového typu, též nazývaný booleanovský typ (datový typ bool) vyjadřují, zda nějaké tvrzení platí (hodnota true) nebo neplatí (hodnota false). Princip operací s logickými proměnnými byl již popsán dříve v knize Rozhodování.

Ilustrativní příklad Logika

Program Logika

• Popis: Příklad deklarace logické proměnné typu boolean s inicializací a použitím logických a relačních operací
• Zadání: Deklarujte v hlavní metodě Main dvě proměnné s názvem logickaPromenna a logickaPromenna2 obojí datového typu bool a inicializujte první proměnnou hodnotou true a druhou hodnotou false. U proměnných proveďte operaci logického součinu, součtu, negaci (pouze první proměnné), rovnosti a porovnání (využijte metodu metodu CompareTo a ternární operátor pro určení zda je výsledná číselná hodnota > 0 pak vypište true, jinak false). Vypište hodnoty obou proměnných a také výslednou hodnotu jednotlivých operací 
  
• Řešení: Bude postupně probráno v následujícím textu

Ve zdrojovém kódu jsme nejprve deklarovali obě datové proměnné a následně jim přiřadily hodnoty - první true a druhé false. 

Následně jsme nechali hodnoty obou proměnných vypsat. První operací je logický součin pomocí logického operátoru &&. Pokud si představíme true jako celočíselnou hodnotu 1 a false jako 0, pak pokud tyto hodnoty vynásobíme dostáváme 0, tedy false. Podobně je to u druhé operace logického součtu, kde výsledek je 1, tedy true. V dalším příkazu jsme využili operátor negace !, pro negování hodnoty uložené v první proměnné, tzn. z hodnoty true jsme udělali opačnou hodnotu, tedy false. Pro porovnání rovnosti obou logických proměnných jsme využili operátor ==. Pro poslední operaci porovnání jsme využili metodu CompareTo vyvolanou pomocí tečkové notace u první logické proměnné. Metoda CompareTo navrací jako výsledek porovnání celé číslo. Pokud jsme porovnávali první logickou proměnnou vůči druhé, mohli jsme obdržet tři možné stavy (v závislosti na hodnotách proměnných):

• > 0 ... hodnota v první proměnné je větší než ve druhé
• = 0 ... hodnota v první proměnné je stejná jako ve druhé
• < 0 ... hodnota v první proměnné je menší než ve druhé

Pro zachování výpisu hodnot true, nebo false jsme použili ternární operátor, který nahradil příkaz if. Pokud je metodou CompareTo navráceno číslo větší než 0, vypíše se hodnota true, v opačném případě hodnota false.

static void Main(string[] args)
{
    //Deklarace logických proměnných včetně inicializace
    bool logickaPromenna = true;
    bool logickaPromenna2 = false;
    //Výpis hodnoty první logické proměnné
    Console.WriteLine("Hodnota první proměnné: {0}", logickaPromenna);
    //Výpis hodnoty druhé logické proměnné
    Console.WriteLine("Hodnota druhé proměnné: {0}", logickaPromenna2);
    //Výpis výsledné hodnoty logického součinu dvou logických proměnných
    Console.WriteLine("Logický součin: {0}", logickaPromenna && logickaPromenna2);
    //Výpis výsledné hodnoty logického součtu dvou logických proměnných
    Console.WriteLine("Logický součet: {0}", logickaPromenna || logickaPromenna2);
    //Výpis výsledné hodnoty po negaci hodnoty logické proměnné
    Console.WriteLine("Negace první proměnné: {0}", !logickaPromenna);
    //Výpis výsledné hodnoty rovnosti dvou logických proměnných
    Console.WriteLine("Rovnost: {0}", logickaPromenna == logickaPromenna2);
    //Výpis výsledné hodnoty porovnání hodnot dvou logických proměnných s použitím ternárního operátoru
    Console.WriteLine("Porovnání: {0}", logickaPromenna.CompareTo(logickaPromenna2) > 0 ? true : false);
    //Čekání na stisk klávesy -> ukončení programu
    Console.ReadKey();
}

Kód 1: Příklad deklarace logických proměnných typu boolean s inicializací a použitím logických a relačních operací

Na následujícím výstupu vidíme výsledné hodnoty provedených operací na logických proměnných - viz Výstup programu - Kód 1.

Hodnota první proměnné: True
Hodnota druhé proměnné: False
Logický součin: False
Logický součet: True
Negace první proměnné: False
Rovnost: False
Porovnání: True

Výstup programu - Kód 1: Ukázka výsledků provedených logických a relačních operací

2.6. Výčtový typ

Představte si, že potřebujete vytvořit vlastní seznam položek, např. roční období. Tento seznam by mohl obsahovat čtyři celá čísla 1, 2, 3 a 4 z nichž 1 by definovala jaro, 2 zase léto apod. Sami vidíte, že tento přístup není moc intuitivní a po čase, až byste se vrátili ke kódu, tak by Vám rozpoznávání jednotlivých časových podle čísel mohlo dělat potíže. C# nám nabízí možnost vytvoření vlastního seznamu pojmenovaných konstant (též nazývaných literálů) definovaných programátorem – enumerační neboli výčtový typ (anglicky „Enumeration“). Tento seznam představuje skupinu pojmenovaných konstant tvořících samostatný datový typ. Obecně bychom syntaxi deklarace v C# tohoto typu mohli popsat:

enum jméno { seznam_konstant}

kde:

• enum - představuje klíčové slovo uváděné v deklaraci výčtového typu
• jméno - identifikátor výčtového typu 
• seznam_konstant - představuje pojmenované konstanty tohoto definovaného výčtového typu

Poněvadž se jedná o seznam pojmenovaných konstant, můžeme v deklaraci výčtového typu provádět inicializaci, tzn., že konstantě můžeme přiřadit hodnotu pomocí operátoru přiřazení. Standardně C# pojmenované konstanty asociuje s datovým typem int. Prvnímu prvku přiřadí hodnotu 0 a dalšímu o 1 vyšší. Pojmenovaným konstantám také můžeme individuálně přiřazovat různé hodnoty.

Výčtový typ standardně asociuje pojmenované konstanty s datovým typem int. Pokud ale chceme, můžeme specifikovat i jiný celočíselný datový typ (byte, sbyte, short, ushort, int, uint, long, ulong) pro tyto konstanty (např. kvůli úspoře paměti použijeme menší datový typ short), který uvedeme za dvojtečku za názvem výčtového typu.

U deklarace proměnné výčtového typu lze také použít tzv. modifikátor ?, který uvedeme za výčtový typ a přiřadíme prázdnou hodnotu. [6]

Ilustrativní příklad VyctovyTyp

Program VyctovyTyp

• Popis: Příklad deklarace výčtového typu, deklarace proměnné tohoto typu včetně přiřazení hodnoty
• Zadání: V třídě Program  deklarujte výčtový typ dnyVTydnu, skládající se ze zkratek dní v týdnu uvedených bez diakritiky např. Po, Ut atd. V hlavní metodě Main deklarujte proměnnou s názvem den, která bude výčtového typu dnyVTydnu. Přiřaďte této proměnné hodnotu Ct. Hodnotu uloženou v proměnné vypište v Main
  
• Řešení: VyctovyTyp_Main

Na příkladu výčtového typu s názvem dnyVTydnu si ukážeme, jak deklarovat výčtový typ zahrnující zkratky jednotlivých dnů v týdnu – viz Kód 1. Tento výčtový typ jsme uvedli mimo metodou Main ve třídě Program. 

class Program
{
    //Deklarace výčtového typu
    enum dnyVTydnu { Po, Ut, St, Ct, Pa, So, Ne };

Kód 1: Deklarace výčtového typu dnyVTydnu

Vzhledem k tomu, že jsme si definovali vlastní výčtový typ, můžeme si v hlavní metodě Main deklarovat proměnnou den tohoto datového typu – viz Kód 2.

static void Main(string[] args)
{
    //Deklarace proměnné datového typu výčtový typ
    dnyVTydnu den;

Kód 2: Deklarace proměnné den výčtového typu dnyVTydnu v metodě Main

Jak jsme zvyklí z minulých kapitol kurzu, již deklarované proměnné můžeme přiřadit hodnotu. V tomto případě ale musíme přiřazovat kompatibilní hodnotu (stejného datového typu), tzn. pojmenovanou konstantu z výčtového typu dnyVTydnu. My jsme zvolili položku, jež představuje čtvrtek. Pro přístup k této konstantě výčtového typu používáme tzv. tečkovou notaci, tj. tečku „.“ uváděnou za výčtovým typem, tzn. hodnota dnyVTydnu.Ct – viz Kód 3. Pokud by existoval nesoulad typů, museli bychom použít konverzi – přetypování.

//Přiřazení hodnoty proměnné
den = dnyVTydnu.Ct;

Kód 3: Přiřazení hodnoty proměnné den 

//Výpis názvu hodnoty (konstanty) uložené v proměnné
Console.WriteLine("Den v týdnu: {0}", den);

Kód 4: Příklad výpisu obsahu proměnné den

Den v týdnu: Ct

Program VyctovyTypIndex

V příkladu jsme pro konstanty výčtového typu tentokrát použili datový typ short (menší rozsah intervalu datového typu short pro nás znamená menší paměťové nároky programu). Tento datový typ uvedeme za dvojtečku za názvem výčtového typu v jeho deklaraci - viz Kód 5. Samozřejmě platí, že přiřazovaná hodnota musí být v rozsahu zvoleného datového typu.

Pokud jsme první pojmenované konstantě výčtového typu přiřadili např. hodnotu 1, pak každá následující konstanta bude mít v sobě hodnotu o 1 vyšší než ta předchozí – viz Kód 5. Tyto hodnoty představují index dne v týdnu.

//Deklarace výčtového typu datového typu short s přiřazením hodnoty konstantě
enum dnyVTydnu : short { Po = 1, Ut, St, Ct, Pa, So, Ne };

Kód 5: Deklarace výčtového typu dnyVTydnu datového typu short s přiřazení hodnoty konstantě

Pro přiřazení hodnoty deklarované proměnné den výčtového typu dodržíme stejný postup jako v předchozím případu - viz Kód 2 a Kód 3. 

Ve výpisu indexu dne, však musíme obsah proměnné den přetypovat na datový typ int, protože potřebujeme přistoupit k hodnotě (indexu), která je uložena v konstantě Ct – viz Kód 6.

//Vypis hodnoty v položce (konstantě) - použití přetypování
Console.WriteLine("Den týdne: {0} a index tohoto dne: {1}", den, (int)den);

 Kód 6: Příklad výpisu obsahu uloženého v proměnné a indexu položky datového typu

U výčtových typů můžeme také použít operátory, které využíváme pro celočíselné proměnné, např. můžeme porovnávat pomocí operátoru ==, nebo dokonce provést aritmetickou operaci – viz Kód 7. Odečteme hodnotu 1 od proměnné den, čímž přistoupíme k předchozí položce (konstantě) uvedené ve výčtovém typu. Dále necháme vypsat index předchozí dne - v našem případě hodnotu 4 - 1 - viz Kód 7. 

//Vypis hodnoty v předchozí položce (konstantě) - použití přetypování
Console.WriteLine("Den předchozí: {0} a index tohoto dne: {1}", den-1, (int)den-1);

Kód 7: Příklad výpisu obsahu proměnné a indexu předchozí položky výčtového typu

Výpis hodnoty uložené v proměnné (položky výčtového typu a předchozí položky) včetně indexu této a předchozí položky by vypadal následovně - viz Výstup programu - VyctovyTypIndex_Main.

Den týdne: Ct a index tohoto dne: 4
Den předchozí: St a index tohoto dne: 3

Výstup programu - VyctovyTypIndex_Main - ukázka výpisu obsahu proměnné a indexu

U deklarace proměnné výčtového typu lze v inicializaci přiřadit i prázdnou hodnotu za použití modifikátoru ? - viz Kód 8.

//Deklarace proměnné výčtového typu s inicializací prázdné hodnoty
dnyVTydnu? den = null;

Kód 8: Příklad deklarace proměnné s přiřazením prázdné hodnoty

2.7. Struktura

V C# (.NET Framework) jsou dvě implementace konceptu třídy postavené na základě objektově orientovaného programování - třída a struktura. Struktura je dalším hodnotovým typem oproti třídě (ta je referenčního typu - rozdílnost je zejména ve způsobu ukládání. Více o způsobu ukládání se dozvíme později). Výhodou typu struktura je přímé uložení v paměti (v zásobníku) a tedy menší zatěžování správce paměti. Strukturu je tedy vhodné použít v případech, kdy nepotřebujeme ukládat, nebo pracovat s velkým množství dat.  Struktura může mít vlastní atributy – vlastní datové složky (anglicky "Fields") a metody (anglicky "Methods"). Metody můžeme vnímat jako podprogramy, které jsou implementovány ve struktuře.

Struktury jsme již využívali dříve, aniž bychom si to uvědomili. Primitivní datové typy jako např. int, long, float apod., jsou totiž ve skutečnosti strukturami. Mají totiž vlastní metody např. metoda ToString, která konvertuje daný datový typ do textu (string). K těmto metodám se dostaneme pomocí tečkové notace – viz Kód 1. Metoda ToString je definována pro každý typ, včetně struktur a tříd. Pokud potřebujeme, můžeme definovat novou verzi této metody, která potlačí její výchozí chování.

//Deklarace celočíselné proměnné včetně inicializace
int intPromenna = 7;
//Výpis s použitím metody ToString pro datový typ int
Console.WriteLine(intPromenna.ToString());

Kód 1: Příklad deklarace proměnné datového typu int včetně použití metody WriteLine

Tyto metody jsme zatím nemuseli používat, protože Console.WriteLine tuto metodu volá automaticky, když je zapotřebí. 

Měli bychom také uvést zásadní metodu Parse, kterou jsme využívali pro konverzi načteného textu a jeho konverze do příslušného datového typu – viz Kód 2. Tato metoda přečte jednotlivá písmena v textu a převede tento text v našem případu do celočíselné podoby. Pozor, datový typ string není struktura ale třída (o třídách se dozvíme později).

//Deklarace textové proměnné včetně inicialiazce
string stringPromenna = "42";
//Konverze na příslušný datový typ
int intPromenna = int.Parse(stringPromenna);

Kód 2: Příklad deklarace proměnné datového typu int a použití metody Parse

Pokud si vzpomínáte, využili jsme v kapitole o přetečení celého čísla metodu MaxValue, která nám vracela horní mez celého čísla.

Pro deklaraci se využívá klíčové slovo struct, za kterým se uvádí název struktura a tělo ve složených závorkách. V těchto složených závorkách může být uveden konstruktor, konstanty, datové složky, metody, vlastnosti, atd. 

Pojďme si na příkladu vysvětlit implementaci struktury.

Ilustrativní příklad StrukturaCas

Program StrukturaCas

• Popis: Příklad deklarace struktury, která obsahuje datové složky, konstruktor a metody 
• Zadání: Vytvořte strukturu casovyOkamzik, která pomocí vlastní metody převede zadaný celkový počet sekund na hodiny, minuty a sekundy a vypočtené hodnoty vypíše v hlavní metodě Main (pomocí metod VratHodiny, VratMinuty, VratSekundy implementovaných ve struktuře). To znamená, v třídě Program deklarujte strukturu s názvem Cas. Tato struktura bude obsahovat následující celočíselné atributy: hodiny - počet hodin; minuty - počet minut; sekundy - počet sekund. Tyto atributy budou přístupné pouze v rámci struktury. V rámci struktury vytvořte metodu, se shodným názvem jako struktura, pro inicializaci datových složek.  Tato metoda přijímá celočíselný vstupní argument sek představující celkový počet sekund. V konstruktoru převeďte celkový počet sekund na hodiny, minuty, sekundy
  
• Řešení: StrukturaCas_Main

Pojďme si vyzkoušet deklaraci struktury, kterou jsme uvedli ve třídě Program mimo metodu Main – viz Kód 3. Pro deklaraci struktury se využívá klíčové slovo struct, za kterým je uveden název struktury a za ním její tělo ve složených závorkách. V těchto složených závorkách jsme uvedli deklaraci celočíselných proměnných – jedná se o tzv. datové složky. Princip našeho příkladu spočívá v deklaraci struktury vyjadřující čas, kde jednotlivé datové složky vyjadřují počet hodin, minut a sekund. Před datovými složkami je uvedeno řízení přístupnosti k těmto složkám - tzv. modifikátor přístupu. Pokud je u datové složky uvedeno private, je k těmto složkám přístup pouze uvnitř definované struktury. Příkladem uveďme, že někdo by se mohl počet hodin nastavit na hodnotu 25, což by nebylo příliš vhodné pro další výpočty např. celočíselné dělení potřebné pro převod na dny (vycházíme z předpokladu, že den má 24 hodin :-) ). Protějškem k private je public.

//Deklarace datového typu struktura
struct Cas
{
    //Deklarace celočíselných datových složek
    private int hodiny, minuty, sekundy;
}

Kód 3: Deklarace datového typu struktura včetně deklarace celočíselných datových složek

U struktury nelze inicializovat hodnotu datové složky inicializovat přímo při její deklaraci – viz Kód 4!

//Při deklaraci nelze ve struktuře inicializovat hodnotu složky -> K.O.
private int hodiny = 0;
private int minuty, sekundy;

Kód 4: Příklad špatné deklarace datových složek s využitím inicializace

Asi Vás napadne, jak se k těmto složkám ale dostaneme z venku. Využijeme k tomu metodu implementovanou ve struktuře sloužící k inicializaci hodnot vlastních datových složek. Tato metoda se obecně nazývá konstruktor (anglicky „Constructor“). Kompilátor v C# umí vygenerovat vlastní (tzv. implicitní) konstruktor - viz Kód 5. 

//Deklarace proměnné typu struktura, včetně zavolání implicitního konstruktoru
Cas casovyOkamzik = new Cas();

Kód 5: Deklarace proměnné casovyOkamzik datového typu struktura včetně zavolání implicitního konstruktoru struktury Cas

Tento implicitní konstruktor nastaví všechny celočíselné datové složky struktury Cas na hodnotu 0 - viz Obrázek 1. Proměnná typu struktura je uložena v paměti typu zásobník (je to hodnotový typ).

Obrázek 1: Proměnná typu struktura Cas vygenerována implicitním konstruktorem

Struktura je  hodnotového typu, proto ji lze vytvořit (deklarovat) i bez volání konstruktoru. Pak ale její datové složky jsou neinicializovány - viz Obrázek 2. Pokud se tedy pokusíte vypsat hodnotu nějaké nějaké datové složky, kompilátor zahlásí chybu.

Obrázek 2: Deklarace proměnné typu struktura Cas (bez použití konstruktoru)

My však využijeme námi navržený (neimplicitní, tj. explicitní) konstruktor má stejný název jako je název struktury, tedy Cas. V tomto konstruktoru musí být nastaveny všechny datové složky struktury! Do konstruktoru bude vstupovat formální parametr sek, který vyjadřuje celkový počet sekund. Tento celkový počet sekund chceme převést na hodiny, minuty a sekundy. Tento parametr je předáván hodnotou, tzn., že do tohoto parametru se zkopíruje hodnota. S tímto parametrem budou dále prováděny v konstruktoru další aritmetické operace v našem případě celočíselné dělení a zbytek po celočíselném dělení. Až konstruktor skončí, tento parametr zanikne. Jedná se tedy pouze o vstupní parametr. 

Jak si můžete všimnout v dalším řádku kódu je proveden přepočet na hodiny pomocí celočíselného dělení. Tento výsledek je zapsán do datové složky náležící počtu hodin, tj. datová složka hodiny. Pro přístup do této složky využijeme klíčové slovo this s tečkou. Použitím tohoto slova přistoupíme k seznamu datových složek definovaných uvnitř struktury. Hodnotu této složce přiřadíme pomocí operátoru přiřazení. Následuje odebrání celých hodin z tohoto parametru pomocí zbytku po celočíselném dělení. Zbytek tedy reprezentuje zbývající minuty a sekundy. Princip výpočtu je znovu stejný – viz Kód 6.

//Deklarace vlastního konstruktoru
public Cas(int sek)
{
    //Převod sekund na celé hodiny -> nastavení datové složky
    this.hodiny = sek / (60 * 60);
    //Zbytek sekund po odebrání celých hodin
    sek = sek % (60 * 60);
    //Převod sekund na celé minuty -> nastavení dat. složky
    this.minuty = sek / 60;
    //Zbytek sekund po odebrání celých minut -> nastavení dat. složky
    this.sekundy = sek % 60;
}

Kód 6: Deklarace vlastního konstruktoru Cas datového typu struktura

Po vypočtení a přiřazení hodnoty do poslední datové složky již proměnná obsahuje hodnoty - proběhla jejich inicializace pomocí vlastního konstruktoru - viz Obrázek 3.

Obrázek 3: Proměnná typu struktura Cas vygenerována vlastním konstruktorem

Pro obdržení hodnoty uložené v datové složce např. hodiny, vytvoříme metodu VratHodiny (funkci), která nám navrací celočíselnou hodnotu počtu hodin (hodiny jsou datového typu int). Tato metoda je volně přístupná i mimo strukturu - přístupový modifikátor public. Tato metoda nemá žádný vstupní parametr, protože pouze potřebujeme získat výstup, tj. hodnotu příslušné datové složky. K té přistoupíme pomocí tečkové notace s využitím this. Pro přiřazení výstupu této metody využijeme příkaz return - viz Kód 7. 

//Deklarace metody ve struktuře - navrací hodnotu datové složky 'hodiny'
public int VratHodiny()
{
    //Navrácení hodnoty datové složky
    return this.hodiny;
}

Kód 7 Deklarace metody VratHodiny - navrácení hodnoty datové složky

Obdobně budeme postupovat u dalších datových složek minuty a sekundy - viz Kód 8. 

//Deklarace metody navracející počet minut uložených v datové složce
public int VratMinuty()
{
    return this.minuty;
}
 
//Deklarace metody navracející počet sekund uložených v datové složce
public int VratSekundy()
{
    return this.sekundy;
}

Kód 8: Deklarace metod VratMinuty a VratSekundy - navrácení hodnoty datové složky

Kódy nezbytné k deklaraci struktury, inicializaci datových složek pomocí konstruktoru a vrácení hodnot v datových složkách už máme vytvořeny. Nyní ale potřebujeme vytvořit proměnnou, která bude datového typu struktura. Tato deklarace v metodě Main je v podstatě stejná jako u předchozích datových typů, ale až na jeden rozdíl. Využívá zavolání konstruktoru pomocí klíčového slova new. Tento konstruktor ze zadané hodnoty (v našem případě 37000 sekund) inicializuje všechny datové složky struktury – viz Kód 9.

//Deklarace proměnné typu struktura, včetně zavolání vlastního konstruktoru
Cas casovyOkamzik = new Cas(37000);

Kód 9: Příklad deklarace proměnné casovyOkamzik datového typu struktura včetně zavolání vlastního konstruktoru

Je asi jasné, že po obětování takového úsilí, bychom chtěli vidět výsledky naší práce. Využijeme proto příkaz výpisu do konzole a necháme vypsat vypočtené datové složky. K tomu využijeme volně přístupné metody (funkce), které nám navrací jednotlivé hodnoty datových složek, tj. VratHodiny, VratMinuty, VratSekundy - viz Kód 10.

//Výpis jednotlivých hodnot v datových složkách
Console.WriteLine("Je právě: {0} hodin, {1} minut, {2} sekund", casovyOkamzik.VratHodiny(), casovyOkamzik.VratMinuty(), casovyOkamzik.VratSekundy());

Kód 10: Výpis hodnot jednotlivých datových složek proměnné

Ve výpisu vidíme přepočtené sekundy na hodiny, minuty a sekundy – viz Výstup programu - StrukturaCas_Main.

Je právě: 10 hodin, 16 minut, 40 sekund

Výstup programu - StrukturaCas_Main: Ukázka výpisu obsahu datových složek uložených v proměnné datového typu struktura

U deklarace proměnné typu struktura lze také použít tzv. modifikátor ?, který uvedeme za typ struktury a přiřadíme prázdnou hodnotu - viz Kód 11.

//Deklarace proměnné typu struktura s inicializací prázdné hodnoty
Cas? casovyOkamzik = null;

Kód 11: Příklad deklarace proměnné datového typu struktura s prázdnou hodnotou (null)

2.8. Rozdíl mezi strukturou a třídou

Následující tabulka ukazuje rozdíly mezi strukturou a třídou – viz Tabulka 1.

2.9. Stručné shrnutí

int intPromenna = 10;

long longPromenna = 42L;

longPromenna = intPromenna;

intPromenna = (int)longPromenna;

float floatPromenna = 0.42F;

double doublePromenna = 0.42;

string stringPromenna = "Ahoj";

char charPromenna = 'A';

bool boolPromenna = false;

enum dnyVTydnu { Po, Ut, St, Ct, Pa, So, Ne };

dnyVTydnu den = dnyVTydnu.Po;

struct Cas
{
    private int hodiny, minuty, sekundy;
    ...
    public Cas(int hod, int min, int sek)
    {
        ...
    }
}

Cas casObeda = new Cas(11, 30, 00);