X.	TYPY  UKAZATEL

Hodnotami typu ukazatel jsou paměťové adresy. Na operační paměť lze pohlížet jako na posloupnost bytů, jejichž pozici v této posloupnosti charakterizuje právě adresa. Pro účely adresování je posloupnost členěna na odstavce — úseky o délce 16 bytů.

Na strojové úrovni se k adresování používají dvojice šestnáctibitových registrů procesoru. Jeden z registrů dvojice obsahuje hlavní, tzv. segmentovou část adresy (segment), druhý doplňkovou, tzv. ofsetovou část adresy (ofset). Interpretujeme-li segment i ofset jako celá nezáporná čísla (na šestnácti bitech tedy čísla 0 až 65 535), má segment význam pořadí referovaného odstavce od začátku operační paměti a ofset pořadí referovaného bytu od začátku tohoto odstavce. Pořadí referovaného bytu od začátku operační paměti — tzv. efektivní adresa — je pak hodnotou výrazu segment × 16 + ofset.

Uvedené členění adresy na segment a ofset je zachováno i ve vnitřním tvaru ukazatelových hodnot v Turbo Pascalu. Hodnota ukazatele má velikost dvě slova (4 byty), přičemž nižší z nich obsahuje ofsetovou a vyšší segmentovou část reprezentované adresy.

X.1.	Ukazatelové proměnné

Hodnotou ukazatelové proměnné je ukazatel na počátek nějakého úseku operační paměti. Aby referovaný úsek mohl být programem zpracován, musí být obvykle k dispozici ještě informace o jeho velikosti a struktuře, tedy informace o typu proměnné, za kterou bude pokládán. Význam termínů ukazatelová proměnná, ukazatel a referovaná proměnná ilustruje následující obrázek.

Obrázek 45: Ukazatelem referovaná proměnná

Třídy ukazatelových typů   Informaci o typu referované proměnné lze programu poskytnout dvěma způsoby, jimž odpovídají dvě implementované třídy ukazatelových typů — ukazatele typové a ukazatele univerzální (netypové).

Typ proměnné, referované typovým ukazatelem, je pevně stanoven již v popisu příslušného ukazatelového typu (obrázek 46), jako tzv. bázový typ ukazatele. Může jím být libovolný pojmenovaný typ, string nebo file. Každá proměnná, referovaná typovým ukazatelem, je pak považována za proměnnou jeho bázového typu.

Obrázek 46: Popis typu ukazatel

Jako univerzální jsou chápány ukazatele předdeklarovaného typu Pointer. Jejich univerzálnost spočívá v tom, že typy jimi referovaných proměnných jsou nedefinované — lze je podle aktuální potřeby volit až v okamžiku (každého) přístupu k těmto proměnným.

type Baze     = array [1..5] of Char;
     Ukazatel = ^Baze;

var  U1       : Ukazatel;
     U2       : Ukazatel;
     U3, U4   : ^Baze;
     U5       : ^Baze;
     P        : Pointer;

Typovou kontrolu kontrolu kompatibility ukazatelových typů lze řídit direktivou {$T} kompilátoru. Ve stavu {$T–} je kontrola striktní — dva ukazatelové typy jsou kompatibilní pouze pokud jsou identické nebo pokud jeden z nich je univerzálním ukazatelovým typem. Ve stavu {$T+} jsou za kompatibilní považovány i ukazatelové typy s identickými bázovými typy.

Přiřazovací příkaz   Pro ukazatele je kompatibilita vůči přiřazení ekvivalentní kompatibilitě (viz výše). Pokud je tedy proměnná na levé straně přiřazovacího příkazu typovým ukazatelem, hodnotou výrazu na straně pravé musí být typový ukazatel identického typu nebo typový ukazatel s identickým bázovým typem (jen za stavu {$T+}) nebo ukazatel univerzální. Pokud je však proměnná univerzálním ukazatelem, smí být výraz ukazatelem libovolným.

