| 一． VC常用数据类型列表 二． 常用数据类型转化 2.1数学类型变量与字符串相互转换 2.2 CString及string,char *与其他数据类型的转换和操作 ●CString,string,char*的综合比较 ●数学类型与CString相互转化 ●CString与char*相互转换举例 ●CString 与 BSTR 型转换 ●VARIANT 型转化成 CString 型 2.3 BSTR、_bstr_t与CComBSTR 2.4 VARIANT 、_variant_t 与 COleVariant 附录CString及字符串转及操作详解
参考书籍:CSDN,<<MFC深入浅出(Second Edit)>>
一．VC常用数据类型列表
说明: (1)-------表示省略 (2)1Byte=8Bit, 字与机器有关,在8位系统中:字=1字节,16位系统中,1字=2字节，32位中:1字=4字节, 64位中1字=8字节.不要搞混这些概念.
二．常用数据类型转化及操作 2．1 数学类型变量与字符串相互转换(这些函数都在STDLIB.H里) （1）将数学类型转换为字符串可以用以下一些函数: 举例: _CRTIMP char * __cdecl _itoa(int, char *, int);//这是一个将数字转换为一个字符串类型的函数,最后一个int表示转换的进制 如以下程序: int iTyep=3; char *szChar; itoa(iType,szChar,2); cout<<szChar;//输出为1010 类似函数列表: _CRTIMP char * __cdecl _itoa(int, char *, int);//为了完整性,也列在其中 _CRTIMP char * __cdecl _ultoa(unsigned long, char *, int); _CRTIMP char * __cdecl _ltoa(long, char *, int); _CRTIMP char * __cdecl _i64toa(__int64, char *, int); _CRTIMP char * __cdecl _ui64toa(unsigned __int64, char *, int); _CRTIMP wchar_t * __cdecl _i64tow(__int64, wchar_t *, int); _CRTIMP wchar_t * __cdecl _ui64tow(unsigned __int64, wchar_t *, int); _CRTIMP wchar_t * __cdecl _itow (int, wchar_t *, int);//转换为长字符串类型 _CRTIMP wchar_t * __cdecl _ltow (long, wchar_t *, int); _CRTIMP wchar_t * __cdecl _ultow (unsigned long, wchar_t *, int); 还有很多,请自行研究 （2）将字符串类型转换为数学类型变量可以用以下一些函数: 举例: _CRTIMP int __cdecl atoi(const char *);//参数一看就很明了 char *szChar=”88”; int temp(0); temp=atoi(szChar); cout<<temp; 类似的函数列表: _CRTIMP int __cdecl atoi(const char *); _CRTIMP double __cdecl atof(const char *); _CRTIMP long __cdecl atol(const char *); _CRTIMP long double __cdecl _atold(const char *); _CRTIMP __int64 __cdecl _atoi64(const char *); _CRTIMP double __cdecl strtod(const char *, char **);// _CRTIMP long __cdecl strtol(const char *, char **, int);// _CRTIMP long double __cdecl _strtold(const char *, char **); _CRTIMP unsigned long __cdecl strtoul(const char *, char **, int); _CRTIMP double __cdecl wcstod(const wchar_t *, wchar_t **);//长字符串类型转换为数学类型 _CRTIMP long __cdecl wcstol(const wchar_t *, wchar_t **, int); _CRTIMP unsigned long __cdecl wcstoul(const wchar_t *, wchar_t **, int); _CRTIMP int __cdecl _wtoi(const wchar_t *); _CRTIMP long __cdecl _wtol(const wchar_t *); _CRTIMP __int64 __cdecl _wtoi64(const wchar_t *); 还有很多,请自行研究 2．2．CString及string,char *与其他数据类型的转换和操作 （1）CString,string,char*的综合比较（这部分CSDN上的作者joise的文章 << CString,string,char*的综合比较>>写的很详细,请大家在仔细阅读他的文章. 地址: http://blog.csdn.net/joise/ 或参考附录: (2)转换: ●数学类型与CString相互转化 数学类型转化为CString 可用Format函数,举例: CString s; int i = 64; s.Format("%d", i) CString转换为数学类型:举例CString strValue("1.234"); double dblValue; dblValue = atof((LPCTSTR)strValue); ●CString与char*相互转换举例 CString strValue(“Hello”); char *szValue; szValue=strValue.GetBuffer(szValue); 也可用(LPSTR)(LPCTSTR)对CString// 进行强制转换. szValue=(LPSTR)(LPCTSTR)strValue; 反过来可直接赋值: char *szChar=NULL; CString strValue; szChar=new char[10]; memset(szChar,0,10); strcpy(szChar,”Hello”); strValue=szChar; ●CString 与 BSTR 型转换 CString 型转化成 BSTR 型 当我们使用 ActiveX 控件编程时，经常需要用到将某个值表示成 BSTR 类型.BSTR 是一种记数字符串，Intel平台上的宽字符串（Unicode），并且可以包含嵌入的 NULL 字符。 可以调用 CString 对象的 AllocSysString 方法将 CString 转化成 BSTR： CString str; str = .....; // whatever BSTR bStr = str.AllocSysString();
如果你在 UNICODE 模式下编译代码，你可以简单地写成： CString convert(BSTR bStr) { if(bStr == NULL) return CString(_T("")); CString s(bStr); // in UNICODE mode return s; } 如果是 ANSI 模式 CString convert(BSTR b) { CString s; if(b == NULL) return s; // empty for NULL BSTR #ifdef UNICODE s = b; #else LPSTR p = s.GetBuffer(SysStringLen(b) + 1); ::WideCharToMultiByte(CP_ACP, // ANSI Code Page 0, // no flags b, // source widechar string -1, // assume NUL-terminated p, // target buffer SysStringLen(b)+1, // target buffer length NULL, // use system default char NULL); // don''t care if default used s.ReleaseBuffer(); #endif return s; }
●VARIANT 型转化成 CString 型 VARIANT 类型经常用来给 COM 对象传递参数，或者接收从 COM 对象返回的值。你也能自己编写返回 VARIANT 类型的方法，函数返回什么类型 依赖可能（并且常常）方法的输入参数（比如，在自动化操作中，依赖与你调用哪个方法。IDispatch::Invoke 可能返回（通过其一个参数）一个 包含有BYTE、WORD、float、double、date、BSTR 等等 VARIANT 类型的结果，（详见 MSDN 上的 VARIANT 结构的定义）。在下面的例子中，假设 类型是一个BSTR的变体，也就是说在串中的值是通过 bsrtVal 来引用，其优点是在 ANSI 应用中，有一个构造函数会把 LPCWCHAR 引用的值转换为一个 CString（见 BSTR-to-CString 部分）。在 Unicode 模式中，将成为标准的 CString 构造函数，参见对缺省::WideCharToMultiByte 转换的告诫，以及你觉得是否可以接受（大多数情况下，你会满意的）。VARIANT vaData; vaData = m_com.YourMethodHere(); ASSERT(vaData.vt == VT_BSTR); CString strData(vaData.bstrVal); 你还可以根据 vt 域的不同来建立更通用的转换例程。为此你可能会考虑： CString VariantToString(VARIANT * va) { CString s; switch(va->vt) { /* vt */ case VT_BSTR: return CString(vaData->bstrVal); case VT_BSTR | VT_BYREF: return CString(*vaData->pbstrVal); case VT_I4: s.Format(_T("%d"), va->lVal); return s; case VT_I4 | VT_BYREF: s.Format(_T("%d"), *va->plVal); case VT_R8: s.Format(_T("%f"), va->dblVal); return s; ... 剩下的类型转换由读者自己完成 default: ASSERT(FALSE); // unknown VARIANT type (this ASSERT is optional) return CString(""); } /* vt */ }
2．3 BSTR、_bstr_t与CComBSTR CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。 char *转换到BSTR可以这样: BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上头文件comutil.h 反之可以使用char *p=_com_util::ConvertBSTRToString(b); 2．4(引)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; | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
在Visual C++.NET的所有编程方式中，我们常常要用到这样的一些基本字符串类型，如BSTR、LPSTR和LPWSTR等。之所以出现类似上述的这些数据类型，是因为不同编程语言之间的数据交换以及对ANSI、Unicode和多字节字符集(MBCS)的支持。
那么什么是BSTR、LPSTR以及LPWSTR呢？
BSTR(Basic STRing，Basic字符串)是一个OLECHAR*类型的Unicode字符串。它被描述成一个与自动化相兼容的类型。由于操作系统提供相应的 API函数(如SysAllocString)来管理它以及一些默认的调度代码，因此BSTR实际上就是一个COM字符串，但它却在自动化技术以外的多种场合下得到广泛使用。图1描述了BSTR的结构，其中DWORD值是字符串中实际所占用的字节数，且它的值是字符串中Unicode字符的两倍。
LPSTR和LPWSTR是Win32和VC++所使用的一种字符串数据类型。LPSTR被定义成是一个指向以NULL(‘/0’)结尾的8位ANSI 字符数组指针，而LPWSTR是一个指向以NULL结尾的16位双字节字符数组指针。在VC++中，还有类似的字符串类型，如LPTSTR、 LPCTSTR等，它们的含义如图2所示。
例如，LPCTSTR是指“long pointer to a constant generic string”，表示“一个指向一般字符串常量的长指针类型”，与C/C++的const char*相映射，而LPTSTR映射为 char*。
一般地，还有下列类型定义：
#ifdef UNICODE
typedef LPWSTR LPTSTR;
typedef LPCWSTR LPCTSTR;
#else
typedef LPSTR LPTSTR;
typedef LPCSTR LPCTSTR;
#endif
二、CString、CStringA 和 CStringW
Visual C++.NET中将CStringT作为ATL和MFC的共享的“一般”字符串类，它有CString、CStringA和CStringW三种形式，分别操作不同字符类型的字符串。这些字符类型是TCHAR、char和wchar_t。TCHAR在Unicode平台中等同于WCHAR(16位 Unicode字符)，在ANSI中等价于char。wchar_t通常定义为unsigned short。由于CString在MFC应用程序中经常用到，这里不再重复。
三、VARIANT、COleVariant 和_variant_t
在OLE、ActiveX和COM中，VARIANT数据类型提供了一种非常有效的机制，由于它既包含了数据本身，也包含了数据的类型，因而它可以实现各种不同的自动化数据的传输。下面让我们来看看OAIDL.H文件中VARIANT定义的一个简化版：
struct tagVARIANT {
VARTYPE vt;
union {
short iVal; // VT_I2.
long lVal; // VT_I4.
float fltVal; // VT_R4.
double dblVal; // VT_R8.
DATE date; // VT_DATE.
BSTR bstrVal; // VT_BSTR.
…
short * piVal; // VT_BYREF|VT_I2.
long * plVal; // VT_BYREF|VT_I4.
float * pfltVal; // VT_BYREF|VT_R4.
double * pdblVal; // VT_BYREF|VT_R8.
DATE * pdate; // VT_BYREF|VT_DATE.
BSTR * pbstrVal; // VT_BYREF|VT_BSTR.
};
};
显然，VARIANT类型是一个C结构，它包含了一个类型成员vt、一些保留字节以及一个大的union类型。例如，如果vt为VT_I2，那么我们可以从iVal中读出VARIANT的值。同样，当给一个VARIANT变量赋值时，也要先指明其类型。例如：
VARIANT va;
:: VariantInit(&va); // 初始化
int a = 2002;
va.vt = VT_I4; // 指明long数据类型
va.lVal = a; // 赋值
为了方便处理VARIANT类型的变量，Windows还提供了这样一些非常有用的函数：
VariantInit —— 将变量初始化为VT_EMPTY；
VariantClear —— 消除并初始化VARIANT；
VariantChangeType —— 改变VARIANT的类型；
VariantCopy —— 释放与目标VARIANT相连的内存并复制源VARIANT。
COleVariant类是对VARIANT结构的封装。它的构造函数具有极为强大大的功能，当对象构造时首先调用VariantInit进行初始化，然后根据参数中的标准类型调用相应的构造函数，并使用VariantCopy进行转换赋值操作，当VARIANT对象不在有效范围时，它的析构函数就会被自动调用，由于析构函数调用了VariantClear，因而相应的内存就会被自动清除。除此之外，COleVariant的赋值操作符在与VARIANT类型转换中为我们提供极大的方便。例如下面的代码：
COleVariant v1("This is a test"); // 直接构造
COleVariant v2 = "This is a test";
// 结果是VT_BSTR类型，值为"This is a test"
COleVariant v3((long)2002);
COleVariant v4 = (long)2002;
// 结果是VT_I4类型，值为2002
_variant_t是一个用于COM的VARIANT类，它的功能与COleVariant相似。不过在Visual C++.NET的MFC应用程序中使用时需要在代码文件前面添加下列两句：
#include "comutil.h"
#pragma comment( lib, "comsupp.lib" )
四、CComBSTR和_bstr_t
CComBSTR是对BSTR数据类型封装的一个ATL类，它的操作比较方便。例如：
CComBSTR bstr1;
bstr1 = "Bye"; // 直接赋值
OLECHAR* str = OLESTR("ta ta"); // 长度为5的宽字符
CComBSTR bstr2(wcslen(str)); // 定义长度为5
wcscpy(bstr2.m_str, str); // 将宽字符串复制到BSTR中
CComBSTR bstr3(5, OLESTR("Hello World"));
CComBSTR bstr4(5, "Hello World");
CComBSTR bstr5(OLESTR("Hey there"));
CComBSTR bstr6("Hey there");
CComBSTR bstr7(bstr6);
// 构造时复制，内容为"Hey there"
_bstr_t是是C++对BSTR的封装，它的构造和析构函数分别调用SysAllocString和SysFreeString函数，其他操作是借用BSTR API函数。与_variant_t相似，使用时也要添加comutil.h和comsupp.lib。
五、BSTR、char*和CString转换
(1) char*转换成CString
若将char*转换成CString，除了直接赋值外，还可使用CString::Format进行。例如：
char chArray[] = "This is a test";
char * p = "This is a test";
或
LPSTR p = "This is a test";
或在已定义Unicode应的用程序中
TCHAR * p = _T("This is a test");
或
LPTSTR p = _T("This is a test");
CString theString = chArray;
theString.Format(_T("%s"), chArray);
theString = p;
(2) CString转换成char*
若将CString类转换成char*(LPSTR)类型，常常使用下列三种方法：
方法一，使用强制转换。例如：
CString theString( "This is a test" );
LPTSTR lpsz =(LPTSTR)(LPCTSTR)theString;
方法二，使用strcpy。例如：
CString theString( "This is a test" );
LPTSTR lpsz = new TCHAR[theString.GetLength()+1];
_tcscpy(lpsz, theString);
需要说明的是，strcpy(或可移值Unicode/MBCS的_tcscpy)的第二个参数是 const wchar_t* (Unicode)或const char* (ANSI)，系统编译器将会自动对其进行转换。
方法三，使用CString::GetBuffer。例如：
CString s(_T("This is a test "));
LPTSTR p = s.GetBuffer();
// 在这里添加使用p的代码
if(p != NULL) *p = _T('/0');
s.ReleaseBuffer();
// 使用完后及时释放，以便能使用其它的CString成员函数
(3) BSTR转换成char*
方法一，使用ConvertBSTRToString。例如：
#include
#pragma comment(lib, "comsupp.lib")
int _tmain(int argc, _TCHAR* argv[]){
BSTR bstrText = ::SysAllocString(L"Test");
char* lpszText2 = _com_util::ConvertBSTRToString(bstrText);
SysFreeString(bstrText); // 用完释放
delete[] lpszText2;
return 0;
}
方法二，使用_bstr_t的赋值运算符重载。例如：
_bstr_t b = bstrText;
char* lpszText2 = b;
(4) char*转换成BSTR
方法一，使用SysAllocString等API函数。例如：
BSTR bstrText = ::SysAllocString(L"Test");
BSTR bstrText = ::SysAllocStringLen(L"Test",4);
BSTR bstrText = ::SysAllocStringByteLen("Test",4);
方法二，使用COleVariant或_variant_t。例如：
//COleVariant strVar("This is a test");
_variant_t strVar("This is a test");
BSTR bstrText = strVar.bstrVal;
方法三，使用_bstr_t，这是一种最简单的方法。例如：
BSTR bstrText = _bstr_t("This is a test");
方法四，使用CComBSTR。例如：
BSTR bstrText = CComBSTR("This is a test");
或
CComBSTR bstr("This is a test");
BSTR bstrText = bstr.m_str;
方法五，使用ConvertStringToBSTR。例如：
char* lpszText = "Test";
BSTR bstrText = _com_util::ConvertStringToBSTR(lpszText);
(5) CString转换成BSTR
通常是通过使用CStringT::AllocSysString来实现。例如：
CString str("This is a test");
BSTR bstrText = str.AllocSysString();
…
SysFreeString(bstrText); // 用完释放
(6) BSTR转换成CString
一般可按下列方法进行：
BSTR bstrText = ::SysAllocString(L"Test");
CStringA str;
str.Empty();
str = bstrText;
或
CStringA str(bstrText);
(7) ANSI、Unicode和宽字符之间的转换
方法一，使用MultiByteToWideChar将ANSI字符转换成Unicode字符，使用WideCharToMultiByte将Unicode字符转换成ANSI字符。
方法二，使用“_T”将ANSI转换成“一般”类型字符串，使用“L”将ANSI转换成Unicode，而在托管C++环境中还可使用S将ANSI字符串转换成String*对象。例如：
TCHAR tstr[] = _T("this is a test");
wchar_t wszStr[] = L"This is a test";
String* str = S”This is a test”;
方法三，使用ATL 7.0的转换宏和类。ATL7.0在原有3.0基础上完善和增加了许多字符串转换宏以及提供相应的类，它具有如图3所示的统一形式：
其中，第一个C表示“类”，以便于ATL 3.0宏相区别，第二个C表示常量，2表示“to”，EX表示要开辟一定大小的缓冲。SourceType和DestinationType可以是A、 T、W和OLE，其含义分别是ANSI、Unicode、“一般”类型和OLE字符串。例如，CA2CT就是将ANSI转换成一般类型的字符串常量。下面是一些示例代码：
LPTSTR tstr= CA2TEX<16>("this is a test");
LPCTSTR tcstr= CA2CT("this is a test");
wchar_t wszStr[] = L"This is a test";
char* chstr = CW2A(wszStr);
六、结语
几乎所有的程序都要用到字符串，而Visual C++.NET由于功能强大、应用广泛，因而字符串之间的转换更为频繁。本文几乎涉及到目前的所有转换方法。当然对于.NET框架来说，还可使用Convert和Text类进行不同数据类型以及字符编码之间的相互转换。
扫一扫
1505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
