CString 操作指南

这篇文章包括以下内容：

1. CString 对象的连接

2. 格式化字符串（包括 int 型转化为 CString ）
3. CString 型转化成 int 型
4. CString 型和 char* 类型的相互转化
   
   char* 转化成 CString
   CString 转化成 char* 之一：使用LPCTSTR强制转化
   CString 转化成 char* 之二：使用CString对象的GetBuffer方法
   CString 转化成 char* 之三: 和控件的接口
5. CString 型转化成 BSTR 型；
6. BSTR 型转化成 CString 型；
7. VARIANT 型转化成 CString 型；
8. 载入字符串表资源；
9. CString 和临时对象；
10. CString 的效率；
11. 总结

下面我分别讨论。

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(); // 现在应该 OKint 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[i]; // usage 1// ... lots more stuff... = a[i]; // usage 2

　　那么，编译器会以为既然 i 是 const ，所以 usage1和usage2的值是相同的，并且它甚至能事先计算好 usage1 处的 a[i] 的地址，然后保留着在后面的 usage2 处使用，而不是重新计算。如果你按如下方式写的话：

const int i = ...;int * p = &i;//... do lots of stuff... = a[i]; // usage 1// ... lots more stuff(*p)++; // mess over compiler''s assumption// ... and other stuff... = a[i]; // usage 2

　　编译器将认为 i 是常量，从而 a[i] 的位置也是常量，这样间接地破坏了先前的假设。因此，你的程序将会在 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 tvitvi.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 = ... ; // whateverBSTR 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 = ...; // whateverCString 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。这就是你可能需要改变的地方。

7、 VARIANT 型转化成 CString 型

　　事实上，我从来没有这么做过，因为我没有用 COM/OLE/ActiveX 编写过程序。但是我在microsoft.public.vc.mfc 新闻组上看到了 Robert Quirk 的一篇帖子谈到了这种转化，我觉得把他的文章包含在我的文章里是不太好的做法，所以在这里多做一些解释和演示。如果和他的文章有相孛的地方可能是我的疏忽。
　　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 */}

8、 载入字符串表资源

　　如果你想创建一个容易进行语言版本移植的应用程序，你就不能在你的源代码中直接包含本土语言字符串 （下面这些例子我用的语言都是英语，因为我的本土语是英语），比如下面这种写法就很糟：

CString s = "There is an error";

　　你应该把你所有特定语言的字符串单独摆放（调试信息、在发布版本中不出现的信息除外）。这意味着向下面这样写比较好：

s.Format(_T("%d - %s"), code, text);

　　在你的程序中，文字字符串不是语言敏感的。不管怎样，你必须很小心，不要使用下面这样的串：

// fmt is "Error in %s file %s"// readorwrite is "reading" or "writing"s.Format(fmt, readorwrite, filename); 

　　这是我的切身体会。在我的第一个国际化的应用程序中我犯了这个错误，尽管我懂德语，知道在德语的语法中动词放在句子的最后面，我们的德国方面的发行人还是苦苦的抱怨他们不得不提取那些不可思议的德语错误提示信息然后重新格式化以让它们能正常工作。比较好的办法（也是我现在使用的办法）是使用两个字符串，一个用 于读，一个用于写，在使用时加载合适的版本，使得它们对字符串参数是非敏感的。也就是说加载整个格式，而不是加载串“reading”，“writing”：

// fmt is "Error in reading file %s"// "Error in writing file %s"s.Format(fmt, filename);

　　一定要注意，如果你有好几个地方需要替换，你一定要保证替换后句子的结构不会出现问题，比如在英语中，可以是主语-宾语，主语-谓语，动词-宾语的结构等等。
　　在这里，我们并不讨论 FormatMessage，其实它比 sprintf/Format 还要有优势，但是不太容易和CString 结合使用。解决这种问题的办法就是我们按照参数出现在参数表中的位置给参数取名字，这样在你输出的时候就不会把他们的位置排错了。
　　接下来我们讨论我们这些独立的字符串放在什么地方。我们可以把字符串的值放入资源文件中的一个称为 STRINGTABLE 的段中。过程如下：首先使用 Visual Studio 的资源编辑器创建一个字符串，然后给每一个字符串取一个ID，一般我们给它取名字都以 IDS_开头。所以如果你有一个信息，你可以创建一个字符串资源然后取名为 IDS_READING_FILE，另外一个就取名为 IDS_WRITING_FILE。它们以下面的形式出现在你的 .rc 文件中：

STRINGTABLEIDS_READING_FILE "Reading file %s"IDS_WRITING_FILE "Writing file %s"END

注意：这些资源都以 Unicode 的格式保存，不管你是在什么环境下编译。他们在Win9x系统上也是以Unicode 的形式存在，虽然 Win9x 不能真正处理 Unicode。
然后你可以这样使用这些资源：
// 在使用资源串表之前，程序是这样写的：

   CString fmt;      if(...)        fmt = "Reading file %s";     else       fmt = "Writing file %s";  ...    // much later  CString s;  s.Format(fmt, filename); 

// 使用资源串表之后，程序这样写：

    CString fmt;        if(...)           fmt.LoadString(IDS_READING_FILE);        else           fmt.LoadString(DS_WRITING_FILE);    ...      // much later    CString s;    s.Format(fmt, filename);

　　现在，你的代码可以移植到任何语言中去。LoadString 方法需要一个字符串资源的 ID 作为参数，然后它从 STRINGTABLE 中取出它对应的字符串，赋值给 CString 对象。 CString 对象的构造函数还有一个更加聪明的特征可以简化 STRINGTABLE 的使用。这个用法在 CString::CString 的文档中没有指出，但是在 构造函数的示例程序中使用了。（为什么这个特性没有成为正式文档的一部分，而是放在了一个例子中，我记不得了！）——【 译者注：从这句话看，作者可能是CString的设计者。其实前面还有一句类似的话。说他没有对使用GetBuffer(0)获得的指针指向的地址是否可读做有效性检查 】。这个特征就是：如果你将一个字符串资源的ID强制类型转换为 LPCTSTR，将会隐含调用 LoadString。因此，下面两个构造字符串的例子具有相同的效果，而且其 ASSERT 在debug模式下不会被触发：

CString s;s.LoadString(IDS_WHATEVER);CString t( (LPCTSTR)IDS_WHATEVER );ASSERT(s == t);//不会被触发，说明s和t是相同的。

　　现在，你可能会想：这怎么可能工作呢？我们怎么能把 STRINGTABLE ID 转化成一个指针呢？很简单：所有的字符串 ID 都在1~65535这个范围内，也就是说，它所有的高位都是0，而我们在程序中所使用的指针是不可能小于65535的，因为程序的低 64K 内存永远也不可能存在的，如果你试图访问0x00000000到0x0000FFFF之间的内存，将会引发一个内存越界错误。所以说1~65535的值不可能是一个内存地址，所以我们可以用这些值来作为字符串资源的ID。
　　我倾向于使用 MAKEINTRESOURCE 宏显式地做这种转换。我认为这样可以让代码更加易于阅读。这是个只适合在 MFC 中使用的标准宏。你要记住，大多数的方法即可以接受一个 UINT 型的参数，也可以接受一个 LPCTSTR 型的参数，这是依赖 C++ 的重载功能做到的。C++重载函数带来的 弊端就是造成所有的强制类型转化都需要显示声明。同样，你也可以给很多种结构只传递一个资源名。

CString s;s.LoadString(IDS_WHATEVER);CString t( MAKEINTRESOURCE(IDS_WHATEVER));ASSERT(s == t);

　　告诉你吧：我不仅只是在这里鼓吹，事实上我也是这么做的。在我的代码中，你几乎不可能找到一个字符串，当然，那些只是偶然在调试中出现的或者和语言无关的字符串除外。

9、CString 和临时对象

　　这是出现在 microsoft.public.vc.mfc 新闻组中的一个小问题，我简单的提一下，这个问题是有个程序员需要往注册表中写入一个字符串，他写道：
　　我试着用 RegSetValueEx() 设置一个注册表键的值，但是它的结果总是令我困惑。当我用char[]声明一个变量时它能正常工作，但是当我用 CString 的时候，总是得到一些垃圾："ÝÝÝÝ...ÝÝÝÝÝÝ"为了确认是不是我的 CString 数据出了问题，我试着用 GetBuffer，然后强制转化成 char*，LPCSTR。GetBuffer 返回的值是正确的，但是当我把它赋值给 char* 时，它就变成垃圾了。以下是我的程序段：

char* szName = GetName().GetBuffer(20);RegSetValueEx(hKey, "Name", 0, REG_SZ,              (CONST BYTE *) szName,             strlen (szName + 1));

这个 Name 字符串的长度小于 20，所以我不认为是 GetBuffer 的参数的问题。

真让人困惑，请帮帮我。

亲爱的 Frustrated，

你犯了一个相当微妙的错误，聪明反被聪明误，正确的代码应该象下面这样：

CString Name = GetName();RegSetValueEx(hKey, _T("Name"), 0, REG_SZ,                     (CONST BYTE *) (LPCTSTR)Name,                    (Name.GetLength() + 1) * sizeof(TCHAR));

　　为什么我写的代码能行而你写的就有问题呢？主要是因为当你调用 GetName 时返回的 CString 对象是一个临时对象。参见：《C++ Reference manual》§12.2
　　在一些环境中，编译器有必要创建一个临时对象，这样引入临时对象是依赖于实现的。如果编译器引入的这个临时对象所属的类有构造函数的话，编译器要确保这个类的构造函数被调用。同样的，如果这个类声明有析构函数的话，也要保证这个临时对象的析构函数被调用。
　　编译器必须保证这个临时对象被销毁了。被销毁的确切地点依赖于实现.....这个析构函数必须在退出创建该临时对象的范围之前被调用。
　　大部分的编译器是这样设计的：在临时对象被创建的代码的下一个执行步骤处隐含调用这个临时对象的析构函数，实现起来，一般都是在下一个分号处。因此，这个 CString 对象在 GetBuffer 调用之后就被析构了（顺便提一句，你没有理由给 GetBuffer 函数传递一个参数，而且没有使用ReleaseBuffer 也是不对的）。所以 GetBuffer 本来返回的是指向这个临时对象中字符串的地址的指针，但是当这个临时对象被析构后，这块内存就被释放了。然后 MFC 的调试内存分配器会重新为这块内存全部填上 0xDD，显示出来刚好就是“Ý”符号。在这个时候你向注册表中写数据，字符串的内容当然全被破坏了。
　　我们不应该立即把这个临时对象转化成 char* 类型，应该先把它保存到一个 CString 对象中，这意味着把临时对象复制了一份，所以当临时的 CString 对象被析构了之后，这个 CString 对象中的值依然保存着。这个时候再向注册表中写数据就没有问题了。
　　此外，我的代码是具有 Unicode 意识的。那个操作注册表的函数需要一个字节大小，使用lstrlen(Name+1) 得到的实际结果对于 Unicode 字符来说比 ANSI 字符要小一半，而且它也不能从这个字符串的第二个字符起开始计算，也许你的本意是 lstrlen(Name) + 1（OK，我承认，我也犯了同样的错误！）。不论如何，在 Unicode 模式下，所有的字符都是2个字节大小，我们需要处理这个问题。微软的文档令人惊讶地对此保持缄默：REG_SZ 的值究竟是以字节计算还是以字符计算呢？我们假设它指的是以字节为单位计算，你需要对你的代码做一些修改来计算这个字符串所含有的字节大小。

