Típus szerkezet
Az adattípus és az osztály azonos fogalmak a VIRT-ben. Az osztálydefinícióban az osztály neve, az ősosztály neve(opcionális), az adott osztály specifikációja és implementációja szerepel. Az osztály definíciója csak metódusokat foglal magába.
Bővebben lást: Obejktum-oriantált programozás.Elemi típusok
A standard osztályok a következőek: Number, Integer, Real, String, Array többváltozós tömbosztály, Definition a lambda kifejezés osztály, Exception a kivételek osztálya. A Number osztály leszármazottai az Integer és a Real osztályok. A standard osztályok felépítése az általános szabályoknak megfelelő. Van specifikációs és implementációs részük, amit a System modulban találunk(system.w).
Number típus
Interface:
class Number
function Init( X ) constructor
function ":="( X )
function "-1"( X )
function "+1"( X )
end
class Integer : Number
function "+"( X, Y )
function "-"( X, Y )
function "*"( X, Y )
function "/"( X, Y )
function "<"( Z )
function ">"( Z )
function ">="( Z )
function "<="( Z )
function "="( Z )
function "<>"( Z )
function "and"( X, Y )
function "or"( X, Y )
end
class Real : Number
function "integer"( Z ) //típuskonverzió
function "+"( X, Y )
function "-"( X, Y )
function "*"( X, Y )
function "/"( X, Y )
function "<"( Z )
function ">"( Z )
function ">="( Z )
function "<="( Z )
function "="( Z )
function "<>"( Z )
end
A logikai értékek valójában integerek, a 0 == false és 1 == true.
String
class String
function "+"( X, Y ) //konkatenáció
function "<"( Z )
function ">"( Z )
function ">="( Z )
function "<="( Z )
function "="( Z )
function "<>"( Z )
function ":="( Z )
end
Lambda-kifejezés típus
class Definition
function "*"( I )
end
A Definition osztály egy objektuma egy lamda-kifejezés definícióját tartalmazza. A definíció belso reprezentációjának illeszkednie kell a lambda-kifejezés hívásának tényleges megvalósításához.
Szintaxis:
Lambda_definition = "{" "|" [ Parameter,{"," Parameter } ] "|" Expression "}"
Példa:
X := { | P, Q | 2 * P + A + Q }
P,Q a lambda-kifejezés paraméterei, a "*" kompozíció. A lambda kifejezés hívásához az EvalObject standard függvényt használjuk.
Y := EvalObject( X, [ 5, 7 ] )
A kivétel osztály, és a leszármazottjai
A kivétel biztonságos programírást tesz lehetővé, mindemelett a kivétellel átadhatjuk a program irányítását. Bármely objektum lehet kivétel. A standard kivétel osztály specifikációját a a System module tartalmazza.
-- Alaposztály
class Exception
function Create() constructor
function Show()
end
-- Nemdefiniált változó
class EUndefError : Exception
end
-- Unáris operátor hiányzik
class EUnary : Exception
end
-- Konverziós operátor hiányzik
class EConversion : Exception
end
-- Bináris operátor hiányzik
class EBinary : Exception
end
-- Hibás típusillesztés
class ETypeMismatch : Exception
end
-- Helytelen függvényhívás
class EFunctionCall : Exception
end
-- Nullával való osztás
class EDivByZero : Exception
end
Mutatók
A VIRT-ben nincsenek mutatók. Az adat struktúrákhoz máskép férhetünk hozzá. Ezt a mechanizmust azonosításnak vagy álnév hozzárendelésnek hívjuk. P = = E Itt P a változó, E egy kifejezés, a fenti sor lefutása után P az E álneve lesz. Minden művelet amit a P változón végzünk ekvivalens azzal, mintha az E kifejezésen végeznénk. Az azonosítás koncepció röviden a pointeres megközelítés tranzitív lezártja. Ha Q = = P és P = = E akkor Q = = E, ahogy a matematikában már megszoktuk.
Típus konstrukciók
Tömb típus
class Array
function Init( N ) constructor
function "[]"( I ) //a tomb I. eleme
end
A tömb osztály egy példánya fix számú tetszőleges típusú komponensből áll. Tömb osztály használatával lehetséges tetszőleges adatstruktúra építése futási időben.
A := array( M )
for I := 1 to M do
A[ I ] := array( N )
end
end
Ez egy kétdimenziós tömb, egy M*N-es mátrixot reprezentál.
A [] operator egy dimenziós tömbként kezeli a tömböt, ezért ha el akarjuk érni pl a tömb 3.sorának 5. elemét, akkor :
A := A[3][5]
Tömböt létrehozhatunk zárójelezés segítségével is. Pl a következő utasítás egy 'abc', 77, 3.14 elemekből álló tömböt hoz létre:
L := [ 'abc', [ 77, [ 3.14, * ] ] ]
Típusazonosság
T1 és T2 típus csak akkor azonosak, ha a nevük megegyezik.
Típuskonverzió
Csak implicit típuskonverzió van, tehát az ősosztály felé lehet konvertálni. Ha C a D őse, akkor a D osztályban definiálni kell egy "C" nevű metódust, ami elvégzi a típuskonverziót.
Példa:
class R : Integer
function InitR( InitP )
function "+"( X, Y )
function "*"( X, Y )
function "integer"( X )
end
implementation R
local shared P
function InitGF( InitP )
P := InitP
return 0
function "+"( X, Y )
Z := Integer."+"( X, Y )
if Z > P then
Integer."-"( Z, P )
end
return 0
function "*"( X, Y )
Z := Integer."*"( X, Y )
Z1 := Integer."/"( Z, P )
Z2 := Integer."*"( Z1, P )
Integer."-"( Z, Z2 )
return 0
function "integer"( X )
":="( X )
return Self()
end
R.InitR( 5 )
object I, J : R -- Declaration I, J
I := 4
J := 3
K := I + J -- Result : K = 2
L := I * J + 1 -- Result : L = 3
return
Változók, konstansok
Konstansok definiálása:
constant
Key = 1
Left = 2
Right = 3
ArrConst = [ '$1', '$2', '$3', '$4', '$5', '$6', '$7', '$8' ]
end
A jobb oldalon bármilyen literal állhat. String konstansokon csak + konkatenáció művelet végezhető, a Number típusra sé leszármazottaira alkamazhatóak a szokásos aritmetikai műveletek.
Operátorok
A VIRT gondoskodik a ":=" , "=" , "<>" operátorokról, minden adattípusra. Lehetőség van más operátorok definiálására a származtatott adattípusoknál, és a standard típusoknál a ":=" , "=", "<>" operátorok felüldefiniálására.
| Operation | Function | Number of parameter |
| Addition | "+" | 2 |
| Subtraction | "-" | 2 |
| Multiplication | "*" | 2 |
| Division | "/" | 2 |
| And | "and" | 2 |
| Or | "or" | 2 |
| Not | "not" | 0 |
| Greater than | ">" | 1 |
| Less than | "<" | 1 |
| Greater or equal | ">=" | 1 |
| Less or equal | "<=" | 1 |
| Equal | "=" | 1 |
| Not equal | "<>" | 1 |
| Indexing | "[]" | 1 |
| Assignment | ":=" | 1 |
| Unary plus | "+1" | 0 |
| Unary minus | "-1" | 0 |
Tehát például írhatunk először egy rendező függvényt az integerekre, aztán használhatjuk ugyanezt a függvényt akármelyik más osztály rendezésére. Ez úgy történik , hogy írunk egy "<" függvényt, majd az adott osztály implementációs részében elhelyezzük a definícióját.
Egyéb műveletek:
P = = E P pointerhez hasonlóan viselkedik (a pointereknél olvashatunk róla többet)
Destroy(P) Egséges objektum megsemmisítő. P megsemmisítése nem befolyásolja E-t az ő értéke megmarad. Destroy(@P) már megsemmisíti E tartalmát is
A @ operátort 3 esetben használjuk:
- Egy kifejezés megsemmisítésére (fenti példa)
- Ha P egy még nem konkretizált A változó álneve, akkor @P = = B eredménye az lesz hogy A egy álneve lesz a B-nek a közbülső P-n keresztűl.
- Ha C egy osztály neve, akkor @C visszaadja a legutóbb létrehozott C típusú objektumot.
A < < B A következő szekvencia rövidítése: A:=B Destroy(B)