九月鹰飞

求多边形面积的简单方法

九月鹰飞 — Wed, 10 Jan 2007 04:53:00 GMT

<PRE>
不论凸多边形还是凹多边形，都可以采用向量叉乘的方法来求面积。代码如下
#include "stdafx.h"
#include "stdio.h"
typedef struct tagPoint
{
double x;
double y;
}FPoint;
double MianJi(FPoint *pArray,int NumPoint)
{
if(NumPoint<3)return 0;

double sum = 0;
int m = 1;
for(;;)
{
  if(NumPoint < 3)break;
  FPoint r1;
  r1.x = pArray[m].x - pArray[0].x;
  r1.y = pArray[m].y - pArray[0].y;
  FPoint r2;
  r2.x = pArray[m+1].x - pArray[m].x;
  r2.y = pArray[m+1].y - pArray[m].y;
  sum += (r1.x * r2.y - r2.x * r1.y);
  m++;
  NumPoint --;
}
double result = (sum>0)?(sum/2.):(-sum/2.);
return result;
}
//test
void main()
{
FPoint pArray1[4]={{1,1},{1,2},{2,2},{2,1}};
FPoint pArray2[5]={{0,0},{0,2},{2,2},{1,1},{2,0}};
FPoint pArray3[9]={{0,0},{2,0},{2,1},{0,1},{0,2},{-2,0},{-1,0},{-1,-1},{0,-1}};
printf("Area1 = %f\n",MianJi(pArray1,4));
printf("Area2 = %f\n",MianJi(pArray2,5));
printf("Area3 = %f\n",MianJi(pArray3,9));
}

iwaswzq 2007/1/10

</PRE>

一个数独小游戏。[附送源代码]

九月鹰飞 — Sun, 31 Dec 2006 03:10:00 GMT

<PRE>
画面简单，不过已经能玩了。喜欢数独的朋友可以拿来消磨时间。喜欢编程的朋友可以拿去进一步改进。不过记得保留我的名字。有些功能感觉没有必要，不过懒得再折腾这个破玩意了。

下载地址：
http://blog.vckbase.com/Files/iwaswzq/ShuDu.rar

</PRE>

Windows 语音编程初步

九月鹰飞 — Tue, 12 Sep 2006 14:49:00 GMT

<PRE>
Windows 语音编程初步

一、SAPI简介

软件中的语音技术包括两方面的内容，一个是语音识别(speech recognition) 和语音合成(speech synthesis)。这两个技术都需要语音引擎的支持。微软推出的应用编程接口API，虽然现在不是业界标准，但是应用比较广泛。

SAPI全称 The Microsoft Speech API.相关的SR和SS引擎位于Speech SDK开发包中。这个语音引擎支持多种语言的识别和朗读，包括英文、中文、日文等。

SAPI包括以下组件对象（接口）：

（1）Voice Commands API。对应用程序进行控制，一般用于语音识别系统中。识别某个命令后，会调用相关接口是应用程序完成对应的功能。如果程序想实现语音控制，必须使用此组对象。
（2）Voice Dictation API。听写输入，即语音识别接口。
（3）Voice Text API。完成从文字到语音的转换，即语音合成。
（4）Voice Telephone API。语音识别和语音合成综合运用到电话系统之上，利用此接口可以建立一个电话应答系统，甚至可以通过电话控制计算机。
（5）Audio Objects API。封装了计算机发音系统。

SAPI是架构在COM基础上的，微软还提供了ActiveX控件，所以不仅可用于一般的windows程序，还可以用于网页、VBA甚至EXCEL的图表中。如果对COM感到陌生，还可以使用微软的C++ WRAPPERS，它用C++类封装了语音SDK COM对象。

二、安装SAPI SDK。

首先从这个站点下载开发包：http://www.microsoft.com/speech/download/sdk51

Microsoft Speech SDK 5.1添加了Automation支持。所以可以在VB,ECMAScript等支持Automation的语言中使用。

版本说明：
Version: 5.1
发布日期: 8/8/2001
语音: English
下载尺寸: 2.0 MB - 288.8 MB

这个SDK开发包还包括了可以随便发布的英文和中文的语音合成引擎(TTS)，和英文、中文、日文的语音识别引擎(SR)。

系统要求98以上版本。编译开发包中的例子程序需要vc6以上环境。

******下载说明******：
（1）如果要下载例子程序，说明文档，SAPI以及用于开发的美国英语语音引擎，需要下载SpeechSDK51.exe，大约68M。
（2）如果想要使用简体中文和日文的语音引擎，需要下载SpeechSDK51LangPack.exe。大约82M。
（3）如果想要和自己的软件一起发布语音引擎，需要下载SpeechSDK51MSM.exe，大约132M。
（在这个地址，我未能成功下载）。
（4）如果要获取XP下的 Mike 和 Mary 语音，下载Sp5TTIntXP.exe。大约3.5M。
（5）如果要获取开发包的文档说明，请下载sapi.chm。大约2.3M。这个在sdk51里面已经包含。

下载完毕后，首先安装SpeechSDK51.exe，然后安装中文语言补丁包SpeechSDK51LangPack，然后展开
msttss22l，自动将所需dll安装到系统目录。

三、配置vc环境

在vc6.0的环境下编译语音工程，首先要配置编译环境。假设sdk安装在d:\Microsoft Speech SDK 5.1\路径下，打开工程设置对话框，在c/c++栏中选择Preprocessor分类，然后在"附加包含路径"中输入
d:\Microsoft Speech SDK 5.1\include
告诉vc编译程序所需的SAPI头文件的位置。
然后切换到LINK栏，在Input分类下的附加库路径中输入：
d:\Microsoft Speech SDK 5.1\lib\i386
使vc在链接的时候能够找到sapi.lib。

四、语音合成的应用。即使用SAPI实现TTS(Text to Speech)。

1、首先要初始化语音接口，一般有两种方式：
   ISpVoice* pVoice;
   ::CoInitialize(NULL);
   HRESULT hr = CoCreateInstance(CLSID_SpVoice, NULL, CLSCTX_ALL, IID_ISpVoice,
               (void **)&pVoice);
   然后就可以使用这个指针调用SAPI函数了，例如
   pVoice->SetVolume(50);//设置音量
   pVoice->Speak(str.AllocSysString(),SPF_ASYNC,NULL);

   另外也可以使用如下方式：
    CComPtr<ISpVoice>   m_cpVoice;
    HRESULT hr = m_cpVoice.CoCreateInstance( CLSID_SpVoice );
   在下面的例子中都用这个m_cpVoice变量。

CLSID_SpVoice的定义位于SPAI.H中。

2、获取/设置输出频率。

SAPI朗读文字的时候，可以采用多种频率方式输出声音，比如：
8kHz 8Bit Mono、8kHz 8Bit Stereo、44kHz 16Bit Mono、44kHz 16Bit Stereo等。在音调上有所差别。具体可以参考sapi.h。

   可以使用如下代码获取当前的配置：
   CComPtr<ISpStreamFormat> cpStream;
   HRESULT hrOutputStream = m_cpVoice->GetOutputStream(&cpStream);
   if (hrOutputStream == S_OK)
   {
       CSpStreamFormat Fmt;
       hr = Fmt.AssignFormat(cpStream);
       if (SUCCEEDED(hr))
       {
           SPSTREAMFORMAT eFmt = Fmt.ComputeFormatEnum();
       }
   }
    SPSTREAMFORMAT 是一个ENUM类型，定义位于SPAI.H中。每一个值对应了不同的频率设置。例如 SPSF_8kHz8BitStereo = 5

    通过如下代码设置当前朗读频率：
    CComPtr<ISpAudio>   m_cpOutAudio; //声音输出接口
    SpCreateDefaultObjectFromCategoryId( SPCAT_AUDIOOUT, &m_cpOutAudio ); //创建接口

SPSTREAMFORMAT eFmt = 21; //SPSF_22kHz 8Bit Stereo

    CSpStreamFormat Fmt;
    Fmt.AssignFormat(eFmt);
    if ( m_cpOutAudio )
    {
hr = m_cpOutAudio->SetFormat( Fmt.FormatId(), Fmt.WaveFormatExPtr() );
    }
    else hr = E_FAIL;

    if( SUCCEEDED( hr ) )
   {
       m_cpVoice->SetOutput( m_cpOutAudio, FALSE );
   }

3、获取/设置播放所用语音。

引擎中所用的语音数据文件一般保存在SpeechEngines下的spd或者vce文件中。安装sdk后，在注册表中保存了可用的语音，比如英文的男/女，简体中文的男音等。位置是：
HKEY_LOCAL_MACHINE\Software\Microsoft\Speech\Voices\Tokens
如果安装在中文操作系统下，则缺省所用的朗读语音是简体中文。SAPI的缺点是不能支持中英文混读，在朗读中文的时候，遇到英文，只能逐个字母读出。所以需要程序自己进行语音切换。

(1) 可以采用如下的函数把当前SDK支持的语音填充在一个组合框中：
    // SAPI5 helper function in sphelper.h
    HWND hWndCombo = GetDlgItem( hWnd, IDC_COMBO_VOICES ); //组合框句柄
    HRESULT hr = SpInitTokenComboBox( hWndCombo , SPCAT_VOICES );
    这个函数是通过IEnumSpObjectTokens接口枚举当前可用的语音接口，把接口的说明文字添加到组合框中，并且把接口的指针作为LPARAM
    保存在组合框中。
    一定要记住最后程序退出的时候，释放组合框中保存的接口：
    SpDestroyTokenComboBox( hWndCombo );
    这个函数的原理就是逐个取得combo里面每一项的LPARAM数据，转换成IUnknown接口指针，然后调用Release函数。