Ukazatelový výraz může být tvořen ukazatelovou proměnnou či konstantou, voláním funkce s ukazatelovou hodnotou nebo aplikací adresního operátoru.

Ukazatelové funkce   Pro definici ukazatelových hodnot jsou jazykem implementovány funkce Ptr, Seg, Ofs a Addr.

function Addr (Objekt): Pointer;

Funkce vrací ukazatele na uvedený parametr, jímž může být libovolná proměnná nebo identifikátor uživatelského podprogramu. Mechanismus výpočtu funkční hodnoty je podle druhu parametru modifikován takto:

• Je-li Objekt hodnotou volaný formální parametr nějakého podprogramu, je vrácen ukazatel na příslušnou lokální proměnnou na zásobníku.

• Je-li Objekt odkazem volaný formální parametr nějakého podprogramu, je vrácen ukazatel na příslušný skutečný parametr.

• Je-li Objekt proměnná procedurálního typu (kapitola XIII), pak operace Addr (Objekt) předepisuje, aby na Objekt bylo pohlíženo jako na proměnnou typu Pointer. Výsledkem výskytu této operace ve výrazu je tedy hodnota proměnné Objekt ve formátu Pointer — ukazatel na vstupní bod příslušné procedury či funkce. Teprve výraz Addr (Addr (Objekt)) pak má hodnotu ukazatele na proměnnou Objekt.

• Je-li Objekt „normální“ proměnná, vrací funkce ukazatel na ni.

• Je-li Objekt identifikátorem procedury nebo funkce, vrací funkce ukazatel na její vstupní bod (startovací adresu).

function Ptr (Segment, Ofset: Word): Pointer;

Vrací ukazatelovou hodnotu, odpovídající zadané segmentové (parametr Segment) a ofsetové (parametr Ofset) části reprezentované adresy.

function Seg (Objekt): Word;
function Ofs (Objekt): Word;

Skutečným parametrem obou funkcí může být libovolná proměnná nebo identifikátor uživatelského podprogramu. Funkce Seg resp. Ofs pak vrací segmentovou resp. ofsetovou část adresy uvedeného parametru, přičemž je mechanismus výpočtu funkční hodnoty modifikován podle druhu parametru stejně jako ve výše popsané funkci Addr.

Adresní operátor   Adresní operátor @ je operátorem unárním, váže se tedy na jediný operand vpravo. Používá se jako ekvivalent výše popsané adresní funkce Addr — výsledkem operace @Objekt je Addr (Objekt).

Typ výrazu @Objekt, kde Objekt je neprocedurální proměnná, závisí (na rozdíl od typu funkce Addr) na nastavení direktivy {$T} kompilátoru. Ve stavu {$T–} je typem výrazu ukazatel univerzální, kdežto ve stavu {$T+} ukazatel typový, jehož bázovým typem je typ proměnné Objekt.

Relační operace   Hodnoty kompatibilních ukazatelových typů lze porovnávat relačními operacemi býti rovno (operátor =) a býti různo (operátor <>). Při porovnávání není počítána efektivní adresa, porovnávají se zvlášť segmentové a zvlášť ofsetové části obou operandů (rovnost ukazatelů je dána rovností jejich segmentových částí i ofsetových částí). Tímto způsobem získaný výsledek relace však nemusí být vždy shodný s očekávaným. Například výraz

Ptr (100, 0) <> Ptr (99, 16)

Přístup k referované proměnné   Syntax přístupu k ukazatelem referované proměnné popisuje diagram na obrázku 47. Operandem, uvedeným před kvalifikátorem ^, musí být ukazatelová proměnná či konstanta, volání ukazatelové funkce nebo ozávorkovaný obecný výraz ukazatelového typu (například aplikace adresního operátoru @). Výsledkem operace je proměnná (!), alokovaná v operační paměti na adrese, získané vyhodnocením operandu.

Obrázek 47: Přístup k referované proměnné

