Lekce 1.19
Typ ARRAY - proměnné typu pole

Proměnné s možností indexového přístupu jsou obsaženy i v jazycích BONANZA a JUKON, používají se však k tomu jiné procedury a funkce!

Pole si můžete jednoduše představit jako řadu hodnot. Každá hodnota je uváděna jako jeden prvek pole. Pro přístup k jednotlivým hodnotám musíte přitom použít tzv. index, kterým zadáváte pořadí prvku (hodnoty) v poli. Celková dimenze (rozsah) pole se zadává při inicializaci pole.

Pole může být jednorozměrné nebo dvourozměrné. Jednorozměrné pole je vlastně řada hodnot a index se zadává jako pořadí hodnoty. Dvourozměrné pole je možné si jednoduše představit jako šachovnici. Index pro přístup do dvourozměrného pole v tomto případě udává řádek a sloupec šachovnice. Při definici pole nemusí začínat rozsah pole vždy od jedničky. Je možné si definovat hodnotu počátečního a koncového indexu.

S proměnnou typu Array (pole) se pracuje jinak, než s běžnou proměnnou. Proměnnou musíte nejprve běžným způsobem deklarovat. Abyste ale mohli k proměnné přistupovat jako k poli, musíte ji ještě dále v programu inicializovat. Inicializací se současně zadává rozsah indexových polí. Inicializace jednorozměrného pole se provádí funkcí Array1Create. Parametry udávají počáteční a koncový prvek pole. Při inicializaci obsahuje pole proměnné typu variant s nedefinovaným stavem a je proto vhodné ještě nulovat položky pole na počáteční hodnoty:

Pole:=Array1Create(0, 9);
For x:= 0 to 9 do 
    Pole := Array1Set(Pole, x, 0);

Pole := Array2Create(1, 3, 0, 9);
For x:= 1 to 3 do
begin
   For y:= 0 to 9 do 
       Pole := Array2Set(Pole, x, y, 0);
end;

Po inicializaci obsahuje každý prvek pole prázdnou hodnotu nedefinovaného stavu. Je proto vhodné po ihned po inicializaci pole před jeho dalším použitím naplnit pole počátečními hodnotami požadovaného typu. Možnost počátečního naplnění pole je uvedena ve výše uvedených inicializacích pole.

Pro kontrolu počtu rozměrů a správnosti inicializace pole můžeme použít funkci ArrayDimCount, která nám vrací počet rozměrů (dimenzí) pole, případně nulovou hodnotu, pokud není proměnná typu pole (Array).

V mnoha případech, například při programování cyklů, bude vhodné mít z programu přístup k rozsahu indexování polí. K tomu slouží funkce Array1Low a Array1High pro jednorozměrné pole a Array2Low a Array2High pro dvourozměrné pole. Díky tomu je například možné nulovat položky pole následujícím způsobem:

{jednorozměrné pole}
mesice := Array1Create(1, 12);
For x:= Array1Low(mesice) to Array1High(mesice) do
    Mesice := Array1Set(Mesice, x, Month(x));

{dvourozměrné pole}
rok := Array2Create(1, 12, 1, 30);
For x:= Array2Low(rok,1) to Array2High(rok,1) do
    For y:= Array2Low(rok,2) to Array2High(rok,2) do
        Rok := Array2Set(Rok, x, y, 0);

V := Array1Set(V, poradi, 'obsah');

V := Array2Set(V, radek, sloupec, 'obsah');

Writeln(Array1Get(v, poradi));

Writeln(Array2Get(v, radek, sloupec));

Získané znalosti o programování polí můžete vyzkoušet například na výpočtu průměrné hodnoty náhodné veličiny funkcí Random. Nejedná se o zcela efektivní příklad, protože není nutné náhodné veličiny ukládat do pole. Nyní nám jde spíše o vysvětlení principu používání polí.

Unit Prumer;
interface
implementation

Var
   x      : Integer;
   soucet : Real;
   cislo  : Array;

begin
   ConsoleClear;
   ConsoleShow;

   {inicializace jednorozměrného pole}
   cislo := Array1Create(1, 100);

   {cyklus pro celé pole}
   For x := Array1Low(cislo) to Array1High(cislo) do
   begin
       cislo := Array1Set(cislo,x,Random(100)); {náhodné číslo}
       Writeln(Array1Get(cislo,x));    {výpis hodnoty}
   end;

   {výpočet součtu a průměru uložených hodnot}
   soucet := 0;
   For x := Array1Low(cislo) to Array1High(cislo) do
       soucet := soucet + Array1Get(cislo, x);
   Writeln('-------------');
   Writeln('Součet:'+IntToStr(soucet));
   Writeln('Průměr:'+IntToStr(soucet/Array1High(cislo)));
end;
end.

V dalším příkladě již budeme pracovat s dvourozměrným polem. Všimněte si, že prvky pole mohou být různého typu.

Unit Pole;
interface
implementation

var v: Array;
    i: Integer;
    x: Integer;

begin
   ConsoleClear;
   ConsoleShow;

   {založíme dvourozměrné pole}
   v:=Array2Create(1, 3, 0, 9);
   Writeln('Dimenze pole:'+IntToStr(ArrayDimCount(v)));

   {pro kontrolu zobrazíme rozsah polí}
   Writeln('1.dimenze rozsah Low  ='
           +IntToStr(Array2Low (v, 1)));
   Writeln('1.dimenze rozsah High ='
           +IntToStr(Array2High(v, 1)));
   Writeln('2.dimenze rozsah Low  ='
           +IntToStr(Array2Low (v, 2)));
   Writeln('2.dimenze rozsah High ='
           +IntToStr(Array2High(v, 2)));

   {naplníme pole počátečními hodnotami}
   for i:= 0 to 9 do
       v := Array2set(v,1,i,i);
   for i:= 0 to 9 do
       v := Array2set(v,2,i,100/(i+1));
   for i:= 0 to 9 do
       v := Array2set(v,3,i,'Hodnota='+IntToStr(i));

   {vypíšeme obsah polí}
   Writeln(''); Writeln('Obsah pole1:');
   for i:= 0 to 9 do 
       Writeln(Array2get(v,1,i));
   Writeln(''); Writeln('Obsah pole2:');
   for i:= 0 to 9 do
       Writeln(Array2get(v,2,i));
   Writeln(''); Writeln('Obsah pole3:');
   for i:= 0 to 9 do
       Writeln(Array2get(v,3,i));
end;
end.

Unit prg;
interface
implementation

Var pole, pok: array;

begin
   {inicializace pole}
   pole:=Array1Create(1, 3);

   {naplnění hodnotou}
   pole := Array1Set(pole,1, 'KLONDAIK');

   {přesun kompletního pole do jiné položky}
   pok := pole;

   {kontrolní výpis obsahu položky pole}
   Writeln(Array1Get(pok,1));
end;
end.

Jistě uznáte, že možnost tvorby a používání proměnných typu pole je velmi zajímavá. Mějte však na paměti, že zvláště dvourozměrná pole zabírají v paměti dost prostoru. Buďte proto opatrní a nepoužívejte rozsáhlá mnohapoložková pole. Po inicializaci pole je vhodné se voláním funkce ArrayDimCount přesvědčit, zda byla zadaná inicializace pole opravdu bezchybně provedena.

Další jednoduchý příklad práce s polem je uveden v programu DIMENZE.KLN. Jednoduchý příklad použití polí můžete nalézt v programu SPORTKA.KLN.