10、 CString 的效率

　　CString 的一个问题是它确实掩藏了一些低效率的东西。从另外一个方面讲，它也确实可以被实现得更加高效，你可能会说下面的代码：

CString s = SomeCString1;s += SomeCString2;s += SomeCString3;s += ",";s += SomeCString4;

比起下面的代码来，效率要低多了：

char s[1024];lstrcpy(s, SomeString1);lstrcat(s, SomeString2);lstrcat(s, SomeString 3);lstrcat(s, ",");lstrcat(s, SomeString4);

　　总之，你可能会想，首先，它为 SomeCString1 分配一块内存，然后把 SomeCString1 复制到里面，然后发现它要做一个连接，则重新分配一块新的足够大的内存，大到能够放下当前的字符串加上SomeCString2，把内容复制到这块内存 ，然后把 SomeCString2 连接到后面，然后释放第一块内存，并把指针重新指向新内存。然后为每个字符串重复这个过程。把这 4 个字符串连接起来效率多低啊。事实上，在很多情况下根本就不需要复制源字符串（在 += 操作符左边的字符串）。
　　在 VC++6.0 中，Release 模式下，所有的 CString 中的缓存都是按预定义量子分配的。所谓量子，即确定为 64、128、256 或者 512 字节。这意味着除非字符串非常长，连接字符串的操作实际上就是 strcat 经过优化后的版本（因为它知道本地的字符串应该在什么地方结束，所以不需要寻找字符串的结尾；只需要把内存中的数据拷贝到指定的地方即可）加上重新计算字符串的长度。所以它的执行效率和纯 C 的代码是一样的，但是它更容易写、更容易维护和更容易理解。
　　如果你还是不能确定究竟发生了怎样的过程，请看看 CString 的源代码，strcore.cpp，在你 vc98的安装目录的 mfc/src 子目录中。看看 ConcatInPlace 方法，它被在所有的 += 操作符中调用。

啊哈！难道 CString 真的这么"高效"吗？比如，如果我创建

CString cat("Mew!");

　　然后我并不是得到了一个高效的、精简的5个字节大小的缓冲区（4个字符加一个结束字符），系统将给我分配64个字节，而其中59个字节都被浪费了。
　　如果你也是这么想的话，那么就请准备好接受再教育吧。可能在某个地方某个人给你讲过尽量使用少的空间是件好事情。不错，这种说法的确正确，但是他忽略了事实中一个很重要的方面。
　　如果你编写的是运行在16K EPROMs下的嵌入式程序的话，你有理由尽量少使用空间，在这种环境下，它能使你的程序更健壮。但是在 500MHz, 256MB的机器上写 Windows 程序，如果你还是这么做，它只会比你认为的“低效”的代码运行得更糟。
　　举例来说。字符串的大小被认为是影响效率的首要因素，使字符串尽可能小可以提高效率，反之则降低效率，这是大家一贯的想法。但是这种想法是不对的，精确的内存分配的后果要在程序运行了好几个小时后才能体现得出来，那时，程序的堆中将充满小片的内存，它们太小以至于不能用来做任何事，但是他们增加了你程序的内存用量，增加了内存页面交换的次数，当页面交换的次数增加到系统能够忍受的上限，系统则会为你的程序分配更多的页面，直到你的程序占用了所有的可用内存。由此可见，虽然内存碎片是决定效率的次要因素，但正是这些因素实际控制了系统的行为，最终，它损害了系统的可靠性，这是令人无法接受的。
　　记住，在 debug 模式下，内存往往是精确分配的，这是为了更好的排错。
　　假设你的应用程序通常需要连续工作好几个月。比如，我常打开 VC++，Word，PowerPoint，Frontpage，Outlook Express，Forté Agent，Internet Explorer和其它的一些程序，而且通常不关闭它们。我曾经夜以继日地连续用 PowerPoint 工作了好几天（反之，如果你不幸不得不使用像 Adobe FrameMaker 这样的程序的话，你将会体会到可靠性的重要；这个程序机会每天都要崩溃4~6次，每次都是因为用完了所有的空间并填满我所有的交换页面）。所以精确内存分配是不可取的，它会危及到系统的可靠性，并引起应用程序崩溃。
　　按量子的倍数为字符串分配内存，内存分配器就可以回收用过的内存块，通常这些回收的内存块马上就可以被其它的 CString 对象重新用到，这样就可以保证碎片最少。分配器的功能加强了，应用程序用到的内存就能尽可能保持最小，这样的程序就可以运行几个星期或几个月而不出现问题。
　　题外话：很多年以前，我们在 CMU 写一个交互式系统的时候，一些对内存分配器的研究显示出它往往产生很多内存碎片。Jim Mitchell，现在他在 Sun Microsystems 工作，那时侯他创造了一种内存分配器，它保留了一个内存分配状况的运行时统计表，这种技术和当时的主流分配器所用的技术都不同，且较为领先。当一个内存块需要被分割得比某一个值小的话，他并不分割它，因此可以避免产生太多小到什么事都干不了的内存碎片。事实上他在内存分配器中使用了一个浮动指针，他认为：与其让指令做长时间的存取内存操作，还不如简单的忽略那些太小的内存块而只做一些浮动指针的操作。（His observation was that the long-term saving in instructions by not having to ignore unusable small storage chunks far and away exceeded the additional cost of doing a few floating point operations on an allocation operation.）他是对的。
　　永远不要认为所谓的“最优化”是建立在每一行代码都高速且节省内存的基础上的，事实上，高速且节省内存应该是在一个应用程序的整体水平上考虑的。在软件的整体水平上，只使用最小内存的字符串分配策略可能是最糟糕的一种方法。
　　如果你认为优化是你在每一行代码上做的那些努力的话，你应该想一想：在每一行代码中做的优化很少能真正起作用。你可以看我的另一篇关于优化问题的文章《Your Worst Enemy for some thought-provoking ideas》。
　　记住，+= 运算符只是一种特例，如果你写成下面这样：

CString s = SomeCString1 + SomeCString2 + SomeCString3 + "," + SomeCString4;

则每一个 + 的应用会造成一个新的字符串被创建和一次复制操作。

总结

　　以上是使用 CString 的一些技巧。我每天写程序的时候都会用到这些。CString 并不是一种很难使用的类，但是 MFC 没有很明显的指出这些特征，需要你自己去探索、去发现。

 

 

____________________________________________________________________________________________________________

string 转 CString 
CString.format("%s", string.c_str()); 

char 转 CString 
CString.format("%s", char*); 

char 转 string 
string s(char *); 

string 转 char * 
char *p = string.c_str(); 

CString 转 string 
string s(CString.GetBuffer()); 

1，string -> CString 
CString.format("%s", string.c_str()); 
用c_str()确实比data()要好. 
2，char -> string 
string s(char *); 
你的只能初始化，在不是初始化的地方最好还是用assign(). 
3,CString -> string 
string s(CString.GetBuffer()); 
GetBuffer()后一定要ReleaseBuffer(),否则就没有释放缓冲区所占的空间. 


《C++标准函数库》中说的 
有三个函数可以将字符串的内容转换为字符数组和C—string 
1.data(),返回没有”/0“的字符串数组 
2,c_str()，返回有”/0“的字符串数组 
3，copy() 

--------------------------------------------------------------- 

CString与int、char*、char[100]之间的转换- - 


CString与int、char*、char[100]之间的转换- - 



CString互转int 

将字符转换为整数，可以使用atoi、_atoi64或atol。 
而将数字转换为CString变量，可以使用CString的Format函数。如 
CString s; 
int i = 64; 
s.Format("%d", i) 
Format函数的功能很强，值得你研究一下。 

void CStrDlg::OnButton1() 
{ 
// TODO: Add your control notification handler code here 
CString 
ss="1212.12"; 
int temp=atoi(ss); 
CString aa; 
aa.Format("%d",temp); 
AfxMessageBox("var is " + aa); 
} 

sart.Format("%s",buf); 

CString互转char* 

///char * TO cstring 
CString strtest; 
char * charpoint; 
charpoint="give string a value"; 
strtest=charpoint; 


///cstring TO char * 
charpoint=strtest.GetBuffer(strtest.GetLength()); 

标准C里没有string,char *==char []==string 

可以用CString.Format("%s",char *)这个方法来将char *转成CString。要把CString转成char *，用操作符（LPCSTR）CString就可以了。 


CString转换 char[100] 

char a[100]; 
CString str("aaaaaa"); 
strncpy(a,(LPCTSTR)str,sizeof(a));

______________________________________________________________________________________

