vc中常用类型转换

一、字符串转换
1、CString转化为整形Int
CString str = _T("12345");
//atoi， 不知道还有别的函数没有，目前只知道有atoi
atoi((LPCSTR)str);//用LPCSTR转化为const char*即可

 

2、 将一个CString 转到一个char的数组(char*)中
char buffer[256];
CString str;
1)、 //strcpy方法
strcpy(buffer, str.GetBuffer());
str.ReleaseBuffer();
2)、 //强制转化方法
buffer=(LPTSTR)(LPCTSTR)str;
3)、//sprintf方法
sprint(buffer,"%s",str)
// 如果在vc2005中，需要将项目设置为MultiByte如果为

二、数值处理
1、浮点数取整方法

1)、 直接赋值给整数变量。如：
int i = 2.5; 或 i = (int)2.5; 这种方法采用的是四舍五入。

2)、 使 用 floor函 数 。 floor(x)返回的是x的整数部分。如：
floor(2.5) = 2
floor(-2.5) = -2
3)、使用ceil函数。ceil(x)返回的是不大于x的最小整数。如 ：
ceil(2.5) = 2
ceil(-2.5) = -3

4)、求余数%,fmod函数。
8 % 3 = 2。适用于整数
fmod(8.1,3) = 2.1。适用于浮点数。这个函数找了好久，本来都自己写了，不相信c++没有带，还是找到了。

vc中常用类型转换 (CString,char *,string,int)
1,
//(长)整形<-- -->字符串
//CString<-- -->int
CString   strTemp="10";
int iTemp=9;
//例-->
atoi(strTemp);
//atof(strTemp);
// 例<--
strTemp.Format("%d",iTemp);
2,
//CString<-- -->char[n],(char *)
char chTemp[20];
strcpy(chTemp,"char string");
//char * chTemp=NULL;
//chTemp="char string";
CString strTemp="test string";
//例-->
chTemp=strTemp.GetBuffer(strTemp.GetLength());
strTemp.ReleaseBuffer();
也可用(LPSTR)(LPCTSTR)对CString// 进行强制转换.
chTemp=(LPSTR)(LPCTSTR)strTemp;
// 例<--
strTemp=(const char*)chTemp;
3,
//string<-- -->CString
//string<-- -->char
char * chTemp=NULL;
memset( chTemp,0, 20 );
strcpy(chTemp,"char string");
CString strTemp="test string";
//例<--
string strstr=chTemp;
strstr=strTemp;
//
4,
//char -->CString
//char<-- -->char *
char chch;
CString strTemp;
char * chTemp;
//例<--
chch=chTemp[0];
strTemp=chch;
// 例-->
chTemp[0]=chch;
//char-->const char *
//(const char *)chch

转自：http://hi.baidu.com/mrhall/blog/item/58c05bf4a990ceec7609d7c7.html

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;
     };

