Pascal haladó

Program01.pas

program {a program neve}
uses {a használni kívánt könyvtárak, vesszővel elválasztva}
const {globális állandók meghatározása}
var {globális változók meghatározása}
 
function {függvények, ha vannak}
{ helyi változók }
begin
...
end;
 
procedure { eljárások meghatározása, ha vannak}
{ helyi változók }
begin
...
end;
 
begin { itt indul a főprogram }
...
end. { a főprogram vége }

A Pascal nyelvben a ^ karakter biztosítja a mutatók használatát. Ha mutatóként deklarálok egy változót, akkor használat előtt helyet kell számára foglalni a memóriában. Mutató típusú változó létrehozásához a típus elé kell tennünk a ^ karaktert. A helyfoglalás a New() utasítással lehetséges. A Dispose() utasítással a memóriafoglalás megszüntethető.

Program01.pas

var
	a : ^Integer;
begin
	New(a) ;
	a^ := 3;
	WriteLn(a^);
	Dispose(a);
end.

A fenti programban egy a mutató típusú változó deklarálunk, majd helyet foglalunk, hármat helyezünk el benne, kiíratjuk, majd töröljük a memóriából.

Létrehozhatunk saját mutatótípust:

Program01.pas

type
	TMutato = ^integer;
var
	a : TMutato;
begin
	New(a) ;
	a^ := 3;
	WriteLn(a^);
	Dispose(a);
end.

A mutatókkal így dinamikus memóriahasználat valósítható meg.

Az addr() függvény segítségével lekérdezhető egy változó címe:

addr(valtozonev)

Az ilyen cím eltárolható egy mutató típusú változóban. Tulajdonképpen rámutathatók egy másik változóra.

p01.pas

program p01;
var 
	a : ^integer;
	b : integer;
begin
	b := 3;
	a := addr(b);
	WriteLn(a^);
end.

A fenti programban az „a” egy mutató típusú változó. A „b” egy szimpla változó. A programban b-be teszek hármat, majd az a változóban eltárolom a b címét. Végül a változó által mutatott helyről kiírom az értéket, amely tulajdonképpen b értéke.

Lentebb látni fogjuk, hogy addr() függvény elérhető a „@” operátorral is.

A mutatók számára nil érték adható meg, ami azt mondja, ne mutasson sehova a mutató típusú változó:

...
var
    ap : ^integer;
begin
    ap = nil;

Szelekcióval vizsgálhatom a nil értéket:

if(ap <> nill )then     { igazat kapunk ha ap nem null, vagyis mutat valahova }
if(ap = nill)then    { igazat kapunk, ha ap nem mutat sehova, vagyis null }

A @ operátor visszaadja egy változó címét a memóriában. Úgy is mondhatnánk a mutatóját.

Program01.pas

var
	a : Integer;
	b : ^Integer;
begin
	a := 3;
	b := @a;	
	WriteLn(b[0]);
	a := 5;
	WriteLn(b[0]);
end.

A „b” változót mutató típusúnak adom meg a „^” operátorral, a megadhatom, hogy a „b” változó az „a” változóra mutasson. Ezek után ha az „a” változó értéke változik, a „b” mutató típusú változón keresztül is a megváltozott értéket tudom lekérdezni.

De csinálhatjuk fordítva is:

Program01.pas

var
	a : Integer;
	b : ^Integer;
begin
	a := 3;
	b := @a;	
	WriteLn(a);
	b^ := 5;
	WriteLn(a);
end.

Az „is” operátorral megvizsgálhatjuk, hogy egy objektum melyik osztályból származik.

Program.pas

{$mode objfpc}
type
	TDolgozo = class
		nev : String;
		kor : byte;
	end;
var 
	Joska : TDolgozo;
begin
	Joska := TDolgozo.Create;	
	Joska.nev :='Nagy József';
	Joska.kor := 28;
 
	if Joska is TDolgozo then
		WriteLn('Egyezik')
	else
		WriteLn('Nem egyezik');	
end.

Ahogy nő a programunk mérete, szeretnénk azokat külön állományokba elhelyezni. Egy eljárás vagy egy függvénygyűjteményt egy unit állományba teszünk. Ilyenkor a „program” kulcsszó helyett a fájl elején a „unit” kulcsszót használjuk. Fontos, hogy a fájl neve meg kell egyezzen a unit nevével.

Calculator.pas

unit Calculator;
 
interface
 
function sum(a, b: Double):Double;
function sub(a, b: Double):Double;
 
implementation
 
function sum(a, b: Double):Double;
begin
	sum := a + b;
end;
 
function sub(a, b: Double):Double;
begin
	sub := a - b;	
end;
 
end.

Program01.pas

program Program01;
 
uses Calculator, crt;
 
begin
	WriteLn(sum(3, 5):0:0);
	WriteLn(sub(3, 5):0:0);
end.