对有关数据类型转换的整理

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 <comdef.h>
  例如：
  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] = '/0';
  (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" )

后记：本文匆匆写成，错误之处在所难免，欢迎指正.

关于把BSTR类型数据转换成CString 类型数据时的问题?
当我在把BSTR类型数据转换成CString 或 “char* 类型”数据时，发现在BSTR类型字符串较短的情况下没问题，当较长时就会出现
内存读写错了。（在NT，2000下都测试是这样的。）
根据你所说：
1）字符串指针(char *)等已经被CString构造函数支持的数据类型 可以直接赋值 str = username;
2）当b 为BSTR类型时可以使用
char *p=_com_util::ConvertBSTRToString(b);
于是以下是对的：
CString cstr;
BSTR bstr;
....
cstr=com_util::ConvertBSTRToString(bstr);
...
可是当bstr非常大时（其实，较大时就会）就会出现内存读写错，不知何故。
此外我发现cstr=com_util::ConvertBSTRToString(bstr);
可以简化为 cstr=bstr; 但当bstr较大时同样出现这个问题。
请兄弟帮忙！急。谢谢！如何转化((list*)fileip.bian)->liang

关于把CString转化成LPCTSTR的问题 作者:jakiesun 发表日期:2001-9-5 20:08:48
我记的我以前写过这样一段代码
void function()
{
CString str,str1,str2;
function((char*)(LPCTSTR)str1);
str=str1;
...//调试道此发现str2的值随着str的改变而改变，请问能解释一下为什么，如有回答，请通知
wangshaohong@sohu.com,tx先

}

添加lib支持 作者:磨刀霍霍 发表日期:2001-9-10 11:32:12
如果不添加会产生错误，在setting中加入comsupp.lib或者直接#pragma comment( lib, "comsupp.lib" )
微软认为缺省的设置call convention如果不设置成__cdecl也会出现同样的错误。

1。int 转成cstring ？？

回复人：　caigzhi(caigzhi)　(2001-10-17 11:27:35) 得0分 
CString 的成员函数Format()

int a = 2131;
CString str;
str.Format("%d",a);

回复人：　tenchi(C与C++之间)　(2001-10-17 11:32:12) 得0分 
int i=2001;
char str[10];
_itoa(i,str,10);
CString szString=str; 
回复人：　fiolin(幽深的水)　(2001-10-17 11:45:40) 得0分 
他们两个的都可以！！ 

回复人：　sohucsdnvc(thanks)　(2001-10-17 13:24:17) 得0分 
那如何把double转成cstring 
回复人：　yihugang(小虎子)　(2001-10-17 13:29:15) 得6分 
int i = 2131;
char *c=new char[20];
CString str;
sprintf(c,'%d',i);
str=*c;


回复人：　Gu_c_h(Gu)　(2001-10-17 14:07:17) 得0分 
用 _gcvt 下面是 msdn 的例子

Example

/* _GCVT.C: This program converts -3.1415e5
* to its string representation.
*/

#include <stdlib.h>
#include <stdio.h>

void main( void )
{
char buffer[50];
double source = -3.1415e5;
_gcvt( source, 7, buffer );
printf( "source: %f buffer: '%s'/n", source, buffer );
_gcvt( source, 7, buffer );
printf( "source: %e buffer: '%s'/n", source, buffer );
}


Output

source: -314150.000000 buffer: '-314150.'
source: -3.141500e+005 buffer: '-314150.'

回复人：　Gu_c_h(Gu)　(2001-10-17 14:49:56) 得6分 
int a = -3.1415e5;
CString str;
str.Format("%f",a); 
回复人：　ruixp(锐剑)　(2001-10-17 15:06:48) 得6分 
CString 的成员函数Format()
int a = 2131;
CString str;
str.Format("%d",a);

2。基类对象怎么能转换成派生类对象？
int CDaoListView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
lpCreateStruct->style |= LVS_REPORT |LVS_EDITLABELS;
if (CListView::OnCreate(lpCreateStruct) == -1)
return -1;

创建ImageList;
CDaoViewApp * pApp = (CDaoViewApp *) AfxGetApp();

m_pImageList = new CImageList();
ASSERT(m_pImageList !=NULL);
m_pImageList->Create(16,16,TRUE,4,4);
m_pImageList->Add(pApp->LoadIcon(IDI_KEY));
m_pImageList->Add(pApp->LoadIcon(IDI_ICON4));
m_pImageList->Add(pApp->LoadIcon(IDI_ICON5));

CListCtrlEx& ctlList = (CListCtrlEx&) GetListCtrl();//我不懂的就这句，cListCtrlEx看下面的声明。
ctlList.SetImageList (m_pImageList, LVSIL_SMALL) ;

return 0;
}

class CListCtrlEx : public CListCtrl//类cListCtrlEx定义。
{.....
}
class CDaoListView : public CListView//cDaoListView定义！
{
...
}
注：我的问题是GetListCtrl()返回的是一个cListCtrl对象的引用,怎么能把它转换成一个它的派生类对象的引用？c++的类型转换怎么支持？ 


回复贴子： 
回复人：　lhj(努力加油)　(2002-1-29 18:56:06) 得0分 
CListCtrlEx& ctlList = (CListCtrlEx&) GetListCtrl();
这是强制类型转换，&表示是一个引用，lctList的值在这次赋值后不能被修改。

回复人：　wwwsq(wwwsq)　(2002-1-29 19:09:22) 得0分 
建议你找本C++方面的书看看，VC虽然号称可视，实际上C++基础还是很重要的。


回复人：　xcopy(xcopy)　(2002-1-29 19:26:16) 得0分 
用dynamic_cast()可以安全的转换。 

3。如何在CString和double之间转换？要求转换之后能保留小数点，保留正负号？？

cstring::format(%.xe) x为精度位 

回复人：　pchaos(杂讲)　(2002-1-28 11:21:46) 得0分 
CString str;
double db;
str = "123.456";
db = atof((LPCTSTR)str); 
回复人：　hgw111(hg)　(2002-1-28 11:52:57) 得0分 
CString -> double : atof
double ->CString :Format 
回复人：　pchaos(杂讲)　(2002-1-28 13:46:04) 得0分 
CString str;
double db;
str = "123.456";
db = atof((LPCTSTR)str); 
db = 777.999;
str.format("%e", db); 

4。字符型要转换成int？？
atoi(str) 

5。_bstr_t 到 unsigned int？？
_bstr_t str;
unsigned int Length=6;
Length=Length-str.length(); 

6。VARIANT类型转换问题？
我在使用MSCOMM中SetOutput()函数时
形参必须为VARIANT变量
如何将其它的数据类型转换为VARIANT类型？
如：Cstring->VARIANT、 *char->VARIANT
我对VARIANT的类型结构体不太熟，请讲详细些（最好有范例），谢谢！

回复贴子： 
回复人：　vc_xiaoxin(小新)　(2001-12-26 15:43:57) 得0分 
VARIANT本身是一个复杂的结构，别的数据怎么转呀？关注 
回复人：　mpg_liu(星仁)　(2001-12-27 18:33:50) 得10分 
定义一个VARIANT变量后，他应该是一个结构体变量，其中有一个成员是字符型的，给这个成员赋值 
回复人：　LLnju(LLnju)　(2001-12-27 18:36:10) 得0分 
实在不清楚嘛就用 _variant_t , COleVariant 这些东东嘛，很好用的啊 
回复人：　softarts(CDMA2000)　(2001-12-27 18:41:32) 得10分 
构造一个就行了。
VARIANT varXX;
CString strYY;
varXX.vt=VT_BSTR;
varXX.bstrVal = strYY.allocsysstring();
应该可以了。
回复人：　softarts(CDMA2000)　(2001-12-27 18:42:11) 得0分 
我也觉得COleVariant要好用一些，呵呵，我都用它。 
回复人：　bobofu(有问题要问)　(2001-12-27 19:32:18) 得10分 
CString str;
_variant_t var;
var = _variant_t(str); 

7。COleVarant 如何转换为 CString?
CString 如何转换为 char *
CString 如何转换为 char[xx] ？？

CString 如何转换为 char * wsprintf或者＝
CString 如何转换为 char[xx] strcpy（） 
回复人：　SecretGarden(天堂鸟)　(2002-1-14 11:55:23) 得0分 
COleVarant封装了VAREANT类型。
VAREANT类型其实是个巨大地Union，里面自然有你
想要地unsigned char *类型。
CString地GetBuffer和Format可以实现你的后两个问题


8。v_variant_t类型转换成cstring
总提示我cstring未定义
程序如下
_variant_t vfirstname;//存储的是数据库中的数据
CString str;//提示出错
vfirstname=pRs->GetCollect (_variant_t("Phone_Num"));
vfirstname.ChangeType (VT_BSTR);
str=vfirstname.bstrVal;//提示出错 


回复贴子： 
回复人：　hydnoahark(诺亚方舟)　(2001-11-12 11:56:51) 得10分 
>>CString str;//提示出错
要求include <afx.h>并且设置Use run-time Library为Multithreaded 
回复人：　zhengyun_ustc(^-^)　(2001-11-12 12:04:39) 得15分 
CString未定义，说明你的工程没有引用MFC！！

要想使你的工程支持MFC，请按照以下步骤作：
1：在你的stdafx.h的头文件中加入：
#include "afxtempl.h"
这是一个囊括了MFC的集合定义的头文件，有了它，你的工程就识别Cstring类了。

2：在你的工程设置中，在General页中，选择“MFC”为“Using MFC in a shared DLL”

OK，现在再编译你的工程即可。 
回复人：　zhengyun_ustc(^-^)　(2001-11-12 12:06:56) 得5分 
_variant_t的bstrVal成员是BSTR类型。
它是一个指向一个OLECHART*的指针。 
回复人：　vickowang(小苍)　(2001-11-12 12:48:21) 得5分 
(char *)_bstr_t(vfirstname) 
回复人：　smallfool(smallfool)　(2001-11-12 13:52:54) 得4分 
或许你还需要一个从UNICODE字符到ANSI字符的转变函数 
回复人：　sun_1112(萧)　(2001-11-12 17:34:44) 得0分 
谢谢大家
给我这么大的支持！：） 
回复人：　zhengyun_ustc(^-^)　(2001-11-14 13:24:07) 得0分 
用vickowang(小苍)的意见可能会有问题，转换出的字符串应该是乱码。

因为(char *)转换需要一个const的字符串资源，才能强制转换。
所以应该：
_bstr_t bstrTemp = _bstr_t(vfirstname.bstrVal);
TCHAR szTemp[MAX_PATH];
szTemp = (char*)bstrTemp;

