无码人妻久久一区二区三区免费丨 ,成人亚洲欧美久久久久,一本久久a久久精品综合夜夜

[转]常用数据�c�d��的��用与转换

李亚 — Sat, 12 Jan 2008 15:07:00 GMT

我们先定义一些常见类型变量借以说明

int i = 100;
long l = 2001;
float f=300.2;
double d=12345.119;
char username[]="�E�佩�?;
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2;

一、其它数据类型�{换�ؓ字符�?/strong>

短整�?int)
itoa(i,temp,10);///��i转换为字�W�串攑օ�temp�?最后一个数字表�C�十�q�制
itoa(i,temp,2); ///按二�q�制方式转换
长整�?long)
ltoa(l,temp,10);
��点�?float,double)
用fcvt可以完成转换,�q�是MSDN中的例子:
int decimal, sign;
char *buffer;
double source = 3.1415926535;
buffer = _fcvt( source, 7, &decimal, &sign );
�q�行�l�果:source: 3.1415926535 buffer: '31415927' decimal: 1 sign: 0
decimal表示��数点的位置,sign表示�W�号:0为正敎ͼ�1��?
CString变量
str = "2008北京奥运";
buf = (LPSTR)(LPCTSTR)str;
BSTR变量
BSTR bstrValue = ::SysAllocString(L"�E�序�?);
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�c�d��是对BSTR的封装，因�ؓ已经重蝲�?操作�W�，所以很�Ҏ��使用
_bstr_t bstrVar("test");
const char *buf = bstrVar;///不要修改buf中的内容
AfxMessageBox(buf);

通用�Ҏ��(针对非COM数据�c�d��)
用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);

二、字�W�串转换为其它数据类�?/font>
strcpy(temp,"123");

