VARIANT数据类型的使用

转载 2013年12月05日 11:25:56

VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
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;
    };
  对于VARIANT变量的赋值:首先给vt成员赋值,指明数据类型,再对联合结构中相同数据类型的变量赋值,举个例子:

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


  对于不马上赋值的VARIANT,最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:

unsigned char bVal; VT_UI1
short iVal; VT_I2
long lVal; VT_I4
float fltVal; VT_R4
double dblVal; VT_R8
VARIANT_BOOL boolVal; VT_BOOL
SCODE scode; VT_ERROR
CY cyVal; VT_CY
DATE date; VT_DATE
BSTR bstrVal; VT_BSTR
IUnknown FAR* punkVal; VT_UNKNOWN
IDispatch FAR* pdispVal; VT_DISPATCH
SAFEARRAY FAR* parray; VT_ARRAY|*
unsigned char FAR* pbVal; VT_BYREF|VT_UI1
short FAR* piVal; VT_BYREF|VT_I2
long FAR* plVal; VT_BYREF|VT_I4
float FAR* pfltVal; VT_BYREF|VT_R4
double FAR* pdblVal; VT_BYREF|VT_R8
VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL
SCODE FAR* pscode; VT_BYREF|VT_ERROR
CY FAR* pcyVal; VT_BYREF|VT_CY
DATE FAR* pdate; VT_BYREF|VT_DATE
BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR
IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN
IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH
SAFEARRAY FAR* FAR* pparray; VT_ARRAY|*
VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT
void FAR* byref; VT_BYREF


   _variant_t是VARIANT的封装类,其赋值可以使用强制类型转换,其构造函数会自动处理这些数据类型。

  例如:

long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;


  COleVariant的使用与_variant_t的方法基本一样,请参考如下例子:

COleVariant v3 = "字符串", v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;
http://www.cnblogs.com/strinkbug/archive/2007/03/22/683473.html


VARIANT类型的用法  

2009-04-06 15:43:13|  分类: vc编程 |字号 订阅

一 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);  

  }




相关文章推荐

[Microsoft][ODBC Microsoft Access Driver] 试图将 Null 值赋予一个非 Variant 数据类型的变量

今天写代码的时候遇到了一个这样的小问题记录下来(使用的是access数据库)sun.jdbc.odbc.JdbcOdbcBatchUpdateException: [Microsoft][ODBC M...
  • wkcgy
  • wkcgy
  • 2011-01-14 20:27
  • 1524

_variant_t 数据类型介绍

_variant_t 和 _bstr_t 这两个类分别用于封装并管理 VARIANT 和 BSTR 这两种数据类型,VARIANT 和 BSTR 这两种类型是 COM 中使用的数据类型。为了将C+...

_variant_t与其他数据类型的转换

转自:http://kuaixingdong.blog.hexun.com/29627840_d.html 我们先看看COM所支持的一些类型的基本类: (微软提供,在comdef.h中定义...

Variant 数据类型介绍

Variant 数据类型是所有没被显式声明(用如 Dim、Private、Public 或 Static等语句)为其他类型变量的数据类型。Variant 数据类型并没有类型声明字符。 Var...

_variant_t 数据类型学习

转自:http://hi.baidu.com/ruiqing_2008/blog/item/d9488a9b7caa6ab9c8eaf47f.html _variant_t是一个类,是VARIANT的...

_variant_t与其他数据类型的转换

转自:http://kuaixingdong.blog.hexun.com/29627840_d.html 我们先看看COM所支持的一些类型的基本类: (微软提供,在comdef.h中定义) 在...

[ASP.NET]解决“试图将 Null 值赋予一个非 Variant 数据类型的变量”的问题

错误提示 :"试图将 Null 值赋予一个非 Variant 数据类型的变量" 错误原因:在VS2005中,用ACCESS做数据库时insert into 命令会把自动编号也会加进去,所以这个就需要...

_variant_t 数据类型 注释 vt类型

_variant_t 数据类型 _variant_t类封闭了VARIANT数据类型,VARIANT是一个结构体类型,我们可以看一下它的定义 typedef struct tagVARIANT...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)