实现步骤
大家知道，每个Internet客户端程序都伴随有一定的目的行为，如读文件、写文件、删除文件等等。客户端的程序要实现这些行为的先决条件是建立Internet连接。然后再根据不同的目的进行具体的操作。为了方便起见，下面这这些张表格针对不同的应用行为列出了所需要的具体操作。其中列出了一般的Internet URL (FTP、或者 HTTP)客户端行为要实现某个目标所必须使用的方法。这张表格的内容来自MSDN。我对部分我认为重要的地方做了补充。
（表一）一个典型的Internet客户端程序的处理流程
| 目的 | 方法 | 结果 |
| 开始一个Internet session | 创建 CInternetSession 对象 | 初始化WinInet，并连接服务器 |
| 读取或设置 InternetQuery 选项 (如超时或重试次数） | 调用 CInternetSession::SetOption | 不成功返回FALSE |
| 建立回调函数监视session状态 | 调用CInternetSession::EnableStatusCallback 建立回调函数 | CInternetSession::OnStatusCallback，重写OnStatusCallback，创建自己的回调例程 |
| Internet服务器Intranet服务器或本地文件 | 调用 CInternetSession::OpenURL | 解析并打开到指定服务器的连接，返回CStdioFile（如果你传递的OpenURL是本地文件名）或CInternetFile对象，通过存取这个对象，获得服务器或文件的数据 |
| 读文件 | 调用 CInternetFile::Read | 用你提供的Buffer读指定的字节数 |
| 异常处理 | 在 CInternetException 类中处理 | 处理所有普通的 Internet 异常类型 |
| 结束 Internet session 处理 | CInternetSession对象 | 自动清除打开的句柄的连接 |
（表二）典型的 FTP 客户端程序实现的一般步骤
| 目的 | 方法 | 结果 |
| 开始一个FTP会话，建立一个FTP连接 | 创建一个CInternetSession对象，调用CInternetSession::GetFtpConnection | 初始化WinInet 并联接服务器 |
| 连接到一个FTP Server | 用CInternetSession::GetFtpConnection | 返回一个CFtpConnection对象 |
| CD到 FTP 服务器的一个新目录 | 用CFtpConnection::SetCurrentDirectory | CD到FTP服务器的一个 新目录 |
| Find 第一个FTP目录中的文件 | 创建一个CFtpFileFind对象，调用CFtpFileFind::FindFile，OpenURL函数返回一个只读资源对象；调用CFtpFileFind::FindFile | Find第一个文件,如果文件每找到返回FALSE |
| 枚举所有可获得的资源，Find下一个FTP目录中的文件 | Find下一个资源，调用CFtpFileFind::FindNextFile直到返回FALSE。 | Find下一个文件 如果文件没找到返回FALSE |
| 打开FindFile或FindNextFile找到的文件（用于读写） | 调用CFtpConnection::OpenFile，参数为FindFile或FindNextFile返回的文件名 ，创建并打开一个CInternetFile对象 | 打开FindFile或FindNextFile找到的文件（用于读写）,返回一个CInternetFile对象 |
| 读写文件 | 以读方式打开FTP文件，用CInternetFile::Read | 使用你指定的缓冲读 指定的字节数 |
| 写FTP文件 | 以写方式打开FTP文件，调用CInternetFile::Write，重写CInternetSession::OnStatusCallback | 使用你指定的缓冲写 指定的字节数 |
| 改变客户端在服务器上的目录 | 调用CFtpConnection::SetCurrentDirectory | 进入新的目录 |
| 获取客户端在服务器上的当前目录 | 调用CFtpConnection::GetCurrentDirectory | 获取目录信息 |
| 异常处理 | 用CInternetException类 | 处理所有普通的Internet异常类型 |
| 结束FTP session | 处理CInternetSession对象 | 自动清除打开的句柄的连接 |
（表三）显示了一个典型的删除文件的FTP客户端应用要实现的一般步骤：
| 目的 | 方法 | 结果 |
| 开始一个FTP session | 创建一个CInternetSession对象 | 初始化WinInet 并联接服务器 |
| 连接到一个FTP Server | 用CInternetSession::GetFtpConnection | 返回一个CFtpConnection对象 |
| 检查FTP目录是否正确 | 用CFtpConnection::GetCurrentDirectory或CFtpConnection::GetCurrentDirectoryAsURL | 返回目录名字 服务器目录或返回目录的URL |
| CD（改变目录）到 FTP 服务器的一个新目录 | 用CFtpConnection::SetCurrentDirectory | CD到FTP服务器的一个 新目录 |
| Find 第一个FTP目录中的文件 | 用CFtpFileFind::FindFile | Find第一个文件,如果文件每找到返回FALSE |
| Find 下一个FTP目录中的文件 | 用CFtpFileFind::FindNextFile | Find下一个文件 如果文件没找到返回FALSE |
| 删除FindFile或FindNextFile找到的文件 | 用CFtpConnection::Remove用FindFile或FindNextFile返回的文件名 | 删除FindFile或FindNextFile 找到的文件 |
| 异常处理 | 用CInternetException类 | 处理所有普通的Internet异常类型 |
| 结束FTP session | 处理CInternetSession对象 | 自动清除打开的句柄的连接 |
（表四）显示了实现一个典型的 HTTP 客户端应用程序的一般步骤：
| 目的 | 方法 | 结果 |
| 开始HTTP会话，建立HTTP连接 | 创建 CInternetSession对象，调用CInternetSession::GetHttpConnection 创建CHttpConnection对象 | 初始化WinInet并联接服务器，返回一个CHttpConnection对象 |
| 创建一个 HTTP 请求 | 调用CHttpConnection::OpenRequest 创建一个CHttpFile对象； | 返回一个CHttpFile对象 |
| 发送一个HTTP 请求 | 用CHttpFile::AddRequestHeaders 并且用CHttpFile::SendRequest | Find一个文件 如果文件没找到返回FALSE |
| 读文件 | 调用CInternetFile::Read | 使用你提供的缓冲读指定的字节 |
| 获取HTTP请求信息 | 调用CHttpFile::QueryInfo | 从服务器获取HTTP请求头信息 |
| 异常处理 | 利用CInternetException类 | 处理所有普通的Internet异常类型 |
| 结束 HTTP 会话 | 处理CInternetSession对象 | 自动清除打开的句柄的连接 |
由于时间关系，我没有写本文的例子代码。不过MSDN里有两个简单的例子可以参考，一个是FTPTREE，另一个是TEAR。此外，也可以用“WinInet”作为关键字在google里搜一下也能找到一些使用MFC WinInet的技术信息。（完）
VC Post HTTP
我这里有一段程序，用来在一个对话框里显示出一次http request的原始信息，不过使用Inet API做的，希望能有帮助。
void CHTTPRequestDlg::OnButtonRequest()
{
UpdateData(TRUE);
HINTERNET hInternet = InternetOpen("Mozilla/4.0 (compatible; MSIE 5.0; Windows NT 5.0)", INTERNET_OPEN_TYPE_DIRECT,
NULL, NULL, NULL);
HINTERNET hSession = InternetConnect(hInternet, m_strHost,
m_nPort, "username", "password",
INTERNET_SERVICE_HTTP, 0, 0);
char* szAccept[] = {"*/*", NULL};
CString strVerb;
m_comboVerb.GetWindowText(strVerb);
HINTERNET hRequest = HttpOpenRequest(hSession, strVerb, m_strObject, NULL, NULL, (LPCSTR*)szAccept, 0, 0);
struct
{
char* Language;
char* Encoding;
char* ContentType;
}Headers = {"Accept-Language: zh-cn\r\n",
"Accept-Encoding: gzip, deflate\r\n",
"Content-Type: application/x-www-form-urlencoded\r\n"};
if(m_bLanguage)
HttpAddRequestHeaders(hRequest, Headers.Language, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE);
if(m_bEncoding)
HttpAddRequestHeaders(hRequest, Headers.Encoding, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE);
if(m_bContentType)
HttpAddRequestHeaders(hRequest, Headers.ContentType, -1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE);
LPCSTR lpAddHeader = NULL, lpContent = NULL;
if(m_strHeaders.GetLength())
{
if(m_strHeaders.Right(2) != "\r\n")
m_strHeaders += "\r\n";
lpAddHeader = (LPCSTR)m_strHeaders;
}
if(m_strContent.GetLength() && (strVerb == "POST" || strVerb == "PUT"))
lpContent = (LPCSTR)m_strContent;
HttpSendRequest(hRequest, lpAddHeader, -1, (LPVOID)lpContent, m_strContent.GetLength());
m_editContentGot.SetSel(0, -1);
m_editContentGot.ReplaceSel("");
LPSTR lpszData; // buffer for the data
DWORD dwSize; // size of the data available
DWORD dwDownloaded; // size of the downloaded data
// Set the cursor to an hourglass.
SetCursor(LoadCursor(NULL,IDC_WAIT));
// This loop handles reading the data.
while(1)
{
// The call to InternetQueryDataAvailable determines the amount of
// data available to download.
if (!InternetQueryDataAvailable(hRequest,&dwSize,0,0))
{
SetCursor(LoadCursor(NULL,IDC_ARROW));
break;
}
else
{
// Allocates a buffer of the size returned by InternetQueryDataAvailable
lpszData = new char[dwSize+1];
// Reads the data from the HINTERNET handle.
if(!InternetReadFile(hRequest,(LPVOID)lpszData,dwSize,&dwDownloaded))
{
delete[] lpszData;
break;
}
else
{
// Adds a null terminator to the end of the data buffer
lpszData[dwDownloaded]='\0';
int nLen = m_editContentGot.GetWindowTextLength();
m_editContentGot.SetSel(nLen-1, nLen-1);
m_editContentGot.ReplaceSel(lpszData);
// Delete the two buffers
delete[] lpszData;
// Check the size of the remaining data. If it is zero, break.
if (dwDownloaded == 0)
break;
}
}
}
// Close the HINTERNET handle
InternetCloseHandle(hRequest);
InternetCloseHandle(hSession);
InternetCloseHandle(hInternet);
// Set the cursor back to an arrow
SetCursor(LoadCursor(NULL,IDC_ARROW));
使用MFC示例如下:
首先设置m_strRequest请求字符串 eg."name=aaa&pass=bbb";
m_strServerName 服务器名称或者IP eg."www.yahoo.com"
m_strObjectName 请求文件位置 eg. "pub/aaa.asp"
请求的结果存放在m_strHtml中
func(){
CInternetSession m_InetSession("session");
CHttpConnection* pServer = NULL;
CHttpFile* pFile = NULL;
try{
INTERNET_PORT nPort;
nPort=80;
pServer = m_InetSession.GetHttpConnection(m_strServerName, nPort);
pFile = pServer->OpenRequest(CHttpConnection::HTTP_VERB_POST,
m_strObjectName);
char szHeaders[100];
strcpy(szHeaders,"Accept: text*/*\r\nContent-Type: application/x-www-form-urlencoded");
pFile->AddRequestHeaders(szHeaders);
pFile->SendRequestEx(m_strRequest.GetLength());
pFile->WriteString(m_strRequest); //重要-->m_Request 中有"name=aaa&name2=BBB&..."
pFile->EndRequest();
DWORD dwRet;
pFile->QueryInfoStatusCode(dwRet);
CString str;
m_Mutex.Lock();
m_strHtml="";
char szBuff[1024];
if (dwRet == HTTP_STATUS_OK){
UINT nRead;
while ((nRead = pFile->Read(szBuff,1023))>0)
{
m_strHtml+=CString(szBuff,nRead);
}
}
m_Mutex.Unlock();
delete pFile;
delete pServer;
}
catch (CInternetException* e){
CString s;
s.Format("Internet Exception\r\nm_dwError%u,m_dwContextError%u",e->m_dwError,e->m_dwContext);
AfxMessageBox(s);
//catch errors from WinInet
}
}
DOM应用---遍历网页中的元素
DOM应用---遍历网页中的元素
作者：杨老师
下载源代码
一、摘要
在我们编写的程序中，如果想要实现对浏览器打开的网页进行监视、模拟操纵、动态提取用户输入、动态修改......等功能，那么请你抽出宝贵的时间，继续往下阅读。本文介绍的知识和示例程序都是围绕如何遍历 HTML 中的表单(form)并枚举出表单域的属性为目标的，对于网页中的其它元素，比如图象、连接、脚本等等，应用同样的方法都可以轻松实现。
二、网页的文档层次结构
IE 浏览器，采用 DOM（文档对象模型）来管理网页的数据。它通过一个容器（IWebBrowser2/IHTMLWindow2）来装载网页文档（IHTMLDocument2），而一个文档，又可以由 0 或多个贞(frame)组成，管理这些贞的接口叫“框架集合（IHTMLFramesCollection2）”,而每个贞的容器又是 IHTMLWindow2，和IWebBrowser2一样，它也装载着各自的文档（IHTMLDocument2）。因此，我们的第一个任务，就是想方设法能够得到IHTMLDocument2的接口。因为文档可能包含贞，而贞又包含着子文档，子文档可能再包含贞......，如此要得到所有的文档，这里有一个递归遍历的处理过程。
得到文档（IHTMLDocument2）后，下一步任务就是要设法取得表单了（IHTMLFormElement）。因为在一个文档中可以包含 0 或多个表单(form)，而管理这些表单的又是一个表单集合（IHTMLElementCollection），所以必须先得到集合，然后再枚举出所有的表单条目了。
得到表单（IHTMLFormElement）后，接下来的事情就简单了，逐个提取表单中的元素（也叫表单域 IHTMLInputElement）就可以读写这些域的属性了。
说了半天，我估计初次接触的朋友一定没有听懂:( 呵呵，还是用图的方式表示一下吧，这样比较清晰一些。
三、程序实现
<1> 取得 IHTMLDocument2 的接口指针。根据IE浏览器的运行方式，有多种不同的方式可以获取文档指针。
<1.1> 如果你在程序中使用MFC的 CHtmlView 视来浏览网页。
取得文档的方法最简单，调用 CHtmlView::GetHtmlDocument() 函数。
<1.2> 如果你的程序中使用了“Web 浏览器” 的ActiveX 控件。
取得文档的方法也比较简单，调用 CWebBrowser2::GetDocument() 函数。
<1.3> 如果你的程序是用 ATL 写的 ActiveX 控件。
那么需要调用 IOleClientSite::GetContainer 得到 IOleContainer 接口，然后就可以通过 QueryInterface() 查询得到 IHTMLDocument2 的接口。主要代码如下：
CComPtr < IOleContainer > spContainer;
m_spClientSite->GetContainer( &spContainer );
CComQIPtr < IHTMLDocument2 > spDoc = spContainer;
if ( spDoc )
{
// 已经得到了 IHTMLDocument2 的接口指针
}
<1.4> 如果你的程序是用 MFC 写的 ActiveX 控件。
那么需要调用 COleControl::GetClientSite() 得到 IOleContainer 接口，然后的操作和<1.3>是一致的了。
<1.5> IE 浏览器作为独立的进程正在运行。
每个运行的浏览器（IE 和 资源浏览器）都会在 ShellWindows 中进行登记，因此我们要通过 IShellWindows 取得实例（示例程序中使用的就是这个方法）。主要代码如下：
#include < atlbase.h >
#include < mshtml.h >
void FindFromShell()
{
CComPtr< IShellWindows > spShellWin;
HRESULT hr = spShellWin.CoCreateInstance( CLSID_ShellWindows );
if ( FAILED( hr ) ) return;
long nCount=0;
spShellWin->get_Count(&nCount); // 取得浏览器实例个数
for(long i=0; i<nCount; i++)
{
CComPtr< IDispatch ><nCount; i++)
{
CComPtr< IDispatch ><nCount; i++)
{
CComPtr< IDispatch > spDisp;
hr=spShellWin->Item(CComVariant( i ), &spDisp );
if ( FAILED( hr ) ) continue;
CComQIPtr< IWebBrowser2 > spBrowser = spDisp;
if ( !spBrowser ) continue;
spDisp.Release();
hr = spBrowser->get_Document( &spDisp );
if ( FAILED ( hr ) ) continue;
CComQIPtr< IHTMLDocument2 > spDoc = spDisp;
if ( !spDoc ) continue;
// 程序运行到此，已经找到了 IHTMLDocument2 的接口指针
}
}
<1.6> IE 浏览器控件被一个进程包装在一个子窗口中。那么你首先要得到那个进程的顶层窗口句柄（使用 FindWindow() 函数，或其它任何可行的方法），然后枚举所有子窗口，通过判断窗口类名是否是“Internet Explorer_Server”，从而得到浏览器的窗口句柄，再向窗口发消息取得文档的接口指针。主要代码如下：
#include < atlbase.h >
#include < mshtml.h >
#include < oleacc.h >
#pragma comment ( lib, "oleacc" )
BOOL CALLBACK EnumChildProc(HWND hwnd,LPARAM lParam)
{
TCHAR szClassName[100];
::GetClassName( hwnd, &szClassName, sizeof(szClassName) );
if ( _tcscmp( szClassName, _T("Internet Explorer_Server") ) == 0 )
{
*(HWND*)lParam = hwnd;
return FALSE; // 找到第一个 IE 控件的子窗口就停止
}
else return TRUE; // 继续枚举子窗口
};
void FindFromHwnd(HWND hWnd)
{
HWND hWndChild=NULL;
::EnumChildWindows( hWnd, EnumChildProc, (LPARAM)&hWndChild );
if(NULL == hWndChild) return;
UINT nMsg = ::RegisterWindowMessage( _T("WM_HTML_GETOBJECT") );
LRESULT lRes;
::SendMessageTimeout( hWndChild, nMsg, 0L, 0L, SMTO_ABORTIFHUNG, 1000, (DWORD*) &lRes );
CComPtr < IHTMLDocument2 > spDoc;
HRESULT hr = ::ObjectFromLresult ( lRes, IID_IHTMLDocument2, 0 , (LPVOID *) &spDoc );
if ( FAILED ( hr ) ) return;
// 程序运行到此，已经找到了 IHTMLDocument2 的接口指针
}
<2> 得到了 IHTMLDocument2 接口指针后，如果网页是单贞的，那么转第<4>步骤。如果是多贞（有子框架）则还需要遍历所有的子框架。这些子框架（IHTMLWindow2），被保存在集合中（IHTMLFramesCollection2）,取得集合指针的方法比较简单，取属性 IHTMLDocument2::get_frames()。
<3> 首先取得子框架的总数目 IHTMLFramesCollection::get_length()，接着就可以循环调用 IHTMLFramesCollection::item()函数一个一个地取得子框架 IHTMLWindow2 指针，然后转第<1>步。
<4> 一个文档中可能拥有多个表单，因此还是同样的道理，先要取得表单的集合（IHTMLElementCollection，其实这个不光是表单的集合，其他元素的集合，比如图片集合也是用它）。这个操作也很简单，取得属性 IHTMLDocument2::get_forms()。
<5> 属性 IHTMLElementCollection::get_length() 得到表单总数目，就可以循环取得每一个表单指针了 IHTMLElementCollection::item()。
<6> 在第<5>步中的item()函数，得到的是一个IDispatch的指针，你通过QueryInterface()查询，就可以得到 某类型输入的指针，代码如下：
// 假设 spDisp 是由IHTMLElementCollection::item() 得到的 IDispatch 指针
CComQIPtr < IHTMLInputTextElement > spInputText(spDisp);
CComQIPtr < IHTMLInputButtonElement > spInputButton(spDisp);
CComQIPtr < IHTMLInputHiddenElement > spInputHidden(spDisp);
......
if ( spInputText )
{
//如果是文本输入表单域
}
else if ( spInputButton )
{
//如果是按纽输入表单域
}
else if ( spInputHiddent )
{
//如果是隐藏输入表单域
}
else if ........ //其它输入类型
上面的方法，由于使用具体类型的接口指针，因此程序的效率比较高。但是通过 QueryInterface 接口查询，然后再进行条件判断显然是比较烦琐的，所以这个方法适合于特定的已知网页设计内容的程序。在示例程序中，我则是直接使用 IDispatch 接口进行操作的，这个方式执行起来稍微慢一些，但程序比较简单。主要代码和说明如下：
#include < atlbase.h >
CComModule _Module; // 由于需要使用 CComDispatchDriver 的 IDispatch 包装类ATL智能指针，所以这个是必须的
#include < atlcom.h >
......
long nElemCount=0; //表单域的总数目
spFormElement->get_length( &nElemCount );
for(long j=0; j< nElemCount; j++)
{
CComDispatchDriver spInputElement; // IDispatch 的智能指针
spFormElement->item( CComVariant( j ), CComVariant(), &spInputElement );
CComVariant vName,vVal,vType; // 域名称，域值，域类型
spInputElement.GetPropertyByName( L"name", &vName );
spInputElement.GetPropertyByName( L"value",&vVal );
spInputElement.GetPropertyByName( L"type", &vType );
// 使用 IDispatch 的智能指针的好处就是：象上面这样读取、设置属性很简单
// 另外调用 Invoke 函数也异常方便，Invoke0(),Invoke1(),Invoke2()....
......
}
四、结束语
示例程序在 VC6 下编译执行通过。运行方法：随便启动几个 IE 浏览网页，最好是有表单输入的网页。然后执行示例的 EXE 程序即可。到这里，就到这里了......祝大家学习快乐 ^-^
CString Usage
VC++中的CString操作指南
VC++中的CString操作指南
原文出处：codeproject：CString Management
通过阅读本文你可以学习如何有效地使用 CString。
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[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 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。这就是你可能需要改变的地方。
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 文件中：
STRINGTABLE
IDS_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 的时候，总是得到一些垃圾："
VC++ type Cast ChapterA
VC中有关数据类型转换的整理 | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
说明：本文纯粹是总结一下有关类型转换的贴子， 本人并未对所有方法都做测试，仅仅是为了给大家一个参考。 读者层次：初学 int i = 100;
二、字符串转换为其它数据类型
三、其它数据类型转换到CString
四、BSTR、_bstr_t与CComBSTR
五、VARIANT 、_variant_t 与 COleVariant
六、其它一些COM数据类型
七、ANSI与Unicode
八、其它
九、注意事项 后记：本文匆匆写成，错误之处在所难免，欢迎指正. |
5986
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
