Soubor přednášek

A,B : byte);
volání : Secti(X,Y); Secti (20, 30);
Kombinované – kombinace předchozích typů. Deklarace identifikátoru různých datových typů se oddělují středníkem.
Procedure Secti(var A,B : byte; Prumer : real); Program Pocitej2;
Uses CRT, DOS;
Var X,Y : byte; Z : integer;
Procedure Vstup_hodnot (var A,B : byte);
Begin
Write(“Zadejte hodnotu pro A,B : ”);
Readln(A,B);
End;
Function Obsah (A,B : byte) : integer;
Begin
Obsah := A*B;
End;
begin
Vstup_hodnot(X,Y);
Z := Obsah(X,Y);
End. Příklady podprogramů s parametry Program Pocitej1;
Uses CRT, DOS;
Var CisloA, CisloB : byte;
Procedure Obsah_Obdelniku (a,b : byte);
Begin
Writeln(“Obsah obdelníku je : ”, A*B);
End;
begin
Read(CisloA, CisloB);
Writeln(“První číslo je : “, CisloA);
Writeln(“Druhé číslo je : “, CisloB);
Obsah_Obdelniku(CisloA, CisloB);
End.
Příkaz IF Příkaz větvení – slouží k rozvětvení programu na dvě větve, přičemž při zpracování programu je použita pouze jedna větev a druhá je automaticky přeskočena
Dvě možnosti :
Neúplný příkaz IF
if then
Úplný příkaz IF
if then else
Příkaz IF se provádí následovně :
Program nejprve vyhodnotí booleovský výraz
Je-li výsledkem tohoto výrazu hodnota true, pak se provede příkaz, který následuje za slovem then
Je-li výsledkem tohoto výrazu hodnota false, pak se provede příkaz, který následuje za slovem else Příklady příkazu IF Jednoduchá přiřazení :
If CisloA CisloB then Writeln(‘Rozdilna cisla’);
If CisloA > 10 then Soucet := CisloA + CisloB;
If Znak = ‘*’ then Read(CisloA, CisloB) else Read(cilsoC);
Složená přiřazení :
If CisloA CisloB then
begin
Writeln(‘Prvni cislo je : ‘,CisloA);
Writen(’Druhe cislo je : ‘,CisloB);
Writeln(‘Rozdilna cisla’);
end;
If Znak = ‘*’ then
begin
Read(CisloA);
Read(CilsoB);
end
else Writeln(‘Nebyl zadan znak *’); Příklady příkazu IF If mesic = 1 then dny := 31 else
If mesic = 2 then dny := 28 else
If mesic = 3 then dny := 31 else
If mesic = 4 then dny := 30 else
If mesic = 5 then dny := 31 else
If mesic = 6 then dny := 30 else
If mesic = 7 then dny := 31 else
If mesic = 8 then dny := 31 else
If mesic = 9 then dny := 30 else
If mesic = 10 then dny := 31 else
If mesic = 11 then dny := 30 else
If mesic = 12 then dny := 31; Příklady příkazu IF If D < 0 then writeln(‘Kořeny jsou z oboru KČ’)
else if D = 0 then writeln(‘Koren1 = Koren2’)
else writeln(‘Koren1 Koren2’);
If (A < 10) and (A > 5) then writeln(‘6 - 9’)
else writeln(‘mimo 6 - 9’);
If (A = 5) then writeln(‘5 - 10’)
else writeln(‘mimo 5 - 10’);
If (X = ‘A’) or (X = ‘B’) then writeln(‘A nebo B’)
else writeln(‘ani A nebo B’); Příkaz CASE Příkaz větvení – slouží k rozvětvení programu na více než na dvě části, přičemž na základě podmínky program může využít pouze jednu z nich
Výběrová podmínka (selektor) určuje, která větev příkazu CASE se provede
Selektor musí být vždy ordinálního datového typu
Příkaz CASE může obsahovat nepovinnou větev ELSE
Hodnota selektoru i konstant (větve) nesmí být větší než na 2 Byte
Každá větev může být označena více konstantami Case mesic of
1..3 : writeln(‘1. kvartál’);
4..6 : writeln(‘2. kvartál’);
7..9 : writeln(‘3.kvartál’);
10..12 : writeln(‘4.kvartál’);
else writeln(‘-----’);
End; Case mesic of
12,1..3 : writeln(‘Zima’);
4,5 : writeln(‘Jaro’);
6..8 : writeln(‘Léto’);
9..11 : writeln(‘Podzim’);
else writeln(‘-----’);
End; Příklady příkazu CASE Case mesic of
1 : writeln(‘Leden’);
2 : writeln(‘Únor’);
3 : writeln(‘Březen’);
4 : writeln(‘Duben’);
5 : writeln(‘Květen’);
6 : writeln(‘Červen’);
7 : writeln(‘Červenec’);
8 : writeln(‘Srpen’);
9 : writeln(‘Září’);
10 : writeln(‘Říjen’);
11 : writeln(‘Listopad’);
12 : writeln(‘Prosinec’);
else writeln(‘-----’);
End; Příkaz FOR Příkaz cyklu – používá se tam, kde je striktně zadáno počet opakování cyklu
Zadáváme vždy počáteční hodnotu cyklu A a koncovou hodnotu cyklu B.
Počet opakování C je dán výrazem C = |B - A| + 1
Příkaz FOR má 2 varianty :
Vyhrazené slovo TO v případě, že A < B
Vyhrazené slovo DOWNTO v případě, že A > B
For A := 1 to 10 do ABC := A;
For A := 1 to 10 do POLE[A] := 1;
For A := 1 to 10 do POLE[A] := A;
For A := 1 to 10 do
Begin
Write(‘Zadejte ’,A,’.cislo : ’);
ReadLN(Pole[A]);
Write(‘Zadali jste cislo : ’,Pole[A]);
End;
Tento příklad názorně ukazuje rozdíl mezi použitím hodnotového a proměnného parametru podprogramu
Procedure Nacti_hodnoty_1 (A,B : integer)
má parametry hodnotové. Hodnoty těchto parametrů X, Y vstupují do výpočtu prostřednictvím parametrů A,B. Po ukončení podprogramu jsou hodnoty proměnných parametrů podprogramů A,B uvolněny z paměti a jejich hodnoty nejsou předány proměnným X,Y. Tato procedura se může volat s parametry coby identifikátor proměnné :
Nacti_hodnoty_1(X,Y);
Přičemž X a Y jsou proměnné deklarované již dříve nebo se procedura volá pomocí číselných konstant, které odpovídají příslušnému datovému typu přiřazenému parametrům procedury.
Nacti_hodnoty_1(55,69);
Procedure Nacti_hodnoty_2 (var A,B : integer)
má parametry proměnné. Hodnoty proměnných X,Y vstupují do výpočtu prostřednictvím parametrů procedury A,B. uvnitř podprogramu jsou A i B. Po vystoupení z podprogramu jsou nové hodnoty parametrů A,B předány proměnným X,Y Tato procedura se může volat pouze s parametry coby identifikátory proměnných :
Nacti_hodnoty_1(X,Y);
Způsob volání podprogramu (viz níže) je v tomto okamžiku nepřípustný a sytém zahlásí chybu, jelikož nové hodnoty proměnných A,B nemůže uložit do konstanty
Nacti_hodnoty_1(55,69); Program pokus2;

