我日常整理了CString的一些用法，很实用，发给你共享，相信你之后遇到CString的问题都会迎刃而解：

CString 是一种颇有用的数据类型。它们很大程度上简化了MFC中的许多操做，使得MFC在作字符串操做的时候方便了不少。无论怎样，使用CString有不少特殊的技巧，特别是对于纯C背景下走出来的程序员来讲有点难以学习。这篇文章就来讨论这些技巧。
　　使用CString可让你对字符串的操做更加直截了当。这篇文章不是CString的彻底手册，但囊括了大部分常见基本问题。
这篇文章包括如下内容： 
1. CString 对象的链接 
2. 格式化字符串（包括 int 型转化为 CString ） 
3. CString 型转化成 int 型 
4. CString 型和 char* 类型的相互转化
5. char* 转化成 CString 
6. CString 转化成 char* 之一：使用LPCTSTR强制转化 
7. CString 转化成 char* 之二：使用CString对象的GetBuffer方法 
8. CString 转化成 char* 之三: 和控件的接口
9. CString 型转化成 BSTR 型； 
10. BSTR 型转化成 CString 型； 
11. VARIANT 型转化成 CString 型； 
12. 载入字符串表资源； 
13. CString 和临时对象； 
14. CString 的效率； 
15. 总结 
下面我分别讨论。
 一、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);
 二、格式化字符串
　　与其用 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位的字符哦。

三、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));
 四、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() 来包围格式化字符串，可是基本 思路仍然是在走弯路，这这样很容易出错。