_variant_t 数据类型介绍

于 2017-08-14 13:44:39 发布
阅读量1.8k 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imJaron/article/details/77160692
版权

_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 ?
  1. class _variant_t : public ::tagVARIANT {  
  2. public:  
  3. // Constructors  
  4. //  
  5. _variant_t() throw();  
  6. _variant_t(const VARIANT& varSrc) throw(_com_error);  
  7. _variant_t(const VARIANT* pSrc) throw(_com_error);  
  8. _variant_t(const _variant_t& varSrc) throw(_com_error);  
  9. _variant_t(VARIANT& varSrc, bool fCopy) throw(_com_error); // Attach VARIANT if !fCopy  
  10. _variant_t(short sSrc, VARTYPE vtSrc = VT_I2) throw(_com_error); // Creates a VT_I2, or a VT_BOOL  
  11. _variant_t(long lSrc, VARTYPE vtSrc = VT_I4) throw(_com_error); // Creates a VT_I4, a VT_ERROR, or a VT_BOOL  
  12. _variant_t(float fltSrc) throw(); // Creates a VT_R4  
  13. _variant_t(double dblSrc, VARTYPE vtSrc = VT_R8) throw(_com_error); // Creates a VT_R8, or a VT_DATE  
  14. _variant_t(const CY& cySrc) throw(); // Creates a VT_CY  
  15. _variant_t(const _bstr_t& bstrSrc) throw(_com_error); // Creates a VT_BSTR  
  16. _variant_t(const wchar_t*pSrc) throw(_com_error); // Creates a VT_BSTR  
  17. _variant_t(const char* pSrc) throw(_com_error); // Creates a VT_BSTR  
  18. _variant_t(IDispatch* pSrc, bool fAddRef = true) throw(); // Creates a VT_DISPATCH  
  19. _variant_t(bool bSrc) throw(); // Creates a VT_BOOL  
  20. _variant_t(IUnknown* pSrc, bool fAddRef = true) throw(); // Creates a VT_UNKNOWN  
  21. _variant_t(const DECIMAL& decSrc) throw(); // Creates a VT_DECIMAL  
  22. _variant_t(BYTE bSrc) throw(); // Creates a VT_UI1  
  23. // Destructor  
  24. //  
  25. ~_variant_t() throw(_com_error);  
  26. // Extractors  
  27. //  
  28. operator short() const throw(_com_error); // Extracts a short from a VT_I2  
  29. operator long() const throw(_com_error); // Extracts a long from a VT_I4  
  30. operator float() const throw(_com_error); // Extracts a float from a VT_R4  
  31. operator double() const throw(_com_error); // Extracts a double from a VT_R8  
  32. operator CY() const throw(_com_error); // Extracts a CY from a VT_CY  
  33. operator _bstr_t() const throw(_com_error); // Extracts a _bstr_t from a VT_BSTR  
  34. operator IDispatch*() const throw(_com_error); // Extracts a IDispatch* from a VT_DISPATCH  
  35. operator bool() const throw(_com_error); // Extracts a bool from a VT_BOOL  
  36. operator IUnknown*() const throw(_com_error); // Extracts a IUnknown* from a VT_UNKNOWN  
  37. operator DECIMAL() const throw(_com_error); // Extracts a DECIMAL from a VT_DECIMAL  
  38. operator BYTE() const throw(_com_error); // Extracts a BTYE (unsigned char) from a VT_UI1  
  39. // Assignment operations  
  40. //  
  41. _variant_t& operator=(const VARIANT& varSrc) throw(_com_error);  
  42. _variant_t& operator=(const VARIANT* pSrc) throw(_com_error);  
  43. _variant_t& operator=(const _variant_t& varSrc) throw(_com_error);  
  44. _variant_t& operator=(short sSrc) throw(_com_error); // Assign a VT_I2, or a VT_BOOL  
  45. _variant_t& operator=(long lSrc) throw(_com_error); // Assign a VT_I4, a VT_ERROR or a VT_BOOL  
  46. _variant_t& operator=(float fltSrc) throw(_com_error); // Assign a VT_R4  
  47. _variant_t& operator=(double dblSrc) throw(_com_error); // Assign a VT_R8, or a VT_DATE  
  48. _variant_t& operator=(const CY& cySrc) throw(_com_error); // Assign a VT_CY  
  49. _variant_t& operator=(const _bstr_t& bstrSrc) throw(_com_error); // Assign a VT_BSTR  
  50. _variant_t& operator=(const wchar_t* pSrc) throw(_com_error); // Assign a VT_BSTR  
  51. _variant_t& operator=(const char* pSrc) throw(_com_error); // Assign a VT_BSTR  
  52. _variant_t& operator=(IDispatch* pSrc) throw(_com_error); // Assign a VT_DISPATCH  
  53. _variant_t& operator=(bool bSrc) throw(_com_error); // Assign a VT_BOOL  
  54. _variant_t& operator=(IUnknown* pSrc) throw(_com_error); // Assign a VT_UNKNOWN  
  55. _variant_t& operator=(const DECIMAL& decSrc) throw(_com_error); // Assign a VT_DECIMAL  
  56. _variant_t& operator=(BYTE bSrc) throw(_com_error); // Assign a VT_UI1  
  57. // Comparison operations  
  58. //  
  59. bool operator==(const VARIANT& varSrc) const throw(_com_error);  
  60. bool operator==(const VARIANT* pSrc) const throw(_com_error);  
  61. bool operator!=(const VARIANT& varSrc) const throw(_com_error);  
  62. bool operator!=(const VARIANT* pSrc) const throw(_com_error);  
  63. // Low-level operations  
  64. //  
  65. void Clear() throw(_com_error);  
  66. void Attach(VARIANT& varSrc) throw(_com_error);  
  67. VARIANT Detach() throw(_com_error);  
  68. void ChangeType(VARTYPE vartype, const _variant_t* pSrc = NULL) throw(_com_error);  
  69. void SetString(const char* pSrc) throw(_com_error); // used to set ANSI string  
  70. };  

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

