VC常见数据类型转换详解[转]

VC常见数据类型转换详解[转]

 

我们先定义一些常见类型变量借以说明

int  i  =  100; 

long  l  =  2001; 

float  f=300.2; 

double  d=12345.119; 

char  username[]="女侠程佩君"; 

char  temp[200]; 

char  *buf; 

CString  str; 

_variant_t  v1; 

_bstr_t  v2; 

// 

 

一、其它数据类型转换为字符串

短整型(int) 

itoa(i,temp,10);///将i转换为字符串放入temp中,最后一个数字表示十进制

itoa(i,temp,2);  ///按二进制方式转换  

长整型(long) 

ltoa(l,temp,10); 

// 

 

二、从其它包含字符串的变量中获取指向该字符串的指针

CString变量

str  =  "2008北京奥运"; 

buf  =  (LPSTR)(LPCTSTR)str;   

BSTR类型的_variant_t变量

v1  =  (_bstr_t)"程序员"; 

buf  =  _com_util::ConvertBSTRToString((_bstr_t)v1); 

// 

 

三、字符串转换为其它数据类型

strcpy(temp,"123");   

短整型(int) 

i  =  atoi(temp);   

长整型(long) 

l  =  atol(temp);   

浮点(double) 

d  =  atof(temp); 

// 

 

四、其它数据类型转换到CString 

使用CString的成员函数Format来转换,例如: 

整数(int) 

str.Format("%d",i);   

浮点数(float) 

str.Format("%f",i);   

字符串指针(char  *)等已经被CString构造函数支持的数据类型可以直接赋值

str  =  username; 

// 

 

五、BSTR、_bstr_t与CComBSTR 

CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的位指针。

char  *转换到BSTR可以这样:  BSTR  b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上头文件comutil.h 

反之可以使用char  *p=_com_util::ConvertBSTRToString(b); 

// 

 

六、VARIANT  、_variant_t  与 COleVariant 

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

对于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; 

// 

 

七、其它

对消息的处理中我们经常需要将WPARAM或LPARAM等位数据(DWORD)分解成两个位数据(WORD),例如：

LPARAM  lParam; 

WORD  loValue  =  LOWORD(lParam);///取低位

WORD  hiValue  =  HIWORD(lParam);///取高位  

对于位的数据(WORD)我们可以用同样的方法分解成高低两个位数据(BYTE),例如: 

WORD  wValue; 

BYTE  loValue  =  LOBYTE(wValue);///取低位

BYTE  hiValue  =  HIBYTE(wValue);///取高位

--------------------------------------------------------------- 

int  ->str  itoa,atoi 

double-  str  ftoa,atof 

_bstr_t,_variant_t,CString,long  等等看看下面: 

我给你点详细的例子，看下面

先看懂_variant_t与_bstr_t这两个类的构造函数和 operator= 

里面有重载了很多情况，

其他类型向_variant_t  赋值: 

_variant_t(  )  throw(  ); 

_variant_t(  const  VARIANT&  varSrc  )  throw(  _com_error  ); 

_variant_t(  const  VARIANT*  pVarSrc  )  throw(  _com_error  ); 

_variant_t(  const  _variant_t&  var_t_Src  )  throw(  _com_error  ); 

_variant_t(  VARIANT&  varSrc,  bool  fCopy  )  throw(  _com_error  ); 

_variant_t(  short  sSrc,  VARTYPE  vtSrc  =  VT_I2  )  throw(  _com_error  ); 

_variant_t(  long  lSrc,  VARTYPE  vtSrc  =  VT_I4  )  throw(  _com_error  ); 

_variant_t(  float  fltSrc  )  throw(  ); 

_variant_t(  double  dblSrc,  VARTYPE  vtSrc  =  VT_R8  )  throw(  _com_error  ); 

_variant_t(  const  CY&  cySrc  )  throw(  ); 

_variant_t(  const  _bstr_t&  bstrSrc  )  throw(  _com_error  ); 

_variant_t(  const  wchar_t  *wstrSrc  )  throw(  _com_error  ); 

_variant_t(  const  char*  strSrc  )  throw(  _com_error  ); 

_variant_t(  bool  bSrc  )  throw(  ); 

_variant_t(  IUnknown*  pIUknownSrc,  bool  fAddRef  =  true  )  throw(  ); 

_variant_t(  IDispatch*  pDispSrc,  bool  fAddRef  =  true  )  throw(  ); 

_variant_t(  const  DECIMAL&  decSrc  )  throw(  ); 

_variant_t(  BYTE  bSrc  )  throw(  ); 

 

operator=的重载形式: 

_variant_t&  operator=(  const  VARIANT&  varSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  const  VARIANT*  pVarSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  const  _variant_t&  var_t_Src  )  throw(  _com_error  ); 

_variant_t&  operator=(  short  sSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  long  lSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  float  fltSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  double  dblSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  const  CY&  cySrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  const  _bstr_t&  bstrSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  const  wchar_t*  wstrSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  const  char*  strSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  IDispatch*  pDispSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  bool  bSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  IUnknown*  pSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  const  DECIMAL&  decSrc  )  throw(  _com_error  ); 

_variant_t&  operator=(  BYTE  bSrc  )  throw(  _com_error  ); 

 

有了以上两个函数,举个例子：

double  f=1.0 

_variant_t  v; 

v=f;                  //是合法的看看operator=的重载形式就知道了

CString  str="ddd" 

_variant_t  v; 

v=str.AllocSysString()  或者v=(_bstr_t)(char*)str; 

即可

_variant_t转换成别的形式

 

你首先必须确定你要转化成什么样的形式

double  f; 

_variant_t  v 

f=v.dblVal  即可或者f=(double)v;也可以

 

附：_variant_t的操作符

operator  short(  )  const  throw(  _com_error  ); 

operator  long(  )  const  throw(  _com_error); 

operator  float(  )  const  throw(  _com_error  ); 

operator  double(  )  const  throw(  _com_error  ); 

operator  CY(  )  const  throw(  _com_error  ); 

operator  bool(  )  const  throw(  _com_error  ); 

operator  DECIMAL(  )  const  throw(  _com_error  ); 

operator  BYTE(  )  const  throw(  _com_error  ); 

operator  _bstr_t(  )  const  throw(  _com_error  ); 

operator  IDispatch*(  )  const  throw(  _com_error  ); 

operator  IUnknown*(  )  const  throw(  _com_error  ); 

// 

 

转自: http://www.cnblogs.com/forwyvernhom/archive/2008/12/04/1347833.html