VARIANT的用法

一 VARIANT的用法

VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。

struct tagVARIANT {
    union {
        struct __tagVARIANT {
            VARTYPE vt;
            WORD    wReserved1;
            WORD    wReserved2;
            WORD    wReserved3;
            union {
                ULONGLONG     ullVal;        ---VT_UI8      
                LONGLONG      llVal;         ---VT_I8               
                LONG          lVal;          ---VT_I4                */
                BYTE          bVal;          ---VT_UI1               */
                SHORT         iVal;          ---VT_I2                */
                FLOAT         fltVal;        ---VT_R4                */
                DOUBLE        dblVal;        ---VT_R8                */
                VARIANT_BOOL  boolVal;       ---VT_BOOL              */
                _VARIANT_BOOL bool;          ---(obsolete)           */
                SCODE         scode;         ---VT_ERROR             */
                CY            cyVal;         ---VT_CY                */
                DATE          date;          ---VT_DATE              */
                BSTR          bstrVal;       ---VT_BSTR              */
                IUnknown *    punkVal;       ---VT_UNKNOWN           */
                IDispatch *   pdispVal;      ---VT_DISPATCH          */
                SAFEARRAY *   parray;        ---VT_ARRAY             */
                BYTE *        pbVal;         ---VT_BYREF|VT_UI1      */
                SHORT *       piVal;         ---VT_BYREF|VT_I2       */
                LONG *        plVal;         ---VT_BYREF|VT_I4       */
                LONGLONG *    pllVal;        ---VT_BYREF|VT_I8       */
                FLOAT *       pfltVal;       ---VT_BYREF|VT_R4       */
                DOUBLE *      pdblVal;       ---VT_BYREF|VT_R8       */
                VARIANT_BOOL *pboolVal;      ---VT_BYREF|VT_BOOL     */
                _VARIANT_BOOL *pbool;        ---(obsolete)           */
                SCODE *       pscode;        ---VT_BYREF|VT_ERROR    */
                CY *          pcyVal;        ---VT_BYREF|VT_CY       */
                DATE *        pdate;         ---VT_BYREF|VT_DATE     */
                BSTR *        pbstrVal;      ---VT_BYREF|VT_BSTR     */
                IUnknown **   ppunkVal;      ---VT_BYREF|VT_UNKNOWN  */
                IDispatch **  ppdispVal;     ---VT_BYREF|VT_DISPATCH */
                SAFEARRAY **  pparray;       ---VT_BYREF|VT_ARRAY    */
                VARIANT *     pvarVal;       ---VT_BYREF|VT_VARIANT  */
                PVOID         byref;         ---Generic ByRef        */
                CHAR          cVal;          ---VT_I1                */
                USHORT        uiVal;         ---VT_UI2               */
                ULONG         ulVal;         ---VT_UI4               */
                INT           intVal;        ---VT_INT               */
                UINT          uintVal;       ---VT_UINT              */
                DECIMAL *     pdecVal;       ---VT_BYREF|VT_DECIMAL  */
                CHAR *        pcVal;         ---VT_BYREF|VT_I1       */
                USHORT *      puiVal;        ---VT_BYREF|VT_UI2      */
                ULONG *       pulVal;        ---VT_BYREF|VT_UI4      */
                ULONGLONG *   pullVal;       --- VT_BYREF|VT_UI8      */
                INT *         pintVal;       ---VT_BYREF|VT_INT      */
                UINT *        puintVal;      ---VT_BYREF|VT_UINT     
                struct __tagBRECORD {
                    PVOID         pvRecord;
                    IRecordInfo * pRecInfo;
                } __VARIANT_NAME_4;          --- VT_RECORD            
            } __VARIANT_NAME_3;
        } __VARIANT_NAME_2;

        DECIMAL decVal;
    } __VARIANT_NAME_1;
};

     VARIANT数据结构包含两个域(如果不考虑保留的域)。vt域描述了第二个域的数据类型。为了使多种类型能够在第二个域中出现，我们定义了一个联合结构。所以，第二个域的名称随着vt域中输入值的不同而改变。用于指定vt域值情况的常量在联合的定义中以每一行的注释形式给出。

　　对于VARIANT变量的赋值，分两步：

（1）首先给vt成员赋值，指明数据类型;

（2）再对联合结构中相同数据类型的变量赋值.

举个例子：

  1.如果为整型

      VARIANT va;
      int a=2001;
      va.vt=VT_I4;      //指明为整型数据
      va.lVal=a;         //赋值

     在第一行中指定数据类型。常量VT_I4表明在第二个域中将出现一个int型的数据。根据类型VARIANT的定义，可以得知，当一个int型数据存入VARIANT类型时，其第二个域使用的名称是lVal。

 2.如果为浮点型

     VARIANT va;
     float a=20.1;
     va.vt=VT_R4;        //指明为浮点型数据
     va.ftlVal=a;           //赋值

 3.如果为安全数组(SAFEARRAY)

     VARIANT va;

     SAFEARRAY* pSaf;

     … …      // 此处是对pSaf赋值，具体做法后面将介绍

     va.vt=VT_ARRAY|VT_R4;//这里是假设pSaf里存的是浮点型数据

                                //注意，此时声明类型时必须确定数据类型

    对于不马上赋值的VARIANT，最好先用Void VariantInit（VARIANTARG FAR* pvarg）;进行初始化,其本质是将vt设置为VT_EMPTY.

二  SAFEARRAY的用法

（1）  SAFEARRAY的赋值并传递给VARIANT变量

    SAFEARRAYBOUND saBound[1];  // 1表示一维数组

    saBound[0].cElements = 20;     // 20表示有20个元素

    saBound[0].lLbound = 0;         // 0表示从0开始

    SAFEARRAY *p;

    p = SafeArrayCreate(VT_R4,1,saBound);  //创建SafeArray

                                           // 1表示维数

    //   下面为锁定数据，将pdata和p关联起来，以后对pdata操作相当于//   对p操作

   float *pdata;

   SafeArrayAccessData(p,(void HUGEP**)&pdata);

   pdata = new float[20];

   for(int i=0;i<20;i++)

       pdata[i]=i;

   SafeArrayUnaccessData(p);       //解除锁定

   VARIANT varBand;

   varBand1.vt = VT_ARRAY|VT_R4;

   varBand1.parray = p;

（2） 从VARIANT变量中获取SAFEARRAY值，并传递给普通类型的变量

   SAFEARRAY *pIn;

   pIn = varBand.parray;

   VARTYPE vt;

   UINT dim;

   SafeArrayGetVartype(pIn,&vt);    //获得数据类型

   dim = SafeArrayGetDim(pIn);    //获得维数

   long LBound;                           //下界

   long UBound;                           //上界

   SafeArrayGetLBound(pIn,1,&LBound);    //获得下界

   SafeArrayGetUBound(pIn,1,&UBound);   //获得上界

   float *pData;

   SafeArrayAccessData(pIn,(void HUGEP**)&pData);

   //锁定数据

   //此时就得到了varBand中的数组数据了,保存在pData中

  其次SAFEARRAY也可以通过下列函数来读取数据：

  放置数据元素到SafeArray psa

  Double bVal[10]={1,2,3,4};
  for(long index=0;index<=10;index++)         
  {
     SafeArrayPutElement(psa,&index,&bVal[index]);
  }

 读取SafeArray中的数据的步骤：
 DOUBLE buf[10];
 for(long ind=0;ind<10;ind++)        
  {          
     ::SafeArrayGetElement(pvar.parray,&ind,buf+ind);  
  }