COleDateTime vartodate(const _variant_t& var)
{
COleDateTime value;
switch (var.vt)
{
case VT_DATE:
   {
    value = var.date;
   }
   break;
case VT_EMPTY:
case VT_NULL:
   value.SetStatus(COleDateTime::null);
   break;
default:
   value.SetStatus(COleDateTime::null);
   TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d "), __FILE__, __LINE__);
}
return value;
}
COleCurrency vartocy(const _variant_t& var)
{
COleCurrency value;
switch (var.vt)
{
case VT_CY:
   value = (CURRENCY)var.cyVal;
   break;
case VT_EMPTY:
case VT_NULL:
   value.m_status = COleCurrency::null;
   break;
default:
   value.m_status = COleCurrency::null;
   TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d "), __FILE__, __LINE__);
}
return value;
}
bool vartobool(const _variant_t& var)
{
bool value = false;
switch (var.vt)
{
case VT_BOOL:
   value = var.boolVal true : false;
case VT_EMPTY:
case VT_NULL:
   break;
default:
   TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d "), __FILE__, __LINE__);
}
return value;
}
BYTE vartoby(const _variant_t& var)
{
BYTE value = 0;
switch (var.vt)
{
case VT_I1:
case VT_UI1:
   value = var.bVal;
   break;
case VT_NULL:
case VT_EMPTY:
   value = 0;
   break;
default:
   TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d "), __FILE__, __LINE__);
}
return value;
}
short vartoi(const _variant_t& var)
{
short value = 0;
switch (var.vt)
{
case VT_BOOL:
   value = var.boolVal;
   break;
case VT_UI1:
case VT_I1:
   value = var.bVal;
   break;
case VT_I2:
case VT_UI2:
   value = var.iVal;
   break;
case VT_NULL:
case VT_EMPTY:
   value = 0;
   break;
default:
   TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d "), __FILE__, __LINE__);
}
return value;
}
long vartol(const _variant_t& var)
{
long value = 0;
switch (var.vt)
{
case VT_BOOL:
   value = var.boolVal;
   break;
case VT_UI1:
case VT_I1:
   value = var.bVal;
   break;
case VT_UI2:
case VT_I2:
   value = var.iVal;
   break;
case VT_I4:
case VT_UI4:
   value = var.lVal;
   break;
case VT_INT:
   value = var.intVal;
   break;
case VT_R4:
   value = (long)(var.fltVal + 0.5);
   break;
case VT_R8:
   value = (long)(var.dblVal + 0.5);
   break;
case VT_DECIMAL:
   value = (long)var;
   break;
case VT_CY:
   value = (long)var;
   break;
case VT_BSTR://字符串
case VT_LPSTR://字符串
case VT_LPWSTR://字符串
   value = atol((LPCTSTR)(_bstr_t)var);
   break;
case VT_NULL:
case VT_EMPTY:
   value = 0;
   break;
default:
   TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d "), __FILE__, __LINE__);
}
return value;
}
double vartof(const _variant_t& var)
{
double value = 0;
switch (var.vt)
{
case VT_R4:
   value = var.fltVal;
   break;
case VT_R8:
   value = var.dblVal;
   break;
case VT_DECIMAL:
   value = (double)var;
   break;
case VT_CY:
   value = (double)var;
   break;
case VT_BOOL:
   value = var.boolVal;
   break;
case VT_UI1:
case VT_I1:
   value = var.bVal;
   break;
case VT_UI2:
case VT_I2:
   value = var.iVal;
   break;
case VT_UI4:
case VT_I4:
   value = var.lVal;
   break;
case VT_INT:
   value = var.intVal;
   break;
case VT_BSTR://字符串
case VT_LPSTR://字符串
case VT_LPWSTR://字符串
   value = atof((LPCTSTR)(_bstr_t)var);
   break;
case VT_NULL:
case VT_EMPTY:
   value = 0;
   break;
default:
   value = 0;
   TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d "), __FILE__, __LINE__);
}
return value;
}
CString vartostr(const _variant_t &var)
{
CString strValue;

switch (var.vt)
{
case VT_BSTR://字符串
case VT_LPSTR://字符串
case VT_LPWSTR://字符串
   strValue = (LPCTSTR)(_bstr_t)var;
   break;
case VT_I1:
case VT_UI1:
   strValue.Format("%d", var.bVal);
   break;
case VT_I2://短整型
   strValue.Format("%d", var.iVal);
   break;
case VT_UI2://无符号短整型
   strValue.Format("%d", var.uiVal);
   break;
case VT_INT://整型
   strValue.Format("%d", var.intVal);
   break;
case VT_I4: //整型
   strValue.Format("%d", var.lVal);
   break;
case VT_I8: //长整型
   strValue.Format("%d", var.lVal);
   break;
case VT_UINT://无符号整型
   strValue.Format("%d", var.uintVal);
   break;
case VT_UI4: //无符号整型
   strValue.Format("%d", var.ulVal);
   break;
case VT_UI8: //无符号长整型
   strValue.Format("%d", var.ulVal);
   break;
case VT_VOID:
   strValue.Format("%8x", var.byref);
   break;
case VT_R4://浮点型
   strValue.Format("%.4f", var.fltVal);
   break;
case VT_R8://双精度型
   strValue.Format("%.8f", var.dblVal);
   break;
case VT_DECIMAL: //小数
   strValue.Format("%.8f", (double)var);
   break;
case VT_CY:
   {
    COleCurrency cy = var.cyVal;
    strValue = cy.Format();
   }
   break;
case VT_BLOB:
case VT_BLOB_OBJECT:
case 0x2011:
   strValue = "[BLOB]";
   break;
case VT_BOOL://布尔型
   strValue = var.boolVal "TRUE" : "FALSE";
   break;
case VT_DATE: //日期型
   {
    DATE dt = var.date;
    COleDateTime da = COleDateTime(dt);
    strValue = da.Format("%Y-%m-%d %H:%M:%S");
   }
   break;
case VT_NULL://NULL值
   strValue = "";
   break;
case VT_EMPTY://空
   strValue = "";
   break;
case VT_UNKNOWN://未知类型
default:
   strValue = "UN_KNOW";
   break;
}
return strValue;
}

