Delphi v příkladech - 1. díl: Přece jen trochu teorie

Ačkoli se seriál jmenuje Delphi v příkladech, bez teorie se přeci jen neobejdete. Stručně se seznámíme s nejdůležitějšími základy programování v Delphi.

Zdravím všechny příznivce programování v Delphi! V tomto seriálu se budeme učit pracovat s mocným programovacím nástrojem Delphi. A jak se lépe učit, než na příkladech? Dnes se seznámíme s nejdůležitějšími základy programování.

Co budete potřebovat

V tomto kurzu budeme pracovat s Borland Delphi 7 Personal. Výhodou této verze je, že ji výrobce poskytuje pro nekomerční užití (vytvořené programy nesmíte prodávat, atd.) zdarma. Pokud máte lepší verzi (novější Turbo Delphi nebo některou placenou), neměl by být žádný problém. Můžete ještě použít starší verzi 6, která je sice podobná, ale nemohu vám zaručit, že v ní budou fungovat všechny uváděné příklady.

Co byste měli vědět

Klíčová slova – předdefinovaná slova se specifickým významem (např. procedure, program, begin, end, var), Delphi je zvýrazňuje tučným písmem.
Identifikátor – posloupnost znaků, která pojmenovává program, proměnné, komponenty, konstanty (které definoval uživatel), procedury, funkce, … (vše, co programátor vytvořil), identifikátor se nesmí shodovat s klíčovým slovem, v identifikátoru smí být použita jen písmena anglické abecedy, čísla a podtržítko.
Syntaxe – „pravopis“ programovacího jazyka
Object Pascal – jazyk, který používá Delphi.
Zdrojový kód – program zapsaný v programovacím jazyce.
Překladač – vytváří ze zdrojového kódu spustitelný soubor (*.exe).
Kompilace – přeložení zdrojového kódu na spustitelný program.
Poznámka – část textu, kterou překladač ignoruje; slouží pouze pro programátora, dá se zapsat třemi způsoby:
1. {mezi složené závorky}
2. (* mezi závorky s hvězdičkami *)
3. //za dvě lomítka, tato poznámka se neukončuje a nepokračuje na dalším řádku!
Projekt – nepřeložený program.
Z čeho se skládá projekt v Delphi (pokud chcete uložit všechny změny, dávejte Save all, protože projekt se skládá z více souborů):
1. soubor *.dpr (Delphi project) – základ projektu, sdružuje všechny formuláře a zdrojové kódy, dá se přeložit a spustit; chcete-li pracovat na projektu, otevírejte tento soubor
2. soubor *.pas – obsahuje unitu (část programu) s příslušnou částí zdrojového kódu, v projektu může být více těchto souborů
3. další soubory, které Delphi vytváří samo a o které se zatím nemusíte starat

Prostředí Delphi

Delphi se skládá z několika oken. Nejdůležitějším je hlavní okno s menu a paletami objektů. Všimněte si také zelené šipky (Run), po jejímž spuštění se projekt zkompiluje a spustí.

Z palet můžete myší přidávat objekty na formulář, kde je můžete přemisťovat a měnit jejich velikost.

S formulářem je spojen zdrojový kód, kde vytváříte většinu programu. Mezi editorem zdrojového kódu a formulářem můžete přepínat klávesou F12. V jeho spodní části se při neúspěšné kompilaci (kvůli chybě nemohl být projekt přeložen) objevují chyby v syntaxi.

Dalším velmi důležitým oknem je ObjectInspector, ve kterém nastavujete vlastnosti objektů (na záložce Properties) a reakce na události (na záložce Events). Dávejte si pozor, který objekt editujete.

Poslední okno, které oceníte hlavně při práci na větších projektech, je Object Tree View. Zde jsou zobrazeny všechny objekty a jejich hierarchie a vy si mezi nimi můžete přepínat. Všimněte si, že formulář (tady Form1) není jediný prvek, pod který mohou být přiřazeny objekty.

Všechna okna si můžete podle vlastní potřeby posunout a upravit jejich velikost (velikost okna s formulářem je zároveň výchozí velikostí okna výsledného programu).

Vlastnosti objektů a události

Každý objekt má v Delphi určité vlastnosti, které si můžete měnit v Object Inspectoru. Mezi základní vlastnosti, které má většina objektů (ale ne všechny), patří tyto:

Name – jméno objektu (je to identifikátor)
Visible – viditelnost; udává, je-li objekt zobrazován, nebo ne
Enabled – zda-li je objekt aktivní (jestli jej uživatel může použít; pokud není aktivní, je zašedlý)
Top – vzdálenost od horního okraje nadřazeného objektu (většinou formuláře)
Left – vzdálenost od levého okraje nadřazeného objektu (většinou formuláře)
Height – výška objektu
Width – šířka objektu
Tag – program jej k ničemu nevyužívá, můžete si do něj uložit vlastní hodnotu bez ovlivnění chování a vzhledu objektu

Programování v Delphi je založeno na událostech. Událost je každá akce vykonaná uživatelem (ale ne každá událost je vyvolaná uživatelem) – např. pohyb myší, zmáčknutí tlačítka nebo klávesy,… Vyvolaná událost se týká vždy aktivního objektu (má tzv. Focus), při standardním nastavení přepíná uživatel aktivitu objektů tabulátorem. Reakce na události se editují v Object Inspectoru po přepnutí na záložku Events. Příslušné procedury vytvoří Delphi po dvojkliku na políčko vedle požadované položky. Základní události (u většiny objektů) jsou tyto:

onClick – kliknutí na objekt
onKeyDown – zmáčknutí klávesy
onKeyPress – držení zmáčknuté klávesy
onKeyUp – uvolnění („odmáčknutí“) klávesy
onMouseDown – zmáčknutí tlačítka myši (dokáže rozlišit mezi pravým a levým tlačítkem))
onMouseMove – pohyb kurzoru myši nad objektem
onMouseUp – uvolnění tlačítka myši

Objekt formulář má navíc ještě další důležité události:

onCreate – proběhne po vytvoření formuláře
onClose – proběhne po ukončení formuláře
onDeactivate – deaktivování okna (uživatel jej minimalizoval nebo přepnul na jiné okno/aplikaci)
onActivate – aktivování okna

Přehled základních objektů

Objektů máte k dispozici hned několik palet. Na začátku každé palety je ještě šipka, která označuje výběrový nástroj. Následující tabulka zachycuje přehled nejpoužívanějších objektů.

Paleta	Ikona	Jméno	Popis
Standard		Label	Nápis
Standard		Edit	Pole pro zadávání textu uživatelem
Standard		Button	Tlačítko
Additional		Image	Obrázek
System		Timer	Časovač

Pro většinu objektů máte k dispozici základní vlastnosti a ještě další specifické vlastnosti, které zachycuje následující přehled.

Label

Caption:String – text nápisu
Color:TColor – barva pozadí
Font:TFont – písmo nápisu (skládá se z více vlastností)
Transparent:Boolean – průhlednost pozadí (pokud je True, je pozadí průhledné)
WordWrap:Boolean – rozložení dlouhého Captionu na více řádků (pokud je vlastnost nastavena na True)

Edit

Color:TColor – barva pole
Font:TFont – písmo
ReadOnly:Boolean – jen pro čtení (je-li hodnota False, uživatel nemůže měnit obsah)
Text:String – text v poli

Button

Caption:String – nápis na tlačítku
Font:TFont – písmo
WordWrap:Boolean – rozložení dlouhého Captionu na více řádků (pokud je vlastnost nastavena na True)

Image

Picture:TPicture – zobrazený obrázek
Stretch:Boolean – přizpůsobení obrázku (Picture) velikosti objektu (je-li True)
Transparent:Boolean – průhlednost pozadí (tj. body s barvou, jako má bod v levém dolním rohu)

Timer

Timer je systémový objekt, nikdy jej nevidíte (i když má v editačním módu také svůj zastupující obrázek na formuláři), nemůžete tedy změnit jeho velikost, viditelnost, atd.

Interval:Cardinal – perioda v milisekundách, po uběhnutí této doby nastane událost onTimer
Enabled:Boolean – u Timeru funguje tato vlastnost trochu jinak než u jiných objektů; udává, zda-li je Timer aktivní (odpočítává dobu), nebo není
onTimer:TNotifyEvent – vykoná se po uplynutí doby Interval

