A Variant típus használata

A Delphi nyelv az erősen típusos programozási nyelvek közé tartozik. Minden egyes változónak vagy objektumnak meg kell adnunk a típusát. Ez meghatározza azt az adatszerkezetet vagy értékkészletet, amelyet az adott változó vagy objektum felvehet.

Néha azonban szükségünk lehet arra, hogy olyan változókat használjunk, amelyek típusa fordítási időben még nincs meghatározva. Esetleg típusuk futási időben módosulhasson.

Erre a problémára kínál megoldást a Variant típus használata. A Variant-ok használata nagyobb rugalmasságot kínál a hagyományos változókkal szemben. A rugalmasságért cserébe nagyobb memóriaterületet kell biztosítanunk, mint a hagyományos változók számára. Egy nagy hátrányuk, hogy fordítási időben nem jelentkeznek a használatuk során fellépő esetleges hibák, csak futási időben. Ez nagyban megnehezíti az alkalmazások fejlesztését és kétségtelenül nagyobb körültekintést igényel.

Egy Variant változó majdnem minden fajta típusú értéket tárolhat. A kivételek a következők: állományok, halmazok, mutatók, osztályok, osztály referenciák, rekordok, statikus tömbök. Tárolhatnak azonban dinamikus tömböket és interface-eket.

Egy művelet megadása során vegyíthetjük a különböző típusú értékeket tartalmazó Variant-okat. Legyenek azok integer, real vagy akár string típusúak. A Delphi fordító ilyenkor meghatározza azt a legnagyobb értékkészletet (típust), amelybe az eredmény belefér, és a művelet eredménye ezzel a típussal fog rendelkezni.

A Variant típus a Variants unitban található.

Hozzuk létre a következő deklarációt.

var a,b,c,d: Variant;

A forráskódban ezeknek a változóknak bármilyen értéket adhatunk.

a:=10;
b:=625.2;
c:='115';
d:=a+b+c;

Az a értéke integer, b értéke float, c értéke pedig string típusú lesz. Az érdekes az, hogy a d változónak értékül adhatunk egy olyan kifejezést, amely három különböző típusú adatot tartalmaz. Nos ez az a típuskonverzió, amiről a Delphi fordítója gondoskodik. A d értéke ebben az esetbe float lesz, hiszen ez a legnagyobb halmaz a három közül. A c változó tartalmának ilyenkor számnak kell lenni. Ha a c változó nem számot tartalmazna, akkor az összeadási művelet hibát eredményezne.

Amikor felhasználjuk a Variant változók tartalmát, nekünk kell gondoskodnunk a megfelelő értékkonverziókról. Nézzünk egy példát a b változó tartalmának megjelenítésére.

Memo1.Lines.Add('b='+FloatToStr(b)+' {float}');

Ha a FloatToStr helyett mondjuk IntToStr állna, akkor egy kerekített integer típusú értéket kapnánk, azaz 625-öt.

A Variant nagy előnye az is, hogy egyetlen változóban több típusú értéket is tárolhatunk. Helyes például a következő utasítássorozat.

a:=15;
a:='string';
a:=781.136;

A Variant típus statikus tömb tárolására nem alkalmas. Egy Variant tömböt a következőképpen hozhatunk létre.

var t: Variant;
. . .
t:=VarArrayCreate([1,5],varInteger);

Ilyenkor a t egy integereket tartalmazó tömb lesz. Az első elem indexe 1, az utolsóé pedig 5 lesz. Az egyes elemek elérése ugyanúgy történik, mint egy hagyományos tömb esetében.

for i:=1 to 5 do
  t[i]:=Random(30000);

A varInteger helyén a következő típusdefiníciók szerepelhetnek: varAny, varArray, varBoolean, varByRef, varByte, varCurrency, varDate, varDispatch, varDouble, varEmpty, varError, varInt64, varInteger, varLongWord, varNull, varOleStr, varShortInt, varSingle, varSmallint, varString, varStrArg, varTypeMask, varUnknown, varVariant, varWord.

A Variant típus egy speciális változata az OLEVariant. Segítségével a rendszer OLEAutomation objektumait használhatjuk fel. Az alábbi példában megnyitjuk a Microsoft Word programot.

var WordApp: OLEVariant;
. . .
WordApp:=CreateOLEObject('Word.Application');
WordApp.Visible:=True;

A CreateOLEObject használatához a uses listában fel kell sorolnunk a COMOBJ unit nevét. A 'Word.Application' meghatároz egy interface-t, jelen esetben egy Word alkalmazást. Az OLEVariant használata során csak futási időben derül ki, hogy például a WordApp.Visible egy létező tulajdonság-e.

Amikor egy Variant típusú változónak még nem adunk kezdőértéket, akkor tartalma UnAssigned. A VarIsEmpty függvénnyel kérdezhetjük le, hogy a változóhoz van-e érték hozzárendelve.

if not VarIsEmpty(a) then 
  Memo1.Lines.Add('a='+IntToStr(a));

A VarIsType függvény segítségével megvizsgálhatunk egy Variant változót, hogy adott típusú-e.

if VarIsType(b,varString) then
  Memo1.Lines.Add('b='+b);

Ha egy konkrét típusra vagyunk csak kíváncsiak, akkor használhatóak az alábbi típusú függvények is.

function VarIsArray(const A: Variant): Boolean;
function VarIsFloat(const V: Variant): Boolean;
function VarIsNull(const V: Variant): Boolean;
function VarIsNumeric(const V: Variant): Boolean;
function VarIsStr(const V: Variant): Boolean;

A függvények visszatérési értéke igaz, ha a megadott Variant típusú változó az adott típusba besorolható.

A VarInRange függvény segítségével lekérdezhetjük, hogy a megadott Variant változó a megadott értéktartományon belül van-e.

function VarInRange(const AValue, AMin, AMax: Variant): Boolean;

Az AValue paraméterben kell megadni a változót. Az AMin és AMax az intervallum minimum és maximum értékeit határozzák meg.

Két Variant egyenlőségét a VarSameValue függvénnyel határozhatjuk meg.

function VarSameValue(const A, B: Variant): Boolean;

A függvény értéke akkor igaz, ha a két változó azonos értékkel rendelkezik.

A VarCompareValue függvénnyel logikailag összehasonlíthatjuk két Variant értékét.

function VarCompareValue(const A, B: Variant): TVariantRelationship;

Az eredmény a következő lehet: vrEqual – A = B, vrLessThan – A < B, vrGreaterThan – A > B, vrNotEqual – A vagy B közül az egyik Null értéket tartalmaz.

A VarToStr függvény segítségével egy Variant-ban szereplő adatokat String-é konvertálhatunk.

function VarToStr(const V: Variant): string;

A Variant tömbök esetében a dimenziók számát, valamint egy dimenzió minimum és maximum indexét a következő függvényekkel kérdezhetjük le.

function VarArrayDimCount(const A: Variant): Integer;
function VarArrayLowBound(const A: Variant; Dim: Integer): Integer;
function VarArrayHighBound(const A: Variant; Dim: Integer): Integer;