Základné údajové typy

Premenné

Počas činnosti programu dochádza často k presúvaniu údajov, ktoré sú uložené v pamäti. Bloky pamäte, ktoré slúžia na ukladanie potrebných údajov sa nazývajú premenné. Každá premenná je pomenovaná identifikátorom, pomocou ktorého sa pristupuje k ich obsahu.  Meno premennej môže byť ľubovoľné slovo, ktoré môže obsahovať aj číslice (nie na začiatku), ale aj znak _ (podčiarkovník). Malo by sa zvoliť tak, aby už jej názov vyjadroval, čo bude v tejto premennej uchované. Mená premenných nemôžu obsahovať písmená s diakritikou.

Predtým ako sa v programe použije akákoľvek premenná, je nutné, aby sa na začiatku programu objavilo slovo var a za ním jej deklarácia.
To znamená, že hneď na začiatku musí byť kompilátoru jasné, koľko premenných bude použitých, aby pre ne vyhradil dostatočné množstvo pamäte.

Napríklad:
 var
  A, X, Y: Integer;

V príklade sme zadeklarovali tri celočíselné premenné - za slovo var sme najprv vymenovali premenné A, X, Y a za dvojbodku zapísali, že budú celočíselné - Integer.

Treba si zapamätať, že takéto premenné sa v pamäti vyhradia vždy pri štarte programu, alebo procedúry (napr. pri slove begin) - vtedy majú ešte nedefinovanú hodnotu a treba im nejakú priradiť. Od tohto momentu môžeme s nimi pracovať pomocou ich mien, môžeme tieto hodnoty aj viackrát meniť, ale zapamätajme si, že na konci procedúry (pri slove end) sa tieto premenné zrušia a ich hodnota sa nenávratne zabudne.

Údajové typy

Údaje, ktoré sa v programe spracovávajú sú zakaždým iné. Raz sú to celé čísla, inokedy reálne čísla, znaky, alebo celé reťazce znakov. Všetky tieto údaje sú natoľko nesúrodé, že je nutné mať aj niekoľko druhov premenných, ktoré sa budú od seba líšiť typom údajov, ktoré sú v nich uložené. Zavedenie rôznych údajových typov pre premenné prináša dve výhody.
Jednak úsporu pamäte, pretože pre uloženie jedného znaku určite postačí menší pamäťový priestor ako pre uloženie celej vety.
Druhá výhoda spočíva v tom, že programátor je ušetrený pokušenia sčítať príslovečné jablká s hruškami. Inými slovami sa dá ľahko zabrániť tomu, aby vykonával neprípustné operácie s údajmi, ktoré spolu nesúvisia. Napríklad sčítaním slova ,program' a čísla 10 sa nedá väčšinou získať zmysluplný výsledok.

dajové typy v Delphi je možné rozdeliť do niekoľkých skupín:

• celočíselné typy,
• reálne typy,
• znaky,
• logické hodnoty,
• reťazce,
• ukazovatele,
• užívateľom definované typy.

Okrem tohto triedenia je možné všetky údajové typy v Delphi rozdeliť na dve základné skupiny:

• ordinálne
• neordinálne

Ordinálne
Do tejto kategórie patria všetky typy, u ktorých je presne daná postupnosť medzi jednotlivými hodnotami. To znamená, že sa vždy vie, ktorá hodnota je nasledujúca a ktorá predchádzajúca. Preto sem patria všetky celočíselné typy, znaky a ešte niektoré ďalšie typy. Ak niekto nechápe, prečo tomu tak je, stačí si uvedomiť, že číslu dva vždy predchádza jednotka a nasleduje ho číslo tri. Rovnako po písmene 'B' je vždy 'C' atd.
Poradie každej takej hodnoty je dané tzv. ordinálnou hodnotou. Prvá hodnota typu má ordinálnu hodnotu 0 a každá ďalšia o jednotku väčšia.
Pre prácu s ordinálnymi typmi zavádza Delphi päť funkcií:

