Programování

1. Strukturované programování

• rozdělení řešené úlohy na jednodušší podúlohy, řešení těchto podúloh a jejich následné spojení do celku,
• používání datových a programových struktur (strukturované programování znamená především vytváření a používání vlastních - uživatelsky definovaných datových struktur jako jsou například záznamy).

Datové struktury: různé datové typy, každý z nich má určité vlastnosti (kolik místa v paměti zabírá, co představuje, ...) a možnosti (jinak zacházíme s čísly, jinak s řetězci, záznamy, výčtovými typy, ..., každý datový typ má přiřazenu množinu příkazů - funkcí a procedur, které slouží k práci s ním. Za datové struktury považujeme především ty datové typy, které jsou poskládány z jiných (obvykle uživatelsky definované jako je pole, záznam, objekt, ...).

Programové (řídicí) struktury: posloupnost příkazů, rozhodování (IF), přepínač (CASE), cykly (FOR, WHILE, REPEAT), podprogramy (procedury a funkce), bloky (vymezené klíčovými slovy BEGIN-END, případně příkaz WITH při práci se záznamy).

Všimněte si, že v seznamu NENÍ PŘÍKAZ goto návěští!!! V některých programovacích jazycích se bez něho neobejdeme (např. v Assembleru, to ovšem není jazyk plně podporující strukturované programování), ale v jazycích typu Pascal nebo C platí, že cokoliv lze naprogramovat bez použití příkazu goto návěští.

2. Modulární programování

V Pascalu jsou takovými moduly unity (jednotky). Samotné prostředí Pascalu již hodně takových unit obsahuje (System, CRT, Graph, Printer, DOS, ...), modulární programování však spočívá především ve vytváření vlastních unit.

Pokud chceme použít některou z vestavěných unit, musíme ji v programu (nebo unitě) uvést v seznamu za klíčovým slovem USES, například

uses
  crt, dos;

Unita System je však načtena automaticky, proto ji nemusíme uvádět. V této unitě jsou totiž obsaženy konstanty, datové typy, funkce a procedury, bez kterých se žádný program neobejde.

Zatímco zdrojový soubor, který obsahuje přímo program, je přeložen do souboru s příponou EXE, ze zdrojového souboru s unitou překladač vytvoří soubor s příponou TPU. Pokud chceme v některém programu nebo unitě využít podprogramy nebo cokoliv dalšího, co exportuje některá unita, stačí nám tento soubor TPU.

Vlastní unity vytváříme podle základní šablony:

unit nazev_jednotky;

interface         { klíčové slovo určující oblast rozhraní - v této oblasti
                    bude seznam datových typů, proměnných a podprogramů, které
                    se rozhodneme exportovat, tedy budou přístupné z jiných
...                 modulů, uvádíme zde pouze deklarace podprogramů, tedy 
                    jen název, parametry a příp. návratovou hodnotu }

implementation    { klíčové slovo určující oblast implementace všeho, co
                    unita nabízí, je zde také kód všech podprogramů, jejichž
...                 deklarace jsou v oblasti interface }

begin             { inicializační oblast unity - příkazy, které jsou zde, 
                    se provedou v okamžiku, kdy je unita použita v některém 
                    programu nebo jiné unitě (tzn. uvedena za klíčovým slovem
...                 USES), obvykle se nechává prázdné }
end.

Cokoliv je v části interface, bude viditelné a použitelné i mimo unitu, proto si důkladně rozmýšlíme, co tam dáme.

TYPE
V interface můžeme definovat vlastní datové typy, ale děláme to jen tehdy, když tyto typy jsou nutné například při určování parametrů podprogramů, které unita nabízí. Pokud je uživatel nebude potřebovat, radši je umístíme do části implementation.

VAR
V interface také mohou být proměnné, které zviditelníme i mimo unitu. Takový postup se však NEDOPORUČUJE, protože se může stát, že nezodpovědný, neznalý nebo dokonce škodolibý uživatel do proměnné přiřadí takovou hodnotu, která v ní nemá co dělat, případně by mohla způsobit nepředvídané chování programu. Proměnné tedy raději umísťujeme do části implementation a jejich hodnoty umožníme měnit pouze přes tzv. přístupové funkce (pojmenované např. DejPocet, ZmenPocet, DejPozici, ZmenPozici, ...). Tak se dá vyřešit i proměnná, která má být "read-only", tedy pouze pro čtení.

CONST
Konstanty mohou být v interface nebo implementation, rozhodujeme se podle toho, zda je bude používat i uživatel mimo unitu. Pro typové konstanty však platí totéž co pro proměnné, protože jejich hodnotu na rozdíl od skutečných konstant lze měnit. Pro zopakování:

CONST
  MAX_DELKA = 100;  { konstanta }
  POCET: word = 2;  { typová konstanta!!! (je zde udán datový typ) }

LABEL
Protože používání příkazu GOTO a tedy také návěští (label) je proti zásadám strukturovaného (a tedy i modulárního) programování, toto klíčové slovo ani nepoužíváme. Ostatně, v části interface by návěští ani neměla smysl.

USES
Vzhledem k tomu, že některé datové typy nebo struktury jsou definovány v určitých unitách, je někdy potřeba zařadit do části interface i načtení těchto unit. Pokud je to však možné, preferujeme načtení unit v části implementation. V některých případech je nutné, aby se dvě unity viděly navzájem, například:

unit prvni; ... uses druha; ...

unit druha; ... uses prvni; ...

Kdybychom v obou unitách dali USES do části interface nebo v obou do části implementation, nebylo by možné tyto unity přeložit. Řešení je jednoduché: v jedné unitě bude USES v části implementation a v druhé v části interface. Rozdíl spočívá v tom, že jednou je unita vyžadována již přeložená do souboru s příponou TPU, v druhém případě ještě přeložená být nemusí.

Příklad unity:

unit pomocna;


interface       { Zde začíná část interface - rozhraní unity }


  const
    impl_delka = 1000;    { Tuto konstantu lze používat i mimo unitu }


  { Nechá zaznít zvukový generátor se zadanou frekvencí a délkou: }
  procedure Zvuk(frekvence, delka: word);

  { Vykreslí okno s levým horním a pravým dolním rohem [x1,y1], [x2,y2],
    nastaví barvu textu a pozadí a vytvořené okno vyčistí: }
  procedure Okno(x1, y1, x2, y2, bText, bPozadi: integer);

  { Vrátí v proměnných x, y aktuální pozici kurzoru: }
  procedure DejPozici(var x, y: integer);

  { Nastaví pracovní okno na celou obrazovku, nastaví barvu textu
    a pozadí a obrazovku vyčistí: }
  procedure UklidObrazovky;

  { Napíše zadaný řetězec na souřadnicích x, y (v textovém režimu): }
  procedure PisXY(x, y: integer; s: string);


implementation  { Zde začíná část implementation – tělo unity }


  uses
    crt;


  procedure Zvuk(frekvence, delka: word);
  begin
    sound(frekvence);
    delay(delka);
    nosound;
  end;

  procedure Okno(x1, y1, x2, y2, bText, bPozadi: integer);
  begin
    window(x1, y1, x2, y2);
    textcolor(bText);
    textbackground(bPozadi);
    clrscr;
  end;

  procedure DejPozici(var x, y: integer);
  begin
    x := WhereX;
    y := WhereY;
  end;

  procedure UklidObrazovky;
  begin
    window(1, 1, 80, 25);
    textcolor(lightgray);
    textbackground(black);
    clrscr;
  end;

  procedure PisXY(x, y: integer; s: string);
  begin
    gotoxy(x,y);
    write(s);
  end;

begin

end.

Potom unitu přeložíme (vytvoříme soubor s příponou TPU) a můžeme použít v jiné unitě nebo programu. Například kdybychom tento soubor nazvali ABC.PAS, po překladu by vznikl soubor ABC.TPU. V jednom souboru může být více unit - po ukončení jedné řádkem end. prostě začneme další řádkem unit xxxx;. Při použití v některém programu nebo unitě uvádíme nikoliv název souboru, ale přímo název unity, například v tomto případě bychom psali

uses
  pomocna;