Ke všem vlastnostem se přistupuje JmenoObjektu.JmenoVlastnosti, např. vlastnost Caption objektu Button1:

Button1.Caption

Základní syntaxe

Syntaxe, jak jsem již říkal, je „pravopis“ programovacího jazyka. Výhodou Delphi je, že si většinu věcí vytvoří samo, takže dokud vám vyhovuje výchozí nastavení, nemusíte se o nic starat. Delphi nevadí mezery a řádky, které jsou navíc, proto se nebojte je používat pro zpřehlednění zápisů. Nepsaným pravidlem je odsazovat podřazené řádky vždy o další 2 mezery (viz ukázky zdrojových kódů). Delphi také nerozlišuje malá a velká písmena v názvech (objektů, proměnných, …). Pokud si přepnete na editor zdrojového kódu, uvidíte toto (doplněno poznámkami):

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
     //v této části se deklarují objekty, procedury a funkce
  private
    { Private declarations }
  public
    { Public declarations }
     //v této části se deklarují proměnné
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

//v této části se definují (rozlišujte od deklarují!) procedury a funkce

end.  (*značí konec programu, jediný end zakončený tečkou, text za tímto endem překladač ignoruje*)

Některé procedury si Delphi vytvoří samo, např. dvojklikem na některou událost v Object Inspectoru, na vás pak zůstává naprogramovat její činnost. Zdrojový kód poté vypadá třeba takto:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  //tady jsou příkazy, které se mají vykonat při stisknutí tlačítka
end;

end.

Použití procedur a funkcí v programu se označuje jako jejich volání. Funkce se od procedur liší tím, že vracejí výsledek (procedury jen vykonají posloupnost příkazů), zastupují tedy hodnotu.

Vlastní procedury a funkce

Vlastní procedury musíte nejdříve (stejně jako všechno, co nevytvořilo Delphi) deklarovat, a to v části type za klíčové slovo procedure. Procedury a funkce se většinou přiřazují pod formulář, ale není to nezbytně nutné.

type
  TForm1 = class(TForm)
    procedure MojeProcedura1; //jméno procedury je tedy MojeProcedura1
    procedure MojeProcedura2; //jméno procedury je tedy MojeProcedura2

Dalším krokem je definování procedury. Procedura se skládá z hlavičky a bloku, který se skládá z části definic a deklarací (není povinná) a příkazové části.

{$R *.dfm}

procedure TForm1.MojeProcedura1; (* hlavička, procedura je zařazena do třídy
  TForm1, proto musíme při definici uvést, že patří do této třídy, což
  uděláme připsáním jména třídy a tečky *)
  //tady může zařadit část definicí a deklarací konstant, proměnných, ...
begin
  //tady jsou příkazy, které se mají vykonat
end;

procedure TForm1.MojeProcedura2; 
begin
  //tady jsou příkazy, které se mají vykonat
end;


end.

Pro volání procedury stačí napsat její jméno jako příkaz (zakončený středníkem):

MojeProcedura1;
MojeProcedura2;

Proceduře (a hlavně funkci) budete často potřebovat předat nějakou hodnotu. Tato hodnota se nazývá parametr a musí se uvést při deklaraci, definici i volání, a to do závorky (u definice a deklarace včetně typu parametru).

procedure MojeProcedura1(parametr:Integer); (*deklarace,
  typ integer je celé číslo *)
...
procedure TForm1.MojeProcedura1(parametr:Integer); //definice
begin

end;
...
MojeProcedura1(1); //volání procedury s parametrem

S tímto parametrem poté můžete pracovat jako s lokální proměnnou (viz později).

U funkcí je deklarace a definice podobná, liší se v klíčovém slovu (místo procedure použijete function) a ještě musíte uvést typ výsledku. Pro určení výsledku použijte Result a přiřazovací příkaz (viz Příkazy).

function MojeFunkce1(parametr:Integer):Integer; //deklarace
...
function TForm1.MojeFunkce1(parametr:Integer):Integer;
begin
  Result := 2 * parametr;
  // výsledkem této funkce bude dvojnásobek předaného parametru
end;

Příkazy