9。char * 转换为TCHAR类型？？
直接转换,TCHAR相当于char了
char * s;
TCHAR * s1=(TCHAR *)s; 
回复人：　dysxq()　(2001-12-21 21:26:25) 得0分 
要看你的程序设置是ANSI还是UNICODE, 如果是ANSI,直接转,如果是UNICODE,TCHAR相当于WCHAR, 要用mbstowcsz转一下 
回复人：　xiaoxiaohan(萧晓寒)　(2001-12-21 23:52:17) 得0分 
Unicode ：宽字节字符集
1. 如何取得一个既包含单字节字符又包含双字节字符的字符串的字符个数？
可以调用Microsoft Visual C++的运行期库包含函数_mbslen来操作多字节（既包括单字节也包括双字节）字符串。
调用strlen函数，无法真正了解字符串中究竟有多少字符，它只能告诉你到达结尾的0之前有多少个字节。
2. 如何对DBCS（双字节字符集）字符串进行操作？
函数 描述
PTSTR CharNext （ LPCTSTR ）; 返回字符串中下一个字符的地址
PTSTR CharPrev （ LPCTSTR, LPCTSTR ）； 返回字符串中上一个字符的地址
BOOL IsDBCSLeadByte( BYTE )； 如果该字节是DBCS字符的第一个字节，则返回非0值
3. 为什么要使用Unicode？
（1） 可以很容易地在不同语言之间进行数据交换。
（2） 使你能够分配支持所有语言的单个二进制.exe文件或DLL文件。
（3） 提高应用程序的运行效率。
Windows 2000是使用Unicode从头进行开发的，如果调用任何一个Windows函数并给它传递一个ANSI字符串，那么系统首先要将字符串转换成
Unicode，然后将Unicode字符串传递给操作系统。如果希望函数返回ANSI字符串，系统就会首先将Unicode字符串转换成ANSI字符串，然后将结
果返回给你的应用程序。进行这些字符串的转换需要占用系统的时间和内存。通过从头开始用Unicode来开发应用程序，就能够使你的应用程序
更加有效地运行。
Windows CE 本身就是使用Unicode的一种操作系统，完全不支持ANSI Windows函数
Windows 98 只支持ANSI，只能为ANSI开发应用程序。
Microsoft公司将COM从16位Windows转换成Win32时，公司决定需要字符串的所有COM接口方法都只能接受Unicode字符串。
4. 如何编写Unicode源代码？
Microsoft公司为Unicode设计了WindowsAPI，这样，可以尽量减少代码的影响。实际上，可以编写单个源代码文件，以便使用或者不使用
Unicode来对它进行编译。只需要定义两个宏（UNICODE和_UNICODE），就可以修改然后重新编译该源文件。
_UNICODE宏用于C运行期头文件，而UNICODE宏则用于Windows头文件。当编译源代码模块时，通常必须同时定义这两个宏。
5. Windows定义的Unicode数据类型有哪些？
数据类型 说明
WCHAR Unicode字符
PWSTR 指向Unicode字符串的指针
PCWSTR 指向一个恒定的Unicode字符串的指针
对应的ANSI数据类型为CHAR，LPSTR和LPCSTR。
ANSI/Unicode通用数据类型为TCHAR，PTSTR,LPCTSTR。
6. 如何对Unicode进行操作？
字符集 特性 实例
ANSI 操作函数以str开头 strcpy
Unicode 操作函数以wcs开头 wcscpy
MBCS 操作函数以_mbs开头 _mbscpy
ANSI/Unicode 操作函数以_tcs开头 _tcscpy（C运行期库）
ANSI/Unicode 操作函数以lstr开头 lstrcpy（Windows函数）
所有新的和未过时的函数在Windows2000中都同时拥有ANSI和Unicode两个版本。ANSI版本函数结尾以A表示；Unicode版本函数结尾以W表示。
Windows会如下定义：
#ifdef UNICODE
#define CreateWindowEx CreateWindowExW
#else
#define CreateWindowEx CreateWindowExA
#endif // !UNICODE
7. 如何表示Unicode字符串常量？
字符集 实例
ANSI “string”
Unicode L“string”
ANSI/Unicode T(“string”)或_TEXT(“string”)if( szError[0] == _TEXT(‘J’) ){ }
8. 为什么应当尽量使用操作系统函数？
这将有助于稍稍提高应用程序的运行性能，因为操作系统字符串函数常常被大型应用程序比如操作系统的外壳进程Explorer.exe所使用。由于
这些函数使用得很多，因此，在应用程序运行时，它们可能已经被装入RAM。
如：StrCat，StrChr，StrCmp和StrCpy等。
9. 如何编写符合ANSI和Unicode的应用程序？
（1） 将文本串视为字符数组，而不是chars数组或字节数组。
（2） 将通用数据类型（如TCHAR和PTSTR）用于文本字符和字符串。
（3） 将显式数据类型（如BYTE和PBYTE）用于字节、字节指针和数据缓存。
（4） 将TEXT宏用于原义字符和字符串。
（5） 执行全局性替换（例如用PTSTR替换PSTR）。
（6） 修改字符串运算问题。例如函数通常希望在字符中传递一个缓存的大小，而不是字节。这意味着不应该传递sizeof(szBuffer),而应该传
递（sizeof(szBuffer)/sizeof(TCHAR)。另外，如果需要为字符串分配一个内存块，并且拥有该字符串中的字符数目，那么请记住要按字节来
分配内存。这就是说，应该调用malloc(nCharacters *sizeof(TCHAR)),而不是调用malloc(nCharacters)。
10. 如何对字符串进行有选择的比较？
通过调用CompareString来实现。
标志 含义
NORM_IGNORECASE 忽略字母的大小写
NORM_IGNOREKANATYPE 不区分平假名与片假名字符
NORM_IGNORENONSPACE 忽略无间隔字符
NORM_IGNORESYMBOLS 忽略符号
NORM_IGNOREWIDTH 不区分单字节字符与作为双字节字符的同一个字符
SORT_STRINGSORT 将标点符号作为普通符号来处理
11. 如何判断一个文本文件是ANSI还是Unicode？
判断如果文本文件的开头两个字节是0xFF和0xFE，那么就是Unicode，否则是ANSI。
12. 如何判断一段字符串是ANSI还是Unicode？
用IsTextUnicode进行判断。IsTextUnicode使用一系列统计方法和定性方法，以便猜测缓存的内容。由于这不是一种确切的科学方法，因此 
IsTextUnicode有可能返回不正确的结果。
13. 如何在Unicode与ANSI之间转换字符串？
Windows函数MultiByteToWideChar用于将多字节字符串转换成宽字符串；函数WideCharToMultiByte将宽字符串转换成等价的多字节字符串。

回复人：　xtky_limi(痛在心中笑在脸上)　(2001-12-22 0:35:58) 得0分 
上面说的已经比较全了。 
回复人：　xtky_limi(痛在心中笑在脸上)　(2001-12-22 0:38:13) 得0分 
TEXT是宏
相当于L##

它可以根据编译环境确定为DBMS,还是UNICODE字符集

10。int类型转换为CString类型？
回复人：　tjmxf(天涯)　(2001-12-17 19:59:34) 得0分 
itoa() 
回复人：　zf925(天下哪来那么多高手)　(2001-12-17 20:00:30) 得22分 
char m[20];
str=str + itoa(i,m,10); 
回复人：　yuezifeng(wybzd)　(2001-12-17 20:00:50) 得22分 
CString str;
str.Format("%d",i);

回复人：　kingfish(今飞)　(2001-12-17 20:06:27) 得0分 
str.Format("%s%d",str,i); 
回复人：　tanyajun(谈子)　(2001-12-17 20:09:25) 得0分 
CString str="test";
int i=11;
CString str1;
str1.Format("%d",i);
str = str+str1;

回复人：　guanjinke(纶巾客)　(2001-12-17 20:10:42) 得0分 
int i=11;
CString str="test";
CString addition;
addition.Format("%d",i);
str+=addition;
就可以了。 

11。关于sprintf类型转换的问题
sprintf(buf,"select price from ls01 where p_date>='%'",t_date)
其中t_date是CTime类型，%后面应该是什么呢？%s是String类型,%c是char,那么CTime型对应的是什么呢？ 
 
回复人：　yakai(日落长河)　(2001-12-17 17:45:47) 得0分 
sprintf(buf,"select price from ls01 where p_date>='%S'",(LPCSTR)t_date.Format( "%A, %B %d, %Y" ));
如果不行，就
char temp[50];
CString str=t_date.Format( "%A, %B %d, %Y" );
strcpy(temp,(LPCSTR)str);
sprintf(buf,"select price from ls01 where p_date>='%S'",temp);
CTime::Format返回CString 
回复人：　loh(乐啸天涯)　(2001-12-17 17:52:57) 得0分 
wait

don't know 
回复人：　masterz()　(2001-12-17 20:21:05) 得0分 
SQL语句中日期要写成字符串"yyyymmdd" 


12。类型转换 unsigned int <==>CString??
回复次数：8
发表时间：2001-12-17 10:25:23

unsigned int f;//unsigned int 0~4294967295
CString g;
f=2300000000;
g.Format("%d",f);
AfxMessageBox(g);
出错。 

回复人：　ydogg(灰毛兔频频)　(2001-12-17 10:31:29) 得0分 
unsigned int f;//unsigned int 0~4294967295
CString g;
f=2300000000;
g.Format("%d",f);
MessageBox(g);//使用AfxMessageBox，需要窗口的句炳参数

回复人：　asdmusic8(asdmusic8)　(2001-12-17 10:35:15) 得0分 
我 AfxMessageBox(g); 和MessageBox(g); 都不错。
错的是g.从 2300000000=》1994967296

回复人：　asdmusic8(asdmusic8)　(2001-12-17 10:36:10) 得0分 
是2300000000=》-1994967296 类型转换错。

回复人：　ydogg(灰毛兔频频)　(2001-12-17 10:37:54) 得6分 
g.Format("%u",f);

回复人：　asdmusic8(asdmusic8)　(2001-12-17 10:40:24) 得0分 
to dgsnmpoperate 那怎么从 CString ==>>unsigned int 
回复人：　kingfish(今飞)　(2001-12-17 10:42:10) 得6分 
既然是 unsigned int,
超过 0x7f000000 (2130706432) 当然不能用 %d (signed int)用%u 
回复人：　kingfish(今飞)　(2001-12-17 10:44:57) 得8分 
CString ==>>unsigned int 
char *p = (LPSTR)(LPCSTR) g;
f = atoi(p); 

13。static_cast、dynamic_cast 和直接类型转换（如 (void *)p ）的区别?
发表时间：2001-12-14 9:31:13

先拷贝MSDN中的一小段话：
class B { ... };
class C : public B { ... };
class D : public C { ... };

void f(D* pd)
{
C* pc = dynamic_cast<C*>(pd); // ok: C is a direct base class
// pc points to C subobject of pd 

B* pb = dynamic_cast<B*>(pd); // ok: B is an indirect base class
// pb points to B subobject of pd 
...
}
我已经知道 static_cast 和 dynamic_cast 的作用，但MSDN中并没有提到这两个操作符与直接类型转换如
void f(D* pd)
{
C* pc = （C*）(pd);

B* pb = （B*）(pd); 
...
}
的不同啊。不知道那位知道的告诉一声，在此不胜感谢，50分奉上。

回复贴子：ysdesigned(清泉)　(2001-12-14 10:03:07) 得0分 
static_cast、dynamic_cast 代 替 简 单 的 强 制 转 化， 从 而 消 除 多 继 承 带 来 的 歧 义。 使 用 这 两 个 运 算 符 号， 我 们可以 在 对 象 运 行 过 程 中 获 取 对 象 的 类 型 信 息
dynamic_cast 用于多态类型的转换
static_cast 用于非多态类型的转换

回复人：　masterz()　(2001-12-14 10:05:48) 得0分 
static_cast<...>compile时能发现不正确的指针类型转换
dynamic_cast<...>运行时如果发现是不正确的指针类型转换会返回NULL
(void*)强制转换，如果是不正确的指针类型转换，没有办法检查，不如上面2中安全 
回复人：　meady()　(2001-12-14 11:29:05) 得0分 
类型安全 
回复人：　bluecrest(为什么我的VC还是那么的菜)　(2001-12-14 11:45:34) 得0分 
com技术内幕介绍过
我刚看完就忘了 

