GFlags是Windows debug tools 工具包下的一个工具,在Windows 2000的Resource Kit中也可以找得到。用来设置一些调试属性，总体上分为3个级别System，Kernel和Image File。我们设置好Path环境变量,将其指向Debug tools工具的目录下。

下载安装 gflags:

http://www.microsoft.com/whdc/devtools/debugging/installx86.mspx

http://www.ithov.com/Soft/system/systest/38210.shtml

GFlags 

- 老牌的PageHeap配置工具，有命令行和GUI两种操作方式，功能比较全，包含在Windbg调试器安装包内。同样在Windows 2000 Professional SP2 以上可用。

一些使用GFlags命令行的例子：

配置正常页堆：

"C:\Program Files\Debugging Tools for Windows (x86)\gflags.exe" /p /enable qq.exe

配置完全页堆：

"C:\Program Files\Debugging Tools for Windows (x86)\gflags.exe" /p /enable qq.exe /full

列出当前启动了页堆的进程列表：

"C:\Program Files\Debugging Tools for Windows (x86)\gflags.exe" /p

取消页堆设置：

"C:\Program Files\Debugging Tools for Windows (x86)\gflags.exe" /p /disable qq.exe

一些特殊选项解释：

/unaligned

这个选项只能用于完全页堆。当我们从普通堆管理器分配一块内存时，内存总是8字节对齐的，页堆默认情况下也会使用这个对齐规则，但是这会导致分配的内存块的结尾不能跟页边界精确对齐，可能存在0-7个字节的间隙，显然，对位于间隙范围内的访问是不会被立即发现。更准确的说，读操作将永远不能被发现，写操作则要等到内存块释放时校验间隙空间内的填充信息时才发现。/unaligned用于修正这个缺陷，它指定页堆管理器不必遵守8字节对齐规则，保证内存块尾部精确对齐页边界。

需要注意的是，一些程序启用这个选项可能出现异常，例如IE和QQ就不支持。

/backwards

这个选项只能用于完全页堆。这个选项使得分配的内存块头部与页边界对齐（而不是尾部与边界对齐），通过这个选项来检查头部的访问越界。

/debug

指定一启动进程即Attach到调试器，对于那些不能自动生成dump的程序，是比较有用的选项。

完全页堆：

    当分配一块内存时，通过调整内存块的分配位置，使其结尾恰好与系统分页边界对齐，然后在边界处再多分配一个不可访问的页作为保护区域。这样，一旦出现内存读/写越界时，进程就会Crash，从而帮助及时检查内存越界。

因为每次分配的内存都要以这种形式布局，尤其对于小片的内存分配，即使分配一个字节，也要分配一个内存页，和一个保留的虚拟内存页（注意在目前的实现中，这个用作边界保护区域的页从来不会被提交）。这就需要大量的内存，到底一个进程需要多少内存，很难估算，因此在使用Page Heap前，至少保证你的机器至少设置了1G虚拟内存以上。

正常页堆

    正常页堆原理与CRT调试内存分配函数类似，通过分配少量的填充信息，在释放内存块时检查填充区域。来检测内存是否被损坏，此方法的优点是极大的减少了内存耗用量。缺点是只能在释放块时检测，不太好跟踪出错的代码位置。

页堆能处理的错误类型：

错误类型                    正常页堆               整页堆 

堆句柄无效                     立即发现                 立即发现 

堆内存块指针无效               立即发现                 立即发现 

多线程访问堆不同步             立即发现                 立即发现 

假设重新分配返回相同地址(realloc)  90% 内存释放后发现   90% 立即发现 

内存块重复释放                 90% 立即发现             90% 立即发现 

访问已释放的内存块             90% 在实际释放后发现     90% 立即发现 

访问块结尾之后的内容           在释放后发现             立即发现 

访问块开始之前的内容           在释放后发现             立即发现 

以下是举例：

前期工作： 将gflags（默认安装在C:\Program Files\Debugging Tools for Windows (x86)）加入到path

案例1：
int _tmain(int argc, _TCHAR* argv[])
{
     char *p = new char[8];
     p[8] = 10;

     delete[] p;
     return 0;
}
程序本身是有问题的。数组已经越界，但是debug模式下并不报错，release模式下也很大可能是不crash的。

在命令提示符下运行：

>gflags /p /enable test.exe /full

在release模式运行test.exe。exception将直接定位到 p[8] = 10; 这一行

案例2：
int _tmain(int argc, _TCHAR* argv[])
{
     char *p = new char[9];
     p[9] = 10;

     delete[] p;
     return 0;
}
以上代码和案例1仅有一点不同，就是数组大小。但是如果运行
gflags /p /enable test.exe /full

在release模式下并不会出现exception并定位到 p[9] = 10;
原因是没有设置 /unaligned 参数，具体看说明。案例2中，数组有9字节大小，按内存8字节对齐的说法，这块内存应该是

16字节，后面还有7字节的空间，所以 p[9] = 10; 并不会产生exception。设置 /unaligned 参数，禁止8字节对齐，就

可以跟踪到 p[9] = 10; 这个exception

>gflags /p /enable test.exe /full /unaligned

案例3：
class A
{
public:
 int a;
 void del(){
  delete this;
  a = 10;
 }
};
int _tmain(int argc, _TCHAR* argv[])
{
 A* a = new A();
 a->del();
 return 0;
}

在debug模式下可能产生exception:
HEAP:   Free   Heap   block   xxxxxxxx modified   at   xxxxxxxx  after   it   was   freed
在release模式下运行并不报错，但是程序本身是有问题的，delete this; 之后，又给成员变量 a=10;

这显然是不对的。

>gflags /p /enable test.exe /full
此时在debug下运行程序，会产生exception，并定位到   a = 10;

首先一种比较直观简洁的方式就是用WinDbg等调试器直接attach到需要调试的进程，调试完毕之后再detach即可。但是这种方式有个缺点就是执行debugger命令时必须先break这个进程，执行完debug命令之后又得赶紧F5让他继续运行，因为被你break住的时候意味着整个进程也已经被你挂起。另外也经常会由于First Chance Excetpion而自动break，你得时刻留意避免长时间break整个进程。所以这样的调试方式对时间是个很大的考验，往往没有充裕的时间来做仔细分析。

另一种方式则是在出现问题的时候，比如CPU持续长时间100%，内存突然暴涨等非正常情况下，通过对服务进程snapshot抓取一个dump文件，完成dump之后先deatch，让进程继续运行。然后用windbg等工具来分析这个抓取到的dump文件。

那么如何在不终止进程的情况下抓取dump文件呢？Debugging Tools for Windows里提供了一个非常好的工具，adplus.vbs。从名字可以看出，实际上是一个vb脚本，只是对cdb调试器作的一个包装脚本。

其路径与Debugging Tools for Windows的安装路径相同，使用的方法也很简单，如下所示:

adplus.vbs -hang -p 1234 -o d:\dump

其中-hang指明使用hang模式，亦即在进程运行过程中附加上去snapshot抓取一个dump文件，完成之后detach。与之对应的是-crash崩溃模式，用户先启动adplus，然后由它启动要监控的程序，在出现异常崩溃时自动生成dump文件，或者通过Ctrl-C人为发出抓取指令。但是-crash模式在抓取完成之后，被监控的进程就必须终止。因此我们在这里只选用-hang模式。

-p是要调试的进程ID，比如ASP.NET应用线程池，在Win2003下就是w3wp.exe

-o 指定要output的dump文件路径。