[cpp]  view plain  copy
 print ?
  1. struct tagVARIANT  
  2. {  
  3. union  
  4. {  
  5. struct __tagVARIANT  
  6. {  
  7. VARTYPE vt;  
  8. WORD wReserved1;  
  9. WORD wReserved2;  
  10. WORD wReserved3;  
  11. union  
  12. {  
  13. LONG lVal;  
  14. BYTE bVal;  
  15. SHORT iVal;  
  16. FLOAT fltVal;  
  17. DOUBLE dblVal;  
  18. VARIANT_BOOL boolVal;  
  19. _VARIANT_BOOL bool;  
  20. SCODE scode;  
  21. CY cyVal;  
  22. DATE date;  
  23. BSTR bstrVal;  
  24. IUnknown __RPC_FAR *punkVal;  
  25. IDispatch __RPC_FAR *pdispVal;  
  26. SAFEARRAY __RPC_FAR *parray;  
  27. BYTE __RPC_FAR *pbVal;  
  28. SHORT __RPC_FAR *piVal;  
  29. LONG __RPC_FAR *plVal;  
  30. FLOAT __RPC_FAR *pfltVal;  
  31. DOUBLE __RPC_FAR *pdblVal;  
  32. VARIANT_BOOL __RPC_FAR *pboolVal;  
  33. _VARIANT_BOOL __RPC_FAR *pbool;  
  34. SCODE __RPC_FAR *pscode;  
  35. CY __RPC_FAR *pcyVal;  
  36. DATE __RPC_FAR *pdate;  
  37. BSTR __RPC_FAR *pbstrVal;  
  38. IUnknown __RPC_FAR *__RPC_FAR *ppunkVal;  
  39. IDispatch __RPC_FAR *__RPC_FAR *ppdispVal;  
  40. SAFEARRAY __RPC_FAR *__RPC_FAR *pparray;  
  41. VARIANT __RPC_FAR *pvarVal;  
  42. PVOID byref;  
  43. CHAR cVal;  
  44. USHORT uiVal;  
  45. ULONG ulVal;  
  46. INT intVal;  
  47. UINT uintVal;  
  48. DECIMAL __RPC_FAR *pdecVal;  
  49. CHAR __RPC_FAR *pcVal;  
  50. USHORT __RPC_FAR *puiVal;  
  51. ULONG __RPC_FAR *pulVal;  
  52. INT __RPC_FAR *pintVal;  
  53. UINT __RPC_FAR *puintVal;  
  54. struct __tagBRECORD  
  55. {  
  56. PVOID pvRecord;  
  57. IRecordInfo __RPC_FAR *pRecInfo;  
  58. } __VARIANT_NAME_4;  
  59. } __VARIANT_NAME_3;  
  60. } __VARIANT_NAME_2;  
  61. DECIMAL decVal;  
  62. } __VARIANT_NAME_1;  
  63. };  
 其中，vt 表示的是  _variant_t 的数据类型，它的取值是以下枚举结构的值：

