[[oktatas:programozás:pascal|< Pascal]]


====== Pascal haladó ======

===== Pascal struktúra =====

<code pascal 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 }
</code>

===== Mutatók =====

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ő.

<code pascal Program01.pas>
var
	a : ^Integer;
begin
	New(a) ;
	a^ := 3;
	WriteLn(a^);
	Dispose(a);
end.
</code>


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:
<code pascal Program01.pas>
type
	TMutato = ^integer;
var
	a : TMutato;
begin
	New(a) ;
	a^ := 3;
	WriteLn(a^);
	Dispose(a);
end.
</code>

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. 

<code pascal p01.pas>
program p01;
var 
	a : ^integer;
	b : integer;
begin
	b := 3;
	a := addr(b);
	WriteLn(a^);
end.
</code>

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ó:
<code pascal>
...
var
    ap : ^integer;
begin
    ap = nil;
</code>

Szelekcióval vizsgálhatom a nil értéket:
<code pascal>
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 }
</code>


===== Különleges operátorok =====

A @ operátor visszaadja egy változó címét a memóriában. Úgy is mondhatnánk a mutatóját. 
<code pascal Program01.pas>
var
	a : Integer;
	b : ^Integer;
begin
	a := 3;
	b := @a;	
	WriteLn(b[0]);
	a := 5;
	WriteLn(b[0]);
end.
</code>
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:
<code pascal Program01.pas>
var
	a : Integer;
	b : ^Integer;
begin
	a := 3;
	b := @a;	
	WriteLn(a);
	b^ := 5;
	WriteLn(a);
end.
</code>


===== Az is operátor =====
Az "is" operátorral megvizsgálhatjuk, hogy egy objektum melyik osztályból származik.
<code pascal 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.
</code>

===== Unitok használata =====

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. 



<code pascal 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.

</code>


<code pascal Program01.pas>
program Program01;

uses Calculator, crt;

begin
	WriteLn(sum(3, 5):0:0);
	WriteLn(sub(3, 5):0:0);
end.
</code>