Řízení programu

Nyní se dáme do skutečného programování. Naučíme program rozhodovat se.

Nejjednodušším příkazem Pascalu je tzv. prázdný příkaz. Ten nedělá vůbec nic. Značí se samotným středníkem. Raději na příkladu:

Program PrazdnyPrikaz;
Begin
   ;;;;;;;;;;;;;;;;;;;
   ;;;
   ;;
   ;
End.

Tento program sice jde spustit, ale nic nedělá. Prázdný příkaz slouží totiž například k tomu, aby někteří tupci mohli psát středník za begin, kam evidentně nepatří. Ale od teďka - pozor na něj!

Druhým příkazem je tzv. příkaz složený. Ten začíná slovem begin a končí slovem end; (se středníkem!!!) Mezi tyto dvě slova pak můžeme vkládat další (třeba i složené) příkazy. Překladač hodnotí složený příkaz jako jeden jediný. (O tom, k čemu je to dobré, až za chvíli)
Nikdy se nám nesmí stát, že k beginu zapomeneme end; (v rozsáhlejších programech je to skoro neopravitelná chyba... - jde dopsat, jen když víte, kam s ním.) Pište tedy raději ke každému beginu end okamžitě, další příkazy dopisujte dodatečně mezi ně. Každý nový složený příkaz poněkud odsaďte. Ale raději na příkladu - aby nám bylo vše jasné:

Program SlozenyPrikaz;
Begin     {Tady začíná program}
   Begin  {První složený příkaz}
    Writeln('Zatím nejsme moc hluboko');
      Begin {Složený příkaz ve složeném příkaz (vnořený složený příkaz)}
       Writeln('Ale už se to noří');
         Begin
          Writeln('Pro dnešek to stačí');
         End;
      End;
   End;
   Begin {Druhý složený příkaz}
    Writeln('Ponor číslo 2');
   End;
 Readln;
End.      {Za tímhle endem je tečka, protože tu končí program}

Jak vidíte, je to pěkně nepřehledné. Abyste v tom udrželi pořádek, měli byste tedy dodržovat tato pravidla:

• Příslušný end přesně pod správným beginem a ostatní příkazy taky trochu odsadit (1 sloupec)
• Nový begin odsadit o 3 sloupce
• Složené příkazy stejného vnoření psát pod sebe

Nyní již víme vše, abychom mohli psát složitější programy.

Řízení programu lze rozdělit na dvě části - rozhodování a cykly. Rozhodování je jednodušší, takže jdeme na něj.

Nejdříve se naučíme vytvořit jednoduchou podmínku: K tomu slouží znaky (a dvojznaky) >, <, =, >=, <=, <>. (Větší, menší, rovná se, větší nebo rovno, menší nebo rovno, nerovná se).
Nejčastěji se pomocí podmínek testují proměnné.
Podmínka tedy vypadá třeba takto A = 5 Podmínka může být buď nastat (A je skutečně pět, kdo by to byl řekl) nebo nenastat (A je cokoliv jiného). V případě že je podmínka splněna, říkáme že je pravdivá, jinak je nepravdivá.

Nyní se podíváme na podmínky složené - ty vznikají z jednoduchých pomocí logických spojek.
Jednodušší podmínky pak ovšem musíme závorkovat!!!!
Tabulka logických spojek (jen těch nejjednodušších):

Pro úplnost uvedu i jejich český překlad (i když anglicky máte umět) : and = a současně, or=nebo.

A teď samotné rozhodování. To má tvar:

if Podmínka then Příkaz;

V případě, že je splněna podmínka, provede se příkaz.

Raději na příkladu
if 5=7 then Writeln('To jsem z toho jelen'); - Tak tohle neudělá vůbec nic
if (5+2)=7 then Writeln('Umím počítat'); - To už ten text napíše.
if (A=0) or (A<>0) then writeln('A tohle napíši vždy'); - Složené podmínky vždy závorkujte.

Všimněte si, že za then je jen jeden příkaz, pokud jich chceme víc, použijeme složený příkaz.

if A = 5 then
   begin
    TextColor(4);
    Writeln('A je pět a od teď je všechno červený');
   end;

Za then nemůžeme psát středník. Pascal by si myslel, že při splnění podmínky má vykonat prázdný příkaz. A nic by nedělal.

Občas potřebujeme rozhodnout, zda je podmínka splněna (a něco provést), či není (a v tom případě udělat něco jiného). Pak použijeme if Podmínka then Příkaz1 else Příkaz2; (za Příkaz1 není středník!) Příkaz1 se provede, je-li podmínka splněna; Příkaz2 se provede, pokud podmínka splněna není.