(2) 当组合框选择变化的时候，可以用下面的函数获取用户选择的语音：
    ISpObjectToken* pToken = SpGetCurSelComboBoxToken( hWndCombo );

(3) 用下面的函数获取当前正在使用的语音：
    CComPtr<ISpObjectToken> pOldToken;
    HRESULT hr = m_cpVoice->GetVoice( &pOldToken );
(4) 当用户选择的语音和当前正在使用的不一致的时候，用下面的函数修改：
    if (pOldToken != pToken)
    {
         // 首先结束当前的朗读，这个不是必须的。
         HRESULT hr = m_cpVoice->Speak( NULL, SPF_PURGEBEFORESPEAK, 0);
         if (SUCCEEDED (hr) )
        {
            hr = m_cpVoice->SetVoice( pToken );
         }
    }
(5) 也可以直接使用函数SpGetTokenFromId获取指定voice的Token指针，例如：
      WCHAR pszTokenId[] = L"HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Speech\\Voices\\Tokens\\MSSimplifiedChineseVoice";
    SpGetTokenFromId(pszTokenID , &pChineseToken);

4、开始/暂停/恢复/结束当前的朗读

   要朗读的文字必须位于宽字符串中，假设位于szWTextString中，则：
   开始朗读的代码：
   hr = m_cpVoice->Speak( szWTextString, SPF_ASYNC | SPF_IS_NOT_XML, 0 );
   如果要解读一个XML文本，用：
   hr = m_cpVoice->Speak( szWTextString, SPF_ASYNC | SPF_IS_XML, 0 );

   暂停的代码：   m_cpVoice->Pause();
   恢复的代码：   m_cpVoice->Resume();
   结束的代码：（上面的例子中已经给出了）
   hr = m_cpVoice->Speak( NULL, SPF_PURGEBEFORESPEAK, 0);

5、跳过部分朗读的文字

   在朗读的过程中，可以跳过部分文字继续后面的朗读，代码如下：
   ULONG ulGarbage = 0;
   WCHAR szGarbage[] = L"Sentence";
   hr = m_cpVoice->Skip( szGarbage, SkipNum, &ulGarbage );
   SkipNum是设置要跳过的句子数量，值可以是正/负。
   根据sdk的说明，目前SAPI仅仅支持SENTENCE这个类型。SAPI是通过标点符号来区分句子的。

6、播放WAV文件。SAPI可以播放WAV文件，这是通过ISpStream接口实现的：

CComPtr<ISpStream> cpWavStream;
WCHAR szwWavFileName[NORM_SIZE] = L"";;

USES_CONVERSION;
wcscpy( szwWavFileName, T2W( szAFileName ) );//从ANSI将WAV文件的名字转换成宽字符串

   //使用sphelper.h 提供的这个函数打开 wav 文件，并得到一个 IStream 指针
   hr = SPBindToFile( szwWavFileName, SPFM_OPEN_READONLY, &cpWavStream );
   if( SUCCEEDED( hr ) )
   {
        m_cpVoice->SpeakStream( cpWavStream, SPF_ASYNC, NULL );//播放WAV文件
   }
7、将朗读的结果保存到wav文件
   TCHAR szFileName[256];//假设这里面保存着目标文件的路径
   USES_CONVERSION;
   WCHAR m_szWFileName[MAX_FILE_PATH];
   wcscpy( m_szWFileName, T2W(szFileName) );//转换成宽字符串

   //创建一个输出流，绑定到wav文件
   CSpStreamFormat OriginalFmt;
   CComPtr<ISpStream> cpWavStream;
   CComPtr<ISpStreamFormat>    cpOldStream;
   HRESULT hr = m_cpVoice->GetOutputStream( &cpOldStream );
   if (hr == S_OK) hr = OriginalFmt.AssignFormat(cpOldStream);
   else hr = E_FAIL;
   // 使用sphelper.h中提供的函数创建 wav 文件
   if (SUCCEEDED(hr))
   {
      hr = SPBindToFile( m_szWFileName, SPFM_CREATE_ALWAYS, &cpWavStream,
                         &OriginalFmt.FormatId(), OriginalFmt.WaveFormatExPtr() );
    }
   if( SUCCEEDED( hr ) )
   {
      //设置声音的输出到 wav 文件，而不是 speakers
      m_cpVoice->SetOutput(cpWavStream, TRUE);
    }
    //开始朗读
    m_cpVoice->Speak( szWTextString, SPF_ASYNC | SPF_IS_NOT_XML, 0 );

    //等待朗读结束
    m_cpVoice->WaitUntilDone( INFINITE );
    cpWavStream.Release();

    //把输出重新定位到原来的流
    m_cpVoice->SetOutput( cpOldStream, FALSE );

8、设置朗读音量和速度
   m_cpVoice->SetVolume((USHORT)hpos); //设置音量，范围是 0 - 100
   m_cpVoice->SetRate(hpos);  //设置速度，范围是 -10 - 10

hpos的值一般位于

9、设置SAPI通知消息。SAPI在朗读的过程中，会给指定窗口发送消息，窗口收到消息后，可以主动获取SAPI的事件，
根据事件的不同，用户可以得到当前SAPI的一些信息，比如正在朗读的单词的位置，当前的朗读口型值（用于显
示动画口型，中文语音的情况下并不提供这个事件）等等。

   要获取SAPI的通知，首先要注册一个消息：
   m_cpVoice->SetNotifyWindowMessage( hWnd, WM_TTSAPPCUSTOMEVENT, 0, 0 );
   这个代码一般是在主窗口初始化的时候调用，hWnd是主窗口（或者接收消息的窗口）句柄。WM_TTSAPPCUSTOMEVENT
   是用户自定义消息。

在窗口响应WM_TTSAPPCUSTOMEVENT消息的函数中，通过如下代码获取sapi的通知事件：

CSpEvent event; // 使用这个类，比用 SPEVENT结构更方便

    while( event.GetFrom(m_cpVoice) == S_OK )
    {
        switch( event.eEventId )
        {
           。。。
        }
    }

eEventID有很多种，比如SPEI_START_INPUT_STREAM表示开始朗读，SPEI_END_INPUT_STREAM表示朗读结束等。
可以根据需要进行判断使用。

四、结束语

   SAPI的功能很多，比如语音识别、使用语法分析等，由于条件和精力有限，我未能一一尝试，感兴趣的朋友可以自己安装一个研究一下。
   另外提供一个简单例子程序的下载，位置是：
   ftp://vckbase:vckbase@210.192.111.117/user/iwaswzq/Universe.rar
   再次感谢砸玻璃。

============================================
iwaswzq 初稿于 2006/7/26 ，修改于 2006/9/7。
</PRE>

谈谈父窗口和所有者窗口

九月鹰飞 — Tue, 12 Sep 2006 14:43:00 GMT

<PRE>
一、概念和区别

    在windows系统中，每个窗口对象都对应有一个数据结构，形成一个list链表。系统的窗口管理器通过这个list来获取窗口信息和管理每个窗口。这个数据结构中有四个数据用来构建list，即child、sibling、parent、owner四个域。
    所以我们可以看到，窗口之间的关系有两种：owner-owned 关系和 parent-child关系。前者称之为拥有/被拥有关系，后者称之为父/子关系。在这篇文字中，我把owner窗口称之所有者窗口。换句话说，一个窗口在有一个父窗口（parent)的同时，还可能被不同的窗口拥有（owner)，也可以有自己的子窗口(child)。在MFC 的CWnd类中，所有者窗口保存在m_hWndOwner成员变量中，父窗口则保存在m_hParent中，但是这两个值并不一定和窗口对象数据结构中的值相对应。

    窗口之间的关系，决定了窗口的外在表现。比如显示、销毁等。

    如果一个窗口数据的owner域非NULL，则它和该窗口建立了owner-owned 关系，拥有关系决定了：
    （1）被拥有的窗口永远显示在拥有它的那个窗口的前面；
    （2）当所有者窗口最小化的时候，它所拥有的窗口都会被隐藏；
    （3）当所有者窗口被销毁的时候，它所拥有的窗口都会被销毁。
    需要注意的是，隐藏所有者窗口并不会影响它所拥有的窗口的可见状态。比如：如果窗口 A 拥有窗口B,窗口B拥有窗口C,则当窗口A最小化的时候，窗口B被隐藏，但是窗口 C还是可见。

    如果一个窗口的parent域非NULL，则它和该窗口之间就建立了parent-child关系。父子决定了：
    （1）窗口在屏幕上面的显示位置。父窗口提供了用来定位子窗口的坐标系统，一个子窗口只能显示在它的父窗口的客户区中，之外的部分将被裁减。这个裁减法则决定了如果父窗口不可见，则子窗口肯定不可见。如果父窗口移动到了屏幕之外，子窗口也一样。
    （2）当父窗口被隐藏时，它的所有子窗口也被隐藏。
    （3）父窗口被销毁的时候，它所拥有的子窗口都会被销毁。
     注意！最小化父窗口不会影响子窗口的可见状态，子窗口会随着父窗口被最小化，但是它的WS_VISIBLE属性不会变。

Windows系统为什么要使用两种关系呢？这是为了更加灵活的管理窗口。举个例子：组合框（combobox)的下拉列表框（list box）可以超出组合框的父窗口的客户区，这样有利于显示，因此系统创建该list box的时候，是作为控制台窗口（desktop window）的子窗口，它的父窗口hWndParent是NULL，这样，list box的显示区域是限制在整个屏幕内，但是该list box的所有者却是组合框的第一个非子窗口祖先（比如对话框），当它的所有者窗口销毁后，该 list box自动销毁。

