_variant_t与其他数据类型的转换

转自：http://kuaixingdong.blog.hexun.com/29627840_d.html

我们先看看COM所支持的一些类型的基本类：

（微软提供，在comdef.h中定义）

在COM中使用的标准类Class如下所示：

_bstr_t：对BSTR类型进行打包，并提供有用的操作和方法；

_com_error：定义抛出的error对象；

_com_ptr_t：封装COM接口指针

_variant_t：对VARIANT类型进行打包，并提供有用的操作和方法；

一、_variant_t类的简单介绍：

_variant_t对象封装了VARIANT数据类型。

The class manages resource allocation and deallocation and makes function calls to VariantInit and VariantClear as appropriate.

(1) _variant类提供的方法：

1> 构造函数

_variant_t

对_variant_t变量初始化调用的是_variant_t的构造函数。我们一般习惯于用一个int型的变量对数字类的变量进行初始化，这对_variant_t变量是不允许的。

原因很简单，_variant_t 的构造函数中没有用整型( Int )对其初始化的构造函数

可先将整型转化成long，然后再对其进行初始化

2> Attach()

Attaches a VARIANT object into the _variant_t object.

3> Clear()

Clears the encapsulated VARIANT object.

4> ChangeType

Changes the type of the _variant_t object to the indicated VARTYPE.

5> Detach

Detaches the encapsulated VARIANT object from this _variant_t object.

6> SetString

将一个string赋值给_variant_t对象；

7> Operators

赋值操作，给现有的_variant_t对象赋一个新值；

8> operator ==, !=

对比两个 _variant_t 对象是否相等；

9> Extractors

Extract data from the encapsulated VARIANT object.

(2) _variant_t的定义：

_variant_t类封闭了VARIANT数据类型，VARIANT是一个结构体类型，我们可以看一下它的定义

1. typedef struct tagVARIANT
2. {
3. VARTYPE vt;                             //存储数据类型
4. unsigned short wReserved1;
5. unsigned short wReserved2;
6. unsigned short wReserved3;
7. union
8. {
9. Byte bVal;                          // VT_UI1.
10. Short iVal;                         // VT_I2.
11. long lVal;                          // VT_I4.
12. float fltVal;                       // VT_R4.
13. double dblVal;                      // VT_R8.
14. VARIANT_BOOL boolVal;               // VT_BOOL.
15. SCODE scode;                        // VT_ERROR.
16. CY cyVal;                           // VT_CY.
17. DATE date;                          // VT_DATE.
18. BSTR bstrVal;                       // VT_BSTR.
19. DECIMAL FAR* pdecVal                // VT_BYREF|VT_DECIMAL.
20. IUnknown FAR* punkVal;              // VT_UNKNOWN.
21. IDispatch FAR* pdispVal;            // VT_DISPATCH.
22. SAFEARRAY FAR* parray;              // VT_ARRAY|*.
23. Byte FAR* pbVal;                    // VT_BYREF|VT_UI1.
24. short FAR* piVal;                   // VT_BYREF|VT_I2.
25. long FAR* plVal;                    // VT_BYREF|VT_I4.
26. float FAR* pfltVal;                 // VT_BYREF|VT_R4.
27. double FAR* pdblVal;                // VT_BYREF|VT_R8.
28. VARIANT_BOOL FAR* pboolVal;         // VT_BYREF|VT_BOOL.
29. SCODE FAR* pscode;                  // VT_BYREF|VT_ERROR.
30. CY FAR* pcyVal;                     // VT_BYREF|VT_CY.
31. DATE FAR* pdate;                    // VT_BYREF|VT_DATE.
32. BSTR FAR* pbstrVal;                 // VT_BYREF|VT_BSTR.
33. IUnknown FAR* FAR* ppunkVal;        // VT_BYREF|VT_UNKNOWN.
34. IDispatch FAR* FAR* ppdispVal;      // VT_BYREF|VT_DISPATCH.
35. SAFEARRAY FAR* FAR* pparray;        // VT_ARRAY|*.
36. VARIANT FAR* pvarVal;               // VT_BYREF|VT_VARIANT.
37. void FAR* byref;                    // Generic ByRef.
38. char cVal;                          // VT_I1.
39. unsigned short uiVal;               // VT_UI2.
40. unsigned long ulVal;                // VT_UI4.
41. int intVal;                         // VT_INT.
42. unsigned int uintVal;               // VT_UINT.
43. char FAR * pcVal;                   // VT_BYREF|VT_I1.
44. unsigned short FAR * puiVal;        // VT_BYREF|VT_UI2.
45. unsigned long FAR * pulVal;         // VT_BYREF|VT_UI4.
46. int FAR * pintVal;                  // VT_BYREF|VT_INT.
47. unsigned int FAR * puintVal;        //VT_BYREF|VT_UINT.
48. };
49. };

