CString与LPCWSTR、LPWSTR等数据类型的转化

CString与LPCWSTR、LPWSTR等数据类型的转化

之前我遇到过类似的问题，在以前两篇博文中也提到过类似编码问题： VC6.0设定UNICODE编译环境、VC中_T("")与L区别，但是都没有涉及到这些数据类型的转换。

1. CString与LPCWSTR的转换

LPCWSTR 是Unicode字符串常量指针，初始化时串有多大，申请空间就有多大，以后存储若超过则出现无法预料的结果，这是它与CString的不同之处。而CString是一个串类，内存空间类会自动管理。LPCWSTR的定义为：

[cpp]  view plain copy

1. typedef CONST WCHAR *LPCWSTR, *PCWSTR;  

LPCWSTR 初始化如下：

[cpp]  view plain copy

1. LPCWSTR Name=L"TestlpCwstr";   

由于LPCWSTR必须指向Unicode的字符串，问题的关键变成了ANSI字符与Unicode（可以参考： VC中_T("")与L区别）字符之间的转换。通过查询资料，涉及到不同编码间的转换，可以ATL中转换宏可以用如下方法实现：

[cpp]  view plain copy

1. //方法一   
2. CString str=_T("TestStr");   
3. USES_CONVERSION;   
4. LPWSTR pwStr=new wchar_t[str.GetLength()+1];   
5. wcscpy(pwStr,T2W((LPCTSTR)str));  

[cpp]  view plain copy

1. // 方法二   
2. CString str=_T("TestStr");   
3. USES_CONVERSION;   
4. LPWCSTR pwcStr = A2CW((LPCSTR)str);   

这里两种方法都用到了： USES_CONVERSION，它表示用来定义一些中间变量，在使用ATL的转换宏之前必须定义该语句。它需要包含头文件：#include <atlconv.h>。

注意： 慎用USES_CONVERSION

USES_CONVERSION是ATL中的一个宏定义。用于编码转换(用的比较多的是CString向LPCWSTR转换)。在ATL下使用要包含头文件#include <atlconv.h>
使用USES_CONVERSION一定要小心，它们从堆栈上分配内存，直到调用它的函数返回，该内存不会被释放。如果在一个循环中，这个宏被反复调用几万次，将不可避免的产生stackoverflow。

在一个函数的循环体中使用A2W等字符转换宏可能引起栈溢出。

[cpp]  view plain copy

1. #include <atlconv.h>  
2. void fn()  
3. {  
4.     while(true)  
5.     {  
6.         {  
7.             USES_CONVERSION;  
8.             DoSomething(A2W("SomeString"));  
9.         }  
10.     }  
11. }  

它的宏定义为：

[cpp]  view plain copy

1. #define A2W(lpa) (\  
2.     ((_lpa = lpa) == NULL) ? NULL : (\  
3.         _convert = (lstrlenA(_lpa)+1),\  
4.         ATLA2WHELPER((LPWSTR) alloca(_convert*2), _lpa, _convert)))  

[cpp]  view plain copy

1. #define ATLA2WHELPER AtlA2WHelper  

[cpp]  view plain copy

1. inline LPWSTR WINAPI AtlA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars, UINT acp)  
2. {  
3.    ATLASSERT(lpa != NULL);  
4.    ATLASSERT(lpw != NULL);  
5.    // verify that no illegal character present  
6.    // since lpw was allocated based on the size of lpa  
7.    // don't worry about the number of chars  
8.    lpw[0] = '\0';  
9.    MultiByteToWideChar(acp, 0, lpa, -1, lpw, nChars);  
10.    return lpw;  
11. }  

关键的地方在 alloca 内存分配内存上。
分配的内存是在函数的栈中分配的。 而VC编译器默认的栈内存空间是2M。当在一个函数中循环调用它时就会不断的分配栈中的内存。那么为了避免这类问题的发生，我们应该把字符转换部分放到一个函数中处理，如下：

[cpp]  view plain copy

1. void fn2()  
2. {  
3.     USES_CONVERSION;  
4.     DoSomething(A2W("SomeString"));  
5. }  
6.   
7. void fn()  
8. {  
9.     while(true)  
10.     {  
11.         fn2();  
12.     }  
13. }  

如果不知道这点问题，在使用后崩溃时很难查出崩溃原因的。

以上说明是为了解释USES_CONVERSION

提供另一种快捷的方法CString中的一个方法 AllocSysString，它返回BSTR 

[cpp]  view plain copy

1. //方法三  
2. CString str = _T("test");  
3. LPCWSTR lpcwStr = str.AllocSysString();  

如果将LPCWSTR转换成CString，那就更加容易，在msdn中的CString类说明中提到了可以直接用LPCWSTR来构造CString，所以可以进行如下的转换代码：