14。byte数据类型转换成int型??
我用byte型读进一组数据想把他转成int型进行运算如何做呢?
如果再把int型转回byte又怎么实现呢? 

回复人：　louifox(兰陵笑笑生)　(2001-12-6 9:18:38) 得0分 
用下面这些宏：
WORD MAKEWORD(
BYTE bLow, 
BYTE bHigh 
);
BYTE LOBYTE(
WORD wValue 
);
BYTE HIBYTE(
WORD wValue 
);

回复人：　chskim(大刀阔斧)　(2001-12-6 9:21:04) 得0分 
int i;
BYTE b;
b=128;
i=(int)b;

回复人：　nannet(似的)　(2001-12-6 9:38:24) 得0分 
这个宏怎么用呀?有没有简单一点儿的，我现在能把BYTE 转成INT 型了，再转回去直接赋值可以吗？ 
回复人：　louifox(兰陵笑笑生)　(2001-12-6 9:46:24) 得20分 
WORD wa;
BYTE ba=32,bb=64;
wa=MAKEWORD(ba,bb);
...
WORD wa=1234;
BYTE ba,bb;
ba=LOBYTE(wa);
bb=LOBYTE(wa);

回复人：　nannet(似的)　(2001-12-6 9:54:55) 得0分 
问题解决了，多谢各位 

15。类型转换的问题，unsigned int --> lptstr/lpctstr??
发表时间：2001-8-7 23:49:41
如果强制转换的话，会出现致命错误，有什么好的办法呢？
能列举一些其他的办法吗？
谢谢大虾！ 

回复人：　AlphaOne(总是第一个倒下)　(2001-8-8 0:02:43) 得5分 
你为什么要强行转换呢？
如果你是要把int 的值作为 lptstr/lpctstr 的内容的话，
可以用CString:
unsigned int a = 100;
LPCTSTR lpText;
CString str;
str.Format("%d",a);
lpText = (LPCTSTR)str;

回复人：　tryibest(编の魂)　(2001-8-8 8:20:20) 得5分 
wsprintf(str,"%u",ui); 
回复人：　zzh()　(2001-8-8 9:04:39) 得5分 
这种情况不需要进行强制转换，直接使用wsprintf就可以了。 
回复人：　GJA106(中文字符)　(2001-8-8 10:10:51) 得5分 
unsigned int m_na=22;
LPTSTR lptstr;
wsprintf(lptstr,"%u",m_na);

16。关于COM类型转换问题??
我定义了两个变量，一个是void *piaRef=new unsigned char[1000];另一个是m_Temp=new CComVariant();我的问题是如何将piaRef中的值
COPY到m_Temp中。 

回复人：　nichang()　(2001-11-21 15:34:04) 得0分 
CComBSTR bsRef=piaRef;
m_Temp=bsRef.copy() 
回复人：　VincentChin(瘟神)　(2001-11-21 17:04:24) 得0分 
CComBSTR bsRef=piaRef;
//error C2440: 'initializing' : cannot convert from 'void *' to 'class ATL::CComBSTR'
m_Temp=bsRef.copy();
//error C2440: '=' : cannot convert from 'unsigned short *' to 'class ATL::CComVariant *' 
回复人：　nichang()　(2001-11-21 17:14:28) 得0分 
将void*改为unsigned char * 
回复人：　VincentChin(瘟神)　(2001-11-21 17:22:22) 得0分 
我用CComBSTR bsRef=(unsigned char*)piaRef，也不行吗？ 
回复人：　VincentChin(瘟神)　(2001-11-21 17:28:06) 得0分 
会报错：
error C2440: 'type cast' : cannot convert from 'unsigned char *' to 'class ATL::CComBSTR' 
回复人：　nichang()　(2001-11-22 9:12:14) 得0分 
m_Temp=::SysAllocString((OLECHAR *)piaRef) 
回复人：　VincentChin(瘟神)　(2001-11-22 10:43:07) 得0分 
//error C2440: '=' : cannot convert from 'unsigned short *' to 'class ATL::CComVariant *' 
回复人：　VincentChin(瘟神)　(2001-11-22 11:22:35) 得0分 
m_Temp=new CComVariant(::SysAllocString(OLECHAR *)piaRef));没有出错，但是我的m_Temp是COM组件中的一个PROPERTY，我想返回的是
unsigned char类型（单字节），但经过上述转换后，就不再是单字节了呀！怎么办？ 
回复人：　jiangsheng(蒋晟)　(2001-11-22 11:36:58) 得0分 
把这个属性的类型改成BSTR 
回复人：　GrayWhite(灰白)　(2001-11-22 12:01:09) 得0分 
m_Temp = new CComVariant((char*) piaRef);就可以了。VB就是用的BSTR,你要给谁用阿？VC不用VARIANT的。 
回复人：　GrayWhite(灰白)　(2001-11-22 12:18:18) 得19分 
哦，我明白了，你要各字节数组：
SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, 1000);
if (!psa)
_com_issue_error(ERROR_NOT_ENOUGH_MEMORY);

HRESULT hr
for (long i = 0; i < 2; i ++)
{
if (FAILED (hr = SafeArrayPutElement(psa, &i, piaRef + i)))
_com_issue_error(hr);
}

_variant_t va; // include <comdef.h>
va.vt = VT_ARRAY | VT_UI1;
va.parray = psa;

m_Temp = new CComVariant(va); 
回复人：　VincentChin(瘟神)　(2001-11-22 14:21:08) 得0分 
SafeArrayPutElement(psa, &i, piaRef + i)
//error C2036: 'void *' : unknown size 
回复人：　VincentChin(瘟神)　(2001-11-22 14:46:05) 得0分 
To GrayWhite:为什么要for(long i=0;i<2;i++)? 
回复人：　nichang()　(2001-11-22 15:16:35) 得0分 
到底你想怎样转换嘛，是将数组内的值拷贝到CComVariant中存为字符串吗? 
回复人：　VincentChin(瘟神)　(2001-11-22 15:28:35) 得0分 
我是想把piaRef中的值照原样返回给其它程序使用。我正在做的是一个COM组件。谢谢各位！ 
回复人：　nichang()　(2001-11-22 15:34:40) 得10分 
unsigned char *s=new unsigned char[1000];
strcpy((char*)s,"1234");//可以用你自己方法设置s中的值。
BSTR bstrS;
oleS=A2WBSTR((char*)s);//将char*转换成BSTR类型

CComVariant comVT;
comVT=oleS;//将BSTR转成CComVariant,这里一步也可，comVT=A2WBSTR((char*)s);

回复人：　VincentChin(瘟神)　(2001-11-22 16:54:07) 得0分 
谢谢你！
但我还有一个问题，就是如果在s中有'/0'之类的东西我该怎么返回呢？char *遇到'/0'会认为到头了。完整的设计是这样的，我定义一个void * 用来从一个外部设备获取数据，该数据应该是unsigned char，我想把这个返回的数据作为属性传出，让其它应用使用（如VB）。 
回复人：　nichang()　(2001-11-22 17:18:09) 得0分 
将'/0'转换成其它如'/1'就OK了， 
回复人：　jiangsheng(蒋晟)　(2001-11-22 18:07:16) 得0分 
用字符串数组 
回复人：　VincentChin(瘟神)　(2001-11-23 15:54:39) 得0分 
谢谢各位的回复！我的问题解决了！如下：
SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, 1000);
if (!psa)
return S_FALSE;
HRESULT hr;
for (long i = 0; i < 1000; i ++)
if (FAILED (hr = SafeArrayPutElement(psa, &i, ((unsigned char*)piaRefTemplate) + i)))
return S_FALSE;
VARIANT va;
va.vt = VT_ARRAY | VT_UI1;
va.parray = psa;
CComVariant *m_Temp = new CComVariant();
m_Temp->Copy(&va);

17。类型转换 static_cast reinterprete_cast 的区别??
static_cast reinterprete_cast 的区别 

回复人：　tar(GPS)　(2001-11-21 10:06:41) 得0分 
static_cast会检查转换类型健的相关性
如果没有的画会有编译错误
reinterprete_cast就是硬转了 
回复人：　tigerwoods(tao)　(2001-11-21 12:28:19) 得0分 
是否可以这样理解：在多重继承中，static_cast可实现对象指针的移动，从而指向正确的父类对象部分，而reinterprete_cast不作偏移？ 
回复人：　liu_feng_fly(我恨死驱动程序了，哎，就是为了混口饭吃)　(2001-11-21 12:35:14) 得0分 
在多重继承中可以用dynamic_cast啊 

18。那如何取得CString中的字符串？？
回复人：　nichang()　(2001-11-5 17:06:00) 得0分 
=(LPCTSTR)CString变量 
回复人：　snake1122(领悟)　(2001-11-5 17:12:16) 得0分 
方法太多了:
GetAt,Left,Mid,Right等等，就看你怎么取了！ 
回复人：　dusb(保时捷)　(2001-11-5 17:34:29) 得0分 
可是不管是GetAt，Left，Mid，Right返回类型都是CString，还是不能用，我是要取其中的字符串，奇怪的是，VC中没有string类型。（我要的字符串是给树型控件中的分支名称） 
回复人：　Alps_lou(云飞扬)　(2001-11-5 17:41:36) 得0分 
有string类型的啊，要包含<string> 
回复人：　luxes()　(2001-11-5 17:42:19) 得0分 
加上(LPCTSTR)，相当于一个const char *了，还不能用？ 
回复人：　wt007(tt)　(2001-11-5 17:48:33) 得0分 
GetBuffer 
回复人：　espon99()　(2001-11-5 17:54:06) 得20分 
(LPSTR)(LPCTSTR)

回复人：　ineedyou(古寺僧)　(2001-11-5 17:59:29) 得0分 
...m_str.GetBuffer(needlen)...;
....
m_str.ReleaseBuffer() 
回复人：　dusb(保时捷)　(2001-11-6 15:08:36) 得0分 
espon99大侠，果然是绝招，不过能否解释一下啊？ 

19。如何从CString类型转换为Unicode string 类型？
回复人：　ychener(贫血)　(2001-10-20 10:28:48) 得0分 
CString本身就支持Unicode的。
只要你选择的是UniCode编译，生成的可执行程序就是支持UniCode的 

回复人：　ychener(贫血)　(2001-10-20 10:30:04) 得0分 
CString类是自适应的就像TCHAR一样，如果你定义了UniCode宏 就会以UniCode编译 