Typ výsledné proměnné závisí na typu uvedeného operandu. Jestliže je operandem ukazatel typový, je typem výsledné proměnné jeho bázový typ. Pokud je však operandem ukazatel univerzální, je typ výsledné proměnné nedefinovaný. Proměnné nedefinovaného typu je pak nutno nějaký typ přidělit explicitně, operací přetypování proměnné (kapitola XII).

type Baze = array [1..10] of Real;
     Ukaz = ^Baze;

var  U    : Ukaz;
     B    : Baze;
     Z    : Char;

function FU (X: Char): Ukaz;
...

Následující procedura PisZnak vypíše na pozici obrazovky danou parametry R (řádka, shora od nuly) a S (sloupec, zleva od nuly) znak Znak s barevným atributem Atr.

{----------------------------------------------------------------------}
procedure PisZnak (R, S: Byte; Znak: Char; Atr: Byte);
{----------------------------------------------------------------------}

 type VideoChar = record                 { struktura slova videopaměti }
                   Symbol  : Char;       { nižší byte                  }
                   Atribut : Byte        { vyšší byte                  }
                  end;

 var  Pozice    : ^VideoChar;            { ukazatel na vybrané slovo   }

begin { PisZnak }
 Pozice := Ptr($B800, 2 * (S + 80 * R)); { adresa - výběr slova        }
 with Pozice^ do                         { zápis do vybraného slova    }
  begin
   Symbol  := Znak;                      { znak                        }
   Atribut := Atr                        { atribut znaku               }
  end
end; { PisZnak }

Určitého zprůhlednění přístupu k jednotlivým slovům ve videopaměti lze dosáhnout použitím dvourozměrného pole jako bázového typu ukazatele Pozice. Hodnota ukazatele pak bude konstantní, bude stále referovat začátek bloku videopaměti — pole — a přístup k jednotlivým slovům bude realizován pomocí indexů:

{----------------------------------------------------------------------}
procedure PisZnak (R, S: Byte; Znak: Char; Atr: Byte);
{----------------------------------------------------------------------}

 type  VideoChar = record                { struktura slova videopaměti }
                    Symbol  : Char;      { nižší byte                  }
                    Atribut : Byte       { vyšší byte                  }
                   end;
       VideoRAM  = array [0..24, 0..79]  { struktura stránky videopam. }
                   of VideoChar;

 const Pozice    : VideoRAM              { ukazatel na stránku         }
                 = Ptr($B800, 0);

begin { PisZnak }
 with Pozice^[R, S] do                   { zápis do vybraného slova    }
  begin
   Symbol  := Znak;                      { znak                        }
   Atribut := Atr                        { atribut znaku               }
  end
end; { PisZnak }

Ukazatelové konstanty   Jazykem je předdeklarována jediná standardní ukazatelová konstanta nil. Pojmenovává ukazatele s nulovou segmentovou i ofsetovou částí reprezentované adresy.

const nil = Ptr (0, 0);

Typem konstanty nil je univerzální ukazatelový typ Pointer (kompatibilní se všemi ukazatelovými typy). Podle konvencí jazyka se hodnota nil používá pro reprezentaci ukazatele, který „nikam neukazuje“ (nereferuje žádnou proměnnou).

Pomocí funkce Ptr s konstantními parametry lze zavádět i uživatelské ukazatelové konstanty (rovněž jejich typem pak bude Pointer):

const VideoRAM = Ptr ($B800, 0);

type  Ukaz = ^Real;
var   A : Real;

const B : Ukaz = @A;           { korektní deklarace }
      C : Ukaz = Addr (A);
      D : Ukaz = Ptr (10, 20);
      E : Ukaz = nil;
      F : Word = Seg (A);
      G : Word = Ofs (A);

      H = @A;                  { chybné deklarace   }
      I = Seg (A);
      J : Ukaz = Ptr (Seg (A), Ofs (A));

Dynamické proměnné nejsou deklarovány, nemají tudíž přidělen identifikátor. Jsou přístupné pouze pomocí své adresy, kterou je nutno uchovávat v ukazatelové proměnné. Úsek operační paměti, vyhrazený pro alokaci dynamických proměnných, se nazývá heap.