另外，窗口之间消息的传递也和窗口关系有关，通常，一个窗口会把自己的通知消息发送给它的父窗口，但不全是这样，比如，CToolBar发送通知消息给它的所有者窗口而不是父窗口。这样以来，就可以允许工具条作为一个窗口（比如一个 OLE 容器程序窗口）的子窗口的同时，能够给另一个窗口（比如in-place框架窗口）发送消息。至于某类窗口到底是把消息发送给谁，是父窗口还是所有者窗口，microsoft并没有明示。还有，在现场（in-place）编辑的情况下，当一个 server 窗口激活或者失效的时候，框架窗口所拥有的子窗口自动隐藏或者显示，这也是通过直接调用SetOwner函数实现的。

二、窗口类型的说明和限制

（1）控制台窗口（desktop window）。这是系统最早创建的窗口。可以认为它是所有 WS_OVERLAPPED 类型窗口的所有者和父窗口。Kyle Marsh在他的文章“Win32 Window Hierarchy and Styles”中指出，当系统初始化的时候，它首先创建控制台窗口，大小覆盖整个屏幕。所有其它窗口都在这个控制台窗口上面显示。窗口管理器所用的窗口list中第一个就是这个控制台。它的下一层窗口叫做顶级窗口（top-level），顶级窗口是指所有非child、没有父窗口，或者父窗口是desktop的窗口，它们没有WS_CHILD属性。

（2）WS_OVERLAPPED类型的窗口可以显示在屏幕的任何地方。它们的所有者窗口是控制台。

Overlapped 类型的窗口属于顶级窗口，一般作为应用程序的主窗口。不论是否给出了WS_CAPTION、WS_BORDER属性，这类窗口创建后都有标题栏和边框。Overlapped窗口可以拥有其它顶级窗口或者被其它顶级窗口所拥有。所有overlapped窗口都有WS_CLIPSIBLINGS属性。系统可以自动设置 overlapped窗口的大小和初始位置。

当系统 shuts down的时候，它将销毁所有overlapped类型的窗口。

（3）WS_POPUP类型的窗口可以显示在屏幕任何地方，它们一般没有父窗口，但是如果明确调用SetParent，这类窗口也可以有父窗口。

WS_POPUP类型的窗口的所有者是在CreateWindow函数中通过设置hWndParent参数给定的，如果hWndParent不是子窗口，则该窗口就成为这个新的弹出式窗口的owner，否则，系统从hWndParent的父窗口向上找，直到找到第一个非子窗口，把它作为该弹出窗口的owner。当owner窗口销毁的时候，系统自动销毁这个弹出窗口。

Pop-up类型的窗口也属于顶级窗口，它和 overlapped 窗口的主要区别是弹出式窗口不需要有标题栏，也不必有边框。弹出式可以拥有其它顶级窗口或者被拥有。所有弹出式窗口也都有 WS_CLIPSIBLINGS属性。

（4）所有者窗口（owner)只能是 overlapped 或者 pop-up 类型的窗口，子窗口不能是所有者窗口，也就是说子窗口不能拥有其它窗口。

overlapped 或者 pop-up 类型的窗口在拥有其它窗口的同时，也可以被拥有。

在使用CreateWindowEx创建 WS_OVERLAPPED 或者 WS_POPUP类型的窗口时，可以在 hwndParent 参数中给出它的所有者窗口的句柄。如果 hwndParent 给出的是一个child 类型的窗口句柄，则系统自动将新创建窗口的所有权交给该子窗口的顶级父窗口。在这种情况下，参数hwndParent被保存在新建窗口的parent域中，而它的所有者窗口句柄则保存在owner域中。

（5）缺省情况下，对话框和消息框属于 owned 窗口，除非在创建它们的时候明确给出了WS_CHILD属性，（比如对话框中嵌入对话框的情形）
否则由系统负责给它们指定owner窗口。需要注意的是，一旦创建了owned类型的窗口，就无法再改变其所有关系，因为WIN32没有没有提供改变窗口所有者的方法。

而且在Win32中，由于有多线程的存在，所以要注意保证父子窗口或者owner/owned 窗口要同属于一个线程。

（6）对于 WS_CHILD类型的窗口，它的父窗口就是它的所有者窗口。一个子窗口的父窗口也是在CreateWindow函数中用hWndParent参数指定的。子窗口只能在父窗口的客户区中显示，并随父窗口一起销毁。
子窗口必须有一个父窗口，这是它和overlapped 以及 pop-up 窗口之间的主要区别。父窗口可以是顶级窗口，也可以是其它子窗口。

三、几个相关函数的说明

（1）获取/设置所有者窗口

win32 API提供了函数GetWindow函数（GW_OWNER 标志）来获取一个窗口的所有者窗口句柄。
GetWindow(hWnd, GW_OWNER)永远返回窗口的所有者(owner)。对于子窗口，函数返回 NULL，因为它们的父窗口就相当于所有者（注意，是“相当于”）。因为Windows系统没有维护子窗口的所有者信息。

    MFC中则是通过如下函数得到所有者窗口指针：
    _AFXWIN_INLINE CWnd* CWnd::GetOwner() const
      { return m_hWndOwner != NULL ? CWnd::FromHandle(m_hWndOwner) : GetParent(); }
    从上述代码我们可以看出，它返回的值和GetWindow返回的有所区别，如果当前窗口没有owner，那么将返回它的父窗口指针。

    但是Windows没有提供改变窗口所有者的方法。MFC中则提供了改变所有者的方法：
    _AFXWIN_INLINE void CWnd::SetOwner(CWnd* pOwnerWnd)
      { m_hWndOwner = pOwnerWnd != NULL ? pOwnerWnd->m_hWnd : NULL; }

另外，mfc还提供了CWnd::GetSafeOwner( CWnd* pParent, HWND* pWndTop );函数，可以用来得到参数pParent的第一个非child属性的父窗口指针。如果这个参数是NULL，则返回当前线程的主窗口(通过AfxGetMainWnd得到)。框架经常使用这个函数查找对话框或者属性页的所有者窗口。

（2）获取/设置父窗口

WIN32 API给出了函数GetParent和SetParent。而mfc也是完全封装了这两个函数：

    _AFXWIN_INLINE CWnd* CWnd::SetParent(CWnd* pWndNewParent)
      { ASSERT(::IsWindow(m_hWnd)); return CWnd::FromHandle(::SetParent(m_hWnd,
   pWndNewParent->GetSafeHwnd())); }

_AFXWIN_INLINE CWnd* CWnd::GetParent() const
{ ASSERT(::IsWindow(m_hWnd)); return CWnd::FromHandle(::GetParent(m_hWnd)); }

对于SetParent，msdn里面说明了父子窗口必须是同一个进程的。但是由于窗口句柄是系统全局唯一的，不属于同一个进程的情况下，也可以成功调用，但是后果未知。
GetParent的返回值比较复杂，对于overlapped类型的窗口，它返回0，对于WS_CHILD类型，它返回其父窗口，对于WS_POPUP类型，它返回其所有者窗口，如果想得到创建它时所传递进去的那个hwndParent参数，应该用GetWindowWord(GWW_HWNDPARENT)函数。

（3）GetWindowWord(hWnd, GWW_HWNDPARENT)返回一个窗口的父窗口，如果没有，则返回其所有者。

（4）上面谈到，当一个owner窗口被最小化后，系统自动隐藏它所拥有的窗口。当owner窗口被恢复的时候，系统自动显示它所拥有的窗口。在这两种情况下，系统都会发送（send）WM_SHOWWINDOW消息给被拥有的窗口。某些时候，我们可能需要隐藏 owned窗口，但并不想最小化其所有者窗口，这时候，可以通过ShowOwnedPopups函数来实现，该函数设置或者删除当前窗口所拥有的窗口的WS_VISIBLE属性，然后发送WM_SHOWWINDOW消息更新窗口显示。

==========================
iwaswzq 初稿于2005/5/19 ，修改于2006/9/12
</PRE>

从内存中加载动态库(二)

九月鹰飞 — Fri, 28 Jul 2006 04:57:00 GMT

<PRE>
五、加载类的源代码。（编译环境vc6,win98）

typedef BOOL (__stdcall *ProcDllMain)(HINSTANCE, DWORD, LPVOID );

class CMemLoadDll
{
public:
CMemLoadDll();
~CMemLoadDll();
BOOL MemLoadLibrary( void* lpFileData , int DataLength); // Dll file data buffer
FARPROC MemGetProcAddress(LPCSTR lpProcName);
private:
BOOL isLoadOk;
BOOL CheckDataValide(void* lpFileData, int DataLength);
int CalcTotalImageSize();
void CopyDllDatas(void* pDest, void* pSrc);
BOOL FillRavAddress(void* pBase);
void DoRelocation(void* pNewBase);
int GetAlignedSize(int Origin, int Alignment);
private:
ProcDllMain pDllMain;

private:
DWORD pImageBase;
PIMAGE_DOS_HEADER pDosHeader;
PIMAGE_NT_HEADERS pNTHeader;
PIMAGE_SECTION_HEADER pSectionHeader;
};

CMemLoadDll::CMemLoadDll()
{
isLoadOk = FALSE;
pImageBase = NULL;
pDllMain = NULL;
}
CMemLoadDll::~CMemLoadDll()
{
if(isLoadOk)
{
  ASSERT(pImageBase != NULL);
  ASSERT(pDllMain   != NULL);
  //脱钩，准备卸载dll
  pDllMain((HINSTANCE)pImageBase,DLL_PROCESS_DETACH,0);
  VirtualFree((LPVOID)pImageBase, 0, MEM_RELEASE);
}
}

