Free Pascal - Úvod

Svetoznámy programovací jazyk Pascal má veľký počet verzií kompilátorov a odvodených

programov.

Verzie
Najjednoduchší je TurboPascal, ktorý poskytuje základné možnosti pre výučbu princípov
programovania. Viac možností obsahuje Object Pascal, v ktorom môžeme pracovať z tzv.
objektmi. Existujú i Open Source aplikácie, ktoré nám poslúžia najmenej rovnako dobre.
GNU Pascal je určený najmä pre Linux a jeho inštalácia na Windowse je náročná. Preto
odporúčam Free Pascal - obdobu Object Pascalu.

Free Pascal
Je to multiplatformový kompilátor objektového Pascalu spolu s vývojovým prostredím. Má
pomerne jednoduché ovládanie, množstvo jednotiek (Units) a je ľahko rozšíriteľný. Jeho
prostredie sa podobá TurboPascalu, má však mnoho vylepšení.

Free Pascal si môžete zadarmo stiahnuť na stránke www.freepascal.org. Tu je screenshot:

Free Pascal - Začiatky

Keď ste si už stiahli a nainštalovali Free Pascal, môžeme s ním začať pracovať. Najprv sa
naučíme ovládať tzv. IDE - prostredie, v ktorom môžeme vyvíjať aplikácie.

Otvorenie
Ak sa vám v Štart menu vytvoril odkaz, určite nemusím nič viac hovoriť. Ak sa tak nestalo,
FreePascal otvoríte pomocou súboru s názvom fp.exe v priečinku (adresár Free
Pascalu)\bin\i386-win32\.

Prvý program
Ako všade inde - kliknite na menu File / New. Napíšte tento zdrojový kód (súbor príkazov, z
ktorého môže vzniknúť napr. program):

program prvy;
begin
writeln('Ahoj');
end.

Stlačte Alt+F9 alebo menu Compile / Compile. Ak vás program vyzve k uloženiu, zadajte
názov súboru. Mal by mať koncovku PAS - napr. prvy.pas.

Po úspešnom skompilovaní a potvrdení hlášky môžeme program spustiť klávesovou skratkou

Ctrl+F9 alebo cez menu Run / Run. Možno ste spozorovali bliknutie a nič viac. To je úplne v
poriadku - náš program totiž vypísal na obrazovku slovo Ahoj a skončil.

Ako sa teda dozvieme, čo je na obrazovke aj po skončení programu? Pomocou klávesov