注意：vt用来存储内部变量（联合体中保存的变量）的类型，联合体用来存储对应类型的值

二、数据类型转换

_bstr_t类可以作为_variant_t类与基本数据类型转换的中介

(1) _variant_t与CString之间的转化

1> CString转换为_variant_t：

1. CString str;
2. _variant_t str1=(LPCTSTR)str;

使用_variant_t的成员函数SetString来对_variant_t的对象赋值会更好；

2> _variant_t转换为CString：

1. _variant_t vt;
2. CString tempstr=(LPCSTR)_bstr_t(vt);         //_bstr_t的构造函数有对_variant_t类型的处理

(2) _variant_t与char *之间的转换

1> char * 转换为_variant_t

方法与CString转换为_variant_t的方法类似：

1. char * cValue;
2. _variant_t vValue=(LPSTR)cValue;

2> _variant_t转换为char *：

错误方法：

1. _variant_t vValue;
2. char * value=(LPSTR)(LPCSTR)_bstr_t(vValue)

value指向一堆乱码...

原因：不能用char *直接指向(LPSTR)(LPCSTR)_bstr_t( _variant_t )，因为这样转换之后实际上是一个string，而非一个char *

正确方法：

进行转换时，只能用strcpy()，将LPSTR指向的字符复制到char * 所指向的内存中；

如下例：

1. _variant_t vValue;
2. char cValue[16]={0};
3. strcpy(cValue, (LPCSTR)_bstr_t(vValue));

(3) 判断_variant_t的值类型

下面的转换代码根据_variant_t的vt进行类型判断，然后将数据值转换为CString类型（可作为转换为其他数据类型的中介）

1. CString str;
2. //以下代码演示如何转换为C标准字符串型
3. switch(var.vt)
4. {
5. case VT_BSTR:
6. {
7. str=var.bstrVal;
8. break;
9. }
10. case VT_I2: //var is short int type
11. {
12. str.Format("%d",(int)var.iVal);
13. break;
14. }
15. case VT_I4: //var is long int type
16. {
17. str.Format("%d", var.lVal);
18. break;
19. }
20. case VT_R4: //var is float type
21. {
22. str.Format("%10.6f", (double)var.fltVal);
23. break;
24. }
25. case VT_R8: //var is double type
26. {
27. str.Format("%10.6f", var.dblVal);
28. break;
29. }
30. case VT_CY: //var is CY type
31. {
32. str=COleCurrency(var).Format();
33. break;
34. }
35. case VT_DATE: //var is DATE type
36. {
37. str=COleDateTime(var).Format();
38. break;
39. }
40. case VT_BOOL: //var is VARIANT_BOOL
41. {
42. str= (var.boolVal==0) ?"FALSE": "TRUE";
43. break;
44. }
45. default:
46. {
47. str.Format("Unk type %d\n",var.vt);
48. TRACE("Unknown type %d\n",var.vt);
49. break;
50. }
51. }