`

vc中常用类型转换

VC++数据结构F#J#Blog 
阅读更多
一、字符串转换
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
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" )

分享到：
| 开发新产品所需要的十类文档
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    VC常用数据类型使用转换详解

    不同的数据类型适用于不同的应用场景，而正确地进行类型转换能够确保程序的健壮性和准确性。在实际开发中，理解并熟练运用这些转换方法，将大大提升代码的质量和效率。此外，对于高级类型如VARIANT的掌握，更是深入...

    VC常用数据类型转换.doc

    以下是一些关于VC常用数据类型转换的详细说明： 1. **BSTR、LPSTR 和 LPWSTR** - **BSTR**（Basic String）是OLECHAR*类型的Unicode字符串，用于自动化兼容性。它由系统API（如`SysAllocString`）管理，并包含一个...

    VC常用数据类型使用转换详解.mht

    VC常用数据类型使用转换详解.mhtVC常用数据类型使用转换详解.mhtVC常用数据类型使用转换详解.mhtVC常用数据类型使用转换详解.mhtVC常用数据类型使用转换详解.mhtVC常用数据类型使用转换详解.mht

    VC常用数据类型使用转换详解.doc

    CString 的成员函数 Format 可以将各种数据类型转换为字符串。例如： * 整数转换为字符串：str.Format("%d", i); * 浮点数转换为字符串：str.Format("%f", f); * 字符串指针转换为 CString：str = CString(buf); 6...

    VC CString最全面的总结 常用数据类型使用转换详解等总结

    在Windows程序设计中，了解和...在VC常用数据类型使用转换中，理解和掌握这些概念和技巧对于高效地开发Windows应用程序至关重要。熟练运用这些工具和消息机制能够帮助程序员编写出更加灵活、响应迅速且健壮的应用程序。

    VC常用数据类型转换

    包含基本类型－&gt;CString转换，WORD-&gt;DWORD/BYTE,TCHAR-&gt;CSTRING/BSTR, DWORD-&gt;WORD,CSTRING-&gt;基本数据类型/TCHAR/BSTR,COLORREF-&gt;RGB,BYTE-&gt;KB/MB/GB,BSTR-&gt; TCHAR/CSTRING等多种数据类型转换源码！

    vc常用数据类型使用转换详解

    ### VC常用数据类型使用转换详解 #### 一、引言 在C++编程尤其是使用Visual C++（简称VC）进行开发时，数据类型的转换是非常重要的一个环节。掌握不同类型之间的转换不仅可以帮助开发者更灵活地处理数据，还能提升...

    VC常用字符类型.doc

    本文主要探讨了VC中常用的字符类型以及如何在ANSI和Unicode之间进行转换。 首先，了解字符类型的差异至关重要。在VC++中，有三种主要的字符类型：ASCII（ANSI）、Unicode和MBCS（多字节字符集）。ASCII是最基本的...

    VC++类型转换详解

    **一．VC常用数据类型列表** 1. **boolean**: 8位无符号整型，用于表示真/假值，通常对应于`TRUE`和`FALSE`。 2. **byte**: 8位无符号整型，通常用于存储单个字符或简单的数值。 3. **char**: 8位有符号整型，用于...

    VC常用数据类型的使用

    - `CString`变量可以通过类型转换得到字符串，如`buf = (LPSTR)(LPCTSTR)str;` - `BSTR`变量需要通过`_com_util::ConvertBSTRToString()`进行转换，如`buf = _com_util::ConvertBSTRToString(bstrValue);` - `_...

    在vc中如何进行类型转换比如把整型转换为字符串型或从字符串转换为整型教材.pdf

    在VC（Visual C++）中进行类型转换是程序开发中一个基础且常用的操作，涉及到数据类型之间的转换，这包括基本数据类型（如整型、浮点型和字符串型）之间的转换以及更复杂的对象类型转换，如COM对象和BSTR（Basic ...

    VC常用类型转化及内存泄露检测.rar

    在压缩包中的"VC常用类型转化.txt"可能涵盖了上述类型转换的详细示例和解释，而"CString常用方法.txt"可能涉及到MFC中的CString类，这是一个非常方便的字符串处理类，其内部管理内存，可以减少内存泄露的机会。...

    VC常用数据类型列表.doc

    一、VC 常用数据类型列表 VC++支持多种基本和特定于Windows的数据类型。以下是一些主要的数据类型： 1. boolean：8位，用于表示真/假值。 2. byte：8位无符号整数。 3. char：8位字符类型，通常用于处理ASCII字符。...

    vc数据类型的转换

    总结，VC++中的数据类型转换涉及到多种函数和类方法，包括但不限于`itoa()`, `ltoa()`, `_fcvt()`, `atoi()`, `atof()`, `Format()`，以及COM相关的转换函数。理解并熟练掌握这些转换方法，对编写高效且可靠的VC++...

    常用类型转换

    以下是对"常用类型转换"这一主题的详细阐述。 首先，C++中的类型转换分为隐式转换和显式转换。隐式转换是指编译器自动进行的转换，如基本数据类型的提升，例如将`int`转换为`long`或者从`char`到`int`。这种转换...

Magicbox
Global site tag (gtag.js) - Google Analytics