1.Prednaska

Z Pascal
Prejsť na: navigácia, hľadanie
1. Prednáška

úlohy | cvičenie


Programátorské prostredie

Čo je to FreePascal a Lazarus


  • Lazarus je pomenovanie programátorského prostredia, v ktorom sa programuje v jazyku FreePascal
  • samotný jazyk Pascal je komunitou informatikov na celom svete považovaný za jazyk
    • vytvorený na to aby sa v ňom dalo učiť programovanie, princípy tvorby algoritmov, algoritmické rozmýšľanie, programátorská disciplína a pod.
    • v ktorom sa zapisujú algoritmy - tieto sú potom zrozumiteľné pre profesionálov bez ohľadu na to, v akom jazyku programujú
    • je odporúčaný ako jeden z prvých jazykov programovania napr. na ZŠ a SŠ (na rozdiel od C)
    • jazyk je natoľko jednoduchý a jednoznačný, že neskorší prechod na ľubovoľný iný programovací jazyk je veľmi príjemný
  • Pascal podobne ako C vznikol začiatkom 70-tych rokov - oba boli postavené na základe štruktúrovaných konštrukcií jazyka Algol a oba sa inšpirovali pravdepodobne vtedajšími jazykmi ako Fortran a PL/1
    • hlavnou prioritou Pascalu bola akademická pôda, na rozdiel od C, ktoré vzniklo pre systémových programátorov - teda už veľmi skúsených programátorov
  • postupom času (v polovici 80-tych rokov) sa z Pascalu vyvinul moderný Objektový Pascal a C sa zmodernizovalo na objektové C++
  • tiež aj v súčasnosti vzniká množstvo nových programovacích jazykov, ktoré sa veľmi silne inšpirujú Pascalom aj jazykom C, resp. C++, takže v budúcej vašej praxi možno budete pracovať s jazykmi, ktoré buď zatiaľ ešte neexistujú, alebo sú u nás zatiaľ málo známe - ale s najväčšou pravdepodobnosťou sa vám programátorský štýl, ktorý získate v týchto úvodných programátorských predmetoch veľmi zíde...
  • vo vyšších ročníkoch sa zoznámite aj s inými jazykmi, pričom práve Pascal vám umožní veľmi prirodzený prechod (napr. v 3. semestri táto prednáška pokračuje v jazyku C++, v 2. semestri je to úvod do PHP, v ďalších semestroch sa budete môcť zoznámiť s Javou, SmallTalk ale aj deklaratívnym programovaním)


Ako vyzerá programátorské prostredie


Programátorské prostredie Lazarus (IDE - integrated development environment) označuje, že programátor v jednom balíku môže

  • programy navrhovať, písať, upravovať, vyvíjať
  • kompilovať
  • testovať, ladiť
  • lokalizovať
  • ...

Súčasné moderné programátorské prostredia, ktoré umožňujú vyvíjať nielen aplikácie pre grafické rozhranie (napr. Windows), ale aj aplikácie pre web - sú založené na vizuálnom princípe: všetko, čo bude mať v bežiacej aplikácii vizuálne znázornenie, sa už počas návrhu bude dať vizuálne poskladať z nejakých predpripravených častí. Programátor potom veľmi často "iba" doprogramováva správanie týchto komponentov v rôznych situáciách a grafická nadstavba mu zabezpečí celkové správne fungovanie.

Podobne funguje aj Lazarus. Jeho celé prostredie sa skladá z viacerých častí:

  • panel ovládacích tlačidiel: napr. Nová jednotka, Uložiť, Nový formulár, Spustiť, a pod.
  • editovacie okno (editor kódu), v ktorom popisujeme správanie programu v rôznych situáciách (vo FreePascale)
  • formulár: vizualizácia nášho budúceho programu, t.j. okno - tu budeme vkladať a upravovať rôzne, väčšinou vizuálne komponenty
  • paleta komponentov: ponuka predpripravených "súčiastok", ktoré môžeme vkladať do nášho okna, napr. tlačidlá, grafické a textové plochy, editovacie okienka, posúvače a pod.
  • inšpektor objektov: špeciálne okienko, v ktorom môžeme upravovať parametre komponentov vo formulári
  • prostredie obsahuje ešte aj ďalšie časti - s niektorými sa zoznámime neskôr

prostredie Lazarus - úprava formulára

prostredie Lazarus - editovanie programu


Náš prvý program, spúšťanie a zastavenie


Skôr ako do detailov pochopíme princípy tvorby nového programu (aplikácie, projektu) v Lazarus, bude dobre si zautomatizovať nejaký jednoduchý postup, ktorý nám na začiatku pomôže vyvarovať sa niektorých začiatočníckych chýb. Takže poďme na našu prvú aplikáciu:

  1. naštartujeme Lazarus
  2. v menu Projekt zvolíme Nový projekt ... a potom Aplikácia
  3. Lazarus je teraz už pripravený na to, aby sme mohli začať tvoriť náš nový program - editovacie okno obsahuje len zopár základných predpísaných konštrukcií a formulár je prázdny
  4. v tomto momente (práve pred samotným začiatkom tvorby programu) je dobre si zvyknúť takýto zatiaľ "prázdny" program uložiť - samozrejme, že to môžeme aj neskôr, ale začiatočník pri tom môže robiť množstvo chýb - takže, z ponuky Projekt vyberieme Uložiť projekt:
    • zvolíme priečinok, do ktorého budeme projekt ukladať - odporúčame ukladať každý projekt do nového priečinku
    • každý projekt sa na disku skladá z viacerých súborov a tieto by mali byť spolu v jednom priečinku a nemali by sa prekrývať s inými projektmi
    • pri ukladaní projektu sa Lazarus pýta na uloženie dvoch súborov: Unit1.pas - to je samotný program aj s formulárom a project1.lpi - to je projektový súbor, ktorý sa vytvára automaticky a obsahuje dôležité informácie o celkovej štruktúre nášho projektu
  5. teraz už predpokladáme, že máme projekt úspešne uložený a môžeme ho spustiť:
    • hoci sme ešte nič neprogramovali, Lazarus nám s novou aplikáciou všetko pripraví tak, aby sme už mali funkčné jedno windows okno
    • stlačíme kláves F9 (alebo tlačidlo Spustiť na ovládacom paneli so zeleným trojuholníkom) a ak je program bez chýb, tak sa spustí: objavilo sa prázdne šedé okno s titulovým modrým pásom, s textom Form1 a s malými systémovými tlačidlami na minimalizovanie, maximalizovanie a ukončenie aplikácie
    • spustený program môžeme na pracovnej ploche windows posúvať, meniť mu veľkosť, prípadne sa prepnúť do inej bežiacej aplikácie, napr. prostredie Lazarus (to že naša aplikácia práve beží, vidíme v Lazarus, napr. tak, že tlačidlo so zeleným trojuholníkom je zablokované - zašedené)
    • bežiaci program ukončíme buď Close (v pravom hornom rohu)
    • po zastavení nášho bežiaceho prvého programu, ho môžeme teraz začať naozaj programovať - ale budeme na to potrebovať nejaké komponenty


