VARIANT数组封装类

1.     最近经常使用VC的VARIANT，封装了一个 VARIANT类与常见数组的转换类，实现其相关功能，提高了开发效率。
5. #pragma once
6. enum ElementType
7. {   
8.     V_LONGLONG=VT_I8,       //VT_I8.
9.     V_ULONGLONG=VT_UI8,     //VT_UI8
11.     V_LONG=VT_I4,           //VT_I4.
12.     V_ULONG=VT_UI4,         //VT_UI4
14.     V_INT=VT_INT,           //VT_INT
15.     V_UINT=VT_UINT          //VT_UINT
17.     V_BYTE=VT_UI1,          //VT_UI1.
18.     V_CHAR=VT_I1,           //VT_CHAR
20.     V_SHORT=VT_I2,          //VT_I2.
21.     V_USHORT=VT_UI2,        //VT_UI2
23.     V_FLOAT=VT_R4,          //VT_R4.
24.     V_DOUBLE=VT_R8,         //VT_R8.
25.     V_DATE=VT_DATE,         //VT_DATE
26.     V_BSTR=VT_BSTR,         //VT_BSTR
27.     V_VARIANT=VT_VARIANT,   //VT_VARIANT
28.     V_DECIMAL=VT_DECIMAL,   //VT_DECIMAL
29. };
30. template<class T>
31. class CVariantPack
32. {
33. private:
34.     CVariantPack(void){};
35.     virtual ~CVariantPack(void){};
36. public:
37.     static bool SetTPtrVariant( ElementType type ,const T *pData,int num,VARIANT &vdata)
38.     {
39.         try
40.         {   
41.             if( pData == NULL || num <= 0 )
42.             {
43.                 return false;
44.             }
46.             SAFEARRAYBOUND rgsabound[1];
47.             rgsabound[0].lLbound = 0;
48.             rgsabound[0].cElements = (ULONG)num;
50.             SAFEARRAY *psa = SafeArrayCreate( type,1, rgsabound );
51.             if( psa )
52.             {
53.                 for( long i=0; i<(long)num; i++ )
54.                 {
55.                     SafeArrayPutElement( psa, &i, (void *)(pData + i) );
56.                 }
58.                 vdata.vt = VT_ARRAY | type;
59.                 vdata.parray = psa;
60.                 SafeArrayUnaccessData( psa );
61.                 return true;    
62.             }
63.             else
64.             {
65.                 return false;
66.             }
67.         }
68.         catch(...)
69.         {
70.             return false;
71.         }
72.     }; 
73.     static int GetTPtrVariant ( ElementType type ,T *pData,const VARIANT vdata)
74.     {
75.         try
76.         {
77.             if( vdata.vt==VT_NULL || vdata.vt==VT_EMPTY || pData==NULL )
78.             {
79.                 return -1;
80.             }
81.             if( !(vdata.vt & VT_ARRAY)  )
82.             {
83.                 return -2;
84.             }
86.             SAFEARRAY *psa = vdata.parray;
87.             UINT nDims = SafeArrayGetDim( psa );
88.             if( nDims != 1 )
89.             {
90.                 return -3;
91.             }
92.             //检查数组元素类型
93.             VARTYPE vt = 0;
95.             SafeArrayGetVartype( psa, &vt );
96.             if( vt != type )
97.             {
98.                 return -4;
99.             }
101.             //检查数组上下限和元素个数是否为偶数个
102.             LONG lUBound =0, lLBound = 0;
104.             SafeArrayGetUBound( psa, 1, &lUBound );
105.             SafeArrayGetLBound( psa, 1, &lLBound );
107.             int lElements = lUBound - lLBound + 1;
109.             if( lElements <= 0 )
110.             {
111.                 return -5;
112.             }
114.             T *pTmp = NULL;
116.             SafeArrayAccessData( psa, (void **)&pTmp );
118.             if( NULL == pTmp )
119.             {
120.                 return -6;
121.             }
122.             memcpy( pData,pTmp,lElements*sizeof(T));
123.             SafeArrayUnaccessData( psa );
124.             return lElements;   
125.         }
126.         catch(...)
127.         {
128.             return -1;
129.         };
130.     };
131.     
132. };

 

                        //Example

1.     long a[] ={1,2,3};
2.     VARIANT vdata;
3.     //long 数组封装到VARIANT
4.     if( !CVariantPack<long>::PackTPtrVariant(V_LONG,a,3,vdata))
5.     {
6.         return false;
7.     }
9.     long b[10]={0} ;
10.     //从VARIANT获取long数组数据
11.     int num= CVariantPack<long>::GetTPtrVariant(V_LONG,b,vdata); 
12.     if( num<=0 )
13.     {
14.         return false;
15.     }