System.TVarData
Delphi
TVarData = packed record
case Integer of
0: (VType: TVarType;
case Integer of
0: (Reserved1: Word;
case Integer of
0: (Reserved2, Reserved3: Word;
case Integer of
varSmallInt: (VSmallInt: SmallInt);
varInteger: (VInteger: Integer);
varSingle: (VSingle: Single);
varDouble: (VDouble: Double);
varCurrency: (VCurrency: Currency);
varDate: (VDate: TDateTime);
varOleStr: (VOleStr: PWideChar);
varDispatch: (VDispatch: Pointer);
varError: (VError: HRESULT);
varBoolean: (VBoolean: WordBool);
varUnknown: (VUnknown: Pointer);
varShortInt: (VShortInt: ShortInt);
varByte: (VByte: Byte);
varWord: (VWord: Word);
-1: (VLongWord: Cardinal {deprecated 'use VUInt32'});
varUInt32: (VUInt32: UInt32);
varInt64: (VInt64: Int64);
varUInt64: (VUInt64: UInt64);
varString: (VString: Pointer);
varAny: (VAny: Pointer);
varArray: (VArray: PVarArray);
varByRef: (VPointer: Pointer);
varUString: (VUString: Pointer);
varRecord: (VRecord: TVarRecord);
);
1: (VLongs: array[0..{$IFDEF CPU64BITS}4{$ELSE}2{$ENDIF}] of Integer);
);
2: (VWords: array [0..{$IFDEF CPU64BITS}10{$ELSE}6{$ENDIF}] of Word);
3: (VBytes: array [0..{$IFDEF CPU64BITS}21{$ELSE}13{$ENDIF}] of Byte);
);
1: (RawData: array [0..{$IFDEF CPU64BITS}5{$ELSE}3{$ENDIF}] of Integer);
end;
C++
struct TVarData
{
union
{
uint16_t VType; // Delphi-compatible - Variant Type member
#if defined(VARIANT_NATIVE_SUPPORT)
VARTYPE vt; // tagVARIANT compatible member
#else
uint16_t vt; // Expose a generic 'vt' member
#endif
};
uint16_t Reserved1;
uint16_t Reserved2;
uint16_t Reserved3;
union
{
System::Smallint VSmallint; // iVal
System::Integer VInteger; // lVal
System::Single VSingle; // fltVal
System::Double VDouble; // dblVal
System::CurrencyBase VCurrency; // cyVal
System::TDateTimeBase VDate; // date
System::PWideChar VOleStr; // bstrVal
#ifdef _WIN32
IDispatch* VDispatch; // pdispVal
#else
System::IDispatch* VDispatch; // pdispVal
#endif
System::HResult VError; // scode
System::WordBool VBoolean; // boolVal
IUnknown* VUnknown; // punkVal
System::Byte VByte; // bVal
System::Int8 VShortint; // charVal
System::Int8 VShortInt; // charVal
System::Pointer VString; // ??????
System::PVarArray VArray; // parray
System::Pointer VPointer; // byref
__int64 VInt64; // llVal
unsigned __int64 VUInt64; // ullVal
System::Word VWord; // uiVal
System::LongWord VLongWord; // ulVal
System::TVarRecord VRecord; // struct __tagBRECORD
#if defined(VARIANT_NATIVE_SUPPORT)
LONG lVal;
BYTE bVal;
SHORT iVal;
FLOAT fltVal;
DOUBLE dblVal;
VARIANT_BOOL boolVal;
SCODE scode;
CY cyVal;
DATE date;
BSTR bstrVal;
LONG64 llVal;
ULONG64 ullVal;
IUnknown *punkVal;
IDispatch *pdispVal;
SAFEARRAY *parray;
BYTE *pbVal;
SHORT *piVal;
LONG *plVal;
FLOAT *pfltVal;
DOUBLE *pdblVal;
VARIANT_BOOL *pboolVal;
SCODE *pscode;
CY *pcyVal;
DATE *pdate;
BSTR *pbstrVal;
IUnknown **ppunkVal;
IDispatch **ppdispVal;
SAFEARRAY **pparray;
VARIANT *pvarVal;
PVOID byref;
CHAR cVal;
USHORT uiVal;
ULONG ulVal;
INT intVal;
UINT uintVal;
DECIMAL *pdecVal;
CHAR *pcVal;
USHORT *puiVal;
ULONG *pulVal;
INT *pintVal;
UINT *puintVal;
LONG64 *pllVal;
ULONG64 *pullVal;
#endif
};
};
Eigenschaften
| Typ | Sichtbarkeit | Quelle | Unit | Übergeordnet |
|---|---|---|---|---|
record struct |
public | System.pas systvar.h |
System | System |
Beschreibung
TVarData repräsentiert Variant-Daten.
TVarData ist die Basisklasse für Variant.
Anmerkung: Die interne Struktur eines Variant-Objekts wird durch TVarData definiert und ist mit dem in OLE und den Win32-APIs verwendeten Variant-Typ identisch.
struct TVarData]
{
union
{
Word VType; // Delphi-kompatibel - Element des Variant-Typs
VARTYPE vt; // tagVARIANT kompatibles Element
};
Word Reserved1;
Word Reserved2;
Word Reserved3;
union
{
// Delphi-kompatible Variant-Elemente
Smallint VSmallint; // iVal
Integer VInteger; // lVal
Single VSingle; // fltVal
Double VDouble; // dblVal
CurrencyBase VCurrency; // cyVal
TDateTimeBase VDate; // date
PWideChar VOleStr; // bstrVal
IDispatch* VDispatch; // pdispVal
HResult VError; // scode
WordBool VBoolean; // boolVal
IUnknown* VUnknown; // punkVal
Byte VByte; // bVal
Pointer VString; // ??????
PVarArray VArray; // parray
Pointer VPointer; // byref
// tagVARIANT kompatible Elemente (aus OAIDL.H)
// Lässt alle mit [V] gekennzeichneten Typen zu (können in einem VARIANT initialisiert werden)
LONG lVal;
BYTE bVal;
SHORT iVal;
FLOAT fltVal;
DOUBLE dblVal;
VARIANT_BOOL boolVal;
SCODE scode;
CY cyVal;
DATE date;
BSTR bstrVal;
IUnknown *punkVal;
IDispatch *pdispVal;
SAFEARRAY *parray;
BYTE *pbVal;
SHORT *piVal;
LONG *plVal;
FLOAT *pfltVal;
DOUBLE *pdblVal;
VARIANT_BOOL *pboolVal;
SCODE *pscode;
CY *pcyVal;
DATE *pdate;
BSTR *pbstrVal;
IUnknown **ppunkVal;
IDispatch **ppdispVal;
SAFEARRAY **pparray;
VARIANT *pvarVal;
PVOID byref;
CHAR cVal;
USHORT uiVal;
ULONG ulVal;
INT intVal;
UINT uintVal;
DECIMAL *pdecVal;
CHAR *pcVal;
USHORT *puiVal;
ULONG *pulVal;
INT *pintVal;
UINT *puintVal;
};
};
Das Feld VType eines TVarData-Objekts enthält den Typcode der Varianten in den niederwertigen zwölf Bits (die durch varTypeMask definiert werden).
Die folgende Werte werden für VType verwendet:
#define varEmpty (Byte)(0) #define varNull (ByteByte_Type)(1) #define varSmallint (ByteByte_Type)(2) #define varInteger (ByteByte_Type)(3) #define varSingle (ByteByte_Type)(4) #define varDouble (ByteByte_Type)(5) #define varCurrency (ByteByte_Type)(6) #define varDate (ByteByte_Type)(7) #define varOleStr (ByteByte_Type)(8) #define varDispatch (ByteByte_Type)(9) #define varError (ByteByte_Type)(10) #define varBoolean (ByteByte_Type)(11) #define varVariant (ByteByte_Type)(12) #define varUnknown (ByteByte_Type)(13) #define varByte (ByteByte_Type)(17) #define varString (WordWord_Type)(256) #define varTypeMask (WordWord_Type)(4095) #define varArray (WordWord_Type)(8192) #define varByRef (WordWord_Type)(16384) #define varStrArg (ByteByte_Type)(72) #define vtInteger (ByteByte_Type)(0) #define vtBoolean (ByteByte_Type)(1) #define vtChar (ByteByte_Type)(2) #define vtExtended (ByteByte_Type)(3) #define vtString (ByteByte_Type)(4) #define vtPointer (ByteByte_Type)(5) #define vtPChar (ByteByte_Type)(6) #define vtObject (ByteByte_Type)(7) #define vtClass (ByteByte_Type)(8) #define vtWideChar (ByteByte_Type)(9) #define vtPWideChar (ByteByte_Type)(10) #define vtAnsiString (ByteByte_Type)(11) #define vtCurrency (ByteByte_Type)(12) #define vtVariant (ByteByte_Type)(13)
Außerdem kann durch Setzen des Bits varArray angezeigt werden, dass die Variante ein Array ist. Durch Setzen des Bits varByRef kann angegeben werden, dass die Variante eine Referenz statt eines Wertes enthält.
Word Reserved1; Word Reserved2; Word Reserved3;
Die Felder Reserved1, Reserved2 und Reserved3 eines TVarData-Objekts werden nicht benutzt.
union
{
Smallint VSmallint;
Integer VInteger;
Single VSingle;
Double VDouble;
CurrencyBase VCurrency;
TDateTimeBase VDate;
PWideChar VOleStr;
Ole2::IDispatch* VDispatch;
Integer VError;
WordBool VBoolean;
Ole2::IUnknown* VUnknown;
Byte VByte;
Pointer VString;
PVarArray VArray;
Pointer VPointer;
};
Der Inhalt der verbleibenden acht Bytes eines TVarData-Objekts ist vom Feld VType abhängig. Wenn weder das Bit varArray noch das varByRef gesetzt ist, enthält das Variant-Objekt einen Wert des angegebenen Typs.
Ist das Bit varArray gesetzt, enthält das Variant-Objekt einen Zeiger auf eine TVarArray-Struktur mit den Array-Spezifikationen. Der Typ der einzelnen Array-Elemente wird durch die varTypeMask-Bits im Feld VType angegeben.
Ist das Bit varByRef gesetzt, enthält das Variant-Objekt eine Referenz auf einen Wert des Typs, der in den Bits varTypeMask und varArray in VType festgelegt ist.
Codebeispiele