uses CRT, dos;

Var X,Y,O : integer;

Procedure Nacti_hodnoty_1(A,B : integer);
Begin
Write('Zadej hodnotu postupne pro A a B : ');
Readln(A,B);
{zadáme z klávesnice pro A hodnotu 20 a pro B hodnotu 30}
end;

Procedure Nacti_hodnoty_2(var A,B : integer);
Begin
Write('Zadej hodnotu postupne pro A a B : ');
Readln(A,B);
{zadáme z klávesnice pro A hodnotu 20 a pro B hodnotu 30}
end;

Function Vynasob(z,x : integer) : integer;
Begin
Vynasob := z*x;
end;


begin
X := 100;
Y := 50;
Nacti_Hodnoty_1(X,Y); {v X bude 100 a v Y bude 50}
Nacti_Hodnoty_2(X,Y); {v X bude 20 a v Y bude 30}
O := Vynasob(X,Y);
Writeln(O);
repeat until keypressed;
end.

Příkazy cyklu Příkazy cyklu umožňují provádět vícenásobné opakování příkazu nebo skupiny příkazu.
Příkaz while – počet opakování je určen podmínkou vyhodnocovanou před příkazem, který se má opakovat
Příkaz Repeat - počet opakování je určen podmínkou vyhodnocovanou po příkazu, který se má opakovat Příkaz While Postup při zpracování cyklu While :
Vyhodnotí se podmínka (booleovský výraz)
Je-li výsledná hodnota podmínky pravdivá - TRUE pak se provede příkaz (nebo skupina příkazů), který následuje za klíčovým slovem DO
Poté je opět vyhodnocována podmínka (bod 1)
Cyklus probíhá do té doby dokud není podmínka vyhodnocená jako nepravdivá – FALSE. Příkaz (nebo skupina příkazů se za klíčovým slovem DO neprovede a pokračuje se příkazem, který následuje za příkazem While
Je-li podmínka vyhodnocena jako FALSE již při prvním opakování, pak se příkazy, které následují za DO vůbec neprovedou Příkaz Repeat-Until Postup při zpracování cyklu Repeat Until :
Provede se příkaz nebo množina příkazu umístěna mezi klíčovými slovy REPEAT - UNTIL
Vyhodnotí se podmínka (booleovský výraz)
Je-li podmínka vyhodnocena jako FALSE (je nepravdivá), pak se celý cyklus provádění příkazů opakuje (bod 1)
POZOR jelikož je vyhodnocovací podmínka až na konci cyklu, provede se vykonání bloku příkazu mezi klíčovými slovy REPAT UNTIL minimálně jednou.
Cyklus probíhá pokud je podmínka vyhodnocená za klíčovým slovem UNTIL jako nepravdivá – FALSE. Pokud je podmínka za klíčovým slovem UNTIL vyhodnocena jako TRUE, další cyklus již neproběhne a provede se příkaz, který následuje za cyklem REPEAT-UNTIL Syntaxe příkazu Repeat-Until
Repeat
;
;
.
.
until ; Syntaxe Syntaxe příkazu While
While do
begin
;
;
.
.
end; Program Faktorial;
Uses CRT, DOS;
Var X : byte; {čítač cyklů}
F : byte;
Y : longint;
begin
X := 1; {startovací hodnota čítače}
Y := 1; {startovací hodnota FAKT!}
Write(‘Zadejte číslo : ’);
Readln(F); {udává počet cyklu}
While X