另外，与adplus类似的，有个UserDump工具，但是抓取用户模式的进程，而adplus则是内核模式和用户模式两者皆可。

而总所周至的Dr. Waston，则会在进程崩溃之后的自动时候抓取dump文件，一样可以用于windbg等调试器来事后分析程序崩溃时的状态。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
0:000> !dumpheap -stat
No export dumpheap found
======解决方法：
.load clr20\sos.dll，你要先执行的。sos.dll在默认的c:\windows\microsoft.net\framework\v2.....下面，你复制到c:\program files\debugging tools for windows下面的clr20目录下面（clr20是你手工创建的）
 ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
    
  在.NET下开发时，最基本的调试方法就是使用Visual Studio的单步调试。但是对于一些特殊情况，特别是涉及到CLR内部的时候使用这种方式就达不到目的了。
  如果要查看运行时内存使用情况，IL代码，CLR信息等可以使用以下两种方式：
  1、使用VS2005 + sos.dll
  2、使用Windbg + sos.dll
  第二种方式功能更加强大，下面我就通过实际操作展示一下怎么使用这种方法得到运行时ArrayList内部的值。
  有人可能会说：我直接用Visual Studio的单步调试岂不是更快？当然，这个只是一个演示，通过这个演示是为以后的高级调试打下基础
  
  在操作之前，先熟悉一下基本知识：
  A、使用VS2005 + sos.dll调试
  1、需要在项目->属性->调试-〉启用非托管代码调试
  2、打开调试-〉窗口-〉即时
  3、在即时窗口中输入 !load sos 加载调试模块
  4、输入其它调试语句
  
  B、使用Windbg + sos.dll
  1、去微软的网站下载最新的Windbg
  2、打开Windbg在File-〉Symbol File Path ...窗口中输入 srv*c:\symbols*http://msdl.microsoft.com/download/symbols
  3、运行需要调试的程序，然后在Windbg中File-〉Attach to Process中选择刚才运行的程序
  4、在出现的Command窗口中就可以输入调试语句
  5、常用调试语句：
   lm //查看加载了哪些模块
   .load C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\sos.dll //加载调试模块
   ld TestClass //加载调试符号
   !name2ee TestClass.exe TestClass.Program.test //显示test方法相关的地址
   !dumpmt -md 00976d48 //得到类的成员函数详细信息
   !dumpil 00973028 // 显示这个方法被编译器编译之后的IL代码
   !dumpheap -stat //该命令显示程序中所有对象的统计信息，显示的大小是对象本身的大小，不包括对象里面值的大小
   !dumpheap -mt 790fcb30 //该命令显示MethodTable 790fcb30的详细信息
   !gcroot 012919b8 //来显示一个实例的所属关系
   !dumpobj(do) 012a3904 //显示一个对象的具体内容，看对象里面有什么，值是什么
   !ObjSize 012a1ba4 //对象实际在内存中的大小
   !eeheap -gc //查看托管堆的情况(包括大小)
   !DumpArray //查看数组信息
   下面就来看看具体的调试步骤：
  1、我们的测试代码
  
  
  namespace TestClass
  {
   class Program
   {
   [STAThread]
   static void Main(string[] args)
   {
   ArrayList list = new ArrayList();
   list.Add("aaaa");
   list.Add("bbbb");
   Console.ReadLine();
   }
   }
  }很简单，就是一个ArrayList
  
  运行这个程序(开始执行，不调试)，然后进入Windbg，Attach到这个进程
  
  2、查看所有堆栈信息
  0:004> !dumpheap -stat
   MT Count TotalSize Class Name
  7910062c 1 12 System.Security.Permissions.SecurityPermission
  7918e284 1 16 System.IO.TextReader+SyncTextReader
  79102d10 1 20 Microsoft.Win32.SafeHandles.SafeFileMappingHandle
  79102cb4 1 20 Microsoft.Win32.SafeHandles.SafeViewOfFileHandle
  79101d30 1 20 System.Text.InternalEncoderBestFitFallback
  79100a7c 1 20 Microsoft.Win32.SafeHandles.SafeFileHandle
  79105cd4 1 24 System.Collections.ArrayList
  ......
  7912ad90 11 9036 System.Object[]
  790fcb30 2083 131492 System.String
  Total 2202 objects
  除了我们的ArrayList外，还有很多其它的系统信息，先不用管它
  
  3、查看我们的ArrayList的信息
  0:004> !dumpheap -mt 79105cd4
   Address MT Size
  012a1b88 79105cd4 24
  total 1 objects
  Statistics:
   MT Count TotalSize Class Name
  79105cd4 1 24 System.Collections.ArrayList
  Total 1 objects
  
  4、查看对应地址内部实际的值
  0:004> !do 012a1b88
  Name: System.Collections.ArrayList
  MethodTable: 79105cd4
  EEClass: 79105c28
  Size: 24(0x18) bytes
   (C:\WINDOWS\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll)
  Fields:
   MT Field Offset Type VT Attr Value Name
  7912ad90 40008df 4 System.Object[] 0 instance 012a1bb0 _items
  791018e0 40008e0 c System.Int32 1 instance 2 _size
  791018e0 40008e1 10 System.Int32 1 instance 2 _version
  790fc35c 40008e2 8 System.Object 0 instance 00000000 _syncRoot
  7912ad90 40008e3 1c0 System.Object[] 0 shared static emptyArray
   >> Domain:Value 00149c58:012a1ba0 <<
  可以看到ArrayList的大小为2，具体的值保存在地址012a1bb0中，是一个System.Object[]类型的数组
  
  5、查看数组信息
  0:004> !DumpArray 012a1bb0
  Name: System.Object[]
  MethodTable: 7912ad90
  EEClass: 7912b304
  Size: 32(0x20) bytes
  Array: Rank 1, Number of elements 4, Type CLASS
  Element Methodtable: 790fc35c
  [0] 012a1b50
  [1] 012a1b6c
  [2] null
  [3] null
  
  6、查看数组内对象的值
  0:004> !do 012a1b50
  Name: System.String
  MethodTable: 790fcb30
  EEClass: 790fca90
  Size: 26(0x1a) bytes
   (C:\WINDOWS\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll)
  String: aaaa
  Fields:
   MT Field Offset Type VT Attr Value Name
  791018e0 4000096 4 System.Int32 1 instance 5 m_arrayLength
  791018e0 4000097 8 System.Int32 1 instance 4 m_stringLength
  790fe534 4000098 c System.Char 1 instance 61 m_firstChar
  790fcb30 4000099 10 System.String 0 shared static Empty
   >> Domain:Value 00149c58:790d81bc <<
  7912b1d8 400009a 14 System.Char[] 0 shared static WhitespaceChars
   >> Domain:Value 00149c58:012a16f0 << 
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

windbg使用小总结
【抓dump】
1、一般抓法
adplus -hang -p 3230 -quiet 抓3230 pid进程，hang模式，相当于把那个进程暂停住，取内存快照
adplus -crash -pn w3wp -quiet 抓w3wp进程，crash模式，当那个进程崩溃结束的时候自动抓取当时的内存
adplus -hang -iis -quiet 抓IIS相关进程，包括其上host的web应用，以及iis自身
2、抓window服务
http://support.microsoft.com/kb/824344/zh-cn
3、远程抓
http://blog.joycode.com/tingwang/archive/2006/08/11/79763.aspx
4、抓蓝屏和死机的dump
电脑无故重启或者蓝屏会在C:\WINDOWS\Minidump\下保存一个minidump，但是这个minidump可用的命令很少，一般只打!analyze –v看到是哪个进程引起的，还有相关的驱动模块就基本定位问题了。
5、IIS回收的时候抓
http://blog.yesky.com/blog/omakey/archive/2006/12/17/1618015.html
6、计划任务抓
比如一个进程起来后不知道它什么时候会意外崩溃，可以在计划任务里用crash里抓，当那个进程意外终止的时候，cdb可以直接附加上去，抓取当时的dump，如果要抓一些会自动重启的进程，而且要抓每次重启前的dump，可以参考附录里一节。