回复人：　xjl1980_81(阿龙)　(2001-10-20 10:35:16) 得0分 
不是呀，我有个函数中有一个参数需Unicode string 类型的，比如应该填L"abc",而且引号中的内容要有变化，现在我有一个 temp变量，是CString类型的，如何用呀？ 
回复人：　xt_jat(桑巴)　(2001-10-20 10:39:37) 得0分 
_T()
_TEXT()
行不行？ 
回复人：　xjl1980_81(阿龙)　(2001-10-20 10:43:18) 得0分 
不行 
回复人：　Jeffery__Chen()　(2001-10-20 11:04:53) 得0分 
强制转化：
CString temp;
WCHAR wTemp = (WCHAR)temp; 
回复人：　xjl1980_81(阿龙)　(2001-10-20 11:37:06) 得0分 
to:Jeffery__Chen()　
不对呀，出现不能转换的错误 
回复人：　hongzhh(关儿)　(2001-10-20 11:39:42) 得0分 
问题是这样的：
temp 是 CString类型变量，值为zhh
现在有一个API 
PCCERT_CONTEXT WINAPI CertFindCertificateInStore(
HCERTSTORE hCertStore, 
DWORD dwCertEncodingType, 
DWORD dwFindFlags, 
DWORD dwFindType, 
const void *pvFindPara, //此处用 L"zhh" 没问题 
//请问怎么转换 可以 用temp

PCCERT_CONTEXT pPrevCertContext 
);

在此谢谢大家，请帮忙看看

回复人：　hongzhh(关儿)　(2001-10-20 13:27:10) 得0分 
WCHAR wszDomain[256]; 
MultiByteToWideChar( CP_ACP, 0, temp,
strlen(temp)+1, wszUserName, 
sizeof(wszUserName)/sizeof(wszUserName[0]) );


wszUserName就是转换后的值

回复人：　ychener(贫血)　(2001-10-23 11:43:05) 得0分 
只要你用的是CString的函数就行的，如果你要用类似strcpy函数时，看看MSDN中一般情况下都有响应的函数对于Unicode的。只要换成_tcscpy等等。 
回复人：　ychener(贫血)　(2001-10-23 11:44:10) 得0分 
你有没有定义Unicode宏？ 
20。请问在用ATL且不支持MFC的组件开发中，如何将从数据库中读到的DATE数据类型转换回为字符串?? 

复人：　zhxuys(zhxuys)　(2001-9-24 10:36:47) 得0分 
ATL把datetime类型的列映射为DBTIMESTAMP类型，可取出该类型的year、month、day等，然后将这些数据传递回客户端，在客户端用CTime来构造 
回复人：　YUANXU(旭)　(2001-9-24 11:18:14) 得0分 
to zhxuys:CTime是MFC类，在ATL 不支持MFC时不能用。DATE其实质是个double* 
回复人：　zhxuys(zhxuys)　(2001-9-24 11:57:01) 得0分 
你在客户端与服务器端只用ATL规定的数据类型或VARIANT类型，而在客户端，可以用MFC来重新构造想要的数据结构 

21。类型转换，CString to wchar_t ??

CString ss("aabb");
wchar_t* cc;
cc=ss.AllocSysString();

22。如何将CString类型转换为_bstr_t类型？
回复人：　wei97081116(韦小宝)　(2001-9-4 11:19:30) 得20分 
CString b;
_bstr_t a;
a=(_bstr_t)b; 

回复人：　zhaozhen1212(赵振)　(2001-9-18 1:30:18) 得0分 
_bstr_t a=b.AllocSysString();;

23。如何把一个CString类型转换成一个普通的字符串，如char*?

回复人：　liu_feng_fly(我恨死驱动程序了，哎，就是为了混口饭吃)　(2001-9-17 18:00:52) 得0分 
所以，直接用就可以，因为类里边有这样的转换函数 
回复人：　ydogg(灰毛兔频频)　(2001-9-17 18:01:21) 得0分 
CString show;

char *p = show.GetBuffer(show.GetLength()); 
回复人：　jiangping_zhu(娜可露露之风之刃)　(2001-9-17 18:02:05) 得0分 
(char*)(LPCTSTR)str 
回复人：　bmouse(老鼠)　(2001-9-18 0:10:56) 得0分 
同意楼上! 
回复人：　bmouse(老鼠)　(2001-9-18 0:13:22) 得0分 
你还可以通过GetBuff来直接操作CString的缓冲区,不过要记着释放缓冲区. 

24。CString 类型转换成 unsigned char类型吗？？
回复人：　LJN(*)风流倜傥无人及，玉树偏又临风立(*)　(2001-9-17 12:46:01) 得0分 
可以用CString.GetBuffer函数 
回复人：　xpmao()　(2001-9-17 13:09:09) 得0分 
CString strWork;
MessageBox(0,(LPSTR)strWork,0,0);
或MessageBox(0,strWork.GetBuffer(0),0,0);

回复人：　sandd(降龙掌)　(2001-9-17 13:17:32) 得0分 
CString string;

(LPCTSTR)string; 
回复人：　jeff_hunter(PandaLee)　(2001-9-17 13:45:30) 得0分 
(unsigned char *)(LPCTSTR) 
回复人：　fandh(好了)　(2001-9-17 14:00:57) 得0分 
用(unsigned char *)(LPCTSTR)即可 
回复人：　ygd(ygd)　(2001-9-17 16:11:17) 得0分 
unsigned char *p;
CString str;
int length=str.GetLength();
for(int i=0;i<length;i++)
p[i]=str.GetAt(i); 
回复人：　swordbroken(断剑书生)　(2001-9-17 16:25:57) 得0分 
CString str;
unsigned char string[30];
strcpy(string,str); 

25。何将一个unsigned int 类型变量值赋给类型为unsigned short的变量，并保证数值不丢失（当然数值在一定范围内)？
回复人：　maxsuy(魔法师兔子)　(2001-8-14 16:37:30) 得0分 
直接=就OK了 
回复人：　oppmm(ppmm)　(2001-8-14 16:38:11) 得0分 
直接赋值 
回复人：　milefo(弥勒佛)　(2001-8-14 16:40:40) 得0分 
如果数值在一定范围内怎么回丢失呢？
unsigned short a;
unsigned int b;
a=( b & 0xffff);
你试试看吧！

26。CString ----char* 
定义了char* aa的变量，现在有一个CString的变量bb，怎样把bb的值赋给aa呢? 

回复人：　emmai(WaTaXiWaWaTaXi)　(2001-8-10 11:57:33) 得0分 
aa=bb.GetBuffer(); 
回复人：　hswqs(??????????????????)　(2001-8-10 11:59:01) 得0分 
aa= (LPSTR)(LPCTSTR)bb; 
回复人：　ydogg(灰毛兔)　(2001-8-10 12:27:23) 得0分 
1.aa=bb.GetBuffer(bb.GetLenth());//第一种方法
2.aa= (LPSTR)(LPCTSTR)bb; //第二种方法 
回复人：　zhizhi()　(2001-8-10 13:16:23) 得0分 
aa= (char *)(LPCTSTR)bb,hehe 

27。在一个COM的接口函数中有一个 BSTR* 类型的参数，需要把一个 char * 类型转换为 BSTR* 类型，不知道如何转换？ 由于调用这个函数后需要把这个参数值再取出来所以只能用指针，另外在调用的时候应该用什么类型的数据传递参数呢？大虾帮忙。

BSTR bstr = SysAllocString(L"字符串");
这样转换,用的时候你用地址操作符&啊，要不指针还得new 

回复人：　yongyue2000i(小吕)　(2001-9-9 18:38:26) 得13分 
CString str = "abcd";
BSTR bstr = str.AllocSysString(); 
回复人：　houjzs()　(2001-9-9 19:14:44) 得13分 
BSTR b = SysAllocString(OLESTR("your string"));

28。要把一个double的数字输出到CEdit控件是否需要类型转换？
回复人：　jiangsheng(蒋晟)　(2001-8-24 14:46:17) 得0分 
void AFXAPI DDX_Text( CDataExchange* pDX, int nIDC, double& value ); 
回复人：　xiezhsh(雪中行)　(2001-8-24 14:56:22) 得0分 
假如你的ＣＥｄｉｔ相关的成员变量是Ｄｏｕｂｌｅ型的，那根本用不着．（ＣｌａｓｓＷｉｚａｒｄ增加成员变量的对话框中，Variable Type选择Double可） 
回复人：　xiezhsh(雪中行)　(2001-8-24 14:58:16) 得0分 
假如你的ＣＥｄｉｔ相关的成员变量不是Ｄｏｕｂｌｅ型的，是ＣＳｔｒｉｎｇ型，那就需要用ltoa()来转换成ＣＳｔｒｉｎｇ型， 
回复人：　haven(大天)　(2001-8-24 14:58:32) 得0分 
m_Edit.Fromat("%l",VarBouble);
updatedata(false); 
回复人：　12345678()　(2001-8-24 14:59:54) 得0分 
CString m_Edit.Format("%lf", doubleVar); 
GetDlgItem(EditID)->SetWindowText(m_strEdit); 

29。该如何把 WINDOWPLACEMENT * 转换成 char **类型??

(char**)&pWP 

30。怎样把CString的类型转换成char*型的？
回复人：　dcz(dcz)　(2001-8-19 19:13:27) 得5分 
// str is CString var
char* temp = strdup(str);
...
free(temp); 
回复人：　yu900(疾风之狼)　(2001-8-19 19:57:25) 得0分 
getbuffer()；即可！ 
回复人：　aileen_long(挑战2001)　(2001-8-19 21:10:35) 得0分 
同意楼上的意见！ 
回复人：　czh912()　(2001-8-19 21:27:08) 得0分 
char buf[20];
printf(buf,"%s",string);

回复人：　casl(casl)　(2001-8-19 22:59:44) 得5分 
CString s("abc");
char* temp=s.GetBuffer(10);
...
s.ReleaseBuffer(); 
回复人：　cocia(高亚)　(2001-8-19 23:04:23) 得0分 
char* temp=s.GetBuffer(10);
10是什么意思啊

回复人：　kevin_dong(梦仙人)　(2001-8-20 10:26:35) 得0分 
// str is CString var
char* temp = strdup(str);
// free
free(temp); 
我的这段代码在一个程序中能通过编译，但是在另外一个中总是出现cannot convert parameter 1 from 'class CString' to 'const char *'的错误。str和temp的类型都一样。这是为什么？

回复人：　dcz(dcz)　(2001-8-20 14:13:45) 得0分 
you may setting your compiler option to UNICODE, in this case, declare the var:

// str is CString var
_TCHAR* temp = _tcsdup(str);

// free
free(str);

31。SA,SB为两个结构类型??
SA* A;
SB* B;
(SB*)A->...（调用函数）
请问此时A的类型，是指向SA还是SB
此时编译器是生成一个临时指针吗？
另外，
B=(SB*)A;此时A又是什么类型？？？

回复贴子： 
回复人：　ddeng(登登)　(2001-8-9 17:13:58) 得0分 
A的类型始终是SA *
B的类型始终是SB *
当进行强制类型转换时使的是临时指针 
回复人：　gold_water(风雨无阻)　(2001-8-9 17:30:46) 得0分 
同意楼上的。 

