---

Polia

1. zoznámime sa s novým jednoduchým typom - interval
2. zoznámime sa s novým zloženým (štruktúrovaným) typom - pole
3. naučíme sa, ako sa pracuje s poľom, ktoré je parametrom podprogramu

---

Typ interval

• interval je odvodený z bázového typu  (tento môže byť len ordinálny typ),
• napr. integer 3..10 (3 a 10 - konštanty bázového typu),
• definovanie: min..max kde min<=max
• preberá vlastnosti a operácie bázového typu; interval je ordinálny typ
• premenná, ktorá je tohto typu, môže nadobúdať len hodnoty z intervalu
• nepriama definícia var x:3..10;
• priama definícia (v odseku definície typov):

type

interval = 3..10;     

cele = integer;  

male = byte;

mpis = 'a'..'z';

cifry = '0'..'9';

---

Štruktúrovaný (zložený) typ POLE

type pole = array[typ_indexu] of typ_prvkov;

• všetky prvky poľa sú rovnakého typu, t. j. pole sa skladá z mnohých "jednoduchších" premenných
• tieto premenné sú prístupné cez index (selektovanie)
• typ_indexu - ľubovoľný ordinálny typ
• typ_prvkov - ľubovoľný typ
• celá štruktúra musí zaberať menej ako 64 KB - v Turbo pascale

Napríklad,

type

pol = array [-7.. 7] of real;

ine = array [1..8 ] of integer;

tab = array [-7.. 7] of pol;

riadok = array [1.. 80] of char;

text = array [1..1000] of riadok;

• počet prvkov poľa musí byť známy pri kompilácii
• všetky prvky poľa sa nedajú naraz načítať ani vypísať jediným príkazom read, write - treba to rozpísať, napr. pomocou for-cyklu

• Príklad: Program, ktorý o každom prvku načítaného poľa vypíše, či je jeho hodnota nad priemerom alebo pod priemerom všetkých vstupných prvkov, resp. či je to priemer:

jednoduchá práca s poľom celých čísel:

const
 max=7;

type
index=1..max;
pole=array[index] of integer;

var
 p: pole;
 i: index;
 s: integer;
 t: Text;

begin

Assign(t,'text.txt'); Reset(t);
for i:=1 to max do read(t,p[i]);
Close(t);
Assign(t,'vypis.txt'); Rewrite(t);
s:=0;
for i:=1 to max do inc(s,p[i]);
writeln(t,'Priemer: ',s/max:0:2);
for i:=1 to max do
if p[i]<s/max then writeln(t,p[i],' pod')
else if p[i]>s/max then writeln(t,p[i],' nad')

 else writeln(t,p[i],' priemer');
Close(t);
 
end;

Pole predstavuje postupnosť prvkov rovnakého typu, pričom každý prvok má svoj index.

Pretože každý prvok poľa má svoj index, pole môže obsahovať rovnakú položku viackrát.

Pole môže byť uložené staticky alebo dynamicky. Dynamickú verziu uloženia poľa poskytujú vyššie verzie jazyka Pascal.

• Typ indexu musí byť ordinálny typ (kvôli poradiu položiek) okrem typu Longint a intervalov z tohto typu.
• Statické polia majú pevný počet komponentov rovnakého typu.
• Dynamické polia nemajú pevnú veľkosť alebo dĺžku. Pamäť je dynamicky zväčšená, keď je priradená hodnota do poľa alebo sa to dá urobiť pomocou procedúry SetLength.

• Každá položka má jednoznačne priradený index, pomocou ktorého je identifikovateľná, typ položky môže byť ľubovoľný - jednoduchý alebo štruktúrovaný.

• Položkou poľa môže byť znova pole, v tom prípade hovoríme o dvojrozmernom poli a môže to pokračovať až na viacrozmerné polia. Počet rozmerov nie je ohraničený (až na veľkosť pamäte).

Napríklad,

type

pol = array [-7.. 7] of real;

tab = array [-7.. 7] of pol;

riadok = array [1.. 80] of char;

text2 = array [1..1000] of riadok;

text1 = array [1..1000,1..80] of char;

• Typy text2 a text1 sú rôzne, aj keď sú veľmi podobné.

---

Polia ako parametre podprogramov

• formálne parametre typu pole môžu byť troch typov:

• var-parameter - nevyhradzuje sa žiadna nová pamäť, ale podprogram priamo manipuluje so skutočným parametrom

• const-parameter - podobne ako var-parameter, len sa nám nedovolí v podprograme to takéhoto poľa priraďovať

• hodnotový parameter - pri volaní podprogramu sa vytvorí duplikát celého poľa (rovnakej veľkosti) a vďaka tomu môžeme modifikovať tento duplikát (lokálnu premennú) bez toho, aby sa menil skutočný parameter