【常用命令】
1、先path C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727，把.net路径设置为path环境变量，一遍在windbg里可以直接.load sos，而不必.load C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\sos.dll
2、ld demo，加载你程序的pdb文件，调试.net程序一般要把kernel32和mscorwks的符号加载上，关于这两个东西大家可以查资料，尤其是后者有哪些函数可以多了解一些。
3、在windbg的file/symbol file path对话框里输入以下文字，以便自动加载和下载符号
C:\WINDOWS\Symbols;d:\Program Files\Microsoft Visual Studio 8\SDK\v2.0\symbols;.sympath SRV*d:\localsymbols*http://msdl.microsoft.com/download/symbols
其中有windows、.net2.0和自动从网上下载的调试符号，注意根据自己的情况适当修改目录

【调试死锁】
1、!syncblk，查看哪些线程拿到了锁
2、~67e!clrstack 跳到某个拿到锁的线程看它正在干什么操作，迟迟不肯释放锁
3、!runaway 查看这个占有锁的线程运行了多长时间。
4、~*e!clrstack查看所有线程的托管堆栈，看看哪些是正在等待锁的，比如hang在System.Threading.Monitor.Enter(System.Object)
5、~136s选择该线程，显示如下
0:000> ~136s eax=00005763 ebx=08deeb5c ecx=03eff0d4 edx=5570ab69 esi=08deeb5c edi=7ffd6000 eip=7c95ed54 esp=08deeb10 ebp=08deebb8 iopl=0 nv up ei pl zr na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246 ntdll!KiFastSystemCallRet: 7c95ed54 c3 ret
找到ecx寄存器的值，复制后ctrl+f，向上查找，会找到!syncblk的地方，如下
0:000> !syncblk Index SyncBlock MonitorHeld Recursion Owning Thread Info SyncBlock Owner 1906 03ee4be4 5 1 03ee8f88 22c8 67 185e2ef0 System.Object 5390 052ca39c 3 1 05292b30 1dd4 49 1060d3ac System.Object 9372 0530702c 15 1 0012d3a8 1aa8 80 185e7704 System.Object 11428 03eff0d4 35 1 053b8fa8 169c 120 166acd98 System.Object 15278 0531c6b4 61 1 06bc1430 26d8 86 1a5bea88 System.Object
可以看到136线程等待的锁被120号线程占着不放（格式有点乱，凑合看），
6、有时候通过ecx寄存器找锁不是很确定，可以用~* kb来把所有线程堆栈打出来，然后根据!syncblk出来的同步快的值去搜索大概有多少个线程在等那个锁。因为同样是等待锁，可等的状态不一样，有的在Q里，有的锁已经升级，有的去尝试去拿锁了，所以不一定当时ecx寄存器指向那块内存，具体如何找到某个正在等待锁的线程等待的锁的内存地址，以及它正等待的这个锁被哪个线程拿着，我还没琢磨出规律来，但一般情况下，如果有其它同步对象的话，更难查。.net里用我上面说的几步就能查出锁的问题了。

【内存泄漏】
1、!dumpheap -stat看看哪些对象个数最多，占内存最大，
2、找到某个格式比较多的对象，可以看它的方法表，然后用!dumpheap -mt 66398fa4去随机找几个对象的地址
3、用!do 1e5a22bc命令去查看几个对象的状态，属性的值等，看看正常不正常
4、用!gcroot -nostacks 1e5a22bc去查看几个对象的根正常不正常，如果有些对象的根不是自己预先设计的那样，很可能被自己没想到的对象强引用了，所以GC无法回收它，就泄漏了。
【CPU百分百】
主要用几个计数器和!runaway命令，具体见以下链接
http://www.cnblogs.com/onlytianc ... 7/06/03/769307.html
【线程池耗尽】
!threadpool 能看到完成端口，线程池工作线程和timer回调各占线程池的情况。
【其它】
1、!eestack -short -ee查看所有重要(获取锁的，托管的，停止并允许回收的)线程的dumpstack，差不多相当于~*e!dumpstack
2、.time 可以看到进程跑了多少时间
3、!dso 查看当前线程里有哪些对象，分析内存泄漏问题也许会用到
【小结】
要想很好的用windbg排查.net问题，首先要了解一些clr宿主的基础知识，以及IL的一些基础，还有简单的寄存器和汇编尝试，再就是有个好的思路，最后就是经验和对代码逻辑的理解。

【附录：写了一个自动抓dump的工具，可在程序异常退出的时候抓dump】
【使用方法】
1、先在cmd下运行以下命令确保计划任务开着
net start "task scheduler"
2、执行以下命令安排自动抓包
at 13:27 d:\myapp\autodump\processmon.exe
其中计划启动的时间和自动抓包的程序路径要根据情况设置，计划启动之前当前用户一定要注销。
【相关配置】
<appSettings>
  <add key="adplusPath" value="D:\MyApp\Debugging\adplus.vbs"/><!--adplus的路径-->
  <add key="ProcessName" value="w3wp"/><!--要抓dump的进程的名字，可用部分名字，不用完整的-->
</appSettings>

【源码】

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

namespace ProcessMon
{
    class Program
    {
        static readonly List<int> _dumpPIDs = new List<int>();
        private static readonly string _processName = System.Configuration.ConfigurationManager.AppSettings["ProcessName"];
        private static readonly string _adplusPath = System.Configuration.ConfigurationManager.AppSettings["adplusPath"];
        static void Main(string[] args)
        {
            while(true)
            {
                Console.WriteLine("..");
                ThreadProc();
                Thread.Sleep(10000);
            }
        }

        private static void ThreadProc()
        {
            foreach(Process vProcess in Process.GetProcesses())
            {
                try
                {             
                    string  processName  =  vProcess.ProcessName.ToLower();
                    if (processName.IndexOf(_processName) >= 0)
                    {
                        Console.WriteLine("{0}-{1}", vProcess.ProcessName, vProcess.Id);

                        if (_dumpPIDs.Contains(vProcess.Id))
                            continue;
                        _dumpPIDs.Add(vProcess.Id);
     
                        DumpProcessDeg d = DumpProcess;
                        d.BeginInvoke(vProcess.Id, null, null);
                        DumpProcess(vProcess.Id);
                    }
                }
                catch(Exception ex)
                {
                    Console.WriteLine(ex);
                }
            }
        }

        private delegate void DumpProcessDeg(int pid);
        static  void  DumpProcess(int pid)
        {
            ProcessStartInfo  Info  =  new  System.Diagnostics.ProcessStartInfo();
            Info.FileName = _adplusPath;
            Info.Arguments = string.Format("-crash -p {0} -quiet",pid);
            Info.WorkingDirectory  =  "C:\\";
            Process  Proc  ;
            try
            {
                Proc  =  Process.Start(Info);
            }
            catch(System.ComponentModel.Win32Exception  e)
            {
                Console.WriteLine("系统找不到指定的程序文件。\r{0}",  e);
                return;
            }
            Proc.EnableRaisingEvents = true;
            Console.WriteLine("外部程序的开始执行时间：{0}",  Proc.StartTime);
            Proc.WaitForExit(60000);
            if(Proc.HasExited  ==  false){
                Console.WriteLine("由主程序强行终止外部程序的运行！");
                Proc.Kill();
            }
            else{
                Console.WriteLine("由外部程序正常退出！");
            }
            Console.WriteLine("外部程序的结束运行时间：{0}",  Proc.ExitTime);
            Console.WriteLine("外部程序在结束运行时的返回值：{0}",  Proc.ExitCode);
        }
    }
}