• Ord: zistí ordinálnu hodnotu prvku. Napr. Ord (1) vráti hodnotu 1, pretože jednotka je druhá v poradí. (prvá je nula a ordinálna hodnota sa počíta od nuly) a Ord { 'A' } vracia hodnotu 65 (Znak A je v poradí 66). Pred ním sú znaky čísiel a niektoré ďalšie
• Pred: vracia hodnotu, ktorá predchádza hodnote uvedenej v zátvorke. Napr. Pred ( 1 ) vracia hodnotu 0 a príkaz Pred ( 'A' ) vracia znak @, pretože má o jednotku nižšiu ordinálnu hodnotu ako veľké A.
• Succ: je pravým opakom predchádzajúcej funkcie a vracia nasledujúcu hodnotu argumentu. Teda succ (1) = 2 a Succ (‘A') = 'B'.
• High: výsledkom tej to funkcie je najvyššia hodnota, ktorú môže premenná daného typu nadobúdať. Napr. High (byte) = 255, pretože rozsah typu Byte je 0 až 255.
• Low: táto funkcia naopak vracia hodnotu najmenšieho prvku. Takže Low (Byte) = 0.

Typickým príkladom neordinálneho údajového typu sú reálne údajové typy, pretože u nich nie je možné určiť nasledujúci prvok v postupnosti. Je všeobecne známe, že v intervale 1,5 až 2,0 leží nekonečne mnoho prvkov.

Pre prácu s celými číslami ponúka Delphi dva základné údajové typy:

Okrem nich sú k dispozícii ešte ďalšie celočíselné typy:

Typy Longint a Longword sú zameniteľné za typy Integer a Cardinal.
Všetky typy uvedené v predchádzajúcej tabuľke sú tzv. fundamentálne, to znamená, že ich veľkosť je rovnaká vo všetkých implementáciách jazyka Object Pascal.

Použitie týchto základných typov síce optimálne nevyužíva všetky možnosti 32 bitového operačného systému, ale na oplátku šetrí pamäť, a preto môže byť v mnohých a prípadoch užitočné.

Všetky celočíselné typy sa radia k ordinálnym typom.

Okrem celých čísel je často potrebné spracovávať aj čísla reálne. Tie môžu byť jedným z nasledujúcich typov:

Typ Currency nepracuje ako ostatné reálne typy s pohyblivou rádovou čiarkou, ale s pevnou rádovou čiarkou a je určený pre finančné výpočty.

Typ Real, na rozdiel od Integer, Char a Boolean, nie je ordinálny typ a preto preň nefungujú napr. Inc a Dec, nemôže sa použiť ani ako riadiaca premenná v  cykle for ani v príkaze case. Treba si pamätať, že v istom zmysle je nadradený nad celočíselný typ a teda sa celočíselný typ automaticky konvertuje na reálny, keď to treba (použije sa v reálnom aritmetickom výraze alebo v priradení). Opačne to neplatí, takže do celočíselnej premennej nesmieme priradiť reálnu hodnotu (musíme ju najprv napr. zaokrúhliť pomocou Round alebo Trunc).

V tabuľkách sú uvedené aj rozsahy hodnôt, ktoré môžu nadobudnúť údaje určitého údajového typu.  Ak do premennej určitého údajového typu vložíme číslo väčšie ako je jeho rozsah, správanie Delphi závisí od nastavenie kompilátora.

Ak sme na záložke Compiler dialógového okna  Project - Options zaškrtli voľbu Range Checking, tak spustenie spustenie programu skončí chybou behu programu.
Ak táto voľba kompilátora nie je nastavená, program sa vykoná, ale výsledok výpočtu nebude správny, pretože po prekročení rozsahu sa hodnota premennej priradí tak, akoby po prekročení rozsahu narastala od nuly.

Znakový typ - Char

Pre uloženie jednotlivých znakov do pamäti sa používajú premenné typu Char. Veľkosť typu Char je 1 byte, čo znamená, že môžete použiť 255 znakov. Každý znak je uzavretý medzi dvomi apostrofmi (napr. 'C'). Všetky znaky sú navzájom usporiadané v tzv. ASCII tabuľke - táto obsahuje 256 znakov.
Na prevedenie znaku na číselnú hodnotu slúži funkcia Ord, o ktorej sme už písali. Jej opakom je funkcia Chr, ktorá vracia znak z ASCII tabuľky.
Napr. Chr(65) = 'A', pretože znaku 'A' zodpovedá hodnota 65.

Nasledujúci program vypisuje ordinálne hodnoty niektorých písmen:

var
  Znak: Char;
begin
  for Znak := 'A' to 'L' do
    Writeln('znak "', Znak, '" ma ordinalnu hodnotu ', Ord(Znak));
  Readln;
end.

a vypíše

znak "A" ma ordinalnu hodnotu 65
znak "B" ma ordinalnu hodnotu 66
znak "C" ma ordinalnu hodnotu 67
znak "D" ma ordinalnu hodnotu 68
znak "E" ma ordinalnu hodnotu 69
znak "F" ma ordinalnu hodnotu 70
znak "G" ma ordinalnu hodnotu 71
znak "H" ma ordinalnu hodnotu 72
znak "I" ma ordinalnu hodnotu 73
znak "J" ma ordinalnu hodnotu 74
znak "K" ma ordinalnu hodnotu 75
znak "L" ma ordinalnu hodnotu 76

Je však potrebné upozorniť na to, že síce každému číslu v rozsahu 0-255 zodpovedá nejaký znak, ale zďaleka nie všetky sú vhodné na grafické zobrazenie. (najmä spodná časť ASCII tabuľky).

Ak potrebujete použiť nejaký znak, ktorý nie je na klávesnici, a nedá sa teda napísať medzi dva apostrofy, je možné  použiť jeho ordinálnu hodnotu uvedenú znakom #. Napr. namiesto znaku konca odseku, ktorý sa vkladá po stlačení tlačidla ENTER,  je možné použiť: # 13.

Logický typ - Boolean

Premenné tohto ordinálneho typu môžu nadobúdať len dve hodnoty. Pre ne sú preddefinované dve konštanty True a False. Tieto premenné sa hojne využívajú pre vyhodnocovanie najrôznejších podmienok a budeme sa s nimi často stretávať.

Delphi ponúka štyry logické údajové typy:

Zďaleka najčastejšie sa však používa typ Boolean a ostatné typy sú uvedené len pre úplnosť.

Logické hodnoty sa najčastejšie používajú v podmienených príkazoch if a v cykle while. Niekedy sa môže hodiť, keď si môžeme zapamätať výsledok nejakej podmienky v logickej premennej, t.j. v premennej, ktorá môže nadobúdať len hodnoty True a False. Premennú deklarujeme s typom Boolean a môžeme do nej priradiť len logický výraz, napr.

var
  Mensi: Boolean;
  Parne: Boolean;
  OK: Boolean;
begin
  Mensi := 3*7 < 22;
  Parne := Cislo mod 2 = 0;
  if 3*3 +4*4 = 5*5 then
    OK := True
  else
    OK := False;
end;

Jazyk Pascal je prísne typový jazyk. To znamená, že za všetkých okolností prísne stráži údajové typy jednotlivých premenných a nedovolí, aby sa s premennou vykonávali operácie mimo tento typ. Napríklad nie je možné do premennej typu Byte uložiť znak a naopak, v premennej Char nesmie byť nič iné ako znaky.

Niekedy by však bolo výhodné, keby sa obsah premennej určitého typu dal umiestniť do premennej nejakého iného typu, napríklad číslo uložiť ako reťazec znakov a potom s ním ďalej pracovať ako s textom.

Také operácie sú možné pomocou niektorých funkcií, ktoré sú v Delphi definované a ich zoznam môžete nájsť v nápovede.

Ak však obidva typy majú rovnakú veľkosť, je možné použiť explicitné pretypovanie (Typecast). Uvažujme o možnosti, keď je potrebné do premennej typu Byte umiestniť nejaký znak, ako je to vidieť v nasledujúcom príklade:

var i:byte; c:char;
begin
    c:='A';         Do premennej c sa uloží znak 'A'
    i: =c;         {Toto je hrubá chyba!!! Prekladač oznámi chybu: "Incompatible types: 'Byte' and 'char'''}
    i:=Byte(c);     {Toto je korektné pretypovanie. V i bude číselná hodnota reprezentovaná znakom 'A'.}
end;

Celé kúzlo spočíva v tom, že sa pred premennú, ktorá má byť pretypovaná, napíše výsledný typ.
Niektoré typy nie je nutné pretypovávať vôbec, pretože to Delphi robia implicitne. Ide napríklad o pretypovanie v rámci rovnakej skupiny typov (reálne, celočíselné) alebo ak sa pretypuje celočíselný typ na reálny.

V nasledujúcom príklade sú uvedené príklady pre rôzne typy údajov:

Raritou medzi údajovými typmi Object Pascalu je typ Variant. Jeho veľkosť je 16 bytov a do premennej tohto typu je možné umiestniť hodnotu ľubovoľného iného typu.

var V: variant;
begin
    v:='nejaký text';
    v:=0.222;
    v:='%'
end;

Mohlo by sa zdať, že Variant nahradí všetky údajové typy. Daňou za univerzálnosť je však jednak veľké miesto obsadené v pamäti a takisto čas spracovania, ktorý je u typu Variant niekoľkokrát dlhší ako u ostatných typov.

Konštanty

Konštanty sa podobajú premenným. Rovnako ako premenné, tak aj konštanty sú rezervované a pomenované časti pamäte, v ktorých je uložená nejaká hodnota. Od premenných sa líšia v tom, že hodnotu na tomto mieste nemožno meniť.
Konštanty sa deklarujú ešte pred premennými v časti, ktorá je uvedená kľúčovým slovom const. Konštanty sa podobajú premenným aj v tom, že sú rôzneho typu. Tu to však nemusí zadávať programátor, ale prekladač sám pozná, o aký typ konštanty ide podľa jej hodnoty.

const
N = 5;
Nazov = 'Zaciname programovat v Delphi';
Znak = '@';

V tomto prípade bude konštanta N typu integer, Nazov typu string a k Znak typu char.
Na stanovenie hodnoty konštanty je dokonca možné použiť aj niektorú z predchádzajúcich konštánt, jak to ukazuje nasledujúci príklad:
 
const
kilometrov = 25;
metrov = kilometrov*lOOO;

Jedinou podmienkou je, že pred prvým použitím konštanty musí byť už definovaná.

Prečo je vhodné požívať konštanty, keď sa ich hodnota v programe nemení?
Predstavme si, že sme vytvorili jednoduchý program, ktorý počíta náklady na dopravu z mesta A do mesta B, vzdialeného 25 kilometrov. Program funguje a programátor si začne pohrávať s myšlienkou jeho použitia pre mestá C a D, ktoré sú od seba vzdialené 30 kilometrov. Ak sa dal zlákať možností ušetrené práce a nepoužíval konštanty, musí v celom programe prepísať vzdialenosť z 25 na 30 km. Táto hodnota sa tam môže objavovať aj stokrát alebo tisíckrát. Každý si iste vie predstaviť náročnosť takejto zámeny.
Problém rieši používanie konštánt. Pretože potom stačí prepísať starú hodnotu na novú len raz.

Operátory a výrazy

Operátory

Od každého programu sa očakáva, že bude vykonávať nejakú činnosť. Programátor hovorí počítaču, akú základnú operáciu chce vykonať, pomocou operátorov.
Operátor je vyhradený znak, ktorý má nejakú špecifickú funkciu. Všetci napríklad poznajú operátor +, ktorý sčíta dva operandy (operand je symbol, na ktorý je použitý operátor) aj všetky ostatné základné aritmetické operátory.

Zďaleka najpoužívanejším operátorom pri programovaní je operátor priradenia. Tento operátor je definovaný dvomi symbolmi : =.
A := B;
Tento jednoduchý kód sa zaslúži o to, že sa obsah premennej B skopíruje do premennej A. Obe premenné majú po vykonaní príkazu rovnakú hodnotu a pôvodný obsah premennej A je nenávratne ztratený.

Okrem presunu údajov medzi premennými potrebujeme vykonávať v programoch ešte ďalšie operácie. K tomu účelu je k dispozícii celá rada ďalších operátorov, ktoré je možné podľa funkcie rozdeliť do niekoľkých skupín:

Aritmetické operátory vykonávajú základné matematické operácie. Tieto operátory sa ďalej delia na unárne (používajú len jeden operand) a binárne (spojujú dva alebo viac operandov).
Nasledujúca tabuľka uvádza ich prehľadný zoznam:

Operátor Div
5 div 2 = 2
Operátor pracuje tak, že nájde najbližšie možné nižšie číslo k delencu (v tomto prípade 5), ktoré je možné bezo zvyšku vydeliť deliteľom (tu 2). V tomto prípade je takým číslom čtvorka.
A 4 : 2 = 2 a to je výsledok celočíselného delenia.
Tím odpadá potreba manipulácie s reálnymi číslami. Ale toto delenie nie je pochopiteľne kompletné, pretože ešte zostal v hre zvyšok po delení, ktorý sa do výsledku nezahrňuje.

Operátor Mod
K zisteniu zvyšku po delení sa s výhodou použije operátor Mod. V tomto prípade platí:
5 mod 2 = 1
pretože rozdiel medzi 4 a 5 je práve 1. Na celom princípe celočíselného delenia nie je nič ťažkého a po nasledujúcom príklade bude všetko jasné.
8 div 3 = 2
8mod3=2

Logické operátory sprevádzajú logické operácie s operandmi typu Boolean. Výsledky logických operácií sú opäť výhradne typu Boolean. V Delphi sú k dispozícii štyri logické operátory: and (logický súčin), or (logický súčet), xor (exkluzívny súčet), not (negácia).

Nasledujúca tabuľka ukazuje, aké výsledky dávajú jednotlivé operátory pri rôznych hodnotách operandov:

Na porovnávanie veľkosti jednotlivých operandov slúžia relačné operátory. Výsledok takého  porovnania je typu Boolean a má hodnotu podľe toho, či je výraz pravdivý či nie.
Napríklad v prípade 2 < 3 má výsledok hodnotu TRUE, na rozdiel od 5 < 4 keď má hodnotu FALSE.

Výrazy

Spojenie operátorov a operandov vytvára výraz, ktorý má nejakú hodnotu. Výraz je teda postupnosť premenných, konštánt a operátorov. Každý výraz má nejakú hodnotu, ktorú je možné ďalej spracovávať, ale nemožno ju meniť. To znamená, že výraz môže stáť na pravej strane priradenia, ale nikdy nie na ľavej. Preto:
i :=i+l;
je korektný príkaz, pretože do premennej i sa priraďuje výsledok výrazu i + 1 (hodnota i sa : zvýši o jednotku), ale
i+1:= 25;
je chyba, pretože výrazu sa priraďuje hodnota, a to nie je možné .

Zaujímavou vlastnosťou výrazu je to, že môžu v sebe obsahovať ďalšie výrazy, napríklad:
X+Y*Z.
Tu sa ale vyskytuje problém, v akom poradí sa také zložené výrazy vyhodnocujú. Inými slovami, akou má ktorý operátor prioritu. Celý problém nie je nijako zložitý, pretože platia základné matematické pravidlá: výrazy sa vyhodnocujú zľava doprava, prvé sa vyhodnocujú výrazy v zátvorkách, ak zátvorky chýbajú, má prednosť násobenie pred sčítaním odčitaním, a tak ďalej.

K správnemu určeniu výsledku výrazu je však potrebné poznať prioritu všetkýchch operátorov. Nasledujúca tabuľka ukazuje kompletný zoznam všetkých operátorov Delphi  v poradí, v akom sa budú  vyhodnocovať vo výraze, ak v ňom nebudú zátvorky:

Platí pravidlo: ak máš pochybnosti o prioritách, zátvorkuj. Nielen, že sa predíde chybám, ale výrazy obsahujúce zátvorky sú omnoho čitateľnejšie.

Logické výrazy obsahujú logické operátory a ich výsledok je typu Boolean. Majú neoceniteľný význam pri riadení činnosti programu a podobných akciách. Operandy v logických výrazoch môžu byť ľubovoľného typu.
Ak ale v logickom výraze porovnávame rovnosť operandov (napr. A=B) nie je možné použiť typ Real, pretože vplyvom operácií v pohyblivej rádovej čiarke dochádza k istým nepresnostiam, ktoré spôsobujú chybné vyhodnotenie výrazu.
Výraz R=0, kde R je premenná typu Real má VŽDY výsledok FALSE, pretože vplyvom zaokrúhľovacích chýb sa na nejakom vzdialenom desatinnom mieste objaví nenulová hodnota, ktorá zvráti celý výsledok. Pre počítač je totiž číslo 0.000000000001 nenulové.