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