Založení dynamické proměnné   Založení dynamické proměnné je operace, při níž je na heapu rezervován paměťový úsek určité velikosti. Lze ji realizovat voláním některé ze standardních procedur New či GetMem. Při použití New musí být velikost zakládané proměnné známa již v okamžiku překladu programu, kdežto při použití GetMem je požadovaná velikost proměnné vyhodnocena až za běhu programu.

procedure New (var P: ukazatel);

Skutečným parametrem P může být ukazatelová proměnná libovolného typu. Procedura založí dynamickou proměnnou o velikosti bázového typu parametru a ukazatel na ni v parametru vrací. Uvedení univerzálního ukazatele na místě parametru P není chybou, je však založena dynamická proměnná o velikosti 0 bytů.

procedure GetMem (var P: ukazatel; Velikost: Word);

Založí dynamickou proměnnou požadované velikosti a její adresu vrací v parametru P. Velikost je uvedena v bytech a její maximální přípustnou hodnotou je 65 521 (větší bloky dat je nutno uchovávat ve více dynamických proměnných). Skutečným parametrem P je zpravidla proměnná typu Pointer. Uvedení typového ukazatele na místě parametru P není chybou, jeho bázový typ však nemá žádný vliv na velikost založené dynamické proměnné.

Pokud není pro zakládanou dynamickou proměnnou na heapu nalezen volný úsek příslušné velikosti, končí volání procedury New resp. GetMem běhovou chybou programu.

Uvolnění dynamické proměnné   Uvolněním dynamické proměnné se rozumí zrušení rezervace jí obsazeného úseku heapu, který pak může být použit pro alokaci dalších dynamických proměnných. Uvolnění lze realizovat voláním jedné ze standardních procedur Dispose a FreeMem. Pokud není příkaz k uvolnění dynamické proměnné explicitně vydán, zůstává příslušný úsek heapu trvale rezervován.

procedure Dispose (var P: ukazatel);

Hodnotou parametru P (libovolného ukazatelového typu) je specifikován ukazatel na uvolňovanou proměnnou a jeho bázovým typem velikost uvolňované proměnné. Procedura totiž předpokládá, že na uvedené adrese se nachází dynamická proměnná bázového typu ukazatele P. Uvedení ukazatele univerzálního sice není chybou, uvolněna je však proměnná o velikosti 0 bytů.

procedure FreeMem (var P: ukazatel; Velikost: Word);

Hodnotou parametru P (libovolného ukazatelového typu) je specifikován ukazatel na uvolňovanou proměnnou a hodnotou parametru Velikost velikost uvolňované proměnné. Velikost bázového typu (v případě uvedení typového ukazatele) nemá na velikost uvolněné proměnné žádný vliv.

Při pokusu o uvolnění neexistující dynamické proměnné končí volání procedur Dispose a FreeMem běhovou chybou programu

 type Base = Char; { deklarace bázového typu ukazatele                 }
      Ukaz = ^Base;{ deklarace ukazatelového typu                      }
 var  P, Q : Ukaz; { při spuštění programu jsou založeny dvě statické  }
                   { proměnné typu Ukaz                                }

begin { program }
 New (P);          { na heapu je založena dynamická proměnná typu Base }
                   { a odkaz na ni je vrácen v P                       }
 P^ := 'A';        { definována hodnota dynamické proměnné P^          }
 New (Q);          { založena další dynamická proměnná typu Base       }
                   { a odkaz na ni vrácen v Q                          }
 Q^ := P^;         { definice hodnoty proměnné Q^ hodnotou proměnné P^ }
 Q := P;           { Q přiřazen ukazatel na proměnnou P^ - P i Q       }
                   { referují tutéž dynamickou proměnnou a ukazatel na }
                   { úsek heapu, v němž je alokována dynam. proměnná,  }
                   { původně referovaná proměnnou P, je ztracen - úsek }
                   { zůstane trvale rezervován a nevyužit              }
 Dispose (Q);      { dynamická proměnná Q^ (= P^) je uvolněna          }
 Dispose (P)       { požadavek na uvolnění neexistující dynamické      }
                   { proměnné - program skončí chybou...               }
