3. diel - Premenné, typový systém a parsovanie v C# .NET

V predchádzajúcej časti kurzu C#, Visual Studio a prvá konzolová aplikácia v C# .NET, sme sa naučili pracovať s Visual Studiom a vytvorili sme si konzolovú aplikáciu.

Dnes sa v tutoriáli pozrieme na tzv. typový systém, ukážeme si základné dátové typy a prácu s premennými. Výsledkom budú 4 jednoduché programy vrátane kalkulačky.

Premenné

Skôr, ako začneme riešiť dátové typy, poďme si definovať, čo je to premenná (programátori mi teraz určite odpustia zbytočné vysvetľovanie). Z matematiky určite poznáte premennú (napr. x), do ktorej sme si mohli vložiť nejakú hodnotu, najčastejšie číslo. Premenná v informatike je úplne to isté; je to miesto v pamäti počítača, kam si môžeme uložiť nejaké dáta (meno užívateľa, aktuálny čas alebo databázu článkov). Toto miesto má podľa typu premennej tiež vyhradenú určitú veľkosť, ktorú premenná nesmie presiahnuť (napr. číslo nesmie byť väčšie ako 2 147 483 647).

Premenná má vždy nejaký dátový typ, môže to byť číslo, znak, text a podobne, záleží od toho, na čo ju chceme používať. Pred prácou s premennou ju väčšinou musíme najskôr tzv. deklarovať, teda musíme povedať jazyku, ako sa premenná bude volať a akého dátového typu bude (aký v nej bude obsah). Jazyk ju v pamäti založí a až potom s ňou môžeme pracovať. Podľa dátového typu premennej si ju jazyk dokáže z pamäte načítať, modifikovať, prípadne ju v pamäti založiť. O každom dátovom type jazyk vie, koľko v pamäti zaberá miesta a ako s týmto kusom pamäte pracovať.

Typový systém

Existujú dva základné typové systémy: statický a dynamický.

• Dynamický typový systém nás úplne odtieňuje od toho, že má premenná vôbec nejaký dátový typ. Ona ho samozrejme vnútorne má, ale jazyk to nedáva najavo. Dynamické typovanie ide mnohokrát tak ďaleko, že premenné nemusíme ani deklarovať. Akonáhle do nejakej premennej niečo uložíme a jazyk zistí, že nebola nikdy deklarovaná, sám ju založí. Do tej istej premennej môžeme ukladať text, potom objekt užívateľa a potom desatinné číslo. Jazyk sa s tým sám pobije a vnútorne automaticky mení dátový typ. V týchto jazykoch ide vývoj rýchlejšie vďaka menšiemu množstvu kódu, ich zástupcami sú napr. PHP alebo Ruby.
• Statický typový systém naopak striktne vyžaduje definovanie typu premennej a tento typ je ďalej nemenný. Akonáhle premennú raz deklarujeme, nie je možné jej dátový typ zmeniť. Akonáhle sa do textového reťazca pokúsime uložiť objekt používateľ, dostaneme vynadané.

C# je staticky typovaný jazyk, všetky premenné teda musíme najskôr deklarovať s ich dátovým typom. Nevýhodou je, že kvôli deklaráciám je zdrojový kód o niečo objemnejší a vývoj pomalší. Obrovskou výhodou však je, že nám kompilátor pred spustením skontroluje, či všetky dátové typy sedia. Dynamické typovanie síce vyzerá ako výhodné, ale zdrojový kód nie je možné automaticky kontrolovať, a keď niekde očakávame objekt používateľ a príde nám tam namiesto toho desatinné číslo, odhalí sa chyba až za behu a interpreter program zhodí. Naopak C# nám nedovolí program ani skompilovať a na chybu nás upozorní (to je ďalšia výhoda kompilácie).

Poďme si teraz niečo naprogramovať, nech si nadobudnuté vedomosti trochu osvojíme, s teóriou budeme pokračovať až nabudúce. Povedzme si teraz tri základné dátové typy:

• celé čísla: int,
• desatinné čísla: float,
• textový reťazec: string.

Program vypisujúci premennú

Skúsime si nadeklarovať celočíselnú premennú a, dosadiť do nej číslo 56 a jej obsah vypísať do konzoly. Vymenujte si nový projekt, nazvite ho Output (aj ku všetkým ďalším príkladom si vždy vytvorte nový projekt):

