_variant_t 数据类型介绍

_variant_t 和 _bstr_t 这两个类分别用于封装并管理 VARIANT 和 BSTR 这两种数据类型，VARIANT
和 BSTR 这两种类型是 COM 中使用的数据类型。为了将C++中的变量应用到ADO编程中，只能进行数据类型的转换。通过
_variant_t 和 _bstr_t 这两个类，就可以方便的把C++类型变量转换成COM中的变量了。

_variant_t的定义：COMUTIL.H

[cpp] view
plain copy

 print?

class _variant_t : public ::tagVARIANT {  

public:  

// Constructors  

//  

_variant_t() throw();  

_variant_t(const VARIANT& varSrc) throw(_com_error);  

_variant_t(const VARIANT* pSrc) th
4000
row(_com_error);  

_variant_t(const _variant_t& varSrc) throw(_com_error);  

_variant_t(VARIANT& varSrc, bool fCopy) throw(_com_error); // Attach VARIANT if !fCopy  

_variant_t(short sSrc, VARTYPE vtSrc = VT_I2) throw(_com_error); // Creates a VT_I2, or a VT_BOOL  

_variant_t(long lSrc, VARTYPE vtSrc = VT_I4) throw(_com_error); // Creates a VT_I4, a VT_ERROR, or a VT_BOOL  

_variant_t(float fltSrc) throw(); // Creates a VT_R4  

_variant_t(double dblSrc, VARTYPE vtSrc = VT_R8) throw(_com_error); // Creates a VT_R8, or a VT_DATE  

_variant_t(const CY& cySrc) throw(); // Creates a VT_CY  

_variant_t(const _bstr_t& bstrSrc) throw(_com_error); // Creates a VT_BSTR  

_variant_t(const wchar_t*pSrc) throw(_com_error); // Creates a VT_BSTR  

_variant_t(const char* pSrc) throw(_com_error); // Creates a VT_BSTR  

_variant_t(IDispatch* pSrc, bool fAddRef = true) throw(); // Creates a VT_DISPATCH  

_variant_t(bool bSrc) throw(); // Creates a VT_BOOL  

_variant_t(IUnknown* pSrc, bool fAddRef = true) throw(); // Creates a VT_UNKNOWN  

_variant_t(const DECIMAL& decSrc) throw(); // Creates a VT_DECIMAL  

_variant_t(BYTE bSrc) throw(); // Creates a VT_UI1  

// Destructor  

//  

~_variant_t() throw(_com_error);  

// Extractors  

//  

operator short() const throw(_com_error); // Extracts a short from a VT_I2  

operator long() const throw(_com_error); // Extracts a long from a VT_I4  

operator float() const throw(_com_error); // Extracts a float from a VT_R4  

operator double() const throw(_com_error); // Extracts a double from a VT_R8  

operator CY() const throw(_com_error); // Extracts a CY from a VT_CY  

operator _bstr_t() const throw(_com_error); // Extracts a _bstr_t from a VT_BSTR  

operator IDispatch*() const throw(_com_error); // Extracts a IDispatch* from a VT_DISPATCH  

operator bool() const throw(_com_error); // Extracts a bool from a VT_BOOL  

operator IUnknown*() const throw(_com_error); // Extracts a IUnknown* from a VT_UNKNOWN  

operator DECIMAL() const throw(_com_error); // Extracts a DECIMAL from a VT_DECIMAL  

operator BYTE() const throw(_com_error); // Extracts a BTYE (unsigned char) from a VT_UI1  

// Assignment operations  

//  

_variant_t& operator=(const VARIANT& varSrc) throw(_com_error);  

_variant_t& operator=(const VARIANT* pSrc) throw(_com_error);  

_variant_t& operator=(const _variant_t& varSrc) throw(_com_error);  

_variant_t& operator=(short sSrc) throw(_com_error); // Assign a VT_I2, or a VT_BOOL  

_variant_t& operator=(long lSrc) throw(_com_error); // Assign a VT_I4, a VT_ERROR or a VT_BOOL  

_variant_t& operator=(float fltSrc) throw(_com_error); // Assign a VT_R4  

_variant_t& operator=(double dblSrc) throw(_com_error); // Assign a VT_R8, or a VT_DATE  

_variant_t& operator=(const CY& cySrc) throw(_com_error); // Assign a VT_CY  

_variant_t& operator=(const _bstr_t& bstrSrc) throw(_com_error); // Assign a VT_BSTR  

_variant_t& operator=(const wchar_t* pSrc) throw(_com_error); // Assign a VT_BSTR  

_variant_t& operator=(const char* pSrc) throw(_com_error); // Assign a VT_BSTR  

_variant_t& operator=(IDispatch* pSrc) throw(_com_error); // Assign a VT_DISPATCH  

_variant_t& operator=(bool bSrc) throw(_com_error); // Assign a VT_BOOL  

_variant_t& operator=(IUnknown* pSrc) throw(_com_error); // Assign a VT_UNKNOWN  

_variant_t& operator=(const DECIMAL& decSrc) throw(_com_error); // Assign a VT_DECIMAL  

_variant_t& operator=(BYTE bSrc) throw(_com_error); // Assign a VT_UI1  

// Comparison operations  

//  

bool operator==(const VARIANT& varSrc) const throw(_com_error);  

bool operator==(const VARIANT* pSrc) const throw(_com_error);  

bool operator!=(const VARIANT& varSrc) const throw(_com_error);  

bool operator!=(const VARIANT* pSrc) const throw(_com_error);  

// Low-level operations  

//  

void Clear() throw(_com_error);  

void Attach(VARIANT& varSrc) throw(_com_error);  

VARIANT Detach() throw(_com_error);  

void ChangeType(VARTYPE vartype, const _variant_t* pSrc = NULL) throw(_com_error);  

void SetString(const char* pSrc) throw(_com_error); // used to set ANSI string  

};  

