|
|
CString 是一种很有用的数据类型。它们很大程度上简化了MFC
中的许多操作，使得MFC 在做字符串操作的时候方便了很多。不管怎
样，使用CString 有很多特殊的技巧，特别是对于纯C 背景下走出来
的程序员来说有点难以学习。这篇文章就来讨论这些技巧。
使用CString 可以让你对字符串的操作更加直截了当。这篇文章
不是CString 的完全手册，但囊括了大部分常见基本问题。
这篇文章包括以下内容：
CString对象的连接
格式化字符串（包括int型转化为CString）
CString型转化成int型
CString型和char*类型的相互转化
char*转化成CString
CString转化成char*之一：使用LPCTSTR强制转化
CString转化成char*之二：使用CString对象的GetBuffer方法
CString转化成char*之三:和控件的接口
CString型转化成BSTR型；
BSTR型转化成CString型；
VARIANT型转化成CString型；
载入字符串表资源；
CString和临时对象；
CString的效率；
总结
下面我分别讨论。
1、CString对象的连接
能体现出 CString类型方便性特点的一个方面就字符串的连接，
使用 CString类型，你能很方便地连接两个字符串，正如下面的例子：
CString gray("Gray");
CString cat("Cat");
CString graycat = gray + cat;
要比用下面的方法好得多：
char gray[] = "Gray";
char cat[] = "Cat";
char * graycat = malloc(strlen(gray) + strlen(cat) + 1);
strcpy(graycat, gray); strcat(graycat, cat);
2、格式化字符串
与其用 sprintf()函数或 wsprintf() 函数来格式化一个字符串，
还不如用 CString对象的Format()方法：
CString s;
s.Format(_T("The total is %d"), total);
用这种方法的好处是你不用担心用来存放格式化后数据的缓冲区
是否足够大，这些工作由CString 类替你完成。
格式化是一种把其它不是字符串类型的数据转化为CString 类型
的最常用技巧，比如，把一个整数转化成CString 类型，可用如下方
法：
CString s;
s.Format(_T("%d"), total);我总是对我的字符串使用_T()宏，
这是为了让我的代码至少有Unicode 的意识，当然，关于Unicode 的
话题不在这篇文章的讨论范围。_T()宏在8 位字符环境下是如下定义
的：
#define _T(x) x //非Unicode版本（non-Unicode version）
而在Unicode环境下是如下定义的：
#define _T(x) L##x // Unicode版本（Unicode version）
所以在Unicode 环境下，它的效果就相当于：
s.Format(L"%d", total);
如果你认为你的程序可能在Unicode 的环境下运行，那么开始在
意用 Unicode编码。比如说，不要用 sizeof() 操作符来获得字符串
的长度，因为在Unicode 环境下就会有2 倍的误差。我们可以用一些
方法来隐藏Unicode 的一些细节，比如在我需要获得字符长度的时候，
我会用一个叫做DIM 的宏，这个宏是在我的dim.h 文件中定义的，我
会在我写的所有程序中都包含这个文件：
#define DIM(x) ( sizeof((x)) / sizeof((x)[0]) )
这个宏不仅可以用来解决Unicode 的字符串长度的问题，也可以
用在编译时定义的表格上，它可以获得表格的项数，如下：
class Whatever { ... };
Whatever data[] = {
{ ... },
...
{ ... },
};
for(int i = 0; i < DIM(data); i++) // 扫描表格寻找匹配项。
这里要提醒你的就是一定要注意那些在参数中需要真实字节数的
API 函数调用，如果你传递字符个数给它，它将不能正常工作。如下
：TCHAR data[20];
lstrcpyn(data, longstring, sizeof(data) - 1); // WRONG!
lstrcpyn(data, longstring, DIM(data) - 1); // RIGHT
WriteFile(f, data, DIM(data), &bytesWritten, NULL); // WRONG!
WriteFile(f, data, sizeof(data), &bytesWritten, NULL); // RIGHT
造成以上原因是因为lstrcpyn需要一个字符个数作为参数，但是
WriteFile 却需要字节数作为参数。
同样需要注意的是有时候需要写出数据的所有内容。如果你仅仅
只想写出数据的真实长度，你可能会认为你应该这样做：
WriteFile(f, data, lstrlen(data), &bytesWritten, NULL); // WRONG
但是在Unicode 环境下，它不会正常工作。正确的做法应该是这
样：
WriteFile(f, data, lstrlen(data) * sizeof(TCHAR), &bytesWritten, NULL); // RIGHT
因为WriteFile 需要的是一个以字节为单位的长度。（可能有些
人会想“在非Unicode 的环境下运行这行代码，就意味着总是在做一
个多余的乘1 操作，这样不会降低程序的效率吗？”这种想法是多余
的，你必须要了解编译器实际上做了什么，没有哪一个C 或C++ 编译
器会把这种无聊的乘1 操作留在代码中。在Unicode 环境下运行的时
候，你也不必担心那个乘2 操作会降低程序的效率，记住，这只是一
个左移一位的操作而已，编译器也很乐意为你做这种替换。）
使用_T宏并不是意味着你已经创建了一个Unicode 的程序，你只
是创建了一个有Unicode 意识的程序而已。如果你在默认的8-bit 模
式下编译你的程序的话，得到的将是一个普通的8-bit 的应用程序
（这里的8-bit 指的只是8 位的字符编码，并不是指8 位的计算机系
统）；当你在Unicode 环境下编译你的程序时，你才会得到一个Unicode
的程序。记住，CString 在 Unicode环境下，里面包含的可都是16位
的字符哦。
3、CString型转化成int型
把 CString类型的数据转化成整数类型最简单的方法就是使用标
准的字符串到整数转换例程。
虽然通常你怀疑使用_atoi() 函数是一个好的选择，它也很少会
是一个正确的选择。如果你准备使用 Unicode字符，你应该用_ttoi()
，它在 ANSI编码系统中被编译成_atoi() ，而在 Unicode编码系统中
编译成_wtoi() 。你也可以考虑使用_tcstoul()或者_tcstol() ，它
们都能把字符串转化成任意进制的长整数（如二进制、八进制、十进
制或十六进制），不同点在于前者转化后的数据是无符号的（unsigned），
而后者相反。看下面的例子：
CString hex = _T("FAB");
CString decimal = _T("4011");
ASSERT(_tcstoul(hex, 0, 16) == _ttoi(decimal));
4、CString型和char*类型的相互转化
这是初学者使用 CString时最常见的问题。有了 C++的帮助，很
多问题你不需要深入的去考虑它，直接拿来用就行了，但是如果你不
能深入了解它的运行机制，又会有很多问题让你迷惑，特别是有些看
起来没有问题的代码，却偏偏不能正常工作。
比如，你会奇怪为什么不能写向下面这样的代码呢：
CString graycat = "Gray" + "Cat";
或者这样：
CString graycat("Gray" + "Cat");
事实上，编译器将抱怨上面的这些尝试。为什么呢？因为针对CString
和 LPCTSTR数据类型的各种各样的组合，“ +”运算符被定义成一个
重载操作符。而不是两个 LPCTSTR数据类型，它是底层数据类型。你
不能对基本数据（如 int、char或者 char*）类型重载 C++的运算符。
你可以象下面这样做：
CString graycat = CString("Gray") + CString("Cat");
或者这样：
CString graycat = CString("Gray") + "Cat";
研究一番就会发现：“ +”总是使用在至少有一个 CString对象
和一个 LPCSTR 的场合。
注意，编写有 Unicode意识的代码总是一件好事，比如：
CString graycat = CString(_T("Gray")) + _T("Cat");
这将使得你的代码可以直接移植。
char*转化为CString
现在你有一个 char*类型的数据，或者说一个字符串。怎么样创
建 CString对象呢？这里有一些例子：
char * p = "This is a test";
或者象下面这样更具有Unicode意识：
TCHAR * p = _T("This is a test")
或
LPTSTR p = _T("This is a test");
你可以使用下面任意一种写法：
CString s = "This is a test"; // 8-bit only
CString s = _T("This is a test"); // Unicode-aware
CString s("This is a test"); // 8-bit only
CString s(_T("This is a test")); // Unicode-aware
CString s = p;
CString s(p);
用这些方法可以轻松将常量字符串或指针转换成 CString。需要
注意的是，字符的赋值总是被拷贝到 CString对象中去的，所以你可
以象下面这样操作：
TCHAR * p = _T("Gray");
CString s(p);
p = _T("Cat");
s += p;
结果字符串肯定是“GrayCat ”。
CString 类还有几个其它的构造函数，但是这里我们不考虑它，
如果你有兴趣可以自己查看相关文档。
事实上，CString 类的构造函数比我展示的要复杂，比如：
CString s = "This is a test";
这是很草率的编码，但是实际上它在 Unicode环境下能编译通过。
它在运行时调用构造函数的 MultiByteToWideChar操作将 8位字符串
转换成 16 位字符串。不管怎样，如果 char * 指针是网络上传输的
8 位数据，这种转换是很有用的。
CString转化成char*之一：强制类型转换为LPCTSTR；
这是一种略微硬性的转换，有关“正确”的做法，人们在认识上
还存在许多混乱，正确的使用方法有很多，但错误的使用方法可能与
正确的使用方法一样多。
我们首先要了解 CString是一种很特殊的 C++对象，它里面包含
了三个值：一个指向某个数据缓冲区的指针、一个是该缓冲中有效的
字符记数以及一个缓冲区长度。有效字符数的大小可以是从0 到该缓
冲最大长度值减1 之间的任何数（因为字符串结尾有一个NULL字符）。
字符记数和缓冲区长度被巧妙隐藏。
除非你做一些特殊的操作，否则你不可能知道给CString 对象分
配的缓冲区的长度。这样，即使你获得了该0 缓冲的地址，你也无法
更改其中的内容，不能截短字符串，也绝对没有办法加长它的内容，
否则第一时间就会看到溢出。
LPCTSTR 操作符（或者更明确地说就是 TCHAR *操作符）在 CString
类中被重载了，该操作符的定义是返回缓冲区的地址，因此，如果你
需要一个指向 CString的字符串指针的话，可以这样做：
CString s("GrayCat");
LPCTSTR p = s;
它可以正确地运行。这是由C 语言的强制类型转化规则实现的。
当需要强制类型转化时，C++ 规测容许这种选择。比如，你可以将
（浮点数）定义为将某个复数（有一对浮点数）进行强制类型转换后
只返回该复数的第一个浮点数（也就是其实部）。可以象下面这样：
Complex c(1.2f, 4.8f);
float realpart = c;
如果(float) 操作符定义正确的话，那么实部的的值应该是1.2 。
这种强制转化适合所有这种情况，例如，任何带有 LPCTSTR类型
参数的函数都会强制执行这种转换。于是，你可能有这样一个函数
（也许在某个你买来的DLL 中）：
BOOL DoSomethingCool(LPCTSTR s);
你象下面这样调用它：
CString file("c:\\myfiles\\coolstuff")
BOOL result = DoSomethingCool(file);
它能正确运行。因为 DoSomethingCool函数已经说明了需要一个
LPCTSTR 类型的参数，因此 LPCTSTR被应用于该参数，在 MFC中就是
返回的串地址。
如果你要格式化字符串怎么办呢？
CString graycat("GrayCat");
CString s;
s.Format("Mew! I love %s", graycat);
注意由于在可变参数列
表中的值（在函数说明中是以“... ”表示的）并没有隐含一个
强制类型转换操作符。你会得到什么结果呢？
一个令人惊讶的结果，我们得到的实际结果串是：
"Mew! I love GrayCat" 。
因为 MFC的设计者们在设计 CString数据类型时非常小心， CString
类型表达式求值后指向了字符串，所以这里看不到任何象 Format 或
sprintf 中的强制类型转换，你仍然可以得到正确的行为。描述 CString
的附加数据实际上在 CString名义地址之后。
有一件事情你是不能做的，那就是修改字符串。比如，你可能会
尝试用“, ”代替“. ”（不要做这样的，如果你在乎国际化问题，
你应该使用十进制转换的 National Language Support特性，），下
面是个简单的例子：
CString v("1.00"); // 货币金额，两位小数
LPCTSTR p = v;
p[lstrlen(p) - 3] = '','';
这时编译器会报错，因为你赋值了一个常量串。如果你做如下尝
试，编译器也会错：
strcat(p, "each");
因为 strcat 的第一个参数应该是 LPTSTR 类型的数据，而你却
给了一个 LPCTSTR。
不要试图钻这个错误消息的牛角尖，这只会使你自己陷入麻烦！
原因是缓冲有一个计数，它是不可存取的（它位于 CString地址
之下的一个隐藏区域），如果你改变这个串，缓冲中的字符计数不会
反映所做的修改。此外，如果字符串长度恰好是该字符串物理限制的
长度（梢后还会讲到这个问题），那么扩展该字符串将改写缓冲以外
的任何数据，那是你无权进行写操作的内存（不对吗？），你会毁换
坏不属于你的内存。这是应用程序真正的死亡处方。
CString转化成char*之二：使用CString对象的GetBuffer方法；
如果你需要修改 CString中的内容，它有一个特殊的方法可以使
用，那就是 GetBuffer，它的作用是返回一个可写的缓冲指针。如果
你只是打算修改字符或者截短字符串，你完全可以这样做：
CString s(_T("File.ext"));
LPTSTR p = s.GetBuffer();
LPTSTR dot = strchr(p, ''.''); // OK, should have used s.Find...
if(p != NULL)
*p = _T(''\0'');
s.ReleaseBuffer();
这是 GetBuffer的第一种用法，也是最简单的一种，不用给它传
递参数，它使用默认值 0，意思是：“给我这个字符串的指针，我保
证不加长它”。当你调用 ReleaseBuffer时，字符串的实际长度会被
重新计算，然后存入 CString对象中。
必须强调一点，在 GetBuffer和 ReleaseBuffer之间这个范围，
一定不能使用你要操作的这个缓冲的 CString对象的任何方法。因为
ReleaseBuffer 被调用之前，该 CString对象的完整性得不到保障。
研究以下代码：
CString s(...);
LPTSTR p = s.GetBuffer();
//... 这个指针 p 发生了很多事情
int n = s.GetLength(); // 很糟D!!!!! 有可能给出错误的答案!!!
s.TrimRight(); // 很糟!!!!! 不能保证能正常工作!!!!
s.ReleaseBuffer(); // 现在应该 OK
int m = s.GetLength(); // 这个结果可以保证是正确的。
s.TrimRight(); // 将正常工作。
假设你想增加字符串的长度，你首先要知道这个字符串可能会有
多长，好比是声明字符串数组的时候用：
char buffer[1024];
表示 1024 个字符空间足以让你做任何想做得事情。在 CString
中与之意义相等的表示法：
LPTSTR p = s.GetBuffer(1024);
调用这个函数后，你不仅获得了字符串缓冲区的指针，而且同时
还获得了长度至少为 1024 个字符的空间（注意，我说的是“字符”，
而不是“字节”，因为 CString是以隐含方式感知 Unicode的）。
同时，还应该注意的是，如果你有一个常量串指针，这个串本身
的值被存储在只读内存中，如果试图存储它，即使你已经调用了 GetBuffer ，
并获得一个只读内存的指针，存入操作会失败，并报告存取错误。我
没有在 CString上证明这一点，但我看到过大把的 C程序员经常犯这
个错误。
C 程序员有一个通病是分配一个固定长度的缓冲，对它进行 sprintf
操作，然后将它赋值给一个 CString：
char buffer[256];
sprintf(buffer, "%......", args, ...); // ... 部分省略许多细节
CString s = buffer;
虽然更好的形式可以这么做：
CString s;
s.Format(_T("%...."), args, ...);
如果你的字符串长度万一
超过 256个字符的时候，不会破坏堆栈。
另外一个常见的错误是：既然固定大小的内存不工作，那么就采
用动态分配字节，这种做法弊端更大：
int len = lstrlen(parm1) + 13 lstrlen(parm2) + 10 + 100;
char * buffer = new char[len];
sprintf(buffer, "%s is equal to %s, valid data", parm1, parm2);
CString s = buffer;
......
delete [] buffer;
它可以能被简单地写成：
CString s;
s.Format(_T("%s is equal to %s, valid data"), parm1, parm2);
需要注意 sprintf例子都不是 Unicode就绪的，尽管你可以使用
tsprintf以及用 _T() 来包围格式化字符串，但是基本思路仍然是在
走弯路，这这样很容易出错。
CString to char * 之三：和控件的接口；
我们经常需要把一个 CString的值传递给一个控件，比如，CTreeCtrl。
MFC 为我们提供了很多便利来重载这个操作，但是在大多数情况下，
你使用“原始”形式的更新，因此需要将墨某个串指针存储到 TVINSERTITEMSTRUCT
结构的 TVITEM 成员中。如下：
TVINSERTITEMSTRUCT tvi;
CString s;
// ... 为s赋一些值。
tvi.item.pszText = s; // Compiler yells at you here
// ... 填写tvi的其他域
HTREEITEM ti = c_MyTree.InsertItem(&tvi);
为什么编译器会报错呢？明明看起来很完美的用法啊！但是事实
上如果你看看 TVITEM 结构的定义你就会明白，在 TVITEM 结构中 pszText
成员的声明如下：
LPTSTR pszText;
int cchTextMax;
因此，赋值不是赋给一个 LPCTSTR类型的变量，而且编译器无法
知道如何将赋值语句右边强制转换成 LPCTSTR。好吧，你说，那我就
改成这样：
tvi.item.pszText = (LPCTSTR)s; //编译器依然会报错。
编译器之所以依然报错是因为你试图把一个 LPCTSTR类型的变量
赋值给一个 LPTSTR 类型的变量，这种操作在C 或C++ 中是被禁止的。
你不能用这种方法来滥用常量指针与非常量指针概念，否则，会扰乱
编译器的优化机制，使之不知如何优化你的程序。比如，如果你这么
做：
const int i = ...;
//... do lots of stuff
... = a; // usage 1
// ... lots more stuff
... = a; // usage 2
那么，编译器会以为既然 i是 const，所以 usage1 和usage2的
值是相同的，并且它甚至能事先计算好 usage1 处的 a 的地址，
然后保留着在后面的 usage2 处使用，而不是重新计算。如果你按如
下方式写的话：
const int i = ...;
int * p = &i;
//... do lots of stuff
... = a; // usage 1
// ... lots more stuff
(*p)++; // mess over compiler''s assumption
// ... and other stuff
... = a; // usage 2
编译器将认为 i是常量，从而 a 的位置也是常量，这样间接
地破坏了先前的假设。因此，你的程序将会在 debug编译模式（没有
优化）和 release编译模式（完全优化）中反映出不同的行为，这种
情况可不好，所以当你试图把指向 i的指针赋值给一个可修改的引用
时，会被编译器诊断为这是一种伪造。这就是为什么（LPCTSTR ）强
制类型转化不起作用的原因。
为什么不把该成员声明成 LPCTSTR类型呢？因为这个结构被用于
读写控件。当你向控件写数据时，文本指针实际上被当成 LPCTSTR，
而当你从控件读数据时，你必须有一个可写的字符串。这个结构无法
区分它是用来读还是用来写。
因此，你会常常在我的代码中看到如下的用法：
tvi.item.pszText = (LPTSTR)(LPCTSTR)s;
它把 CString强制类型转化成 LPCTSTR，也就是说先获得改字符
串的地址，然后再强制类型转化成 LPTSTR ，以便可以对之进行赋值
操作。注意这只有在使用 Set或 Insert 之类的方法才有效！如果你
试图获取数据，则不能这么做。
如果你打算获取存储在控件中的数据，则方法稍有不同，例如，
对某个 CTreeCtrl使用 GetItem方法，我想获取项目的文本。我知道
这些文本的长度不会超过 MY_LIMIT ，因此我可以这样写：
TVITEM tvi;
// ... assorted initialization of other fields of tvi
tvi.pszText = s.GetBuffer(MY_LIMIT);
tvi.cchTextMax = MY_LIMIT;
c_MyTree.GetItem(&tvi);
s.ReleaseBuffer();
可以看出来，其实上面的代码对所有类型的 Set方法都适用，但
是并不需要这么做，因为所有的类 Set方法（包括 Insert 方法）不
会改变字符串的内容。但是当你需要写 CString对象时，必须保证缓
冲是可写的，这正是 GetBuffer所做的事情。再次强调：一旦做了一
次 GetBuffer调用，那么在调用 ReleaseBuffer之前不要对这个 CString
对象做任何操作。
5、CString型转化成BSTR型
当我们使用 ActiveX控件编程时，经常需要用到将某个值表示成
BSTR类型。BSTR是一种记数字符串，Intel 平台上的宽字符串（Unicode
），并且 可以包含嵌入的 NULL 字符。
你可以调用CString对象的AllocSysString方法将CString转化成BSTR：
CString s;
s = ... ; // whatever
BSTR b = s.AllocSysString();
现在指针 b指向的就是一个新分配的 BSTR 对象，该对象是 CString
的一个拷贝，包含终结 NULL 字符。现在你可以将它传递给任何需要
BSTR的接口。通常，BSTR由接收它的组件来释放，如果你需要自己释
放 BSTR 的话，可以这么做：
::SysFreeString(b);
对于如何表示传递给 ActiveX控件的字符串，在微软内部曾一度
争论不休，最后 Visual Basic 的人占了上风，BSTR（“Basic String”
的首字母缩写）就是这场争论的结果。
6、BSTR 型转化成 CString 型
由于 BSTR 是记数 Unicode字符串，你可以用标准转换方法来创
建 8位的 CString。实际上，这是 CString内建的功能。在 CString
中有特殊的构造函数可以把 ANSI 转化成 Unicode，也可以把Unicode
转化成 ANSI 。你同样可以从 VARIANT类型的变量中获得 BSTR 类型
的字符串，VARIANT 类型是由各种 COM和 Automation ( 自动化) 调
用返回的类型。
例如，在一个ANSI程序中：
BSTR b;
b = ...; // whatever
CString s(b == NULL ? L"" : b)
对于单个的 BSTR 串来说，这种用法可以工作得很好，这是因为
CString 有一个特殊的构造函数以LPCWSTR （BSTR正是这种类型）为
参数，并将它转化成 ANSI 类型。专门检查是必须的，因为 BSTR 可
能为空值，而 CString的构造函数对于 NULL 值情况考虑的不是很周
到，（感谢 Brian Ross 指出这一点! ）。这种用法也只能处理包含
NUL 终结字符的单字符串；如果要转化含有多个 NULL 字符串，你得
额外做一些工作才行。在 CString中内嵌的 NULL 字符通常表现不尽
如人意，应该尽量避免。
根据 C/C++规则，如果你有一个 LPWSTR ，那么它别无选择，只
能和 LPCWSTR参数匹配。
在 Unicode 模式下，它的构造函数是：
CString::CString(LPCTSTR);
正如上面所表示的，在 ANSI 模式下，它有一个特殊的构造函数：
CString::CString(LPCWSTR);
它会调用一个内部的函数将 Unicode字符串转换成 ANSI 字符串。
（在Unicode 模式下，有一个专门的构造函数，该函数有一个参数是
LPCSTR类型——一个8 位 ANSI 字符串指针，该函数将它加宽为 Unicode
的字符串！）再次强调：一定要检查 BSTR 的值是否为 NULL 。
另外还有一个问题，正如上文提到的：BSTRs 可以含有多个内嵌
的NULL字符，但是 CString的构造函数只能处理某个串中单个 NULL
字符。也就是说，如果串中含有嵌入的 NUL字节，CString 将会计算
出错误的串长度。你必须自己处理它。如果你看看 strcore.cpp中的
构造函数，你会发现它们都调用了lstrlen ，也就是计算字符串的长
度。
注意从 Unicode到 ANSI 的转换使用带专门参数的 ::WideCharToMultiByte，
如果你不想使用这种默认的转换方式，则必须编写自己的转化代码。
如果你在 UNICODE模式下编译代码，你可以简单地写成：
CString convert(BSTR b)
{
if(b == NULL)
return CString(_T(""));
CString s(b); // in UNICODE mode
return s;
}
如果是 ANSI 模式，则需要更复杂的过程来转换。注意这个代码
使用与 ::WideCharToMultiByte相同的参数值。所以你只能在想要改
变这些参数进行转换时使用该技术。例如，指定不同的默认字符，不
同的标志集等。 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;
}
我并不担心如果 BSTR 包含没有映射到 8位字符集的 Unicode字
符时会发生什么，因为我指定了::WideCharToMultiByte 的最后两个
参数为 NULL 。这就是你可能需要改变的地方。
|
|
发表于 2004-10-13 21:23:00