4. diel - Typový systém druhýkrát: Dátové typy
V predchádzajúcom cvičení, Riešené úlohy k 1.-3. lekciu C # .NET, sme si precvičili získané skúsenosti z predchádzajúcich lekcií.
V minulej lekcii C # kurzu, Riešené úlohy k 1.-3. lekciu C # .NET , sme si ukázali základné dátové
typy, boli to int
, string
a float
.
Teraz sa na dátové typy pozrieme viac zblízka a vysvetlíme si, kedy aký
použiť. Dnešná lekcia bude veľa teoretická, ale o to viac bude praktická
tá budúci. Na konci si vytvoríme pár jednoduchých ukážok.
C # rozoznáva dva druhy dátových typov, hodnotové a referenčný.
Hodnotovej dátové typy
Premenné hodnotového dátového typu si dokážeme jednoducho predstaviť. Môže sa jednať napr. O číslo alebo znak. V pamäti je jednoducho uložená priamo hodnota a my k tejto hodnote môžeme z programu priamo pristupovať. Slovo priamo som toľkokrát nepoužil len náhodou. V tomto C # kurze sa budeme venovať výhradne týmto premenným.
Celočíselné dátové typy
Pozrime sa teraz na tabuľku všetkých vstavaných celočíselných
dátových typov v .NET, všimnite si typu int
, ktorý už
poznáme zminula.
dátový typ | rozsah | veľkosť | .NET typ |
---|---|---|---|
sbyte | -128 až 127 | 8 bitov | System.SByte |
byte | 0 až 255 | 8 bitov | System.Byte |
short | -32 768 až 32 767 | 16 bitov | System.Int16 |
ushort | 0 až 65 535 | 16 bitov | System.UInt16 |
int | -2 147 483 648 až 2 147 483 647 | 32 bitov | System.Int32 |
UINT | 0 až 4 294 967 295 | 32 bitov | System.UInt32 |
long | -9 223 372 036 854 775 808 až 9 223 372 036 854 775 807 | 64 bitov | System.Int64 |
ulong | 0 až 18 446 744 073 709 551 615 | 64 bitov | System.UInt64 |
Prípadne v dokumentácii k Visual štúdiu to nájdete podrobnejšie. Do dokumentácie sa dostanete, keď napíšete konkrétny dátový typ, označíte ho a stlačíte F1.
Asi vás napadá otázka, prečo máme toľko možných typov pre uloženie
čísla. Odpoveď je prostá, záleží na jeho veľkosti. Čím väčšie
číslo, tým viac spotrebuje pamäte. Pre vek užívateľov teda zvolíme
byte
, pretože sa určite nedožije viac, ako 255 rokov.
Predstavte si databázu milióna užívateľov nejakého systému, keď zvolíme
miesto byte int
, bude zaberať 4x viac miesta. Naopak keď budeme
mať funkciu na výpočet faktoriálu, ťažko nám bude stačiť rozsah integer
a použijeme long
.
Všimnite si, že niektoré typy začínajú na u
. Sú takmer
rovnaké, ako ich dvojníci bez u
, len neumožňujú záporné
hodnoty a tým pádom na kladnú časť môžu uložiť 2x vyššiu hodnotu.
Týmto typom sa hovorí unsigned, klasickým
signed.
.NET typ je názov danej štruktúry v .NET knižniciach. My používame tzv. Aliasy, aby bola práca jednoduchšia, v skutočnosti si C # kód:
int a = 10;
preberie ako:
System.Int32 a = 10;
My budeme samozrejme používať aliasy, od toho tam sú
Nad výberom dátového typu nemusíte moc premýšľať a väčšinou sa
používa jednoducho int
. Typ riešte len v prípade, keď sú
premenné v nejakom poli (všeobecne kolekciu) a je ich teda viac, potom sa
oplatí zaoberať sa pamäťovými nárokmi. Tabuľky sem dávam skôr pre
úplnosť. Medzi typy samozrejme funguje už spomínaná implicitné konverzie,
teda môžeme priamo priradiť int
do premennej typu
long
a podobne, bez toho aby sme niečo konvertovali.
Desatinné čísla
U desatinných čísel je situácia trochu jednoduchšie, máme na výber iba
dva dátové typy. Samozrejme sa líšia opäť v rozsahu hodnoty, ďalej však
ešte v presnosti (vlastne počtu des. Miest). Typ double
má už
podľa názvu dvojnásobnú presnosť oproti float
.
dátový typ | rozsah | presnosť | .NET typ |
---|---|---|---|
float | + -1.5 * 10 -45 až + -3.4 * 10 38 | 7 čísel | System.Single |
double | + -5.0 * 10 -324 až + -1.7 * 10 308 | 15-16 čísel | System.Double |
Keď do float
u chceme dosadiť priamo v zdrojovom kóde,
musíme použiť sufix F
, u double
sufix
D
(u double ho môžeme vypustiť, pretože je predvolený
desatinná typ):
float f = 3.14F; double d = 2.72;
Ako desatinný separátor používame v zdrojovom kóde vždy bodku, nehľadiac na to, aké máme vo Windows regionálne nastavenia.
Ďalšie vstavané dátové typy
Pozrime sa na ďalšie dátové typy, ktoré nám .NET ponúka:
dátový typ | rozsah | Veľkosť / Presnosť | .NET typ |
---|---|---|---|
char | U + 0000 až U + ffff | 16 bitov | System.Char |
decimal | + -1.0 * 10 -28 až + -7.9 * 10 28 | 28-29 čísel | System.Decimal |
bool | true alebo false | 8 bitov | System.Boolean |
Char nám reprezentuje jeden znak, na rozdiel od string
u,
ktorý reprezentoval celý reťazec char
ov. Znaky v C # píšeme
do úvodzoviek:
char c = 'A';
Typ char
patrí v podstate do celočíselných premenných
(obsahuje číselný kód znaku), ale prišlo mi logickejšie uviesť ho tu. Typ
char
nám vracia napr. Metóda Console.ReadKey()
.
Decimal
Typ decimal
rieši problém ukladania desatinných čísel v
binárnej podobe, ukladá totiž číslo vnútorne podobne ako text. Používa
sa teda pre uchovanie peňažných hodnôt. Ku všetkým ďalším matematickým
operáciám s des. číslami použijeme float
alebo
double
. K zápisu decimal
hodnoty opäť používame
sufix, m
:
decimal m = 3.14159265358979323846m;
Bool
Dátový typ bool
nadobúda dvoch hodnôt: true
(pravda) a false
(nepravda). Budeme ho používať najmä vtedy,
až sa dostaneme k podmienkam. Do premennej typu bool
možno
uložiť ako priamo hodnotu true
/ false
, tak i
logický výraz. Skúsme si jednoduchý príklad:
{CSHARP_CONSOLE}
bool b = false;
bool vyraz = (15 > 5);
Console.WriteLine(b);
Console.WriteLine(vyraz);
Console.ReadKey();
{/CSHARP_CONSOLE}
Výstup programu:
Konzolová aplikácia
False
True
Výrazy píšeme do zátvoriek. Vidíme, že výraz nadobúda hodnoty
true
(pravda), pretože 15
je naozaj väčší ako
5
. Od výrazov je to len krok k podmienkam, na ne sa pozrieme
nabudúce.
Referenčnej dátové typy
K referenčným typom sa dostaneme až u objektovo orientovaného
programovania, kde si tiež vysvetlíme zásadné rozdiely. Zatiaľ budeme
pracovať len s tak jednoduchými typmi, že rozdiel nepoznáme. Uspokojíme sa
s tým, že referenčná typy sú zložitejšie, než tie hodnotové. Jeden
taký typ už poznáme, je ním string
. Možno vás napadá, že
string
nemá nijako obmedzenú dĺžku, je to tým, že s
referenčnými typy sa v pamäti pracuje inak.
Typ string
má na sebe rad naozaj užitočných metód.
Niektoré si teraz preberieme a vyskúšame:
String
StartsWith () EndsWith () a Contains ()
Môžeme sa jednoducho opýtať, či reťazec začína, končí alebo či
obsahuje určitý podreťazec (substring). Podreťazcom myslíme časť
pôvodného reťazca. Všetky tieto metódy budú ako parameter brať samozrejme
podreťazec a vracať hodnoty typu bool
( true
/
false
). Zatiaľ na výstup nevieme reagovať, ale poďme si ho
aspoň vypísať:
{CSHARP_CONSOLE}
string s = "Krokonosohroch";
Console.WriteLine(s.StartsWith("krok"));
Console.WriteLine(s.EndsWith("hroch"));
Console.WriteLine(s.Contains("nos"));
Console.WriteLine(s.Contains("roh"));
Console.ReadKey();
{/CSHARP_CONSOLE}
Výstup programu:
Konzolová aplikácia
False
True
True
False
Vidíme, že všetko funguje podľa očakávania. Prvý výraz samozrejme neprešiel vďaka tomu, že reťazec v skutočnosti začína veľkým písmenom.
ToUpper () a ToLower ()
Rozlišovanie veľkých a malých písmen môže byť niekedy na obtiaž.
Veľakrát sa budeme potrebovať opýtať na prítomnosť podreťazca tak, aby
nezáležalo na veľkosti písmen. Situáciu môžeme vyriešiť pomocou metód
ToUpper()
a ToLower()
, ktoré vracia reťazec vo
veľkých a v malých písmenách. Uveďme si reálnejšie príklad ako je
Krokonosohroch. Budeme mať v premennej riadok konfiguračného súboru, ktorý
písal užívateľ. Keďže sa na vstupy od užívateľov nemožno spoľahnúť,
musíme sa snažiť eliminovať možné chyby, tu napr. S veľkými
písmenami.
{CSHARP_CONSOLE}
string konfig = "Fullscreen shaDows autosave";
konfig = konfig.ToLower();
Console.WriteLine("Pobeží hra vo fullscreen?");
Console.WriteLine(konfig.Contains("fullscreen"));
Console.WriteLine("Budú zapnuté tiene?");
Console.WriteLine(konfig.Contains("shadows"));
Console.WriteLine("Želá si hráč vypnúť zvuk?");
Console.WriteLine(konfig.Contains("nosound"));
Console.WriteLine("Želá si hráč hru automaticky ukladať?");
Console.WriteLine(konfig.Contains("autosave"));
Console.ReadKey();
{/CSHARP_CONSOLE}
Výstup programu:
Konzolová aplikácia
Pobeží hra vo fullscreen?
True
Budú zapnuté tiene?
True
Želá si hráč vypnúť zvuk?
False
Želá si hráč hru automaticky ukladať?
True
Vidíme, že sme schopní zistiť prítomnosť jednotlivých slov v reťazci tak, že si najprv reťazec prevedieme celý na malé písmená (alebo na veľké) a potom kontrolujeme prítomnosť slová len malými (alebo veľkými) písmenami. Takto by mimochodom mohlo naozaj vyzerať jednoduché spracovanie nejakého konfiguračného skriptu.
Trim (), TrimStart () a TrimEnd ()
Problémom vo vstupoch od užívateľa môže byť aj diakritika. C # ale našťastie pracuje plne v UTF-8, nestane sa nám teda, že by sa diakritika nejako skomolila. Ďalšou nástrahou môžu byť medzery a všeobecne všetky tzv. Biele znaky, ktoré nie sú vidieť, ale môžu nám uškodiť. Vo všeobecnosti môže byť dobré tzv. Trimovať všetky vstupy od užívateľa, môžeme trimovať buď okolo celého reťazca alebo len biele znaky pred ním a za ním. Prezradím, že pri parsovacích funkciách C # trimuje zadaný reťazec automaticky, než s ním začne pracovať. Odstránené sú len neviditeľné znaky okolo reťazca, napr. Medzery medzi slovami zostanú. Skúste si v nasledujúcej aplikácii pred číslo a za číslo zadať niekoľko medzier:
{CSHARP_CONSOLE}
Console.WriteLine("Zadajte číslo:");
string s = Console.ReadLine();
Console.WriteLine("Zadal ste text: " + s);
Console.WriteLine("Text po funkciu trim: " + s.Trim());
int a = int.Parse(s);
Console.WriteLine("Previedol som zadaný text na číslo parsováním, zadal ste: " + a);
Console.ReadKey();
{/CSHARP_CONSOLE}
Replace ()
Asi najdôležitejšie metódou na string
u je nahradenie
určitej jeho časti iným textom. Ako parametre zadáme dva podreťazca, jeden
čo chceme nahrádzať a druhý ten, ktorým to chceme nahradiť. Metóda vráti
nový string
, v ktorom prebehlo nahradenie. Keď daný podreťazec
metóda nenájde, vráti pôvodnú reťazec. Skúsme si to:
{CSHARP_CONSOLE}
string s = "Java je najlepší!";
s = s.Replace("Java", "C #");
Console.WriteLine(s);
Console.ReadKey();
{/CSHARP_CONSOLE}
Výstup programu:
Konzolová aplikácia
C # je najlepší!
Format ()
Format()
je veľmi užitočná metóda, ktorá nám umožňuje
vkladať do samotného textového reťazca zástupné značky. Tie sú
reprezentované ako číslo v zložených zátvorkách, prvým číslom je
0
. Ako ďalšie parametre metódy nasledujú v tomto poradí
premenné, ktoré sa majú do textu namiesto značiek vložiť. Všimnite si,
že sa metóda nevolá na konkrétne premenné (presnejšie inštanciu, pozri
ďalší lekcie), ale priamo na typu string
.
{CSHARP_CONSOLE}
int a = 10;
int b = 20;
int c = a + b;
string s = string.Format("Keď sčítame {0} a {1}, dostaneme {2}", a, b, c);
Console.WriteLine(s);
Console.ReadKey();
{/CSHARP_CONSOLE}
Výstup programu:
Konzolová aplikácia
Keď sčítame 10 a 20, dostaneme 30
Konzola sama vie prijímať text v takomto formáte, môžeme teda napísať:
{CSHARP_CONSOLE}
int a = 10;
int b = 20;
int c = a + b;
Console.WriteLine("Keď sčítame {0} a {1}, dostaneme {2}", a, b, c);
Console.ReadKey();
{/CSHARP_CONSOLE}
Toto je veľmi užitočná a prehľadná cesta, ako zostavovať reťazca, a
určite sa ju oplatí mnohokrát použiť namiesto bežnej konkatenace pomocou
operátora +
, ak nebazírujú na vysokej rýchlosti.
PadLeft () a PadRight ()
Ako posledný si spomenieme metódy, ktoré nám k textu naopak medzery
pridajú K čomu to je dobré?
Predstavte si, že máme 100 premenných a budeme ich chcieť usporiadať do
tabuľky. Text upravíme pomocou metódy PadRight()
s parametrom
šírky stĺpca, teda napr. 20 znakov. Pokiaľ bude mať text len 12 znakov,
vypíše sa pred neho 8 medzier, aby mal veľkosť 20. Obdobne metóda
PadLeft()
by vypísala 8 medzier za neho. Keďže nemáme znalosti
na vytvorenie takej tabuľky, budeme si metódy len pamätať a vyskúšame si
ich ďalej v C # kurze.
Vlastnosť Length
Posledný, ale najdôležitejšie vlastnosť (pozor, nie metóda) je
Length
, teda dĺžka. Vracia celé číslo, ktoré predstavuje
počet znakov v reťazci. Za vlastnosti nepíšeme zátvorky, pretože nemajú
parametre.
{CSHARP_CONSOLE}
Console.WriteLine("Zadajte vaše meno:");
string jmeno = Console.ReadLine();
Console.WriteLine("Dĺžka vášho mena je: {0}", jmeno.Length);
Console.ReadKey();
{/CSHARP_CONSOLE}
Je toho ešte veľa k vysvetľovaniu a sú ďalšie dátové typy, ktoré sme neprebrali. Aby sme však stále nepreberala len teóriu, ukážeme si už v nasledujúcej lekcii, Riešené úlohy k 4. lekcii C # .NET , podmienky a neskôr cykly, potom bude naša programátorská výbava dostatočne veľká na to, aby sme tvorili zaujímavé programy
V nasledujúcom cvičení, Riešené úlohy k 4. lekcii C # .NET, si precvičíme nadobudnuté skúsenosti z predchádzajúcich lekcií.