//MemLoadLibrary函数从内存缓冲区数据中加载一个dll到当前进程的地址空间，缺省位置0x10000000
//返回值：成功返回TRUE , 失败返回FALSE
//lpFileData: 存放dll文件数据的缓冲区
//DataLength: 缓冲区中数据的总长度
BOOL CMemLoadDll::MemLoadLibrary(void* lpFileData, int DataLength)
{
if(pImageBase != NULL)
{
return FALSE; //已经加载一个dll，还没有释放，不能加载新的dll
}
//检查数据有效性，并初始化
if(!CheckDataValide(lpFileData, DataLength))return FALSE;
//计算所需的加载空间
int ImageSize = CalcTotalImageSize();
if(ImageSize == 0) return FALSE;

// 分配虚拟内存
void *pMemoryAddress = VirtualAlloc((LPVOID)0x10000000, ImageSize,
     MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if(pMemoryAddress == NULL) return FALSE;
else
{
  CopyDllDatas(pMemoryAddress, lpFileData); //复制dll数据，并对齐每个段
  //重定位信息
  if(pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress >0
   && pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size>0)
  {
   DoRelocation(pMemoryAddress);
  }
  //填充引入地址表
  if(!FillRavAddress(pMemoryAddress)) //修正引入地址表失败
  {
   VirtualFree(pMemoryAddress,0,MEM_RELEASE);
   return FALSE;
  }
  //修改页属性。应该根据每个页的属性单独设置其对应内存页的属性。这里简化一下。
  //统一设置成一个属性PAGE_EXECUTE_READWRITE
  unsigned long old;
  VirtualProtect(pMemoryAddress, ImageSize, PAGE_EXECUTE_READWRITE,&old);
}
//修正基地址
pNTHeader->OptionalHeader.ImageBase = (DWORD)pMemoryAddress;

//接下来要调用一下dll的入口函数，做初始化工作。
pDllMain = (ProcDllMain)(pNTHeader->OptionalHeader.AddressOfEntryPoint +(DWORD) pMemoryAddress);
BOOL InitResult = pDllMain((HINSTANCE)pMemoryAddress,DLL_PROCESS_ATTACH,0);
if(!InitResult) //初始化失败
{
  pDllMain((HINSTANCE)pMemoryAddress,DLL_PROCESS_DETACH,0);
  VirtualFree(pMemoryAddress,0,MEM_RELEASE);
  pDllMain = NULL;
  return FALSE;
}

isLoadOk = TRUE;
pImageBase = (DWORD)pMemoryAddress;
return TRUE;
}

//MemGetProcAddress函数从dll中获取指定函数的地址
//返回值：成功返回函数地址 , 失败返回NULL
//lpProcName: 要查找函数的名字或者序号
FARPROC CMemLoadDll::MemGetProcAddress(LPCSTR lpProcName)
{
if(pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress == 0 ||
pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size == 0)
return NULL;
if(!isLoadOk) return NULL;

DWORD OffsetStart = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
DWORD Size = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size;

PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY)((DWORD)pImageBase + pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
int iBase = pExport->Base;
int iNumberOfFunctions = pExport->NumberOfFunctions;
int iNumberOfNames = pExport->NumberOfNames; //<= iNumberOfFunctions
LPDWORD pAddressOfFunctions = (LPDWORD)(pExport->AddressOfFunctions + pImageBase);
LPWORD pAddressOfOrdinals = (LPWORD)(pExport->AddressOfNameOrdinals + pImageBase);
LPDWORD pAddressOfNames = (LPDWORD)(pExport->AddressOfNames + pImageBase);

int iOrdinal = -1;

if(((DWORD)lpProcName & 0xFFFF0000) == 0) //IT IS A ORDINAL!
{
iOrdinal = (DWORD)lpProcName & 0x0000FFFF - iBase;
}
else //use name
{
int iFound = -1;

  for(int i=0;i<iNumberOfNames;i++)
  {
   char* pName= (char* )(pAddressOfNames[i] + pImageBase);
   if(strcmp(pName, lpProcName) == 0)
   {
    iFound = i; break;
   }
  }
  if(iFound >= 0)
  {
   iOrdinal = (int)(pAddressOfOrdinals[iFound]);
  }
}

if(iOrdinal < 0 || iOrdinal >= iNumberOfFunctions ) return NULL;
else
{
  DWORD pFunctionOffset = pAddressOfFunctions[iOrdinal];
  if(pFunctionOffset > OffsetStart && pFunctionOffset < (OffsetStart+Size))//maybe Export Forwarding
   return NULL;
  else return (FARPROC)(pFunctionOffset + pImageBase);
}

}

// 重定向PE用到的地址
void CMemLoadDll::DoRelocation( void *NewBase)
{
/* 重定位表的结构：
// DWORD sectionAddress, DWORD size (包括本节需要重定位的数据)
// 例如 1000节需要修正5个重定位数据的话，重定位表的数据是
// 00 10 00 00   14 00 00 00      xxxx xxxx xxxx xxxx xxxx 0000
// -----------   -----------      ----
// 给出节的偏移总尺寸=8+6*2     需要修正的地址           用于对齐4字节
// 重定位表是若干个相连，如果address 和 size都是0 表示结束
// 需要修正的地址是12位的，高4位是形态字，intel cpu下是3
*/
//假设NewBase是0x600000,而文件中设置的缺省ImageBase是0x400000,则修正偏移量就是0x200000
DWORD Delta = (DWORD)NewBase - pNTHeader->OptionalHeader.ImageBase;

//注意重定位表的位置可能和硬盘文件中的偏移地址不同，应该使用加载后的地址
PIMAGE_BASE_RELOCATION pLoc = (PIMAGE_BASE_RELOCATION)((unsigned long)NewBase
  + pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
while((pLoc->VirtualAddress + pLoc->SizeOfBlock) != 0) //开始扫描重定位表
{
  WORD *pLocData = (WORD *)((int)pLoc + sizeof(IMAGE_BASE_RELOCATION));
  //计算本节需要修正的重定位项（地址）的数目
  int NumberOfReloc = (pLoc->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION))/sizeof(WORD);
  for( int i=0 ; i < NumberOfReloc; i++)
  {
   if( (DWORD)(pLocData[i] & 0xF000) == 0x00003000) //这是一个需要修正的地址
   {
    // 举例：
    // pLoc->VirtualAddress = 0x1000;
    // pLocData[i] = 0x313E; 表示本节偏移地址0x13E处需要修正
    // 因此 pAddress = 基地址 + 0x113E
    // 里面的内容是 A1 ( 0c d4 02 10) 汇编代码是： mov eax , [1002d40c]
    // 需要修正1002d40c这个地址
    DWORD * pAddress = (DWORD *)((unsigned long)NewBase + pLoc->VirtualAddress + (pLocData[i] & 0x0FFF));
    *pAddress += Delta;
   }
  }
  //转移到下一个节进行处理
  pLoc = (PIMAGE_BASE_RELOCATION)((DWORD)pLoc + pLoc->SizeOfBlock);
}
}

//填充引入地址表
BOOL CMemLoadDll::FillRavAddress(void *pImageBase)
{
// 引入表实际上是一个 IMAGE_IMPORT_DESCRIPTOR 结构数组，全部是0表示结束
// 数组定义如下：
//
    // DWORD   OriginalFirstThunk;         // 0表示结束，否则指向未绑定的IAT结构数组
    // DWORD   TimeDateStamp;
    // DWORD   ForwarderChain;             // -1 if no forwarders
    // DWORD   Name;                       // 给出dll的名字
    // DWORD   FirstThunk;                 // 指向IAT结构数组的地址(绑定后，这些IAT里面就是实际的函数地址)
unsigned long Offset = pNTHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress ;
if(Offset == 0) return TRUE; //No Import Table
PIMAGE_IMPORT_DESCRIPTOR pID = (PIMAGE_IMPORT_DESCRIPTOR)((unsigned long) pImageBase + Offset);
while(pID->Characteristics != 0 )
{
  PIMAGE_THUNK_DATA pRealIAT = (PIMAGE_THUNK_DATA)((unsigned long)pImageBase + pID->FirstThunk);
  PIMAGE_THUNK_DATA pOriginalIAT = (PIMAGE_THUNK_DATA)((unsigned long)pImageBase + pID->OriginalFirstThunk);
  //获取dll的名字
  char buf[256]; //dll name;
  BYTE* pName = (BYTE*)((unsigned long)pImageBase + pID->Name);
  for(int i=0;i<256;i++)
  {
   if(pName[i] == 0)break;
   buf[i] = pName[i];
  }
  if(i>=256) return FALSE; // bad dll name
  else buf[i] = 0;
  HMODULE hDll = GetModuleHandle(buf);
  if(hDll == NULL)return FALSE; //NOT FOUND DLL
  //获取DLL中每个导出函数的地址，填入IAT
  //每个IAT结构是：
  // union { PBYTE ForwarderString;
        //   PDWORD Function;
        //   DWORD Ordinal;
        //   PIMAGE_IMPORT_BY_NAME AddressOfData;
  // } u1;
  // 长度是一个DWORD ，正好容纳一个地址。
  for(i=0; ;i++)
  {
   if(pOriginalIAT[i].u1.Function == 0)break;
   FARPROC lpFunction = NULL;
   if(pOriginalIAT[i].u1.Ordinal & IMAGE_ORDINAL_FLAG) //这里的值给出的是导出序号
   {
    lpFunction = GetProcAddress(hDll, (LPCSTR)(pOriginalIAT[i].u1.Ordinal & 0x0000FFFF));
   }
   else //按照名字导入
   {
    //获取此IAT项所描述的函数名称
    PIMAGE_IMPORT_BY_NAME pByName = (PIMAGE_IMPORT_BY_NAME)
     ((DWORD)pImageBase + (DWORD)(pOriginalIAT[i].u1.AddressOfData));
//    if(pByName->Hint !=0)
//     lpFunction = GetProcAddress(hDll, (LPCSTR)pByName->Hint);
//    else
     lpFunction = GetProcAddress(hDll, (char *)pByName->Name);
   }
   if(lpFunction != NULL)   //找到了！
   {
    pRealIAT[i].u1.Function = (PDWORD) lpFunction;
   }
   else return FALSE;
  }

//move to next
pID = (PIMAGE_IMPORT_DESCRIPTOR)( (DWORD)pID + sizeof(IMAGE_IMPORT_DESCRIPTOR));
}
return TRUE;
}

//CheckDataValide函数用于检查缓冲区中的数据是否有效的dll文件
//返回值：是一个可执行的dll则返回TRUE，否则返回FALSE。
//lpFileData: 存放dll数据的内存缓冲区
//DataLength: dll文件的长度
BOOL CMemLoadDll::CheckDataValide(void* lpFileData, int DataLength)
{
//检查长度
if(DataLength < sizeof(IMAGE_DOS_HEADER)) return FALSE;
pDosHeader = (PIMAGE_DOS_HEADER)lpFileData; // DOS头
//检查dos头的标记
if(pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) return FALSE; //0x5A4D : MZ

//检查长度
if((DWORD)DataLength < (pDosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS)) ) return FALSE;
//取得pe头
pNTHeader = (PIMAGE_NT_HEADERS)( (unsigned long)lpFileData + pDosHeader->e_lfanew); // PE头
//检查pe头的合法性
if(pNTHeader->Signature != IMAGE_NT_SIGNATURE) return FALSE;  //0x00004550 : PE00
if((pNTHeader->FileHeader.Characteristics & IMAGE_FILE_DLL) == 0) //0x2000 : File is a DLL
  return FALSE;
if((pNTHeader->FileHeader.Characteristics & IMAGE_FILE_EXECUTABLE_IMAGE) == 0) //0x0002 : 指出文件可以运行
  return FALSE;
if(pNTHeader->FileHeader.SizeOfOptionalHeader != sizeof(IMAGE_OPTIONAL_HEADER)) return FALSE;

//取得节表（段表）
pSectionHeader = (PIMAGE_SECTION_HEADER)((int)pNTHeader + sizeof(IMAGE_NT_HEADERS));
//验证每个节表的空间
for(int i=0; i< pNTHeader->FileHeader.NumberOfSections; i++)
{
if((pSectionHeader[i].PointerToRawData + pSectionHeader[i].SizeOfRawData) > (DWORD)DataLength)return FALSE;
}
return TRUE;
}

