vc中常用类型转换

最新推荐文章于 2023-09-27 09:26:44 发布

转载最新推荐文章于 2023-09-27 09:26:44 发布 · 2.9k 阅读

本文详细介绍了VC++环境下不同类型之间的转换方法，包括CString与其他类型如int、char*之间的相互转换，并提供了示例代码。此外，还探讨了浮点数的取整策略，如使用floor和ceil函数等。

一、字符串转换

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

标签