短整�?int)
i = atoi(temp);
长整�?long)
l = atol(temp);
��点(double)
d = atof(temp);
CString变量
CString name = temp;
BSTR变量
BSTR bstrValue = ::SysAllocString(L"�E�序�?);
...///完成对bstrValue的��?br>SysFreeString(bstrValue);

CComBSTR变量
CComBSTR�c�d��变量可以直接赋�?br>CComBSTR bstrVar1("test");
CComBSTR bstrVar2(temp);

_bstr_t变量
_bstr_t�c�d��的变量可以直接赋�?br>_bstr_t bstrVar1("test");
_bstr_t bstrVar2(temp);

三、其它数据类型�{换到CString
使用CString的成员函数Format来�{�?例如:

整数(int)
str.Format("%d",i);
��点�?float)
str.Format("%f",i);
字符串指�?char *)�{�已�l�被CString构造函数支持的数据�c�d��可以直接赋�?br>str = username;
对于Format所不支持的数据�c�d��Q�可以通过上面所说的关于其它数据�c�d��转化到char *的方法先转到char *�Q�然后赋值给CString变量�?br>

四、BSTR、_bstr_t与CComBSTR

CComBSTR 是ATL对BSTR的封装，_bstr_t是C++对BSTR的封�?BSTR�?2位指�?但�ƈ不直接指向字串的�~�冲区�?br>char *转换到BSTR可以�q�样:
BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上comutil.h和comsupp.lib
SysFreeString(bstrValue);
反之可以使用
char *p=_com_util::ConvertBSTRToString(b);
delete p;
具体可以参考一�Q�二�D�落里的具体说明�?br>
CComBSTR与_bstr_t对大量的操作�W�进行了重蝲�Q�可以直接进�?,!=,==�{�操作，所以��用非常方�ѝ�?br>特别是_bstr_t,��大家使用它�?br>

五、VARIANT 、_variant_t �?COleVariant

VARIANT的结构可以参考头文�gVC98\Include\OAIDL.H中关于结构体tagVARIANT的定义�?br>对于VARIANT变量的赋��|��首先�l�vt成员赋��|��指明数据�c�d��Q�再对联合结构中相同数据�c�d��的变量赋��|��举个例子�Q?br>VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋�?br>
对于不马上赋值的VARIANT�Q�最好先用Void VariantInit(VARIANTARG FAR* pvarg);�q�行初始�?其本质是��vt讄��为VT_EMPTY,下表我们列�Dvt与常用数据的对应关系:

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的封装类�Q�其赋值可以��用强制类型�{换，其构造函��C��自动处理�q�些数据�c�d��?br>使用旉��加上#include
例如�Q?br>long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;

COleVariant的��用与_variant_t的方法基本一��P��请参考如下例子：
COleVariant v3 = "字符�?, v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;

六、其它一些COM数据�c�d��

�Ҏ��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�U�Cؓ宽字�W�型字串,COM里��用的都是Unicode字符丌Ӏ?/font>

��ANSI转换到Unicode
(1)通过L�q�个宏来实现�Q�例�? 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);

八、其�?/strong>

�Ҏ��息的处理中我们经帔R��要将WPARAM或LPARAM�{?2位数据（DWORD)分解成两�?6位数据（WORD),例如�Q?br>LPARAM lParam;
WORD loValue = LOWORD(lParam);///取低16�?br>WORD hiValue = HIWORD(lParam);///取高16�?br>

对于16位的数据(WORD)我们可以用同��L��Ҏ��分解成高低两�?位数�?BYTE),例如:
WORD wValue;
BYTE loValue = LOBYTE(wValue);///取低8�?br>BYTE hiValue = HIBYTE(wValue);///取高8�?br>

两个16位数据（WORD�Q�合�?2位数�?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�c�d��的颜色�?br>COLORREF RGB( BYTE byRed,BYTE byGreen,BYTE byBlue );
例如COLORREF bkcolor = RGB(0x22,0x98,0x34);

从COLORREF�c�d��的颜色值得到RGB三个颜色�?br>BYTE Red = GetRValue(bkcolor); ///得到�U�颜�?br>BYTE Green = GetGValue(bkcolor); ///得到�l�K��?br>BYTE Blue = GetBValue(bkcolor); ///得到兰颜�?/span>

九、注意事��?/strong>
假如需要��用到ConvertBSTRToString此类函数,需要加上头文�gcomutil.h,�q�在setting中加入comsupp.lib或者直接加�?pragma comment( lib, "comsupp.lib" )

李亚 2008-01-12 23:07 发表评论

CString与其他类型的转换----CString字符串�{换箋

李亚 — Sat, 12 Jan 2008 15:00:00 GMT
CString与其他类型的转换
�q�里只是介绍了很常见�Ҏ��,�q�有其他�Ҏ��也可以实现相关的功能!
1、字�W�串与数的�{换：
atof(字符�?>double,int,long),itoa(int->字符�?,ltoa(long int->字符�?
double->CString的方法：CString::Format("%d", &dX);

2、CString to char*
//�l�过�c�d��强制转换�Q�可以将CString�c�d��转换成char*�Q�例如：
CString cStr = "Hello,world!";
char *zStr = (char*)(LPCTSTR)cStr;
当然�Q�这只是最快捷的一�U�方法。因为CString自带一个函数可以将CString对象转换成const char*�Q�也��是LPCTSTR�?br>
3、char* to CString
//char*�c�d��可以直接�l�CString�Q�完成自动�{换，例如�Q?br>char *zStr = "Hello,world!";
CString cStr = zStr;

4、CString to LPCSTR
//��CString转换成LPCSTR�Q�需要获得CString的长度CString cStr=_T("Hello,world!");
int nLen = cStr.GetLength();
LPCSTR lpszBuf = cStr.GetBuffer(nLen);

5、CString to LPSTR
//�q�个和第4个技巧是一��L��Q�例如：
CString cStr = _T("Hello,world!");
int nLen = str.GetLength();
LPSTR lpszBuf = str.GetBuffer(nLen);

李亚 2008-01-12 23:00 发表评论

[转]CString 操作指南

李亚 — Sat, 12 Jan 2008 14:55:00 GMT

CString 是一�U�很有用的数据类型。它们很大程度上��化了MFC中的许多操作�Q��得MFC在做字符串操作的时候方便了很多。不��怎样�Q��用CString有很多特�D�的技巧，特别是对于纯C背景下走出来的程序员来说有点难以学习。这��文章就来讨��些技巧�?br>　　使用CString可以让你对字�W�串的操作更加直截了当。这��文章不是CString的完全手册，但囊括了大部分常见基本问题�?/p>
�q�篇文章包括以下内容�Q?
CString 对象的连�?/span>
格式化字�W�串�Q�包�?int 型�{化�ؓ CString �Q?/span>
CString 型�{化成 int �?/span>
CString 型和 char* �c�d��的相互�{�?/span>
1.char* 转化�?CString
2.CString 转化�?char* 之一�Q��用LPCTSTR强制转化
3.CString 转化�?char* 之二�Q��用CString对象的GetBuffer�Ҏ��
4.CString 转化�?char* 之三: 和控件的接口
5.CString 型�{化成 BSTR 型；
BSTR 型�{化成 CString 型；
VARIANT 型�{化成 CString 型；
载入字符串表资源�Q?
CString 和��时对象；
CString 的效率；
�ȝ��
下面我分别讨论�?/p>
1、CString 对象的连�?/p>
　　能体现出 CString �c�d��方便性特点的一个方面就字符串的�q�接�Q��?CString �c�d��Q�你能很方便地连接两个字�W�串�Q�正如下面的例子�Q?/p>
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、格式化字符�?/p>
　　与其�?sprintf() 函数�?wsprintf() 函数来格式化一个字�W�串�Q�还不如�?CString 对象的Format()�Ҏ��Q?/p>
CString s;s.Format(_T("The total is %d"), total);
　　用这�U�方法的好处是你不用担心用来存放格式化后数据的缓冲区是否��_��大，�q�些工作由CString�c�L��你完成�?br>　　格式化是一�U�把其它不是字符串类型的数据转化为CString�c�d��的最常用技巧，比如�Q�把一个整数�{化成CString�c�d��Q�可用如下方法：

CString s;s.Format(_T("%d"), total);
　　我��L��Ҏ��的字�W�串使用_T()宏，�q�是��Z��让我的代码至��有Unicode的意识，当然�Q�关于Unicode的话题不在这��文章的讨论范围。_T()宏在8位字�W�环境下是如下定义的�Q?/p>
#define _T(x) x // 非Unicode版本�Q�non-Unicode version�Q?br>而在Unicode环境下是如下定义的：

#define _T(x) L##x // Unicode版本�Q�Unicode version�Q?br>所以在Unicode环境下，它的效果��q��当于�Q?/p>
s.Format(L"%d", total);
　　如果你认��Z��的程序可能在Unicode的环境下�q�行�Q�那么开始在意用 Unicode �~�码。比如说�Q�不要用 sizeof() 操作�W�来获得字符串的长度�Q�因为在Unicode环境下就会有2倍的误差。我们可以用一些方法来隐藏Unicode的一些细节，比如在我需要获得字�W�长度的时候，我会用一个叫做DIM的宏�Q�这个宏是在我的dim.h文�g中定义的�Q�我会在我写的所有程序中都包含这个文�Ӟ��

#define DIM(x) ( sizeof((x)) / sizeof((x)[0]) )
　　�q�个宏不仅可以用来解决Unicode的字�W�串长度的问题，也可以用在编译时定义的表��g��Q�它可以获得表格的项敎ͼ�如下�Q?/p>
class Whatever { ... };Whatever data[] = {   { ... },    ...   { ... },};for(int i = 0; i < DIM(data); i++) // 扫描表格��L��匚w��V�?br>　　�q�里要提醒你的就是一定要注意那些在参��C��需要真实字节数的API函数调用�Q�如果你传递字�W�个数给它，它将不能正常工作。如下：
TCHAR data[20];lstrcpyn(data, longstring, sizeof(data) - 1); // WRONG!lstrcpyn(data, longstring, DIM(data) - 1); // RIGHTWriteFile(f, data, DIM(data), &bytesWritten, NULL); // WRONG!WriteFile(f, data, sizeof(data), &bytesWritten, NULL); // RIGHT
造成以上原因是因为lstrcpyn需要一个字�W�个��C��为参敎ͼ�但是WriteFile却需要字节数作�ؓ参数�?br>同样需要注意的是有时候需要写出数据的所有内宏V��如果你仅仅只想写出数据的真实长度，你可能会认�ؓ你应该这样做�Q?/p>
WriteFile(f, data, lstrlen(data), &bytesWritten, NULL); // WRONG
但是在Unicode环境下，它不会正常工作。正��的做法应该是这��P��

WriteFile(f, data, lstrlen(data) * sizeof(TCHAR), &bytesWritten, NULL); // RIGHT
　　因�ؓWriteFile需要的是一个以字节为单位的长度。（可能有些��Z��?#8220;在非Unicode的环境下�q�行�q�行代码�Q�就意味着��L��在做一个多余的�?操作�Q�这样不会降低程序的效率吗？”�q�种��x��是多余的�Q�你必须要了解编译器实际上做了什么，没有哪一个C或C++�~�译器会把这�U�无聊的�?操作留在代码中。在Unicode环境下运行的时候，你也不必担心那个�?操作会降低程序的效率�Q�记住，�q�只是一个左�U�M��位的操作而已�Q�编译器也很乐意��Z��做这�U�替换。）
　　使用_T宏�ƈ不是意味着你已�l�创��Z��一个Unicode的程序，你只是创��Z��一个有Unicode意识的程序而已。如果你在默认的8-bit模式下编译你的程序的话，得到的将是一个普通的8-bit的应用程序（�q�里�?-bit指的只是8位的字符�~�码�Q��ƈ不是�?位的计算机系�l�）�Q�当你在Unicode环境下编译你的程序时�Q�你才会得到一个Unicode的程序。记住，CString �?Unicode 环境下，里面包含的可都是16位的字符哦�?/p>
3、CString 型�{化成 int �?/p>
　　�?CString �c�d��的数据�{化成整数�c�d��最��单的�Ҏ��是使用标准的字�W�串到整数�{换例�E��?br>　　虽然通常你怀疑��用_atoi()函数是一个好的选择�Q�它也很��会是一个正��的选择。如果你准备使用 Unicode 字符�Q�你应该用_ttoi()�Q�它�?ANSI �~�码�pȝ��中被�~�译成_atoi()�Q�而在 Unicode �~�码�pȝ��中编译成_wtoi()。你也可以考虑使用_tcstoul()或者_tcstol()�Q�它们都能把字符串�{化成��L��q�制的长整数�Q�如二进制、八�q�制、十�q�制或十六进�Ӟ��Q�不同点在于前者�{化后的数据是无符��L��Q�unsigned�Q�，而后者相反。看下面的例子：

CString hex = _T("FAB");CString decimal = _T("4011");ASSERT(_tcstoul(hex, 0, 16) == _ttoi(decimal));
4、CString 型和 char* �c�d��的相互�{�?/p>
　　�q�是初学者��?CString 时最常见的问题。有�?C++ 的帮助，很多问题你不需要深入的去考虑它，直接拿来用就行了�Q�但是如果你不能深入了解它的�q�行机制�Q�又会有很多问题让你�q�h��Q�特别是有些看�v来没有问题的代码�Q�却偏偏不能正常工作�?br>比如�Q�你会奇怪�ؓ什么不能写向下面这��L��代码呢：

CString graycat = "Gray" + "Cat";
或者这��P��

CString graycat("Gray" + "Cat");
　　事实上，�~�译器将抱怨上面的�q�些��试。�ؓ什么呢�Q�因为针对CString �?LPCTSTR数据�c�d��的各�U�各��L��l�合�Q?#8220; +” �q�算�W?被定义成一个重载操作符。而不是两�?LPCTSTR 数据�c�d��Q�它是底层数据类型。你不能对基本数据（�?int、char 或�?char*�Q�类型重�?C++ 的运��符。你可以象下面这样做�Q?/p>
CString graycat = CString("Gray") + CString("Cat");
或者这��P��

CString graycat = CString("Gray") + "Cat";
研究一番就会发玎ͼ�“ +”��L��使用在至��有一�?CString 对象和一�?LPCSTR 的场合�?/p>
注意�Q�编写有 Unicode 意识的代码��L��一件好事，比如�Q?/p>
CString graycat = CString(_T("Gray")) + _T("Cat");
�q�将使得你的代码可以直接�U�L��?/p>
char* 转化�?CString

　　现在你有一�?char* �c�d��的数据，或者说一个字�W�串。怎么样创�?CString 对象呢？�q�里有一些例子：

char * p = "This is a test";
或者象下面�q�样更具�?Unicode 意识�Q?/p>
TCHAR * p = _T("This is a test")
�?/p>
LPTSTR p = _T("This is a test");
你可以��用下面�Q意一�U�写法：

CString s = "This is a test"; // 8-bit onlyCString s = _T("This is a test"); // Unicode-awareCString s("This is a test"); // 8-bit onlyCString s(_T("This is a test")); // Unicode-awareCString s = p;CString s(p);
　　用这些方法可以轻村ְ�帔R��字符串或指针转换�?CString。需要注意的是，字符的赋值��L��被拷贝到 CString 对象中去的，所以你可以象下面这��h��作：

TCHAR * p = _T("Gray");CString s(p);p = _T("Cat");s += p;
�l�果字符串肯定是“GrayCat”�?/p>
CString �c�还有几个其它的构造函敎ͼ�但是�q�里我们不考虑它，如果你有兴趣可以自己查看相关文��?/p>
事实上，CString �cȝ��构造函数比我展�C�的要复杂，比如�Q?/p>
CString s = "This is a test";
　　�q�是很草率的�~�码�Q�但是实际上它在 Unicode 环境下能�~�译通过。它在运行时调用构造函数的 MultiByteToWideChar 操作��?8 位字�W�串转换�?16 位字�W�串。不��怎样�Q�如�?char * 指针是网�l�上传输�?8 位数据，�q�种转换是很有用的�?/p>
CString 转化�?char* 之一�Q�强制类型�{换�ؓ LPCTSTR�Q?/p>
　　�q�是一�U�略微硬性的转换�Q�有�?#8220;正确”的做法，��Z��在认识上�q�存在许多�؜乱，正确的��用方法有很多�Q�但错误的��用方法可能与正确的��用方法一样多�?br>　　我们首先要了�?CString 是一�U�很�Ҏ��?C++ 对象�Q�它里面包含了三个��|��一个指向某个数据缓冲区的指针、一个是该缓冲中有效的字�W�记��C��及一个缓冲区长度�?有效字符数的大小可以是从0到该�~�冲最大长度值减1之间的�Q何数�Q�因为字�W�串�l�尾有一个NULL字符�Q�。字�W�记数和�~�冲区长度被巧妙隐藏�?br>　　除非你做一些特�D�的操作�Q�否则你不可能知道给CString对象分配的缓冲区的长度。这��P��即��你获得了�?�~�冲的地址�Q�你也无法更改其中的内容�Q�不能截短字�W�串�Q�也 �l�对没有办法加长它的内容�Q�否则第一旉��׃��看到溢出�?br>　　LPCTSTR 操作�W�（或者更明确地说��是 TCHAR * 操作�W�）�?CString �c�M��被重载了�Q�该操作�W�的定义是返回缓冲区的地址�Q�因此，如果你需要一个指�?CString �?字符串指针的话，可以�q�样做：

CString s("GrayCat");LPCTSTR p = s;
　　它可以正��地�q�行。这是由C语言的强制类型�{化规则实现的。当需要强制类型�{化时�Q�C++规测容许�q�种选择。比如，你可以将�Q��Q�Ҏ��Q�定义�ؓ��某个复�?�Q�有一�Ҏ�Q�Ҏ��Q�进行强制类型�{换后只返回该复数的第一个��Q�Ҏ��Q�也��是其实部）。可以象下面�q�样�Q?/p>
Complex c(1.2f, 4.8f);float realpart = c;
如果(float)操作�W�定义正��的话，那么实部的的值应该是1.2�?br>　　�q�种强制转化适合所有这�U�情况，例如�Q��Q何带�?LPCTSTR �c�d��参数的函数都会强制执行这�U��{换�?于是�Q�你可能有这样一个函敎ͼ�也许在某个你买来的DLL中）�Q?/p>
BOOL DoSomethingCool(LPCTSTR s);
你象下面�q�样调用它：

CString file("c:\\myfiles\\coolstuff")BOOL result = DoSomethingCool(file);
　　它能正确�q�行。因�?DoSomethingCool 函数已经说明了需要一�?LPCTSTR �c�d��的参敎ͼ�因此 LPCTSTR 被应用于该参敎ͼ��?MFC 中就是返回的串地址�?/p>
如果你要格式化字�W�串怎么办呢�Q?/p>
CString graycat("GrayCat");CString s;s.Format("Mew! I love %s", graycat);
　　注意�׃��在可变参数列表中的��|��在函数说明中是以“...”表示的）�q�没有隐含一个强制类型�{换操作符。你会得��C��么结果呢�Q?br>　　一个��o人惊讶的�l�果�Q�我们得到的实际�l�果串是�Q?/p>
"Mew! I love GrayCat"�?br>　　因�ؓ MFC 的设计者们在设�?CString 数据�c�d��旉��常小心， CString �c�d��表达式求值后指向了字�W�串�Q�所以这里看不到��M��?Format �?sprintf 中的强制�c�d��转换�Q�你仍然可以得到正确的行为。描�q?CString 的附加数据实际上�?CString 名义地址之后�?br>　　有一件事情你是不能做的，那就是修改字�W�串。比如，你可能会��试�?#8220;,”代替“.”�Q�不要做�q�样的，如果你在乎国际化问题�Q�你应该使用十进制�{换的 National Language Support �Ҏ��，�Q�，下面是个��单的例子�Q?/p>
CString v("1.00"); // 货币金额�Q�两位小数LPCTSTR p = v;p[lstrlen(p) - 3] = '','';
　　�q�时�~�译器会报错�Q�因��Z��赋��g��一个常量串。如果你做如下尝试，�~�译器也会错�Q?/p>
strcat(p, "each");
　　因�ؓ strcat 的第一个参数应该是 LPTSTR �c�d��的数据，而你却给了一�?LPCTSTR�?/p>
　　不要试图钻这个错误消息的牛角��，�q�只会��你自己陷入麻烦！

　　原因是缓冲有一个计敎ͼ�它是不可存取的（它位�?CString 地址之下的一个隐藏区域）�Q�如果你改变�q�个�Ԍ��~�冲中的字符计数不会反映所做的修改。此外，如果字符串长度恰好是该字�W�串物理限制的长度（梢后�q�会讲到�q�个问题�Q�，那么扩展该字�W�串��改写缓冲以外的��M��数据�Q�那是你无权�q�行写操作的内存�Q�不对吗�Q�）�Q�你会毁换坏不属于你的内存。这是应用程序真正的��M��处方�?/p>
CString转化成char* 之二�Q��?CString 对象�?GetBuffer �Ҏ��Q?/p>
　　如果你需要修�?CString 中的内容�Q�它有一个特�D�的�Ҏ��可以使用�Q�那��是 GetBuffer�Q�它的作用是�q�回一个可写的�~�冲指针�?如果你只是打��修改字�W�或者截短字�W�串�Q�你完全可以�q�样做：

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();
　　�q�是 GetBuffer 的第一�U�用法，也是最��单的一�U�，不用�l�它传递参敎ͼ�它��用默认�?0�Q�意思是�Q?#8220;�l�我�q�个字符串的指针�Q�我保证不加长它”。当你调�?ReleaseBuffer �Ӟ��字符串的实际长度会被重新计算�Q�然后存�?CString 对象中�?br>　　必须��一点，�?GetBuffer �?ReleaseBuffer 之间�q�个范围�Q�一定不能��用你要操作的�q�个�~�冲�?CString 对象的�Q何方法。因�?ReleaseBuffer 被调用之前，�?CString 对象的完整性得不到保障。研�I�以下代码：

CString s(...);LPTSTR p = s.GetBuffer();//... �q�个指针 p 发生了很多事情int n = s.GetLength(); // 很糟D!!!!! 有可能给出错误的�{�案!!!s.TrimRight(); // 很糟!!!!! 不能保证能正常工�?!!!s.ReleaseBuffer(); // 现在应该 OKint m = s.GetLength(); // �q�个�l�果可以保证是正��的。s.TrimRight(); // ��正常工作�?br>　　假设你想增加字符串的长度�Q�你首先要知道这个字�W�串可能会有多长�Q�好比是声明字符串数�l�的时候用�Q?/p>
char buffer[1024];
表示 1024 个字�W�空间��以让你做��M��惛_��得事情。在 CString 中与之意义相�{�的表示法：

LPTSTR p = s.GetBuffer(1024);
　　调用�q�个函数后，你不仅获得了字符串缓冲区的指针，而且同时�q�获得了长度臛_��?1024 个字�W�的�I�间�Q�注意，我说的是“字符”�Q�而不�?#8220;字节”�Q�因�?CString 是以隐含方式感知 Unicode 的）�?br>　　同时�Q�还应该注意的是�Q�如果你有一个常量串指针�Q�这个串本��n的��D��存储在只��d��存中�Q�如果试囑֭�储它�Q�即使你已经调用�?GetBuffer �Q��ƈ获得一个只��d��存的指针�Q�存入操作会��p�|�Q��ƈ报告存取错误。我没有�?CString 上证明这一点，但我看到�q�大把的 C �E�序员经常犯�q�个错误�?br>　　C �E�序员有一个通病是分配一个固定长度的�~�冲�Q�对它进�?sprintf 操作�Q�然后将它赋值给一�?CString�Q?/p>
char buffer[256];sprintf(buffer, "%......", args, ...); // ... 部分省略许多�l�节CString s = buffer;
虽然更好的�Ş式可以这么做�Q?/p>
CString s;s.Format(_T("%...."), args, ...);
如果你的字符串长度万一��过 256 个字�W�的时候，不会破坏堆栈�?/p>
　　另外一个常见的错误是：既然固定大小的内存不工作�Q�那么就采用动态分配字节，�q�种做法弊端更大�Q?/p>
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;
它可以能被简单地写成�Q?/p>
CString s;s.Format(_T("%s is equal to %s, valid data"), parm1, parm2);
　　需要注�?sprintf 例子都不�?Unicode ��q�A的，��管你可以��?tsprintf 以及�?_T() 来包围格式化字符�Ԍ��但是基本思�\仍然是在走弯路，�q�这样很�Ҏ��出错�?/p>
CString to char * 之三�Q�和控�g的接口；

　　我们�l�常需要把一�?CString 的��g��递给一个控�Ӟ��比如�Q�CTreeCtrl。MFC为我们提供了很多便利来重载这个操作，但是在大多数情况下，你��?#8220;原始”形式的更斎ͼ�因此需要将墨某个串指针存储�?TVINSERTITEMSTRUCT �l�构�?TVITEM 成员中。如下：

TVINSERTITEMSTRUCT tvi;CString s;// ... 为s赋一些倹{��tvi.item.pszText = s; // Compiler yells at you here// ... 填写tvi的其他域HTREEITEM ti = c_MyTree.InsertItem(&tvi);
　　��Z��么编译器会报错呢�Q�明明看��h��很完��的用法啊！但是事实上如果你看看 TVITEM �l�构的定义你��׃��明白�Q�在 TVITEM �l�构�?pszText 成员的声明如下：

LPTSTR pszText;int cchTextMax;
　　因此�Q�赋��g��是赋�l�一�?LPCTSTR �c�d��的变量，而且�~�译器无法知道如何将赋��D��句右边强制�{换成 LPCTSTR。好吧，你说�Q�那我就�Ҏ��q�样�Q?/p>
tvi.item.pszText = (LPCTSTR)s; //�~�译器依然会报错�?br>　　�~�译器之所以依然报错是因�ؓ你试图把一�?LPCTSTR �c�d��的变量赋值给一�?LPTSTR �c�d��的变量，�q�种操作在C或C++中是被禁止的。你不能用这�U�方�?来滥用常量指针与非常量指针概念，否则�Q�会��Cؕ�~�译器的优化机制�Q��之不知如何优化你的程序。比如，如果你这么做�Q?/p>
const int i = ...;//... do lots of stuff... = a[i]; // usage 1// ... lots more stuff... = a[i]; // usage 2
　　那么�Q�编译器会以为既�?i �?const �Q�所�?usage1和usage2的值是相同的，�q�且它甚臌��事先计算�?usage1 处的 a[i] 的地址�Q�然后保留着在后面的 usage2 处��用，而不是重新计��。如果你按如下方式写的话�Q?/p>
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] 的位�|�也是常量，�q�样间接地破坏了先前的假设。因此，你的�E�序��会�?debug �~�译模式�Q�没有优化）�?release �~�译模式�Q�完全优化）中反映出不同的行为，�q�种情况可不好，所以当你试图把指向 i 的指针赋值给一�?可修改的引用�Ӟ��会被�~�译器诊断�ؓ�q�是一�U�伪造。这��是��Z��么（LPCTSTR�Q�强制类型�{化不起作用的原因�?br>　　��Z��么不把该成员声明�?LPCTSTR �c�d��呢？因�ؓ�q�个�l�构被用于读写控件。当你向控�g写数据时�Q�文本指针实际上被当�?LPCTSTR�Q�而当你从控�g��L��?�Ӟ��你必��L��一个可写的字符丌Ӏ�这个结构无法区分它是用来读�q�是用来写�?/p>
因此�Q�你会常常在我的代码中看到如下的用法�Q?/p>
tvi.item.pszText = (LPTSTR)(LPCTSTR)s;
　　它把 CString 强制�c�d��转化�?LPCTSTR�Q�也��是说先获得改字�W�串的地址�Q�然后再强制�c�d��转化�?LPTSTR�Q�以便可以对之进行赋值操作�?注意�q�只有在使用 Set �?Insert 之类的方法才有效�Q�如果你试图获取数据�Q�则不能�q�么做�?br>　　如果你打��获取存储在控�g中的数据�Q�则�Ҏ��E�有不同�Q�例如，�Ҏ��?CTreeCtrl 使用 GetItem �Ҏ��Q�我惌��取项目的文本。我知道�q�些文本的长度不会超�q?MY_LIMIT�Q�因此我可以�q�样写：

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 �Ҏ��都适用�Q�但是�ƈ不需要这么做�Q�因为所有的�c?Set �Ҏ��Q�包�?Insert�Ҏ��Q�不会改变字�W�串的内宏V��但是当你需要写 CString 对象�Ӟ��必须保证�~�冲是可写的�Q�这正是 GetBuffer 所做的事情。再�ơ强调：一旦做了一��?GetBuffer 调用�Q�那么在调用 ReleaseBuffer 之前不要对这�?CString 对象做�Q何操作�?/p>
5、CString 型�{化成 BSTR �?/p>
　　当我们��?ActiveX 控�g�~�程�Ӟ��l�常需要用到将某个��D��C�成 BSTR �c�d��。BSTR 是一�U�记数字�W�串�Q�Intel�q�_��上的宽字�W�串�Q�Unicode�Q�，�q�且可以包含嵌入�?NULL 字符�?/p>
你可以调�?CString 对象�?AllocSysString �Ҏ��?CString 转化�?BSTR�Q?/p>
CString s;s = ... ; // whateverBSTR b = s.AllocSysString();
　　现在指针 b 指向的就是一个新分配�?BSTR 对象�Q�该对象�?CString 的一个拷贝，包含�l�结 NULL字符。现在你可以��它传递给��M��需�?BSTR 的接口。通常�Q�BSTR 由接收它的组件来释放�Q�如果你需要自己释�?BSTR 的话�Q�可以这么做�Q?/p>
::SysFreeString(b);
　　对于如何表示传递给 ActiveX 控�g的字�W�串�Q�在微��Y内部曾一度争��Z��休，最�?Visual Basic 的�h占了上风�Q�BSTR�Q?#8220;Basic String”的首字母�~�写�Q�就是这��Z��论的�l�果�?/p>
6、BSTR 型�{化成 CString �?/p>
　　�׃�� BSTR 是记�?Unicode 字符�Ԍ��你可以用标准转换�Ҏ��来创�?8 位的 CString。实际上�Q�这�?CString 内徏的功能。在 CString �?有特�D�的构造函数可以把 ANSI 转化�?Unicode�Q�也可以把Unicode 转化�?ANSI。你同样可以�?VARIANT �c�d��的变量中获得 BSTR �c�d��的字�W�串�Q�VARIANT �c�d��?由各�U?COM �?Automation (自动�?调用�q�回的类型�?/p>
例如�Q�在一个ANSI�E�序中：

BSTR b;b = ...; // whateverCString s(b == NULL ? L"" : b)
　　对于单个�?BSTR 串来��_��q�种用法可以工作得很好，�q�是因�ؓ CString 有一个特�D�的构造函��C��LPCWSTR�Q�BSTR正是�q�种�c�d��Q?为参敎ͼ��q�将它�{化成 ANSI �c�d��。专门检查是必须的，因�ؓ BSTR 可能为空��|��?CString 的构造函数对�?NULL 值情况考虑的不是很周到�Q�（感谢 Brian Ross 指出�q�一�?�Q�。这�U�用法也只能处理包含 NUL �l�结字符的单字符�Ԍ��如果要�{化含有多�?NULL 字符 �Ԍ��你得额外做一些工作才行。在 CString 中内嵌的 NULL 字符通常表现不尽如�h意，应该��量避免�?br>　　�Ҏ�� C/C++ 规则�Q�如果你有一�?LPWSTR�Q�那么它别无选择�Q�只能和 LPCWSTR 参数匚w��?/p>
�?Unicode 模式下，它的构造函数是�Q?/p>
CString::CString(LPCTSTR);
正如上面所表示的，�?ANSI 模式下，它有一个特�D�的构造函敎ͼ�

CString::CString(LPCWSTR);
　　它会调用一个内部的函数��?Unicode 字符串�{换成 ANSI 字符丌Ӏ�（在Unicode模式下，有一个专门的构造函敎ͼ�该函数有一个参数是LPCSTR�c�d��——一�?�?ANSI 字符�?指针�Q�该函数��它加宽�?Unicode 的字�W�串�Q�）再次��Q�一定要��?BSTR 的值是否�ؓ NULL�?br>　　另外�q�有一个问题，正如上文提到的：BSTRs可以含有多个内嵌的NULL字符�Q�但�?CString 的构造函数只能处理某个串中单�?NULL 字符�?也就是说�Q�如果串中含有嵌入的 NUL字节�Q�CString ��会计算出错误的串长度。你必须自己处理它。如果你看看 strcore.cpp 中的构造函敎ͼ�你会发现它们都调用了lstrlen�Q�也��是计算字符串的长度�?br>　　注意�?Unicode �?ANSI 的�{换��用带专门参数�?::WideCharToMultiByte�Q�如果你不想使用�q�种默认的�{换方式，则必��ȝ��写自��q��转化代码�?br>　　如果你在 UNICODE 模式下编译代码，你可以简单地写成�Q?/p>

CString convert(BSTR b){    if(b == NULL)        return CString(_T(""));    CString s(b); // in UNICODE mode    return s;}
　　如果�?ANSI 模式�Q�则需要更复杂的过�E�来转换。注意这个代码��用与 ::WideCharToMultiByte 相同的参数倹{��所以你只能在想要改变这些参数进行�{换时使用该技术。例如，指定不同的默认字�W�，不同的标志集�{��?
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 位字�W�集�?Unicode 字符时会发生什么，因�ؓ我指定了::WideCharToMultiByte 的最后两个参��Cؓ NULL。这��是你可能需要改变的地方�?

7、VARIANT 型�{化成 CString �?/p>
　　事实上，我从来没有这么做�q�，因�ؓ我没有用 COM/OLE/ActiveX �~�写�q�程序。但是我在microsoft.public.vc.mfc 新闻�l�上看到�?Robert Quirk 的一��帖子谈��C��q�种转化�Q�我觉得把他的文章包含在我的文章里是不太好的做法�Q�所以在�q�里多做一些解释和演示。如果和他的文章有相孛的地方可能是我的疏忽�?br>　　VARIANT �c�d��l�常用来�l?COM 对象传递参敎ͼ�或者接收从 COM 对象�q�回的倹{��你也能自己�~�写�q�回 VARIANT �c�d��的方法，函数�q�回什么类�?依赖可能�Q��ƈ且常常）�Ҏ��的输入参敎ͼ�比如�Q�在自动化操作中�Q�依赖与你调用哪个方法。IDispatch::Invoke 可能�q�回�Q�通过其一个参敎ͼ�一�?包含有BYTE、WORD、float、double、date、BSTR �{�等 VARIANT �c�d��的结果，�Q�详�?MSDN 上的 VARIANT �l�构的定义）。在下面的例子中�Q�假�?�c�d��是一个BSTR的变体，也就是说在串中的值是通过 bsrtVal 来引用，其优�Ҏ��?ANSI 应用中，有一个构造函��C��?LPCWCHAR 引用的��D�{换�ؓ一�?CString�Q�见 BSTR-to-CString 部分�Q�。在 Unicode 模式中，��成为标准的 CString 构造函敎ͼ�参见对缺�?:WideCharToMultiByte 转换的告诫，以及你觉得是否可以接受（大多数情况下�Q�你会满意的�Q��?br>VARIANT vaData;vaData = m_com.YourMethodHere();ASSERT(vaData.vt == VT_BSTR);CString strData(vaData.bstrVal);
你还可以�Ҏ�� vt 域的不同来徏立更通用的�{换例�E�。�ؓ此你可能会考虑�Q?/p>

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;       ... 剩下的类型�{换由读者自己完�?nbsp;      default:          ASSERT(FALSE); // unknown VARIANT type (this ASSERT is optional)          return CString("");      } /* vt */}
8、蝲入字�W�串表资�?/p>
　　如果你想创徏一个容易进行语�a�版本�U�L��的应用程序，你就不能在你的源代码中直接包含本土语�a�字符�?�Q�下面这些例子我用的语言都是��p��Q�因为我的本土语是英语）�Q�比如下面这�U�写法就很糟�Q?br>CString s = "There is an error";
　　你应该把你所有特定语�a�的字�W�串单独摆放�Q�调试信息、在发布版本中不出现的信息除外）。这意味着向下面这样写比较好：

s.Format(_T("%d - %s"), code, text);
　　在你的程序中�Q�文字字�W�串不是语言敏感的。不��怎样�Q�你必须很小心，不要使用下面�q�样的串�Q?/p>
// fmt is "Error in %s file %s"http:// readorwrite is "reading" or "writing"s.Format(fmt, readorwrite, filename);
　　�q�是我的切��n体会。在我的�W�一个国际化的应用程序中我犯了这个错误，��管我懂徯��Q�知道在徯��的语法中动词攑֜�句子的最后面�Q�我们的德国斚w��的发行�h�q�是苦苦的抱怨他们不得不提取那些不可思议的�d语错误提�C�Z��息然后重新格式化以让它们能正常工作。比较好的办法（也是我现在��用的办法�Q�是使用两个字符�Ԍ��一个用于读�Q�一个用于写�Q�在使用时加载合适的版本�Q��得它们对字符串参数是非敏感的。也��是说加载整个格式，而不是加载串“reading”�Q?#8220;writing”�Q?/p>
// fmt is "Error in reading file %s"http:// "Error in writing file %s"s.Format(fmt, filename);
　　一定要注意�Q�如果你有好几个地方需要替换，你一定要保证替换后句子的�l�构不会出现问题�Q�比如在��p��中，可以是主�?宾语�Q�主�?谓语�Q�动�?宾语的结构等�{��?br>　　在这里，我们�q�不讨论 FormatMessage�Q�其实它�?sprintf/Format �q�要有优势，但是不太�Ҏ��和CString �l�合使用。解册��U�问题的办法��是我们按照参数出现在参数表中的位置�l�参数取名字�Q�这样在你输出的时候就不会把他们的位置排错了�?br>　　接下来我们讨论我们这些独立的字符串放在什么地斏V��我们可以把字符串的值放入资源文件中的一个称�?STRINGTABLE 的段中。过�E�如下：首先使用 Visual Studio 的资源编辑器创徏一个字�W�串�Q�然后给每一个字�W�串取一个ID�Q�一般我们给它取名字都以 IDS_开头。所以如果你有一个信息，你可以创��Z��个字�W�串资源然后取名�?IDS_READING_FILE�Q�另外一个就取名�?IDS_WRITING_FILE。它们以下面的�Ş式出现在你的 .rc 文�g中：

STRINGTABLEIDS_READING_FILE "Reading file %s"IDS_WRITING_FILE "Writing file %s"END
注意�Q�这些资源都�?Unicode 的格式保存，不管你是在什么环境下�~�译。他们在Win9x�pȝ��上也是以Unicode 的�Ş式存在，虽然 Win9x 不能真正处理 Unicode�?br>然后你可以这样��用这些资源：
// 在��用资源串表之前，�E�序是这样写的：

   CString fmt;      if(...)        fmt = "Reading file %s";     else       fmt = "Writing file %s"; ...    // much later CString s; s.Format(fmt, filename);
// 使用资源串表之后�Q�程序这样写�Q?
    CString fmt;        if(...)           fmt.LoadString(IDS_READING_FILE);        else           fmt.LoadString(DS_WRITING_FILE);    ...      // much later    CString s;    s.Format(fmt, filename);
　　现在�Q�你的代码可以移植到��M��语言中去。LoadString �Ҏ��需要一个字�W�串资源�?ID 作�ؓ参数�Q�然后它�?STRINGTABLE 中取出它对应的字�W�串�Q�赋值给 CString 对象�?CString 对象的构造函数还有一个更加聪明的特征可以��?STRINGTABLE 的��用。这个用法在 CString::CString 的文��中没有指出�Q�但是在构造函数的�C�Z��E�序中��用了。（��Z��么这个特性没有成为正式文��的一部分�Q�而是攑֜�了一个例子中�Q�我��C��得了�Q�）——【译者注�Q�从�q�句话看�Q�作者可能是CString的设计者。其实前面还有一句类似的话。说他没有对使用GetBuffer(0)获得的指针指向的地址是否可读做有效性检�?】。这个特征就是：如果你将一个字�W�串资源的ID强制�c�d��转换�?LPCTSTR�Q�将会隐含调�?LoadString。因此，下面两个构造字�W�串的例子具有相同的效果�Q�而且�?ASSERT 在debug模式下不会被触发�Q?br>CString s;s.LoadString(IDS_WHATEVER);CString t( (LPCTSTR)IDS_WHATEVER );ASSERT(s == t);//不会被触发，说明s和t是相同的�?br>　　现在�Q�你可能会想�Q�这怎么可能工作呢？我们怎么能把 STRINGTABLE ID 转化成一个指针呢�Q�很��单：所有的字符�?ID 都在1~65535�q�个范围内，也就是说�Q�它所有的高位都是0�Q�而我们在�E�序中所使用的指针是不可能小�?5535的，因�ؓ�E�序的低 64K 内存永远也不可能存在的，如果你试图访�?x00000000�?x0000FFFF之间的内存，��会引发一个内存越界错误。所以说1~65535的��g��可能是一个内存地址�Q�所以我们可以用�q�些值来作�ؓ字符串资源的ID�?br>　　我們֐�于��?MAKEINTRESOURCE 宏显式地做这�U��{换。我认�ؓ�q�样可以让代码更加易于阅诅R��这是个只适合�?MFC 中��用的标准宏。你要记住，大多数的�Ҏ��卛_��以接受一�?UINT 型的参数�Q�也可以接受一�?LPCTSTR 型的参数�Q�这是依�?C++ 的重载功能做到的。C++重蝲函数带来�?弊端��是造成所有的强制�c�d��转化都需要显�C�声明。同��P��你也可以�l�很多种�l�构只传递一个资源名�?/p>
CString s;s.LoadString(IDS_WHATEVER);CString t( MAKEINTRESOURCE(IDS_WHATEVER));ASSERT(s == t);
　　告诉你吧�Q�我不仅只是在这里鼓吹，事实上我也是�q�么做的。在我的代码中，你几乎不可能扑ֈ�一个字�W�串�Q�当�Ӟ��那些只是偶然在调试中出现的或者和语言无关的字�W�串除外�?/p>
9、CString 和��时对�?/p>
　　�q�是出现�?microsoft.public.vc.mfc 新闻�l�中的一个小问题�Q�我��单的提一下，�q�个问题是有个程序员需要往注册表中写入一个字�W�串�Q�他写道�Q?br>　　我试着�?RegSetValueEx() 讄��一个注册表键的��|��但是它的�l�果��L��令我困惑。当我用char[]声明一个变量时它能正常工作�Q�但是当我用 CString 的时候，��L��得到一些垃圾："ÝÝÝÝ...ÝÝÝÝÝÝ"��Z��认是不是我�?CString 数据��Z��问题�Q�我试着�?GetBuffer�Q�然后强制�{化成 char*�Q�LPCSTR。GetBuffer �q�回的值是正确的，但是当我把它赋值给 char* �Ӟ��它就变成垃圾了。以下是我的�E�序�D�：

char* szName = GetName().GetBuffer(20);RegSetValueEx(hKey, "Name", 0, REG_SZ,              (CONST BYTE *) szName,             strlen (szName + 1));
�q�个 Name 字符串的长度��于 20�Q�所以我不认为是 GetBuffer 的参数的问题�?/p>
真让人困惑，请帮帮我�?/p>
亲爱�?Frustrated�Q?/p>
你犯了一个相当微妙的错误�Q�聪明反被聪明误�Q�正��的代码应该象下面这��P��

CString Name = GetName();RegSetValueEx(hKey, _T("Name"), 0, REG_SZ,                     (CONST BYTE *) (LPCTSTR)Name,                    (Name.GetLength() + 1) * sizeof(TCHAR));
　　��Z��么我写的代码能行而你写的��有问题呢？主要是因为当你调�?GetName 时返回的 CString 对象是一个��时对象。参见：《C++ Reference manual�?#167;12.2
　　在一些环境中�Q�编译器有必要创��Z��个��时对象，�q�样引入临时对象是依赖于实现的。如果编译器引入的这个��时对象所属的�c�L��构造函数的话，�~�译器要��保�q�个�cȝ��构造函数被调用。同��L��Q�如果这个类声明有析构函数的话，也要保证�q�个临时对象的析构函数被调用�?br>　　�~�译器必��M��证这个��时对象被销毁了。被销毁的��切地点依赖于实�?....�q�个析构函数必须在退出创��临时对象的范围之前被调用�?br>　　大部分的�~�译器是�q�样设计的：在��时对象被创徏的代码的下一个执行步骤处隐含调用�q�个临时对象的析构函敎ͼ�实现��h��Q�一般都是在下一个分号处。因此，�q�个 CString 对象�?GetBuffer 调用之后��p��析构了（��Z��提一句，你没有理��q�� GetBuffer 函数传递一个参敎ͼ�而且没有使用ReleaseBuffer 也是不对的）。所�?GetBuffer 本来�q�回的是指向�q�个临时对象中字�W�串的地址的指针，但是当这个��时对象被析构后，�q�块内存��p��释放了。然�?MFC 的调试内存分配器会重��Cؓ�q�块内存全部填上 0xDD�Q�显�C�出来刚好就�?#8220;Ý”�W�号。在�q�个时候你向注册表中写数据�Q�字�W�串的内容当然全被破坏了�?br>　　我们不应该立��x��q�个临时对象转化�?char* �c�d��Q�应该先把它保存��C��?CString 对象中，�q�意味着把��时对象复制了一份，所以当临时�?CString 对象被析构了之后�Q�这�?CString 对象中的��g��然保存着。这个时候再向注册表中写数据��没有问题了�?br>　　此外�Q�我的代码是��h�� Unicode 意识的。那个操作注册表的函数需要一个字节大��，使用lstrlen(Name+1) 得到的实际结果对�?Unicode 字符来说�?ANSI 字符要小一半，而且它也不能从这个字�W�串的第二个字符起开始计��，也许你的本意�?lstrlen(Name) + 1�Q�OK�Q�我承认�Q�我也犯了同��L��错误�Q�）。不论如何，�?Unicode 模式下，所有的字符都是2个字节大��，我们需要处理这个问题。微软的文档令�h惊讶地对此保持缄默：REG_SZ 的值究竟是以字节计��还是以字符计算呢？我们假设它指的是以字节�ؓ单位计算�Q�你需要对你的代码做一些修�Ҏ��计算�q�个字符串所含有的字节大��?/p>
10、CString 的效�?/p>
　　CString 的一个问题是它确实掩藏了一些低效率的东�ѝ��从另外一个方面讲�Q�它也确实可以被实现得更加高效，你可能会说下面的代码�Q?br>CString s = SomeCString1;s += SomeCString2;s += SomeCString3;s += ",";s += SomeCString4;
比�v下面的代码来�Q�效率要低多了：

char s[1024];lstrcpy(s, SomeString1);lstrcat(s, SomeString2);lstrcat(s, SomeString 3);lstrcat(s, ",");lstrcat(s, SomeString4);
　　��M��Q�你可能会想�Q�首先，它�ؓ SomeCString1 分配一块内存，然后�?SomeCString1 复制到里面，然后发现它要做一个连接，则重新分配一块新的��够大的内存，大到能够放下当前的字�W�串加上SomeCString2�Q�把内容复制到这块内�?�Q�然后把 SomeCString2 �q�接到后面，然后释放�W�一块内存，�q�把指针重新指向新内存。然后�ؓ每个字符串重复这个过�E�。把�q?4 个字�W�串�q�接��h��效率多低啊。事实上�Q�在很多情况下根本就不需要复制源字符�Ԍ��?+= 操作�W�左边的字符�Ԍ��?br>　　�?VC++6.0 中，Release 模式下，所有的 CString 中的�~�存都是按预定义量子分配的。所谓量子，即确定�ؓ 64�?28�?56 或�?512 字节。这意味着除非字符串非帔R��Q�连接字�W�串的操作实际上��是 strcat �l�过优化后的版本�Q�因为它知道本地的字�W�串应该在什么地方结束，所以不需要寻扑֭��W�串的结��；只需要把内存中的数据拯��到指定的地方卛_��Q�加上重新计��字�W�串的长度。所以它的执行效率和�U?C 的代码是一��L��Q�但是它更容易写、更�Ҏ��l�护和更�Ҏ��理解�?br>　　如果你还是不能确定究竟发生了怎样的过�E�，��L��?CString 的源代码�Q�strcore.cpp�Q�在�?vc98的安装目录的 mfc\src 子目录中。看�?ConcatInPlace �Ҏ��Q�它被在所有的 += 操作�W�中调用�?/p>
啊哈�Q�难�?CString 真的�q�么"高效"吗？比如�Q�如果我创徏

CString cat("Mew!");
　　然后我�ƈ不是得到了一个高效的、精��?个字节大��的�~�冲区（4个字�W�加一个结束字�W�）�Q�系�l�将�l�我分配64个字节，而其�?9个字节都被浪费了�?br>　　如果你也是这么想的话�Q�那么就请准备好接受再教育吧。可能在某个地方某个人给你讲�q�尽量��用少的空间是件好事情。不错，�q�种说法的确正确�Q�但是他忽略了事实中一个很重要的方面�?br>　　如果你编写的是运行在16K EPROMs下的嵌入式程序的话，你有理由��量��用空��_��在这�U�环境下�Q�它能��你的�E�序更健壮。但是在 500MHz, 256MB的机器上�?Windows �E�序�Q�如果你�q�是�q�么做，它只会比你认为的“低效”的代码运行得更糟�?br>　　举例来说。字�W�串的大��被认�ؓ是媄响效率的首要因素�Q��字符串尽可能��可以提高效率，反之则降低效率，�q�是大家一贯的��x��。但是这�U�想法是不对的，�_��的内存分配的后果要在�E�序�q�行了好几个��时后才能体现得出来�Q�那�Ӟ��E�序的堆中将充满��片的内存，它们太小以至于不能用来做��M��事，但是他们增加了你�E�序的内存用量，增加了内存页面交换的�ơ数�Q�当��面交换的次数增加到�pȝ��能够忍受的上限，�pȝ��则会��Z��的程序分配更多的��面�Q�直��C��的程序占用了所有的可用内存。由此可见，虽然内存��片是决定效率的�ơ要因素�Q�但正是�q�些因素实际控制了系�l�的行�ؓ�Q�最�l�，它损害了�pȝ��的可靠性，�q�是令�h无法接受的�?br>　　��C��Q�在 debug 模式下，内存往往是精��分配的�Q�这是�ؓ了更好的排错�?br>　　假设你的应用�E�序通常需要连�l�工作好几个月。比如，我常打开 VC++�Q�Word�Q�PowerPoint�Q�Frontpage�Q�Outlook Express�Q�Forté Agent�Q�Internet Explorer和其它的一些程序，而且通常不关闭它们。我曄��夜以�l�日地连�l�用 PowerPoint 工作了好几天�Q�反之，如果你不�q怸�得不使用�?Adobe FrameMaker �q�样的程序的话，你将会体会到可靠性的重要�Q�这个程序机会每天都要崩�?~6�ơ，每次都是因�ؓ用完了所有的�I�间�q�填满我所有的交换��面�Q�。所以精��内存分配是不可取的�Q�它会危及到�pȝ��的可靠性，�q�引起应用程序崩溃�?br>　　按量子的倍数为字�W�串分配内存�Q�内存分配器��可以回收用�q�的内存块，通常�q�些回收的内存块马上��可以被其它�?CString 对象重新用到�Q�这样就可以保证��片最��。分配器的功能加��Z��Q�应用程序用到的内存��p��可能保持最��，�q�样的程序就可以�q�行几个星期或几个月而不出现问题�?br>　　题外话：很多�q�以前，我们�?CMU 写一个交互式�pȝ��的时候，一些对内存分配器的研究昄��出它往往产生很多内存��片。Jim Mitchell�Q�现在他�?Sun Microsystems 工作�Q�那时侯他创造了一�U�内存分配器�Q�它保留了一个内存分配状�늚��q�行时统计表�Q�这�U�技术和当时的主��分配器所用的技术都不同�Q�且较�ؓ领先。当一个内存块需要被分割得比某一个值小的话�Q�他�q�不分割它，因此可以避免产生太多��到什么事都干不了的内存碎片。事实上他在内存分配器中使用了一个��Q动指针，他认为：与其让指令做长时间的存取内存操作�Q�还不如��单的忽略那些太小的内存块而只做一些��Q动指针的操作。（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.�Q�他是对的�?br>　　永远不要认�ؓ所谓的“最优化”是徏立在每一行代码都高速且节省内存的基��上的�Q�事实上�Q�高速且节省内存应该是在一个应用程序的整体水��^上考虑的。在软�g的整体水�q�上�Q�只使用最��内存的字符串分配策略可能是最�p�糕的一�U�方法�?br>　　如果你认��Z��化是你在每一行代码上做的那些努力的话�Q�你应该想一惻I��在每一行代码中做的优化很少能真正�v作用。你可以看我的另一��关于优化问题的文章《Your Worst Enemy for some thought-provoking ideas》�?br>　　��C��Q?= �q�算�W�只是一�U�特例，如果你写成下面这��P��

CString s = SomeCString1 + SomeCString2 + SomeCString3 + "," + SomeCString4;
则每一�?+ 的应用会造成一个新的字�W�串被创建和一�ơ复制操作�?/p>
�ȝ��

　　以上是��?CString 的一些技巧。我每天写程序的时候都会用到这些。CString �q�不是一�U�很难��用的�c�，但是 MFC 没有很明昄��指出�q�些特征�Q�需要你自己��L��索、去发现�?

李亚 2008-01-12 22:55 发表评论

[转] 深入探讨MFC消息循环和消息�܇

李亚 — Mon, 17 Dec 2007 12:28:00 GMT

深入探讨MFC消息循环和消息�܇

作者：周焱

�?先，应该清楚MFC的消息��@�?::GetMessage,::PeekMessage)�Q�消息�܇(CWinThread::PumpMessage)�?MFC的消息在�H�口之间的�\由是两�g不同的事情。在MFC的应用程序中(应用�E�序�c�d��于CWinThread�l�承)�Q�必��要有一个消息��@环，他的作用是从应用�E�序的消息队列中��d��消息�Q��ƈ把它�z�N��出�?::DispatchMessage)。而消息�\由是指消息派送出��M��后，�pȝ��(USER32.DLL) 把消息投递到哪个�H�口�Q�以及以后消息在�H�口之间的传递是怎样的�?/font>

消息分�ؓ队列消息(�q�入�U�程的消息队�? 和非队列消息(不进入线�E�的消息队列)。对于队列消息，最常见的是鼠标和键盘触发的消息�Q�例如WM_MOUSERMOVE,WM_CHAR�{�消息；�q�有�?如：WM_PAINT、WM_TIMER和WM_QUIT。当鼠标、键盘事件被触发后，相应的鼠标或键盘驱动�E�序��׃��把这些事件�{换成相应的消息，然后�?送到�pȝ��消息队列�Q�由Windows�pȝ��负责把消息加入到相应�U�程的消息队列中�Q�于是就有了消息循环(从消息队列中��d��q�派送消�?。还有一�U�是非队列消息，他绕�q�系�l�队列和消息队列�Q�直接将消息发送到�H�口�q�程。例�?当用��h��z�M��个窗口系�l�发送WM_ACTIVATE, WM_SETFOCUS, and WM_SETCURSOR。创建窗口时发送WM_CREATE消息。在后面你将看到�Q�MS�q�么设计是很有道理的�Q�以及他的整套实现机制�?/p>
�q�里讲述MFC的消息��@环，消息��c��先看看�E�序启动�Ӟ��怎么�q�入消息循环的：
_tWinMain ->AfxWinMain ->AfxWinInit ->CWinThread::InitApplication ->CWinThread::InitInstance ->CWinThread::Run

非对话框�E�序的消息��@环的事情都从�q�CWinThread的一Run开�?..

�W�一部分�Q�非对话框程序的消息循环机制�?/strong>

//thrdcore.cpp
// main running routine until thread exits
int CWinThread::Run()
{
ASSERT_VALID(this);

// for tracking the idle time state
BOOL bIdle = TRUE;
LONG lIdleCount = 0;

// acquire and dispatch messages until a WM_QUIT message is received.
for (;;)
{
// phase1: check to see if we can do idle work
while (bIdle &&
   !::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE))
{
   // call OnIdle while in bIdle state
   if (!OnIdle(lIdleCount++))
    bIdle = FALSE; // assume "no idle" state
}

// phase2: pump messages while available
do
{
   // pump message, but quit on WM_QUIT
   if (!PumpMessage())
    return ExitInstance();

   // reset "no idle" state after pumping "normal" message
   if (IsIdleMessage(&m_msgCur))
   {
    bIdle = TRUE;
    lIdleCount = 0;
   }

} while (::PeekMessage(&m_msgCur, NULL, NULL, NULL, PM_NOREMOVE));
}    //无限循环�Q�退出条件是收到WM_QUIT消息�?/font>

ASSERT(FALSE); // not reachable
}

�q�是一个无限��@环，他的退出条件是收到WM_QUIT消息�Q?/p>
if (!PumpMessage())
    return ExitInstance();

在PumpMessage中，如果收到WM_QUIT消息�Q�那么返回FALSE,所以ExitInstance()函数执行�Q�蟩出��@环，�q�回�E�序的退��Z��码。所以，一个程序要退出，只用在代码中调用函数

VOID PostQuitMessage( int nExitCode )。指定退��Z��码nExitCode��可以退出程序�?/font>

下面讨论一下这个函数Run的流�E�，分两步：

1, �W�一个内循环phase1。bIdle代表�E�序是否�I�闲。他的意思就是，如果�E�序是空闲�ƈ且消息队列中没有要处理的消息�Q�那么调用虚函数OnIdle�q�行 �I�闲处理。在�q�个处理中将更新UI界面(比如工具栏按钮的enable和disable状�?�Q�删除��时对�?比如用FromHandle得到的对象指针。由于这个原因，在函��C��间传递由FromHandle得到的对象指针是不安全的�Q�因��Z��没有持久�?。OnIdle是可以重载的�Q�你可以重蝲他�ƈ�q�回 TRUE使消息��@环��l�处于空闲状态�?/p>
NOTE�Q�MS用��时对象是��Z��效率上的考虑�Q��内存有效利用�Q��ƈ能够在空闲时自动撤销资源。关于由句柄转换成对象，可以有若�q�种�Ҏ��。一般是先申明一个对象obj,然后使用obj.Attatch来和一�?句柄�l�定。这样��生的对象是永久的�Q�你必须用obj.Detach来释攑֯�象�?/font>

2�Q�第二个内��@环phase2。在�q�个循环内先启动消息�?PumpMessage),如果不是WM_QUIT消息�Q�消息�܇��消息发送出�?::DispatchMessage)。消息的目的地是消息�l�构中的hwnd字段所对应的窗口�?br>//thrdcore.cpp
BOOL CWinThread::PumpMessage()
{
ASSERT_VALID(this);

//如果是WM_QUIT��退出函�?return FALSE)�Q�这��导致程序结�?
if (!::GetMessage(&m_msgCur, NULL, NULL, NULL)) {
#ifdef _DEBUG
   if (afxTraceFlags & traceAppMsg)
    TRACE0("CWinThread::PumpMessage - Received WM_QUIT.\n");
   m_nDisablePumpCount++; // application must die
    // Note: prevents calling message loop things in 'ExitInstance'
    // will never be decremented
#endif
   return FALSE;
}

#ifdef _DEBUG
if (m_nDisablePumpCount != 0)
{
   TRACE0("Error: CWinThread::PumpMessage called when not permitted.\n");
   ASSERT(FALSE);
}
#endif

#ifdef _DEBUG
if (afxTraceFlags & traceAppMsg)
   _AfxTraceMsg(_T("PumpMessage"), &m_msgCur);
#endif

// process this message

if (m_msgCur.message != WM_KICKIDLE && !PreTranslateMessage(&m_msgCur))
{
   ::TranslateMessage(&m_msgCur); //键�{�?/font>
   ::DispatchMessage(&m_msgCur); //�z�N��消�?/font>
}
return TRUE;
}

�?�q�一步有一个特别重要的函数大家一定认识：PreTranslateMessage。这个函数在::DispatchMessage发送消息到�H�口之前�Q?�q�行�Ҏ��息的预处理。PreTranslateMessage函数是CWinThread的成员函敎ͼ�大家重蝲的时候都是在View�c�L��者主�H�口�c�M��Q�那么，它是怎么�q�入别的�cȝ��呢？代码如下�Q?br>//thrdcore.cpp
BOOL CWinThread::PreTranslateMessage(MSG* pMsg)
{
ASSERT_VALID(this);

// 如果是线�E�消息，那么��会调用�U�程消息的处理函�?/font>
if (pMsg->hwnd == NULL && DispatchThreadMessageEx(pMsg))
   return TRUE;

// walk from target to main window
CWnd* pMainWnd = AfxGetMainWnd();
if (CWnd::WalkPreTranslateTree(pMainWnd->GetSafeHwnd(), pMsg))
   return TRUE;

// in case of modeless dialogs, last chance route through main
//   window's accelerator table
if (pMainWnd != NULL)
{
   CWnd* pWnd = CWnd::FromHandle(pMsg->hwnd);
   if (pWnd->GetTopLevelParent() != pMainWnd)
    return pMainWnd->PreTranslateMessage(pMsg);
}

return FALSE;   // no special processing
}

�׃��面这个函数可以看出：

�W�一�Q�如�?pMsg->hwnd == NULL),说明�q�是一个线�E�消息。调用CWinThread::DispatchThreadMessageEx到消息映��表扑ֈ�消息入口�Q�然后调用消息处理函数�?/p>
NOTE: 一般用PostThreadMessage函数发送线�E�之间的消息�Q�他和窗口消息不同，需要指定线�E�id,消息�Ȁ被系�l�放入到目标�U�程的消息队列中�Q�用 ON_THREAD_MESSAGE( message, memberFxn )宏可以映��线�E�消息和他的处理函数。这个宏必须在应用程序类(从CWinThread�l�承)中，因�ؓ只有应用�E�序�c�L��处理�U�程消息。如果你在别的类(�?如视囄��)中用�q�个宏，�U�程消息的消息处理函数将得不到线�E�消息�?/font>

�W�二�Q�消息的目标�H�口�?PreTranslateMessage函数首先得到消息处理权，如果函数�q�回FALSE�Q�那么他的父�H�口��得到消息的处理权，直到�ȝ��口；如果函数�q�回 TRUE(表示消息已经被处理了)�Q�那么就不需要调用父�cȝ��PreTranslateMessage函数。这��P��保证了消息的目标�H�口以及他的父窗口都�?以有��Z��调用PreTranslateMessage--在消息发送到�H�口之前�q�行预处�?如果自己处理完然后返回FALSE的话 -_-b),如果你想要消息不传递给父类�q�行处理的话�Q�返回TRUE��p��了�?/p>
�W�三�Q�如果消息的目标�H�口和主�H�口没有父子关系�Q�那么再调用�?�H�口的PreTranslateMessage函数。�ؓ什么这��P��q��二步知道�Q�一个窗口的父窗口不是主�H�口的话�Q�尽��它�?PreTranslateMessage�q�回FALSE�Q�主�H�口也没有机会调用PreTranslateMessage函数。我们知道，加速键的�{换一�?在框架窗口的PreTranslateMessage函数中。我��N��了MFC中关于加速键转换的处理，只有CFrameWnd, CMDIFrameWnd�Q�CMDIChildWnd�{�窗口类有。所以，�W�三步的意思是�Q�如果消息的目标�H�口(他的父窗口不是主�H�口�Q�比如一个这��L��非模式对话框)使消息的预处理��l��O游的�?他的PreTranslateMessage�q�回FALSE)�Q�那么给一�ơ机会给�ȝ��口调�?PreTranslateMessage(万一他是某个加速键消息呢？)�Q�这栯��够保证在有非模式对话框的情况下还能保证主�H�口的加速键好��?br>我做了一个小例子�Q�在对话框类的PreTranslateMessage中，�q�回FALSE。在�ȝ��口显�C��个非模式对话框，在对话框拥有焦点的时候，仍然能够�Ȁ�z�M��H�口的快捷键�?/p>
��M��Q�整个框架就是让每个消息的目标窗�?包括他的父窗�?都有��Z��参与消息到来之前的处理。呵呵~

�?此，非对话框的消息��@环和消息�늚�机制��差不多了。这个机制在一个无限��@环中�Q�不断地从消息队列中获取消息�Q��ƈ且保证了�E�序的线�E�消息能够得到机会处理， �H�口消息在预处理之后被发送到相应的窗口处理过�E�。那么，�q�有一点疑问，��Z��么要一会儿调用::PeekMessage,一会儿调用:: GetMessage呢，他们有什么区别？

NOTE�Q�一般来��_��GetMessage被设计用来高效地从消息队列获取消息。如果队列中没有消息�Q�那么函数GetMessage��导致线�E�休�?让出CPU旉��)。而PeekMessage是判断消息队列中如果没有消息�Q�它马上�q�回0�Q�不会导致线�E�处于睡眠状态�?/font>

�?上面的phase1�W�一个内循环中用��C��PeekMessage�Q�它的参数PM_NOREMOVE表示�q�不从消息队列中�U�走消息�Q�而是一个检��查询，如果消息队列中没有消息他立刻�q�回0�Q�如果这时线�E�空闲的话将会引��h��息��@环调用OnIdle处理�q�程(上面讲到了这个函数的重要�?。如果将:: PeekMessage�Ҏ��::GetMessage(***),那么如果消息队列中没有消息，�U�程��休眠，直到�U�程下一�ơ获得CPU旉��q�且有消息出�?才可能��l�执行，�q�样�Q�消息��@环的�I�闲旉��没有得到应用�Q�OnIdle也将得不到执行。这��是��Z��么既要用::PeekMessage(查询),又要 �?:GetMessage(做实际的工作)的缘故�?/p>
�W�二部分: 对话框程序的消息循环机制

��Z��对话框的MFC工程和上面的消息循环机制不一栗��实际上MFC的对话框工程�E�序��是模式对话框。他和上面讲到的非对话框�E�序的不同之处，主要在于应用�E�序对象的InitInstance()不一栗��?/p>
//dlg_5Dlg.cpp
BOOL CDlg_5App::InitInstance()
{
AfxEnableControlContainer();
#ifdef _AFXDLL
Enable3dControls();    // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif

CDlg_5Dlg dlg; //定义一个对话框对象
m_pMainWnd = &dlg;
int nResponse = dlg.DoModal(); //对话框的消息循环在这里面开�?/font>
if (nResponse == IDOK)
{
   // TODO: Place code here to handle when the dialog is
   // dismissed with OK
}
else if (nResponse == IDCANCEL)
{
   // TODO: Place code here to handle when the dialog is
   // dismissed with Cancel
}

// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}

NOTE: InitInstance函数�q�回FALSE�Q�由最上面�E�序启动��程可以看出�Q�CWinThread::Run是不会得到执行的。也��是��_��上面�W�一部分说的消息循环在对话框中是不能执行的。实际上�Q�对话框也有消息循环�Q�她的消息��@环在CDialog::DoModal()虚函��C��的一�?RunModalLoop函数中�?/font>

�q�个函数的实��C��在CWnd�c�M��Q?br>int CWnd::RunModalLoop(DWORD dwFlags)
{
ASSERT(::IsWindow(m_hWnd)); // window must be created
ASSERT(!(m_nFlags & WF_MODALLOOP)); // window must not already be in modal state

// for tracking the idle time state
BOOL bIdle = TRUE;
LONG lIdleCount = 0;
BOOL bShowIdle = (dwFlags & MLF_SHOWONIDLE) && !(GetStyle() & WS_VISIBLE);
HWND hWndParent = ::GetParent(m_hWnd);
m_nFlags |= (WF_MODALLOOP|WF_CONTINUEMODAL);
MSG* pMsg = &AfxGetThread()->m_msgCur;

// acquire and dispatch messages until the modal state is done
for (;;)
{
   ASSERT(ContinueModal());

   // phase1: check to see if we can do idle work
   while (bIdle &&
    !::PeekMessage(pMsg, NULL, NULL, NULL, PM_NOREMOVE))
   {
    ASSERT(ContinueModal());

    // show the dialog when the message queue goes idle
    if (bShowIdle)
    {
     ShowWindow(SW_SHOWNORMAL);
     UpdateWindow();
     bShowIdle = FALSE;
    }

    // call OnIdle while in bIdle state
    if (!(dwFlags & MLF_NOIDLEMSG) && hWndParent != NULL && lIdleCount == 0)
    {
     // send WM_ENTERIDLE to the parent
     ::SendMessage(hWndParent, WM_ENTERIDLE, MSGF_DIALOGBOX, (LPARAM)m_hWnd);
    }
    if ((dwFlags & MLF_NOKICKIDLE) ||
     !SendMessage(WM_KICKIDLE, MSGF_DIALOGBOX, lIdleCount++))
    {
     // stop idle processing next time
     bIdle = FALSE;
    }
   }

// phase2: pump messages while available
   do
   {
    ASSERT(ContinueModal());

    // pump message, but quit on WM_QUIT
   //PumpMessage(消息�?的实现和上面讲的差不多。都是派送消息到�H�口�?/font>
    if (!AfxGetThread()->PumpMessage())
    {
     AfxPostQuitMessage(0);
     return -1;
    }

    // show the window when certain special messages rec'd
    if (bShowIdle &&
     (pMsg->message == 0x118 || pMsg->message == WM_SYSKEYDOWN))
    {
     ShowWindow(SW_SHOWNORMAL);
     UpdateWindow();
     bShowIdle = FALSE;
    }

    if (!ContinueModal())
     goto ExitModal;

    // reset "no idle" state after pumping "normal" message
    if (AfxGetThread()->IsIdleMessage(pMsg))
    {
     bIdle = TRUE;
     lIdleCount = 0;
    }

   } while (::PeekMessage(pMsg, NULL, NULL, NULL, PM_NOREMOVE));
} //无限循环

ExitModal:
m_nFlags &= ~(WF_MODALLOOP|WF_CONTINUEMODAL);
return m_nModalResult;
}

先说说怎么退��个无限��@环，在代码中�Q?br>if (!ContinueModal())
goto ExitModal;
军_��是否退出��@环，消息循环函数�q�回也就是快要结束结束程序了�?br>BOOL CWnd::ContinueModal()
{
return m_nFlags & WF_CONTINUEMODAL;
}

NOTE: CWnd::ContinueModal()函数��查对话框是否�l�箋模式。返回TRUE,表示现在是模式的�Q�返回FALSE�Q�表�C�对话框已经不是模式(��要�l�束)�?/font>

�?果要�l�束对话框，在内部最�l�会调用函数CWnd::EndModalLoop�Q�它取消m_nFlags的模式标�?消息循环中的 ContinueModal函数��返回FALSE�Q�消息��@环将�l�束�Q�程序将退�?�Q�然后激发消息��@环读取消息。也��是��_��l�束模式对话框是一个标志，改变 �q�个标志��可以了。他的代码是�Q?/p>
//wincore.cpp
void CWnd::EndModalLoop(int nResult)
{
ASSERT(::IsWindow(m_hWnd));

// this result will be returned from CWnd::RunModalLoop
m_nModalResult = nResult;

// make sure a message goes through to exit the modal loop
if (m_nFlags & WF_CONTINUEMODAL)
{
   m_nFlags &= ~WF_CONTINUEMODAL;
   PostMessage(WM_NULL);
}
}

NOTE: PostMessage(NULL)是有用的。如果消息队列中没有消息的话�Q�可能消息��@环中的ContinueModal()不会马上执行�Q�发送一个空消息是激发消息��@环马上工作�?/font>

下面说一下CWnd::RunModalLoop函数中的消息循环�I�竟�q�了些什么事�?
1, �W�一个内循环。首先从消息队列中查询消息，如果对话框空�Ԍ��而且消息队列中没有消息，他做三�g事情�Q�大家应到都能从字面上明白什么意思。最重要的是发�?WM_KICKIDLE消息。�ؓ什么呢�Q�第一部分讲到了，非对话框�E�序用OnIdle来更新用��L��?UI)�Q�比如工��h��Q�状态栏。那么，如果对话框中�?有工��h��和状态栏呢，在哪里更�?�|�上有很多这��L��E�序)�Q�可以处理WM_KICKIDLE消息�Q?br>
LRESULT CDlg_5Dlg::OnKickIdle(WPARAM w,LPARAM l)
{
     //调用CWnd::UpdateDialogControls更新用户界面
     UpdateDialogControls(this, TRUE);
     return 0;
}

NOTE: CWnd::UpdateDialog函数发送CN_UPDATE_COMMAND_UI消息�l�所有的用户界面对话框控件�?/font>

2, �W�二个内循环。最重要的还是PumpMessage�z�N��消息到目标�H�口。其他的�Q�像�W�二个if语句�Q?x118消息好像是WM_SYSTIMER消息(�p?�l�用来通知光标跛_��的一个消�?。也��是��_��如果消息为WM_SYSTIMER或者WM_SYSKEYDOWN,�q�且�I�闲昄��标志为真的话�Q�就昄��H�口�q?通知�H�口立刻重绘�?/p>
��M��Q�对话框的消息��@环机制和非对话框(比如SDI,MDI)�q�是�c�M�� 的，仅仅侧重点不同。模式对话框是模式显�C�，自然有他的特炏V��下面部分讨��Z��下模式对话框和非模式对话框的区别。因为模式对话框有自��q��Ҏ��消息循环�Q��?非模式对话框�Q�共用程序的消息循环�Q�和普通的�H�口已经没有什么大的区别了�?/font>

�W�三部分�Q�模式对话框和非模式对话框的区别

�q�个话题已经有很多�h讨论�Q�我说说我所理解的意思�?br>在MFC 框架中，一个对话框对象DoModal一下就能��生一个模式对话框�Q�Create一下就能��生一个非模式对话框。实际上�Q�无论是模式对话框还是非模式对话框，在MFC内部都是调用::CreateDialogIndirect(***)函数来创建非模式对话框。只是模式对话框作了更多的工作，包括使父�H�口无效�Q�然后进入自��q��消息循环�{�等�?:CreateDialogIndirect(***)函数最�l�调用CreateWindowEx函数通知�pȝ��创徏 �H�体�q�返回句柄，他内部没有实现自��q��消息循环�?br>非模式对话框创徏之后立即�q�回�Q��ƈ且和�ȝ��序共用一个消息��@环。非模式对话框要�{�对话框�l�束之后才返回，自己有消息��@环。比如下面的代码�Q?br>CMyDlg* pdlg = new CMyDlg;
pdlg ->Create(IDD_DIALOG1);
pdlg->ShowWindow(SW_SHOW);
MessageBox("abc");
非模式对话框和消息框MessageBox几乎是同时弹出来。而如果将Create�Ҏ��DoModal�Q�那么，只能弹出模式对话框，在关闭了对话框之�?模式对话框自��q��消息循环�l�束)�Q�消息框才弹出来�?/p>
NOTE�Q?可以在模式对话框中调用GetParent()->EnableWindow(true);�q�样�Q�主�H�口的菜单，工具栏又�Ȁ�z�M��Q�能用了。MFC�?用非模式对话框来模拟模式对话框，而在win32 SDK�E�序中，模式对话框激发他的父�H�口Enable操作是没有效果的�?/font>

关于消息循环�ȝ��Q?/strong>

1�Q?我们站在一个什么高度看消息循环�Q�消息��@环其实没有什么深奥的道理。如果一个邮递员要不断在一个城市中送信�Q�我们要求他做什么？要求他来回跑�Q�但他一�ơ只能在一个地方出现。如果我们的应用�E�序只有一个线�E�的话，我们要他不断��Cؓ�H�口传递消息，我们怎么做？在一个��@环中不断的检��消息，�q�将他发送到适当的窗口。窗口可以有很多个，但消息��@环只有一个，而且每时每刻最多只有一个地方在执行代码。�ؓ什么？看第二点�?/p>
2�Q�因为是单线�E�的(�E�序�q�程启动的时候，只有而且有一个线�E�，我们�U�C��Z��U�程),所以就像邮递员一��P��每次只能在某一个地方干�z�R��什么意思呢�Q��D个例子，�?: DiapatchMessage�z�N��消息，在窗口处理过�E?WinProc,�H�口函数)�q�回之前�Q�他是阻塞的,不会立即�q�回�Q�也��是消息循环此时不能再从消息队列中读取消息，直到::DispatchMessage�q�回。如果你在窗口函��C��执行一个死循环操作�Q�就��你用PostQuitMessage函数退出，�E�序也会down掉�?br>while(1)
{
    PostQuitMessage(0); //�E�序照样down.
}
所以，当窗口函数处理没有返回的时候，消息循环是不会从消息队列中读取消息的。这也是��Z��么在模式对话框中要自��q��无限循环来��l�消息��@环，因�ؓ�q�个无限�?环阻塞了原来的消息��@环，所以，在这个无限��@环中要用GetMessage,PeekMessage,DispatchMessage来从消息队列中读�?消息�q�派送消息了。要不然�E�序��׃��会响应了�Q�这不是我们所希望的�?br>所以说�Q�消息��@环放在程序的什么的地方都基本上是过的去的，比如攑֜�DLL�?面。但是，最好在��M��时候，只有一个消息��@环在工作(其他的都被阻塞了)。然后，我们要作好的一件事情，��是怎么从消息��@环中退出！当然用WM_QUIT 是可以拉~(PostThreadMessage也是个好��L��)�Q�这个消息��@环退出后�Q�可能程序退出，也可能会�Ȁ�z�d��外一个被��d��的消息��@环，�E�序�l�箋�q?行。这要看你怎么惻I��怎么��d��。最后一个消息��@环结束的时候，也许��是�E�序快结束的时候，因�ؓ�ȝ��E�的执行代码也快要完�?除非BT的再作个��d�@�?�?/p>
NOTE: 让windows�pȝ��知道创徏一个线�E�的唯一�Ҏ��是调用API CreatThread函数(__beginthreadex之类的都要在内部调用他创建新�U�程)。好像windows核心�~�程��_��在win2000下， �pȝ��用CreateRemoteThread函数来创建线�E�，CreateThread在内部调用CreateRemoteThread。不�q�这不是争论的焦点，臛_��win98下CreateRemoteThread�q�不能正常工作，�q�是CreateThread��L��大局�?/font>

3�Q�在整个消息循环的机制中�Q�还必须谈到�H�口函数的可重入性。什么意思？��是�H�口函数(他是个回调函�?的代码什么时候都可以被系�l?调用者一般是user32模块)调用。比如在�H�口�q�程中，向自��q��H�口SendMessage(***);那么执行�q�程是怎样的？
我们知道�Q�SendMessage是要�{�到消息发送�ƈ被目标窗口执行完之后才返回的。那么窗口在处理消息�Q�然后又�{�待刚才发送到本窗口的消息被处理后之后(SendMessage�q�回)才��l�往下执行，�E�序不就互相死锁了吗�Q?
�?实是不会的。windows设计一套适合SendMessage的算法，他判断如果发送的消息是属于本�U�程创徏的窗口的�Q�那么直接由user32模块调用 �H�口函数(可能��有�H�口重入)�Q��ƈ��消息的处理�l�果�l�果�q�回。这样做体现了窗口重入。上面的例子�Q�我们调用SendMessage(***)发送消息到�?�H�口�Q�那么窗口过�E�再�ơ被调用�Q�处理完消息之后��结果返回，然后SendMessage之后的程序接着执行。对于非队列消息�Q�如果没有窗口重入，不知道会是什么样子�?/p>
NOTE: �׃��H�口的可重入性。在win32 SDK�E�序中应��量��用全局变量和静态变量，因�ؓ在窗口函数执行过�E�中可能�H�口重入�Q�如果重入后��这些变量改了，但你的程序在�H�口重入�q�回之后�l�箋执行�Q?可能��是使用已经改变的全局或静态变量。在MFC�?所有窗口的�H�口函数基本上都是AfxWndProc)�Q�按照类的思想�q�行了组�l�，一般变量都是类�?的，好管理的多�?/font>

4,MFC中窗口类(比如C**View,CFrameWnd�{?中的MessageBox函数�Q�以�?AfxMessageBox函数都是��d��原有的消息��@环的。由消息框内部的一个消息��@环来从消息队列中��d��消息�Q��ƈ�z�N��消�?和模式对话框�c�M��)。实�?上，�q�些消息函数最�l�调用的�?:MessageBox�Q�它在消息框内部实现了一个消息��@�?原有的主�E�序消息循环被阻塞了)。论坛中��到�q�几�ơ关于计�?器和消息框的问题�Q�看下面的代码：
void CTest_recalclayoutView::OnTimer(UINT nIDEvent)
{
// TODO: Add your message handler code here and/or call default
MessageBox("abc");
while(1); //设计一个死循环
CView::OnTimer(nIDEvent);
}
�?让OnTimer大约5�U�钟弹出一个消息框。那么，消息框不断的被弹出来�Q�只要消息框不被关闭�Q�那么程序就不会�q�入��d�@环。实际上�Q�每�ơ弹出对话框�Q�都�?最上层的那个消息框掌握着消息循环�Q�其他的消息循环被阻塞了。只要不关闭最上面的消息框�Q�while(1);��得不到执行。如果点了关闭，�E�序��p��入了�?循环�Q�只能用ctrl+alt+del来解决问题了�?/p>
5�Q�消息��@环在很多地方都有应用。比如应用在�U�程池中。一个线�E�的执行周期一般在�U�程函数�q�回之后�l�束�Q�那么怎么廉��U�程的生命周期呢�Q�一�U�方法就是按照消息��@环的思想�Q�在�U�程中加入消息��@环，不断��C��U�程队列��d��消息�Q��ƈ处理消息�Q�线�E?的生命周期就保持着直到�q�个消息循环的退出�?/p>
NOTE�Q�只要线�E�有界面元素或者调用GetMessage,或者有�U�程消息发送过来，�pȝ��׃��为线�E�创��Z��个消息队列�?/font>

6, 在单�U�程�E�序中，如果要执行一个长旉��的复杂操作而且界面要有相应的话�Q�可以考虑用自��q��消息��c��比如，可以��一个阻塞等待操作放在一个��@环中�Q��ƈ��超�?��D��|�得比较��，然后每个�{�待的片�D�中用消息�܇�l�箋消息循环�Q��界面能够响应用户操作。等�{�之�c�，都可以应用消息�܇(调用一个类��D��L��函数)�Q?br>BOOL CChildView::PeekAndPump()
{
MSG msg;
while(::PeekMessage(&msg,NULL,0,0,PM_NOREMOVE))
{
   if(!AfxGetApp()->PumpMessage())
   {
    ::PostQuitMessage(0);
    return false;
   }
}
return true;
}
其实�Q�用多线�E�也能解军_��杂运��时的界面问题，但是没有�q�么方便�Q�而且一般要加入�U�程通信和同步，考虑的事情更多一炏V�?/p>

�l�g��所�q�ͼ�MFC消息循环��那么回事，主要思想�q�是和SDK中差不多。这�U�思想主要的特点表现在�q�合MFC整个框架上，为整个框架服务，为应用和功能服务。这是我的理解。呵呵~

李亚 2007-12-17 20:28 发表评论

��d��上下文菜单的�Ҏ��

李亚 — Wed, 05 Dec 2007 12:19:00 GMT

首先要在在文仉��定义菜单��：

#define ID_MENU_EDIT   5001
#define ID_MENU_DELETE 5002
然后��d��对话框的WM_CONTEXTMENU消息函数�Q�函数内容�ؓ�Q?br>
    CMenu menuPopup;
    if(menuPopup.CreatePopupMenu())
    {
         menuPopup.AppendMenu(MF_STRING,ID_MENU_EDIT,"修改(&E)");
         menuPopup.AppendMenu(MF_STRING,ID_MENU_DELETE,"删除(&D)");
         menuPopup.TrackPopupMenu(TPM_LEFTALIGN,point.x,point.y,this);
    }
然后定义菜单相应函数,
1,在头文�g中添加函数定义语句：

// Generated message map functions
//{{AFX_MSG(CAdo2Dlg)
virtual BOOL OnInitDialog();
afx_msg void onInfoEdit(); //  �q�个是编辑菜单的响应函数
afx_msg void onInfoDelete();  //�q�个是删除菜单的响应函数
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
afx_msg void OnButton1();
afx_msg void OnButton2();
afx_msg void OnRdblclkList1(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnDblclkList1(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()

2�Q�在cpp文�g中添加函��C��Q?br>

void CAdo2Dlg::OnInfoEdit()
{
    AfxMessageBox("edit");
}

void CAdo2Dlg::OnInfoDelete()
{
    AfxMessageBox("delete");
}

3�Q�然后在cpp文�g中添加媄��：

BEGIN_MESSAGE_MAP(CAdo2Dlg, CDialog)
    //{{AFX_MSG_MAP(CAdo2Dlg)
    ON_COMMAND(ID_MENU_EDIT,    OnInfoEdit)
    ON_COMMAND(ID_MENU_DELETE,  OnInfoDelete)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

所有的工作完成了！

李亚 2007-12-05 20:19 发表评论

VC动态链接库的创建和使用

李亚 — Wed, 05 Dec 2007 12:18:00 GMT
一�Q�MFC扩展DLL
创徏�Q?br>1�Q�新��Z��个MFC扩展DLL ,名字为dll5,��d��头文�Ӟ��名�ؓdll5
2�Q�头文�g中加入：
extern __declspec(dllexport) CString concatA(CString x,CString y);
3�Q�在cpp文�g中加入：
extern __declspec(dllexport) CString concatA(CString x,CString y)
{
return x + y;
}
4,在cpp文�g中加入：
#include "dll5.h"
5�Q�编译，生成dll
使用�Q?br>1�Q�新��Z��个单文��应用�E�序�Q�名为Usedll5
2,��刚才生成的dll5.lib文�g和dll5.h文�g拯��到当前应用程序�\径下,
��dll5.dll 文�g拯��?当前应用�E�序下的debug�?br>3�Q�在当前应用�E�序中用到该dll5的导出方法（concatA)的文�Ӟ��或类�Q�上��d��如下语句�Q?br>#include "dll5.h"
假设��其加到 Usedll5View.cpp中�?br>4�Q�在Usedll5View�c�M��建立消息映射入口�Q�在消息函数中添加如下语句：
CString a=concatA("中国北�R集团","长春轨道客�R股䆾有限公司");
MessageBox(a);
5�Q�在工程/讄��/�q�接/对象�?模块中加入：dll5.lib

6,�~�译执行该应用程序，�q�触发该消息�Q�则输出�Q?/p>
中国北�R集团长春轨道客�R股䆾有限公司

之后只要定义不更改，函数体无论怎么更改。我们只要将�~�译好的dll拯��q�来卛_��。如果定义有了修改，则需要将h文�g和lib 文�g拯��q�来�Q��ƈ需要重新编译�?/p>

二，动态链接库使用�׃�nMFC DLL
创徏�Q?br>1�Q�新��Z��?DLL(�?动态链接库使用�׃�nMFC DLL�Q?
2�Q�头文�g中加入：
_declspec(dllexport) CString WINAPI concatA(CString x,CString y);
3�Q�在cpp文�g末尾加入�Q?br>_declspec(dllexport) CString WINAPI concatA(CString x,CString y)
{
return x + y;
}
4�Q�编译，生成dll
使用�Q?br>1�Q�新��Z��个单文��应用�E�序�Q�名为Usedll8
2,��刚才生成的dll8.lib文�g拯��到当前应用程序�\径下,
��dll8.dll 文�g拯��?c:\winnt\system32�?br>3�Q�在当前应用�E�序中用到该dll5的导出方法（concatA)�?�cȝ��头文件上��d��如下语句�Q?br>extern CString WINAPI concatA(CString x,CString y);
假设��其加到 Usedll8View.h中�?br>4�Q�在Usedll8View�c�M��建立消息映射入口�Q�在消息函数中添加如下语句：
CString a=concatA("中国北�R集团","长春轨道客�R股䆾有限公司");
MessageBox(a);
5�Q�在工程/讄��/�q�接/对象�?模块中加入：dll8.lib
6,�~�译执行该应用程序，�q�触发该消息�Q�则输出�Q?/p>
中国北�R集团长春轨道客�R股䆾有限公司

李亚 2007-12-05 20:18 发表评论

知识�Ҏ��理集�?..

李亚 — Sun, 25 Nov 2007 03:55:00 GMT
UpdateData()的��用方�?/strong>
         UpdateData�Q�）只有一个BOOL�c�d��的参敎ͼ�UpdateData(FALSE)一般用于对话框控�g�q�接的变量值刷新屏�q�显�C�；比如你在一个文本框上绑定了一个m_member变量�Q�用UpdateData(FALSE);卛_��把这个值在文本框里昄��出来�Q�反之，UpdateData(TRUE);能把填入文本框的内容赋值给m_member.

李亚 2007-11-25 11:55 发表评论

李亚 — Fri, 23 Nov 2007 05:21:00 GMT

透明的CheckBox�Q�基�c�L��CButton...
主要代码如下
OnPaint()
{
CPaintDC dc(this); // device context for painting

    // TODO: Add your message handler code here

    CRect rect;
    GetClientRect(&rect);

    CRect BoxRect;
    BoxRect=rect;
    BoxRect.right =BoxRect.left +15;
    dc.DrawFrameControl(BoxRect,DFC_BUTTON,DFCS_BUTTONCHECK|GetCheck()?DFCS_CHECKED :0);

    CFont   myFont;
    myFont.CreatePointFont (120,_T("宋体"));
    CFont   *pOldFont=(CFont   *)dc.SelectObject   (&myFont);
    dc.SetBkMode(TRANSPARENT);

    CString StrWndText;
    GetWindowText(StrWndText);

    rect.OffsetRect (20,0);
    dc.DrawText(StrWndText,   rect,   DT_LEFT|DT_VCENTER|DT_SINGLELINE);
    dc.SelectObject   (pOldFont);
    myFont.DeleteObject   ();
    // Do not call CButton::OnPaint() for painting messages
}

李亚 2007-11-23 13:21 发表评论

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.