//计算对齐边界
int CMemLoadDll::GetAlignedSize(int Origin, int Alignment)
{
return (Origin + Alignment - 1) / Alignment * Alignment;
}
//计算整个dll映像文件的尺寸
int CMemLoadDll::CalcTotalImageSize()
{
int Size;
if(pNTHeader == NULL)return 0;
int nAlign = pNTHeader->OptionalHeader.SectionAlignment; //段对齐字节数

// 计算所有头的尺寸。包括dos, coff, pe头和段表的大小
Size = GetAlignedSize(pNTHeader->OptionalHeader.SizeOfHeaders, nAlign);
// 计算所有节的大小
for(int i=0; i < pNTHeader->FileHeader.NumberOfSections; ++i)
{
  //得到该节的大小
  int CodeSize = pSectionHeader[i].Misc.VirtualSize ;
  int LoadSize = pSectionHeader[i].SizeOfRawData;
  int MaxSize = (LoadSize > CodeSize)?(LoadSize):(CodeSize);

  int SectionSize = GetAlignedSize(pSectionHeader[i].VirtualAddress + MaxSize, nAlign);
  if(Size < SectionSize)
   Size = SectionSize; //Use the Max;
}
return Size;
}
//CopyDllDatas函数将dll数据复制到指定内存区域，并对齐所有节
//pSrc: 存放dll数据的原始缓冲区
//pDest:目标内存地址
void CMemLoadDll::CopyDllDatas(void* pDest, void* pSrc)
{
// 计算需要复制的PE头+段表字节数
int HeaderSize = pNTHeader->OptionalHeader.SizeOfHeaders;
int SectionSize = pNTHeader->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
int MoveSize = HeaderSize + SectionSize;
//复制头和段信息
memmove(pDest, pSrc, MoveSize);

//复制每个节
for(int i=0; i < pNTHeader->FileHeader.NumberOfSections; ++i)
{
  if(pSectionHeader[i].VirtualAddress == 0 || pSectionHeader[i].SizeOfRawData == 0)continue;
  // 定位该节在内存中的位置
  void *pSectionAddress = (void *)((unsigned long)pDest + pSectionHeader[i].VirtualAddress);
  // 复制段数据到虚拟内存
  memmove((void *)pSectionAddress,
       (void *)((DWORD)pSrc + pSectionHeader[i].PointerToRawData),
    pSectionHeader[i].SizeOfRawData);
}

//修正指针，指向新分配的内存
//新的dos头
pDosHeader = (PIMAGE_DOS_HEADER)pDest;
//新的pe头地址
pNTHeader = (PIMAGE_NT_HEADERS)((int)pDest + (pDosHeader->e_lfanew));
//新的节表地址
pSectionHeader = (PIMAGE_SECTION_HEADER)((int)pNTHeader + sizeof(IMAGE_NT_HEADERS));
return ;
}

谨依此文祝贺我在VCKBASE里升级。
iwaswzq 2006/7/27
</PRE>

从内存中加载动态库(一)

九月鹰飞 — Fri, 28 Jul 2006 04:55:00 GMT

<PRE>

    程序使用动态库DLL一般分为隐式加载和显式加载两种，分别对应两种链接情况。本文主要讨论显式加载的技术问题。我们知道，要显式加载一个DLL，并取得其中导出的函数地址一般是通过如下步骤：
    (1) 用LoadLibrary加载dll文件，获得该dll的模块句柄；
    (2) 定义一个函数指针类型，并声明一个变量；
    (3) 用GetProcAddress取得该dll中目标函数的地址，赋值给函数指针变量；
    (4) 调用函数指针变量。

这个方法要求dll文件位于硬盘上面。现在假设我们的dll已经位于内存中，比如通过脱壳、解密或者解压缩得到，能不能不把它写入硬盘文件，而直接从内存加载呢？答案是肯定的。经过多天的研究，非法操作了N次，修改了M个BUG，死亡了若干脑细胞后，终于有了初步的结果，下面做个总结与大家共享。

一、加载的步骤

    由于没有相关的资料说明，只能凭借感觉来写。首先LoadLibrary是把dll的代码映射到exe进程的虚拟地址空间中，我们要实现的也是这个。所以先要弄清楚dll的文件结构。好在这个比较简单，它和exe一样也是PE文件结构，关于PE文件的资料很多，阅读一番后，基本上知道了必须做的几个工作：
    (1)判断内存数据是否是一个有效的DLL。这个功能通过函数CheckDataValide完成。原型是：
        BOOL CMemLoadDll::CheckDataValide(void* lpFileData, int DataLength);
    (2)计算加载该DLL所需的虚拟内存大小。这个功能通过函数CalcTotalImageSize完成。原型是：
        int CMemLoadDll::CalcTotalImageSize();
    (3)将DLL数据复制到所分配的虚拟内存块中。该功能通过函数CopyDllDatas完成。要注意段对齐。
        void CMemLoadDll::CopyDllDatas(void* pDest, void* pSrc);
    (4)修正基地重定位数据。这个功能通过函数DoRelocation完成。原型是：
        void CMemLoadDll::DoRelocation( void *NewBase);
    (5)填充该DLL的引入地址表。这个功能由函数FillRavAddress完成。原型是：
        BOOL CMemLoadDll::FillRavAddress(void *pImageBase);
    (6)根据DLL每个节的属性设置其对应内存页的读写属性。我这里做了简化，所有内存区域都设置成一样的读写属性。
    (7)调用入口函数DllMain，完成初始化工作。这一步我一开始忽略了，所以总是发现自己加载的dll和LoadLibrary加载的dll有些不同(我把整块内存区域保存到两个文件中进行比较，够晕的)。只是最近猜想到还需要这一步。
    (8)保存dll的基地址（即分配的内存块起始地址）,用于查找dll的导出函数。从现在开始这个dll已经完全映射到了进程的虚拟地址空间，可以使用它了。
    (9)不需要dll的时候，释放所分配的虚拟内存。

二、要说明的几个问题

   (1)目前CMemLoadDll仅仅针对win32 动态库，没有考虑mfc常规和扩展dll。
   (2)只考虑使用dll中的函数，对于导出类的dll，由于通常都是隐式链接，所以也没有考虑。导出变量的dll虽然也是隐式链接，但是通过查找函数的方法也可以找到该变量，不过在取值的时候一定要符合dll中对变量的定义，比如dll中导出的是一个int变量，则得到该变量在dll中的地址后，需要强制转换成int*指针，然后取值。
   (3)查找函数的功能通过函数
       FARPROC CMemLoadDll::MemGetProcAddress(LPCSTR lpProcName);
