Free Pascal - ÚvodSvetozná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čiatkyKeď 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.

{ zaciatoknejaky textkoniec }

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ýstupIste 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átorySamozrejme, ž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:

31

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ý:

1512

Free Pascal - Logické výrazyLogický 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:

FALSETRUE

Free Pascal - PodmienkyBez 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íkaz1else 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;endelse 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 - CyklyPri 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 funkcieUž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 programbegin 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 proceduryprocedure meno (poradie: integer; text_mena: string);begin writeln(poradie,'. meno je ',text_mena,'.');end;// samotny programbegin 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 funkciefunction 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 programbegin 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 - PoliaReč 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é javyZatiaľ 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áznamyZá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 - ObjektyObjektovo 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 - GrafikaDoteraz 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úbormiPrí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ý typVymenovaný 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 0writeln(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';