[cpp]  view plain  copy
 print ?
  1. enum VARENUM  
  2. {  
  3. VT_EMPTY = 0 [V] [P] nothing  
  4. VT_NULL =1 [V] [P] SQL style Null  
  5. VT_I2 =2 [V][T][P][S] 2 byte signed int  
  6. VT_I4 =3 [V][T][P][S] 4 byte signed int  
  7. VT_R4 = 4 [V][T][P][S] 4 byte real  
  8. VT_R8 = 5 [V][T][P][S] 8 byte real  
  9. VT_CY = 6 [V][T][P][S] currency  
  10. VT_DATE =7 [V][T][P][S] date  
  11. VT_BSTR =8 [V][T][P][S] OLE Automation string  
  12. VT_DISPATCH =9 [V][T][P][S] IDispatch *  
  13. VT_ERROR =10 [V][T][P][S] SCODE  
  14. VT_BOOL =11 [V][T][P][S] True=-1, False=0  
  15. VT_VARIANT =12 [V][T][P][S] VARIANT *  
  16. VT_UNKNOWN =13 [V][T] [S] IUnknown *  
  17. VT_DECIMAL =14 [V][T] [S] 16 byte fixed point  
  18. VT_RECORD =36 [V] [P][S] user defined type  
  19. VT_I1 = 16 [V][T][P][s] signed char  
  20. VT_UI1 =17 [V][T][P][S] unsigned char  
  21. VT_UI2 =18 [V][T][P][S] unsigned short  
  22. VT_UI4 =19 [V][T][P][S] unsigned short  
  23. VT_I8 =20 [T][P] signed 64-bit int  
  24. VT_UI8 =21 [T][P] unsigned 64-bit int  
  25. VT_INT =22 [V][T][P][S] signed machine int  
  26. VT_UINT =23 [V][T] [S] unsigned machine int  
  27. VT_VOID =24 [T] C style void  
  28. VT_HRESULT =25 [T] Standard return type  
  29. VT_PTR =26 [T] pointer type  
  30. VT_SAFEARRAY =27 [T] (use VT_ARRAY in VARIANT)  
  31. VT_CARRAY = 28 [T] C style array  
  32. VT_USERDEFINED =29 [T] user defined type  
  33. VT_LPSTR = 30 [T][P] null terminated string  
  34. VT_LPWSTR =31 [T][P] wide null terminated string  
  35. VT_FILETIME = 64 [P] FILETIME  
  36. VT_BLOB = 65 [P] Length prefixed bytes  
  37. VT_STREAM =66 [P] Name of the stream follows  
  38. VT_STORAGE =67 [P] Name of the storage follows  
  39. VT_STREAMED_OBJECT =68 [P] Stream contains an object  
  40. VT_STORED_OBJECT =69 [P] Storage contains an object  
  41. VT_BLOB_OBJECT =70 [P] Blob contains an object  
  42. VT_CF = 71 [P] Clipboard format  
  43. VT_CLSID =72 [P] A Class ID  
  44. VT_VECTOR = 0x1000 [P] simple counted array  
  45. VT_ARRAY = 0x2000 [V] SAFEARRAY*  
  46. VT_BYREF = 0x4000 [V] void* for local use  
  47. VT_BSTR_BLOB =0xfff Reserved for system use  
  48. VT_RESERVED = 0x8000,  
  49. VT_ILLEGAL = 0xffff,  
  50. VT_ILLEGALMASKED = 0xfff,  
  51. VT_TYPEMASK = 0xfff  
  52. };  
_variant_t  变量初始化时调用的是  _variant_t  的构造函数。如果用一个int型的变量对数字类的变量进行初始化，会出错，因为  _variant_t  的构造函数中没用用整型对其初始化的构造函数，可先将整型转化成long对其进行初始化，赋值操作与构造函数类似，也可如下操作：

[cpp]  view plain  copy
 print ?
  1. int a = 2000;  
  2. _variant_t var;  
  3. var.vt = VT_I2;  
  4. var.lVal = a;  

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

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

[cpp]  view plain  copy
 print ?
  1. long l=222;   
  2. _variant_t lVal(l); 
imJaron
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值