精华内容
下载资源
问答
  • _variant_t

    2012-09-29 10:24:12
    _variant_t _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型,  VARIANT和BSTR这两种类型是COM中使用的数据类型。  为了C++中的变量应用到ADO编程中,只能进行数据类型的转换。  ...

    _variant_t

    _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型,

      VARIANT和BSTR这两种类型是COM中使用的数据类型。

      为了C++中的变量应用到ADO编程中,只能进行数据类型的转换。

      通过_variant_t和_bstr_t这两个类,就可以方便的把C++类型变量转换成COM中的变量了。

    展开全文
  • _bstr_t和_variant_t

    2012-06-16 15:36:18
    _bstr_t和_variant_t,主要介绍_bstr_t和_variant_t两种数据类型的简单作用。
  • _variant_t和_bstr_t

    2017-08-22 20:02:00
    _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型, VARIANT和BSTR这两种类型是COM中使用的数据类型。 实现_variant_t向int,String ,double,long,byte等类型转换 为了C++中的变量应用...

    _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型,

    VARIANT和BSTR这两种类型是COM中使用的数据类型。

     

    实现_variant_t向int,String ,double,long,byte等类型转换

     

    为了C++中的变量应用到ADO编程中,只能进行数据类型的转换。
    通过_variant_t和_bstr_t这两个类,就可

    _variant_t var;
    var=m_pRecordset->GetCollect ("UserName");
    ss=(TCHAR*)(_bstr_t)vUsername;//转换成字符串

     

    以方便的把C++类型变量转换成COM中的变量了。

     

    CString转换为_variant_t:

    CString str = _T("xxx");
    _variant_t var = (LPCTSTR)str;

    把CString 转换为_variant_t:

    整型:(long) (_variant_t) m_pRecordset->GetFieldByName("XX");
    字符串型:(m_pRecordset->GetFieldByName("XX")).bstrVal;

    把一个日期字符串转成_variant_t:

    1.CString可以直接转_variant_t。 
    CString szTime("2008-8-8 08:08:08");
    _variant_t  mt = szTime;
    2._variant_t转CString用如下函数:
    CString VariantToCString(_variant_t var)
    {
        
        CString str; //转换以后的字符串
        
        switch(var.vt)
            
        {
    case VT_BSTR: //var is BSTR type
            
            str=var.bstrVal;
            
            break;
    case VT_I2: //var is short int type
            
            str.Format("%d",(int)var.iVal);
            
            break;
    case VT_I4: //var is long int type
            
            str.Format("%d",var.lVal);
            
            break;
    case VT_R4: //var is float type
            
            str.Format(".6f",(double)var.fltVal);
            
            break;
    case VT_R8: //var is double type
            
            str.Format(".6f",var.dblVal);
            
            break;
    case VT_CY: //var is CY type
            
            str=COleCurrency(var).Format();
            
            break;
    case VT_DATE: //var is DATE type
            
            str=COleDateTime(var).Format();
            
            break;
    case VT_BOOL: //var is VARIANT_BOOL
            
            str= (var.boolVal==0) ?L"FALSE": L"TRUE";
            
            break;
    default:
            
            str.Format("Unk type %d\n",var.vt);
            
            TRACE("Unknown type %d\n",var.vt);
            
        }
        
        return str;
        
    }

    把一个int转换为_variant_t类型:

    int a = 5;
     _variant_t var;
     
     var = (_variant_t)(long)a;

     

     


     

     

         UpdateData();
            CString strCmd = L"select * from n where 材料='";
            strCmd += m_Querymaterial;
            strCmd += "'";
            m_pRecordset = m_pConnection->Execute(_bstr_t(strCmd), &RecordsAffected, adCmdText);

     

     

     

    _variant_t vM,vN;
        try
        {
            while(!m_pRecordset->adoEOF)
            {
                //取得第0列的值,从0开始计数
                vM=m_pRecordset->GetCollect(_variant_t((long)0));
                //取得“折射率”这一列的值
                vN=m_pRecordset->GetCollect("折射率");
                CString strtemp;
                if (vM.vt!=VT_NULL)  
                {  
                    strtemp.Format(_T("%s"),vM.lVal);  
                }
                if (vN.vt!=VT_NULL)
                {
                    strtemp+=" ";
                    strtemp+=(LPCTSTR)(_bstr_t)vN;
                }
                m_list1.AddString(strtemp);  
                m_list1.AddString(_T("\n"));
                m_pRecordset->MoveNext();//移动到下一条记录
            }
        }
        catch(_com_error &e)  
        {  
            AfxMessageBox(e.Description());
            return;
        }  
        if (m_pRecordset->Close())
        {
            m_pRecordset->Close();
            m_pRecordset=NULL;
        } 
        if (m_pConnection->State)
        {
            m_pConnection->Close();
            m_pConnection=NULL;
        }
    }

     

    转载于:https://www.cnblogs.com/wxl845235800/p/7413414.html

    展开全文
  • _variant_t

    2010-12-03 19:22:00
    _variant_t 是什么数据类型?? <br />这个问题的答案比较广泛:  我所知道常用的  1。在执行的SQL语句一般都是_bstr_t  2.Connection 中的RecordsAffected 为VARIANT  3....
    
    

    这个问题的答案比较广泛:  
      我所知道常用的  
      1。在执行的SQL语句一般都是_bstr_t  
      2.Connection   中的RecordsAffected   为VARIANT  
      3.使用get_Value()获得的记录的值为   VAARIANT  
          等等。。。  
      _bstr_t   中记录了字符串的长度,  
      _variant_t   记录有数据的类型和数据的值  
          如   _variant_t   ttt;  
          ttt.vt=I4_VT;   表示数据类型为整数  
          ttt.lVal   为数据的值

    转载:

    /*
    将 _variant_t 类型的变量,转换成字符串(比如如果是数字,则转换成数字对应的字符串 :如 10.2 -> "10.200000")

    */

    _variant_t var; 

    CString str; //转换以后的字符串

    //以下代码演示如何转换为C标准字符串型
    if (var.vt == VT_I4)
    {
        long lNum;
        char szCh[21];
        str=var.bstrVal;
        WideCharToMultiByte
                 (CP_ACP, 0, var.bstrVal, -1,
                  szCh, sizeof(szCh), NULL, NULL);
    }

    //以下代码演示如何转换成逻辑型
    if( var.vt == VT_BOOL)
    {
        BOOL bVar;
        lNum=var.lVal;
        bVar= var.boolVar==0? FALSE : TRUE;
    }

    //以下代码演示为其余类型(补充)
    switch(var.vt)
    {

    case VT_BSTR:         //var is BSTR type
         str=var.bstrVal;
         break;

    case VT_I2:           //var is short int type
         str.Format("%d",(int)var.iVal);
         break;

    case VT_I4:          //var is long int type
         str.Format("%d",var.lVal);
         break;

    case VT_R4:         //var is float type
         str.Format("%10.6f",(double)var.fltVal);
         break;

    case VT_R8:         //var is double type
         str.Format("%10.6f",var.dblVal);
         break;

    case VT_CY:        //var is CY type
         str=COleCurrency(var).Format();
         break;

    case VT_DATE:     //var is DATE type
         str=COleDateTime(var).Format();
         break;

    case VT_BOOL:     //var is  VARIANT_BOOL
         str= (var.boolVal==0) ?"FALSE": "TRUE";
         break;

    default:
         str.Format("Unk type %d/n",var.vt);
         TRACE("Unknown type %d/n",var.vt);
    }

     

    http://blog.donews.com/martinleilei/archive/2007/10/09/1217580.aspx

    展开全文
  • _variant_t _bstr_t

    2013-01-14 17:11:18
    _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型, VARIANT和BSTR这两种类型是COM中使用的数据类型。 为了C++中的变量应用到ADO编程中,只能进行数据类型的转换。 通过_variant_t和...

    简介

    _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型
    VARIANT和BSTR这两种类型是COM中使用的数据类型
    为了C++中的变量应用到ADO编程中,只能进行数据类型的转换。
    通过_variant_t和_bstr_t这两个类,就可以方便的把C++类型变量转换成COM中的变量了。

    编辑本段定义

    _variant_t的定义:COMUTIL.H
     class _variant_t : public ::tagVARIANT {
    public:
    // Constructors
    //
    _variant_t() throw();
    _variant_t(const VARIANT& varSrc) throw(_com_error);
    _variant_t(const VARIANT* pSrc) throw(_com_error);
    _variant_t(const _variant_t& varSrc) throw(_com_error);
    _variant_t(VARIANT& varSrc, bool fCopy) throw(_com_error); // Attach VARIANT if !fCopy
    _variant_t(short sSrc, VARTYPE vtSrc = VT_I2) throw(_com_error); // Creates a VT_I2, or a VT_BOOL
    _variant_t(long lSrc, VARTYPE vtSrc = VT_I4) throw(_com_error); // Creates a VT_I4, a VT_ERROR, or a VT_BOOL
    _variant_t(float fltSrc) throw(); // Creates a VT_R4
    _variant_t(double dblSrc, VARTYPE vtSrc = VT_R8) throw(_com_error); // Creates a VT_R8, or a VT_DATE
    _variant_t(const CY& cySrc) throw(); // Creates a VT_CY
    _variant_t(const _bstr_t& bstrSrc) throw(_com_error); // Creates a VT_BSTR
    _variant_t(const wchar_t*pSrc) throw(_com_error); // Creates a VT_BSTR
    _variant_t(const char* pSrc) throw(_com_error); // Creates a VT_BSTR
    _variant_t(IDispatch* pSrc, bool fAddRef = true) throw(); // Creates a VT_DISPATCH
    _variant_t(bool bSrc) throw(); // Creates a VT_BOOL
    _variant_t(IUnknown* pSrc, bool fAddRef = true) throw(); // Creates a VT_UNKNOWN
    _variant_t(const DECIMAL& decSrc) throw(); // Creates a VT_DECIMAL
    _variant_t(BYTE bSrc) throw(); // Creates a VT_UI1
    // Destructor
    //
    ~_variant_t() throw(_com_error);
    // Extractors
    //
    operator short() const throw(_com_error); // Extracts a short from a VT_I2
    operator long() const throw(_com_error); // Extracts a long from a VT_I4
    operator float() const throw(_com_error); // Extracts a float from a VT_R4
    operator double() const throw(_com_error); // Extracts a double from a VT_R8
    operator CY() const throw(_com_error); // Extracts a CY from a VT_CY
    operator _bstr_t() const throw(_com_error); // Extracts a _bstr_t from a VT_BSTR
    operator IDispatch*() const throw(_com_error); // Extracts a IDispatch* from a VT_DISPATCH
    operator bool() const throw(_com_error); // Extracts a bool from a VT_BOOL
    operator IUnknown*() const throw(_com_error); // Extracts a IUnknown* from a VT_UNKNOWN
    operator DECIMAL() const throw(_com_error); // Extracts a DECIMAL from a VT_DECIMAL
    operator BYTE() const throw(_com_error); // Extracts a BTYE (unsigned char) from a VT_UI1
    // Assignment operations
    //
    _variant_t& operator=(const VARIANT& varSrc) throw(_com_error);
    _variant_t& operator=(const VARIANT* pSrc) throw(_com_error);
    _variant_t& operator=(const _variant_t& varSrc) throw(_com_error);
    _variant_t& operator=(short sSrc) throw(_com_error); // Assign a VT_I2, or a VT_BOOL
    _variant_t& operator=(long lSrc) throw(_com_error); // Assign a VT_I4, a VT_ERROR or a VT_BOOL
    _variant_t& operator=(float fltSrc) throw(_com_error); // Assign a VT_R4
    _variant_t& operator=(double dblSrc) throw(_com_error); // Assign a VT_R8, or a VT_DATE
    _variant_t& operator=(const CY& cySrc) throw(_com_error); // Assign a VT_CY
    _variant_t& operator=(const _bstr_t& bstrSrc) throw(_com_error); // Assign a VT_BSTR
    _variant_t& operator=(const wchar_t* pSrc) throw(_com_error); // Assign a VT_BSTR
    _variant_t& operator=(const char* pSrc) throw(_com_error); // Assign a VT_BSTR
    _variant_t& operator=(IDispatch* pSrc) throw(_com_error); // Assign a VT_DISPATCH
    _variant_t& operator=(bool bSrc) throw(_com_error); // Assign a VT_BOOL
    _variant_t& operator=(IUnknown* pSrc) throw(_com_error); // Assign a VT_UNKNOWN
    _variant_t& operator=(const DECIMAL& decSrc) throw(_com_error); // Assign a VT_DECIMAL
    _variant_t& operator=(BYTE bSrc) throw(_com_error); // Assign a VT_UI1
    // Comparison operations
    //
    bool operator==(const VARIANT& varSrc) const throw(_com_error);
    bool operator==(const VARIANT* pSrc) const throw(_com_error);
    bool operator!=(const VARIANT& varSrc) const throw(_com_error);
    bool operator!=(const VARIANT* pSrc) const throw(_com_error);
    // Low-level operations
    //
    void Clear() throw(_com_error);
    void Attach(VARIANT& varSrc) throw(_com_error);
    VARIANT Detach() throw(_com_error);
    void ChangeType(VARTYPE vartype, const _variant_t* pSrc = NULL) throw(_com_error);
    void SetString(const char* pSrc) throw(_com_error); // used to set ANSI string
    };

    编辑本段案例

    我定义了一组函数可以方便的实现_variant_t类型转换
    //_variant_t转WORD类型
    BOOL AfxVariantConvert(WORD& val, const _variant_t& vt)
    {
    if (vt.vt == VT_UI2)
    {
    val = (WORD)vt.uiVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }
    _variant_t转DWORD类型
    BOOL AfxVariantConvert(DWORD& val, const _variant_t& vt)
    {
    if (vt.vt == VT_UI4 )
    {
    val = (DWORD)vt.ulVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }
    _variant_t转DWORD64类型
    BOOL AfxVariantConvert(DWORD64& val, const _variant_t& vt)
    {
    if (vt.vt != VT_UI8 )
    {
    val = (DWORD64)vt.ullVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }
    _variant_t转CString类型
    BOOL AfxVariantConvert(CString& val, const _variant_t& vt)
    {
    if (vt.vt == VT_BSTR)
    {
    val = (LPCTSTR)vt.bstrVal;
    return TRUE;
    }
    else
    {
    val = _T("");
    return FALSE;
    }
    }
    _variant_t转BOOL类型
    BOOL AfxVariantConvert(BOOL& val, const _variant_t& vt)
    {
    if (vt.vt == VT_BOOL)
    {
    val = vt.boolVal;
    return TRUE;
    }
    else
    {
    val = FALSE;
    return FALSE;
    }
    }
    _variant_t转CTime类型(精度变短,可能丢失数据)
    BOOL AfxVariantConvert(CTime& val, const _variant_t& vt)
    {
    if (vt.vt == VT_DATE)
    {
    val = vt.date;
    return TRUE;
    }
    else
    {
    val = NULL;
    return FALSE;
    }
    }
    _variant_t转double类型
    BOOL AfxVariantConvert(DOUBLE& val, const _variant_t& vt)
    {
    if (vt.vt == VT_R8)
    {
    val = vt.dblVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }
    _variant_t转byte类型
    BOOL AfxVariantConvert(BYTE& val, const _variant_t& vt)
    {
    if (vt.vt == VT_UI1 || vt.vt == VT_I1)
    {
    val = vt.bVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }
    _variant_t转float类型
    BOOL AfxVariantConvert( FLOAT& val, const _variant_t& vt )
    {
    if (vt.vt == VT_R4)
    {
    val = vt.fltVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }
    _variant_t转long类型
    BOOL AfxVariantConvert( long& val,const _variant_t& vt )
    {
    if (vt.vt == VT_I4)
    {
    val = vt.lVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }
    _variant_t转INT64类型
    BOOL AfxVariantConvert( INT64& val,const _variant_t& vt )
    {
    if (vt.vt == VT_I8)
    {
    val = vt.llVal;
    return TRUE;
    }
    else
    {
    val = 0;
    return FALSE;
    }
    }

    编辑本段功能:

    实现_variant_t向int,String ,double,long,byte等类型转换
    展开全文
  • _bstr_t 和_variant_t

    2012-03-31 16:27:20
    _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型, VARIANT和BSTR这两种类型是COM中使用的数据类型。   为了C++中的变量应用到ADO编程中,只能进行数据类型的转换。 通过_variant_t和_...
  • COM interface pointer => _variant_t   Constructs a _variant_t object of type VT_DISPATCH from a COM interface pointer. IffAddRef istrue, thenAddRef is called on the supplied interface pointer to ...
  • _variant_t 和 _bstr_t 这两个类分别用于封装并管理 VARIANT 和 BSTR 这两种数据类型,VARIANT 和 BSTR 这两种类型是 COM 中使用的数据类型。为了将C++中的变量应用到ADO编程中,只能进行数据类型的转换。通过 _...
  • gt; _variant_t Constructs a _variant_t object of type VT_DISPATCH from a COM interface pointer. IffAddRef istrue, thenAddRef is called on the supplied interface pointer to ...
  • _variant_t的使用

    2019-10-03 19:54:43
    _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型,VARIANT和BSTR这两种类型是COM中使用的数据类型。 转载于:https://www.cnblogs.com/youyui/p/4626079.html...
  • _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型,VARIANT和BSTR这两种类型是COM中使用的数据类型。... (LPCSTR)_bstr_t(var) 把_variant_t里的通用数据当作字符串读出来,_bstr_t类重
  • ADO 数据类型_bstr_t 和_variant_t

    千次阅读 2012-07-01 16:57:23
    _variant_t是VARIANT这个数据类型的封装 Microsoft Specific Constructs a _bstr_t object. _bstr_t( ) throw( ); _bstr_t( const _bstr_t& s1 ) throw( ); _bstr_t
  • _variant_t类型转换

    2011-05-16 23:44:11
    _variant_t 类型的变量,转换成任意类型
  • _variant_t转化成char* ch;ch = (char*)(_bstr_t)vt; =================================VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。 对于VARIANT变量的赋值:首先给vt成员...
  • _variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型,即是“Wrapper Class”VARIANT和BSTR这两种类型是COM中使用的数据类型,VARIANT类型是一个结构体,而BSTR is A ..._variant_t和_bstr_t这两
  • _variant_t和_bstr_t有什么区别

    千次阅读 2015-04-07 22:30:42
    _variant_t是一个类,它封装了VARIANT类型,而VARIANT是一个万能类型,可以存放任意类型的数据(字符型、日期型、数值型等等); _bstr_t也是一个类,它封装了BSTR类型,BSTR是一个字符串指针,也即可以存放字符串。 ...
  • _variant_t 编译不通过的解决方法:如图中的字符设置方法;
  • _variant_t 转 CString

    2015-04-07 16:12:24
    _variant_t m_url; CString str; m_url.ChangeType(VT_BSTR,NULL); str = m_url.bstrVal;
  • BSTR,_bstr_t,CComBSTR,VARIANT,_variant_t,CString的转换 VC6.0上编译通过,console程序,使用静态MFC库。也许有不对的地方,欢迎指正 #include #include #include #include void main() {  BSTR ...
  • _variant_t vtValue=com返回值; if(vtValue.vt==(VT_ARRAY|VT_UI1)) { BYTE *pByte=NULL; ::SafeArrayAccessData(vtValue.parray,(void**)&pByte); memcpy(pBuff,pByte,sizeof(HEADER_USERADM)); ::...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,768
精华内容 2,307
关键字:

_variant_t