Poznámka: Podmínka Odd(A) je pravdivá, pokud je A liché; jinak je Odd(A) nepravda.
Tedy takto:
if Odd(A) then Writeln(A,' je liché') else Writeln(A, ' je sudé');

Pochopitelně pořád platí to o prázdných a složených příkazech.

Někdy se stane, že potřebujeme rozhodnout mezi více možnostmi. K tomu nám slouží příkaz case. Dejme tomu, že máme proměnnou A typu Integer a potřebuje zjistit, zda se rovná jedničce, dvojce, trojce, ... Názorná demonstrace:

case A of
   1: Writeln('Tak to mezi prvočísla nepatří');
   2: Writeln('Jediné sudé prvočíslo');
   3: Writeln('První liché prvočíslo');
   4: Writeln('První číslo složené');
   5: Writeln('Prvočíslo');
{else  Writeln('To je na mě moc velký :-)');}
end;

Proměnná, kterou testujeme (v našem případě A) smí být pouze typu char nebo Integer.
Za každou hodnotou, která nás zajímá napíšeme : Příkaz; (Zase jen jeden - chceme-li víc, použijeme složený příkaz).
Pokud za výčtem všech zajímavých hodnot napíšete else (Není povinné, a proto je v závorce), tak se daná (else) větev provede tehdy, když není nalezen odpovídající hodnota v daném seznamu. (Za else je zase jen jeden jediný příkaz)
case pak končí slovem end; (ke kterému nikde není begin!)

Tím máme rozhodování za sebou. Nastudujte to pořádně, a až tomu budete rozumět, pusťte se do čtení dalších řádků.

Další možností řízení programu jsou tzv. cykly. Nejdříve ty s pevným počtem opakování:

for Proměnná:=DelejOd to DelejDo do Příkaz;

(Proměnná je char nebo integer a DelejOd a DelejDo jsou pro proměnnou přípustné hodnoty...)
Ty dělají toto:
Obsah proměnné zvětšují od DelejOd do DelejDo a pokaždé provedou Příkaz. (Bacha na prázdný příkaz - neboť for I:=1 to 10 do ; provede 10x nic.) Raději si to vyzkoušejte sami:

Program Abeceda;
Var c:char;
Begin
 for c:='a' to 'z' do Writeln(c);
Readln;
End.

Pochopitelně vám nic nebrání použít proměnnou typu integer a for I:=1 to 100 do Writeln('Jsem prase');

Nyní si dáme trochu oddech. Podíváme se na náhodná čísla. Random(HorníMez) - vrátí náhodné celé (a dokonce nezáporné!) číslo od 0 do (HorníMez-1). Pokud bychom chtěli zajistit, že je číslo skutečně náhodné, musíme hned na začátek programu umístit příkaz Randomize;

Program Nahoda;
Begin
  Randomize;
  Writeln(Random(100));
  Readln;
End.

Zkuste ho párkrát bez Randomize a uvidíte, co se stane (to jsou ale náhodná čísla, co ?!!!:)

Vše si zopakujte a jdeme do finále!

Cyklus repeat ... until Podmínka;
Tento příkaz vypadá takto :
repeat
Příkaz1;
Příkaz2;
...
until Podmínka;
A co dělá? Vykoná příkazy tak, jak jdou za sebou. Pokud je na konci cyklu podmínka splněna, skončí, jinak opakuje všechny příkazy od repeat. (V cyklu bychom měli zajistit, že se podmínka někdy stane pravdivou, jinak se program zacykli (=zasekne) a budeme muset počítač restartovat.)
Raději na příkladu:

Soucet:=0; {Nebo můžete použít inicializovanou proměnnou}
repeat
  Writeln('Zadej číslo :');
  Readln(A);
  Soucet:=Soucet+A;
  Writeln('Součet je zatím :',Soucet);
until A=0;

Napište a spusťte, pak vám to bude snad jasné. (Malá nápověda, jakmile zadáte nulu, program skončí).

To by bylo pro dnešek vše.

Domácí úkol :

• Zopakujte si důkladně všechny minulé lekce
• Pochopte složený příkaz
• Snažte se nedávat středníky tam, kam nepatří
• Naučte se důkladně if then else
• Naučte se důkladně cykly
• Napište program, který dá uživateli deset jednoduchých příkladů z malé násobilky (v případě špatného výsledku pak napíše správný) a nakonec napíše, kolik uživatel udělal chyb a kolik měl zadáno příkladů (Použijte Random(10) a nezapomeňte na Randomize, rozvzpomeňte se na konstanty...)