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.