实现，参数是dll导出的函数（或者变量）的名字。这里必须注意函数名修饰，通常不加extern"C"的函数，编译以后在dll中导出的都是修饰名，比如：
    在dll头文件中: extern __declspec(dllexport) int nTestDll;
    在.dll中的导出符号变成 ?nTestDll@@3HA
   所以，为了能够找到我们需要的函数，必须在.h中添加extern "C"修饰。最好是给dll加一个def文件，里面明确给出每个函数的导出名字。
   (4)PE中的内容比较多，有些细节没有考虑。比如CheckDataValide函数中没有考虑dll对操作系统版本的要求。
   (5)PE文件中的节有很多种。可以从节表（或者叫做区块表）中一一找到。而且每个节的属性都不同。例如：.text, .data, .rsrc, .crt等等。由于这个代码基于手头已有的pe文件资料，对于不熟悉的节，在映射dll数据的时候没有考虑是否需要处理。
   (6)一开始把dll映射到进程的地址空间以后，我试图直接使用GetProcAddress查找函数。最初我认为LoadLibrary返回的HINSTANCE值是0x10000000，把它传递给GetProcAddress可以找到目标函数，而我也把dll映射到0x10000000这个地址，但是当我把这个值传递给GetProcAddress的时候，发现无法找到函数，用GetLastError得到错误码一看是无效句柄的错误，这才明白原来LoadLibrary在加载dll的时候，同时创建了一个句柄放入进程的句柄表，而我们要做这个工作是比较麻烦的，所以只能自己写一个查找函数。
   (7)释放dll所占据的虚拟内存，原来我使用
      VirtualFree((LPVOID)pImageBase, 0,MEM_FREE);
后来发现有问题，应该使用 VirtualFree((LPVOID)pImageBase, 0, MEM_RELEASE);
   (8)MemGetProcAddress不仅支持通过函数名查找，还支持通过导出序号查找函数。例如下面的用法：
DLLFUNCTION fDll = (DLLFUNCTION)a.MemGetProcAddress((LPCTSTR)1);

三、创建测试用的DLL，工程的名字取"TestDll"

    用VC向导创建一个WIN32 DLL工程，里面选择“导出一些符号”，为了测试需要，对源代码进行如下修改：
（1）头文件
    // This class is exported from the TestDll.dll
    class TESTDLL_API CTestDll {
        public:
CTestDll(void);
    };
    extern TESTDLL_API int nTestDll;
    //要修改的地方，添加了extern "C" 和 char *参数：
    extern "C" TESTDLL_API int fnTestDll(char *);
（2）cpp文件
      a. 添加 #include "stdlib.h"
      b. DllMain中
  case DLL_PROCESS_DETACH:
   nTestDll = 12345;
   break;
      c. 初始化变量
         TESTDLL_API int nTestDll=654321;
      d. 修改函数
         TESTDLL_API int fnTestDll(char *p)
         {
         if(p == NULL)
      return nTestDll;
         else
      return atoi(p);
          }

四、创建测试工程。使用一个dlg工程，测试代码如下：

    假设 DllNameBuffer里面保存有dll文件的路径
CFile f;
if(f.Open(DllNameBuffer,CFile::modeRead))
{
  int FileLength = f.GetLength();
  void *lpBuf = new char[FileLength];
  f.Read(lpBuf, FileLength);
  f.Close();

  CMemLoadDll a;
  if(a.MemLoadLibrary(lpBuf, FileLength)) //加载dll到当前进程的地址空间
  {
   typedef int (*DLLFUNCTION)(char *);
   DLLFUNCTION fDll = (DLLFUNCTION)a.MemGetProcAddress("fnTestDll");
   if(fDll != NULL)
   {
    MessageBox("找到函数！！");
    CString str;
    str.Format("Result is: %d & %d",fDll(NULL), fDll("100"));
    MessageBox(str);
   }
   else
   {
    DWORD err = GetLastError();
    CString str;
    str.Format("Error: %d",err);
    MessageBox(str);
   }
  }

delete[] lpBuf;
}

五、加载类源代码。（在后续贴子里面给出）

iwaswzq 2006/7/27
</PRE>

虚拟列表控件

九月鹰飞 — Fri, 07 Jul 2006 03:00:00 GMT

<PRE>
一、什么是虚拟列表控件

虚拟列表控件是指带有LVS_OWNERDATA风格的列表控件。。

二、为什么使用虚拟列表控件

我们知道，通常使用列表控件CListCtrl，需要调用InsertItem把要显示的数据插入列表中，之后我们就不必关心数据在哪里了，这是因为控件自己开辟了内存空间来保存这些数据。现在假设我们要显示一个数据库，里面的信息量很大，有几十万条记录。通常有两种方法解决这个问题：1是仅仅在ListCtrl中插入少量的数据，比如100个，然后通过[上一页][下一页]两个按钮进行控制，某一时刻显示的只是从xxx到xxx+100之间的记录。2是把所有数据全部插入到ListCtrl中，然后让用户通过滚动来查看数据。无疑，很多用户喜欢采用第二种方式，特别是对于已经排序的数据，用户只需用键盘输入某行的开头字符，就可以快速定位到某一行。但是，如果这样做，InsertItem插入数据的过程将是很漫长的，而且用户会看到ListCtrl刷新速度也很慢，而且所有数据都位于内存中消耗了大量的内存，当数据多达上万以后几乎是不能忍受的。

为此，mfc特别提供了虚拟列表的支持。一个虚拟列表看起来和普通的ListCtrl一样，但是不用通过InsertItem来插入数据，它仅仅知道自己应该显示多少数据。但是它如何知道要显示什么数据呢？秘密就在于当列表控件需要显示某个数据的时候，它向父窗口要。假设这个列表控件包含100个元素，第10到20个元素（行）是可见的。当列表控件重画的时候，它首先请求父窗口给它第10个元素的数据，父窗口收到请求以后，把数据信息填充到列表提供的一个结构中，列表就可以用来显示了，显示第10个数据后，列表会继续请求下一个数据。

在虚拟的样式下，ListCtrl可以支持多达DWORD个数据项。(缺省的listctrl控件最多支持int个数据项)。但是，虚拟列表的最大优点不在于此，而是它仅仅需要在内存中保持极少量的数据，从而加快了显示的速度。所以，在使用列表控件显示一个很大的数据库的情况下，采用虚拟列表最好不过了。

不仅CListCtrl提供虚拟列表的功能， MFC的CListView类也有同样的功能。

三、虚拟列表控件的消息

虚拟列表总共发送三个消息给父窗口：当它需要数据的时候，它发送LVN_GETDISPINFO消息。这是最重要的消息。当用户试图查找某个元素的时候，它发送LVN_ODFINDITEM消息；还有一个消息是LVN_ODCACHEHINT，用来缓冲数据，基本上很少用到这个消息。

虚拟列表控件使用起来非常简单。它总共只有三个相关的消息，如果你直接使用CListCtrl，应该在对话框中响应这三个消息。如果你使用CListCtrl派生类，可以在派生类中响应这三个消息的反射消息。这三个消息分别是：

（1）LVN_GETDISPINFO 控件请求某个数据
（2）LVN_ODFINDITEM 查找某个数据
（3）LVN_ODCACHEHINT 缓冲某一部分数据

我们必须响应的消息是（1），多数情况下要响应(2)，极少数的情况下需要响应（3）

四、如何使用虚拟列表控件

1、首先要创建控件，创建一个虚拟列表和创建一个正常的 CListCtrl差不多。先在资源编辑器里面添加一个list control资源。然后选中"Owner data"属性，然后给它捆绑一个CListCtrl变量。添加列，添加imagelist等都和使用正常的listctrl一样。

2、给虚拟列表添加元素。假设 m_list 是这个列表的控制变量。通常的情况下这样添加数据：

m_list.InsertItem(0, _T("Hello world"));

但是对于虚拟列表，不能这么做。只需告诉列表有多少个数据:

//总共显示100行
m_list.SetItemCount(100);

3、处理它的通知消息。

五、如何响应虚拟列表的消息

1、处理 LVN_GETDISPINFO 通知消息

当虚拟列表控件需要某个数据的时候，它给父窗口发送一个 LVN_GETDISPINFO通知消息，表示请求某个数据。因此列表的所有者窗口（或者它自己）必须处理这个消息。例如派生类的情况 (CMyListCtrl是一个虚拟列表类对象):

//这里处理的是反射消息
BEGIN_MESSAGE_MAP(CMyListCtrl, CListCtrl)
   //{{AFX_MSG_MAP(CMyListCtrl)
   ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnGetdispinfo)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

在LVN_GETDISPINFO的处理函数中，必须首先检查列表请求的是什么数据，可能的值包括:

（1）LVIF_TEXT 必须填充 pszText
（2）LVIF_IMAGE 必须填充 iImage
（3）LVIF_INDENT 必须填充 iIndent
（4）LVIF_PARAM 必须填充 lParam
（5）LVIF_STATE 必须填充 state

根据它的请求，填充所需的数据即可。

//================= 例子代码=====================================

下面的给出一个例子，填充的是列表所需的某个数据项的文字以及图像信息：

LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
LV_ITEM* pItem= &(pDispInfo)->item;

int iItemIndx= pItem->iItem;

if (pItem->mask & LVIF_TEXT) //字符串缓冲区有效
{
    switch(pItem->iSubItem){
        case 0: //填充数据项的名字
            lstrcpy(pItem->pszText,m_Items[iItemIndx].m_strItemText);
            break;
        case 1: //填充子项1
            lstrcpy(pItem->pszText,m_Items[iItemIndx].m_strSubItem1Text);
            break;
        case 2: //填充子项2
            lstrcpy(pItem->pszText,m_Items[iItemIndx].m_strSubItem2Text);
            break;
    }
}
/*注意，多数情况下要使用lstrcpyn ，因为最多复制字符的个数由pItem->cchTextMax给出：
        lstrcpyn(pItem->pszText, text, pItem->cchTextMax);
*/

if (pItem->mask & LVIF_IMAGE) //是否请求图像
pItem->iImage= m_Items[iItemIndx].m_iImageIndex;

