Szintaxis (függyvények)
Global_ function _definition = Function_definition
Function_definition =
Function_header external |
Function_header [ inline ] Function_body
Function_header = Function_name "(" [[ var ] Param {","[ var ] Param }] ")"
Function_body = { Statement } return Expression
Jelentés
Az f üggvény definíciója a nevébõl, formális paramétereibõl és a függvénytörzsbõl áll. A törzs elmaradhat, ha a csukó zárójelet az external parancs követi. Ebben az esetben a függénytörzs más modulban van definiálva.
Ha a paraméterlista után inline kulcsszó következik, akkor a függvényhívást a fordító az inline utáni törzzsel helyettesíti.
Példa
function Fact( N )
if N = 1 thenN
R := 1
else
R := N * Fact( N - 1 )
end
return R
function Square( X ) inline
return X * X
Paraméterátadás
A formális paramétert megelõzõ var kulcsszó mutatja, hogy az aktuális paramétert az adott függvény módosítja. Egyébként a függvény a paramétert konstansként használja. A függvény a változó kiszámolt értékével tér vissza a return után.
Túlterhelés
Nincs lehetõség függvények túlterhelésére. Az alábbi program lefutását követõen a hibaüzenet: Multiple function definition
function F(N)
v := 6
return v
function F(N,P)
v := 7
return v
writeln( F (1))
writeln( F (1,2))
return
Rekurzió
Példa rekurzióra
function F( N )
if N <= 1 then
Z := 1
else
Z := N * F( N - 1 )
end
return Z
for I:=1 to 12 do
writeln( F( I ) )
end
return
Modulok
A VIRT program általában modulokra oszlik. Minden modul külön fájlban van, a fájl kiterjesztése: .w
A modulok struktúrája megegyezik a program struktúrájával:
Szintaxis:
Program =
[ uses Module { "," Module } ]
{ [ Constant_section ] |
[ Class_interface_section ] |
[ Class_implementation_section ] |
[ Global_function_definition ] }
{ Statement }
return
Module = Identifier
A use utasítás vezeti be azokat a modulokat, amiket az adott programban használunk.
A programot return zárja.
A program részei a fent bemutatott sorrendben követhetik csak egymást.
Példa
function Swap( var X, var Y )
temp << X
X << Y
Y << temp
return 0
function QuickSort( var A, L, H )
I := L
J := H
X := A[ ( I + J ) / 2 ]
repeat
while A[ I ] < X do
I := I + 1
end
while X < A[ J ] do
J := J - 1
end
if I <= J then
Swap( A[ I ], A[ J ] )
I := I + 1
J := J - 1
end
until I > J
if L < J then
QuickSort( A, L, J )
end
if I < H then
QuickSort( A, I, H )
end
return 0
return
uses sort, shape
constant
N = 200
Range = 100
end
A := array( N )
for I:=1 to N do
A[ I ] := Circle( Random( Range ), Random( Range ), Random( Range ) )
end
QuickSort( A, 1, N )
object &p : Point
for I:=1 to N do
p == A[ I ]
writeln( p.Norm() )
end
return
Hatókör
A VIRT program fordítása egy menetben történik, ezért az azonosító deklarációnak meg kell elõznie a használatot.
Az azonosítókat a fajtájától függõen a megfelelõ helyen kell deklarálni:
- Konstans: konstans rész
- Globális függvény: a függvények elõtt
- Osztály: osztály rész
- Publikus eljárás: az interface rész elején
- Privát eljárás: az implementation rész elején
Alapértelmezésben a konstansok, globális függvények és publikus metódusok elérhetõek az adott modul határain belül. A uses utasítással ezeket importálhatjuk más modulokból.
A rendszer modult, ami tartalmazza a standard adattípusok reprezentációját, a globális függvényeket és változókat, minden VIRT program alapértelmezés szerint tartalmazza.
Azok a változók, amiket a global function body vagy method body -ban definiáltunk, azok nem használhatóak azokon kívül.Azok az azonosítók, amiket az implementation section-ban a local kulcsszóval vezetünk be, használhatóak az adott osztály minden metódusában de nem láthatóak az a szekción kívül.(szigorú csomagbazárás). A privát eljárások csak az adott osztály implementation section-jében elérhetõ.