Alt+F5 (alebo menu Debug / User screen (dibag/juza skrin). Kým niečo nestlačíme, na
obrazovke sa (okrem iného) bude zobrazovať text:

Ahoj

Ak sa vám zobrazí chybová hláška, skúste skontrolovať napísaný zdrojový kód alebo zistiť
zmysel hlášky a napraviť chybu.

Stavba programu
Zdrojový kód v každom programovacom jazyku má svoju pevnú štruktúru. V Pascale (Free
Pascale) musí byť na začiatku každého samostatného programu slovo program. Za ním
nasleduje medzera a názov programu. Nemal by byť dlhší ako 8 písmen, ale nevylučujem,
že fungujú aj dlhšie názvy.

Veľmi dôležitým znakom je bodkočiarka (;). Je na konci takmer každého príkazu či

funkcie. Medzi slová begin (bigin) a end vkladáme samotný obsah, ktorý sa má vykonať.
Pomocou procedúry (neskôr si o nich povieme) writeln (raitln) program vypíše na
obrazovku text ohraničený apostrofmi (') a zátvorkami. Na konci súboru musí byť vždy
bodka.

Poznámky
Pri programovaní často potrebujeme niečo zaznamenať - na čo slúži daná časť kódu, čo treba
dokončiť, čo je nefunkčné,... Pomôžu nám poznámky v zdrojovom kóde. Pravdepodobne
najpoužívanejší typ sa skladá zo zložených zátvoriek:

{ nejaká poznámka }

V praxi to vyzerá asi takto:

{ program cislo 1 }
program prvy;
begin
writeln('Ahoj'); { napise Ahoj }
end.

Tento typ poznámok sa môže rozprestierať aj na viacerých riadkoch.

{ zaciatok
nejaky text
koniec }

Poznáme ešte poznámky staršieho štýlu:

(* poznamka *)

Takýto typ poznámky pochádza z Delphi (ale funguje aj vo Free Pascale):

// jednoriadkova poznamka

Free Pascal - Premenné

Dá sa povedať, že premenné sú základom programovania. Sú to miesta v pamäti PC, ku
ktorým v Pascale pristupujeme pomocou ich názvu. Ten môže obsahovať písmená (bez
diakritiky), číslice (nie na začiatku) a znak _. Do premenných sa ukladajú čísla, znaky,
texty,... Ich typ musíme vždy dopredu určiť a nemôžeme ho (teoreticky) meniť. Naopak,
hodnotu premennej meníme.

Použitie premennej
Predtým, než premennú použijeme, musíme ju deklarovať. Na to slúži časť var.
program premenne;
var
cislo: integer;

Kľúčové slovo var sa nachádza ešte pred slovom begin. Za var nasleduje názov premennej
(cislo), dvojbodka, typ premennej (v tomto prípade celé číslo – integer(intidža)) a
bodkočiarka.

begin
cislo := 5;

Kombináciou znakov := sme priradili premennej cislo hodnotu 5.

writeln(cislo);
end.

A nakoniec sme ho vypísali na obrazovku.

Zdrojový kód sa nám akosi rozkúskoval, preto ho teraz uvediem celý.

program premenne;
var
cislo: integer;
begin
cislo := 5;
writeln(cislo);
end.

Ak všetko funguje ako má, zjaví sa na obrazovke číslo 5 (nezabudnite stlačiť Alt+F5 pre
zobrazenie).

Výmena premenných
Urobme si program, ktorý navzájom vymení obsah dvoch premenných (a, b). Ak do
premennej vložíme prvú hodnotu a potom druhú, prvá sa vymaže a zostane len druhá.
Nasledujúci postup:

a := b;
b := a;

je nesprávny. Tak ako na to? Iste zistíte, že na to treba ešte jednu, pomocnú premennú c. Do
nej uložíme obsah a, potom do a priradíme b a do b priradíme c. Vyzerá to byť zložité, ale je
to jednoduché.

program vymen;
var
a, b, c: integer;
begin
a := 1;
b := 2;

c := a;
a := b;
b := c;
 writeln(a);
writeln(b);
end.

Konštanty
Základný rozdiel medzi konštantou a premennou je, že hodnotu konštanty nemôžeme meniť.
Deklaruje sa slovom const.

program konst;
const
biela = 255;
begin
writeln(biela);
end.

Free Pascal - Vstup a výstup

Iste ste si všimli, že nami vytvorené programy vo (Free) Pascale sú tzv. konzolové - nemajú
grafické prostredie, ale vypisujú na obrazovku text (je to štandardný výstup). Teraz si
povieme niečo podrobnejšie o výstupe a naučíme sa, ako prijať informácie z klávesnice
(štandardný vstup programu).

Výstup
Procedúru writeln už poznáme, ale naučíme sa o nej niečo viac. Je to procedúra, ktorá
dokáže na obrazovku vypísať texty a čísla. Text dávame medzi apostrofy, čísla nie.

writeln('nejake slova');
writeln(19);

Po napísaní daných informácií sa vždy vytvorí nový riadok a text pokračuje na ňom.

Poznáme však aj procedúru, ktorá nový riadok nevytvorí a pokračuje na aktuálnom riadku.
Nazýva sa write.

write('dnes ');
write('rano');

Na obrazovke zbadáme text:

dnes rano

Vypísať môžeme i viacero informácií pomocou jednej procedúry. Jednotlivé texty i čísla
oddelíme čiarkami.

writeln('je ', 10, ' hodin');

Predchádzajúci príklad nemá veľký význam, dalo by sa to aj jednoduchšie.

Teraz si však ukážeme, že parametrami (v tomto prípade obsah medzi zátvorkami) môžu byť i
premenné.

program vystup;
var
c: integer;
begin
c := 10;
writeln(c);
write('je ', c, ' hodin');
end.

Vstup
Pod pojmom štandardný vstup z klávesnice v Pascale rozumieme získavanie informácií, ktoré
užívateľ na klávesnici zadá, pričom na konci stlačí Enter. Obsah (text, číslo) sa zapíše do
nami určenej premennej. Procedúra, ktorú použijeme, sa nazýva readln .

program vstup;
var
nazov: string;
begin
writeln('zadajte nazov');
readln(nazov);
writeln('bolo napisane: ', nazov);
end.

V tomto príklade bol použitý typ premennej string. Je to textový reťazec.

Vráťme sa k procedúre readln . Pri nej sa program zastaví a zobrazí blikajúci textový
kurzor. Zadáme napríklad text: lietadlo a program vypíše:

bolo napisane: lietadlo

Miesto textových reťazcov môžeme používať i čísla:

program vstup2;
var
cislo: integer;
begin
writeln('zadajte stastne cislo');
readln(cislo);
writeln('zadali ste ', cislo);
end.

Zvyknite si pred readln ( ri:dln) vždy dávať writeln , aby užívateľ vedel, čo má zadať.

Readln bez parametra pozastaví program do stlačenia Enter.

readln;
Free Pascal - Matematické operátory
Samozrejme, že programy neslúžia len na získavanie a produkciu informácií, ale aj na ich
spracúvanie. Preto sa poďme pozrieť na zopár príkladov.

Sčítanie, odčítanie, násobenie

Keďže sú to základné operácie, ich použitie je veľmi jednoduché.

cislo := 10+5;
writeln(cislo);

Program vypíše: 15. Výstup bude rovnaký i v tomto prípade:

writeln(20-5);

Skúsme trochu experimentovať a 20-5 dáme do úvodzoviek ('apostrofov').

writeln('20-5');

Vidíme, že parameter '20-5' sa stal textom. Zobrazí sa doslovne:

20-5

Na násobenie používame v Pascale/Free Pascale hviezdičku.

Program počítajúci druhú mocninu čísla zadaného z klávesnice:

program mocnina;
var
cislo: integer;
begin
writeln('zadajte cislo');
readln(cislo);
writeln('2. mocnina = ', cislo*cislo);
end.

Delenie
Vo Free Pascale poznáme dva typy delenia - bežné a celočíselné.

Ak ako operátor delenia označíme lomítko (/), výsledok nie je typu „celé číslo“, ale
desatinné (označujeme ho real).

program del;
var
vysledok: real;
begin
vysledok := 10/3;
writeln(vysledok);
writeln(7/2);
end.

Celočíselné delenie označuje kľúčové slovo div.

Zvyšok pri tomto type delenia zistíme operátorom mod.

program del2;
var
vysledok: integer;
begin
vysledok := 10 div 3;
writeln(vysledok);
writeln(10 mod 3);
end.

Program napíše:

3
1

Možno ste si všimli, že niektoré príklady sú zbytočne neefektívne - najprv v nich priradíme
premennej konštantu (napr. 10 div 3) a potom ju vypíšeme. Samozrejme, že je to len pre
ukážku.

Kombinácia operátorov
V jednom výraze môžeme použiť viacero operátorov naraz, rovnako ako v matematike.
Napríklad:

writeln(10+2+3);
writeln(5-2*2);
cislo := 3;
writeln(2*(cislo+1) div 4);

Výsledok je zrejmý:

15
1
2
Free Pascal - Logické výrazy
Logický výraz môže nadobúdať vždy len dve hodnoty - true (pravda) alebo false
(nepravda). Súčasťou výrazov môžu byť operátory.

Premenná s logickou hodnotou

Tento typ premennej označujeme boolean.

program logicke;
var
hodnota: boolean;
begin
hodnota := true;
end.

Spomenutý príklad nemá žiaden praktický význam. Nadobudne ho pri použití podmienky.
Najprv sa však naučíme logické operátory.

Binárne logické operátory

Vkladáme ich medzi dva výrazy (číselné a pod.). Použijeme ich najmä pri porovnávaní
dvoch číselných hodnôt, aj keď celkové možnosti ich využitia sú väčšie. Pozrime si
nasledujúci zoznam:

Logické operátory porovnávania

= rovná sa
< je menší ako
<= je menší alebo rovný
> je väčší ako
>= je väčší alebo rovný
<> nerovná sa

Ukážme si nejaký príklad.

program log_op;
var
a: boolean;
begin
a := 5 < 7;
writeln(a);
writeln(15 = 16);
end.

Program napíše:

TRUE
FALSE

Samozrejme, že logické hodnoty sa v bežných programoch nezvyknú priamo vypisovať na

obrazovku, ale použije sa podmienka.

Unárny logický operátor

Unárny logický operátor not vkladáme pred výraz. Má za úlohu negovať ho.

Ak bol pôvodný výraz pravdivý, výsledný bude nepravdivý a naopak.

program unarny_o;
var
hodnota: boolean;
begin
hodnota := not (12 > 5);
writeln(hodnota);
end.

Program vypíše na obrazovku:

FALSE

Zložené výrazy
Skladajú sa z dvoch, prípadne viacerých jednoduchých výrazov. Tie spájame operátormi and,
or, xor a zátvorkami.

Pri použití operátora and bude výsledný výraz pravdivý (true), ak sú obidva
jednoduché výrazy pravdivé.

program zlozene1;
var
hodnota: boolean;
begin
hodnota := (1 < 5) and (6 > 3);
writeln(hodnota);
end.

Keďže 1 je menšie ako 5 a zároveň 6 je väčšie ako 3, program zobrazí TRUE.

Poďme sa pozrieť na operátor or. Ten urobí zložený výraz pravdivým, ak aspoň jeden
jednoduchý má hodnotu true.

program zlozene2;
var
hodnota: boolean;
begin
hodnota := (1 <= 1) or (6 > 7);
writeln(hodnota);
writeln((2 = 6) or (19 <> 19));
end.
Aplikácia vypíše najprv TRUE, pretože aspoň jeden výraz bol pravdivý, potom FALSE,
lebo boli obidva nepravdivé.

Teraz si ukážeme príklad na operátor xor, pri ktorom má zložený výraz pravdivú hodnotu,
len ak je práve jeden jednoduchý pravdivý.

program zlozene3;
begin
writeln((5 = 5) xor (10 > 1));
writeln((1 < 6) xor (7 <> 7));
end.

Toto je výsledkom:

FALSE
TRUE

Free Pascal - Podmienky

Bez vetvenia by program pravdepodobne nebol veľmi užitočný. Forma úplnej podmienky
znie: Ak je podmienka splnená, vykonaj príkazy, ináč vykonaj iné príkazy. Naopak, neúplná
pri nesplnení podmienky iba pokračuje ďalej. Vysvetlíme si to na príkladoch.

Neúplná podmienka
Používame kľúčové slová if a then. Forma je nasledovná:

if podmienka then
príkaz;

Ak je príkazov viac, použijeme slová begin a end (za toto end dáme bodkočiarku).

if podmienka then begin

nejaké;
príkazy;
end;

Ako podmienku používame logické výrazy. Príkaz sa vykoná, ak sa daný logický výraz rovná
true. Nasledujúci program vypíše číslo zadané z klávesnice, len ak je menšie ako 10.

program podm;
var
c: integer;
begin
writeln('zadajte cislo');
readln(c);
if c < 10 then
writeln('cislo ', c, ' je mensie ako 10');
end.
Úplná podmienka
Tento typ podmieneného príkazu má tvar:

if podmienka then
príkaz1
else
príkaz2;

Ak bude logický výraz zadaný ako podmienka pravdivý, vykoná sa príkaz1, inak príkaz2. Pri
použití viacerých príkazov ich rovnako uzavrieme kľúčovými slovami begin a end.

if podmienka then begin

príkaz1;
príkaz2;
end
else begin
príkaz3;
príkaz4;
end;

Teraz si ukážeme skutočný zdrojový kód na príklade. Po zadaní čísla z klávesnice sa nám
zobrazí text informujúci, či je dané číslo párne. Okrem podmienky použijeme aj
operátor mod - zvyšok po delení.

program parne;
var
c: integer;
begin
writeln('zadajte cislo');
readln(c);
if c mod 2 = 0 then // ak je parne
writeln('cislo ', c, ' je parne')
else // inak
writeln('cislo ', c, ' je neparne');
end.

Príkaz CASE
Umožňuje nám zjednodušiť zdrojový kód pri väčšom množstve podmienok a výsledných
možností. Ak má výraz určitú hodnotu, vykoná sa určený príkaz. Hodnota však musí byť
vždy ordinálna (napr. celé číslo, znak). Takýto je tvar:

case premenná of
hodnota1: príkaz1;
hodnota2: príkaz2;
hodnota3: príkaz3;
...
else príkaz;
end;

V prípade viacerých príkazov pre jednu hodnotu použijeme známe begin a end.

case premenná of
 hodnota1: begin príkazy1 end;
...
else begin príkazy2 end;
end;

V praxi to vyzerá asi nasledovne:

program podmn;
var
cislo: integer;
begin
writeln('zadajte cislo');
readln(cislo);
case cislo of
7: writeln('to je stastne cislo');
13: writeln('vraj nestastne');
else writeln('ine cislo');
end;
end.

To však nie je všetko. Miesto jednej hodnoty môžeme určiť i viacero naraz, či dokonca celý
číselný rozsah.

program podmn2;
var
cislo: integer;
begin
writeln('zadajte cislo');
readln(cislo);
case cislo of
3,7: begin
writeln('stastne cislo');
writeln('OK');
end;
10..99: writeln('dvojciferne cislo');
end;
end.

Free Pascal - Cykly

Pri programovaní v akomkoľvek jazyku sa dosť často používa cyklus. Slúži na opakovanie
určitého kroku alebo krokov. Vždy si treba pamätať, že počet opakovaní musí byť konečný,
pretože nekonečný program nebude nikdy na osoh.

Určený počet opakovaní

Cyklus s určeným počtom opakovaní môžeme využiť, ak dopredu vieme, koľko krát treba
dané inštrukcie vykonávať. Má syntax:

for premenná := hodnota1 to hodnota2 do

príkaz;
Premenná v tomto prípade slúži na počítanie opakovaní a musí byť ordinálna (celé číslo alebo
znak). Hodnota premennej sa bude zvyšovať od hodnoty1 do hodnoty2. Nasledujúci príklad
vypíše čísla od 1 do 15:

program cisla;
var
c: integer;
begin
for c := 1 to 15 do
writeln(c);
end.

Ak chceme vykonať viac ako jeden príkaz, musíme použiť kľúčové slová begin a end.

for cislo := -5 to 5 do begin

writeln(cislo);
writeln('mocnina: ',cislo*cislo);
end;

Existuje aj variant, pri ktorom sa hodnota premennej nezväčšuje, ale zmenšuje. Stačí miesto
slova to použiť downto.

writeln('odpocitavanie:');
for i := 10 downto 1 do
writeln(i);
writeln('koniec');

Ešte jedna vychytávka. Miesto celého čísla môžeme tiež použiť znak - typ char.

program abeceda;
var
znak: char;
begin
for znak := 'a' to 'z' do
write(znak);
end.

Cykly s podmienkou
Využívame ho, ak má podmienka rozhodnúť o tom, či bude cyklus pokračovať.

while podmienka do
príkaz;

Príkaz sa bude vykonávať dovtedy, kým má logický výraz (testovaný na začiatku) hodnotu
true. Pri viacerých príkazoch používame známe begin a end. Tento príklad bude žiadať
napísanie čísla dovtedy, kým užívateľ nezadá číslo väčšie ako 10.

program cyklus2;
var
cislo: integer;
begin
while cislo <= 10 do begin
writeln('zadajte cislo vacsie ako 10');
readln(cislo);
 end;
end.

Existuje aj iný typ cyklu a má syntax:

repeat
príkaz(y)
until nepravdiva_podmienka

Daný príkaz sa bude opakovať, kým bude mať logický príkaz (zisťovaný na konci) hodnotu
false. Jednoduchým, ale užitočným príkladom je pozastavenie programu pred jeho koncom,
kým užívateľ nestlačí klávesu. Pomôže nám funkcia keypressed.

program vypisx;
uses
crt;
begin
writeln('x');
repeat until keypressed;
end.

Zistili sme, že medzi repeat a until nemusíme uviesť žiaden príkaz.

Náhle ukončenie cyklu

Ak potrebujeme okamžite ukončiť cyklus, napríklad niekde v jeho strede, použijeme príkaz
break.

program stop;
var
i, cislo: integer;
begin
for i := 1 to 5 do begin
writeln('Napiste cislo.');
readln(cislo);
if cislo >= 100 then begin
writeln('Nespravna hodnota, koncim!');
break; // uplny koniec cyklu
end;
writeln('Spravna hodnota.');
end;
end.

Náš program v ideálnom prípade prečíta päť čísel z klávesnice. Akonáhle však zadáme číslo
>= 100, vypíše sa hláška a celý cyklus sa ukončí.

Pokračovanie v cykle
Príkaz continue preskočí všetko, čo nasleduje za ním v cykle. Potom pokračuje až v ďalšom
opakovaní. Zvýši pritom počítaciu premennú / testuje podmienky cyklu, ako zvyčajne.
Pre pochopenie uvediem príklad, veľmi podobný predchádzajúcemu. Jediný rozdiel bude v
tom, že ak užívateľ zadá nesprávne číslo (teda >= 100), bude ešte musieť zadať aj zvyšné
čísla. Program teda vždy prečíta práve päť čísel.

program pokracuj;
var
i, cislo: integer;
begin
for i := 1 to 5 do begin
writeln('Napiste cislo.');
readln(cislo);
if cislo >= 100 then begin
writeln('Zla hodnota, ale to nevadi.');
continue; // skok na dalsie opakovanie
end;
writeln('Spravna hodnota.');
end;
end.

Free Pascal - Procedúry a funkcie

Užitočnosť týchto pojmov sa prejaví, ak si chceme zapamätať určitý súbor príkazov. Najprv si
ho zadefinujeme a potom ho môžeme vykonávať pomocou názvu procedúry alebo funkcie.
Pri správnom použití sa zlepší prehľadnosť kódu a zmenší veľkosť programu.

Procedúry
Procedúry sme už používali a zistili sme, že to nie je nič ťažké. Napríklad aj známy writeln
je procedúrou.

writeln('ano');

Poďme si však vytvoriť svoju vlastnú. Procedúra sa deklaruje ešte pred blokom begin - end.
(s bodkou). Vykonávame ju napísaním jej názvu (nezabudnime na bodkočiarku).

program nazov_programu;
{deklaracia procedury}
procedure moja_procedura;
begin
prikazy_procedury;
end;
{samotny program}
begin
moja_procedura;
end.

Naša sa bude volať meno a jej úlohou sa stane zistiť a vypísať vaše meno. Uznávam, že to nie
je vôbec praktický príklad, ale poslúži nám.

program mena;
var
text_mena: string;
// deklaracia procedury
procedure meno;
begin
writeln('Zadajte meno.');
readln(text_mena);
writeln('Volate sa ',text_mena,'.');
end;
// samotny program
begin
meno;
writeln('Skusime to este raz.');
meno;
end.

Procedúry môžu mať aj tzv. parametre. Sú to premenné, ktoré musíme funkcii dodať pri
každom jej vykonávaní a vždy môžu byť iné. Píšeme ich do zátvorky za názov procedúry. Ak
je parametrov viac, pri deklarácii ich oddeľujeme bodkočiarkami, pri vykonávaní čiarkami
(poznáte z writeln).

Teraz náš príklad zmeníme, aby bez zisťovania vypísal dve rôzne mená.

program mena2;
// deklaracia procedury
procedure meno
(poradie: integer; text_mena: string);
begin
writeln(poradie,'. meno je ',text_mena,'.');
end;
// samotny program
begin
meno(1,'Jano');
meno(2,'Peto');
end.

Funkcie
Funkcia sa od procedúry líši tým, že okrem vykonania sady príkazov vráti nejakú hodnotu.
Deklaruje sa kľúčovým slovom function. Hodnotu, ktorá sa má vrátiť, určuje špeciálna
premenná Result. Aby ste ju mohli vo Free Pascale používať bez jej manuálnej deklarácie,
treba zapnúť kompatibilitu s Delphi. Kliknite na menu Options / Compiler a zaškrtnite
políčko Delphi compatibility (ak už nie je zaškrtnuté).

Existuje aj iný spôsob - deklarovať premennú Result bežným spôsobom v časti var. Teraz sa
ale pozrime na príklad (kompatibilita je už zapnutá).

program mocniny;
// deklaracia funkcie
function mocnina
 (zaklad, exponent: integer): integer;
var
c, vysledok: integer;
begin
vysledok := 1;
for c := 1 to exponent do
vysledok := vysledok * zaklad;
Result := vysledok;
end;
// samotny program
begin
writeln(mocnina(10,2));
readln;
end.

Všimnite si, že časť var sa môže nachádzať priamo v deklarácii funkcie. Tieto premenné
budú prístupné len pre aktuálnu funkciu a po jej ukončení sa vynulujú.

Nakoniec ešte spomeniem tretí spôsob vrátenia hodnoty, asi jediný použiteľný v starom Turbo
Pascale. Jednoducho priradíme výsledok premennej, ktorej názov je zhodný s názvom
funkcie.

function Funkcia;
begin
Funkcia := 10;
end;

Free Pascal - Polia

Reč nebude o traktoroch a poľnohospodárskych plodinách, ale o dôležitom type premennej.
Pole v Pascale je súbor premenných rovnakého typu, ktoré majú svoje číselné indexy.

Využitie
Ak napríklad potrebujeme zaznamenať 1000 čísel, určite ich nezačneme ukladať do tisícich
ručne vytvorených premenných nazvaných prem000, prem001, prem002,... Využijeme pole a
jediným riadkom ich deklarujeme. Prístup k prvkom je tiež veľmi jednoduchý. Tak ideme na
to.

Deklarácia poľa
Tu je schéma:

var
názov_poľa: array[začiatok..koniec]
of typ_premenných;

Slovo začiatok predstavuje číslo prvého prvku a koniec - posledného.

Takto vytvoríme pole celých čísel s prvkami od 1 do 10:

var
pole: array[1..10] of integer;

Toto je pole obsahujúce reťazce, ktoré majú indexy od 5 do 123:

var
pole: array[5..123] of string;

Práca s prvkami
K prvkom v poli pristupujeme pomocou názvu poľa, za ktorým nasleduje v hranatých
zátvorkách index prvku.

ovocie[0] := 'jablko';
ovocie[1] := 'banan';
writeln(ovocie[0],' ', ovocie[1]);

Príklad vypíše:

jablko banan

Nasledujúci príklad ukazuje, ako najprv získame od užívateľa 5 čísel a potom ich vypíšeme v
opačnom poradí.

program polia;
var
c: integer;
pole: array[1..5] of integer;
begin
{ ziskavanie }
for c := 1 to 5 do begin
writeln('Zadajte ', c, '. cislo.');
readln(pole[c]);
end;
{ vypis cez cyklus for..downto }
writeln('Opacny vypis:');
for c := 5 downto 1 do
write(pole[c],' ');
end.

Špeciality
Indexy môžu byť i záporné.

a: array[-10..-5] of string;

Miesto celočíselných indexov existujú aj znakové. Nasledujúca deklarácia je teda tiež

správna:

b: array['a'..'n'] of integer;
Free Pascal - Náhodné javy
Zatiaľ viete, že pri programovaní musí mať všetko svoju logiku, nič nenechávame na náhodu.
Alebo predsa? V Pascale existuje tzv. generátor pseudonáhodných čísel. Tie však stále nie sú
úplne vymyslené - získavajú sa špeciálnymi algoritmami, pričom sa využíva aktuálny
systémový čas.

Náhodné desatinné číslo

Ak ho potrebujeme získať, využijeme funkciu random bez parametra.

writeln(random);

Na obrazovke sa zjaví nič nehovoriace číslo. Dokonca, ak program spustíte viackrát, malo by
sa zobraziť presne to isté (nie je to však pravidlo).

Náhodné celé číslo

Opäť použijeme funkciu random, tento raz s parametrom. Ten bude celočíselný a určí
maximálne možné vygenerované číslo.

writeln(random(5));

Aby sme zabránili generovaniu stále toho istého čísla, použijeme procedúru randomize.
Takto vyzerá kompletný program:

program nahodne;
begin
randomize;
writeln(random(5));
end.

Naša aplikácia vypíše náhodne vybrané celé číslo od 0 do 4 (vrátane 0 a 4). Skúste ju spustiť
viackrát.

Príklad
Skúsime napísať program, ktorý by vygeneroval a napísal 10 náhodných čísel od 1 do 15
(vrátane). Výsledné čísla sa však nesmú opakovať! Použijeme pole, do ktorého si budeme
ukladať generované hodnoty. Pred tým, ako číslo vložíme do poľa, skontrolujeme, či sa v
ňom už nenachádza. Aplikáciu nazveme Lotéria.

program loteria;
var
pole: array[1..10] of integer;
nahodne, c, d: integer; // pomocne
nachadza_sa: boolean;
begin
randomize;
for c := 1 to 10 do begin
 repeat {aby sa cisla neopakovali}
nahodne := random(15)+1;
nachadza_sa := false;
for d := 1 to 10 do
if nahodne = pole[d] then
nachadza_sa := true;
until not nachadza_sa;
pole[c] := nahodne;
writeln(nahodne);
end;
end.

Free Pascal - Záznamy

Záznamy v Pascale sa dajú označiť za predchodcov objektov. Sú to premenné, obsahujúce
podradené premenné rôzneho typu.

Príklad na začiatok
Predstavte si, že máte uchovávať údaje o európskych krajinách. Napríklad záznam Slovensko
typu TKrajina môže obsahovať dve celočíselné položky (Rozloha, PocetObyvatelov) a
reťazcovú položku HlavneMesto.

Typ záznamu sa podľa zvyku začína písmenom T (napr. TBudova).

Vytvorenie a používanie
Máme dve možnosti - buď deklarujeme priamo premennú:

var
Zaznam: record
Vlastnost: integer;
InaVlastnost: string;
end;

alebo najprv definujeme nový typ a potom vytvoríme premennú tohto typu. Využijeme druhú
možnosť.

program ludia;
type
TClovek = record
Meno, Priezvisko: string; {2 retazce}
RokNarodenia: word; {cele cislo}
end;
var
Ujo: TClovek;
...

Teraz jednotlivým položkám záznamu Ujo priradíme hodnoty. Potom ich môžeme vypísať.
Oddeľovačom názvu záznamu a jeho položiek je bodka.

...
begin
Ujo.Meno := 'Jozko';
Ujo.Priezvisko := 'Mrkvicka';
Ujo.RokNarodenia := 1850;
write(Ujo.Meno, ' ', Ujo.Priezvisko);
writeln(' bol narodený r. ', Ujo.RokNarodenia);
end.

Podradené záznamy
Jeden záznam môže obsahovať iný záznam. Napríklad človek má okrem už spomenutých
údajov (meno, priezvisko, rok narodenia) aj adresu, ktorá obsahuje ulicu a mesto. Upravíme
teda predchádzajúci kód.

type
TClovek = record
Meno, Priezvisko: string; {2 retazce}
RokNarodenia: word; {cele cislo}
Adresa: record {podradeny zaznam}
Ulica, Mesto: string;
end;
end;

Použitie je dosť jednoduché - záznamy a podzáznamy taktiež oddeľujeme bodkou.

Ujo.Adresa.Ulica := 'Neznama';
Ujo.Adresa.Mesto := 'Hraskovo';

Urýchlený prístup
Ak chceme nejaký záznam používať dosť veľa krát za sebou, nemusíme k nemu pristupovať
vždy pomocou tvaru záznam.položka. Miesto toho môžeme použiť kľúčové slovo with.

with Ujo do begin

Meno := 'Jozko';
Priezvisko := 'Mrkvicka';
RokNarodenia := 1850;
Adresa.Ulica := 'Neznama';
Adresa.Mesto := 'Hraskovo';
end;

Free Pascal - Objekty

Objektovo orientované programovanie umožňuje zadefinovať tzv. objekty - špeciálne
premenné, ktoré majú svoje vlastnosti, udalosti a pod. Pokúsim sa zhrnúť najdôležitejšie
informácie na túto tému.

Aby všetko fungovalo...

V TurboPascale 7 existuje kľúčové slovo object, ale skutočnú podporu tried a objektov
nájdeme až v Object Pascale a Free Pascale.
Ak sa vám vo Free Pascale nebude dariť skompilovať zdrojové kódy uvedené v tomto článku,
je potrebné nastaviť ho: menu Options / Compiler, záložka Syntax, odstavec Compiler mode -
vyberte možnosť Object Pascal extension on, prípadne Delphi compatible.

Trieda
Veľmi zjednodušene možno povedať, že trieda je určitý typ premennej. Objekt je zas
premenná typu trieda.

Pokúsime sa vytvoriť program, v ktorom vytvoríme triedu TSkola. Bude v nej zadefinovaná
vlastnosť - premenná Ziaci (typu integer); ďalej tzv. metóda - procedúra
PrijmiZiakov(pocet: integer), ktorá prijme určitý počet nových žiakov na školu a
pripočíta ich k súčasnému počtu. Metóda VyhodZiaka zmenší počet žiakov školy o 1. Funkcia
(metóda) PocetLudi vráti celkový počet ľudí na škole.

Konštruktor (constructor) je špeciálnu metóda, ktorá sa zavolá pri vytvorení nového

objektu typu TSkola. Jeho úlohou bude nastaviť počiatočný počet žiakov na škole. Naopak,
deštruktor (destructor) sa vykoná pri zaniknutí objektu danej triedy. Ten však dnes
nepoužijeme.

Zdrojový kód v dnešnom článku je trocha dlhší, preto som ho trošku rozkúskoval.

program objekty;
const
{pocet zamestnancov skoly je konstantny}
Zamestnanci = 50;
type
TSkola = class
{pocet ziakov na skole}
Ziaci: integer;
{prijatie dalsich ziakov}
procedure PrijmiZiakov(pocet: integer);
{vyhodenie ziaka zo skoly}
procedure VyhodZiaka;
{funkcia vrati celkovy pocet ludi na skole}
function PocetLudi: integer;
{konstruktor volany pri vytvoreni objektu}
constructor Create;
end;

To bola deklarácia. Kľúčovým slovom type sme zadefinovali nový typ premennej - triedu
(class) TSkola. Nasledoval akýsi výpis vlastností a metód.

Naprogramujme samotné „telá“ metód. Názvy sa tvoria spôsobom meno_triedy.Procedúra.

procedure TSkola.PrijmiZiakov(pocet: integer);

begin
Ziaci := Ziaci+pocet;
end;

procedure TSkola.VyhodZiaka;
begin
{pascalovska procedura Dec
zmensi pocet ziakov o 1}
 Dec(Ziaci);
end;

function TSkola.PocetLudi: integer;

begin
{vratime celkovy pocet ludi}
PocetLudi := Zamestnanci+Ziaci;
end;

Podobne napíšeme kód konštruktora Create.

constructor TSkola.Create;
begin
{na zaciatku bude v kazdej skole 300 ziakov}
Ziaci := 300;
end;

Objekt
To však nie je všetko - zdrojový kód nášho programu pokračuje ďalej.

Vytvoríme objekt typu TSkola. Môže ich byť aj viacej. Každá škola má vlastnosti a metódy
Ziaci, VyhodZiaka, atď. No jedna z nich bude mať po prijatí nových študentov 450 žiakov a
druhá po ich vyhodení 280. To je jedna z výhod objektového programovania - môžeme
vytvoriť viac inštancií jednej triedy.

Deklarujme premenné (objekty) ZSMala a VelkeGymnazium typu TSkola:

var
ZSMala, VelkeGymnazium: TSkola;

Konečne môžeme objekty vytvoriť, a to pomocou ich konštruktora.

begin
ZSMala := TSkola.Create;
VelkeGymnazium := TSkola.Create;

Nakoniec budeme s objektmi pracovať. Oddeľovačom medzi objektom a jeho vlastnosťou,

resp. metódou, je vždy bodka.

ZSMala.PrijmiZiakov(150);
{300 ziakov + 50 zamestnancov
+ 150 prijatych = 500 ludi}
writeln('ZSMala: ', ZSMala.PocetLudi, ' ludi');

VelkeGymnazium.VyhodZiaka;
{300 + 50 - 1 = 349}
writeln('Velky gympel: ',
VelkeGymnazium.PocetLudi, ' ludi');
end.

Program môžeme spustiť a vyskúšať.

Dedičnosť
Dedičnosť je jednou z vlastností OOP. Predstavme si, že chceme navrhnúť novú triedu -
TGymnazium, ktorá by mala okrem vlastností triedy TSkola navyše vlastnosť PocetRocnikov.
Nemusíme programovať všetko odznova, stačí ju vytvoriť takto:

type
TSkola = class
... (tu nič nemeníme) ...
end;
TGymnazium = class(TSkola)
PocetRocnikov: byte;
end;

Trieda TGymnazium zdedila vlastnosti a metódy triedy TSkola - je teda jej potomkom.
Pribudol jej však PocetRocnikov.

Ešte zmeníme zvyšok kódu:

var
...
VelkeGymnazium: TGymnazium;
begin
...
VelkeGymnazium: TGymnazium.Create;

Odteraz môžeme pracovať aj s premennou VelkeGymnazium.PocetRocnikov. Zápis

ZSMala.PocetRocnikov je však nesprávny.

Prístup k vlastnostiam
Ak chceme zamedziť prístupu k daným vlastnostiam z určitých častí kódu, používame
kľúčové slová private (súkromné - neprístupné mimo triedy), public (prístupné z
akejkoľvek časti kódu), protected (prístupné len pre danú triedu a jej potomkov) a
published (niečo podobné ako public). Použitie je nasledovné:

type
TSkola = class
private
Ziaci: integer;
public
procedure PrijmiZiakov(pocet: integer);
...
end;

Polymorfizmus
O polymorfizme hovoríme, ak dva rôzne objekty / triedy reagujú na tú istú správu (napr.
procedúru / funkciu) rozdielne.

type
TSkola = class
...
function TypSkoly: string; virtual;
end;
TGymnazium = class(TSkola)
 ...
function TypSkoly: string; override;

Funkcie TSkola.TypSkoly a TGymnazium.TypSkoly môžu obsahovať rozličný kód.

Free Pascal - Grafika

Doteraz sme ako výstup používali len vypisovanie textu procedúrami write a writeln.
Pascal však dokáže pracovať aj s grafikou - kresliť úsečky, obdĺžniky, elipsy a pod.

Grafický režim
Aby sme mohli pracovať s grafikou, je potrebné prepnúť z textového do grafického režimu.
Uvediem tu kód, ktorý je nutné vkladať do každého pascalovského grafického programu.
Nemusíte mu rozumieť, keďže ide o systémové záležitosti, ale napíšem niečo aj o tom.

Najskôr pridáme do sekcie uses jednotku graph, ktorá obsahuje všetko potrebné na
„kreslenie“.

Premenná ovladac, veľmi zjednodušene povedané, obsahuje číslo ovládača grafickej karty.
Ovládač je súbor sprostredkujúci spoluprácu medzi hardvérom a softvérom. Grafmod je
grafický mód, v akom budeme pracovať - väčšina ovládačov totiž obsahuje viac režimov,
napr. mód 1 = rozlíšenie monitora 640x480, 256 farieb; mód 2 = rozlíšenie 720x400, 16 farieb
a pod.

Nebojte sa, všetko ponecháme na autodetekciu a premennej ovladac priradíme hodnotu

funkcie Detect.

Nakoniec prepneme do grafického režimu procedúrou InitGraph. Prvým parametrom je

ovládač, druhým grafický mód a tretí určuje priečinok, kde sa nachádza súbor s ovládačom.
Veľa rôznych ovládačov môžete nájsť priamo v TurboPascale, ale ak sa vám nechce hľadať a
skúšať, stiahnite si odtiaľto súbor EGAVGA.BGI. Umiestnite ho napr. do adresára
C:\OVLADACE a potom uveďte tento priečinok ako tretí parameter procedúry InitGraph.

program grafika;
uses
crt, graph;
var
ovladac, grafmod: integer;
begin
ovladac := Detect;
InitGraph(ovladac, grafmod, 'C:\OVLADACE');
...
repeat until keypressed;
end.

Ak používate FreePascal a nedarí sa vám tento kód skompilovať, je nutné:

 • Buď zameniť v deklarácii premenných ovladac a grafmod dátový typ integer za
smallint
• alebo nastaviť v menu Options / Compiler na karte Syntax položku Compiler mode na
Turbo Pascal Compatible.

Program spustite a ak nepozorujete chybové hlášky, všetko by malo byť v poriadku.

Grafická plocha
Grafickú plochu predstavuje v prípade TurboPascalu celá obrazovka, pri Free Pascale je to
špeciálne windowsovské okno.

Pracuje sa v súradnicovej sústave. Jej začiatok je v ľavom hornom rohu a má súradnice X = 0,

Y = 0; ináč povedané [0, 0]. Jednotkou sú pixle.

Čiary
Na nakreslenie úsečky používame funkciu Line(X1, Y1, X2, Y2). Parametre sú celočíselné
a zohrávajú nasledujúcu úlohu:

• X1 je X-ová súradnica začiatočného bodu úsečky

• Y1 je jeho Y-ová súradnica
• X2 je X-ová súradnica koncového bodu úsečky
• Y2 je jeho Y-ová súradnica

Skúsime nakresliť vodorovnú čiaru začínajúcu na súradniciach [100, 50] a končiacu na [300,
50].

Line(100, 50, 300, 50);

Podobný efekt môžeme dosiahnuť tým, že procedúrou MoveTo(X, Y) posunieme akýsi

„ukazovateľ“ na pozíciu [100, 50]. Potom pomocou LineTo(X, Y) urobíme čiaru z aktuálnej
súradnice do pozície [300, 50].

MoveTo(100, 50);
LineTo(300, 50);

Obdĺžniky
Obdĺžnik sa dá nakresliť viacerými čiarami, ale zvyčajne ho kreslíme jednoduchšie -
procedúrou Rectange(X1, Y1, X2, Y2). Parametre majú tentoraz takýto význam:

• X1 a Y1 sú súradnice ľavého horného rohu obdĺžnika

• X2 a Y2 sú súradnice jeho pravého dolného rohu

Nakreslíme obdĺžnik široký 200 a vysoký 80 px. Jeho ľavý horný roh bude na pozícii [100,
100].
Rectangle(100, 100, 300, 180);

Procedúra Bar má rovnaké parametre ako Rectangle, ale jej úlohou je nakresliť vyplnený
obdĺžnik. Predtým, ako ju zavoláme, je vhodné nastaviť štýl a farbu výplne pomocou
SetFillStyle(Typ_výplne, Farba).

SetFillStyle(SolidFill, red);
Bar(100, 100, 300, 180);

Kruhy a elipsy
Vytvoriť kruh je jednoduchšie, ako by sa mohlo zdať. Máme na to procedúru Circle(X, Y,
Polomer). Celočíselné parametre X a Y označujú súradnice stredu kruhu, význam slova
polomer asi netreba vysvetľovať.

Circle(250, 200, 40);

Procedúra Ellipse, kresliaca elipsu alebo jej časť, má, samozrejme, trochu viac parametrov.
Takto znie definícia:

Ellipse(X, Y: Integer; StAngle, EndAngle: Word;

XRadius, YRadius: Word);

X a Y sú súradnice stredu. XRadius je x-ový polomer, YRadius zas y-ový.

StAngle je uhol, od ktorého sa začína časť elipsy kresliť. EndAngle je uhol, kde sa má prestať
kresliť. Predstavte si uhlomer, kde 0 alebo 360 stupňov je vpravo, 90 hore, 180 vľavo a 270
dole. Viac možno pochopíte skúšaním rôznych hodnôt.

Ellipse(50, 150, 90, 360, 30, 50);

Vznikne časť elipsy:

Text
Hoci sme v grafickom prostredí, nikto nepovedal, že na grafickú nemôžme písať text. Slúži na
to procedúra OutText s parametrom typu string. Daný text sa vypíše na aktuálnu pozíciu
(určenú cez MoveTo, atď.).

OutText('Nejaky text');

Funkcia OutTextXY(X, Y, Text) vypíše parameter Text na súradniciach X, Y.

OutTextXY(10, 10, 'Iny text');

Farby
Farbu kresliaceho nástroja nastavíme procedúrou SetColor(Farba). Parametrom
je číslo, avšak existujú preddefinované konštanty, ktoré môžeme použiť -
napr. Blue je modrá, Yellow žltá a pod.

SetColor(LightBlue);
Line(0, 0, 100, 200);

Graf kvadratickej funkcie

Uvediem praktický príklad - vykreslenie grafu kvadratickej funkcie x2-
10x+30. Hodnoty sa budú počítať a kresliť od x = -10 po x = 20.

program grafkvad;
uses
crt, graph;
const
zaciatok = -10;
koniec = 20;
var
ovladac, grafmod: integer;
x, stredX, stredY: integer;

Samotná funkcia bude uložená vo funkcii f s celočíselným parametrom X.

Vráti sa stred výšky plochy mínus hodnota Y pre dané X. Dôvod je jasný -
hodnoty pascalovských súradnic sa zhora nadol zvyšujú, v matematike je to
naopak.

{kvadraticka funkcia
s prepoctom na pascalovske suradnice}
function f(x: integer): integer;
begin
f := stredY-(x*x-10*x+30);
end;
begin
{prechod do grafickeho rezimu}
ovladac := Detect;
InitGraph(ovladac, grafmod, 'C:\OVLADACE');

Pascalovská funkcia GetMaxX vráti šírku grafickej plochy v pixloch, GetMaxY

zas jej výšku. Vydelením týchto čísel dvojkou dostaneme stred nášho
vlastného súradnicového systému.

{urcenie stredu plochy}

stredX := GetMaxX div 2;
stredY := GetMaxY div 2;

Teraz nakreslíme osi x a y. Dáme k nim aj textový popis.

{vykreslenie osi x a y}
Line(0, stredY, GetMaxX, stredY);
Line(stredX, 0, stredX, GetMaxY);
{napiseme k nim textovy popis}
OutTextXY(0,stredY+2,'X');
 OutTextXY(stredX+2,0,'Y');

Presunieme ukazovateľ na začiatok. V cykle postupne vykresľujeme hodnoty Y

pre X, zväčšujúce sa od začiatočnej po koncovú hodnotu.

{presun na zaciatok grafu}

MoveTo(stredX+zaciatok, f(zaciatok));
{vykreslovanie v cykle}
for x := zaciatok to koniec do
LineTo(stredX+x, f(x));
repeat until keypressed;
end.

Free Pascal - Práca so súbormi

Prístup k súborom na disku je dôležitý takmer pre každú bežnú aplikáciu. Ukážme si, ako sa s
nimi pracuje v Pascale.

Súbory všeobecne
Najprv je potrebné vytvoriť premennú, ktorá bude daný súbor symbolizovať. Táto premenná
môže byť typu file - tzv. netypovaný súbor, file of nejaký_typ - súbor s určeným
typom, text - textový súbor.

var
Subor: Text;

Teraz je treba premennú „zviazať“ s konkrétnym súborom na disku. Slúži na to procedúra

Assign (v Delphi-móde AssignFile).

Assign(Subor, 'C:\MOJE.TXT');

Premenná subor bude odteraz odkazovať na súbor C:\MOJE.TXT. Ak nemáte prístup do

priečnika C:\, radšej zapisujte do aktuálneho adresára - je to priečinok, v ktorom sa práve
nachádzate a z ktorého bol program spustený. Stačí úplne vynechať cestu k súboru:

Assign(Subor, 'MOJE.TXT');
Keď je už názov súboru určený, je na čase otvoriť ho. V Pascale existujú tri možnosti jeho
otvorenia - na čítanie, zapisovanie a pripisovanie. Tretí spomínaný je dostupný len pre textové
súbory. Spôsob práce uvediem pre každý typ súboru zvlášť.

Textové súbory
Začneme s textovými súbormi, keďže sú asi najjednoduchšie na pochopenie. Ich využitie
nájdeme napr. pri tvorbe textového editora, ukladaní jednoduchých hodnôt do konfiguračného
súboru a pod.

Textový súbor otvoríme jednou z procedúr:

• Reset - ak z neho potrebujeme čítať. Súbor už musí na disku existovať.

• Rewrite - kvôli zapisovaniu. Ak súbor nejestvuje, vytvorí sa. Pokiaľ však existuje,
prepíše sa a stratíme jeho pôvodný obsah!
• Append - pre pripisovanie na koniec súboru. Ten už musí existovať.

Parametrom týchto procedúr je vždy premenná symbolizujúca súbor (typ text).

Rewrite(Subor);

Po otvorení môžeme do súboru zapisovať, čítať z neho a pod. Procedúra ReadLn(subor,

riadok) prečíta riadok zo súboru subor a zapíše ho do premennej riadok. Posunie sa
ukazovateľ (predstavme si ho ako kurzor), takže pri ďalšom volaní tejto procedúry sa číta
vždy ďalší a ďalši riadok.

WriteLn(subor, riadok) zapíše do súboru hodnotu druhého parametra a vytvorí nový

riadok.

Obdobne fungujú procedúry Read a Write.

Tu je jednoduchý príklad. Úlohou je vypísať obsah textového súboru na obrazovku.

Použijeme pri tom funkciu Eof(súbor), ktorá vráti true, ak bol dosiahnutý koniec súboru.
Close(súbor) zatvorí súbor.

program subory;
var
Subor: Text;
riadok: string;
begin
{priradime premennej konkretny subor}
Assign(subor, 'C:\MOJE.TXT');
{otvorime ho na citanie}
Reset(subor);
{kym nie je koniec suboru}
while not Eof(subor) do begin
{precitame riadok zo suboru}
ReadLn(subor, riadok);
{zapiseme riadok na obrazovku}
WriteLn(riadok);
end;
{zatvorime subor}
Close(subor);
end.

Netypované súbory
Používajú sa najmä pri operáciách, kde nás nezaujíma, čo konkrétne je v súbore uložené -
napríklad na kopírovanie súborov.

Na otvorenie používame tieto procedúry:

• Reset - otvorí súbor (už existujúci) na čítanie aj zápis.

• Rewrite - otvorenie na čítanie a zápis. Neexistujúci súbor sa vytvorí, jestvujúci sa
prepíše.

Spomínané procedúry majú dva parametre. Prvý symbolizuje daný súbor (typ file) a druhý,
celočíselný, udáva veľkosť bloku dát.

Miesto procedúr Read a Write tu používame BlockRead a BlockWrite. Tie majú 3 povinné
parametre - súbor, buffer (ľubovoľná pomocná premenná), počet bytov zabraných bufferom.
Ten zistíme funkciou SizeOf(premenná). Do štvrtého (nepovinného) parametra sa uloží
počet prečítaných / zapísaných záznamov.

Je tu dosť veľa teórie, ale iste viac pochopíte z príkladu - už spomínané kopírovanie súborov:

program kopiruj;
var
zdroj, ciel: File;
{buffer bude pole 512 znakov}
buffer: array[1..512] of char;
precitane: integer;
begin
{zdrojovy subor otvorime na citanie}
Assign(zdroj, 'C:\ZDROJ.BIN');
Reset(zdroj, 1);
{cielovy na pisanie}
Assign(ciel, 'C:\CIEL.BIN');
Rewrite(ciel, 1);
{postupne citame z 1. a zapisujeme do 2. suboru}
repeat
{zo zdroja precitame max. 512 bytov, ulozime
ich do buffera, premenna PRECITANE bude
obsahovat pocet skutocne precitanych bytov}
BlockRead(zdroj, buffer,
SizeOf(buffer), precitane);
{buffer zapiseme do ciela}
{velkost buffera v bytoch = PRECITANE}
BlockWrite(ciel, buffer, precitane);
until precitane = 0;
Close(zdroj);
Close(ciel);
end.

Dalo by sa to aj jednoduchšie, ale tento spôsob by mal byť pomerne rýchly.

Súbory s určeným typom

Môžeme ich použiť, ak potrebujeme v binárnej forme ukladať viacero záznamov s rovnakou
štruktúrou - napr. rodné čísla, adresy a pod. Deklarácia je nasledujúca:

var
subor: file of typ_premennej;

Na otváranie sú určené procedúry Reset a Rewrite (ako pri netypovaných súboroch). Čítanie
a zápis je možný vďaka procedúram Read a Write.

Príklad: Prvý program zapíše do súboru čísla zadané z klávesnice. Po zadaní a zapísaní nuly
sa program ukončí.

program citaj;
var
cislo: integer;
subor: File of integer;
begin
{otvorime a prepiseme subor}
Assign(subor, 'C:\CISLA.BIN');
Rewrite(subor);
repeat
{precitame cislo z klavesnice}
ReadLn(cislo);
{zapiseme ho do suboru}
Write(subor, cislo);
{zadanim nuly sa program ukonci}
until cislo = 0;
Close(subor);
end.

Druhý ich zas z tohto súboru prečíta a vypíše na obrazovku.

program pis;
var
cislo: integer;
subor: File of integer;
begin
{otvorime subor}
Assign(subor, 'C:\CISLA.BIN');
Reset(subor);
{kym nie je koniec suboru}
while not Eof(subor) do begin
{precitame cislo zo suboru}
Read(subor, cislo);
{vypiseme cislo na obrazovku}
WriteLn(cislo);
end;
Close(subor);
end.

Test existencie súboru

Ak potrebujeme zistiť, či daný súbor už existuje, vo FreePascale použijeme funkciu
FileExists(názov_súboru) z jednotky SysUtils.
V TurboPascale je situácia zložitejšia. Musíme vypnúť kontrolu vstupno-výstupných chýb
direktívou prekladača {$I-}. Potom sa pokúsime otvoriť súbor na čítanie. Ak sa hodnota
funkcie IOResult (chybový kód poslednej vstupno-výstupnej operácie) rovná nule, súbor
existuje - nebola zaznamenaná žiadna chyba.

program exist;
var
subor: file;
begin
Assign(subor, 'C:\SKUSKA.BIN');
{vypneme kontolu chyb}
{$I-}
{pokusime sa otvorit subor}
Reset(subor);
{podla hodnoty chyboveho kodu
vypiseme, ci subor existuje}
if IOResult = 0 then
writeln('Subor existuje.')
else
writeln('Subor neexistuje.');
{opat zapneme kontrolu chyb}
{$I+}
end.

Všimnite si, že ak za zloženou zátvorkou { nasleduje dolár $, už to nie je poznámka, ale

direktíva prekladača.

Ďalšie operácie
Tu je zopár užitočných procedúr a funkcií:

• Erase(súbor) - zmaže súbor z disku. Parametrom je premenná typu súbor. Ten už

musí byť priradený cez Assign, ale ešte nie otvorený (pomocou Reset, Rewrite,...).
• FilePos(súbor) - vráti aktuálnu pozíciu v otvorenom súbore (nesmie byť textový).
• FileSize(súbor) - vráti celkový počet záznamov v otvorenom súbore (ten nesmie
byť textový).
• Rename(súbor, nový_názov) - premenuje priradený (ale ešte nie otvorený) súbor na
nový_názov.
• Seek(súbor, pozícia) - posunie ukazovateľ v otvorenom súbore na záznam s danou
pozíciou. Súbor nesmie byť textový.

Free Pascal - Vymenovaný typ

Vymenovaný typ (enumerated type) je taký, kde určíme všetky možné hodnoty, aké môže
premenná daného typu nadobudnúť. Táto premenná bude obsahovať vždy len jednu z
určených hodnôt.

Semafor
Jednoduchý príklad je obyčajný cestný semafor. Môže nadobúdať tri rôzne hodnoty - červená,
oranžová, zelená. Najskôr si vytvoríme typ TSemafor. Všetky prijateľné hodnoty
vymenujeme v zátvorke, oddeľujeme ich čiarkami. Býva dobrým zvykom dať pred
vymenované názvy 2-3 písmená, v našom prípade „sm“ ako semafor. Zabránime tým
prípadnému opakovaniu názvov, ktoré by mohlo viesť k chybám.

program vym_typ;
type
TSemafor = (smCervena, smOranzova, smZelena);

Teraz môžeme vytvoriť premennú Semafor.

var
Semafor: TSemafor;

Nakoniec môžeme s premennou pracovať.

begin
Semafor := smCervena;
if Semafor = smCervena then
writeln('Este nemozete ist!');
end.

Práca s ordinálnymi premennými

Ordinálny typ je taký, ktorý má presne určené možné hodnoty a tie sú usporiadané v poradí od
najmenšieho po najväčší. Každá hodnota má svoj číselný index. Ordinálne sú napríklad
celočíselné typy a znak (char). Aj vymenovaný typ je ordinálny. Ukážeme si, ako sa dá s
týmito typmi pracovať.

Funkcia Ord vráti číselný index hodnoty, ktorú jej dáme ako parameter.

writeln(Ord(smCervena));

Index prvého prvku vymenovaného typu je nula. Príklad teda vypísal nulu.

Funkcia Pred vráti hodnotu, ktorá sa nachádza v rade hneď pred zadaným prvkom. Succ vráti
nasledujúcu možnú hodnotu.

{vypise 0, co je index smCervena}

writeln(Ord(Pred(smOranzova)));

{vypise 2, co je index smZelena}

writeln(Ord(Succ(smOranzova)));

Asi ste si všimli, že premennú vymenovaného typu nemôžeme vypísať. Tak sme aspoň
vypísali jej index.

Funkcia Low vráti prvok s najnižším indexom, High zasa ten s najvyšším.

writeln(Ord(Low(smZelena))); // vypise 0
writeln(Ord(High(TSemafor))); // vypise 2
Ako vidíte, funguje to nielen s premennými, ale i s typmi.

Procedúra Inc zvýši hodnotu premennej o 1, Dec ju zníži.

Semafor := smOranzova;
Inc(Semafor);
if Semafor = smZelena then
writeln('Mozete prejst!');

Všetky spomínané funkcie môžeme použiť na akýkoľvek ordinálny typ.

{premenna i je typu integer}

i := 20;
while i >= 15 do begin
writeln(i);
Dec(i);
end;

Príklad postupne vypisoval hodnotu premennej i a znižoval ju o 1.

Vymenovaný typ môžeme porovnávať podobne ako čísla alebo znaky.

writeln(smOranzova < smZelena); // TRUE

Iné spôsoby určenia

Indexy môžeme určiť aj manuálne:

type
TProza = (prPoviedka = 5, prNovela = 10,
prRoman = 15, prIne = 20);

Pri určovaní nového vymenovaného typu nemusíme vždy vypisovať všetky možné hodnoty.
Stačí určiť prvý prvok, napísať dve bodky a posledný prvok.

type
TBeznaProza = prPoviedka..prRoman;
TDvojciferne = 10..99;

Číslo typu TDvojciferne bude môcť nadobúdať hodnoty od 10 po 99 (vrátane).

Premenným môžeme určiť typ aj priamo:

var
MalePismeno: 'a'..'z';