===============
补充几个命令:

1、!analyze -v ：用于分析挂掉线程的详细情形，错误原因。

2、!locks ：列出全部资源使用情况。

3、!locks -v 0x???????? ：特定地址的死锁分析。

4、!thread 0x????????：特定线程详情。

5、.thread 0x????????：转到某个线程堆栈。
 

要消除窗口对象,必须清楚窗口对象的构成.在一个通常的程序中，先创建c++窗口对象,然后由Windows创建实际的窗口结构,并返回句柄与c++对象连接.也就是说,窗口对象包含c++窗口对象和Windows窗口对象,两者通过句柄HWND联系.

现在,让我们看看"正规"的窗口对象清除流程.所谓对象的清除是指释放对象所占的资源,窗口对象中Windows窗口对象占有的是系统资源,c++对象占有的是内存资源.释放系统资源相对要简单一些:调用虚函数DestroyWindow删除Windows窗口对象.如果DestroyWindow删除的是父窗口,Windows会自动为子窗口调用DestroyWindow.一般来说,程序不必调用DestroyWindow.因为当用户关闭窗口时,Windows便发送WM_CLOSE消息,WM_CLOSE的缺省消息处理函数CWnd::OnClose调用DestroyWindow.

到这时,清除工作已经完成了一半,屏幕上的窗口已经不见了!但是别忘了,在内存中还有一个c++窗口对象.让我们再看看c++对象清除的过程:当窗口被取消时,窗口最后发送的一个消息是WM_NCDESTROY.它缺省的消息处理函数CWnd::OnNcDestroy把c++窗口对象与句柄HWND分离,并调用一个很重要的虚函数PostNcDestroy.这个函数是搞清窗口对象清除的关键.Cwnd中的PostNcDestroy什么都不做.有些MFC窗口类会重载它,并加入delete this代码删除c++对象.这些窗口类常常是以new操作符建立在堆中的.由于重载了PostNcDestroy,使窗口有自动清除功能.因此,我们不用关心清除问题了.另外的一些MFC窗口类一般是以变量形式创建的,MFC没有为也没必要为它们重载PostNcDestroy函数.

不具备自动清除功能的窗口类,一般在堆栈中创建或嵌入于其它c++对象中:

所有标准的Windows控件类(如CStatic, CEdit, CListBox等等)

由CWnd类直接派生出来的子窗口对象(如用户定制的控件)

拆分窗口类(CSplitterWnd)

缺省的控制条类(CControlBar的派生类)

对话框类(CDialog)在堆栈上创建的模态对话框类

所有的Windows通用对话框(除CFindReplaceDialog)

由ClassWizard创建的对话框

具有自动清除功能的窗口类,一般在堆中创建:

主框架窗口类(直接或间接从CFrameWnd类派生)

视图类(直接或间接从CView类派生)

从某种程度上来说,MFC的"服务到家"使初学者有些找不着北.不过,不得不承认:MFC干的很漂亮!

谈到这里,我们应该明白c++里一条重要的准则:用DestroyWindow清除窗口对象,不要用"delete".

对于不具备自动清除功能的窗口类使用"delete"时,"delete"先调用析构函数里的DestroyWindow,由于在析构函数中,虚机制不起作用,这里只能调用本地版本(Cwnd类)DestroyWindow函数,显然这不是我们想要的.对于有自动清除功能的窗口类,好象问题更严重一点,前面提到了重载的PostNcDestroy已经含有了"delete this",这样c++对象就被释放了两次.

很多人认为,vc++同vb一样,是一个完全可视化的产品,不用在看c++的书了.通过上面对窗口对象的清除的介绍,可以发现,Windows程序是与Windows紧密结合的,而且牵涉到很多c++的知识(如虚函数、析构函数、new操作符等).要对vc++有进一步理解,必须理解Windows机制,深入学习c++.

　　一、与加速键表有关的几个API函数和结构。

　　操作加速键表使用的几个API函数（关于这几个函数的详细说明请参考有关书籍）：
　　HACCEL LoadAccelerators(HINSTANCE hInstance, LPCTSTR lpTableNAme);
　　LoadAccelerators函数从程序的资源中加载一个加速键表，加载成功后返回一个加速健表的句柄。其中：
　　hInstance　　应用程序的实例句柄。
　　lpTableName　指向加速键表名称字符串的指针。

　　HACCEL CreateAcceleratorTable(LPACCEL lpaccl, int cEntries);
　　CreateAcceleratorTable函数根据一个ACCEL结构数组创建一个加速键表。该函数与LoadAccelerators不同的是：LoadAccelerators函数加载的加速键表在程序结束后系统会自动将该加速键表从内存中清除，但CreateAcceleratorTable函数创建的加速键表需要使用函数DestoryAceleratorTable函数进行清除。
　　lpaccl　　　一个指向ACCEL结构数组的指针。
　　cEntries　　数组中元素的个数。

　　BOOL　DestoryAcceleratorTable(HACCEL hAccel);
　　DestoryAcceleratorTable函数清除由CreateAcceleratorTable函数创建的加速键表，成功则返回TRUE。其中：
　　hAccel　　　需要清除的加速键表句柄。

　　int TranslateAccelerator(HWND hWd, HACCEL hAccTable, LPMSG lpMsg);
　　TranslateAccelerator函数负责翻译加速键。其中：
　　hWnd　　　　 窗口句柄，翻译后的消息将被发往该窗口
　　hAccTable　　加速键表句柄。
　　lpMsg　　　　指向MSG结构的指针。

　　ACCEL结构的定义：
typedef struct tagACCEL{
    BYTE    fVirt;
    WORD    key;
    WORD    cmd;
}ACCEL,*LPACCEL;

其中：
　　fVirt　　　加速键的标记。
　　key　　　　键的代码。如fVirt成员包含FVIRTKEY标志，则key指一个虚键码，否则是一个ASCII码。
　　cmd　　　　命令ID号，该参数将被放入WM＿COMMAND或WM＿SYSCOMMAND消息的wParam参数的低位字发至窗口。

　　二、在windows下如何使用加速键表。

　　在window下使用加速键表一般有两种方法：1，创建一个加速键资源，在程序中使用API函数LoadAccelerators来将加速键表加载入内存。并在消息循环中使用API函数TranslateAccelerator来翻译该加速键表。2、在程序中填充一个ACCEL数组。然后调用API函数CreateAcceleratorTable来创建加速表，翻译加速键同上，但不要忘记在退出程序前使用API函数DestoryAcceleratorTable来清除它。下面分别给出一个例子：