32。char buff[100],char UserName[50][100],怎么将buff的值传给UserName，是其成为UserName数组中的某一项呢？？

//0=<i<50
strcpy(UserName[i],buff); 
回复人：　Ashura(阿修罗)　(2001-7-26 10:08:20) 得0分 
呵呵，benbensan抢先一步。 
回复人：　tuita(斗牛士)　(2001-7-26 10:13:22) 得0分 
for (i=0;i<100;i++)
*(*(username+x)+i)=*(buffer+i)
其中0《X〈50
benbensan写的也对

回复人：　kekeke(我是来向大家学习的)　(2001-7-26 10:24:22) 得0分 
那反过来呢？把UserName中的某一项读出赋值给buff呢？怎么弄？ 
回复人：　benbensan(笨笨三)　(2001-7-26 10:26:53) 得0分 
//0=<i<50
strcpy(UserName[i],buff); 
回复人：　benbensan(笨笨三)　(2001-7-26 10:28:15) 得0分 
对不起，能错了，不过建议你看一下C语言了的指针和数组
//0=<i<50
strcpy(buff,UserName[i]); 

回复人：　jfzsl(剿匪总司令)　(2001-7-26 10:32:57) 得0分 
好好看看老潭的书先！OK？ 
回复人：　kekeke(我是来向大家学习的)　(2001-7-26 10:44:25) 得0分 
好。。。。！ 

33。请问怎样把SYSTEMTIME类型转换成time_t类型?
SYSTEMTIME st;
GetLocalTime(&st);
CTime tm(st.wYear,st.wMonth,st.wDay,st.wHour,st.wMinute,st.wSecond);
time_t t = tm.GetTime();

34。unsigned char Exponent[10]; //e
unsigned long eBytes; //e的字节数
如何转换成DWord型! ??

用强制类型转换呀
(DWord)eBeytes;
(DWord)Exponent[i];//(0<=i<=10);

回复人：　xjl1980_81(阿龙)　(2001-7-26 16:47:29) 得0分 
我是说把e转换成DWORD型
也就是说把Exponent中的内容转换成DWORD型

回复人：　cloudshadow1(云影)　(2001-7-26 17:13:30) 得0分 
用强制类型转换就可以了，（DWORD的高24位自动加0）
DWORD Des[10]
for (int i=0;i<11;i++)
Des[i]=Exponent[i];
至于那个ULONG的也是用强制类型软换就可以了

35。请问怎样把time_t类型转换成SYSTEMTIME类型？
回复人：　haven(大天)　(2001-7-26 17:12:36) 得0分 
typedef struct _SYSTEMTIME
typedef long time_t
很明显不行嘛！ 
回复人：　facexy(FACE仔)　(2001-7-26 17:17:38) 得0分 
哎呀，问错了，前后对象相反了；-（
忙昏了的结果…………

另外，TO 楼上的：
转换是可以的
struct tm *tblock;
SYSTEMTIME SystemTime;
memset(&SystemTime,0,sizeof(SYSTEMTIME));
tblock=localtime(&timer);
SystemTime.wYear=tblock->tm_year+1900;
SystemTime.wMonth=tblock->tm_mon+1;
SystemTime.wDay=tblock->tm_mday;
SystemTime.wHour=tblock->tm_hour;
SystemTime.wMinute=tblock->tm_min;
SystemTime.wSecond=tblock->tm_sec;
SystemTime.wDayOfWeek=tblock->tm_wday;
return &SystemTime; 
回复人：　zjh73(大章鱼)　(2001-7-26 20:28:28) 得0分 
有两种方法：
1、用CTime类
先用time_t类型构造一个CTime对象，再定义一个SYSTEMTIME结构，最后用CTime类的成员函数GetAsSystemTime将时间转换到SYSTEMTIME结构中
即可。
2、用gmtime函数
gmtime函数将time_t时间转换到tm结构中并返回一个tm指针，再将tm结构的相对应的项赋给SYSTEMTIME相对应的项即可，不过用这种方法要注
意这两种结构在天、星期等方面的记数方法有点区别，一个一般从0开始，一个一般从1开始，赋值时要注意校正，还有要注意的是SYSTEMTIME
结构中有一项是毫秒，而time_t是以秒记数的。 
回复人：　zjh73(大章鱼)　(2001-7-26 20:32:13) 得0分 
反过来也可以用Ctime类的方法
就是先用SYSTEMTIME结构构造一个CTime对象，在用CTime类中的成员函数GetTime返回一个对应的time_t即可。 36。我现在正在学习SDK编程，遇到的问题是：
我定义了一个静态长整形变量，
static long lScore=0;
我想把窗口的标题换成长整形数值,用SetWindowText函数来实现，
由于它的第二个参数要求数据类型为 unsigned short *,但用其来实现强制转换时
总是出现编译错误：
cannot convert parameter 2 from 'unsigned short *' to 'const char *'
后来改成来LPCTSTR 来实现强制转换，没有出现编译错误，但函数总是执行不成功,
请教各位高人，这倒底是怎么回事？？？

回复贴子： 
回复人：　prog_st(st)　(2001-8-4 21:20:07) 得0分 
/* ITOA.C: This program converts integers of various
* sizes to strings in various radixes.
*/

#include <stdlib.h>
#include <stdio.h>

void main( void )
{
char buffer[20];
int i = 3445;
long l = -344115L;
unsigned long ul = 1234567890UL;

_itoa( i, buffer, 10 );
printf( "String of integer %d (radix 10): %s/n", i, buffer );
_itoa( i, buffer, 16 );
printf( "String of integer %d (radix 16): 0x%s/n", i, buffer );
_itoa( i, buffer, 2 );
printf( "String of integer %d (radix 2): %s/n", i, buffer );

_ltoa( l, buffer, 16 );
printf( "String of long int %ld (radix 16): 0x%s/n", l, 
buffer );

_ultoa( ul, buffer, 16 );
printf( "String of unsigned long %lu (radix 16): 0x%s/n", ul,
buffer );
}


Output

String of integer 3445 (radix 10): 3445
String of integer 3445 (radix 16): 0xd75
String of integer 3445 (radix 2): 110101110101
String of long int -344115 (radix 16): 0xfffabfcd
String of unsigned long 1234567890 (radix 16): 0x499602d2


回复人：　lwg7603(刑满释放人员)　(2001-8-4 21:36:15) 得0分 
TCHAR str[255]={_T('/0')};
_stprintf(str,_T("%d"),lScore);
SetWindowText(hwnd,str);

37。我用socket发送的的buf中间需要的是 char *类型的数据，我想将一个 struct 直接转换成 char * 发过去。
我用
struct ABCD *abcd;
char *buf;
abcd = (ABCD *)calloc(1,sizeof(ABCD));
buf = (char *)calloc(1,sizeof(ABCD));
///
给abcd 中间赋值，其中有多个char[]的值和int 的值
///
memcpy(buf,abcd,sizeof(ABCD));
//strcpy(buf,(char *)abcd)；也不可以
sock(host,buf,....);
//sock(host,(char *)buf,...);也不可以
问题就是在这里，这个buf中间的值总是不对，大家知道为什么否。

回复人：　wolf721()　(2001-7-30 18:18:34) 得5分 
你传的是个指针值，而不是数据 
回复人：　kiko_lee(到处瞧瞧)　(2001-7-30 18:50:49) 得0分 
但是用memcpy这个是将整个数据都复制过去 
回复人：　lz_0618(lz_0618)　(2001-7-30 19:26:44) 得5分 
你用的VC???改成ABCD *abcd;后编译一点问题也没有啊！
sock(host,buf,....);这不知是什么，自定义函数？

typedef struct _ABCD
{
int ID;
char Name[10];
}ABCD;

.......


ABCD *abcd;
char *buf;
abcd = (ABCD *)calloc(2,sizeof(ABCD));
buf = (char *)calloc(2,sizeof(ABCD));
///
//给abcd 中间赋值，其中有多个char[]的值和int 的值
abcd[0].ID =1;
abcd[1].ID =2;
///
memcpy(buf,abcd,2*sizeof(ABCD));
strcpy(buf,(char *)abcd);//也不可以

buf中的内容也正确！！

回复人：　kiko_lee(到处瞧瞧)　(2001-7-31 8:57:52) 得0分 
我按照楼上的兄弟说的，做了一下，但是仍然做不下来，我用
memcpy(buf,abcd,sizeof(ABCD));
中间的abcd，不知道是不是地址的问题。 
回复人：　supersusheng(小苏)　(2001-7-31 14:30:42) 得0分 
老大，你sizeof()得出的数值事多大，看看吧。 
回复人：　ydogg(灰毛兔)　(2001-7-31 14:41:52) 得0分 
只能传递流数据，结构是传递不过去的。 
回复人：　IamNotMan(NorGirl)　(2001-7-31 14:50:53) 得5分 
我常这么用
ABCD a ;
//给a的各个域赋值（一定不能含有指针项）
char* buff = new char[sizeof(ABCD)];
memcpy(buff,&a,sizeof(ABCD));
//或者 *（ABCD*)buff = a;
.................
如果buff里的数对，说明问题不在这儿吧

回复人：　zb_china(最后一座水车zb_china新浪)　(2001-7-31 15:16:24) 得0分 
看不明白 
回复人：　eggplant(拉拉)　(2001-7-31 15:42:48) 得0分 
最好使用memcpy(),因为struct中的值有可能包含零字节，所以strcpy（）可能不对，如果传递struct,最好把struct的字节对齐改为以字节为单位。 
回复人：　lvfengxun(lfx)　(2001-7-31 16:06:57) 得5分 
直接将结构指针作为send的参数发就可以了,还用转换什么
有必要在这里讨论吗?
struct AA
{
int a;
char b[100];
};
struct AA aa;
aa.a=11;
strcpy(aa.b,"aaa");
send(hSocket,(char *)(&aa),sizeof(aa),0);
//OK 
回复人：　mydewang(mydewang)　(2001-7-31 16:33:21) 得0分 
其实这里是一个字节对齐的问题,
比如
struct AA
{
int a;
char b;
};
那么sizeof( struct AA )就不等于5了,而是8了,所以,将这个结构赋值给一个char *,里面会多出一些零...

需要解决这个问题,可以在Project->Setting->Link->Project Options里加上/Zp1

另外,可以参考一下MSDN里/Zp的编译选项..... 
回复人：　lz_0618(lz_0618)　(2001-7-31 19:43:54) 得0分 
根本不是什么字节对齐的问题，我上面的程序经过测试都好用啊，这位老兄用我的那段程序究竟是什么错误，能说清楚点吗？？？