[cpp]  view plain copy

1. LPCWSTR pcwStr = L"TestpwcStr";   
2. CString str(pcwStr);  

MFC中CString和LPSTR是可以通用，其中A2CW表示(LPCSTR) -> (LPCWSTR)

2. CString和LPWSTR的转换

我也看到CString和LPWSTR有这么转化的：

[cpp]  view plain copy

1. CString str = _T("test");  
2. LPWSTR lpwStr = (LPWSTR)(LPCTSTR)str;  

这里转化以后只是得到的是一个指针，而不是str的真实内容。

如果要获取str里面的内容，用ATL转换如下，也有其他转换方法：

[cpp]  view plain copy

1. CString str = _T("test");  
2. USES_CONVERSION;  
3. LPWSTR lpwStr = A2W(str);  

这样的转换也比较简单。。。。

当然也可以用如下方法，所用函数wcscpy，宽字符复制函数：

[cpp]  view plain copy

1. wchar_t szBuffer[100] = {0};  
2. wcscpy(szBuffer,L"test");  
3. LPWSTR lpwStr = szBuffer;  

3. CString与LPSTR转换

CString转为LPSTR

[cpp]  view plain copy

1. //方法一  
2. CString str = _T("test");  
3. LPSTR lpStr = str.GetBuffer();  
4. str.ReleaseBuffer();  

[cpp]  view plain copy

1. //方法二  
2. CString str = _T("test");  
3. LPSTR lpStr = (LPSTR)(LPCSTR)str;  

LPSTR转为CString
这里比较简单，给出一种转换方法。

[cpp]  view plain copy

1. LPSTR lpStr = L"lpTestStr";  
2. CString str(lpStr);  

4. CString转为LPCSTR

CString转为LPCSTR可直接转换

[cpp]  view plain copy

1. CString str = _T("test");  
2. LPCSTR lpcStr = (LPCSTR)str;  

5. CString转为char*

[cpp]  view plain copy

1. //方法一  
2. CString str = _T("test");  
3. char *p = str.GetBuffer();  

[cpp]  view plain copy

1. //方法二  
2. CString str = _T("test");  
3. char *p = (LPSTR)(LPCSTR)str;  

char *转换成CString

[cpp]  view plain copy

1. char *p = "test";  
2. CString str = ("%s",p);  

或者

[cpp]  view plain copy

1. char *p = "test";  
2. CString str;  
3. str.Format(_T("%s"),p);  

6. CString转换成int、float等

直接使用 atoi，atof，atol等函数来实现。

7. 其他类型

在头文件<atlconv.h>中定义了ATL提供的所有转换宏，如： 

[cpp]  view plain copy

1. A2CW       (LPCSTR)  -> (LPCWSTR)   
2. A2W        (LPCSTR)  -> (LPWSTR)   
3. W2CA       (LPCWSTR) -> (LPCSTR)   
4. W2A        (LPCWSTR) -> (LPSTR)  

所有的宏如下表所示： 

A2BSTR	OLE2A	T2A	W2A
A2COLE	OLE2BSTR	T2BSTR	W2BSTR
A2CT	OLE2CA	T2CA	W2CA
A2CW	OLE2CT	T2COLE	W2COLE
A2OLE	OLE2CW	T2CW	W2CT
A2T	OLE2T	T2OLE	W2OLE
A2W	OLE2W	T2W	W2T

上表中的宏函数，非常的有规律，每个字母都有确切的含义如下：

2	to 的发音和 2 一样，所以借用来表示“转换为、转换到”的含义。
A	ANSI 字符串，也就是 MBCS。
W、OLE	宽字符串，也就是 UNICODE。
T	中间类型T。如果定义了 _UNICODE，则T表示W；如果定义了 _MBCS，则T表示A
C	const 的缩写

    利用这些宏，可以快速的进行各种字符间的转换。使用前必须包含头文件，并且申明USER_CONVERSION；

    使用 ATL 转换宏，由于不用释放临时空间，所以使用起来非常方便。

    但是考虑到栈空间的尺寸（VC 默认2M），使用时要注意几点： 

    1、只适合于进行短字符串的转换； 
    2、不要试图在一个次数比较多的循环体内进行转换； 
    3、不要试图对字符型文件内容进行转换，因为文件尺寸一般情况下是比较大的； 
    4、对情况 2 和 3，要使用 MultiByteToWideChar() 和 WideCharToMultiByte()；

8. 参考资料：

[1]  http://www.vckbase.com/index.php/wv/1206

[2]  http://www.cnblogs.com/foolboy/archive/2005/07/25/199869.html

[3]  http://www.cnblogs.com/carekee/articles/1935789.html