Tlačidlá, priradenie akcií

Ukladanie komponentov do formulára je veľmi jednoduché:

  • okno s formulárom by malo byť v Lazaruse vpredu - ak je skryté, stlačíme kláves F12, aby sa dostalo navrch
  • z palety komponentov klikneme na komponent, ktorý budeme chcieť položiť do formulára - keďže paleta má viac záložiek s menami, napr. Standard, Additional, System a pod. - niekedy musíme najprv zvoliť správnu skupinu a až potom kliknúť na komponent
  • takže začíname komponentom tlačidlo - jeho názov je TButton a nachádza sa v štandardnej záložke palety - v palete má tvar malého tlačidla s textom OK - kliknite na tento komponent
  • kliknite niekde do formulára - objaví sa tu tlačidlo s popisom Button1
    • toto tlačidlo môžete presunúť na ľubovoľnú pozíciu, prípadne mu zmeniť veľkosť ťahaním za čierne štvorčeky
    • veľmi jednoducho zmeníme aj popis na tlačidle: všimnite si, že keď je naše nové tlačidlo označené (má okolo seba čierne štvorčeky), v Inšpektore objektov sú nejaké informácie, ktoré sa týkajú práve tohto tlačidla. Inšpektor sa skladá z dvoch stĺpcov: ľavý obsahuje meno nejakého nastavenia (napr. Caption označuje popis na tlačidle) a v príslušnom pravom je momentálna hodnota (teraz je tam Button1) - informácie v pravom stĺpci môžeme meniť a tým sa bude meniť vzhľad tlačidla a niekedy aj jeho správanie
    • zmeňte v Inšpektore nastavenie Caption na text, napr. Tlačidlo - zároveň sa zmenil popis na tlačidle
  • vytvorte na formulári viac tlačidiel rôznych rozmerov, zmeňte im popisy a vyskúšajte, ako sa správajú, keď takúto aplikáciu spustíme (F9)
  • ak potrebujete nejaké tlačidlo z formulára odstrániť, stačí aby bolo označené (kliknite naň) a stlačte kláves Del

položili sme komponent TButton do formulára

premenovali sme text na tlačidle

pridali sme ďalšie tlačidlá

spustili sme program


Priradenie akcií ku tlačidlám


Program s tlačidlami je už zaujímavejší, ako čisté okno, ale tlačidlá zatiaľ nerobia žiadne akcie. Každé tlačidlo môže mať priradenú nejakú akciu, ktorá sa spustí, keď naň počas behu programu klikneme - spustí sa zakaždým, keď naň klikneme. Priradenie akcie sa robí nasledovne:

  • na dané tlačidlo vo formulári dvojklikneme (nech to bolo tlačidlo Button1)
  • objaví sa editovacie okno, v ktorom sú automaticky pripísané tieto riadky:
procedure TForm1.Button1Click(Sender: TObject);
begin
 
end;
  • pre nás je dôležité si všimnúť slovo Button1Click - toto označuje, že to čo naprogramujeme medzi slová begin a end sa spustí vždy, keď sa klikne na tlačidlo Button1

Pre otestovanie tlačidiel sa naučíme jednoduchý príkaz na zmenu popisu na tlačidle:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Button1.Caption := 'zmena';
end;

Program spustíme (F9) a keď naňho teraz klikneme myšou, jeho popis sa zmení na slovo zmena. Ak máme v programe viac tlačidiel, každému môžeme naprogramovať inú akciu - dvojkliknutím sa predpripraví časť programu, do ktorej dopíšeme nové akcie. Ďalším jednoduchým príkazom je volanie štandardnej procedúry Close - spôsobí zatvorenie našej aplikácie a teda koniec programu, napr.

procedure TForm1.Button2Click(Sender: TObject);
begin
  Close;
end;

POZOR! ak chceme akciu na tlačidle zrušiť, najlepšie je zmazať len obsah príslušnej procedúry, t.j. len príkazy medzi begin a end - najbližšie uloženie projektu (napr. Ctrl+S), takéto zbytočné konštrukcie korektne odstráni.

Kompletný Unit1.pas teraz vyzerá takto:

unit Unit1;
 
{$mode objfpc}{$H+}
 
interface
 
uses
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, StdCtrls;
 
type
 
  { TForm1 }
 
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { private declarations }
   public
    { public declarations }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.lfm}
 