甚至连某行数据是否选中（当有checkbox的情况下）的信息也需要由用户自己来维护，例如：
//是否显示该行的选择信息?
if(IsCheckBoxesVisible()) //自定义函数
{
pItem->mask |= LVIF_STATE;
pItem->stateMask = LVIS_STATEIMAGEMASK;

    if(m_database[itemid].m_checked)
    {
         pItem->state = INDEXTOSTATEIMAGEMASK(2);
    }
    else
    {
         pItem->state = INDEXTOSTATEIMAGEMASK(1);
     }
}

2、处理 LVN_ODFINDITEM 消息

在资源管理器里面，定位到某个文件夹，会显示很多文件，如果按下键盘的‘A’，则资源管理器会自动找到名字以 'A'打头的文件夹或者文件, 并选择该文件。继续按 A，如果还有其它名字以'A'打头的文件，则下一个文件被选中。如果输入 "AB"，则 'AB'打头的文件被选中。这就是列表控件的自动查找功能。

当虚拟列表收到一个LVM_FINDITEM消息，它也会发送这个消息通知父窗口查找目标元素。要搜索的信息通过 LVFINDINFO 结构给出。它是 NMLVFINDITEM 结构的一个成员。当找到要搜索的数据后，应该把该数据的索引（行号）返回，如果没有找到，则返回-1。

以对话框为例，响应函数大致如下:

//================= 例子代码=====================================
void CVirtualListDlg::OnOdfinditemList(NMHDR* pNMHDR, LRESULT* pResult)
{
// pNMHDR 里面是要查找的元素的信息
// 要选中的目标元素的行号最后要保存在 pResult 中，这是关键！

NMLVFINDITEM* pFindInfo = (NMLVFINDITEM*)pNMHDR;

/* pFindInfo->iStart 是查找的起始位置，一直到最后，然后从头开始，如果没有找到合适的，最终停留在iStart*/

*pResult = -1;

    //是否按照文字查找？
    if( (pFindInfo->lvfi.flags & LVFI_STRING) == 0 )
    {
        return;
    }

//这是我们要找的字符串
CString searchstr = pFindInfo->lvfi.psz;

int startPos = pFindInfo->iStart;//保存起始位置

    //判断是否最后一行
    if(startPos >= m_list.GetItemCount())
        startPos = 0;

    int currentPos=startPos;

    //开始查找
    do
    {
        if( _tcsnicmp(m_database[currentPos].m_name,
                 searchstr, searchstr.GetLength()) == 0)
        {
            //选中这个元素，停止查找
            *pResult = currentPos;
            break;
        }

currentPos++;

        //从头开始
        if(currentPos >= m_list.GetItemCount())
            currentPos = 0;

}while(currentPos != startPos);
}

显然，如果数据很多，必须实现一个快速查找的方法。

关于pFindInfo->lvfi里面的信息的详细说明可以参考 MSDN。

3、处理 LVN_ODCACHEHINT 消息。

假如我们从数据库或者其它地方读取数据的速度比较慢，则可以利用这个消息，批量读取一些数据，然后根据请求，逐个提供给虚拟列表。LVN_ODCACHEHINT消息的用途就是给程序一个缓冲数据的机会。以提高程序的性能。

//================= 例子代码=====================================
使用 ClassWizard 重载 OnChildNotify 函数，检查是否 LVN_ODCACHEHINT 消息，然后准备缓冲数据：

NMLVCACHEHINT* pcachehint=NULL;

NMHDR* phdr = (NMHDR*)lParam;

if(phdr->code == LVN_ODCACHEHINT)
{
     pcachehint= (NMLVCACHEHINT*) phdr;
     //自定义函数，准备指定范围的数据到缓冲区
     PrepCache(pcachehint->iFrom, pcachehint->iTo);
}
else ...

注意，如果消息不是 LVN_ODCACHEHINT，则要传递给基类进行处理。

五、如何修改ListCtrl显示的数据。

由于是程序自己维护数据，所以只需修改数据库中的数据，然后调用CListCtrl::RedrawItems函数进行重画即可。

六、数据的选择状态和选择框

CListCtrl可以显示checkbox选择框。有些情况下是很有用的。对于正常的listctrl，用户可以用鼠标来修改某个元素的选择状态，但是对于虚拟列表就不行了。必须自己处理一些消息，然后自己保存数据的选中状态:

void CVirtualListDlg::ToggleCheckBox(int item)
{
m_database[item].m_checked = !m_database[item].m_checked;
m_list.RedrawItems(item, item);
}

处理 LVN_KEYDOWN消息，添加对空格键的响应，用于切换选择状态：

void CVirtualListDlg::OnKeydownList(NMHDR* pNMHDR, LRESULT* pResult)
{
LV_KEYDOWN* pLVKeyDown = (LV_KEYDOWN*)pNMHDR;

    if( pLVKeyDown->wVKey == VK_SPACE )
    {
       int item = m_list.GetSelectionMark();
        if(item != -1)
            ToggleCheckBox(item);
    }

*pResult = 0;
}

然后处理 NM_CLICK 消息:

void CVirtualListDlg::OnClickList(NMHDR* pNMHDR, LRESULT* pResult)
{
NMLISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;

LVHITTESTINFO hitinfo;
hitinfo.pt = pNMListView->ptAction;

int item = m_list.HitTest(&hitinfo);

    if(item != -1)
    {
        //看看鼠标是否单击在 check box上面了?
        if( (hitinfo.flags & LVHT_ONITEMSTATEICON) != 0)
        {
            ToggleCheckBox(item);
        }
    }

    *pResult = 0;
}

七、备注：

1、虚拟列表无法进行排序。

2、虚表的一个优点是容易保持和数据库的同步。修改数据库中的数据，然后重画list十分容易而且高效。

3、虚表的另一个优点是可以根据需要产生数据。比如在某一列加上行号。

iwaswzq 2006/6/21 0:16
--------------------------------------------------------------------------------
</PRE>

奇怪的SetCheck

九月鹰飞 — Sun, 19 Feb 2006 08:01:00 GMT

一、问题的提出

CTreeCtrl有个属性TVS_HASBUTTONS，如果创建控件的时候加上了这个属性，则在每个节点的左侧
都有一个按钮，用来表示节点的选择状态。通过两个函数SetCheck / GetCheck来设置和获取指定
节点的选择状态。

但是奇怪的是，在对话框中按照常规的方法使用了SetCheck，最后CTreeCtrl并没有显示节点被选
中，下面是测试例子：

   1、用wizard创建一个对话框工程，并且在上面放置一个CTreeCtrl控件。
   2、设置CTreeCtrl的属性，"More Styles"里面选中"Check Boxes"，给它加上复选框。
   3、对话框初始化的时候，给CTreeCtrl控件添加节点，并设置选中。代码如下：

BOOL CTestCheckDlg::OnInitDialog()
{
CDialog::OnInitDialog();
。。。
// TODO: Add extra initialization here
HTREEITEM hRoot = m_Tree.InsertItem("Root");
m_Tree.SetCheck(hRoot);
m_Tree.InsertItem("Child1", hRoot);
m_Tree.InsertItem("Child2", hRoot);
m_Tree.Expand(hRoot, TVE_EXPAND );

return TRUE;
}

但是，对话框运行以后，树控件的根节点并没有显示被选中。用GetCheck测试，返回FALSE。但是
如果在OnInitDialog里面SetCheck以后，立刻用GetCheck测试，发现返回的却是TRUE。

进一步测试可以发现，对话框显示以后，任何时候再次使用SetCheck都没有问题了。

二、问题分析

由于无法直接监视树控件根节点状态的变化，为了弄清楚树控件究竟是什么时候修改了我们设置的
check状态，我在其他消息响应函数中进一步用GetCheck检查，发现对话框在第一次OnPaint的时候
，树控件根节点的check状态还是选中的，但紧接着下个消息来到后，它的状态就发生了改变。我
思来想去肯定是树控件本身的问题。可能是它第一次画自己的时候，修改了每个节点的选择状态。

但是它为何这么做？我开始猜测和它的图表列表有关系。为了验证这个想法，加入下面的代码：

CImageList* pStateIcon = m_Tree.GetImageList(TVSIL_STATE);
int nItem = (pStateIcon == NULL)?(0):(pStateIcon->GetImageCount());
CString str;
str.Format("Count of State Icon: %d\n", nItem);
TRACE(str);

果然不出所料，测试结果发现，在OnInitDialog里面，树控件虽然添加了数据，但是它的State Icon
并没有加载，ImageList是空的。一旦它显示自己后，ImageList就不是NULL了，里面的图标数目是3。
也就是说它使用了3个图标。

显然是树控件在创建自己的时候，并没有加载所需的图标列表，而是在显示的时候，发现需要后，它才
加载，并且重新复位了每个节点的选择状态。它之所以这么做，我想可能是出于效率方面的考虑。也就
是说，如果用户没有添加TVS_HASBUTTONS，那么它就不需要这个图标列表了。

三、解决问题

既然知道了问题的所在，那么鉴于在对话框初始化的时候，设置树控件的数据和选择状态是一个常规的
做法，我就不打算修改这些代码的位置，而采用提前给它加载图标列表的方法。方法如下：

   1、在资源中添加一个位图资源IDB_BITMAP1，尺寸拉伸成48*16。（长48，高16，共三个图标）
   2、在位图上面画三个图标，每个大小都是16*16，第二个是X，第三个是选择（对勾）。至于第一个
      的用途，还不清楚。
   3、在对话框的头文件中，添加一个CImageList对象：
      CImageList m_ImageList;
   4、在对话框初始化函数中，添加如下代码：

m_ImageList.Create(IDB_BITMAP1, 16,3,RGB(255,255,255));
m_Tree.SetImageList(&m_ImageList, TVSIL_STATE);

运行以后，发现问题已经解决。只不过树控件的状态图标已经换成了自己的，可以弄得更好看一些。

以上代码的测试环境[win98 / vc6.0]