Příkazy zadávají, co se má vykonat. Příkazy se, až na výjimky, zakončují středníkem (středník nemusí být před endem a nesmí být před else). Nejjednodušším a nejdůležitějším příkazem je přiřazovací příkaz. Zapisuje se ve tvaru proměnná (nebo vlastnost objektu) := (dvojtečka a rovnítko) výraz (složen z operátorů, operandů a závorek).

Button1.Caption := 'Ahoj'; //řetězec (string) se píše mezi jednoduché uvozovky

Výraz je „předpis“ na získání hodnoty. Operátory, které se používají, záleží na druhu proměnné. Nejčastější operátory jsou numerické (+, -, *, div, mod, /), relační (pro porovnávání hodnot, =, <, >, <>, <=, >=) a logické (and, or, not – na spojování podmínek). Operandy jsou konstanty, proměnné a hodnoty funkcí.

Často se setkáte s případy, kdy syntaxe umožňuje napsat jen jeden příkaz. Pokud jich přesto chcete vykonat více, musíte tuto skupinu příkazů začít klíčovým slovem Begin a ukončit klíčovým slovem end (a za něj podle potřeby přidat středník). Příkazy mezi beginem a endem v syntaxi vystupují jako jeden příkaz.

//tady podle syntaxe může být jen jeden příkaz, chceme jich ale vykonat více
begin
  příkaz1;
  příkaz2;
  příkaz3;
end;

Proměnné a vlastní konstanty

Proměnné jsou místa v paměti, kam si můžete uložit vlastní hodnotu, kterou můžete změnit podle potřeby.

Do konstant si můžete uložit hodnotu, kterou ovšem změnit nemůžete. Možná namítnete, k čemu jsou dobré. Jejich využití je, např. když pracujete na programu a nejste si jistí hodnotou, která se mnohokrát opakuje. Když se pak rozhodnete ji změnit, musíte prohledat celý zdrojový kód a zdlouhavě ji všude přepisovat. Při použití konstanty ale stačí jediná změna.

Proměnné a konstanty mohou být lokální nebo globální. Pracuje se s nimi stejně, rozdíl je v místě, kde se deklarují, a v místech, kde se dají použít (globální lze použít v celém programu, lokální jen v té části, pro kterou jsou nadeklarovány, např. v proceduře).

Proměnná je určena jménem a datovým typem, který udává, co lze do proměnné uložit a jak s tím můžete pracovat. Zápis při deklaraci pak vypadá takto:

jméno:datový_typ;