我这边用socket发送结构是一点问题也没有啊，而且是在VC和Delphi编的程序间通讯，当然，这时应该注意字节对齐的问题了，在VC程序间，
只要不是故意将服务器和客户端的编译环境设的不一样，肯定是没有什么问题的，最多是多传几个Bit罢了。 
回复人：　kiko_lee(到处瞧瞧)　(2001-8-3 11:02:51) 得0分 
我发现将char * memcpy 到 char * 中间都有点问题，但是如果放到 char []中间就可以了，大家知道为什么否？ 
回复人：　ydogg(灰毛兔)　(2001-8-3 11:40:35) 得0分 
memcpy不copy最后的'/0'... 
回复人：　wenjunlin2000(微软克星)　(2001-8-3 14:32:17) 得0分 
是你看错了
因为char*是以0 结尾的

回复人：　mc_music(狂沙)　(2001-8-3 15:07:21) 得0分 
请注意我的程序:
struct ABCD *abcd;
char *buf;
abcd = (ABCD *)calloc(1,sizeof(ABCD));
//初始化abcd
buf=abcd;//指针直接符值就可以了 
回复人：　zhangnanonnet(WinSockZhang)　(2001-8-3 16:21:03) 得0分 
你试试把类型变为BYTE 
回复人：　kiko_lee(到处瞧瞧)　(2001-8-7 9:21:08) 得0分 
不管了，给分，大家都有不少的建议呢。 


38。double dou=12.34;我如何可以得到char * ch="12.34";转换函数是什么？

回复人：　wyzegg(蛋)　(2001-7-24 21:26:04) 得50分 
double dou=12.34;
char * ch;
ch=malloc(100);
sprintf(ch,"%5.2f",dou); 
回复人：　wyzegg(蛋)　(2001-7-24 21:28:24) 得0分 
或者
#include <stdlib.h>
#include <stdio.h>

void main( void )
{
int decimal, sign;
char *buffer;
int precision = 10;
double source = 3.1415926535;

buffer = _ecvt( source, precision, &decimal, &sign );
printf( "source: %2.10f buffer: '%s' decimal: %d sign: %d/n",
source, buffer, decimal, sign );
}

但是第一种常用 
回复人：　Matrix_w(学会一点点)　(2001-7-24 21:32:43) 得30分 
int decimal, sign;
double dou =12.34;
char* ch;
ch = _ecvt(dou,4,&decimal,&sign);

回复人：　imhua(华弟)　(2001-7-24 21:35:02) 得20分 
double dou=12.34;
char *str;
gcvt(dou,5,str); //5是长度
MessageBox(str); 
回复人：　Matrix_w(学会一点点)　(2001-7-24 21:37:58) 得0分 
/* _GCVT.C: This program converts -3.1415e5
* to its string representation.
*/

#include <stdlib.h>
#include <stdio.h>

void main( void )
{
char buffer[50];
double source = -3.1415e5;
_gcvt( source, 7, buffer );
printf( "source: %f buffer: '%s'/n", source, buffer );
_gcvt( source, 7, buffer );
printf( "source: %e buffer: '%s'/n", source, buffer );
}


Output

source: -314150.000000 buffer: '-314150.'
source: -3.141500e+005 buffer: '-314150.'

39。 我在ADO中调用一个存储过程，存储过程有三个输入参数@useradd char(30),@username char(10),@userage char(3)，现在要把char 
*addr,char *name,char *age分别赋值给他们。??
我做了如下定义：
_ParameterPtr para1;
_variant_t var1,var2,var3；
==============================================================
var1.vt=VT_BSTR;
var1.bstrval=addr;/(编译错误）
==============================================================
para1=m_pCommand->CreateParameter(L"useradd",adBSTR,adParamInput,30,var1);
m_pCommand->Parameters->Append(para1);
编译结果出现下面错误：
cannot convert from 'char *' to 'unsigned short *
不知道类型是不是选择VT_BSTR?
回复人：tar(GPS)　(2001-7-12 18:49:05) 得15分 
var1.bstrval应该指向宽字符的字符串，
即unicode字符串
use _bstr_t to convert it

_bstr_t var1(addr);

　回复人：happyhackwang()　(2001-7-12 20:06:48) 得5分 
char *要进行转换成BSTR

　回复人：WhiteWaterBlueSky(疯狂数码)　(2001-7-13 9:35:15) 得10分 
SDK中是这样的
1。先用MultiByteToWideChar把char* 转为wchar_t*
2。再用SysAllocString把wchar_t*转为BSTR 

　回复人：tar(GPS)　(2001-7-13 14:10:01) 得0分 
faint,我都已经把语句写出来了
_bstr_t a(addr);
var1.vt=VT_BSTR;
var1.bstrval=(wchar_t *)a; 

　回复人：xwchena(西风之神)　(2001-7-13 15:57:00) 得0分 
大哥，我改完之后记录集无结果返回。我的代码是这样的：
m_pRecordset.CreateInstance(__uuidof(Recordset));
m_pRecordset=m_pCommand->Execute(NULL,NULL,adCmdStoredProc);
if(!m_pRecordset->adoEOF)
{
result1=m_pRecordset->GetCollect((long)0);
if(result1.vt!=NULL)
{
result1.ChangeType(VT_BSTR);
CString strResult1=result1.bstrVal;
strcpy(resval,strResult1);
}
调试的时候看到执行完m_pCommand->Execute()后m_pRecordset就到了记录集的尾部
而如果把char*型都改成int型，结果就能返回记录集。
这是为什么啊？？？

　回复人：tar(GPS)　(2001-7-13 19:19:51) 得0分 
try adVarChar 
　回复人：xwchena(西风之神)　(2001-7-13 22:54:21) 得0分 
还是不行，记录集没有返回结果 
　回复人：seesi(不是我想骗你，是我不知道怎么才能不骗！)　(2001-7-14 0:24:36)

40。如何将 BSTR pVal 赋给：unsigned char *pw；如何将：unsigned char digest[16]赋给 BSTR *pOutVal?

USES_CONVERSION;
  *pOutVal=SysAllocString(A2W((LPTSTR)digest));

unsigned char *pw = (unsigned char *)_com_util::ConvertBSTRToString(pInVal);

15:58 | 添加评论  | 固定链接  | 引用通告 (0)  | 写入日志

7月21日

保存文件路径

///**********初始化路径，取得播放曲目列表文件的全路径*********
bool CPlayerDlg::InitPath()
{  

 TCHAR szPath[MAX_PATH];           //保存文件路径
 ::GetModuleFileName (NULL, szPath,
                   sizeof (szPath) / sizeof (TCHAR));//获取当前程序路径

 CString string = szPath;
 int nIndex = string.ReverseFind (_T ('//'));
 ASSERT (nIndex != -1);

 string = string.Left (nIndex + 1) + _T ("player.mp");
 m_strSongListPath = string;

 return true;
}

/**********读取曲目路径列表**********************
void CPlayerDlg::ReadSongList ()
{
 try
 {
  CFile file (m_strSongListPath,
           CFile::modeReadWrite);
  CArchive ar(&file, CArchive::load);
 
  ar >> nCurCount;
  
  if (nCurCount >= 0)
  {
   for (int i = 0; i <= nCurCount; i++)
   {
    ar >> m_strSongPath[i];
    CString strSongName = m_strSongPath[i];
       FilterPathToFileName (strSongName);
      
    CString strNum;
    strNum.Format (_T ("%d "), i);
    strSongName = strNum + strSongName;
   
    m_wndSongList.AddString (strSongName);
   }
   ar >> m_strCurSong;
   ar >> m_nCurIndex;
   m_wndSongList.SetCurSel (m_nCurIndex);
  }
 }
 catch (CFileException* e)
 {
  e->ReportError ();
  e->Delete ();
 }
}

 

 

/**********保存曲目路径列表**********************
void CPlayerDlg::SaveSongList ()
{
 try
 {
  CFile file;
  if (!file.Open (m_strSongListPath,
           CFile::modeReadWrite | CFile::modeCreate))
    return;
  CArchive ar(&file, CArchive::store);
 
  if (nCurCount >= 0)
  {
   ar << nCurCount;
   
   for (int i = 0; i <= nCurCount; i++)
   {
    ar << m_strSongPath[i];
    
   }
   ar << m_strCurSong;
   ar << m_nCurIndex;
  }
 }
 catch (CFileException* e)
 {
  e->ReportError ();
  e->Delete ();
 }
}

 

 

 

 

 

//-------------------获得播放列表文件的路径------------
bool CMidi::InitPath()
{//初始化路径，取得播放曲目列表文件的全路径
 TCHAR path[256];//保存文件路径
 GetModuleFileName(NULL,path,sizeof(path)) ;//获取当前程序路径
 TCHAR * p = _tcsrchr(path,_T('//')) ;//查找最后一个'//'字符
 if(p) lstrcpy(p,_T(" //MPlayer.mdr"));//替换成要查找的完整路径
 m_MusicFilePath=path;//保存到路径变量中，以便用它来打开列表文件
 return true;
}
//----------读取曲目路径列表-----------------
bool CMidi::OpenList()
{
 CFile fileList;
 if(!fileList.Open(m_MusicFilePath,CFile::modeNoTruncate|CFile::modeRead))
  return FALSE;//以只读模式打开，不覆盖原有文件,m_MusicFilePath为列表文件的路径 
 char ch;
 while(1)
 {
  CString fileName;
  fileList.Read(&ch,1);//读入一个字符
  if(ch=='-') break;  //如文件是最后返回,-是文件最后的标志
  fileName+=ch;//否则存入
  while(1)
  {//读入一行
   fileList.Read(&ch,1);
   if(ch=='/r')
   {//这儿可以判断是一行了
    m_totalFiles++;//曲目首数计数
    fileList.Read(&ch,1);
    break;
   }
   fileName+=ch;
  }
        //下面这句把路径加入列表中，用字符串数组代替
  //m_totalFiles前面已经加一了，所以这儿要少一个
  m_FileList[m_totalFiles-1]=fileName;
 }
 fileList.Close();
 return TRUE;
}

 

//----------保存曲目列表-----------------
bool CMidi::SaveList()
{
 CFile fileList;//文件对象
 if(!fileList.Open(m_MusicFilePath,CFile::modeCreate|CFile::modeWrite))
  return FALSE;//打开文件,不存在则创建，写文件
 char fileName[256];
 for(int i=0;i<m_totalFiles;i++)
 {//m_totalFiles为打开对话框中获取的歌曲总数
  strcpy(fileName,m_FileList[i]);//取出一条曲目路径
  fileList.Write(fileName,strlen(fileName));//写入文件
  fileList.Write("/r/n",2);//写入一行结束和换行符
 }
 fileList.Write("----",4);//写入文件最后标志
 fileList.Close();//关闭文件
 return TRUE;

}