end. { program }

X.3.	Řízení heapu

Při zavádění programu do operační paměti je mu operačním systémem určitý její úsek přidělen jako heap. Požadavek na velikost přiděleného heapu lze (společně s požadavkem na velikost přiděleného zásobníku) ve zdrojovém textu programu specifikovat pomocí direktivy kompilátoru (viz požadavek na přidělení paměti).

Základní údaje o umístění a velikosti přiděleného heapu a o jeho zaplnění obsahují standardní proměnné HeapOrg, HeapEnd a HeapPtr.

const HeapOrg: Pointer = nil;
      HeapEnd: Pointer = nil;
      HeapPtr: Pointer = nil;

Po zavedení programu do operační paměti je do proměnné HeapOrg i do proměnné HeapPtr vložena adresa dna (počátku) heapu, do proměnné HeapEnd pak adresa konce heapu. Při postupné alokaci a uvolňování dynamických proměnných v průběhu výpočtu programu je hodnota proměnné HeapPtr automaticky aktualizována tak, že vždy ukazuje na vrchol obsazené části heapu (nové dynamické proměnné jsou postupně alokovány od dna heapu směrem nahoru).

Pokud jsou všechny alokované dynamické proměnné uvolňovány v přesně opačném pořadí, než v jakém byly založeny, je obsazená část heapu trvale souvislá a tudíž adresami dna a vrcholu plně definovaná. V takovém případě lze k hromadnému uvolnění několika naposled založených dynamických proměnných s výhodou použít procedury Mark a Release (namísto postupného uvolňování jednotlivých proměnných procedurou Dispose či FreeMem).

procedure Mark (var P: Pointer);

Procedura Mark uloží do parametru P aktuální hodnotu vrcholu heapu pro pozdější využití procedurou Release.

procedure Release (var P: Pointer);

Procedura Release vloží do ukazatele na vrchol heapu (HeapPtr) hodnotu parametru P, získanou dříve voláním procedury Mark. Všechny mezitím alokované dynamické proměnné se ocitnou nad novým vrcholem heapu — jsou uvolněny. Volání Release(HeapOrg) uvolní celý heap.

Procedurami Dispose a FreeMem lze uvolnit kteroukoliv dynamickou proměnnou, tedy nejen proměnnou na heapu nejvýše položenou. Tím ovšem dochází k fragmentaci heapu, neboť v jeho obsazené části vznikají tzv. díry — neobsazené úseky. Seznam všech děr si program automaticky udržuje na konci heapu a kontroluje jej při zakládání nových dynamických proměnných, které jsou pak do děr přednostně alokovány.

Obrázek 48: Organizace heapu

Procedura Release kromě nastavení hodnoty proměnné HeapPtr také „vyčistí“ seznam děr, tj. inicializuje jej jako prázdný. Pokud pod novým vrcholem heapu nějaké díry existují, chovají se dále jako obsazené. Při společném používání procedur Dispose a FreeMem s procedurami Mark a Release je třeba vzít toto nebezpečí na vědomí a postupovat tak, aby takové nezjistitelné a dále nevyužitelné úseky na heapu nemohly vzniknout.

Pro testování velikosti volné paměti na heapu jsou implementovány funkce MemAvail a MaxAvail. Jejich použitím před požadavkem na založení dynamické proměnné se lze vyhnout běhové chybě, která by nastala v případě jeho neuspokojení.

function MemAvail: LongInt;
function MaxAvail: LongInt;

Funkce MemAvail vrací celkový počet volných bytů na heapu (včetně děr mezi jeho dnem a vrcholem), funkce MaxAvail počet bytů největšího souvislého volného úseku heapu.