{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  Button1.Caption := 'zmena';
end;
 
procedure TForm1.Button2Click(Sender: TObject);
begin
   Close;
end;
 
end.

Pozrite si Inšpektor objektov, ktorý pre tlačidlá ale aj pre iné typy komponentov poskytuje veľa rôznych nastavení, napr. Left označuje X-ovú súradnicu uloženia komponentu, Top je Y-ová súradnica, Caption je text na komponente a pod.. Tieto aj iné nastavenia môžete meniť v programe. Poexperimentujte s nimi.

Do formuláru vložte komponent TLabel - jednoduchý text a v Inšpektore objektov mu zmeňte nastavenie Caption - zobrazený text, napr. na slovo Pascal. Pre tlačidlo Button1 vo formulári zadajte

procedure TForm1.Button1Click(Sender: TObject);
begin
  Button1.Left := 0;
  Label1.Top := 0;
end;

Zatlačenie tohto tlačidla počas behu aplikácie prisunie samotné tlačidlo k ľavému okraju (Left = 0) a jednoduchý text sa prisunie k hornému okraju (Top = 0). Neskôr by ste mohli rozumieť, čo by sa udialo pri stláčaní druhého tlačidla, keby ste zadali:

procedure TForm1.Button2Click(Sender: TObject);
begin
  Button1.Left := Button1.Left + 5;
  Label1.Top := Label1.Top + 5;
end;


Grafická plocha (Image)

Na kreslenie budeme najčastejšie používať komponent Image, ktorému budeme hovoriť grafická plocha. Komponent nájdeme na záložke palety komponentov Additional, vložíme ho do formulára a čo najviac roztiahneme. Tento komponent dostal meno Image1 (podobne ako tlačidlá dostali mená Button1, Button2, ... a texty Label1, Label2, ...). Keď budeme chcieť kresliť do tejto grafickej plochy, budeme musieť uvádzať meno komponentu, t.j. Image1, za ktorý budeme musieť písať aj slovo Canvas. Canvas označuje tzv. plátno, na ktoré sa fyzicky kreslí (niečo ako reálne obrazy, ktoré sa skladajú z rámu a plátna a väčšinou sa kreslí práve na plátno). Kresliť do grafickej plochy budeme zadávaním súradníc nejakých vrcholov. Súradnicová sústava je ale orientovaná inak, ako ju poznáme z matematiky - y-ová os je otočená smerom nadol a smerom nahor od 0 sú záporné hodnoty. Ľavý horný vrchol (pixel) má súradnice (0, 0). Ak by sme predpokladali, že grafická plocha má rozmery presne 300x200, tak pravý horný vrchol má súradnice (299, 0), ľavý dolný (0, 199) a pravý dolný (299, 199). Samozrejme toto závisí od momentálnej veľkosti grafickej plochy, ktorú sme nastavili vo formulári, prípadne v Inšpektore objektov.

S grafickou plochou budeme pracovať pomocou grafických príkazov a rôznych nastavení nástrojov. Pre nás sú dôležité tieto nástroje grafickej plochy:

  • grafické pero (Pen), ktoré hoci nevidíme, ale sa presúva po ploche a kreslí rôzne čiary; peru budeme nastavovať jeho hrúbku (Width) a farbu (Color); pri štarte programu je hrúbka pera 1 a farba je čierna,
  • štetec (Brush), ktorý slúži na automatické vyfarbovanie nejakých útvarov, napr. obdĺžnikov a elíps; štetcu budeme nastavovať jeho farbu (Color), resp. ho budeme môcť vypnúť pomocou zmeny režimu (Style); pri štarte programu je farba štetca biela,
  • písmo (Font), slúži pre príkazy, ktoré vypisujú texty do grafickej plochy; budeme môcť meniť meno fontu (Name), jeho veľkosť (Height) a farbu (Color).


TextOut - výpis textu


Naše prvé programy, ktoré budú kresliť do grafickej plochy, budeme navrhovať tak, že okrem grafickej plochy (Image1), sem vložíme tlačidlo (neskôr aj viac tlačidiel) a naprogramujeme akcie, ktoré sa vykonajú pri zatlačení tlačidla. Začneme príkazom TextOut, ktorý vypíše nejaký text do grafickej plochy. Všimnite si, že príkazy pre grafickú plochu začínajú slovami Image1.Canvas, za tým nasleduje znak bodka a až potom je samotné meno príkazu. Tento príkaz má tri parametre, ktoré musia byť uzavreté v zátvorkách. Prvé dva parametre určujú súradnice, kde sa bude text vypisovať, v našom príklade (50, 100). Tretí parameter musí byť nejaký text, ktorý uzatvárame do apostrofov, v našom príklade je to 'programujeme v Pascale'. Po spustení programu a zatlačení tlačidla dostávame:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.TextOut(50, 100, 'programujeme v Pascale');
end;

{{{3}}}

{{{3}}}

Prvý obrázok ukazuje, ako vyzeral program ešte pred zatlačením tlačidla, druhý po zatlačení, teda po spustení akcie Button1Click. Vidíme, že celá grafická plocha je zrazu čierna okrem obdĺžnika pod samotným textom. Zapamätajte si, že grafická plocha sa pri prvom použití (u nás príkazom TextOut) automaticky zafarbí na čierno. Toto sa nám bude hodiť veľmi zriedka, tak je výhodné grafickú plochu ešte pred prvým použitím vyčistiť na bielo. My to budeme najčastejšie robiť pri inicializácii programu v špeciálnej na to určenej procedúre FormCreate. Táto procedúra, keď je definovaná, sa automaticky vykoná ešte pred samotným zobrazením okna nášho bežiaceho programu, a môžeme sam dať rôzne inicializačné akcie. Prázdnu procedúru FormCreate nám pripraví Lazarus, keď dvojklikneme do formulára ale mimo komponentov Image1 a Button1. Do tela procedúry zapíšeme príkaz FillRect na zmazanie grafickej plochy. Keď program spustíme teraz, tak vidíme biele pozadie grafickej plochy:

procedure TForm1.FormCreate(Sender: TObject);
begin
  Image1.Canvas.FillRect(Image1.ClientRect);
end;

{{{3}}}

Nastavenia písma (Font) pre príkaz TextOut budeme zapisovať podobne, ako sme menili nastavenia pre tlačidlá a texty. Zápísy teraz budú trochu dlhšie. Veľkosť písma zmeníme priradením do nastavenia Height a farbu priradením do Color:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.TextOut(50, 50, 'programujeme v Pascale');
  Image1.Canvas.Font.Height := 30;
  Image1.Canvas.TextOut(150, 100, 'Lazarus');
  Image1.Canvas.Font.Color := clRed;
  Image1.Canvas.TextOut(150, 150, 'FreePascal');
end;

{{{3}}}

{{{3}}}

Použili sme tu nastavenie farby textu (Color) a priradili sme farbu clRed. Pascal ponúka niekoľko preddefinovaných farieb (mená sú identifikátory preddefinovaných konštánt), neskôr sa naučíme vytvárať ľubovoľnú farbu. V nasledujúcej tabuľke je uvedených niekoľko najčastejšie používaných farieb:

clRed červená clBlack čierna
clBlue modrá clWhile biela
clGreen zelená clGray šedá
clYellow žltá clSilver strieborná
clNavy námornícká modrá clOlive olivová
clMaroon hnedá clTeal modrozelená
clAqua azúrová clLime limetková
clPurple fialová clFuchsia svetlofialová

Každé nastavenie začne fungovať na všetky za tým nasledujúce príkazy. Nastavenia sa pamätajú, aj keď procedúra Button1Cllick skončí a zavoláme ju znovu, t.j. znovu stlačíme tlačidlo. Efekt po znovu stlačení tlačidla je vidieť na druhom obrázku.


Rectangle - obdĺžnik


Ďalším grafickým príkazom je Rectangle na kreslenie obdĺžnika. Príkaz má štyri číselné parametre, ktoré vyjadrujú súradnice nejakých dvoch protiľahlých vrcholov obdĺžnika:

  Image1.Canvas.Rectangle(x1, y1, x2, y2);

Príkaz nakreslí obdĺžnik, ktorého strany sú rovnobežné so súradnicovými osiami. Dĺžky strán sú potom zrejme Abs(x1-x2) a Abs(y1-y2), kde Abs je absolútna hodnota. Príklad ukazuje dva rovnako veľké obdĺžniky.

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Rectangle(50, 30, 230, 110);
  Image1.Canvas.Rectangle(80, 125, 260, 205);
end;

{{{3}}}

Keby sa obdĺžniky prekrývali, tak neskôr kreslený prekrýva už ten skôr nakreslený, keďže obdĺžniky sa kreslia s bielou výplňou (štetec Brush má zatiaľ nastavenú bielu farbu výplne). V príklade vidíme dve dvojice prekrývajúcich sa obdĺžnikov:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Rectangle(50, 30, 230, 110);
  Image1.Canvas.Rectangle(60, 70, 240, 150);
  Image1.Canvas.Rectangle(250, 100, 290, 200);
  Image1.Canvas.Brush.Color := clBlue;
  Image1.Canvas.Rectangle(80, 160, 280, 190);
end;

{{{3}}}

Zároveň vidíme zmenu farby výplne. Použili sme na to opäť priraďovací príkaz, v ktorom do nastavenia farby (Color) pre štetec (Brush) grafickej plochy (Image1) priradíme napr. modrú farbu (clBlue).

Obdĺžniky sa kreslia grafickým perom (Pen), ktoré má počiatočné nastavenie hrúbky 1 a čiernu farbu. Tieto nastavenia môžeme tiež zmeniť priraďovacími príkazmi:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Pen.Color := clGreen;
  Image1.Canvas.Pen.Width := 20;
  Image1.Canvas.Brush.Color := clYellow;
  Image1.Canvas.Rectangle(80, 80, 180, 180);
end;

{{{3}}}

Program nakreslil farebný štvorec so stranou 100.

Ukázali sme, že je vhodné nastaviť biele pozadie grafickej plochy hneď pri inicializácii (v procedúre FormCreate). Niekedy sa nám zíde vyčistenie plochy buď ako súčasť akcie na tlačidle, alebo ako samostatné tlačidlo. Vtedy je vhodné nastaviť farbu štetca (Brush) na bielo, alebo aj nejakú inú farbu, napr.

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Brush.Color := clSilver;
  Image1.Canvas.FillRect(Image1.ClientRect);
end;

Môžete vyskúšať namiesto FillRect napísať Rectangle - grafická plocha teraz dostáva rámik.


Ellipse - elipsa


Elipsy a kruhy, kreslíme pomocou grafického príkazu Ellipse. Jeho štyri parametre majú podobný význam, ale inú interpretáciu: elipsa sa kreslí ako vpísaná elipsa do obdĺžnika zadaného dvoma vrcholmi. Ak elipsu vpisujeme do štvorca, dostávame kruh. Príklad ilustruje kreslenie elipsy a štvorca, pričom môžeme vidieť aj príslušný obdĺžnik:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Pen.Color := clSilver;
  Image1.Canvas.Rectangle(20, 80, 180, 150);
  Image1.Canvas.Pen.Color := clRed;
  Image1.Canvas.Ellipse(20, 80, 180, 150);
  Image1.Canvas.Pen.Color := clBlack;
  Image1.Canvas.Rectangle(200, 120, 270, 190);  // štvorec
  Image1.Canvas.Brush.Color := clYellow;
  Image1.Canvas.Ellipse(200, 120, 270, 190);    // kruh
end;

{{{3}}}


MoveTo, LineTo - kreslenie čiar


Dvojicu príkazov MoveTo a LineTo ukážeme na tomto príklade:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Pen.Width := 10;
  Image1.Canvas.MoveTo(100, 200);
  Image1.Canvas.LineTo(100, 50);
  Image1.Canvas.MoveTo(150, 100);
  Image1.Canvas.LineTo(50, 100);
end;

{{{3}}}

Príkaz MoveTo presunie grafické pero (už poznáme nastavenia grafického pera Pen, napr. Color a Width) na zadané súradnice, v našom prípade do bodu (100, 200) - toto presúvanie sa robí so "zdvihnutým perom" t.j. sa nič nekreslí. Ďalej príkaz LineTo presunie toto pero na novú pozíciu, teda (100, 50), ale teraz už so "spusteným perom", teda sa naozaj kreslí úsečka so nastavenou hrúbkou (Width) a farbou (Color). Ďalšia dvojica príkazov MoveTo a nakreslí druhú úsečku.

Grafické pero si vždy pamätá svoju momentálnu pozíciu a preto, ak za príkazom LineTo ide znovu ďalší LineTo, ďalšie úsečka naväzuje na koniec predchádzajúcej. Ak by sme v predchádzajúcom príklade vyhodili druhý príkaz MoveTo, nakreslené úsečky by vyzerali inak. Ukážeme, že niekedy sa nám môže hodiť, keď pre nejaký riadok nechceme, aby sa vykonal, ale chceme si ho napr. pre názornosť uchovať. Takýto riadok zakomentujeme, čo umožní, aby v programe ostal, ale sa nevykonal. Použijeme dve lomky //, ktoré označujú, že zvyšok riadka sa ignoruje (je to tzv. komentár). Komentármi budú často aj dôležité texty, ktoré môžeme vkladať na niektoré miesta programu. Pozmenený program so zakomentovaným riadkom:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Pen.Width := 10;
  Image1.Canvas.MoveTo(100, 200);
  Image1.Canvas.LineTo(100, 50);
  // Image1.Canvas.MoveTo(150, 100);
  Image1.Canvas.LineTo(50, 100);
end;

{{{3}}}


Line - úsečka


Dvojicu príkazov MoveTo a LineTo môžeme zapísať aj jedným príkazom Line, ktorý má 4 celočíselné parametre - súradnice dvoch koncových bodov úsečky. Ukazuje to príklad, ktorý kreslí obe uhlopriečky nejakého obdĺžnika:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Rectangle(50, 100, 250, 200);
  Image1.Canvas.Line(50, 100, 250, 200);
  Image1.Canvas.Line(50, 200, 250, 100);
end;

{{{3}}}

Príkaz Line má ešte jedno užitočné použitie. Pomocou neho môžeme kresliť bodky rôznych veľkostí: od 1 až po kruhy s ľubovoľným priemerom. Keď budeme kresliť úsečku dĺžky 1, nakreslí sa len jedna bodka tejto úsečky. Ukazuje to tento príklad:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Pen.Color := clGreen;
  Image1.Canvas.Pen.Width := 1;
  Image1.Canvas.Line(50, 100, 51, 100);
  Image1.Canvas.Pen.Width := 8;
  Image1.Canvas.Line(100, 100, 101, 100);
  Image1.Canvas.Pen.Width := 60;
  Image1.Canvas.Line(150, 100, 151, 100);
end;

{{{3}}}


Polygon - vyfarbený útvar


Zoznámime sa ešte s jedným grafickým príkazom, pomocou ktorého môžeme vyplniť farbou ľubovoľný útvar, ktorý popíšeme postupnosťou vrcholov. Príkaz Polygon ako parameter dostáva postupnosť nejakých vrcholov. Každý vrchol tu musí byť zadaný konštrukciou Point(x, y) a celá postupnosť musí byť ešte uzavretá v hranatých zátvorkách. Nasledujúci príklad nakreslí trojuholník:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Brush.Color := clTeal;
  Image1.Canvas.Polygon([Point(50, 100), Point(150, 30), Point(200, 170)]);
end;

{{{3}}}

Môžeme vidieť, že na nakreslenie trojuholníka sme zadali tri vrcholy, pričom tento príkaz automaticky uzavrel tento útvar, t.j. spojil prvý vrchol s posledným. Ďalší príklad ukazuje, že je dôležité aj poradie vrcholov:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Brush.Color := clTeal;
  Image1.Canvas.Polygon([Point(20, 50), Point(120, 60), Point(110, 160), Point(10, 150)]);
  Image1.Canvas.Brush.Color := clAqua;
  Image1.Canvas.Polygon([Point(150, 50), Point(240, 160), Point(250, 60), Point(140, 150)]);
end;

{{{3}}}


Zhrnutie grafických príkazov


Zhrnieme všetky grafické príkazy, s ktorými sme sa už zoznámili, resp. ich doplníme o niekoľko ďalších základných. Vo všetkých príkazoch predpokladáme, že začínajú napr. Image1.Canvas.

Nastavenie pera a štetca:

Pen.Color := clRed;         // ďalšie farby sú, napr. clBlack, clGreen, clBlue, clYellow, clWhite ...
Pen.Width := 3;             // hrúbka pera od 1 vyššie
Pen.Style := psSolid;       // typ čiary - rôzne bodkované a čiarkované čiary, napr. psDash, psDot, ...
Brush.Color := clWhite;     // farba výplne
Brush.Style := bsSolid;     // štýl výplne, užitočný je bsClear - žiadna výplň, ďalšie sú napr. bsVertical, bsHorizontal, ...

Kreslenie čiar a útvarov:

MoveTo(x, y);               // presunie pero bez kreslenia čiar
LineTo(x, y);               // od momentálnej pozície pera kreslí úsečku do bodu (x, y)
Line(x1, y1, x2, y2);       // kreslí úsečku  z bodu (x1, y1) do bodu (x2, y2)
Rectangle(x1, y1, x2, y2);  // obdĺžnik - teda aj štvorec
Ellipse(x1, y1, x2, y2);    // elipsa a teda aj kruh - parametre sú ako pri obdĺžniku a znamenajú elipsu vpísanú do obdĺžnika

Zmazanie plochy:

FillRect(obdĺžnik);         // obdĺžnik zmaže farbou štetca

Písanie textov do grafickej plochy:

TextOut(x, y, 'text');      // text v apostrofoch vypíše od súradnice (x, y) - písmo sa dá nastaviť pomocou Font
Font.Height := 20;          // veľkosť písma
Font.Name := 'Arial';       // meno fontu
Font.Color := clRed;        // farba písma
Font.Style := [fsBold];     // do hranatých zátvoriek sa vymenujú atribúty písma - napr. aj fsItalic, fsUnderline


Náhodné čísla

Na experimentovanie s programami nám veľmi pomôže funkcia Random. Pomocou nej sa generujú tzv. pseudonáhodné čísla. Funkcia má jeden celočíselný parameter, ktorý určuje veľkosť množiny hodnôt, z ktorej sa má náhodne vybrať jedna hodnota. Napríklad volanie Random(6) vyberie jednu z hodnôt zo 6-prvkovej množiny {0, 1, 2, 3, 4, 5} – môžeme si to predstaviť tak, že počítač si zoberie hraciu kocku, na ktorej sú čísla od 0 do 5 a vždy, keď od neho chceme nejakú náhodnú hodnotu Random(6), tak si hodí touto kockou a vráti nám to číslo, ktoré padlo na tejto kocke. Zrejme, keď túto funkciu zavoláme viackrát, tak počítač môže dávať rôzne výsledky.

Ukážeme to na tomto príklade. Na stlačenie tlačidla počítač vyberie nejaké dve náhodné čísla X a Y. Prvé z intervalu <0, 299> a druhé z intervalu <0, 199> (predpokladáme, že grafická plocha má rozmery aspoň 300x200). Potom nakreslí úsečku z ľavého dolného rohu do tohto náhodne vybraného bodu (X, Y).

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.MoveTo(0, 200);
  Image1.Canvas.LineTo(Random(300), Random(200));
end;

{{{3}}}

{{{3}}}

Prvý obrázok ukazuje grafickú plochu, keď tlačidlo Button1 zatlačíme veľakrát. Druhý obrázok ukazuje ako sa zmenil tento obraz, keď sme zakomentovali prvý riadok s príkazom MoveTo - v programe ostal len jeden príkaz LineTo.

Nasledovný program kreslí náhodné úsečky, ale pritom im mení aj hrúbku. Hrúbka je teraz náhodné číslo od 3 do 10. Keďže Random vie generovať náhodné čísla len od 0, tak my ho zavoláme ako Random(8), ten vyrobí náhodné číslo od 0 do 7 a k tomu ešte pripočítame číslo 3, teda takto dostaneme náhodné číslo od 3 do 10:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Pen.Width := Random(8) + 3;
  Image1.Canvas.Line(Random(300), Random(200), Random(300), Random(200));
end;

{{{3}}}

Nasledovný program kreslí náhodné obdĺžniky. Obrázok ukazuje stav grafickej plochy po niekoľkých stlačeniach tlačidla.

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Rectangle(Random(300), Random(200), Random(300), Random(200));
end;

{{{3}}}

Ak by sme chceli využiť túto ideu na kreslenie náhodných kruhov veľkosti 20, zistíme, že takto sa to nedá:

procedure TForm1.Button1Click(Sender: TObject);
begin
  Image1.Canvas.Ellipse(Random(300), Random(200), Random(300) + 20, Random(200) + 20);
end;

{{{3}}}

Pravdepodobnosť, že medzi týmito elipsami je kruh veľkosti 20 je veľmi malá. Tu by sme potrebovali napr. nejako si zapamätať prvé dve náhodné čísla (súradnice prvého vrchola) a ďalšie dve by potom boli rovnaké ako tieto zapamätané prvé dve plus číslo 20. Na toto už budeme potrebovať premenné.


Celočíselné premenné

V programovaní pojem premenná označuje pamäťové miesto na ukladanie nejakých hodnôt. Väčšinou má každá premenná svoje meno - hovoríme mu identifikátor premennej. Najčastejšie budeme s premennými pracovať takto

  1. premennú musíme zadeklarovať, t.j. počítaču oznámime, že bude treba vyhradiť nové pamäťové miesto pre našu premennú,
  2. do premennej môžeme priradiť nejakú hodnotu pomocou priraďovacieho príkazu; kým sa do premennej ešte nič nepriradilo, hovoríme, že premenná má nedefinovanú hodnotu,
  3. premennej môžeme zmeniť jej zapamätanú hodnotu tým, že do nej priradíme niečo ďalšie; v premennej sa pamätá vždy iba posledne priradená hodnota,
  4. z premennej môžeme zistiť jej momentálnu hodnotu tým, že jej identifikátor použijeme ako parametre alebo v nejakých aritmetických výrazoch.

Neskôr uvidíme, že do premennej vieme priradiť nejakú hodnotu aj inak ako v priraďovacom príkaze.


Deklarácia premennej


V Pascale musíme každú premennú zadeklarovať, t.j. špeciálnym spôsobom kompilátoru oznámiť jej meno (identifikátor) a typ (tým určíme veľkosť vyhradeného pamäťového miesta). Zatiaľ sa naučíme deklarovať len celočíselné premenné, t.j. také, do ktorých sa budú ukladať 32-bitové celé čísla. Kompilátor vie, že bude musieť vyhradiť pre takúto premennú 4 bajty. Premenné deklarujeme v programe v časti medzi hlavičkou procedúry (riadok začínajúci procedure) a telom procedúry (telo procedúry sú príkazy medzi begin a end). Takto deklarované premenné majú platnosť pre toto telo procedúry a iná procedúra môže mať svoje ďalšie premenné (hoci aj s rovnakým menom).

Identifikátor premennej je nejaká postupnosť písmen a číslic, ktorá musí začínať písmenom. Často budú identifikátory len jednopísmenové. V Pascale platí dohoda, že identifikátory začínajú veľkým písmenom. Hoci v Pascale sa v identifikátoroch nerozlišujú malé a veľké písmená, odporúčame používať rovnaké zápisy premennej v celej procedúre ako je to v deklarácii. Identifikátor premennej by mal byť rôzny od všetkých rezervovaných slov Pascalu. V zdrojovom kóde programu ich vidíme vypísané tučným písmom, napr. procedure, begin, end, var, uses, unit, ... Už pri písaní programu budeme vidieť, či sme nezvolili vadný identifikátor, lebo editor nám takéto slovo vypíše tučným písmom.

Deklarácie premenných začínajú slovom var (z anglického variable, teda premenná). Za tým nasleduje identifikátor novej premennej, za tým dvojbodka a slovo Integer. Táto deklarácia je ukončená bodkočiarkou rovnako ako všetky príkazy v Pascale. Integer označuje, že to bude celočíslená premenná. Neskôr uvidíme aj iné typy premenných.

Uvádzame správne aj nesprávne deklarácie premenných:

var             // správne zápisy
  Pocet: Integer;
  X, Y, Pomoc2: Integer;
  Dlzka, D1zka: Integer; // prvý je D L Z K A, druhý je D jedna L Z K A - teda sú rôzne
  OO, O0: Integer;       // prvý je o o, druhý je o nula
  Prvy_rok: Integer;     // aj znak podčiarkovník je povolený
 
var             // chybné zápisy
  3rok: Integer;         // začína číslicou
  Do, To, Of: Integer;   // všetko sú to rezervované slová
  Dĺžka: Integer;        // obsahuje písmená s diakritikou
  Prvy rok: Integer;     // medzera je zakázaná
  Abc, AbC: Integer;     // všetky identifikátory musia byť navzájom rôzne

Všimnite si, že ak zvolíme nevhodné názvy premenných, budeme ich v programe veľmi ťažko rozlišovať, napr. dvojica OO a O0.



Priraďovací príkaz


Priraďovací príkaz už poznáme z predchádzajúcich častí, lebo sme pomocou neho menili hodnoty nastavení. Napr.

  Button1.Caption := 'zmena';
  Image1.Canvas.Pen.Width := Random(8) + 3;
  Image1.Canvas.Brush.Color := clTeal;
  

Na ľavej strane priraďovacieho príkazu je buď nejaké nastavenie (napr. Button1.Caption) alebo tu môže byť už nejaká zadeklarovaná premenná. Na pravej strane priraďovacieho príkazu je nejaká hodnota, ale môže tu byť aj nejaký aritmetický výraz, ktorý sa bude musieť najprv vypočítať (napr. Random(8) + 3). Priraďovací príkaz teda najprv zistí hodnotu pravej strany príkazu (prípadne vykoná požadovaný výpočet) a potom túto hodnotu priradí do nastavenia alebo premennej. Pôvodná hodnota premennej sa v tom momente "zabudne" a nahradí sa touto novou hodnotou. Napr.

var
  A, B: Integer;
begin                   //    A = ?   B = ?
  A := 23;              //    A = 23  B = ?
  B := A + 8;           //    A = 23  B = 31
  A := A * 2;           //    A = 46  B = 31
  ...
  

V komentároch vidíme, že na začiatku programu (riadok s begin) majú obe premenné nedefinovanú hodnotu. Postupne každý priraďovací príkaz zmení hodnotu jednej premennej.

Teraz by sme už mali vedieť naprogramovať nakreslenie kruhu na náhodnej pozícii. Najprv kruh na konkrétnom mieste:

procedure TForm1.Button1Click(Sender: TObject);
var
  X, Y: Integer;
begin                       //    X = ?    Y = ?
  X := 150;                 //    X = 150  Y = ?
  Y := 100;                 //    X = 150  Y = 100
  Image1.Canvas.Ellipse(X, Y, X + 20, Y + 20);
end;

{{{3}}}

A teraz na náhodných pozíciách (ak zatlačíme tlačidlo viackrát, nakreslia sa kruhy na rôznych miestach):

procedure TForm1.Button1Click(Sender: TObject);
var
  X, Y: Integer;
begin
  X := Random(300);
  Y := Random(200);
  Image1.Canvas.Ellipse(X, Y, X + 20, Y + 20);
end;

{{{3}}}

Trochu program vylepšíme: nakreslia sa tesne vedľa seba dva kruhy veľkosti 20 - jedne modrý druhý červený:

procedure TForm1.Button1Click(Sender: TObject);
var
  X, Y: Integer;
begin
  X := Random(300);
  Y := Random(200);
  Image1.Canvas.Brush.Color := clBlue;
  Image1.Canvas.Ellipse(X, Y, X + 20, Y + 20);
  Image1.Canvas.Brush.Color := clRed;
  Image1.Canvas.Ellipse(X + 20, Y, X + 40, Y + 20);
end;

{{{3}}}

Teraz predpokladajme, že v tomto programe potrebujeme zmeniť veľkosť kruhov, napr. na 30. Je výhodné to prepísať tak, aby bolo neskôr veľmi jednoduché opäť zmeniť veľkosť na nejakú inú hodnotu. Mohli by sme na to použiť ďalšiu premennú, napr. Vel, v ktorej by bola uložená veľkosť kruhu. Namiesto premennej tu ukážeme, ako môžeme využiť pomenované konštanty:

procedure TForm1.Button1Click(Sender: TObject);
const
  Vel = 30;
var
  X, Y: Integer;
begin
  X := Random(300);
  Y := Random(200);
  Image1.Canvas.Brush.Color := clBlue;
  Image1.Canvas.Ellipse(X, Y, X + Vel, Y + Vel);
  Image1.Canvas.Brush.Color := clRed;
  Image1.Canvas.Ellipse(X + Vel, Y, X + 2 * Vel, Y + Vel);
end;

{{{3}}}

Konštanta Vel sa správa podobne ako premenná, len sa do nej priraďuje hodnota v deklaráciách a v programe sa už meniť nedá.

V predchádzajúcich programoch sme predpokladali, že grafická plocha má rozmery aspoň 300x200 a preto aj náhodné body sme generovali ako Random(300) a Random(200). Skutočná šírka a výška plochy sa ale zisťuje veľmi ľahko a vďaka tomu lepšie zvládneme rozložiť naše kresby. Šírku grafickej plochy vieme zistiť pomocou Image1.Width a výšku pomocou Image1.Height. Napíšme program, ktorý vygeneruje kruh s náhodným polomerom R od 20 do 50 a jeho pozícia bude tiež náhodná, ale taká, aby sa celý kruh zmestil do grafickej plochy. Do stredu každého kruhu ešte nakreslíme malú bodku. Všimnite si, ako pracujeme s funkciou Random:

procedure TForm1.Button1Click(Sender: TObject);
var
  X, Y, R: Integer;
begin
  R := Random(31) + 20;
  X := Random(Image1.Width - 2 * R) + R;
  Y := Random(Image1.Height - 2 * R) + R;
  Image1.Canvas.Ellipse(X - R, Y - R, X + R, Y + R);   // kruh so stredom (X, Y) a s polomerom R
  Image1.Canvas.Line(X, Y, X + 1, Y);                  // bodka v strede kruhu
end;

{{{3}}}



Výpis čísel do plochy


Doteraz sme do plochy vypisovali pomocou príkazu TextOut len nejaké texty. Tretí parameter tohto príkazu naozaj musí byť len text. Napr. tento program bude vypisovať text [X, Y], hoci radšej by sme možno chceli vidieť skutočné hodnoty premenných X a Y (napr. v tvare [123, 77]):

procedure TForm1.Button1Click(Sender: TObject);
var
  X, Y: Integer;
begin
  X := Random(Image1.Width);
  Y := Random(Image1.Height);
  Image1.Canvas.TextOut(X, Y, '[X, Y]');
end;

{{{3}}}

Ak by sme ako tretí parameter zapísali celočíselnú premennú X:

  Image1.Canvas.TextOut(X, Y, X);

program by sa nedal ani spustiť, lebo Pascal by hlásil nejakú chybu (tretí parameter TextOut je namiesto textu celé číslo). Na tieto účely máme pomocnú funkciu, ktorá prekonvertuje celé číslo na text, aby sa dal napr. vypísať. Funkcia IntToStr ľubovoľné číslo prevedie na textový tvar. Takže, ak chceme nejaké číslo (alebo premennú, alebo aritmetický výraz) vypísať pomocou TextOut, zapíšeme to takto:

  Image1.Canvas.TextOut(x, y, IntToStr(celočíslená hodnota));

Opravíme náš program a vidíme X-ové súradnice náhodne generovaných bodov:

procedure TForm1.Button1Click(Sender: TObject);
var
  X, Y: Integer;
begin
  X := Random(Image1.Width);
  Y := Random(Image1.Height);
  Image1.Canvas.TextOut(X, Y, IntToStr(X));
end;

{{{3}}}

Ak by sme chceli vidieť aj Y-ové súradnice, museli by sme použiť špeciálny spôsob zlepovania textov, napr. takto

  Image1.Canvas.TextOut(X, Y, IntToStr(X) + ' ' + IntToStr(Y));

My sa to ale naučíme robiť krajšie. Existuje ešte komplexnejšia funkcia, ktorá prevádza čísla na texty a pritom k nim vie pridať aj nejaké ďalšie texty (nám by sa hodili hranaté zátvorky a čiarka s medzerou). Funkcia Format je dosť zložitá a my sa tu zatiaľ naučíme len jej najjednoduchšie použitie. Má dva parametre. Prvý je text, ktorý obsahuje ľubovoľné znaky plus zástupcov pre celočíselné hodnoty: %d. Druhým parametrom je postupnosť celočíselných hodnôt (v hranatých zátvorkách) a tieto sa budú postupne vkladať do prvého textu. Samotné vkladanie bude na miesta, kde sa vyskytujú dvojice %d. Zrejme hodnôt v zozname musí byť rovnaký počet ako zástupcov %d. Ukážme jednoduché príklady:

  Format('X = ', [X])                    // ak X je 105, text: X = 105
  Format('mám %d euro', [3 * 7])         // text: mám 21 euro
  Format('%d + %d = %d', [A, B, A + B])  // ak A=3 a B=4 text: 3 + 4 = 7

Program teraz prepíšeme

procedure TForm1.Button1Click(Sender: TObject);
var
  X, Y: Integer;
begin
  X := Random(Image1.Width);
  Y := Random(Image1.Height);
  Image1.Canvas.TextOut(X, Y, Format('[%d, %d]', [X, Y]));
end;

{{{3}}}



Celočíselná aritmetika



Celé čísla (Integer) v počítači zaberajú 32-bitov, t.j. 4 bajty. To znamená, že celé čísla pokrývajú interval < –2 147 483 648, 2 147 483 647 > čo je približne + alebo - 231. S celými číslami sú definované tieto základné operácie:

  • +, -, * sú štandardné operácie pre súčet, rozdiel a súčin - ich výsledok by mal byť opäť v intervale celých čísel,
  • div je celočíselné delenie, zrejme sa nesmie deliť nulou,
  • mod je zvyšok po celočíselnom delení (napr. 23 mod 7 = 2).

Rovnako ako v matematike aj v programovacích jazykoch majú operácie násobenia a delenia (teda aj zvyšku) vyššiu prioritu ako sčitovanie a odčitovanie. Z toho vyplýva, že vo výraze 3 + 4 * 5 sa najprv vykoná násobenie a až potom sčitovanie. Výsledkom je zrejme 23. Ak chceme, aby sa výpočet vyhodnocoval mimo priorít operácií, treba použiť zátvorky, napr. (3 + 4) * 5.

Na nasledovnom príklade ukážeme použitie div a mod:

procedure TForm1.Button1Click(Sender: TObject);
var
  Cislo, Cislo2, Cifra: Integer;
begin
  Cislo := 15227;
  Cifra := Cislo mod 10;      // posledná cifra čísla Cislo
  Cislo2 := Cislo div 10;     // Cislo bez poslednej cifry
  Image1.Canvas.Font.Height := 40;
  Image1.Canvas.TextOut(10, 10, Format('%d = %d...%d', [Cislo, Cislo2, Cifra]));
end;

{{{3}}}

Program vypíše nejaké číslo a potom ho rozdelí na dve časti - bez poslednej cifry a zvlášť poslednú cifru.

Ďalší program počíta 12!

procedure TForm1.Button1Click(Sender: TObject);
var
  Cislo: Integer;
begin
  Image1.Canvas.Font.Height := 40;
  Cislo := 1 * 2  * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11 * 12;
  Image1.Canvas.TextOut(10, 10, Format('12! = %d', [Cislo]));
end;

{{{3}}}

Toto ešte funguje dobre, ale 13! bude robiť problémy. Spustenie buď vypíše chybný výsledok, alebo program spadne chybovou správou:

procedure TForm1.Button1Click(Sender: TObject);
var
  Cislo: Integer;
begin
  Image1.Canvas.Font.Height := 40;
  Cislo := 1 * 2  * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10 * 11 * 12;
  Image1.Canvas.TextOut(10, 10, Format('12! = %d', [Cislo]));
  Cislo := Cislo * 13;
  Image1.Canvas.TextOut(10, 80, Format('13! = %d', [Cislo]));
end;

{{{3}}}

{{{3}}}

Výsledok závisí od toho, či je vypnutá alebo zapnutá kontrola pretečenia celočíselnej aritmetiky. Ak je táto kontrola zapnutá, program po spustení spadne na chybovej správe. 13! je totiž väčšie číslo (6 227 020 800), ako sa dá uložiť do 32 bitov. Počítať odmietne vykonať príkaz Cislo := Cislo * 13 a vyhlási chybovú správu. Ešte horšie to dopadne, keď je kontrola vypnutá. Hoci vtedy dostaneme výsledok, a ten na prvý pohľad vyzerá možno aj dobre. Problém je v tom, že počítač vypíše úplný nezmysel a "tvári sa", že všetko je v poriadku. Tento príklad by mal ukázať, že je veľmi dôležité, aby mal kompilátor zapnuté kontroly, lebo inak môže dávať nezmyselné výsledky a my o tom ani nebudeme tušiť. Kontroly zapíname v menu Projekt v nastaveniach Voľby projektu ...

{{{3}}}


späť | ďalej