_variant_t 是一个类，是 VARIANT 的完全包装类，它提供多种构造函数和数据转换函数。它继承自一个结构体，其结构如下：

[cpp] view
plain copy

 print?

struct tagVARIANT  

{  

union  

{  

struct __tagVARIANT  

{  

VARTYPE vt;  

WORD wReserved1;  

WORD wReserved2;  

WORD wReserved3;  

union  

{  

LONG lVal;  

BYTE bVal;  

SHORT iVal;  

FLOAT fltVal;  

DOUBLE dblVal;  

VARIANT_BOOL boolVal;  

_VARIANT_BOOL bool;  

SCODE scode;  

CY cyVal;  

DATE date;  

BSTR bstrVal;  

IUnknown __RPC_FAR *punkVal;  

IDispatch __RPC_FAR *pdispVal;  

SAFEARRAY __RPC_FAR *parray;  

BYTE __RPC_FAR *pbVal;  

SHORT __RPC_FAR *piVal;  

LONG __RPC_FAR *plVal;  

FLOAT __RPC_FAR *pfltVal;  

DOUBLE __RPC_FAR *pdblVal;  

VARIANT_BOOL __RPC_FAR *pboolVal;  

_VARIANT_BOOL __RPC_FAR *pbool;  

SCODE __RPC_FAR *pscode;  

CY __RPC_FAR *pcyVal;  

DATE __RPC_FAR *pdate;  

BSTR __RPC_FAR *pbstrVal;  

IUnknown __RPC_FAR *__RPC_FAR *ppunkVal;  

IDispatch __RPC_FAR *__RPC_FAR *ppdispVal;  

SAFEARRAY __RPC_FAR *__RPC_FAR *pparray;  

VARIANT __RPC_FAR *pvarVal;  

PVOID byref;  

CHAR cVal;  

USHORT uiVal;  

ULONG ulVal;  

INT intVal;  

UINT uintVal;  

DECIMAL __RPC_FAR *pdecVal;  

CHAR __RPC_FAR *pcVal;  

USHORT __RPC_FAR *puiVal;  

ULONG __RPC_FAR *pulVal;  

INT __RPC_FAR *pintVal;  

UINT __RPC_FAR *puintVal;  

struct __tagBRECORD  

{  

PVOID pvRecord;  

IRecordInfo __RPC_FAR *pRecInfo;  

} __VARIANT_NAME_4;  

} __VARIANT_NAME_3;  

} __VARIANT_NAME_2;  

DECIMAL decVal;  

} __VARIANT_NAME_1;  

};  

 其中，vt 表示的是 _variant_t 的数据类型，它的取值是以下枚举结构的值：