{CSHARP_CONSOLE}
int a;
a = 56;
Console.WriteLine(a);
Console.ReadKey();
{/CSHARP_CONSOLE}

Pripomeňme, že kód píšeme do tela metódy Main() v prípade projektov starších ako .NET 6.0.

Prvý príkaz nám nadeklaruje novú premennú a dátového typu int. Premenná teda bude slúžiť na ukladanie celých čísel. Druhý príkaz vykonáva priradenie do premennej, slúži na to operátor "rovná sa" (=). Posledný príkaz je nám známy, vypíše do konzoly obsah premennej a. Konzola je múdra a vie vypísať aj číselné premenné. ReadKey() je nám známy:

Konzolová aplikácia
56

Pre desatinnú premennú by kód vyzeral takto:

{CSHARP_CONSOLE}
float a;
a = 56.6F;
Console.WriteLine(a);
Console.ReadKey();
{/CSHARP_CONSOLE}

Je to takmer rovnaké ako s celočíselnou premennou. Ako desatinný oddeľovač používame bodku (.) a na konci desatinného čísla je nutné zadať tzv. sufix F, tým hovoríme, že sa jedná o float.

Program Parrot

Predchádzajúci program bol trochu nudný, skúsme teda nejako reagovať na vstup od používateľa. Napíšeme program Parrot, ktorý bude dvakrát opakovať to, čo používateľ napísal. Ešte sme neskúšali z konzoly nič načítať, ale je to veľmi jednoduché. Slúži na to metóda ReadLine(), ktorá nám vráti textový reťazec z konzoly. Skúsme si napísať nasledujúci kód:

{CSHARP_CONSOLE}
Console.WriteLine("Hi, I am a virtual parrot Lora, I love to repeat!");
Console.WriteLine("Type something in: ");

string input;
input = Console.ReadLine();

string output;
output = input + ", " + input + "!";

Console.WriteLine(output);
Console.ReadKey();
{/CSHARP_CONSOLE}

To už je trochu zábavnejšie Prvé dva riadky sú jasné, ďalej deklarujeme textový reťazec input. Do input sa priradí hodnota z metódy ReadLine() na konzole, teda to, čo používateľ zadal. Pre výstup si pre názornosť vytvoríme ďalšiu premennú typu textový reťazec. Zaujímavé je to, ako na výsledok premennej output využívame tzv. konkatenáciu (spájanie) reťazcov. Pomocou operátora + totiž môžeme spojiť niekoľko textových reťazcov do jedného a je jedno, či je reťazec v premennej, alebo je explicitne zadaný v úvodzovkách do zdrojového kódu. Do premennej teda priradíme input, ďalej čiarku, znovu input a potom výkričník. Premennú vypíšeme, vyčkáme na stlačenie klávesu a skončíme:

Konzolová aplikácia
Hi, I am a virtual parrot Lora, I love to repeat!
Type something in: 
Hello bird
Hello bird, Hello bird!

Do premennej môžeme priraďovať už v jej deklarácii, nasledujúcu časť kódu môžeme skrátiť:

string input;
input = Console.ReadLine();

Jednoducho napíšeme iba:

string input = Console.ReadLine();

Program by sa dal skrátiť ešte viac v mnohých ohľadoch. Všeobecne je ale lepšie používať viac premenných a dodržiavať prehľadnosť, ako napísať čo najkratší kód a po mesiaci zabudnúť, ako vôbec funguje.

Program Doubler

Doubler si vyžiada na vstupe číslo a to potom vynásobí hodnotou 2 a vypíše. S doterajšími znalosťami by sme asi napísali niečo také:

Console.WriteLine("Enter a number and I will double it: ");
int a = Console.ReadLine();
a = a * 2;
Console.WriteLine(a);
Console.ReadKey();

Všimnite si vynásobenie čísla a, ktoré sme vykonali pomocou priradenia. C# nás teraz karhá a podčiarkne riadok, v ktorom sa snažíme hodnotu z konzoly dostať do premennej typu int. Narážame na typovú kontrolu, konkrétne nám ReadLine() vracia string a my sa ho snažíme uložiť do int. Všetko, čo príde z textovej konzoly, je vždy text, a to aj keď zadáme číslo. Budeme ho potrebovať tzv. naparsovať.