/*例1:使用LoadAccelerators。
　假设你已经建立了一个加速键资源，ID为IDR＿ACCEL。
　假设你已经定义了初始化函数InitApplication(HINSTANCE hInstance,int nCmdShow),
　该函数执行注册窗口类和创建窗口操作。
*/
#include <windows.h>
#include "rc/resource.h"
BOOL InitApplication(HINSTANCE hInstance,int nCmdShow);

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
     MSG msg;
     HANDLE hAccelTable;
     // 初始化应用程序，并生成主窗口.
     if (!InitApplication(hInstance, nCmdShow))
     {
         return FALSE;           // 初始化失败
     }
      //使用函数LoadAccelerators从程序资源中加载加速键表
      hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDR_ACCEL));
      // 取得并分发消息直到接收到 WM_QUIT 消息.
     while (GetMessage(&msg, NULL, 0, 0))
     {
         //在分发消息前首先试着用加速键表进行翻译，如果是一个加速键则由
         //TranslateAccelerator函数进行翻译，不再继续处理该消息。
         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
         {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     return msg.wParam;  // Returns the value from PostQuitMessage
}
 

/*例2:使用CreateAcceleratorTable。
　假设你已经定义了初始化函数InitApplication(HINSTANCE hInstance,int nCmdShow),
　该函数执行注册窗口类和创建窗口操作。
*/

#include <windows.h>
#include "rc/resource.h"

＃define ID_CMD_A      0x00000230
＃define ID_CMD_B      0x00000231
＃define ID_CMD_C      0x00000232
＃define ID_CMD_D      0x00000233
＃define ID_CMD_E      0x00000234
＃define ID_CMD_F      0x00000235
＃define ID_CMD_G      0x00000236

//定义了七个加速键,请在消息回调函数中处理这七个命令ID。
static ACCEL accel[]={
    {FVIRTKEY|FCONTROL,VK_F5,ID_CMD_A},
    {FVIRTKEY|FCONTROL,VK_F6,ID_CMD_B},
    {FVIRTKEY|FCONTROL,VK_HOME,ID_CMD_C},
    {FVIRTKEY|FCONTROL,VK_END,ID_CMD_D},
    {FVIRTKEY|FCONTROL,"G",ID_CMD_E},
    {FVIRTKEY|FCONTROL,VK_SPACE,ID_CMD_F},
    {FVIRTKEY|FCONTROL,"K",ID_CMD_G},
};   

BOOL InitApplication(HINSTANCE hInstance,int nCmdShow);

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
     MSG msg;
     HANDLE hAccelTable;
     // 初始化应用程序，并生成主窗口.
     if (!InitApplication(hInstance, nCmdShow))
     {
         return FALSE;           // 初始化失败
     }
      //使用函数CreateAcceleratorTable从数组accel中加载加速键表
      hAccelTable = CreateAcceleratorTable(accel, sizeof(accel)/sizeof(ACCEL));
      // 取得并分发消息直到接收到 WM_QUIT 消息.
     while (GetMessage(&msg, NULL, 0, 0))
     {
         //在分发消息前首先试着用加速键表进行翻译，如果是一个加速键则由
         //TranslateAccelerator函数进行翻译，不再继续处理该消息。
         if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
         {
             TranslateMessage(&msg);
             DispatchMessage(&msg);
         }
     }
     //删除加速键表
     DestoryAcceleratorTable(hAccelTable);
     return msg.wParam;  // Returns the value from PostQuitMessage
}
 

　　在MFC程序设计中，有关于加速键表的操作已经被CFrameWnd类进行了封装。通常，我们的程序的主框架类CMainFrame从CFrameWnd类派生（SDI界面程序），或者从CMDIFrameWnd类派生（MDI界面程序），而CMDIFrameWnd类也是从CFrameWnd类派生的。所以，我们并不用去关心那个资源号为IDR_MAINFRAME的加速键表是如何加载的，如果你只是需要一个这样的静态的加速键表的话。
　　那么我们能不能使用自己的加速键表呢？答案是：可以的。
　　创建加速键表的方法同前。由于在MFC中，WinMain函数被隐藏，我们不能直接修改WinMain函数，所以，加速键表的创建将在CMainFrame的OnCreate函数中创建。
　　1、在CMainFrame类中添加一个HACCEL类型保护成员变量：m_hMyAccel。在构造函数中初始化为NULL。
　　2、在CMainFrame::OnCreate函数的 “return 0;”句前增加创建加速键表的代码。返回的加速键表句柄保存在m_hMyAccel中：

　　　方法1：(IDR＿MYACCEL为你定义的加速键表资源号)
　　　m_hMyAccel=LoadAccelerators(AfxGetApp()->m_hInstance,MAKEINTRESOURCE(IDR_MYACCEL));

　　　方法2：(accel同前面的例子一样在本文件的开头部分进行定义)
　　　m_hMyAccel=CreateAcceleratorTable(accel,sizeof(accel)/sizeof(ACCEL));

　　3、如果是使用CreateAccelTable函数创建的，则重载虚拟函数DestoryWindow()。在该函数的“return CMDIFrameWnd::DestroyWindow();”前增加如下代码:

    if(m_hMyAccel!=NULL){
        DestroyAcceleratorTable(m_hMyAccel);
        m_hMyAccel=NULL;
    }

　　通过前面的三步，加速键表已经能正确地被创建和删除了，但是它还没有工作。下面就是要让我们刚才所创建的加速键表工作起来。
　　在API程序设计中大家已经知道了加速键是如何工作的。也就是在消息还没有分发出去之前先检查是不是一个加速键。我们通过API函数TranslateAccelerator来实现。在MFC中，消息机制已经被封装了，我们不能去修改消息循环。但是，框架在分发消息前会调用虚拟函数PerTranslateMessage，并且如果该函数返回TRUE，则不再处理该消息。这正是我们所需要的。
　　让我们再回到CMainFrame类，生成PerTranslateMessage函数的覆盖版本。修改函数体如下：

BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
{
    // TODO: Add your specialized code here and/or call the base class
    if(m_hMyAccel&&TranslateAccelerator(m_hWnd, m_hMyAccel, pMsg))
        return TRUE;
    return CMDIFrameWnd::PreTranslateMessage(pMsg);
}

　　好了，现在我们的加速键已经能正常地工作了。以上方法用在其它窗口同样有效（如对话框中，你不妨在对话框中试试）。

　　三、可在运行时编辑的加速键表。

　　通过上面的叙述，你可能已经对可编辑的加速键表有了一定的轮廓。其实其实现思想很简单：只要对一个ACCEL数组进行修改，然后重新生成加速键表就行了。
　　为了区分命令，我们为每个命令取一个名字。在CMainFrame类定义的前面加上下面的一个结构定义：

typedef struct{
    char cCmd[32];
    ACCEL accel;
}ACCELITEM,*LPACCELITEM;

　　我们将使用该结构来保存加速键表的数据。在CMainFrame类中添加两个保护成员变量：

    LPACCELITEM m_lpAccel;
    DWORD m_dwAccelCount;

　　在构造函数中将m_lpAccel初始化为NULL，m_dwAccelCount初始化为0。在数组accel的定义下面增加一个字符串数组的静态变量的定义（用来指定命令的名称,请仿照下面自己定义，个数多少不限，字符串长度不要超过31个字符）：

static char strCmd[][32]={
    "Command One",
    "Command Two",
    "Command Three",
    "Command Four",
    "Command Five"
};

　　在CMainFrame类中添加一个保护成员函数LoadAccel(),该函数用来将加速键表装入，定义如下：