2006/2/17 iwaswzq

关于f(n)=n的我的算法

九月鹰飞 — Sat, 03 Dec 2005 09:02:00 GMT

上次看到星星贴的一道面试题，觉得有点意思，自己也作了一下。

题目：
有一个整数n,写一个函数f(n),返回0到n之间出现的"1"的个数。比如f(13)=6,现在f(1)=1,问下一个最大的f(n)=n的n是什么？

算法1。大家自然想到一个最简单的算法如下：

#include "stdafx.h"
#include "stdio.h"
#include <windows.h>

//统计一个数字中1的个数
int NumberofOne(int num)
{
int result = 0;
while(num>0)
{
  int r = num%10;
  if(r == 1) result++;
  num /= 10;
}
return result;
}

int main()
{
int sum = 0;
for(int i=0;i<4000000000;i++)
{
  sum += NumberofOne(i);
  if(sum == i)
  {
   printf("f(%d) = %d\n",i,sum);
  }
}
return 0;
}

算法虽然很简单，但是效率太差，应该考虑优化算法，提高计算结果的速度。后来一个网友发布了另一个代码。

算法二：来自http://blog.csdn.net/psyl/archive/2005/11/29/539103.aspx

他用的是剪枝算法，速度还可以，本机测试运算到40亿的话，用了32ms

#include "stdafx.h"
#include "stdio.h"
#include <windows.h>

int gTable[10];
const unsigned int gMAX = 4000000000L;

int f(int n)
{
int ret = 0;
int ntemp=n;
int ntemp2=1;
int i=1;
while(ntemp)
{
  ret += (((ntemp-1)/10)+1) * i;
  if( (ntemp%10) == 1 )
  {
   ret -= i;
   ret += ntemp2;
  }
  ntemp = ntemp/10;
  i*=10;
  ntemp2 = n%i+1;
}
return ret;
}

int count1(int n)
{
int count = 0;
while(n)
{
  if( (n%10) == 1)
   ++count;
  n /= 10;
}
return count;
}

int cal(unsigned int number,int nwei,int count1,unsigned int ncount)
{
int i,n=1;
unsigned int maxcount;
if(nwei==0)
{
  ncount += count1;
  if(number == ncount)
  {
   printf("f(%d) = %d \n",number,number);
  }
  return ncount;
}
for(i=0;i<nwei;++i)
  n *= 10;
maxcount = ncount + gTable[nwei-1];
maxcount += count1*n;
if(ncount > (number + (n-1)) )
{
  return maxcount;
}
if(maxcount < number)
{
  return maxcount;
}
n /= 10;
for(i=0;i<10;++i)
{
  if(i==1)
   ncount = cal(number+i*n,nwei-1,count1+1,ncount);
  else
   ncount = cal(number+i*n,nwei-1,count1,ncount);
}
return ncount;
}

int main(int argc, char* argv[])
{
int i;
unsigned int n=1;
unsigned int ncount = 0;
int nwei = 0;
int ncount1;

int beginTime=GetTickCount();
//init gTable
for(i=0;i<10;++i)
{
n *= 10;
gTable[i] = f(n-1);
}

n=0;
nwei = 0;
ncount1 = 0;
while(n<gMAX)
{
unsigned int temp;

temp = 1;

  ncount =cal(n,nwei,ncount1,ncount);
  for(i=0;i<nwei;++i)
   temp *= 10;
  n += temp;
  if( (n/temp)/10 == 1)
   ++nwei;
  ncount1 = count1(n);
}

int endTime=GetTickCount();
endTime-=beginTime;

printf("time: %d ms\n",endTime);
return 0;
}
因为没有说明，没有仔细研究这个算法。

算法三：这是我的算法。加速变量和优化一起做。基于以下考虑：

1、两个函数i和f(i)都是单增函数，故有：

1、计算n位最大数的f值，例如f(9) = 1; f(99) = 20; f(999) = 300, 自然有：
如果i是n位数字，而且i>f(999..9) ,则可以跳过后面的计算，例如当i>300的时候，可以忽略f(301) 至f(999)。

我称以上优化为后段优化

2、计算i和f(i)之间的差值。
   假设：diff = i - f(i);
   （1）如果diff>0，说明f(i) < i。
        考虑f(i)的增长速度：显然此时f(i)的增加速度<=i的位数。例如i是二位数，f(20) = 11; 差值diff = 20-11 = 9;至少i要增加9/2=4次，
        f(i)才有可能追上i的增长。因此可以直接计算f(20+4);
   （2）如果diff<0, 说明f(i) > i。显然i至少要增长 -diff才有可能追上f(i)。例如f(1622581) = 1642401;
差值diff = 1622581 - 1642401 = -19820;
        可以直接考虑计算f(1622581 + 19820),也就是计算f(1642401)即可。
   我称以上优化为前段优化

综合以上两点，写出如下算法：
#include "stdafx.h"
#include "stdio.h"
#include <windows.h>

//计算从1到num的1的个数
UINT NumberOneBelow(UINT num)
{
UINT mod = 1;
UINT add = 0;
UINT result = 0;
while(num>0)
{
  UINT chu = num/10;
  UINT yu = num%10;
  result += chu * mod;
  if(yu > 1) result += mod;
  if(yu ==1) result += (add+1);
  add += yu * mod;
  mod *= 10;
  num /= 10;
}
return result;
}

//计算n位数之内1的总数统计值，这里的num只考虑它的位数
UINT Total(UINT num)
{
UINT key = num;
UINT add = 1;
while(key>9)
{
add*=10;
key/=10;
}

if(num<10)return 1;
else return 10*Total(num/10)+add;
}
//计算num相关的最大值和位数。例如num是二位数，则max = 99, bit = 2
void MaxAndBit(UINT num, UINT &max, UINT &bit)
{
max = 9;
bit = 1;
while(num>9)
{
  num/=10;
  max*=10; max+=9;
  bit++;
}
return ;
}

int main()
{
UINT max, bit;

UINT TotalOnes = Total(1);
MaxAndBit(1,max,bit);

int beginTime=GetTickCount();

for(UINT i=1;i<4000000000;i++)
{
  //如果i超过n位之内所有1的个数，则跳过后面的计算
  if(i>TotalOnes)
  {
   i = max;
   TotalOnes = Total(i+1);
   MaxAndBit(i+1,max,bit);

   //超过最大整数表示范围，用固定数替换
   if(TotalOnes>1000000000)
   {
    TotalOnes = 4000000000; //实际上，应该是100亿
   }
   continue;
  }
  else
  {
   UINT one = NumberOneBelow(i);
   if(one == i)
   {
    printf("f(%d)=%d\n",i,one);
   }
   else
   {
    //计算差值
    int diff = i-one;
    if(diff > 0)
    {
     i+= diff/bit;
    }
    else
    {
     i = one-1;//下个循环i自动加1后，自动从one开始计算
    }
   }
  }
}

int endTime=GetTickCount();
endTime-=beginTime;

printf("time: %d ms\n",endTime);
return 0;
}

计算到最后一个结果f(1111111110) = 1111111110; 所用时间在16 - 47毫秒之间。

iwaswzq 2005/12/2

scanf中有意思的过滤

九月鹰飞 — Thu, 20 Oct 2005 10:46:00 GMT

1、scanf输入数据的时候，它的参数表达式有过滤功能。比如：
int i,j,k;
scanf("%d空格%d空格%d空格",&i,&j,&k);
你输入 10空格20空格30回车， scanf开始处理，它把10 读入到i中，看到后面的空格，会自动删除之。虽然
最后30后面没有空格也没有关系。但是如果10后面或者20后面没有空格，或者是其它字符，比如：
10,20空格30回车，输入就会出错。当然多个空格也没有关系，例如：10空格空格20空格30回车。因为扫描
整数的时候会自动删除多余的空格。
如果用scanf("%d空格,%d,空格%d",&i,&j,&k); //注意空格和逗号的顺序，则输入和结果的比较是：
10空格,20,空格30               //和表达式正好匹配，没有问题
10,20,30                               //ok
10,空格20,空格30               //ok
10,空格20空格,30               //出错
10空格20空格30                 //更错
2、过滤具有多重功能。例如下面输入字符的例子：
char c;
for(;;)
{
  scanf("%cabc",&c);
  if(c=='q')break;
  printf("c=%c\n",c);
}
则在输入的字符串里面遇到a, ab, abc, 会自动删除。例如输入：
1a2ab3abc4bc5ba6aa7abca8
输出结果是：
c=1
c=2
c=3
c=4
c=b
c=c
c=5
c=b
c=6
c=a
c=7
c=a
c=8

可以看到实际的过滤情况，但是有意思的一点是scanf不会过滤bc，而且一旦成功过滤一组输入，
接下来的数据就会直接读入，例如遇到aa的情况，过滤掉a以后，下一个a被成功读入。

而且上面的例子，如果输入一些数据后，再输入q退出，则还会输出一个c=，表明读入了一个回车符，
真的很奇怪。可以如下测试：
char c;
for(;;)
{
  scanf("%cabc",&c);
  if(c=='q')break;
  if(c!='\n')
   printf("c=%c\n",c);
  else
   printf("haha!\n");
}
3、再做进一步的测试，会发现更诡异的事情，把上面的代码改成：
  scanf("%c abc",&c); //注意abc前面的空格
你会发现输入q以后，程序并没有退出，还需要再输入一个字符。改成scanf("%c",&c);就没有问题了。

上述现象应该不是什么语法问题，是scanf这个函数本身的代码产生的问题。诸如下面这样的代码：
char a[20];
scanf("%[A-Za-z ]s", a);
因为很少用到它，我不想再去研究了，谁感兴趣谁去弄吧，呵呵。