Dynamické datové typy 
--------------------- 
určitý ukazatel   type neco = ^baze;

obecný ukazatel   pointer
var P:neco;
 new(P)     P^:=...
 dispose(P)

GetMem(X,N)
FreeMem(X,N)

Dynamické datové struktury
--------------------------
Dynamické datové struktury
==========================

Seznamy -- jednosměrný, obousměrný, kruhový, aktivní, zásobník, 
           fronta.

Strom -- uzly a následníci, binární, ternární, n-ární, 


Graf -- orientovaný, neorientovaný

Konstrukce struktur:

-- prvky = kontejnery s daty a strukturními složkami (záznam)

type Ukazatelnaprvek = ^prvek;
     prvek = record
        Data: Typdata;   { datová složka }
        ukaz: Ukazatelnaprvek; { strukturní složka }
     end;

Kontejnery jsou svázány ukazateli.

Obyčejný seznam: Vytvoření prázdného seznamu.
                 Vložení prvku do seznamu / začátek, konec, 
                                    aktivní, obecně
                 Odstranění prvku / začátek, konec, aktivní, jinak
                 Změna pořadí prvků / strukturně, datově
                 Průchody / získání jiné datové struktury

if aktiv<>nil then begin
  if aktiv^.Predch<>nil then begin
       aktiv^.Predch^.Nasled:=aktiv^.Nasled;
  end else Zac:=aktiv^.Nasled;
  if aktiv^.Nasled<>nil then begin
       aktiv^.Nasled^.Predch:=aktiv^.Predch;
  end else Kon:=aktiv^.Predch;
end;

Pom:=Zac;
if Pom<>nil then begin {neprázdný seznam}
   if Pom^.D=hledám then begin { rušený prvek je první }
      Zac:=Zac^.Nasled;
      Dispose(Pom)
   end else begin  { rušený prvek je jinde }
      if Pom^.Nasled<>nil then begin  { máme kde hledat }
   
         while (Pom^.Nasled<>nil) and (Pom^.Nasled^.D<>Hledám)
               do Pom:=Pom^.Nasled;
         if Pom^.Nasled<>nil then begin { HURÁ, RUŠÍME!!! }
            Ruseny:=Pom^.Nasled;
            Pom^.Nasled:=Ruseny^.Nasled;
            DISPOSE(RUSENY)
         end
       end
   end
end;


Datový typ podprogram
=====================
Ukazatel na proceduru, funkci.
type realnafunkce = function (X: real): real;
var F: realnafunkce;

{$F+}
function sinus(X:real):real;
 begin sinus:=sin(x)
 end;

function enax(X:real):real;
 begin enax:=exp(X)
 end;


{$F-}

function Integral(A,B:real; F:realnafunkce):real;
 var vysl:real; krok,x:real; I:word;
 begin krok:=(B-A)/100;
       vysl:=(f(A)+f(B))/2;
       x:=A+krok;
       for I:=1 to 100 do begin
         vysl:=vysl+f(x);
         x:=x+krok
       end;
       Integral:=vysl*krok;
 end;

var A,B:real;
begin F:=@sinus;
      readln(A,B);
      writeln('hodnota pro sinus:',Integral(A,B,sinus));
      writeln('hodnota pro expon.',Integral(A,B,enax))
end.


type neco = record
       A: integer;
       B: string[45];
       C: realnafunkce
     end;


Příklady:
=========
 Vstup -- řada řetězců.
 Výstup -- a) řada řetězců uspořádaná v opačném pořadí.
                 b) řada řetězců uspořádaná podle délky vzestupně.

const MaxPole=1000;
      MaxString=100;
type Indexy=1..MaxPole;
     Pristupy=0..MaxPole;
     Retez=string[MaxString];
     Pole=array [Indexy] of Retez;

var P: Pole;
    I, Pocet: Pristupy;
    k: byte;

function CtiJedenRetezec: Retez;
 var x: byte; pom: Retez;
 begin Pom:='';
       for x:=1 to K do 
          begin read(Pom[x]);
                if Pom[x] < ' ' then Pom[x]:=' '
          end;
       Pom[0]:=char(K);
       CtiJedenRetezec:=Pom;
 end;

function CtiDruhyRetezec: Retez;
 var x: byte; pom: Retez; znak:char;
 begin Pom:='';
       read(znak);
       while not ((znak in [#0..' ']) or eof) do
           Pom:=Pom+Znak;
           read(Znak)
       end;
       CtiDruhyRetezec:=Pom
 end;

function CtiTretiRetezec: Retez;
  var pom: Retez;
 begin readln(pom);
       CtiTretiRetezec:=Pom
 end;

type TypCteni = function: Retez;
var Cteni: TypCteni;

begin K:=6; Cteni:=@CtiPrvniRetezec;

      Pocet:=0;
      while not eof do begin
         Inc(Pocet);
         P[Pocet]:=Cteni;
      end;

      for I:=Pocet downto 1 do writeln(P[I])
end.