Parsovanie

Parsovaním myslíme prevod z textovej podoby na nejaký špecifický typ, napr. číslo. Veľa dátových typov v C# má už pripravené metódy na parsovanie. Ak budeme chcieť naparsovať napr. int zo string, budeme postupovať takto:

string s = "56";
int a = int.Parse(s);

Vidíme, že dátový typ int má na sebe priamo metódu Parse(), ktorá ako parameter berie textový reťazec a vráti číslo. To využijeme v našom programe:

{CSHARP_CONSOLE}
Console.WriteLine("Enter a number and I will double it: ");
string s = Console.ReadLine();
int a = int.Parse(s);
a = a * 2;
Console.WriteLine(a);
Console.ReadKey();
{/CSHARP_CONSOLE}

Najprv si text z konzoly uložíme do textového reťazca s. Do celočíselnej premennej a potom uložíme číselnú hodnotu reťazca s. Ďalej hodnotu v a vynásobíme hodnotou 2 a vypíšeme do konzoly:

Konzolová aplikácia
Enter a number and I will double it: 
1024
2048

Môžete sa stretnúť s parsovaním zo string pomocou triedy Convert, tá však slúži na konverziu medzi číslami a s textom si nemusí poradiť správne, takže ide o zlé riešenie.

Parsovanie sa samozrejme nemusí podariť, keď bude v texte namiesto čísla napr. "slovo", ale tento prípad zatiaľ riešiť nebudeme.

Jednoduchá kalkulačka

Ešte sme nepracovali s desatinnými číslami, tak si teda skúsme napísať sľubovanú kalkulačku. Bude veľmi jednoduchá - na vstup prídu dve čísla, program potom vypíše výsledky sčítania, odčítania, násobenia a delenia. Namiesto dátového typu float použijeme pre desatinné čísla iný datový typ, a to double:

{CSHARP_CONSOLE}
Console.WriteLine("Welcome to our calculator");
Console.WriteLine("Enter the first number:");
double a = double.Parse(Console.ReadLine());
Console.WriteLine("Enter the second number:");
double b = double.Parse(Console.ReadLine());
double sum = a + b;
double difference = a - b;
double product = a * b;
double quotient = a / b;
Console.WriteLine("Addition: " + sum);
Console.WriteLine("Subtraction: " + difference);
Console.WriteLine("Multiplication: " + product);
Console.WriteLine("Division: " + quotient);
Console.WriteLine("Thank you for using our calculator. Press any key to end the program.");
Console.ReadKey();
{/CSHARP_CONSOLE}

Konzolová aplikácia
Welcome to our calculator
Enter the first number:
3,14
Enter the second number:
2,72
Addition: 5,86
Subtraction: 0,42
Multiplication: 8,5408
Division: 1,15441176470588
Thank you for using our calculator. Press any key to end the program.

Všimnime si dve veci. Po prvé sme zjednodušili parsovanie z konzoly tak, aby sme nepotrebovali stringovú premennú, pretože by sme ju aj tak už potom nepoužili. Po druhé, na konci programu spájame reťazec s číslom pomocou operátora +. C# prekvapivo nezahlási chybu, ale vykoná tzv. implicitnú konverziu a zavolá na čísle metódu ToString(). Keby to tak nebolo alebo keby sme sa dostali do situácie, keď potrebujeme previesť čokoľvek na string, zavoláme na premenné metódu ToString(). C# to v tomto prípade urobil za nás a v podstate vykoná:

Console.WriteLine("Addition: " + sum.ToString());

Práve sme sa teda naučili opak parsovania – previesť čokoľvek do textovej podoby.

Operátor nameof

Niekedy sa nám môže hodiť získať namiesto hodnoty premennej jej názov. Slúži na to operátor nameof:

int number = 5;
Console.WriteLine(nameof(number));

Výstup:

Konzolová aplikácia
number

Môžeme si vyskúšať, že program naozaj nevypíše päťku, ale number.

Všetky programy máte samozrejme opäť v prílohe, skúšajte si vytvárať nejaké podobné, vedomosti už máte

V budúcej lekcii, Využitie umelej inteligencie pri štúdiu programovania, sa pozrieme na využitie umelej inteligencie pri štúdiu programovania.

 

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.