[cpp] view
plain copy

 print?

enum VARENUM  

{  

VT_EMPTY = 0 [V] [P] nothing  

VT_NULL =1 [V] [P] SQL style Null  

VT_I2 =2 [V][T][P][S] 2 byte signed int  

VT_I4 =3 [V][T][P][S] 4 byte signed int  

VT_R4 = 4 [V][T][P][S] 4 byte real  

VT_R8 = 5 [V][T][P][S] 8 byte real  

VT_CY = 6 [V][T][P][S] currency  

VT_DATE =7 [V][T][P][S] date  

VT_BSTR =8 [V][T][P][S] OLE Automation string  

VT_DISPATCH =9 [V][T][P][S] IDispatch *  

VT_ERROR =10 [V][T][P][S] SCODE  

VT_BOOL =11 [V][T][P][S] True=-1, False=0  

VT_VARIANT =12 [V][T][P][S] VARIANT *  

VT_UNKNOWN =13 [V][T] [S] IUnknown *  

VT_DECIMAL =14 [V][T] [S] 16 byte fixed point  

VT_RECORD =36 [V] [P][S] user defined type  

VT_I1 = 16 [V][T][P][s] signed char  

VT_UI1 =17 [V][T][P][S] unsigned char  

VT_UI2 =18 [V][T][P][S] unsigned short  

VT_UI4 =19 [V][T][P][S] unsigned short  

VT_I8 =20 [T][P] signed 64-bit int  

VT_UI8 =21 [T][P] unsigned 64-bit int  

VT_INT =22 [V][T][P][S] signed machine int  

VT_UINT =23 [V][T] [S] unsigned machine int  

VT_VOID =24 [T] C style void  

VT_HRESULT =25 [T] Standard return type  

VT_PTR =26 [T] pointer type  

VT_SAFEARRAY =27 [T] (use VT_ARRAY in VARIANT)  

VT_CARRAY = 28 [T] C style array  

VT_USERDEFINED =29 [T] user defined type  

VT_LPSTR = 30 [T][P] null terminated string  

VT_LPWSTR =31 [T][P] wide null terminated string  

VT_FILETIME = 64 [P] FILETIME  

VT_BLOB = 65 [P] Length prefixed bytes  

VT_STREAM =66 [P] Name of the stream follows  

VT_STORAGE =67 [P] Name of the storage follows  

VT_STREAMED_OBJECT =68 [P] Stream contains an object  

VT_STORED_OBJECT =69 [P] Storage contains an object  

VT_BLOB_OBJECT =70 [P] Blob contains an object  

VT_CF = 71 [P] Clipboard format  

VT_CLSID =72 [P] A Class ID  

VT_VECTOR = 0x1000 [P] simple counted array  

VT_ARRAY = 0x2000 [V] SAFEARRAY*  

VT_BYREF = 0x4000 [V] void* for local use  

VT_BSTR_BLOB =0xfff Reserved for system use  

VT_RESERVED = 0x8000,  

VT_ILLEGAL = 0xffff,  

VT_ILLEGALMASKED = 0xfff,  

VT_TYPEMASK = 0xfff  

};  

_variant_t 变量初始化时调用的是 _variant_t 的构造函数。如果用一个int型的变量对数字类的变量进行初始化，会出错，因为 _variant_t 的构造函数中没用用整型对其初始化的构造函数，可先将整型转化成long对其进行初始化，赋值操作与构造函数类似，也可如下操作：

[cpp] view
plain copy

 print?

int a = 2000;  

_variant_t var;  

var.vt = VT_I2;  

var.lVal = a;  

对于没有构造函数的数据类型都可以这样赋值。

对于有构造函数的就可以直接利用构造函数赋值，例如：

[cpp] view
plain copy

 print?

long l=222;   

_variant_t lVal(l);