CString csTime;
Holder = MySet->GetCollect("FileCreateTime");
if(Holder.vt!=VT_NULL){
csTime.Format("%s",(LPCTSTR)_bstr_t(Holder));
}  
 
 

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

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);
• 浮点数(float,double)
  用fcvt可以完成转换, 这是MSDN中的例子:
  int decimal, sign;
  char *buffer;
  double source = 3.1415926535;
  buffer = _fcvt( source, 7, & decimal, & sign );
  运行结果:source: 3.1415926535 buffer: \'31415927\' decimal: 1 sign: 0
  decimal 表示小数点的位置,sign表示符号:0为正数，1为负数
• CString变量
  str = " 2008北京奥运" ;
  buf = (LPSTR)(LPCTSTR)str;
• BSTR变 量
  BSTR bstrValue = ::SysAllocString(L" 程序员" );
  char * buf = _com_util::ConvertBSTRToString(bstrValue);
  SysFreeString(bstrValue);
  AfxMessageBox(buf);
  delete(buf);
• CComBSTR变量
  CComBSTR bstrVar(" test" );
  char *buf = _com_util::ConvertBSTRToString(bstrVar.m_str);
  AfxMessageBox(buf);
  delete(buf);
  
• _bstr_t 变量
  _bstr_t类型是对BSTR的封装，因为已经重载了=操作符，所以很容易使用
  _bstr_t bstrVar(" test" );
  const char *buf = bstrVar; ///不要修改buf中的内容
  AfxMessageBox(buf);
  
  
• 通用方法(针对非COM数据类型)
  用 sprintf完成转换
  

  char  buffer[200];
  char  c = \'1\';
  int   i = 35;
  long  j = 1000;
  float f = 1.7320534f;
  sprintf( buffer, "
  %c"
  ,c);
  sprintf( buffer, "
  %d"
  ,i);
  sprintf( buffer, "
  %d"
  ,j);
  sprintf( buffer, "
  %f"
  ,f);
  
  
  

二、字符串转换为 其它数据类型
strcpy(temp," 123" );

• 短整型(int)
  i = atoi(temp);
• 长整型(long)
  l = atol(temp);
• 浮点(double)
  d = atof(temp);
• CString变量
  CString name = temp;
• BSTR变量
  BSTR bstrValue = ::SysAllocString(L" 程序员" );
  ...///完成对bstrValue的使用
  SysFreeString(bstrValue);
  
• CComBSTR变量
  CComBSTR 类型变量可以直接赋值
  CComBSTR bstrVar1(" test" );
  CComBSTR bstrVar2(temp);
  
• _bstr_t变量
  _bstr_t类型的变量可以直接赋值
  _bstr_t bstrVar1(" test" );
  _bstr_t bstrVar2(temp);
  
  

三、其它数据类型转换到CString
使用 CString的成员函数Format来转换,例如:

• 整数(int)
  str.Format(" %d" ,i);
• 浮 点数(float)
  str.Format(" %f" ,i);
• 字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值
  str = username;
• 对于Format所不支持的 数据类型，可以通过上面所说的关于其它数据类型转化到char *的方法先转到char *，然后赋值给CString变量。
  

四、BSTR、_bstr_t与CComBSTR

• CComBSTR 是ATL对BSTR的封装，_bstr_t是C++对BSTR的封装,BSTR是32位指针,但并不直接指向字串的缓冲区。
  char *转换到BSTR可以这样:
  BSTR b=_com_util::ConvertStringToBSTR(" 数据" ); ///使用前需要加上comutil.h和comsupp.lib
  SysFreeString(bstrValue);
  反之可以使用
  char *p=_com_util::ConvertBSTRToString(b);
  delete p;
  具体可以参考一，二段落里的具体 说明。
  
  CComBSTR与_bstr_t对大量的操作符进行了重载，可以直接进行=,!=,==等操作，所以使用非常方便。
  特别 是_bstr_t,建议大家使用它。
  

五、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与常用数据的对应关系:
  
  

  Byte 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.
  DECIMAL FAR* pdecVal	// VT_BYREF|VT_DECIMAL.
  IUnknown FAR* punkVal;	// VT_UNKNOWN.
  IDispatch FAR* pdispVal;	// VT_DISPATCH.
  SAFEARRAY FAR* parray;	// VT_ARRAY|*.
  Byte 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;	// Generic ByRef.
  char cVal;	// VT_I1.
  unsigned short uiVal;	// VT_UI2.
  unsigned long ulVal;	// VT_UI4.
  int intVal;	// VT_INT.
  unsigned int uintVal;	// VT_UINT.
  char FAR * pcVal;	// VT_BYREF|VT_I1.
  unsigned short FAR * puiVal;	// VT_BYREF|VT_UI2.
  unsigned long FAR * pulVal;	// VT_BYREF|VT_UI4.
  int FAR * pintVal;	// VT_BYREF|VT_INT.
  unsigned int FAR * puintVal;	//VT_BYREF|VT_UINT.

  
  