BOOL CMainFrame::LoadAccel()
{
    ASSERT(m_hActAccel==NULL);
    ASSERT(m_lpAccel==NULL);
    m_dwAccelCount=sizeof(accel)/sizeof(ACCEL);
    m_lpAccel=new ACCELITEM[m_dwAccelCount];
    memset(m_lpAccel,0,sizeof(ACCELITEM)*m_dwAccelCount);
    DWORD dwCmdStr=sizeof(strCmd)/sizeof(char[32]);
    for(DWORD dw=0;dw<m_dwAccelCount;dw++){
        m_lpAccel[dw].accel=accel[dw];
        strcpy(m_lpAccel[dw].cCmd,dw<dwCmdStr?strCmd[dw]:"Command Unknow");
    }

    m_hActAccel=CreateAcceleratorTable(accel,m_dwAccelCount);
    return TRUE;

}

　　删除OnCreate函数中原来创建加速键表的代码，改成对LoadAccel()的调用：

    LoadAccel();

　　在CMainFrame的析构函数中增加以下内容：

    if(m_lpAccel)
        delete[] m_lpAccel;

　　为了能够对加速键数据进行编辑，我们在工程中添加一个对话框资源，ID为“IDD_ACCELEDIT”，在对话框上放置三个成组框（Group Box），左边一个标题为“命令”；中间一个标题为“组合键”；右边一个标题为“虚键值”。在左边成组框中放置一个列表框（List Box），ID为“IDC_LST_CMD”。在中间成组框中放置三个核选框（Check Box），上下排列。上面的核选框的ID为“IDC_CHK_ALT”，标题为“Alt”，并勾选“Group”属性；中间的核选框的ID为“IDC_CHK_SHIFT”，标题为“Shift”，取消“Group”属性；下面的核选框的ID为“IDC_CHK_CTRL”，标题为“Ctrl”，取消“Group”属性。在右边的成组框中放置一个列表框，ID为“IDC_LST_KEY”。调整各个控件的尺寸及位置至合适。设置控件的TAB跳转顺序，从左至右、从上到下。依次为：左成组框、IDC_LST_CMD列表框、中成组框、IDC_CHK_ALT核选框、IDC_CHK_SHIFT核选框、IDC_CHK_CTRL核选框、右成组框、IDC_LST_KEY列表框、OK按钮、CANCEL按钮。
　　打开类向导，为对话框新建一个类，类名为“CDlgEditAccel”。为两个列表框和三个核选框映射变量，如下：
　　控件ID:ID_LST_CMD；类型:Control/CListBox；名称:m_LstCmd；
　　控件ID:ID_LST_KEY；类型:Control/CListBox；名称:m_LstKey；
　　控件ID:ID_CHK_ALT；类型:Control/CButton；名称:m_ChkAlt；
　　控件ID:ID_CHK_SHIFT；类型:Control/CButton；名称:m_ChkShift；
　　控件ID:ID_CHK_CTRL；类型:Control/CButton；名称:m_ChkCtrl；

　　在类CDlgEditAccel的定义前加入下面的定义：
typedef struct tag_KeyName{
    CString m_strName;
    WORD m_wID;
    tag_KeyName(CString str,WORD id){m_strName=str,m_wID=id;}
}KEYNAME,*LPKEYNAME;

typedef struct tag_ActAccel{
    CString m_strCmd;
    ACCEL m_Accel;
}ACTACCEL,*LPACTACCEL;

class CActAccelList
{
public:
    CActAccelList();
    ~CActAccelList();

protected:
    LPACTACCEL m_lpActAccel;
    int m_iCount;

public:
    ACTACCEL& operator[](int index);
    BOOL SetSize(int iSize);
    int GetSize();
};

　　在文件DlgEditAccel.cpp文件中定义类CActAccelList的成员函数，代码如下：
CActAccelList::CActAccelList()
{
    m_lpActAccel=NULL;
   m_iCount=0;
}

CActAccelList::~CActAccelList()
{
    if(m_iCount>0&&m_lpActAccel)
        delete[] m_lpActAccel;
}

int CActAccelList::GetSize()
{
    return m_iCount;
}

ACTACCEL& CActAccelList::operator []( int index)
{
    if(!(index>=0&&index<m_iCount))
    AfxThrowMemoryException();
    return m_lpActAccel[index];
}

BOOL CActAccelList::SetSize(int iSize)
{
    if(iSize<0)
        return FALSE;
    if(m_iCount>0&&m_lpActAccel)
        delete[] m_lpActAccel;
    m_iCount=0;
    m_lpActAccel=new ACTACCEL[iSize];
    if(m_lpActAccel==NULL)
        return FALSE;
    m_iCount=iSize;
    return TRUE;
}