• treba dávať pozor na použitie tohto typu formálneho parametra, ak je to pole, lebo spomaľuje výpočet, veľmi míňa pamäť pre lokálne premenné a často program na tomto aj hlási chyby

• pri definovaní formálnych parametrov nesmieme nepriamo definovať nový typ, t.j. môžeme uvádzať len identifikátory typov

Napíšeme program, ktorý

• náhodne generuje do poľa X prvky z intervalu 0..n-1
• vypíše pole X
• presunie pole X do poľa Y, zvýši hodnoty v poli Y o 1 a vypíše pole Y:

procedúry s poľami:

 
Type
 Const nmax=100;
 
 pole=array[1..nmax] of integer;
 
 Procedure nahodne(n:integer; var p:pole);
 {Procedura vygeneruje nahodne hodnoty z intervalu <0, n) do pola p}
 var
 i:integer;
 begin
 for i:=1 to nmax do
 p[i]:=random(n);
 end;
 
 procedure vypis(var t:Text; p:pole);
 var
 i:integer;
 begin
 for i:=1 to nmax do write(t,p[i],' ');
 writeln(t);
 end;
 
 procedure presun(var a:pole; b:pole);
 begin
 a:=b
 end;
 
 procedure inc(var a:pole);
 var
 i:integer;
 begin
 for i:=1 to nmax do a[i]:=a[i]+1; 
 end;
 
var
 x,y:pole;
 t:Text;
begin
 Assign(t,'vypis.txt'); Rewrite(t);
 randomize;
 nahodne(20,x);
 vypis(t,x);
 presun(y,x);
 inc(y);
 vypis(t,y);
 Close(t);
end;

• všimnite si, že sme vytvorili funkciu inc na zvýšenie hodnôt prvkov v poli, tým sme prekryli pôvodný štandardný identifikátor funkcie inc a preto ho už v pôvodnom význame používať nemôžeme (v komentári môžete vidieť, ako sa tento problém aj tak dá odstrániť)

procedúry pre prácu s maticami:

Type
 Const nmax=30;
 Mmax=30
 
 pole=array[1..nmax] of integer;
 matica=array[1..mmax] of pole;
 
procedure nac_m(var m, n: integer; var mat:matica);
{procedura nacita pocet riadkov a stlpcov a prvky matice zo standardneho vstupu input}
var i, j: integer;
begin
 writeln('Zadaj pocet riadkov');
 readln(m);
 writeln('Zadaj pocet stlpcov');
 readln(n);
 writeln('Zadaj prvky po riadkoch');
 for i:= 1 to m do
 begin
 for j:= 1 to n do read(mat[i,j]);
 readln;
 end;
end;
 
procedure vyp_m(m, n: integer; mat:matica);
{procedura vypise pocet riadkov a stlpcov a prvky matice do standardneho vystupu output}
var i, j: integer;
begin
 writeln('Pocet riadkov ', m);
 writeln('Pocet stlpcov ', n);
 writeln('Prvky po riadkoch');
 for i:= 1 to m do
 begin
 for j:= 1 to n do write(mat[i,j]:5);
 writelnln;
 end;
end;
 
procedure zisti_m(m, n: integer; mat:matica; var maxim:integer; var in1, in2:integer);
{procedura zisti maximalny prvok matice a jeho indexy}
var i, j: integer;
begin
 maxim:= mat[1,1];
 in1:=1;
 in2:=1;
 for i:= 1 to m do
 for j:= 1 to n do 
 if maxim<mat[i,j] then
 begin 
 maxim:=mat[i,j];
 in1:=i; in2:=j;
 end;
end;

Príklad: Zásobník je postupnosť prvkov, v ktorej je možné pridávať a odoberať prvky len na jednom konci. Tento koniec sa nazýva vrchol zásobníka. Teda zásobník môžeme považovať za istú štruktúru údajov.

procedúry pre prácu so zásobníkom:

Const nmax=100;
 
Type
 zasobnik=array[1..nmax] of integer;
 rozsah: 0..nmax;
 
var z: zasobnik; vrchol: rozsah;
 
procedure vytvor_z(var zz: zasobnik; var vrch:rozsah);
{Vytvori prazdny zasobnik}
begin
 vrch:=0;
end; 
 
procedure vloz_z(var zz: zasobnik; var vrch:rozsah; e: integer);
{Vlozi prvok do zasobnika}
begin
 if vrch<nmax then 
 begin inc(vrch); zz[vrch]:=e; end
 else writeln('Zasobnik je plny');
end; 
 
procedure vyber_z(var zz: zasobnik; var vrch:rozsah; var e: integer);
{Vyberie prvok zo zasobnika}
begin
 if vrch>0 then 
 begin e:=zz[vrch]; dec(vrch) end
 else writeln('Zasobnik je prazdny');
end;