• _variant_t是VARIANT的封装类，其赋值可以使用强制 类型转换，其构造函数会自动处理这些数据类型。
  使用时需加上#include
  例如：
  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;
  
  

六、其它一些COM数据类型

• 根 据ProgID得到CLSID
  HRESULT CLSIDFromProgID( LPCOLESTR lpszProgID,LPCLSID pclsid);
  CLSID clsid;
  CLSIDFromProgID( L" MAPI.Folder" ,& clsid);
  
• 根据CLSID得到ProgID
  WINOLEAPI ProgIDFromCLSID( REFCLSID clsid,LPOLESTR * lplpszProgID);
  例如我们已经定义了 CLSID_IApplication,下面的代码得到ProgID
  LPOLESTR pProgID = 0;
  ProgIDFromCLSID( CLSID_IApplication,& pProgID);
  ...///可以使用pProgID
  CoTaskMemFree(pProgID); //不要忘记释放
  

七、 ANSI与Unicode
Unicode称为宽字符型字串,COM里使用的都是Unicode字符串。

• 将 ANSI转换到Unicode
  (1)通过L这个宏来实现，例如: CLSIDFromProgID( L" MAPI.Folder" ,& clsid);
  (2)通过MultiByteToWideChar函数实现转换,例如:
  char *szProgID = " MAPI.Folder" ;
  WCHAR szWideProgID[128];
  CLSID clsid;
  long lLen = MultiByteToWideChar(CP_ACP,0,szProgID,strlen(szProgID),szWideProgID,sizeof(szWideProgID));
  szWideProgID[lLen] = \'\\';
  (3)通过A2W宏来实现,例如:
  USES_CONVERSION;
  CLSIDFromProgID( A2W(szProgID),& clsid);
• 将Unicode转换到 ANSI
  (1)使用WideCharToMultiByte,例如:
  // 假设已经有了一个Unicode 串 wszSomeString...
  char szANSIString [MAX_PATH];
  WideCharToMultiByte ( CP_ACP, WC_COMPOSITECHECK, wszSomeString, -1, szANSIString, sizeof(szANSIString), NULL, NULL );
  (2)使用W2A宏来实现,例如:
  USES_CONVERSION;
  pTemp=W2A(wszSomeString);

八、其它

• 对消息的处理中我们经常需要将WPARAM或 LPARAM等32位数据（DWORD)分解成两个16位数据（WORD),例如：
  LPARAM lParam;
  WORD loValue = LOWORD(lParam); ///取低16位
  WORD hiValue = HIWORD(lParam); ///取高16位
  
  
• 对于16位的数据(WORD)我们可以用同样的方法分解成高低两个8位数据(BYTE),例如:
  WORD wValue;
  BYTE loValue = LOBYTE(wValue); ///取低8位
  BYTE hiValue = HIBYTE(wValue); ///取高8位
  
  
• 两个16位数据（WORD）合成32位数据 (DWORD,LRESULT,LPARAM,或WPARAM)
  LONG MAKELONG( WORD wLow, WORD wHigh );
  WPARAM MAKEWPARAM( WORD wLow, WORD wHigh );
  LPARAM MAKELPARAM( WORD wLow, WORD wHigh );
  LRESULT MAKELRESULT( WORD wLow, WORD wHigh );
  
  
• 两个8位的数据(BYTE)合成16位的数据(WORD)
  WORD MAKEWORD( BYTE bLow, BYTE bHigh );
  
  
• 从 R(red),G(green),B(blue)三色得到COLORREF类型的颜色值
  COLORREF RGB( BYTE byRed,BYTE byGreen,BYTE byBlue );
  例如COLORREF bkcolor = RGB(0x22,0x98,0x34);
  
  
• 从COLORREF类型的颜色值得到RGB三个颜色值
  BYTE Red = GetRValue(bkcolor); ///得到红颜色
  BYTE Green = GetGValue(bkcolor); ///得到绿颜色
  BYTE Blue = GetBValue(bkcolor); ///得到兰颜色
  

九、注意事项
假如需要使用 到ConvertBSTRToString此类函数,需要加上头文件comutil.h,并在setting中加入comsupp.lib或者直接加 上#pragma comment( lib, " comsupp.lib" )