　　在DlgAccelEdit.cpp文件头部定义全局变量－－数组key：
static KEYNAME key[]={
    KEYNAME("Left mouse button",VK_LBUTTON),
    KEYNAME("Right mouse button",VK_RBUTTON),
    KEYNAME("Control-break processing",VK_CANCEL),
    KEYNAME("Middle mouse button",VK_MBUTTON),
    KEYNAME("Back Space",VK_BACK),
    KEYNAME("Tab",VK_TAB),
    KEYNAME("Clear",VK_CLEAR),
    KEYNAME("Enter",VK_RETURN),
    KEYNAME("Shift",VK_SHIFT),
    KEYNAME("Ctrl",VK_CONTROL),
    KEYNAME("Alt",VK_MENU),
    KEYNAME("Pause",VK_PAUSE),
    KEYNAME("Caps Lock",VK_CAPITAL),
    KEYNAME("Esc",VK_ESCAPE),
    KEYNAME("Space",VK_SPACE),
    KEYNAME("Page Up",VK_PRIOR), 
    KEYNAME("Page Down",VK_NEXT),
    KEYNAME("End",VK_END),
    KEYNAME("Home",VK_HOME),
    KEYNAME("Left",VK_LEFT),
    KEYNAME("Up",VK_UP),
    KEYNAME("Right",VK_RIGHT),
    KEYNAME("Down",VK_DOWN),
    KEYNAME("Select",VK_SELECT),
    KEYNAME("Excute",VK_EXECUTE),
    KEYNAME("Print Screen",VK_SNAPSHOT),
    KEYNAME("Insert",VK_INSERT),
    KEYNAME("Delete",VK_DELETE),
    KEYNAME("Help",VK_HELP),
    KEYNAME("0",'0'),
    KEYNAME("1",'1'),
    KEYNAME("2",'2'),
    KEYNAME("3",'3'),
    KEYNAME("4",'4'),
    KEYNAME("5",'5'),
    KEYNAME("6",'6'),
    KEYNAME("7",'7'),
    KEYNAME("8",'8'),
    KEYNAME("9",'9'),
    KEYNAME("A",'A'),
    KEYNAME("B",'B'),
    KEYNAME("C",'C'),
    KEYNAME("D",'D'),
    KEYNAME("E",'E'),
    KEYNAME("F",'F'),
    KEYNAME("G",'G'),
    KEYNAME("H",'H'),
    KEYNAME("I",'I'),
    KEYNAME("J",'J'),
    KEYNAME("K",'K'),
    KEYNAME("L",'L'),
    KEYNAME("M",'M'),
    KEYNAME("N",'N'),
    KEYNAME("O",'O'),
    KEYNAME("P",'P'),
    KEYNAME("Q",'Q'),
    KEYNAME("R",'R'),
    KEYNAME("S",'S'),
    KEYNAME("T",'T'),
    KEYNAME("U",'U'),
    KEYNAME("V",'V'),
    KEYNAME("W",'W'),
    KEYNAME("X",'X'),
    KEYNAME("Y",'Y'),
    KEYNAME("Z",'Z'),
    KEYNAME("Left windows",VK_LWIN),
    KEYNAME("Right windows",VK_RWIN),
    KEYNAME("Applications",VK_APPS),
    KEYNAME("Numeric keypad 0", VK_NUMPAD0),
    KEYNAME("Numeric keypad 1", VK_NUMPAD1),
    KEYNAME("Numeric keypad 2", VK_NUMPAD2),
    KEYNAME("Numeric keypad 3", VK_NUMPAD3),
    KEYNAME("Numeric keypad 4", VK_NUMPAD4),
    KEYNAME("Numeric keypad 5", VK_NUMPAD5),
    KEYNAME("Numeric keypad 6", VK_NUMPAD6),
    KEYNAME("Numeric keypad 7", VK_NUMPAD7),
    KEYNAME("Numeric keypad 8", VK_NUMPAD8),
    KEYNAME("Numeric keypad 9", VK_NUMPAD9),
    KEYNAME("Multiply",VK_MULTIPLY),
    KEYNAME("Add",VK_ADD),
    KEYNAME("Separator",VK_SEPARATOR),
    KEYNAME("Subtract",VK_SUBTRACT),
    KEYNAME("Decimal Point",VK_DECIMAL),
    KEYNAME("Divide",VK_DIVIDE),
    KEYNAME("F1",VK_F1),
    KEYNAME("F2",VK_F2),
    KEYNAME("F3",VK_F3),
    KEYNAME("F4",VK_F4),
    KEYNAME("F5",VK_F5),
    KEYNAME("F6",VK_F6),
    KEYNAME("F7",VK_F7),
    KEYNAME("F8",VK_F8),
    KEYNAME("F9",VK_F9),
    KEYNAME("F10",VK_F10),
    KEYNAME("F11",VK_F11),
    KEYNAME("F12",VK_F12),
    KEYNAME("F13",VK_F13),
    KEYNAME("F14",VK_F14),
    KEYNAME("F15",VK_F15),
    KEYNAME("F16",VK_F16),
    KEYNAME("F17",VK_F17),
    KEYNAME("F18",VK_F18),
    KEYNAME("F19",VK_F19),
    KEYNAME("F20",VK_F20),
    KEYNAME("F21",VK_F21),
    KEYNAME("F22",VK_F22),
    KEYNAME("F23",VK_F23),
    KEYNAME("F24",VK_F24),
    KEYNAME("Attn",VK_ATTN),
    KEYNAME("CrSel",VK_CRSEL),
    KEYNAME("ExSel",VK_EXSEL),
    KEYNAME("Erase",VK_EREOF),
    KEYNAME("Play",VK_PLAY),
    KEYNAME("Zoom",VK_ZOOM),
    KEYNAME("Reserved for future use",VK_NONAME ),
    KEYNAME("PA1",VK_PA1),
    KEYNAME("Clear(OEM)",VK_OEM_CLEAR ),

    KEYNAME("file://",'//'),
    KEYNAME("-",'-'),
    KEYNAME("=",'='),
    KEYNAME("[",'['),
    KEYNAME("]",']'),
    KEYNAME(";",';'),
    KEYNAME("\'",'\''),
    KEYNAME(",",','),
    KEYNAME(".",'.'),
    KEYNAME("/",'/'),
    KEYNAME("`",'`')
};

　　在类CDlgAccelEdit中响应Windows消息：WM_INITDIALOD，代码如下：
BOOL CDlgEditAccel::OnInitDialog()
{
    CDialog::OnInitDialog();

    // TODO: Add extra initialization here
    SetWindowText("Edit Accelerator Table");

    int iCount=m_AccelList.GetSize();
    int i;
    for(i=0;i<iCount;i++){
        m_LstCmd.AddString(m_AccelList[i].m_strCmd);
    }
    for(i=0;i<sizeof(key)/sizeof(KEYNAME);i++)
    {
        m_LstKey.AddString(key[i].m_strName);
    }
    m_LstCmd.SetCurSel(0);
    OnSelchangeLstCmd();
    return TRUE;  // return TRUE unless you set the focus to a control
                  // EXCEPTION: OCX Property Pages should return FALSE
}

　　为类CDglAccelEdit增加一个保护成员函数：
    void SaveChange(int index=-1);

　　在文件DlgAccelEdit中定义该函数，代码如下：

void CDlgEditAccel::SaveChange(int index)
{
    if(index>=0||(index=m_LstCmd.GetCurSel())>=0)
    {
        if(m_LstKey.GetCurSel()<0){
            AfxMessageBox("你必需选择一个键码!");
            return;
        }
        BYTE btCmp=((m_ChkAlt.GetCheck()==1)?FALT:NULL)|
                   ((m_ChkCtrl.GetCheck()==1)?FCONTROL:NULL)|
                   ((m_ChkShift.GetCheck()==1)?FSHIFT:NULL)|FVIRTKEY;
        WORD wKey=key[m_LstKey.GetCurSel()].m_wID;

        m_AccelList[index].m_Accel.fVirt=btCmp;
        m_AccelList[index].m_Accel.key=wKey;
        return;
    }
}

　　响应列表框ID_LST_CMD的通知消息“LBN_SELCHANGE”，函数代码如下：
void CDlgEditAccel::OnSelchangeLstCmd()
{
    // TODO: Add your control notification handler code here
    int iCmd=m_LstCmd.GetCurSel();
    WORD wKey=m_AccelList[iCmd].m_Accel.key;
    BYTE btCmp=m_AccelList[iCmd].m_Accel.fVirt;
    m_ChkAlt.SetCheck(btCmp&FALT);
    m_ChkCtrl.SetCheck(btCmp&FCONTROL);
    m_ChkShift.SetCheck(btCmp&FSHIFT);
    int iCount=sizeof(key)/sizeof(KEYNAME);
    int id=-1;
    for(int i=0;i<iCount;i++)
    {
        if(key[i].m_wID==wKey){
            id=i;
            break;
        }
    }
    m_LstKey.SetCurSel(id);

}

　　响应列表框ID_LST_KEY的通知消息“LBN_SELCHANGE”，函数代码如下：
void CDlgEditAccel::OnSelchangeLstKey()
{
    SaveChange(); 
}

　　响应核选框ID_CHK_ALT的通知消息“BN_CLICKED”，函数代码如下：
void CDlgEditAccel::OnChkAlt()
{
    SaveChange();
}

　　响应核选框ID_CHK_SHIFT的通知消息“BN_CLICKED”，函数代码如下：
void CDlgEditAccel::OnChkShift()
{
    SaveChange();
}

　　响应核选框ID_CHK_CTRL的通知消息“BN_CLICKED”，函数代码如下：
void CDlgEditAccel::OnChkCtrl()
{
    SaveChange();
}

　　至此，用于编辑加速键的对话框已经完成。我们现在要做的就是在程序中打开对话框来编辑了。让我们回到CMainFrame类中。我们将在该类中响应一个命令来打开编辑对话框，对加速键表进行编辑。完成后点按OK回到主程序中，然后更新加速键表。这样后，我们刚刚编辑好的加速键表就开始起作用了。
　　首先，打开菜单。在“查看”项后增加一个“工具(&T)”下拉菜单，在下拉菜单中增加一个了菜单：“编辑加速键表(&A)...”，ID为“ID_TOOL_ACCELEDIT”。打开类向导，选择CMainFrame类，响应“ID_TOOL_ACCELEDIT”命令。编辑响应函数如下：