Nejběžnější datové typy jsou Integer (celé číslo), Byte (celé kladné číslo), Real (reálné číslo), Boolean (logický typ, má pouze 2 možné hodnoty True nebo False), Char (znak zapsaný ve tvaru #ASCII kód znaku, lze také psát 'znak') a String (řetězec znaků). Často se vyskytují odvozené datové typy, které se liší svým rozsahem (od Integer ShortInt a LongInt, od Byte Cardinal a Word, od Real Extended a další). S mnoha dalšími typy se setkáte např. ve vlastnostech objektů.

Proměnné se většinou deklarují za klíčové slovo var. Lze je také deklarovat v části public u formuláře (globální). Nezapomeňte, že jméno proměnné je identifikátor, tedy že v něm můžete použít jen písmena anglické abecedy, čísla a podtržítko. Pokud chcete deklarovat více proměnných stejného typu, můžete je oddělovat čárkou a dvojtečku s datovým typem napsat až za poslední z nich. Za každým uvedením datového typu musí být opět středník. Pokud chcete do proměnné uložit nějakou hodnotu, použijte jméno proměnné a přiřazovací příkaz.

//globální proměnné
type
  TForm1 = class(TForm)
    procedure UkazkaPromennych;
  private
    { Private declarations }
  public
    { Public declarations }
    Moje_Promenna1,Moje_Promenna2:integer;
    Moje_Promenna3,Moje_Promenna4:real;
    Moje_Promenna5,Moje_Promenna6:string;
  end;
...
//lokální proměnné
procedure TForm1.UkazkaPromennych;
var
  Moje_Promenna1,Moje_Promenna2:integer;
  Moje_Promenna3,Moje_Promenna4:real;
  Moje_Promenna5,Moje_Promenna6:string;
begin
  Moje_Promenna1:=1;
  Moje_Promenna3:=1.1;
  Moje_Promenna4:=Moje_Promenna3+2*Moje_Promenna1;
  Moje_Promenna5:='Ahoj';
end;

Globální a lokální proměnné se mohou jmenovat stejně, v takovém případě lokální proměnná zastíní globální (tedy lokální proměnná má přednost před globální).

Numerické operace zastupují numerické operátory. Jsou to sčítání (+), odčítání (-), násobení (*) a dělení.

V Delphi jsou 3 druhy dělení:

reálné dělení / – výsledkem je reálné číslo, tedy nemůžete použít pro proměnnou I typu Integer příkaz I:=10/4; (ale dokonce ani I:=10/2;), v takovém případě Delpi oznámí chybu.
celočíselné dělení div – vydělí číslo a zbytek vynechá (10 mod 3 = 3).
celočíselné dělení mod – výsledkem je zbytek po dělení (10 mod 3 = 1).

Lze tedy napsat rovnost A = B*(A div B) + (A mod B)
Operandy u dělení mod a div musí být celá čísla.

Konstanty se deklarují za klíčové slovo const před deklarací proměnných (var). Poté se napíše jmeno_konstanty = hodnota; (řetězcová konstanta se píše mezi jednoduché uvozovky). Mezi konstanty patří i takové konstanty, které se nemusejí definovat. Jsou to např. čísla, znaky (#ASCII hodnota znaku nebo 'znak') a řetězce ('Ahoj'). Definované konstanty použijete ve výrazu napsáním jména konstanty.

type
  TForm1 = class(TForm)
    procedure UkazkaKonstant;
  private

  public

  end;

const   //globální konstanty
  y = 112;
  abc = 'abc';

var
  Form1: TForm1;
...
procedure TForm1.UkazkaKonstant;
const   //lokální konstanty
  a = 10;
  b = #64;
var 
  x:integer;
  c:char;
begin
  x := a * 2;
  c := b;
end;

Větvení programu (příkazy if a case)

Často se setkáte s problémem, že chcete vykonat určité příkazy, pouze pokud platí nějaká podmínka. K tomuto účelu je v Delphi podmíněný příkaz if.

if podmínka:boolean
  then
    příkaz;   (* zde je pouze jeden příkaz, pokud jich chcete vykonat více, musíte použít begin a end *)

Příkaz se vykoná, pouze pokud podmínka platí (její hodnota je True). Pro porovnávání hodnot slouží relační operátory, relace se vyhodnotí jako True (zápis platí) nebo False.

var A,B:Integer
...
if A >= B
  then
    begin
      A := 0;
      B := 10;
     end;

Pokud chcete vykonat nějaké příkazy i v případě, že podmínka neplatí (vyhodnotí se jako False), nemusíte psát další podmíněný příkaz, ale stačí za podmíněný příkaz připsat klíčové slovo else (Pozor! před else nesmí být středník, ten se napíše až za příkaz po else, resp. za end po else).

if A > B
     then
       begin
         A := 0;
         B := 10;
       end
     else   //vykoná se, jen pokud A není větší než B (podmínka neplatí)
       begin
         A := 10;
         B := 0;
       end;

Pokud je u podmíněného příkazu else, je to úplný podmíněný příkaz, pokud část else chybí, je to neúplný podmíněný příkaz. Celý podmíněný příkaz je jeden příkaz, můžete tedy za then napsat další podmíněný příkaz bez nutnosti použití begin a end.

Pokud chcete v podmínce zohlednit více věcí, je lepší využít místo několika vnořených podmíněných příkazů logické operátory and (a zároveň) or (nebo) a not (není). Tyto spojky mají vyšší prioritu než relační operátory, proto musíte použít závorky.

if (10 < A) and (A < 15)   (*vykoná se, pouze pokud A je větší než 10 a menší než 15, tedy pokud je A 11, 12, 13, 14 nebo 15 *)
  then ...

if (A < 10) or (15 < A ) (* pokud je A menší než 10 nebo větší než 15 *)
  then ...

if not (A = 10)   (* pokud A není 10, v tomto případě by ale bylo vhodnější použít if A <> 10, což znamená A je různé od 10 *)
  then ...

Další operátor je in, který se používá, pokud chcete ověřit, zda se proměnná nachází v určité množině. Množina se píše výčtem prvků do hranatých závorek, přičemž prvky se oddělují čárkou. Pokud chcete napsat více po sobě následujících prvků, použijte interval (píše se první_hodnota..poslední_hodnota).

if A in [10,12,20..30]   (* pokud je A 10, 12 nebo číslo od 20 do 30 *)
  then ...

Podmínky lze samozřejmě psát i pro jiné datové typy než Integer (i pro nečíselné proměnné a hodnoty).

Dalším příkazem pro větvení programu je case. Tento příkaz lze využít jen pro výrazy, jejichž výsledkem je ordinální datový typ (Integer, Char, Boolean – pro tento se ale využívá příkaz if – atd.). Ordinální typy jsou takové typy, které jsou omezené, konečné a pro každou hodnotu (s výjimkou krajních hodnot) je jednoznačně určen následník a předchůdce. Tyto hodnoty získáte pomocí funkcí pred(hodnota) (předchůdce) a succ(hodnota) (následovník). (Tedy X := X + 1 má stejný význam jako X := succ(X)). Typ Real není ordinální typ (není jednoznačně určen předchůdce a následovník). Jeho syntaktický zápis vypadá takto:

Case výraz of
  hodnota_1: příkazy;
  hodnota_2:příkazy;
  hodnota_3,hodnota_4,hodnota_x:příkazy; //hodnoty můžete spojovat čárkou
  ...
  hodnota_n:příkazy
  else příkaz;   //nemusí tady být
end;

Je to příkaz, kde se nevyskytuje begin, ale přesto je zakončený endem.

Cykly

Cykly se využívají pro opakování určitého příkazu nebo skupiny příkazů (tzv. tělo cyklu). V Delphi jsou 3 druhy cyklů:

Cyklus s podmínkou na začátku (while)

while podmínka (*podobně jako u podmíněného příkazu*) do
  příkaz;   //nebo begin příkazy; end;

Cyklus se opakuje, dokud platí podmínka (její hodnota je True), když je hodnota False, pokračuje program v příkazech za cyklem.

Cyklus s podmínkou na konci (repeat)

Repeat
  příkazy;   //tady nemusí být begin a end, protože jsou zastoupeny slovy repeat a until
until podmíka;

Tento cyklus vykonává tělo cyklu, dokud není splněna podmínka (tedy dokud je její hodnota False). Tělo takovéhoto cyklu se vždy vykoná minimálně jednou (protože nejdříve se vykonávají příkazy a pak se teprve kontroluje podmínka).

U příkazů while i repeat se musí v těle cyklu ovlivňovat podmínka, jelikož jinak by mohlo dojít k „zacyklení“, cyklus by nikdy neskončil, protože by se hodnota podmínky nikdy nezměnila. Z tohoto důvodu také musíte v podmínce použít minimálně jednu změnitelnou hodnotu, tedy proměnnou. Dávejte si pozor, abyste nevytvořili cyklus, který nemůže skončit.

Cyklus řízený proměnnou

Tento cyklus je řízný pomocnou (řídící) proměnnou, která musí být ordinálního typu (používá se většinou celočíselná proměnná nebo Char) a má přesně stanovený počet opakování (i když je jednou z hodnot proměnná). Do pomocné proměnné se přiřadí první hodnota a program ji postupně přiřazuje všechny hodnoty, dokud není rovna poslední hodnotě. V těle cyklu tedy nemusíte ovlivňovat podmínku. Řídící proměnnou můžete použít ve výrazu, neměli byste ale sami měnit její hodnotu. Jsou 2 způsoby použití – pokud je první hodnota menší než poslední hodnota, je klíčovým slovem to (hodnota řídící proměnné se postupně zvětšuje), v opačném případě je to slovo downto (hodnota řídící proměnné se postupně zmenšuje). Pokud byste použili opačné klíčové slovo, nevykoná se tělo příkazu ani jednou (ale nenastane chyba), pokud se první hodnota rovná poslední hodnotě, vykoná se tělo cyklu v obou případech právě jednou.

var
  A:Char;
  B,C:Integer;  
...
C := 0;
for A := 'A' to 'D' do
   C := C + 1;
A := 'A';
for B := 10 downto 1 do
  begin
    C := C + 2 * B;
    A := succ(A);
  end;

Po vykonání těchto příkazů bude v proměnné A hodnota 'K' a v proměnné C číslo 114 (můžete si to ověřit).

Vlastní datové typy

Delphi nabízí také možnost vytvořit si několik druhů vlastních datových typů, které se deklarují v části type. Všimněte si, že formulář (většinou Form1) je proměnnou typu TForm1, přičemž tento typ je také definován v části type. Nejpoužívanějšími typy, se kterými se setkáte jsou pole, záznam a výčet.

Záznam

Tento datový typ se skládá z několika vlastností různých datových typů. Chcete-li s takovouto proměnnou pracovat, musíte napsat jméno proměnné (tohoto typu) .vlastnost. Syntaxe pak vypadá takto (na příkladě záznamu Pracovník):

type
  Pracovnik = record
    Jmeno:string;
    Prijmeni:string;
    Vek:byte;
  end;
...
Zamestnanec:Pracovnik;
...
Zamestnanec.Jmeno := 'Lojza';
Zamestnanec.Prijmeni := 'Novák';
Zamestnanec.Vek := 38;

Pole

Je to řada proměnných stejného datového typu. Výhodou je, že práci s nimi můžete zobecnit, protože ke každému přistupujete pomocí indexu. Ten udává, kolikátá v řadě je proměnná, se kterou chcete pracovat.

type
  Pole = array [0..20] of Integer; 
...
Vysledky:Pole;
...
Vysledky[1]:= 120;
Vysledky[2]:= 124;

Hodnoty v hranatých závorkách (u deklarace) udávají rozsah pole (první hodnota v poli nemusí mít index 0), slovo za klíčovým slovem of udává typ proměnných v poli. Při práci s polem je v hranatých závorkách index proměnné.

Pole mohou být i vícerozměrná, jejich deklarace vypadá takto:

type
  Pole = array [1..5,1..10] of Integer;

Toto pole si můžete představit jako tabulku, která má 5 řádků a 10 sloupců. Při práci musíte samozřejmě uvést oba indexy (a oddělit je čárkou) a jejich pořadí nesmíte zaměnit.

Pole nemusí být tvořeno jen předdefinovanými datovými typy, ale i těmi, které si definujete sami.

Výčet

Tento typ je určen výčtem prvků v hranatých závorkách.

type
  Tyden = [Pondeli,Utery,Streda,Ctvrtek,Patek,Sobota,Nedele]
...
Den_v_Tydnu:Tyden;
...
Den_v_Tydnu := Pondeli;

Přetypování hodnot

Posledním problémem, se kterým se dnes seznámíme, je přetypování hodnot. Když chcete použít hodnotu jiného datového typu, než umožňuje syntaxe, musíte ji přetypovat. Nejčastěji se přetypovává na řetězec (string) nebo z řetězce.

IntToStr(hodnota);  //převede integer na string, např. z 10 udělá '10'
FloatToStr(hodnota);  //podobně jako inttostr, ale s reálným číslem
StrToInt(hodnota);  //převede string na integer
StrToFloat(hodnota);  //převede string na reálné číslo

Pozor při používání přetypování ze stringu na čísla! Ne každý řetězec lze převést na číslo (např. 'Ahoj') a takovéto použití by vyvolalo chybu v běhu programu. Teto problém lze ošetřit pomocí výjimky v programu.

  I:Integer;
  S:string;
...
try
  I:= strtoint(S);
except
  showmessage('Chyba');  //příkaz pro vytvoření jednoduché zprávy, parametr předává text zprávy
end;

Část except se vykoná, pokud při vykonávání části v try nastane chyba, která nastane, pokud hodnotu v S nelze převést na integer. Pokud jste program spustili z prostředí Delphi, přeruší Delphi běh programu a oznámí vám chybu v programu. Tu můžete ignorovat a zmáčknutím zelené šipky v menu (Run), se vrátíte do programu, který bude plynule pokračovat (pokud byste nechtěli pokračovat v běhu programu, zmáčkněte (v menu) Run → Program reset). Pokud program spustíte přes vytvořený .exe soubor, vykonají se přímo příkazy části v except (žádná chybová zpráva se nezobrazí, tedy pokud si nevytvoříte vlastní zprávu).

Delphi v příkladech - 1. díl: Přece jen trochu teorie

Programátoři po celém světě dnes slaví Den programátorů
Celá zprávička