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
};
};
Propriétés
Type | Visibilité | Source | Unité | Parent |
---|---|---|---|---|
record struct |
public | System.pas systvar.h |
System | System |
Description
TVarData représente les informations Variant.
TVarData est la classe de base pour les variants.
Remarque : La structure interne d'un variant telle qu'elle est définie par TVarData est identique au type Variant utilisé par les API OLE et Win32.
struct TVarData { union { Word VType; // compatible Delphi – membre de type Variant VARTYPE vt; // membre compatible tagVARIANT }; Word Reserved1; Word Reserved2; Word Reserved3; union { // Membres Variant compatibles Delphi 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 // Membres compatibles tagVARIANT (à partir de OAIDL.H) // Autorise tous types repérés [V] (peuvent apparaître dans un VARIANT à initialiser) 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; }; };
VType de TVarData contient le code du type du variant dans ses douze bits de poids faible (les bits définis par varTypeMask).
Les valeurs suivantes sont utilisées pour Vtype :
#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)
De plus, le bit varArray peut être initialisé pour indiquer que le variant est un tableau, et le bit varByRef peut être initialisé pour indiquer que le variant contient une référence (et non une valeur).
Word Reserved1; Word Reserved2; Word Reserved3;
Les membres Reserved1, Reserved2 et Reserved3 de TVarData ne sont pas utilisés.
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; };
Le contenu des huit bits restants de TVarData dépend du champ VType. Si aucun des bits varArray ou varByRef ne sont initialisés, le variant contient une valeur du type donné.
Si le bit varArray est initialisé, le variant contient un pointeur sur une structure TVarArray qui définit les spécificités du tableau. Le type de chaque élément du tableau est donné par les bits varTypeMask dans VType.
Si le bit varByRef est initialisé, le variant contient une référence à une valeur du type donné par les bits varTypeMask et varArray dans VType.
Exemples de code