void CMainFrame::OnToolAcceledit()
{
    // TODO: Add your command handler code here
    CDlgEditAccel dlg;

    DWORD i;
    dlg.m_AccelList.SetSize(m_dwAccelCount);
    for(i=0;i<m_dwAccelCount;i++){
        dlg.m_AccelList[i].m_strCmd=m_lpAccel[i].cCmd;
        dlg.m_AccelList[i].m_Accel=m_lpAccel[i].accel;
    }
    if(IDOK==dlg.DoModal()){
        ACCEL* pAccel=new ACCEL[m_dwAccelCount];
        for(DWORD dw=0;dw<m_dwAccelCount;dw++){
            m_lpAccel[dw].accel=pAccel[dw]=dlg.m_AccelList[dw].m_Accel;
        }

        if(m_hActAccel!=NULL)
        DestroyAcceleratorTable(m_hActAccel);
        m_hActAccel=CreateAcceleratorTable(pAccel,m_dwAccelCount);
    }
}

　　在该文件的头部包含类CDlgEditAccel的头文件：

#include "DlgEditAccel.h"

　　至此，可编辑的加速键表已经完成了。不妨试试看。

　　三、将加速键表保存至文件，并在程序运行时自动从文件中加载。

　　上面我们实现了可编辑的加速键表。但是，当程序退出后，我们编辑过的加速键数据就消失了，下次运行程序时还是和以前一样了。将加速键表保存起来以备下次使用，这是我们所希望的。下面讨论的方法是使用文件来保存我们的加速键表。
　　首先，在MainFrm.cpp文件的头部定义一个全局字符串，也就是用于保存加速键的文件名：

static char strAccelFileName[]="Accel.cus";

　　定义一个DWORD值作为文件头，我们通过该DWORD值来判断是否是一个有效格式的文件：

#define ACCEL_FILE_HEAD 0x00434341

　　其次，为CMainFrame类添加一个保护的成员函数：“BOOL SaveAccel()”，编辑其代码如下：
BOOL CMainFrame::SaveAccel()
{
    char lpAppName[256];
    char lpAppPath[256];
    char* lpFilePart=NULL;
    GetModuleFileName(AfxGetInstanceHandle(),lpAppName,255);
    GetFullPathName(lpAppName,255,lpAppPath,&lpFilePart);
    TRACE1("Application File Name:%s.\n",lpAppName);
    strcpy(lpFilePart,strAccelFileName);
    TRACE1("Accelerator File Name:%s.\n",lpAppPath);
    try
    {
        DWORD dwHead=ACCEL_FILE_HEAD;
        DWORD dwCount=m_dwAccelCount;

        CFile fAccel(lpAppPath,CFile::modeCreate|CFile::modeWrite);
        fAccel.SeekToBegin();
        fAccel.Write(&dwHead,sizeof(DWORD));
        fAccel.Write(&dwCount,sizeof(DWORD));
        for(DWORD dw=0;dw<dwCount;dw++)
        {
            fAccel.Write(m_lpAccel+dw,sizeof(ACCELITEM));
        }

        return TRUE;

    }

    catch(CFileException* e)
    {
        char buf[256];
        char buf2[512];
        int iError;
        iError=e->m_cause;
        e->GetErrorMessage(buf,256);
        sprintf(buf2,"将加速键表保存到文件 \"%s\" 中时发生错误!\n"
                     "错 误 号:%d\n"
                     "错误描述:%s\n"
                     "\0",
                     strAccelFileName,iError,buf);
        AfxMessageBox(buf2,MB_OK|MB_ICONSTOP|MB_DEFBUTTON1);
        return FALSE;
    }
}

　　再次，修改LoadAccel()函数如下：

BOOL CMainFrame::LoadAccel()
{
    char lpAppName[256];
    char lpAppPath[256];
    char* lpFilePart=NULL;
    GetModuleFileName(AfxGetInstanceHandle(),lpAppName,255);
    GetFullPathName(lpAppName,255,lpAppPath,&lpFilePart);
    TRACE1("Application File Name:%s.\n",lpAppName);
    strcpy(lpFilePart,strAccelFileName);
    TRACE1("Accelerator File Name:%s.\n",lpAppPath);
    try
    {
        DWORD dwHead;
        DWORD dwCount;

        CFile fAccel(lpAppPath,CFile::modeRead);
        fAccel.SeekToBegin();
        if(fAccel.Read(&dwHead,sizeof(DWORD))!=sizeof(DWORD))
            AfxThrowFileException(CFileException::endOfFile,12,lpAppPath);
        if(dwHead!=ACCEL_FILE_HEAD)
            AfxThrowFileException(CFileException::invalidFile,13,lpAppPath);

        if(fAccel.Read(&dwCount,sizeof(DWORD))!=sizeof(DWORD))
            AfxThrowFileException(CFileException::endOfFile,12,lpAppPath);
       
        ASSERT(m_lpAccel==NULL);
       
        m_lpAccel=new ACCELITEM[dwCount];
        memset(m_lpAccel,0,sizeof(ACCELITEM)*dwCount);
        m_dwAccelCount=dwCount;

        for(DWORD dw=0;dw<dwCount;dw++)
        {
            if(fAccel.Read(m_lpAccel+dw,sizeof(ACCELITEM))!=sizeof(ACCELITEM))
                AfxThrowFileException(CFileException::endOfFile,12,lpAppPath);
        }

        ACCEL* pAccel=new ACCEL[dwCount];
        for(dw=0;dw<dwCount;dw++){
            pAccel[dw]=m_lpAccel[dw].accel;
        }

        m_hActAccel=CreateAcceleratorTable(pAccel,dwCount);

        return TRUE;

    }

    catch(CFileException* e)
    {
        char buf[256];
        char buf2[512];
        int iError;
        iError=e->m_cause;
        e->GetErrorMessage(buf,256);
        sprintf(buf2,"从文件 \"%s\" 中加载加速键表时发生错误!\n"
                     "错 误 号:%d\n"
                     "错误描述:%s\n"
                     "是否生成默认的加速键表?\n\0",
                     strAccelFileName,iError,buf);
        if(IDYES==AfxMessageBox(buf2,MB_YESNO|MB_SYSTEMMODAL|MB_ICONSTOP|MB_DEFBUTTON1))
        {
            ASSERT(m_hActAccel==NULL);
            ASSERT(m_lpAccel==NULL);
            m_dwAccelCount=sizeof(accel)/sizeof(ACCEL);
            m_lpAccel=new ACCELITEM[m_dwAccelCount];
            memset(m_lpAccel,0,sizeof(ACCELITEM)*m_dwAccelCount);
            DWORD dwCmdStr=sizeof(strCmd)/sizeof(char[30]);
            for(DWORD dw=0;dw<m_dwAccelCount;dw++){
                m_lpAccel[dw].accel=accel[dw];
                strcpy(m_lpAccel[dw].cCmd,dw<dwCmdStr?strCmd[dw]:"Command Unknow");
            }
           
            m_hActAccel=CreateAcceleratorTable(accel,m_dwAccelCount);
            SaveAccel();
            return TRUE;
        }
        return FALSE;
    }
}

　　最后，在DestroyWindow()函数头部增加对SaveAccel()函数的调用：

    SaveAccel();
    ...

　　好了，你自己的加速键数据已经能保存在文件中了，并能从中正确加载。如果文件不存在或程序读取时发现错误则提醒你是否建立缺省的加速键表，如你确认的话则生成缺省的加速键表并立刻保存至文件中。
　　由于水平有限，其中难免有误，欢迎批评指正、发表你的意见。本人不胜感激。