致谢 - 《Visual C++ 6.0程序员指南》 - 数字图书馆，智慧电子阅览室系统

致谢 - 图1

美国微软出版社授权的标准、权威、完整的中文图书

M icrosoft Visual C++ 6.0

程序员指南

〔美〕 Beck Zaratian 著希望图书创作室译

希望图书创作室审校

本书配套光盘包括两部分内容：

. 本书英文原版附带光盘中的例子代码及可执行程序
. 与本书配套的中文版电子书

北京希望电脑公司出品

1 9 9 8

内容提要

本书是美国微软出版社授权的 M icrosoft Visual Studio 系列中文版图书之一，它是 Visual C++ 6.0 程序员的实用参考书。全书共分成六个部分：第一部分介绍 Developer Studio 和 AppWizard 的基础知识；第二部分介绍文本、图形和对话框编辑器；第三部分是编程指南，展示了如何使用 ClassWizard 和 Gallery 来加速编程开发工作，创建自己的组件；第四部分介绍 ActiveX 控件及其使用，说明如何用 MFC 或 ATL 来写 ActiveX 控件；第五部分讨论调试器的各种能力，程序优化的各种选项及原因，如何定制 Visual C++ ，如何编制宏和附加实用程序；第六部分提供 ASCII 字符和 ANSI 字符的标准表格，并简要描述 ClassWizard 支持的 MFC 类和 VBScrip t。

书中讨论的许多主题均以范例程序进行说明，所有范例程序的项目文件都在配套光盘上。本书是从事 Visual C++ 6.0 应用与开发的所有技术人员极好的工具书，同时也是大专院校相关专业的师生的自学、教学参考用书。

本书配套光盘包括两部分内容： 1. 本书英文原版附带光盘中的例子代码及可执行程序； 2. 与本书配套的中文版电子书。

需要本书和配套光盘及需技术支持的读者请与北京海淀 8721 信箱书刊部联系，邮政编码： 100080 ，联系电话： 010-62562329 ， 62541992 ， 62531267 ，传真： 010-62579874 。

版权声明

本书英文版名为《 M icrosoft Visual C++ 6.0 Programme r’s Guide 》，由 Microsoft 出版社出版，版权归 M icrosoft 出版社所有。本书中文版由 Microsoft 出版社授权出版。未经出版者书面许可，本书的任何部分不得以任何形式或任何手段复制或传播。

本书封四上贴有防伪标签，无标签者不得销售，违者必究！

M icrosoft Visual C++ 6.0 程序员指南

[ 美 ] Beck Zaratian 著希望图书创作室译希望图书创作室审校责任编辑刘晓融

北京希望电脑公司出品

北京海淀路 82 号（ 100080 ）

印刷

新华书店、新华书店音像发行所发行、各地书店及软件专卖店经销

* * * * *

1998 年 12 月第 1

版

1998 年 12 月第 1

次印刷

开本： 787 × 1092 印张： 39.125

字数： 916 千字印数： 1-5000

新出音管 [1998]164 号

ISBN 7-980021-23-1/TP · 16

定价： 68.00 元（ 1CD ，含配套书）

致谢

第二版要比第一版容易写，因为在第二版中问题已解决了一半。我乐意写 ( 或者更准确地说，是扩展 ) 这本书的主要原因是，我又一次得到了具有献身精神的人们的帮助。尽管处理过较早版本的 M icrosoft Press 小组已经转向出版书籍的其他任务，但他们的贡献仍在，他们认真负责的工作态度和敬业精神在本书留下了深深的烙印。

在第一版中，项目编辑 Lucinda Rowley 在百忙之中花费了许多时间，他审阅手稿具有敏锐的观察力 ( 在书名为《 M icrosoft Visual C++ Owner's Manual》的版本中，我将 Lucinda 誉为 “ 每位作家梦寐以求的编辑 ”，他的确名符其实 )。手稿编辑 Vicky Thulman 推敲了每个句子，而技术编辑 Linda Ebenstein 和 Jim Johnson 确保所述内容的确切。

项目编辑 Saul Candib 和技术编辑 Jim Fuchs ， M ary DeJong 和 M ichael Hochberg 仔细审阅了新材料。旧金山的 Labrecque 出版社在编辑、版式、校对和制作管理等方面做了大量工作，为此谨向 Chrisa Hotchkiss、 Curtis Philip s、 Lisa Bravo 、 Andrea Fox 和 Lisa Labrecque 表示谢意。

我不仅得到了来自 Press 和 Labrecque 的帮助，而且得到微软公司 42 楼 Visual C++ 分部的支持。如同以前一样， Laura Hamilton 充当了联络员的角色，我很感激，因为如果没有她的帮助，我将无法写出这本书来。 Laura 是一名高级编辑，

她可以保证本书和在线《 Visual C++ User's Guide》的质量。

这个版本离不开 Visual C++ 小组 ( 以及其他领域 ) 中许多人的帮助，他们为第一版做了勘误，提出了有价值的建议。其他人审阅了这一版的新材料，集思广益确保本书的结构严谨和内容实用。在此谨向 Dennis Andersen 、 Cathy Anderson 、Chuck Bell、 D iane Berkeley 、 Patricia Cornette 、 Stacey Doerr 、 Chris Flaat、 Jocelyn Garner、 Anita George、 Eric Gunnerson 、 Karl Hilsmann 、 M ark Hopkin s、 Simon Koeman 、 Chris Koziarz 、 Louis Lafreniere 、 Martin Lovell、 M ichael Maio 、 Bruce M cKinney 、 Diane Melde 、 Daryn Robbins、 Steve Ross 、 David Schwartz 、 Scott Semyan 、 Teeri Sharkey 、 George Shepherd 、 Kathy Shoesmith 、 Suzanne Sowinska 、Yefim Siga l 、 Chuck Sphar 、 Yeong-Kan Tam 、 Donn Trenton 和 Laura Wall 表示谢意。这些人中的一部分是我认识多年的朋友，其他则从未见过面，仅仅通过电子邮件和联邦快递相互通信。

特别值得一提的是微软公司的 Barbara Ellsworth ，没有她，本书将无法写成。感谢 Barb 。

本书中文版的问世渗透了参与策划、翻译、录排、审校和出版人员的大量心血。本书由贺军、贺民、王雷、陈武、刘传凯、高胜友、佟大双、程宏筠等人翻译，邓蛟龙、陈代川、龚亚萍、王晓娟、吴安定、孟丽艳、王学龙、张定军等人也做了大量的工作，希望图书创作室技术人员对该书进行了仔细审校，在此深表感谢。

前言

本书是 M icrosoft Visual C++ 6.0 程序员指南，不是 C++ 语言，也不是 MFC 库，而仅仅与 Visual C++ 本身有关。

确实， Visual C++ 带有程序设计者的指导手册，即在线帮助。那庞大的帮助系统可能会激励你，使你自信些，因为你想知道的内容会在帮助系统的某个地方。但是，在线帮助的问题是，当你知道你要找什么时，它才能很好地起作用。这本书弥补了在线帮助的不足，但不能取代它。帮助系统和书面文字在目的和风格上存在着固有的差异，因而谁都不能取代另一个。它们一个是提供有关信息，另一个则是教你怎么做。一个范围广泛，而另一个则有深度。在线帮助尽可能简洁地提供清晰的事实，而不是详细的描述，它提供一个步骤列表，来指导完成一些任务，但很少花时间来进行整体描述。从中你可以知道 “ 如何做 ”，而不是 “ 为什么这样做 ”。

本书试图使你成为 Visual C++ 的熟练用户。它按材料的逻辑层次展开，展示了整体的各部分之间是如何相互关联的，它用简单的代码来阐明原理，并常充当指导老师的角色。而且，它携带方便。它确实拥有在线帮助所缺乏的优点。另一方面，在线帮助非常直接，而且范围广泛。数兆字节的帮助文本可以涉及到 Visual C++

的每个细节，而本书仅讨论一些要点。

首先，从本书上获得 Visual C++ 坚实的基础知识，然后，当你经验更丰富，而问题变得更深奥时，你可以转向在线帮助。有意思的是，你对产品越熟悉，在线帮助就越有用。

本书第一版的书名为《 M icrosoft Visual C++ Owner’ s M anual 》，它成为微软关于Visual C++ 5 版的正式指南。但微软把第二版改名为《程序员指南》，是为了把它作为 Visual Studio 98 系列丛书（共五本）的一部分，其余四本分别为《 Visual Basic 》、《 Visual J++ 》、《 Visual FoxPro 》和《 Visual InterDev 》四种开发工具提供相关文档。本书独立成册，如果你的兴趣仅局限于 Visual C++ ，你就找对了地方。本 “ 指南 ” 和其他“ 指南 ” 之间的相似之处仅在于封面，因为其他“ 指南 ” 只是在线帮助的副本（每个产品所带的在线文档的副本）。你会发现本书同其他 “ 指南 ” 完全不同。

微软有充分的理由为本书改名，但我对丢掉原来的书名感到遗憾。我选择

《 Owner ’ s Manua l》（用户手册）来尽可能清楚地表达本书的重点，以便使读者对哪些是本书涉及的内容，哪些不是，可以有清醒的认识。如果是在一百多年前，那容忍冗长标题的时代，我可以加上一些东西，如 “ 作为教程、伴侣和参考书，它深入阐述 M icrosoft Visual C++ 的知识，它不介绍 C++ 编程语言和 Microsoft 基础类库 ”。显然，那个冗长的标题并不完全精确。 Visual C++ 同 C++ 语言和 MFC 库完整地联系在一起，以致于不可能只谈论 Visual C++ ，而不提及其他两者。下

面的章节为了说明 Visual C++ 的某个方面而提供了许多范例和程序。代码必须有注释，否则它是没有用的。范例程序的说明也扩展到技术和 MFC 的主题。但这些事情是相互独立的，并且，不会分散我们如何使用编译器的重点。其他优秀的书籍可用来解释 C++ 编程和 MFC 库。

本书描述 Visual C++ 6 版，但较早版本的所有者也能从中受益。 Visual C++ 的某些方面同以前的版本相比有相当大的变动，但其他许多地方变动甚微，甚至根本没有变动。近来， Visual C++ 附带发行了一个很小的包裹，其中有少量传单、一些印刷材料及一两个光盘。但是，由于你早就阅读了这些，你可能意识到，Visual C++ 中有大量的材料。我称它为 “ 编译器 ”，仅仅是因为缺乏更好的名字。除编译器本身外， Visual C++ 提供了链接器、生成实用程序、调试器、文本编辑器、资源编辑器、开发环境、微软基础类库（ MFC ）、运行时间库、成千上万行源代码和其他许多东西。重申一次：本书不会阐述每件事情。我的目的是帮助你掌握Visual C++ ，而不是在某些细节上纠缠。

读者要求

这类书不能从学习曲线的零点开始。如果起点太低，对预备知识的讨论会让人感到混乱。若起点太高，则作者会失去多数听众（除了作为无足轻重的东西，而给人留下印象）。诀窍在于，对有各式各样的技术和兴趣的读者，我们以同一种方式来说明，然而，在谈论深奥知识时，不能失掉一个听众，且在提供基础知识时，

也不会惹恼任何一个人。本书没有太多的要求。我假定你已经熟悉 C 和 C++ 编程语言，以前进行过 Windows 编程，并至少对 MFC 有基本的认识。无论如何，你不必是专家，但如果你理解一些基本概念，如指针、类和消息，你会发现，文本和范例代码更容易懂。幸运的是，关于编译器，这里并没有什么抽象的东西，它只是一个软件而已。

Visual C++ 简史

人们可以举出， Visual C++ 的根源不是开始于 M icrosoft 而是 Borland 的事例。一些读者可能会记起，给 DOS 带来集成开发环境，或称 IDE 的想法的 Turbo Pascal 。IDE 仍是某个领域内的另一个缩写，它们的状况已经改变了。 IDE 只是意味着，编辑器和编译器共同工作，二者可从同一个地方访问。在编辑器中写下源代码，单击 Compile （编译）按钮来启动编译器。当编译器发现错误时，它将编辑光标设到出错语句处，以便于你改正问题。 IDE 的想法是，为程序开发提供一个整体环境，程序员无须从中离开到其他程序中。

C 语言正是这个时候诞生的（公元 1987 年）， Turbo Pascal 发行了 Turbo C 。M icrosoft 相应地推出相似的产品，称为 QuickC 。我被邀做一些与 QuickC 相关的编程工作，并在结束时写些指导性文章，这些被包括在产品包装中，题为《 C for Yourself 》（标题不是我想的）。 QuickC 作为一个产品单独发售，但它也包括在我们称之为 Big C 的 Microsoft’ s C 编译器中。当时， Big C 版本号为 5 。它的

竞争对手包括： Computer Innovations、 Datalight 、 Lattice 、 M anx ，这些名字现在听起来很陌生。其他有些幸存下来，著名的有 Borland 和 Watcom （现在是PowerSoft ）。它们优秀的产品继续同 M icrosoft 公司竞争着。

把 QuickC 同 Big C 放在一起的目的是，使程序员能在 QuickC 方便的 IDE 下编写代码。 QuickC 编译起来很快，主要是因为它对代码仅作些微优化（本书后面会谈及优化，那时我们会看到它是如何影响编译时间的）。 QuickC 优化时只是登记一些变量，插入几条 LEAVE 指令，仅此而已。结果是编译时间很短。程序调试过后，再在 QuickC 中运行时，程序员就能用 Big C 创建一个正式版，它在代码优化方面做得更为正式些。当用 Big C 编译时，程序的大小减少 15% 或更多，这并非怪事。

QuickC 和 Turbo C 给 C 编程引进了许多东西，但从没有对开发者产生永久性的影响。首要原因就是二者的编辑器都不怎么好（ QuickC 编辑器后来合并到M icrosoft QuickBasic 中，现在它作为 D O S 编辑器 Edit.com 仍存在于 M icrosoft W indows 95 中）。 DOS 下 IDE 的另一个问题就是，它们占据大量内存，只给开发环境下的程序运行留下很少的空间。你经常不得不离开 IDE 来运行和调试程序。许多在开发工作中使用 QuickC 的程序员（包括我自己）仅仅使用它的命令行版本。

随后， Windows 3.0 出现了。

W indows 3.0 尤其是 3.1 ，为个人计算机引进了正式的 IDE 时代。内存的约束消

失了。而且，如果你准备做 W indows 编程， W indows 环境看来是天生的好地方。人们很容易明白，在 W indows 下进行 W indows 编程，会产生更好的结果。W indows 是个优秀的软件，长期在 Windows 下工作，会使你对一个程序应该做什么，不应该做什么，有更好的认识。

让许多人惊奇的是， M icrosoft 把精力更多地集中在 C 编译器的内部支持上，而不是把它的界面升级到一个新的时代。当 7 版发行时，它仍然是一个基于 DOS 的产品，它既可以在 Windows 下的 DOS 模式下运行，也可以在扩展内存管理器下运行（它的包装盒中带有 Qualitas ’s 386Max ）。作为让步， 7 版提供了一个名为Programme r’ s Workbench 的字符模式的 ID E ，它已成为现有标准的累赘。然而， Workbench 展示了自 QuickC 时代以来的自然而然的演变结果。许多菜单中的命令看起来还是很现代化的，例如 New 、 Open 、 Save A s、 Build 和 Open Project 。

7 版对编程工作的重要贡献不是它的 IDE ，而是它对 C++ 的支持。M icrosoft 首次把编译器指明为 “ C/C++ ”，来强调其新的双重性。它看起来就像细胞分裂一样。它不只是简单地扩展编译器，来辨认 C++ 超集的新命令，而是牵涉到更多的东西。C/C++ 7 版也引进了 M icrosoft Foundation Class 库 1.0 版，完善了源代码。如果没有 M icrosoft 发送给开发者的这套优秀的预写类， C++ 就不会成为现在这么流行的 W indows 编程工具。

微软下一个主要的让步是放弃了多数产品对 DOS 的依赖。 M icrosoft C/C++ 8 版成为真正的 Windows ID E，它就是大家所知道的 Visual C++ 1 版。这个名字利用

了早期 Visual Basic 的成功，但二者从未互相抗衡过。 Visual Basic 允许开发者通过大量单击鼠标和少量代码来建立正在运作的 W indows 程序，而 Visual C++ 仅仅通过向导这样的特殊动态链接库来创建启动器源文件。在第 2 章中，我们将看到：向导挽救了众多开发过程中重复性的工作，这种对 W indows 程序来说非常普通的工作是由 MFC 编写的。

Visual C++ 1.5 版之后，微软决定不再将更多的努力花在支持 16 位编程上。Visual C++ 2 版仍提供对 16 位的支持，但自从那时起， Visual C++ 仅用来创建 32 位程序。没有 Visual C++ 3 版。版本号从 2 跳到 4 来，使 Visual C++ 和 MFC 同步，这样就结束了一个小小的混乱来源。然而，这种合并是短期的，因为 Visual C++ 和 MFC 又使用了不同的版本号。

Internet 的流行已经明显地影响了产品设计，在发行第 4 版时， Visual C++ 引进了为 Internet 编程而设计的新类库。 5 版也增加了一些新类，但注意力更多地集中在改善产品的界面上，以提供一个更好的在线帮助系统、更高级的宏能力和对在开发者组内进行类和其它代码共享的支持。 5 版也合并了 Active Template Library ，并显著地改善了编译器优化代码的能力。在后面的章节中我们将看到：

6 版作了更进一步的改进。

本书内容

本书分成六个部分，每个部分讨论一个与 Visual C++ 及它的开发环境相关的话题。一直到讨论文本编辑器的第 3 章，我们都有意地保持一些基本的讨论，这有助于确保每位读者，不论是新手还是专家，都能成功地操纵 Visual C++ 开发环境，及在文本编辑器中编写源代码。从第 4 章开始，讨论逐渐变得更专业一些。

第一部分：基础知识

我们通常所说的 Visual C++ 实际上是它的开发环境，它的名字是 M icrosoft Developer Studio 。二者之间的细小差别并不重要，通常这两个术语可以互换。但如果你不围绕 Developer Studio 来进行学习，就不能有效地使用 Visual C++

（ Developer Studio 听起来很像 Visual Studio ，但它们之间没有关系，因此，在阅读本书时，你可以忘掉它）。

第 1 章可以说是方向性的，它介绍了 Developer Studio ，并描述了你在这个环境下工作时将要碰到的主要的窗口。这一章也解释了如何使用 M icrosoft Developer Network（ M S D N ），它为包括 Visual C++ 在内的所有微软的程序产品提供在线帮助系统。

第 2 章介绍了 AppWizard ，它是用 MFC 来为典型的 W indows 应用程序创建启动

器文件的 Visual C++ 向导程序。在本书中，我们将用 AppWizard 来建立一些范例程序。

第二部分：编辑器

Visual C++ 提供了三个不同的编辑器：一个用来创建文本源代码，另一个用来创建菜单和图形文件，而第三个用来创建对话框。每个编辑器都用一章来介绍，首先是在第 3 章中讲述文本编辑器。这一章仔细说明了重要的菜单命令，展示了打开文本文档的快捷方式，并介绍了宏。

第 4 章描述了 Visual C++ 多功能的图形编辑器，它可以用来创建包括菜单、位图、图标和工具栏在内的资源数据。这一章篇幅不小，因为它涉及到许多材料。随着内容的深入，将会产生一个名为 D iskPie1 的范例程序。每个部分首先描述如何用图形编辑器来创建一个特定的界面元素，如菜单或工具栏，然后，通过把该元素加入到 D iskPie1 程序来举例说明。到这一章的结尾，这个程序就成为一个以饼图形式显示磁盘和内存的使用情况的实用程序。

第 5 章讨论对话框编辑器，并展示如何用 Visual C++ 来设计对话框和创建基于对话框的应用程序，如 W indows Character Map 和 Phone Dialer 程序。这一章举了几个例子，包括一个能建立一个属性表（也称多选项卡对话框）的例子。

第三部分：编程指南

第三部分中的几章展示了如何使用 Visual C++ 中的两个重要工具来加速编程开发工作。第 6 章介绍了 ClassWizard ，尽管它很难描述，但很容易让人喜欢。当开发 MFC 应用程序时，你会发现， ClassWizard 对于创建和维护类是非常有帮助的。

第 7 章中描述的 Gallery 提供了一个附加组件的集合，你只要点几下鼠标，就可以把它们合并到你的项目中去。 Visual C++ 带有许多已经做好的由类的源代码和ActiveX 控件组成的组件。第 7 章还演示如何为 Gallery 来创建你自己的组件。

第四部分： ActiveX 控件

第 8 章介绍 ActiveX 控件，并展示如何在应用程序中使用它们。第 9 章和第 10 章分别从不同方向来说明如何用 MFC 或 Active Template Library （ ATL ）来写一个 ActiveX 控件。第 9 章提供了一个名为 Tower 的范例，来带领你一步一步地创建和编码一个依赖于 MFC 的 ActiveX 控件。然后，第 10 章用 Active Template Library 来建立一个同样的控件，从而清楚地说明这两种方法之间的不同之处。结果可以插入到任何支持 ActiveX 控件的应用程序中。

第五部分：高级主题

第 11 章讨论了调试器的重要主题，它是 Visual C++ 最完美的组成部分之一。这一章说明了调试器的内部特征，描述了调试器窗口和工具栏，然后通过修复范例程序中隐藏的缺陷来检验调试器的能力。

当程序调试过后，你将希望打开编译优化来创建一个发行版。第 12 章讨论编译器优化的一些通常难以理解的主题，同时，展示 Visual C++ 的诸多优化选项开关的作用及使用的原因。

到第 13 章的时候，你应已在 Developer Studio 环境上花费了大量时间，这些足够使你知道自己喜欢什么和想要改变什么。这一章展示了如何定制 Visual C++ 来适合你的喜好。它也通过范例演示了如何编制宏和附加实用程序，来使它们同Developer Studio 紧密地结合在一起。

第六部分：附录

附录 A 提供了 ASCII 字符和 ANSI 字符的标准表格。你可能会发现附录 A 中的ANSI 字符表比在线帮助中的类似信息要有用得多，因为该表显示了字符的八进制数形式。这样做是有理由的。我们在第 5 章中看到：在对话框文本中包含大写ANSI 字符需要字符的八进制数形式。有了这些信息，你就可以在对话框显示的

文本字符串中添加一些有用的标志，例如  和 ¼ 。

附录 B 简要描述了 ClassWizard 支持的 MFC 类，它可以作为快速参考，用来帮助你给新类选择最合适的基类。

附录 C 介绍了 M icrosoft Visual Basic Scripting Edition ，即 VBScript 。 Visual C++ 把 VBScript 合并为它的宏语言，因此，如果你以前没有使用过 VBScript 或类似的 Visual Basic 语言，这里可以作为一本初级读物。尽管在 Visual C++ 中录制宏并不需要 VBScript 的有关知识，但是，你只有用 VBScript 编程，才能创建一个多用途的宏。

范例代码

本书中几乎每个范例程序都是以 C++ 语言写的，并使用了 MF C（两个例外是第 4 章中的一个光标演示程序，以及第 13 章的一个基于控制台的小程序）。但是，我在文中的一些程序片段中还是使用 C 语言。我发现 C++ 在简明地说明编程意图方面不如 C 好，并且除了清楚和简洁的优点外，C 还在现在的程序员间充当一种“ 通用语言 ”。从理论上来说， C++ 程序员可以直接理解 C ，但反过来就不一定对。另一方面， C 没有地方来演示 MFC 应用程序。当我认为有些重要的想法，而且，二者间的差别太大而需要解释时，我偶尔也会同时给出 C 和 C++ 代码。

本书中诸多章节讨论的主题都有很好的范例说明，而我一直试图包括那些有趣的、有用的和能说明问题的范例程序。一些程序是用 AppWizard 创建的，另一些不是，这样就可以模拟范围广泛的编程实践。书中对几乎每个程序都进行了彻底的讨论。书中也包括了源代码列表，因此，你无须在编辑器中打开源文件，就可参加讨论。程序代码力求清楚，而不是优美。因此，毫无疑问，对一部分代码你可以在自己的开发工作中采取不同的处理。例如，我在程序中很少包含有错误检查标志。程序是在 W indows 95 下创建的，但多数是在 W indows NT 下测试的。

附带光盘

所有范例程序的项目文件都在书后所附的光盘上。为了把所有的项目复制到硬盘上，按下列步骤执行 Setup 程序：

在 W indows 任务栏上单击 Start 按钮并选择 Run 命令。
在 Run 对话框中键入 “ d:\setup ”，其中 d 代表光驱的驱

动器号。

Setup 程序从光盘上复制 3M 多文件到硬盘上，它们放在名为 Visual C++ Programme r’ s Guide（或你指定的名字）的子目录下。运行 Setup 完全是可选的，如果你愿意，可以手动地从光盘上再次获得这些文件。你会发现所有的文件都位于 Code 子目录下。

嵌套的子文件夹指明了描述程序的章节号和项目名。例如，子文件夹Chapter.05\ M fcTree 中保留了生成第 5 章中的 M fcTree 程序所需的全部文件。每个项目文件夹都有一个名为 Release 的子文件夹，该目录包含了程序的可执行文件。因此，你可以直接试验范例程序，而不必先生成它。如果你想通过生成范例程序来参加文中的讨论，启动 Visual C++ ，从 File 菜单中选取 Open Workspace 命令。在硬盘上浏览项目夹，并双击项目的 DSW 文件。

范例程序的项目名保持为八个字符或更少。这一惯例适应了那些宁愿使用较早版本的文本编辑器的读者，这些编辑器可能不能识别长文件名。一些老版本的光盘驱动器也不能识别长文件名。

附带光盘包含了一个名为 Index 的程序。 Index 不是一个范例程序，因此你不会在书中找到对它的说明。 Index 为本书提供了索引，它在所有的章节和附录中进行全字符搜索。它保证只要某个主题在书中的某个地方提及过，你就可以找到它。这个程序实际上是书志学家所称的“ 词语索引 ” 的电子形式：给出一个或更多的词，程序就会告诉你，它们出现在哪一页、哪一段。使用这个程序需要把文件 Index.exe、 Index.hlp 和 Index.key 从光盘上复制到硬盘上，一定要把这三个文件放在同一目录下。如果你愿意的话，也可以直接从光盘上执行 Index 。该程序外观如下图所示。

致谢 - 图2

Index 窗口中的四个组合框每一个接受一个单词。这些单词可以组成一个短语，

如 “ Active Template Library ”，或仅仅是指定一些一同出现在同一段或同一页的毫无关联的几个词。程序也能搜索单词的复数和由 -ed 和 -ing 形成的派生词，并能考虑到单词拼写上细微的变化。例如，搜索单词 edit 、 handle 和 debug ，程序同时会找出 edits 、 handling 和 debugged 的出现位置来。搜索单词的大小写无关紧要，不常见的简写可能会导致意外的匹配。例如，当搜索只取首字母的缩写GUID 时，Index 会找到单词 guiding 。单击 Search 按钮或书图标，即可开始搜索。

四个组合框会记住上一个搜索词，因此你无须再次输入。要调用以前输入过的单词，点开组合框的下拉列表，并选中该单词即可。弹出式帮助信息解释了程序的其他特色。单击对话框右上角的小问号按钮，然后单击控件窗口或组合框区，即可获得相关帮助。 Windows NT 3.51 的用户必须按 F1 键才能获得帮助。

Index 把一页中的每一段标识为一个数字，如 2 或 7 。当搜索一页来找出程序指出的特定的一段时，注意下面的规则，它决定程序认为哪一段是搜索到的：

图表的标题组成单独一段，如表格的每一行都是一段

。
源代码的每一行（包括空行）都代表一段。
一页首端的一段的一部分不能作为单独的一段，因为

Index 认为这些文本属于上一页底端的一段。

Index 程序能识别布尔操作符 AND 、OR 或 N O T 。如果你对全文本搜索中的布尔

逻辑有些生疏的话，第 1 章描述了当搜索 MSDN 在线帮助系统时如何使用布尔操作符。参见表 1-1 的例子。

一些术语定义

在深入本书前，应定义一些术语，例如生成、项目、目标、配置和应用程序框架。由于在下面的章节中要用到这些词，因此最好现在说明它们的意义。

生成指编译和链接，把一组源文件转变成可执行的应用程序。编译源文件，链接对象文件，然后项目就生成了。项目有两个相互关联的的含义。它可以指最终的结果，即生成的应用程序，但更准确的是指创建应用程序所需文件的集合，包括源文件、预编译头文件、资源脚本、图形文件和其他建立该程序所需的任何文件。Visual C++ 一次仅允许打开一个项目，这时你已经可以访问所有的项目文件，并可以进行编辑、生成和调试。每个项目可以拥有任意数量的嵌套子项目，当开发一个包含多个可执行元素的程序时，安排这些子项目是非常有意义的。例如，你

可以开发一个应用程序作为主项目，而把一个辅助的动态链接库作为独立的子项目。

生成一个项目后创建的应用程序有两种类型：发行版和调试版。 Visual C++ 有时

用术语“ 目标 ” 来指定生成类型。项目的正式目标是提供给最终用户的可执行程序。调试目标是计划开发过程中的可执行程序。项目设置，就是所说的配置，决定 Visual C++ 生成项目时创建的可执行文件是发行版的，还是调试版的。

般类的 MFC 库通过提供 W in32 API 作为一套类对象，来使
W indows 编程更容易。使用 MFC 的程序利用测试过的代码作为一个应用程序框架来处理许多任务，否则，应用程序不得不自己来照顾这些事。这些隐藏服务的唯一代价是，对于大多数 MFC 程序来说，可执行文件尺寸可能更大，并存在某些内置的公共部分。应用程序框架通过类来指明应用程序的结构，而不是细节。然而， MFC 并没有严格限制程序员的创造力，许多不同的 W indows 应用程序是用 MFC 编写的这一事实就可证明这一点。

参考资料

推荐参考书可不容易做，我感到责任重大。书是很昂贵的，不仅是在金钱方面，更主要的是在时间方面。下面是一些我认为能给使用 Visual C++ 的程序员提供有价值的资料的书。它们碰巧都是 M icrosoft Press 出版的，但这只是因为我没有说出更多的书名。

要开始了解 MFC ，我相信，没有比 Jeff Prosise 的《
Programming Windows

95 with MFC 》更好的书了。我喜欢这本书。它写得很好，清楚明了，

主题明确、一致。

关于 MFC 的另一本好书是 David Kruglinski 的《 Inside Visual

C++ 》。不要被标题愚弄了，这本书的重点是 MFC ，讨论了 Prosise 的书中没有讨论过的主题，例如数据库管理和 OLE 。讨论和所有的范例程序都假定读者正使用 Visual C++ 。
如果你是 W indows 编程新手，想加强基础，并更愿意用

C 语言，而不是 C++ 语言编程，可以考虑 Charles Petzold 和 Paul Yao 的《 Programming W indows 95 》。该系列的最新版本首先出现在大约十年前，这本书仅仅是因为它对 W indows 编程这一主题的清楚说明而出名的。注意书中的警告，尽管除了最后一章，该书没有提及 C++ 或 MFC 。
David Chappell 的《 Understanding ActiveX and OLE 》详细介绍

了ActiveX 。尽管它对 Visual C++ 没有说什么，对编程也很少提及，这本值得一读的书对复杂的主题提供了全面的看法。

反馈

如果你对本书的再版有什么建议，写信给我。我会仔细阅读收到的电子邮件的每一行（我对这些事是很勤奋的），尽管我不能保证回信。在 Internet 的beckz@witzendsoft.com 上可以访问到我。

第 1 章环境

Visual C++ 软件包包含了许多单独的组件，如编辑器、编译器、链接器、生成实用程序、调试器，以及各种各样为开发 M icrosoft Windows 下的 C/C++ 程序而设计的工具。幸运的是，它还包含有一个名为 Developer Studio 的开发环境。Developer Studio 把所有的 Visual C++ 工具结合在一起，集成为一个整体，通过一个由窗口、对话框、菜单、工具栏、快捷键及宏组成的和谐系统，你可以观察和控制整个开发进程。集成开发环境就像一间带有监视器、刻度盘和操纵杆（它使个人能操作工厂中的许多机器）的控制室。该环境几乎就是 Visual C++ 中所能“ 看见 ” 的所有东西。所有其他事情都在其管理下在幕后运行。

产品 Visual C++ 和它的开发环境 Developer Studio 之间的区别几乎没有意义，因为后者完全取代了前者。为避免应付两个不同的名字，本书在一般场合下，用术语 Visual C++ 来既指代整个产品，又指代它的开发环境。微软自己已经接纳了这个做法，而以前版本的用户会注意到，原来标为 Developer Studio 的窗口标题已经改为 Visual C++ 。然而，在最后一章讨论实用程序如何同 Developer Studio 程序结合起来，而成为环境的一部分时，我们将恢复原来的名字。

开始，我们来概括一下 Visual C++ 环境为帮助程序开发而设计提供的诸多服务。

圆括号中的章节号指出了本书中详细讨论这些服务的地方。

对开发进程的不同方面，从类和源文件的列表到编译

器消息，都提供了观察窗口（第 1 章）。
访问在线帮助的扩展系统的菜单（第 1 章）。
创建和维护源文件的文本编辑器（第 3 章），设计对话

框用的优秀对话框编辑器（第 5 章），并创建其他界面组件，如位图、图标、鼠标及工具栏的图形编辑器（第 4 章）。
为程序创建启动器文件的向导在建立新项目的常规任

务上提供一个良好的开端。 Visual C++ 为不同类型的 W indows 程序提供向导，包括带有可选数据库和 Automation 支持的标准应用程序（第 2 章）、动态链接库、基于对话框的应用程序（第 5 章）、使用 Internet Server API(ISAPI) 的 Web 服务器的扩展程序及 ActiveX 控件（第 9 章和第 10 章）。
帮助 MFC 应用程序创建和维护类的帮手 — — ClassWizard （

第 6 章）。
Gallery 维护的内置可执行组件给程序增加方便的特征

（第 7 章）。
优秀的调试器（第 11 章）。
通过对菜单和工具栏对命令进行合理和方便的访问。

你可以定制

Visual C++ 中已有的菜单或创建新的菜单（第 13 章）。

通过宏和附加的动态链接库来添加自己的环境工具的
能力（第 13 章）。你可以自己开发这些附加项，或从各种各样的供应商那里购买它们。

图 1-1 显示了一个典型的 Visual C++ 主窗口。开发环境的外观比以前的版本只有细微的改变，而它的风格和许多命令仍维持不变。如果你从较早版本的 Visual C++ 或其他微软产品中熟悉了 Developer Studio 环境，可以跳过这一章，而直接接触新特征，尤其是修订过的在线帮助系统。如果你以前从未用过 Visual C++ ，你会发现，像任何大的 W indows 程序一样，它需要一些时间来习惯。不要低估它的深度，只有当你认为已经发现了 Visual C++ 的每件事情时，才会峰回路转，出现一番新的景色。但是，它的界面是智能化的，而且，而且非常宽容，它鼓励你去实践，实践总是最好的教师。

致谢 - 图3

图 1-1 Visual C++ 主窗口的典型视图

本章是一个起点，它介绍 Visual C++ 的环境外壳，并描述开发项目时遇到的界面和窗口。我们不急于在本章中讨论单独的工具和菜单命令，因为在后面的几章中，都介绍了菜单和工具栏及它们包含的各种各样的命令。同时，Developer Studio 还充当 Visual J++ 和 Visual InterDev 的主环境，但这里，我们只集中讨论这个环境是如何应用到 Visual C++ 和 C/C++ 项目上的。

工具栏和菜单

Visual C++ 带有一个预先定义好的工具栏集，单击它们便可以访问它们。如果找不到需要的工具，可以用自己设计的定制工具栏来增大工具栏集。每个工具栏都由工具栏的标题栏上的名字标识：

致谢 - 图4

正如下面部分所描述的那样，工具栏经常被定位在某个位置上，这时标题栏消失。例如，图 1-1 显示了 Standard 、Build 和 Edit 工具栏定位在 Visual C++ 主窗口的顶端时的样子。工具栏的安排由你决定。你可以在屏幕四周移动工具栏，通过拖曳边框来调整它们的矩形形状，并使任何一套工具可见或隐藏。你可能愿意让某些工具栏（如 Standard 和 Build ）一直都是可见的，至于其他工具栏，通常只在你工作在需要它们的窗口中时，才变得可见。例如，在默认设置中， Debug 工具栏只在调试过程中才是可见的。Colors 和 Graphics 工具栏（将在第 4 章中讨论）仅在图形编辑器中才是可见的，因为这是你需要它们的唯一地方。

致谢 - 图5

图 1-2 在 Customize （自定义）对话框中打开和关闭工具栏

图 1-2 显示了 Customize （自定义）对话框中包含的工具栏名称列表，这里你通过单击复选框来调整工具栏的可见性是打开或是关闭。在 Tools （工具）菜单中单击 Customize （自定义）命令即可打开这个对话框（第 13 章对 Customize （自定义）对话框有更多的叙述）。

当鼠标停留在工具栏按钮的上面时，按钮凸起。主窗口的底端的状态栏显示了对按钮的简短描述，并且，如果光标停留时间长一些，就会出现一个小的弹出式的“ 工具提示 ” 窗口，它包含了按钮的名字。如果需要的话， Visual C++ 甚至可以显示放大的工具栏：

致谢 - 图6

工具提示和放大的选项都是在图 1-2 显示的 Customize（自定义）对话框中控制的。

Visual C++ 菜单栏是一种特殊形式的工具栏。尽管只有在全屏模式下才能隐藏菜

单栏，其他情况下，它就像一个普通的工具栏。当鼠标停留在 Visual C++ 的菜单栏上时，菜单名像工具栏一样呈凸起状。单击菜单名来拉下菜单时，菜单名看起来像是凹进屏幕里。菜单打开后，把鼠标从一个菜单名滑动到另一个会拉下另一个菜单。

通过在工具栏或菜单栏上不是按钮或菜单名的地方单击，并保持鼠标被按下，就可以把它们拖动到屏幕上新的地方。如果工具栏的标题栏不可见，工具栏上的垂直分隔处正是 “ 抓取 ” 工具栏拖动的好地方。由于停靠这一特征，在 Visual C++ 中移动工具栏，有时并不如你所想像的那样简单。下一部分深入讨论重新在屏幕上定位窗口和工具栏的秘密。

环境窗口

除许多对话框外， Visual C++ 显示两种类型的窗口，即文档窗口和停靠窗口。文档窗口是一般的带边框子窗口，其中包含有源代码文本和图形文档。W indo w（窗口）菜单中列出了在屏幕上以平铺方式还是以层叠方式显示文档窗口的命令。所有其他的 Visual C++ 窗口，包括工具栏甚至菜单栏，都是停靠的。开发环境有两个主要的停靠窗口 — — Workspace （工作空间）窗口和 Outpu t（输出）窗口，它们通过 View （查看）菜单中的命令变成可见的窗口。另一个停靠窗口 Debugger

（调试器）窗口在第 10 章中讨论，它在调试过程中显示。这一部分首先看看所

有停靠窗口的一些共同特征，然后单独地讨论 Workspace （工作空间）窗口和

Outpu t（输出）窗口。

停靠窗口可以固定在 Visual C++ 用户区的顶端、底端或侧面，或者浮动在屏幕上任何地方。停靠窗口，不论是浮动着的或是固定着的，总是出现在文档窗口的上面。这样，就保证了当焦点从一个窗口移到另一个时，浮动的工具栏一直都是可见的，但它也意味着，文档窗口偶尔会看起来像消失了似的。这种情况刚开始时可能会使人不安，但是，文档窗口仍在那儿。例如，如果你正在文本编辑器中编辑源代码，此时打开一个占据整个 Visual C++ 用户区的停靠窗口，源代码文档就会消失，它隐藏在新窗口之下。如果覆盖的窗口被定位在该位置上，你就无法使文档窗口回到上面来。唯一的解决方法是要么关了覆盖的窗口，要么把它拖到不挡眼的地方去。我们将看到如何快速地打开和关闭停靠窗口。

拖动一个停靠窗口时会出现一个移动的轮廓，它显示了释放鼠标左键时窗口的新位置。这些轮廓线是灰色虚线，直到它与环境用户区的边界或另一个停靠窗口的边界接触时，它才变成细黑线。这种变化提示你，若放下窗口，会使它定位在边界附近的位置。工具栏在用户区的顶端或底端时定位为水平位置，而在左右边界时则定位为垂直位置。在拖动工具栏时，可通过按 Shift 键来改变工具栏的放置方向。

把窗口定位在希望的位置和尺寸上，有时会花费一些时间。要使窗口占据整个用户区，向上拉动边界，直到鼠标同用户区的上边界接触，然后释放鼠标按键。要把窗口恢复到较小尺寸，拖动窗口，直到光标接触到用户区的左边界。这迫使窗口成为浮动的，你可以通过其标题栏来把它拖动到其他地方。

在屏幕上移动一个停靠窗口时，窗口看起来像是有主意似的，顽强地紧贴着Visual C++ 主窗口的某一边界，或任何其他它接触到的定位窗口。有两个办法可防止这个问题发生。第一种办法就是在移动窗口时按住 Ctrl 键，来暂时禁止它的停靠特征。第二种办法只对窗口有效，对工具栏无效，那就是禁止窗口的停靠能力，直到你再次使它生效。在窗口内部右击，从上下文相关菜单中，选择 Docking View （停靠视图）命令来关掉命令的复选标志。 W indow （窗口）菜单也提供对Docking View （停靠视图）命令的访问，如图 1-3 所示。

致谢 - 图7

图 1-3 使用 Docking View （停靠视图）命令切换窗口的停靠模式

若关掉窗口的停靠特征，在下面几个方面影响窗口：

窗口就像一个普通的文档窗口，标题栏上有最小化、

最大化和关闭窗口的按钮。
从 Window （窗口）菜单中选择 Cascade（层叠）或 Tile（平

铺）命令时，窗口同其他打开的文档窗口一起排列位置。
窗口不能移到 Visual C++ 主窗口用户区的外面，当它处

在停靠模式下时是可以的。
输入焦点移到该窗口上时，它可以由 W indow （窗口）

菜单上的 Close

（关闭）命令关闭。否则， Close （关闭）命令不能影响停靠模式下的窗口，即使它拥有焦点。

窗口或工具栏被定位后，凸起的硬节（有时称为把手）出现在窗口的顶端或左边界，如图 1-4 所示。双击把手使窗口变成浮动的；双击浮动窗口或工具栏的标题栏，使它回到原来的位置。也可以通过把手来把窗口拖动到另一个固定的或浮动的位置。

在 Visual C++ 中创建的窗口排列，将在项目的整个过程中维持，或直到你改变窗口排列方式。下一次打开项目时，窗口像上次离开时的样子排列。然而，在环境中运行的实用程序的窗口并不遵守这些规则。这些窗口既不是文档窗口，也不是停靠窗口，它们的特征是由实用程序决定的，而不是由 Visual C++ 决定。

致谢 - 图8

图 1-4 在停靠时，窗口、工具栏和菜单栏中出现一个凸起的把手

Wo rkspace （工作空间）窗口和 Ou tpu t（输出）窗口

Visual C++ 在停靠的 Workspace （工作空间）和 Outpu t（输出）窗口中显示项目的有关信息，如图 1-1 、图 1-6 和图 1-7 所示。在本书中，自始至终，我们都要遇到这些重要的窗口，尤其是 Workspace （工作空间）窗口，因此，花些时间来讨论它们如何工作是值得的。

要使 Workspace 或 Outpu t（输出）窗口可见，在 View （查看）菜单中单击它们的名字即可，如图 1-5 所示（这个命令不是一个开关命令，因此，再单击它一次不会使窗口消失）。窗口也可以通过 Standard （标准）工具栏上的按钮来激活，这些按钮按下后会使窗口可见或消失。

致谢 - 图9

图 1-5 显示 Workspace （工作空间）和 Outpu t（输出）窗口，工具按钮在 Standard （标准）工

具栏上

除使用工具栏按钮外，还可以用下列方法来隐藏 Workspac e（工作空间）和 Output

（输出）窗口：

如果窗口是浮动的，单击窗口的标题栏上的 Close （关

闭）按钮。
如果窗口是固定的，单击窗口把手上面或右面的 X 形

按钮（图 1-4 ）。
在窗口内任何地方右击，打开上下文相关菜单，选择

H ide（隐藏）或Close（关闭）命令。菜单上出现哪个命令取决于窗口的停靠模式是打开的还是关闭的，但两个命令有同样的效果。
如果窗口的停靠特征被禁止，单击窗口把焦点移到它

上面，然后从

W indow （窗口）菜单中选择 Close （关闭）命令。

Workspace （工作空间）窗口显示了项目各个方面的信息。在窗口底端选择相应的选项卡来显示项目的类、资源、数据源和文件的列表。在窗口中单击小的加号

（ + ）或减号（ -）来展开或折叠列表。例如，展开类的列表会显示出成员函数的名字，如图 1-6 中的第一屏所示。双击列表开头靠近文件夹或书本形图标的文字，与单击表头的加号或减号有同样的效果。

致谢 - 图10

图 1-6 Workspace （工作空间）窗口的四个窗格

Workspace （工作空间）窗口可以显示多达四个窗格的信息，如下所述：

C lassView ：列出项目中的类和成员函数。要在

Visual C++ 文本编辑器中打开类的源文件，双击列表中的要打开的类或函数。
ResourceView ：列出项目的资源数据，如对话框和位

图。同 ClassView 中一样，双击 ResourceView 列表中的数据项会打开合适的编辑器并加载资源。
FileView ：列出项目的源文件。把源文件复制到项

目夹中，不会自动把文件添加到 FileView 窗格的列表中。你必须用 Project（项目）菜单中的 Add To Project（添加到项目）命令明确地把新文件添加到项目中。
Data View ：显示数据库项目的数据来源信息。 Data

View （数据视图）选项卡只出现在 Visual C++ 的企业版的数据库项目中，企业版遵循开放式数据库互连标准（ ODBC ）来同数据源相连。

在 Workspace （工作空间）窗口中的某项上右击，会显示一个含有常用命令的上下文相关菜单。菜单中的命令取决于单击在哪一项上。例如，在 FileView 窗格中的一个源文件上，右击，会显示一个快速打开或编译文件的上下文相关菜单。你也可以开关单个 Workspace （工作空间）窗格。在 Workspace （工作空间）窗口的底端的选项卡上右击来显示上下文相关菜单，然后从菜单中选择有关命令来

使窗格可见或消失。

Outpu t（输出）窗口（如图 1-7 所示）有四个选项卡： Build （建立）、 Debug （调试）、Find In Files 1（在文件 1 中查找）和 Find In Files 2（在文件 2 中查找）。Build

（建立）选项卡显示编译器、链接器和其他工具的状态消息。 Debug （调试）选项卡用于通知来自调试器的提示，这些提示对诸如未处理的异常异常和内存异常之类的情况提出警告。应用程序通过 OutputDebugString API 函数或 afxDump 类库产生的消息，也显示在 Debug （调试）选项卡中。

致谢 - 图11

图 1-7 Outpu t（输出）窗口

在 Outpu t（输出）窗口中剩下的两个选项卡，显示从 Edi t（编辑）菜单中选中的Find In File s（在文件中查找）命令的执行结果（这个十分有用的特征与 UNIX 的grep 命令相似，它将在第 3 章中详细讨论）。默认情况下， Find In Files 搜索结果

显示在 Outpu t（输出）窗口的 Find In Files 1 选项卡中，但 Find In Files 对话框中的一个复选项，允许你把结果转移到 Find In Files 2 选项卡中。Outpu t（输出）窗口中还可以包含其他的选项卡。在第 13 章中，我们将看到如何给 Visual C++ 添加能在 Outpu t（输出）窗口中自己的选项卡里显示消息的定制工具。

在线帮助

Visual C++ 提供了三个不同的在线帮助来源：

由 WinHlp32 查看器显示的标准 HLP 文件。
对话框中的弹出式帮助信息。
M icrosoft Developer Network Library ，即 MSDN 。

标准的 HLP 文件内容包括环境的命令和窗口，当 Hel p（帮助）菜单的 Use Extension Help （使用扩展命令）命令被选中，或 Visual C++ 不能为帮助主题确定明确的上下文时，按 F1 键就会显示这些帮助文件。例如，考虑文本编辑器中打开的一个典型的源文件文档中的这一行：

DECLARE_MESSAGE_MAP() //MFC message map macro

在这种情况下，按 F1 键的效果取决于文本编辑器中闪烁光标所在的位置。如果光标在宏名的内部或开始，而扩展帮助关闭了，按 F1 键会打开 M S D N 库窗口，并显示 DECLARE_MESSAGE_MAP 宏的有关信息。如果光标是停留在一个空行上，这里没有明确的在线帮助的上下文。这种情况下，按 F1 键会提供文本编辑器窗口本身的有关信息，它们显示在 W inHlp32 查看器中：

致谢 - 图12

在线帮助的第二个来源是弹出式消息，在这个环境中的许多对话框中都可以使用。选项卡和偶尔的提示会尽量解释对话框中的编辑框和按钮的用途，但当标签说明不充分时，总可以通过下列几种方法之一来寻求特殊控件的更多解释：

把焦点移到该控件上，并按 F1 键。对于复选框或单选

按钮，通过单击来给它焦点，可能会打开或关闭一个开关选项。如果你不希望这种结果，当你阅读完帮助信息后，要记得把开关恢复到原来的设置。
在该控件上右击，来打开 What ’ s This ?（这是什么）弹

出式按钮。如果

该控件是一个编辑框，右击该控件的标签文本，比右击编辑框本身要更好一些。单击 What ’ s This ?（这是什么）按钮，将显示该控件的帮助文本。

单击对话框右上角的问号按钮，然后单击要了解的控
件。

这三种方法效果完全一样：运行 W inHlp32 ，来显示一个如图 1-8 所示的简明的弹出式消息。单击鼠标或按任意键时，这些消息就消失了。

致谢 - 图13

图 1-8 在典型的 Developer Studio 对话框获得帮助

在线帮助的第三个来源是你在 Visual C++ 中工作时最常用的一个。M S D N 通常是合乎逻辑的，而且易于使用，但它也十分庞大。正如下一部分我们将看到的一样，要充分利用 MSDN 库还需要进行一些练习。

MSDN 库

一旦通过预订获得 MSDN 库后，它就可以为包括 Visual C++ 在内的整套 Visual Studio 开发环境工具提供在线帮助。由于所有的工具都可以共享它，M S D N 作为一个应用程序单独运行，而没有同任何单个开发环境结合在一起。要从 Visual C++ 中访问 M S D N ， Help （帮助）菜单中的 Use Extension Help （使用扩展帮助）命令必须没有被选中。

从 Visual C++ 的 Hel p（帮助）菜单中选择 Content s（目录）、Searc h（搜索）或 Index

（索引）命令，会使环境通过执行 Windows\HH.exe 程序来运行 MSDN ，该程序从位于 MSDN98\98VS\1033 文件夹中的文件 MSDNVS98.col 中加载 M S D N 目录列表（包含该文件的文件夹名反映了系统的定位设置， 1033 是美国英语的语言代码）。

M S D N 库提供的庞大信息集几乎涉及到微软编程工具和 W in32 编程的每个方面。它包含了成千上万的主题，这些主题讨论了从 Visual C++ 到 Visual J++ 、从MFC 到 ActiveX 和从 abs 函数到 z 排列（ z-ordering ）的每件事情。 M S D N 也包括了几本微软出版的重要书籍的全部文字，例如 Bruce McKinney 的 Hardcore Visual Basic 和 Kraig Brockschmidt 的 Inside Ole 第二版。你也可以从中找到Knowledge Base （知识库）主题、 M icrosoft Systems Journal 的最新论点、应用程序和设备驱动程序的开发工具包的全部文档、协议文件、范例源代码及其他许多东西。这一版的界面并未经过良好的构思，但 M S D N 中所包括的信息的完整性

确实让人吃惊。

M S D N 帮助系统把文本存在一系列的“ 伙伴 ”文件中，这些文件通过扩展名 C H M 来标识；该扩展名指出这些文件是以编译过的 H T M L 格式写的。 CHM 文件就像单册的 M S D N 百科全书，每一个都包含了讨论一个特殊主题的论文，如 ActiveX 或 Win32 API 参考大全。每个文件都与一个独立的索引文件配对，索引文件有同样的文件名和 CHI 扩展名。在安装 M S D N 的过程中，安装程序把所有的 CHI 索引文件都复制到硬盘上，但只从 CD-ROM 中复制你指定的那些 C H M 文件。 C H M 文件占据大量的磁盘空间，因此，你可能会更愿意只安装那些你最常用的帮助主题。在执行过程中， M S D N 访问所有的 C H M 文件，不管它是在硬盘上，还是在光盘上。如果程序在硬盘上找不到需要的 C H M 文件，它会提示用光盘来代替。哪些 M S D N 主题应该安装到系统中，取决于你估计使用 M S D N 的频繁程度、哪些主题你最感兴趣，以及你是否愿意使用光盘。

第一次访问 MSDN 库来搜索一篇文章时，程序创建名为 MSDNVS98.chw 的关键字文件，该文件中包含了所有文章中使用的关键字列表，及指向它们在文本中的位置的指针。以这种方法编辑关键字，会加速特定的词和短语的搜索过程，一会儿，我们就可以看到这一点。创建关键字文件是一次性，只需要几分钟，在此过程中出现动画消息，会告诉你正在做什么：

致谢 - 图14

该过程要求系统 T E M P 文件夹下有许多兆可用的磁盘空间。如果环境变量 T E M P 当前指向一个容量不够的 RAM ，在 MSDN 中进行首次搜索之前，需要在AutoExec.bat 文件中重新设置该变量，并重新启动计算机。 M S D N 创建了关键字文件之后，可以恢复原来的 T E M P 设置。

图 1-9 展示了典型的 M S D N 文章，以两窗格显示。这两个窗格被设计成可以共同工作，左边的允许为你希望阅读的文章输入标准，而右边的则显示找到的文章。

致谢 - 图15

图 1-9 通过 MSDN Library 应用程序来访问在线帮助

在右窗格中，每次都出现主题，它通过超文本链接 web 连接到其他的相关主题。

超文本链接也称超级链接，它是文本中一些特殊的词和短语。链接带有下划线，并以突出的颜色显示，这使得它们能很快被识别。当光标移动到 MSDN 库窗口中的超文本链接上时，光标变成手的形状（图 1-10 ）。在链接上单击，会从 M S D N 窗口中清除掉当前主题，而代之以超文本链接所指向的新主题。这个效果很像在Internet 上浏览 Web 网页。

致谢 - 图16

图 1-10 单击一个超文本链接可以从一个 M S D N 文章跳到另一个

M S D N 窗口右半部分的界面是非常友好的，如果需要阅读帮助文本的话，只要上下滚动窗口即可，此外，还可单击超文本链接，来查看感兴趣的主题。在窗口中，

次只显示一个主题，因此，窗口总是保持干净整洁。
为了观察更多的区域，你可以通过单击 H ide（隐藏）工具按钮来关掉窗口左边的一栏，这样，整个窗口会由于保持固定的大小而收缩。你会发现，通过拖动左边或右边的垂直分隔条，更容易关掉或展开左边的一栏，这样也维持了 MSDN 窗口的整体大小。

窗口左边的一栏中有四个选项卡： Contents （目录）、 Index （索引）、 Search （搜索）和 Favorites （收藏）。每个选项卡提供一种不同的在线帮助浏览方式。

Contents （目录）选项卡

M S D N 的主题组依照标题和副标题的排列方式形成一个目录表。它就像一本书的目录表一样，仅仅是交互式的。开始，可搜索一个大概的主题，然后逐层打开越来越明确的信息路径，来寻找你感兴趣的主题。当你头脑中有一个大概的主题，如调试器或用 OpenGL 编程，而你又想要看一看这个主题有哪些文档时，目录表是非常有用的。

从 Visual C++ 的 Help （帮助）菜单中选择 Contents （目录）命令，会打开 M S D N 窗口，并显示目录列表。展开列表，直到找到要搜索的标题，这可以通过双击标题（通过书形图标来识别），或单击小的加号（ + ）按钮来完成，如图 1-9 所示。目录列表中的文章标题位于一连串分层的末端，每个标题通过一张折起一个角的

纸形图标来区别。双击列表中的标题，会在 MSDN 窗口的右边一栏中打开该文章。

默认情况下，目录列表概括了 MSDN 的全部文章。你可以通过把目录表的一个分支定义为一个信息子集，来缩短显示的目录。子集允许你集中一些特殊类别的主题。例如，下面是如何创建一个只属于 MFC 参考的文章子集：

从 MSDN 的 Vie w（查看）菜单中选择 Define Subse t（定义子

集）命令。
在 Define Subse t（定义子集）对话框中，通过双击名为

MSDN Library Visual Studio 6.0 的标题来展开目录列表，然后，同样，展开 Visual C++ Documentation （ Visual C++ 文档）和 Reference （参考）副标题。选择名为 M icrosoft Foundation Class Library and Template s（ M icrosoft 基础类库和模板）的副标题，并单击 Add （添加）按钮来创建子集。
在 Define Subset（定义子集）对话框的底部的编辑框中

键入新子集的名字，然后单击 Save （保存）和 Close （关闭）按钮。

使用在线帮助时，要在各个子集间切换，只需从名为 Active Subset （有效子集）的下拉列表中选择一个子集即可：

致谢 - 图17

Index （索引）选项卡

搜索在线帮助时，通常首先要求助于 Index （索引）选项卡，尤其当你对要寻找的主题相当清楚时。 Index （索引）选项卡显示了整套 M S D N 文件的全面索引，就像一本书的索引一样。要找到一个索引条目，在对话框顶部的编辑框中键入关键字即可。在你键入关键字的时候，列表框中的索引自动滚动到该关键字所在的位置。例如， M S D N 索引包含条目 “ exception handling（异常处理）”、“ handling exception s（处理异常）” 和 “ C++ exception handling （ C++ 异常处理）”。因此，输入这些词条中的任意一个，都可以找到有关“ 异常处理 ” 的主题。找到所要的

索引条目后，双击它。如果该条目仅对应一篇文章， M S D N 会立刻显示它；否则会显示 Topic Found（找到的主题）对话框，其中列出了该条目指向的所有文章，如图 1-11 所示。通过双击列表中的标题，或选中该标题，并单击 D ispla y（显示）按钮，均可在对话框中打开一篇文章。

致谢 - 图18

图 1-11 提供 MSDN 文章全面索引的 Index （索引）选项卡

Search （搜索）选项卡

M S D N 帮助文件集不仅仅是被动的，它还包含一个搜索引擎，该引擎扫描MSDNVS98.chw 关键字文件，来确定哪些主题文件包含了指定的词或短语，这个过程称为全文本搜索。全文本搜索从 M S D N 的 Search （搜索）选项卡中启动

（图 1-12 ），它允许你寻找包含指定词或短语的主题。 M S D N 搜索引擎是非常优秀的，它能理解词的派生、通配符、布尔逻辑组合及 NEAR 运算符。尽管要有效地使用这些特征，要求认真地考虑和进行计划，它们允许你精选搜索参数，来增加只寻找你最感兴趣的那些主题的机会。

致谢 - 图19

图 1-12 利用 Search （搜索）选项卡可以搜索包含特定词或短语的主题

讨论过 Searc h（搜索）选项卡中可用的各种各样的选项之后，我们将集中讨论如何用通配符和运算符来精炼搜索内容。

在选项卡的顶部键入要搜索的词或短语，用双引号把短语括起来，以区别于单个词（单引号会被忽略）。例如，搜索图 1-12 所示的词，会找到那些只包含短语“ exception handling ” 的主题。键入同样的单词，而不带双引号，就表示你想搜索包含单词 “ exception ” 和 “ handling ” 的主题，它们不一定要作为一个短语同时出现。不能搜索引号。

利用 Searc h（搜索）选项卡中的三个复选项，你可以进一步指定如何和在哪里搜索。 Search Previous Results （搜索以前的结果）复选项，可将搜索过程限制在已经出现在 Search （搜索）选项卡中的那些主题范围内。打开 M atch Similar Words

（匹配类似的词）复选项，会让 MSDN 接受在文本框中键入词的合乎文法的派生词。派生词包括通常的后缀，如 s、 ed 和 ing，例如，它迫使 MSDN 认为 edits 和 edited 同关键字 edit 是相匹配的。这样来放宽搜索标准，当然会找到更多的主题。 Match Similar Words 选项对编辑框中所有的搜索词都适用，打开这个选项时，搜索短语 handle exception ，会找到包含相近的派生词，如 handled exceptions 的主题。MSDN 甚至能识别那些不包含整个关键字的派生词，例如，搜索关键字handling 时，会找到 handler 和 handled 。

打开 Search Titles Only （只搜索主题）复选项，会极大地限制搜索范围，因为它使 M S D N 只扫描文章标题，不扫描文章中的正文。这样，打开该选项时，搜索短语 exception handling，会找到如 “ Exception Handling Topics(SEH )” 和 “ Type- Safe Exception Handling ” 之类的标题，但不能找到其他的相关主题，例如“ Compiler Warning C4530 ”，尽管后者在文中提到了异常处理。

搜索完成后，MSDN 列出所有提到过给定搜索字符串的文章的标题，同时在列表的右上角显示找到的文章数目。列表是按搜索字符串在主题文档中的出现次数递减的次序排列的。要想按标题或文章位置排列，单击相应列表栏顶部的按钮即可。双击 Search（搜索）选项卡中的列表条目，会显示该文章，文中的匹配字符串以高亮显示，这使你可以很快地找到字符串的出现位置。文本中经常重复出现的高亮字符串看起来有点分散注意力，它使文章外表就像一篇笔记。要从显示中

去掉高亮，从 Vie w（查看）菜单中执行 H ighlight（s 高亮）命令两次，或单击 Previous

（前一个）和 Nex t（下一个）工具按钮，来临时转到另一篇文章，再返回来。你也可以用 Edit （编辑）菜单中的 Find In This Topic （在此主题中查找）命令在显示的文章中查找文本。

下面是在 Search （搜索）选项卡中设计搜索参数的一些基本的规则和告诫：

搜索过程不区分大小写，因此用输入搜索短语时，用

大写或小写都可以。
默认情况下， M S D N 只能查找整个单词。例如，搜索

key 不会找到

keyboard 。通配符可以克制这种默认动作，就像前面解释的那样。

可以搜索字母和数字的任意组合，包括单个字符（ a
， b ， c ， 1 ， 2 ， 3 等），但不包括简单的单词，如 an ， and ， as ， at， be ， bu t， by ， do ， for， from ， have， he ， in ， it， near， no t， of， on ， or， she， that， the ，

there ， these ， they ， this ， to ， w e ， when ， which， w ith 和 you 。 M S D N 在匹配文本时会忽略这些词，因此，搜索 handle exceptions 时，也会找到包含短语“ handle the exception ”或“ handle an exception ” 的主题。

MSDN 允许搜索字符串中有省略号，但它忽略其他标点
符号，如句号、逗号、分号、冒号及连字号。这使搜索字符串时可以不管上下文，但它也提供了出现错误匹配的机会。例如，搜索短语 exception handling 时，可能会找到包含下面文本的毫不相干的主题： M essages are an exception. Handling a message...

通配符和运算符

搜索字符串可以用标准的问号（？）和星号（ * ）通配符来组成一个一般的表达式，这些通配符可以代替不在双引号之内的字符。问号通配符在表达式中代表单个字符，因此，搜索字符串 80?86 时，可以找到“ 80286 ”、“ 80386 ”和 “ 80486 ”

（但没有“ 8086 ”）。星号通配符可以代表任意次序的零个到多个字符。例如，搜索 *wnd* 可以找到如 “ wnd ”、“ CWnd ”、“ H W N D ” 和 “ wndproc ” 之类的文本。星号通配符使 M S D N 可以找到包含有共同的词根的所有单词。例如，查找诸如“ keyboard ”、“ keystroke” 和 “ keypress ” 之类的单词时，可以键入 key* 来代替key ，作为搜索字符串。自然，这种方法可能会发现诸如“ keyword ”和“ key_type ” 之类的不相干的搜索结果。运算符可以进一步提炼搜索标准，来减少这种不希望发生的结果。

M S D N 能识别布尔运算符 AND 、 O R 、 N O T 及近程运算符 NEAR 。描述这些运算符作用的最好办法是通过表 1-1 中例子来说明。 NEAR 运算符认为，当字符串之间相隔不超过八个可标识单词时，字符串是 “ 近程的 ”。 M S D N 没有为近程的确定提供另外的标准。

表 1-1 在 M S D N 的 Search 选项卡中字符串运算符的效果

运算符例子结果

AND debug AND window 搜索文中含有 debug 和

w indow 的主题，但只含有一个的主题不包括在内

O R mfc OR “ foundation library ”

搜索含有该字符串中的任何一个或两个的主题

NOT ellipse NOT cdc 搜索仅含有第一个给定字符

串，而不含有第二个字符串的主题。左边的例子指明了那些既包含有 ellipse 又包含有 cdc 的主题应该被跳过，这样就忽略了关于 CDC::Ellipse 函数的主题

续表

NEAR handl* NEAR exception 搜索文中给定字符串相隔不超

过八个单词的主题

要用运算符连接两个单词，在单词之间用空格分开，并键入运算符，如表 1-1 所示；字母的大小写无关紧要。你也可以单击靠近组合框的箭头按钮（ ◗ ），来从小的弹出式菜单中选择要用的运算符。

运算符没有确定的优先权，M S D N 按从左到右的次序求表达式的值。如果要用运算符来明确地组合字符串，可以使用圆括号。 M S D N 忽略双引号内部的圆括号，因此，不能搜索带圆括号的注释。在没有其他运算符、圆括号或双引号的情况下， Search （搜索）选项卡把搜索字符串中的空格视为 A N D 运算符。因此在 Search

（搜索）选项卡中输入下列搜索字符串中的任意一个，都会产生同样的效果：

debug AND window AND breakpoint (debug AND window) breakpoint debug window AND breakpoint debug window breakpoint

早先版本的 InfoViewer 帮助系统允许使用 C 语言中布尔运算符的等同符号：用符号 & 、竖线（ |）和惊叹号（！）来分别代替 A N D 、 O R 和 N O T 。 M S D N 忽略这些字符，因此它们都等同于 AND 运算符。

搜索策略

搜索在线帮助的方法不是取决于要搜索的东西，更多的是取决于如何能描述好想要搜索的东西。如果能用一两个明确的关键字说明要搜索的主题，通过 M S D N 索引来搜索通常是最有效的方法。就像一本书的索引一样，M S D N 索引在关键字和一个相对较小的相关文章列表之间建立了联系，这使你可以快速找到所需要的信息。另一方面，全文本搜索覆盖范围更宽，它比索引提供更多的文章以供选择。搜索结果取决于你如何仔细地用短语描述搜索字符串，并充分利用搜索运算符。经过一次全文本搜索之后，在搜索列表中仔细地寻找最适合于自己的问题的文章，将是一个单调乏味的过程。

如果该主题对你来说是陌生的，你可能需要概述信息，并了解一般的背景知识。这种情况下，MSDN 目录列表可能是最好的求助对象。首先看看目录列表的整体结构来了解其内容。有时，少量索引或全文本搜索能帮助你找到感兴趣的列表区。用这种办法找到一个感兴趣的主题后，你可以通过单击 M S D N 工具栏上的Locat e（定位）按钮，来确定该主题标题在目录列表中的出现位置。 Previou s（前一个）和 Nex t（下一个）按钮选择列表中相邻的文章，它使你能够通过按顺序排列的相关文章来浏览整个列表。许多主题开头都有几行非常有帮助的超文本链

接，它们能带你到一个主页、一个主题综述、一个常见问题列表等等。

Favorites （收藏）选项卡

在帮助文本中从一篇文章跳到另一篇文章时，你会不可避免地想要回到早先阅读过的文章。图 1-13 所示的 Favorites（收藏）选项卡这时就有用了，它维护着一个标记选择过的文章的书签列表，这样，你就可以很快地返回到以前阅读过的文章了。这些标记就像一个由 Web 浏览器维护着的书签，并且你会发现，它们对你在探究在线帮助时折回原来的位置很有帮助。如果不删除，添加到该列表中的标题会一直保留，因此，当你启动 M S D N 程序时， Favorite s（收藏）选项卡保持上次离开时的样子。

当前文章（即显示在右边窗格中的文章）的标题出现在 Favorite s（收藏）选项卡的底部。单击 Ad d（添加）按钮，将该标题添加到列表中；双击列表中的一个标题会回到该文章。

致谢 - 图20

图 1-13 Favorites （收藏）选项卡保持想要重新访问的文章列表

访问万维网

通过嵌入 Internet Explorer 浏览器， M S D N 可以接触到其他 Web 站点上的信息来源，不论它们在哪里。文章可以包含 Internet 地址（通用资源定位符或 URL ）作为超文本链接，因此， MSDN 可以像打开其他任何库中的文章一样来打开一个Web 网页。

致谢 - 图21

图 1-14 通过 MSDN 来访问 Web 站点

要指定目标 Web 网点，从 G o （转向）菜单中选择 URL 命令，并输入网点的网址。图 1-14 演示了一个范例。

在开发环境之外工作

大多数 Visual C++ 工具只有在 Developer Studio 环境内部才是可用的，但编译器、链接器、资源编辑器和生成程序例外。这些程序像 32 位控制台实用程序一样运行。通过编译和链接来生成应用程序时， Visual C++ 用生成程序来执行两个编译器和一个链接器。它们的输出消息通常送到系统的标准输出设备，这些消息被捕获，并显示在环境的 Outpu t（输出）窗口中。不用环境也可以生成应用程序，从命令行执行四个程序 NMake.exe 、 CL.exe、 Link.exe 和 RC.exe 即可。

但在 Developer Studio 之外工作是不切实际的。本章开头的特征列表说明了环境给程序开发带来的好处，尤其（不是唯一）是对使用 MFC 库的 C++ 开发工作。除非你有遗留下来的 C 语言源文件以及还要使用的生成文件，你一定会发现，在环境内部的开发工作更容易，且更具创造性。第 3 章解释如何使用旧的文本编辑器（如果你愿意的话），但 Developer Studio 远不只是一个文本编辑器而已。没有了它， Visual C++ 就去掉了精华部分。本书的每一章都描述了如何使用环境的某些部分来创建和维护 C/C++ 程序。本章仅仅是个开头。

第 2 章 A p p W izard （应用程序向导）

Visual C++ 最显著的技术之一就是它的“ 向导 ”。每个向导擅长为一种特殊类型的程序建立项目，它在创建新项目时提供一个很好的开端，这样，你就不必从头做起了。它像其他动态链接库一样，在 Developer Studio 环境下运行，并且要求你提供新程序的特征，然后生成启动器源文件，其中这些新特征的大部分通用代码都已经替你写好了。 Visual C++ 为专业项目，如 ActiveX 控件和 Developer Studio 附加实用程序，提供了各种各样的向导。甚至有向导来帮助你建立自己的定制向导。在后面的章节中，我们会遇到其中一些类型的项目，但本章着重讨论 Visual C++ 的主向导： AppWizard （应用程序向导）。除了措辞上有所差别外，第 6 版的AppWizard （应用程序向导）同以前的版本没有什么改变。如果以前你曾经使用过 AppWizard （应用程序向导），可以跳过这一章。

AppWizard （应用程序向导）的优点

AppWizar d（应用程序向导）擅长为使用微软基础类库的典型的 C++ Windows 应用程序建立开发项目。

如果你想用 C 来写程序，或不愿意使用 MFC ，请忘掉 AppWizard （应用程序向导）。用 W in32 Application Wizard 来代替 AppWizar d（应用程序向导），不会对你有什么影响。较早版本的 AppWizard （应用程序向导）是专门为创建基于文档 / 视图结构的应用程序而设计的，这种结构中程序的数据由文档对象来维护，并通过视图对象提供给用户。 MFC 本身就倾向于这样一种程序结构。在 Visual C++ 的较晚版本中， AppWizard （应用程序向导）已经变得更加灵活了，它在没有内置文档支持的时候，也能准备应用程序，这个选项对许多不读取或创建文件的较小的程序来说，是非常合适的。你可以把这种简洁的逻辑形式称为“ 视图单一结构 ”，用来代替文档 /视图结构，因为这样创建的应用程序包含一个处理显示的视图类，但没有为文档对象提供通信类。 AppWizard （应用程序向导）也能创建一个不依赖于文档 /视图的基于对话框的应用程序，它通过对话框来与用户交流。第 5 章描述如何在 Visual C++ 中使用 AppWizard （应用程序向导），来创建基于对话框的应用程序，及不使用 AppWizard （应用程序向导）时又如何创建。

在生成的项目中，每个类都有它自己的执行文件和头文件。文件中的全部源代码从空的存根函数到完全成型的程序元素，如工具栏和用户可从 Help （帮助）菜单中调用的 About （关于）对话框，都应该包括在内。 AppWizard （应用程序向导）为各种各样的程序特征提供了代码，这些特征包括：

单文档、多文档和对话框界面。
停靠工具栏、状态栏和打印机支持。
带有典型的操作命令，如 Open （打开）、 Save （保存

）、 Prin t（打印）、

Cu t（剪切）、 Copy （复制）和 Paste （粘贴）的菜单。

上下文相关帮助的启动器文件。
显示程序信息和 MFC 图标的 Abou t（关于）对话框。
数据库支持。
对复合文档、 Automation 和 ActiveX 控件的 OLE/ActiveX 支持

。
对消息应用编程接口（ MAP I ）和 W indows Sockets 的支持

。

在这一章中，我们将着眼于如何用 AppWizard（应用程序向导）来创建一个预先载有这些和其他一些特征的新项目。为使你了解 AppWizard（应用程序向导）可节省你多少工作，图 2-1 演示了从 AppWizard （应用程序向导）生成的项目文件中生成的一个典型的应用程序，它只有一个窗口。这个例子中不需要再做其他的编程工作。

致谢 - 图22

图 2-1 AppWizard （应用程序向导）创建的基本应用程序

AppWizard （应用程序向导）仅在建立项目的开头运行一次，它在开始时，提供足够多的选项，但随后就不再提供了。然而，你并不是完全漫无目的地漂游，因为 AppWizard （应用程序向导）建立项目的方式允许你使用其他的 Visual C++ 工具，如 ClassWizard 来继续开发过程。例如，当查看 AppWizard（应用程序向导）源文件时，你会注意到一些特殊的注释语句。在第 6 章中，我们将看到 ClassWizard 用这些注释来监控项目的类。

AppWizard （应用程序向导）为项目生成的源文件的数目取决于你指定的特征。表 2-1 显示了一个典型的列表。表中每个执行文件都有一个相应的同名头文件。

表 2-1 AppWizar d（应用程序向导）生成的典型的源文件，斜体的项目表示项目名

文件说明

project.cpp 主应用程序源文件

ProjectView.cpp 程序的视图类源代码

ProjectDoc.cpp 程序的文档类源代码

MainFrm.cpp 类 CMainFrame 的源代码。这个类是从 MFC 的 CFrame W nd 或 CMDIFrameWnd 派生来的，它控制程序的主窗口

续表

StdAfx.cpp 用来建立一个名为 project.pch 的预编译头文件。预编译头文件采用 MFC 的编译形式，它包括项目引用的文件，这些文件带有前缀“ Afx ”。对象的计算结果数据使预编译头文件很大，通常超过 6 M B 。但头文件通过节省对未变动的代码的编译工作，从而显著地缩短了编译时间

project.rc 包含项目的资源数据（在第 4 章中讨论）

Resource.h 包含 #define 语句来为项目声明常量

刚开始时，你可能试图想放弃 AppWizard （应用程序向导），它对于核心编程人员来说限制太严。而且，如果你有规律地创建一些相同类型的项目，对你来说，通过复制和修改以前的项目源文件来开始一个新项目，比起用 AppWizar d（应用程序向导）来创建一套新文件来说，要容易得多。但 Visual C++ 中的向导技术已经成熟到这种地步：它不知何故，看起来相当容易，以致于不用 AppWizard（应用程序向导）简直是一种错误。在不到 60 秒的时间内，你就可以完成一个开发项目的单调乏味的常用设置过程，而直接开始代码开发。并且，你可以依赖AppWizard （应用程序向导）写的源代码，它保证是没有错误的，这是你在项目

间剪切和粘贴代码所不能保证的。如果你所计划的程序正是 AppWizar d（应用程序向导）所指定的类型，请不要犹豫。你通过用 AppWizard （应用程序向导）来建立项目，可以节省大量时间。

运行 AppWizard （应用程序向导）

通过环境的 File（文件）菜单中的 New （新建）命令可开始一个 AppWizard （应用程序向导）项目：

致谢 - 图23

单击 New （新建）显示 New （新建）对话框的 Projec t（项目）选项卡，其中列出了 Visual C++ 中的向导。要运行向导来为一个典型的 Windows 应用程序创建项目，选择标有 MFC AppWizard(exe) 的图标，如图 2-2 所示。现在我们集中讨论这个 AppWizard （应用程序向导）。通过 MFC AppWizard （应用程序向导） (dll) 图标调用的 AppWizard （应用程序向导），为你建立动态链接库开发项目，下一章我们将讨论这个问题。

致谢 - 图24

图 2-2 要为典型的应用程序创建项目，需选择 MFC AppWizard(exe) 图标

为项目输入一个名字。正如前面提到过的那样， AppWizard （应用程序向导）用项目名来区别项目中不同的文件，因此，项目名要适当地短一些。项目一旦建立以后，就没有办法改变它的名字。默认情况下， Visual C++ 把 AppWizard （应用程序向导）项目放在 Common\MsDev98\MyProjects 目录下；如果你想用其他目录，在 Locatio n（位置）文本框中指定一个路径。直到你选择列表中的一个图标，并输入一个项目名， O K （确定）按钮才能用。

单击 OK （确定）时， AppWizard （应用程序向导）以对话框的形式提供多达６个步骤。在每个步骤中，对话框的左边显示一个图片，来给出设置的视觉提示。在每一步中，单击 Finish（完成）按钮，将结束 AppWizard（应用程序向导），并接受剩下步骤中的默认设置。为了在一系列步骤中前进或后退，单击 Next （下一步）或 Back （后退）按钮即可。

步骤 1 ：程序界面

如图 2-3 所示， AppWizard （应用程序向导）的第一步指定了应用程序的类型，选择单文档界面 (SDI) 、多文档界面 (MDI) 或基于对话框的界面。要创建不需要文档对象来从磁盘文件中读取数据的简单的 W indows 应用程序，把标为Document/View Architecture Support （文档 /视图结构支持）复选项禁用即可。

致谢 - 图25

图 2-3 在 AppWizard （应用程序向导）的第一步中选择应用程序的界面

对于一次只处理一个文档对象的 SDI 应用程序，请打开 Single Documen t（单文档）单选按钮。这个选项对那些不能明确地遵循文档 /视图结构的应用程序也是适用的。一个 SDI 应用程序的一般性维护程序，比起相应的 MDI 应用程序来说，要小得多，因此， SDI 应用程序的可执行文件要更小一些。

MDI 应用程序的优点是能一次处理任意数量的文档，它在每个分离的窗口中显示一个文档。用户可以在不同的文档窗口中工作，并把每个文档单独保存为一个文件。在后两章中我们将看到， Visual C++ 本身就是 M D I 应用程序的一个例子，它能在不同的编辑窗口中显示文本或非文本数据。

第三种界面选项创建一个基于对话框的应用程序。这种选择对于那些不需要一个主窗口的小实用程序非常适合，因为用户通过对话框就可与程序交流。基于对话框的界面并不像听起来那样限制严格，第 5 章演示了如何创建显示一个属性表的基于对话框的应用程序，该对话框能接受并显示大量信息。W indows 所带的 Phone D iale r（电话拨号程序）实用程序就是基于对话框的应用程序的一个例子。

因为第 5 章将详细讨论基于对话框的应用程序，这里就不再讨论基于对话框的界面这一选项。然而，本章中大部分信息对基于对话框的应用程序也是适用的。

AppWizard （应用程序向导）的步骤 1 还要求你提供程序界面的语种。可选的语言取决于你安装到系统上的 AppWizard（应用程序向导）库；单击文本框附近的箭头按钮，可显示可选的语言。每种语言都依赖它自己的动态链接库，默认情况下，这些动态库都安装在 Common\MsDev98\bin\ide 文件夹中。库文件名以

Appw z xxx .dll 的形式表示，其中 xxx 表示一个三位的语言代码。例如， enu 代表美国英语， deu 代表德语，而 fra 代表法语。图 2-4 显示了在三种不同语言中由AppWizard （应用程序向导）生成的应用程序的 File （文件）菜单的样子。

致谢 - 图26

图 2-4 在三种不同的语言中的应用程序的 File（文件）菜单

步骤 2 ：数据库支持

在图 2-5 中所示的 AppWizard （应用程序向导）的第二步中，要求你提供项目所需要的数据库支持种类。这一步和下面的步骤假定你在第一步中选择了带文档 / 视图支持的 Single Document （单文档）或 Multiple Documents （多文档）选项。

致谢 - 图27

图 2-5 在 AppWizard （应用程序向导）的步骤 2 中选择数据库支持

如果你的项目不使用数据库，单击 Nex t（下一步）按钮跳过这一步，进到步骤 3 。如图 2-5 所示，四个单选按钮决定了 AppWizard （应用程序向导）添加到项目的数据库支持程度：

None （无）：在生成项目时，把数据库支持的库文

件排除在外。如果你的项目不使用数据库，选择 None （无）单选按钮，来避免在项目文件增加不必要的代码。你可以以后再往项目中添加数据库支持。
Header files only （只有头文件）：在生成过程中，包

含数据库头文件和库文件，但 AppWizard（应用程序向导）不为数据库类生成源代码。你必须自己写所有的源代码。这个选项适用于那些开始时不使用数据

库，但你打算以后添加数据库支持的项目。

**Database view without file suppor t（数据库视图，没有文

件支持）**：包含数据库头文件和库文件，同时也创建一个记录视图和记录集。生成的应用程序支持文档，但不支持串行操作。
**Database view with file support（数据库视图，具有文件支

持）**：设置同上，除了生成的应用程序既支持数据库文档，又支持串行操作。

如果你用最后两个选项中的一个来包含数据库视图，那么，除非你指出数据源，否则不能继续到下一步。

数据来源

要指定数据来源，单击 Data Sourc e（数据来源）按钮显示图 2-6 所示的 Database Options（数据库选项）对话框。

致谢 - 图28

图 2-6 在 Database Options（数据库选项）对话框中确定数据来源

Database Option s（数据库选项）对话框提示输入数据源是遵循开放式数据库互接

(ODBC )标准，还是微软的数据访问对象 (DAO )标准，或 OLE 数据库 (OLE DB) 标准。 ODBC 功能在数据库管理系统，如 M icrosoft Access、 Oracle 或 dBase 的特定的驱动程序中实现。Visual C++ 提供了一个 ODBC 驱动程序的集合；其他的可从经销商那里买到。要查看 Visual C++ 中包含的驱动程序列表，参看标题为“ ODBC Driver Lis t” 的在线帮助文档。

选择 ODBC 作为程序的数据源类型时， AppWizard（应用程序向导）生成代码来调用 “ ODBC 驱动管理 ”，并通过它来调用合适的驱动程序。驱动程序用结构化查询语言 (SQL ) 来同目标数据库管理系统发生联系。 ODBC 支持保证应用程序能访问不同格式和不同结构的数据。

选择 ODBC 会激活一个列有 ODBC 数据源管理器中注册过的所有数据来源的下拉列表。数据源既包含数据，也包含访问数据所需的信息。要注册数据源，或取消数据源的注册，在 Control Panel（控制面板）中双击 32 位 ODBC 图标来运行管理器。在安装过程中， Visual C++ 通常会装入数据源管理器，但如果你是定制

安装 Visual C++ 的，你的系统中可能会没有数据源管理器。如果 Control Pan e （l 控

制面板）中没有 32 位 ODBC 图标，需重新运行 Visual C++ 安装程序，并安装必要的 ODBC 数据库支持文件。

DAO 是微软产品如 Access 和 Visual Basic 的标准。 DAO 用 M icrosoft Jet 数据库引擎来提供一套访问对象，包括数据库对象、表定义和查询定义对象及记录集对象。尽管 DAO 在 M D B 文件（例如那些由 M icrosoft Access 创建的文件）上工作

得最好，一个 D A O 程序也能通过 Microsoft Jet 来访问 ODBC 数据源。

OLE DB 是一种新的数据访问方法，它允许一个称为“ 使用者 ” 的客户应用程序从任何装备了被称为 “ 供应者 ” 的数据翻译器的数据源中取回数据。“ 供应者 ” 对应用程序来说，就像一组组分对象模型 (COM )对象，它通常不创建数据，而作为一个中间人以自己所带的格式访问数据，并以可识别的形式把数据传递给“ 使用者 ”。图 2-7 说明了 “ 使用者 ” 如何同“ 供应者 ”（而不是同原始的数据源创立者）通信。

致谢 - 图29

图 2-7 在 OLE DB 中，在数据客户与提供者之间的典型交互

OLE DB 的优点是在 “ 使用者 ” 和 “ 供应者 ” 间不需要任何关于数据格式的预定协议。至少“ 供应者 ” 负责把数据翻译成 “ 使用者 ” 理解的形式，通常是表格式的格式。“ 供应者 ” 也能对未加工的数据进行改进，例如，按照指定的标准进行查询处理和排序。在 AppWizard （应用程序向导）的 Database Option s（数据库选项）对话框中选择 OLE DB 选项，是创建一个使用数据的应用程序（而不是数据供应者）的第一步。这个选项从称为 “ OLE DB 使用者模板 ” 的类库中生成代码，该类库提供了对 OLE DB 类对象，例如 CDataSource 和 CSession 的包装。Visual C++ 提供了另一个向导（ ATL COM AppWizard ）来帮助编写“ 供应者 ” 应用程序。第 10 章对 ATL COM AppWizard 和 Active Template Library 有更多的描述，尽管它是从编写 ActiveX 控件的角度，而不是从 OLE DB 供应者的角度上来说的。

记录集类型

通过在 Database Option s（数据库选项）对话框中的 Recordset Typ e（记录集类型）部分中选择三个单选按钮中的一个，可以指定程序使用的记录集类型。三个单选按钮作用描述如下：

Snapsho t（快照）：快照记录集保持快照创建时的数

据视图。快照是静态的，这意味着，记录集不会反映出原始数据的改变，除非通过调用类 CRecordset 或 CDaoRecordset 的 Requery 函数来刷新它。
Dynaset （动态集）：动态记录集的内容是动态的，

这意味着，记录集自动更新，来反映记录的最新改变。然而，动态设备保持一套固定的记录。一旦动态集建立，其他用户创建的新记录就不会添加到这个集

合中去。

Table （表）： Table （表）选项只有数据源类型选择
为 D A O 时才是可用的。该选项允许程序使用 DAO 对象以表的形式来操作数据。当选

择 Tab l（e 表）单选按钮，并单击 O K（确定）按钮，来关闭 Database Options

（数据库选项）对话框时，另一个对话框就会出现。在这个对话框中，你可以选择程序使用的列表。

步骤 3 ： OLE 和 ActiveX 支持

在 AppWizar d（应用程序向导）的第三步 ( 图 2-8) 中，设置程序的 OLE 和 ActiveX 支持类型。对话框上半部分的五个单选按钮控制着 AppWizard （应用程序向导）添加到程序中的复合文档支持的类型。下面是这些选项的说明：

致谢 - 图30

图 2-8 在 AppWizard （应用程序向导）的第三步中指定 OLE 、 ActiveX 支持

None （无）： AppWizard（应用程序向导）不为复合文

档支持生成任何代码。
Containe r（包容器）： AppWizar d（应用程序向导）创

建能包含链接和嵌入对象的程序。
M ini-serve r（微型服务器）：程序充当一个微型服

务器，它能创建复合文档对象，集成应用程序能把这些对象合并到自己的文档中。这样的文档对用户来说，就像单一文档一样，但实际上它是由不同的来源形

成的。微型服务器直接把数据写在集成应用程序的文档中，而不是写在磁盘文件中，因此，对微型服务器创建的对象集成应用程序能嵌入，但不能链接。微型服务器应用程序不能作为独立的程序运行，而必须由集成应用程序来启动。 M icrosoft Draw 就是微型服务器的一个例子。

Full-server （全服务器）： AppWizard （应用程序向导
）创建的程序能充当一个全服务器应用程序，它具有微型服务器的全部特性，再加上附加的性能。像微型服务器一样，全服务器应用程序能由集成应用程

序来启动，但它也能作为一个独立的 Windows 应用程序来运行。AppWizard （应用程序向导）增加了对把数据存储到磁盘文件中的支持，因此，全服务器应用程序能像支持嵌入一样支持链接。

Both container and serve r（包容器和服务器）： AppWizar
d（应用程序向导）生成代码使程序既能像集成应用程序那样嵌入对象，又能像服

务器应用程序那样提供对象。

通过集成应用程序或服务器应用程序来选择一个复合文档选项，会让你为活动文档选择附加支持。活动文档在客户和服务器之间提供一个比普通的嵌入文档更高程度的集成，它允许由一个应用程序维护的文档出现在另一个应用程序的窗口中。图 2-9 显示了这种集成的一个例子，其中 Internet Explore r（本例中的包容器）打开了一个由服务器 Microsoft Word 创建的文档。

如果你希望你的包容器或服务器程序能串行化复合数据，也就是说，把文档和对象保存到磁盘上，打开单选按钮，来请求对复合文件的支持。尽管从概念上来说，复合文档是单纯的文档，实际上，它代表不同文件的组合，一个文件包含文档，而其他文件则包含链接到文档的对象。当保存复合文档时，包容器负责把自己的文档对象写到磁盘上。然后它给服务器传递一个请求，来把包容器正在使用的各个对象保存到同一个 “ 存储器 ” 中。

致谢 - 图31

图 2-9 Active 文档包容器和服务器在一起工作的例子

第三步的对话框底部的两个复选项询问，是否要求 Automation 和 ActiveX 控件支持。默认情况下， AppWizard （应用程序向导）激活 ActiveX Controls （ ActiveX 控件）选项；如果程序不会嵌入 ActiveX 控件，请清除该复选项。这个决定并不是不可取消的，以后，你可以轻易通过包含一行代码，来向 MFC 程序中添加ActiveX 控件支持。要了解如何向已存在的 MFC 程序中添加 ActiveX 控件支持，

请参阅第 8 章。

步骤 4 ：用户界面特征

在图 2-10 中所示的 AppWizar d（应用程序向导）的第四步中可以控制 AppWizard

（应用程序向导）为程序创建哪些用户界面元素。

致谢 - 图32

图 2-10 在 AppWizard （应用程序向导）的第四步中选择程序的用户界面特征

AppWizard （应用程序向导）自动为程序主窗口的菜单系统、工具栏及状态栏生成代码和数据。工具栏包含与菜单命令效果一样的按钮，而状态栏则显示命令和工具栏按钮的描述信息。当光标在菜单命令或工具栏按钮上停留一段时间后，帮助信息会出现在状态栏上，如下图所示：

致谢 - 图33

没有选中命令时，状态栏显示诸如“ Ready ”、“ For Help, press F1 ” 或任何其他信息。状态栏也包括了键盘的 Caps Lock 、 Num Lock 和 Scroll Lock 键的指示器。当程序运行时， MFC 框架自动更新指示器，因此，你不需要添加其他代码来并入这一特征。

Normal （常规）和 Internet Explorer Rebars 单选按钮为应用程序的工具栏提供两种不同的风格。选择 ReBars 选项，会用 MFC 的新的 CReBar 类来为工具栏生成代码，最终会生成 Visual C++ 、Internet Explorer 及其他应用程序中的平面的工具

栏风格。平面的工具栏是可以调整大小的，因此使用速记词 “ rebar ”，只有当鼠标移到按钮上面时，该按钮才凸起。菜单、工具栏和状态栏的主题将在第 4 章详细讨论。

打印支持

默认情况下 AppWizar d（应用程序向导）激活 Printing And Print Preview（打印和打印预览）复选项。这个选项向应用程序的视图类中添加启动器代码，它跨过了MFC 的 Cview 的三个虚拟函数：

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//CDemoView printing

BOOL CDemoView::OnPreparePrinting(CPrintInfo*pInfo)

{

// default prepartation

return DoPreparePrinting(pInfo);

}

void CDemoView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo/)

{

//TODO: add extra initialization before printing

}

void CDemoView::OnEndPrinting(CDC* /*pDC*/,CPrintInfo* /*pInofo*/)

{

// TODO:and cleanup after printing

}

这些为在文档 /视图程序中打印提供了功能框架，但在程序打印文档之前，你还需要做更多的工作。要更好地了解如何向 MFC 程序中添加打印功能，参阅 Jeff Prosise 的《 Programming Windows 95 with MFC 》的第 10 章。 MSDN 在线帮助也提供了由“ Printing and Print Preview Topics ”开始的一系列主题信息。选中 Search Titles Only 复选项，并在 M S D N 的 Searc h（搜索）选项卡中键入该标题，即可找到该主题。

在线帮助

激活 Context-Sensitive Help （上下文相关）复选项，会告诉 AppWizard （应用程

序向导）你希望程序提供在线帮助。 AppWizard （应用程序向导）会向项目中添加源代码和一系列文件来帮助你创建一个完整的帮助系统。 AppWizard （应用程序向导）会仔细地说明它添加到程序中的所有的命令和工具栏按钮，例如 New 、Open 、 Cut 和 Paste 。这些说明清晰完整，你不需要再做更多的工作，只需要通过说明那些自己添加到程序中的命令来加强帮助文件。本部分首先描述了AppWizard （应用程序向导）创建的帮助系统，然后简要解释如何用自己的帮助文本来加强帮助系统。

当程序需要上下文相关帮助时， AppWizard （应用程序向导）在项目文件夹中创建一个名为 HLP 的子文件夹。 HLP 子文件夹中的文件之一是名为 AfxCore.rtf 的主题文件。如果程序要求打印支持， AppWizard （应用程序向导）还添加另一个名为 AfxPrint.rtf 的主题文件。以多信息文本格式写的 AfxCore.rtf 和 AfxPrint.rtf 包含了描述 AppWizar d（应用程序向导）给项目添加的特征的帮助文本。HLP 子文件夹也包含一个与该项目同名，而扩展名为 HPJ 的帮助项目文件。当你生成项目时，Visual C++ 在启动编译器之前，先执行名为 M akeHelp.bat 的批处理文件。M akeHelp.bat 运行 Makehm.exe Help Maintenance 实用程序，它读入项目的Resource.h 文件中的标志定义，并创建扩展名为 H M 的帮助映像文件。然后该批处理文件运行 Hcrtf.exe 帮助编译器，来收集取自帮助映像文件、项目的 HPJ 文件及 RTF 文件中的文本，它用这些来创建一个 W indows WinHlp32 帮助文件查看器能读取的 HLP 文件。

AppWizard （应用程序向导）也写一些源代码来运行 WinHlp32 ，并加载项目的

HLP 文件来响应用户的帮助请求。整个帮助界面是通过在项目的 MainFrm.cpp

文件中将四个入口添加到消息映像中实现的，如下所示：

BEGIN_MESSAGE_MAP(CMainFrame,CFrameWnd)

ON_COMMAND(ID_HELP_FINDER,CFrameWnd::OnHelpFinder)

ON_COMMAND(ID_HELP,CFrameWnd::OnHelp) ON_COMMAND(ID_CONTEXT_HELP,CFrameWnd::OnContextHelp

)

ON_COMMAND(ID_ DEFAULT _HELP_ CFrameWnd::OnHelpFinder) END_MESSAGE_MAP()

映像中的每个入口指向由 MFC 框架提供的三个函数之一。调用这些函数用以响

应不同的事件，每个函数都调用 W inHlp32 ，并显示项目帮助文件中的相应文本。

下面的列表描述了什么时候调用函数：

被调用的函数当用户做如下事情的时候

OnHelpFinder 从 Hel p（帮助）菜单中选择 Help Topics

（帮助主题）命令时

OnHelp 按 F1 键来接受关于当前上下文的帮助时

OnContextHelp 按 Shift+F1 或单击工具栏上的 Hel p（帮助）按钮时

从 Help （帮助）菜单中选择 Help Topic s（帮助主题）命令，会在 W inHlp32 查看器中显示一个典型的 Help Topics（帮助主题）对话框，如图 2-11 所示。用户可以浏览 Help Topic s（帮助主题）对话框来寻找想得到的主题帮助。

致谢 - 图34

图 2-11 Help Topics （帮助主题）对话框

AppWizar d（应用程序向导）在程序的工具栏上也添加了一个 Hel p（帮助）按钮，它同 Developer Studio 对话框右上角的小问号按钮相类似。单击 Help （帮助）按

钮，会把鼠标形状改变为一个带问号的箭头。然后，用户可以单击程序窗口的任何部分，包括菜单命令、状态栏和工具栏按钮：

致谢 - 图35

调用 Help （帮助）工具，将引起程序执行 WinHlp32 ，它显示一个描述所单击元素的帮助窗口。例如，通过像上面所说的那样单击 Save 按钮以获取帮助时，会显示图 2-12 所示的帮助窗口。

通过描述其他程序自身的特征，可以加强帮助系统，在一个能识别多信息文本格式的字处理程序中加载 AfxCore.rtf 。不要使用 W indows 所带的 WordPad 实用程序。尽管 WordPad 能读取多信息文本文档，但它不保存帮助编译器所需要的信息。多信息文本文档也是以普通的 ASCII 格式写的，因此，在紧急时候你可以通

过文本编辑器来作小小的改动。

创建自己的帮助文本的第一步是搜索字符串 “ <<YourApp>> ”，并用应用程序名来取代它。双击文档中的角括号 (<<>> )，会装入提示你应添加的文本类型的占位符文本。用新的文本来取代提示和角括号。去除应用程序不用的所有主题，并从AppWizard （应用程序向导）放在文件中的文本中取出对重要格式的提示。文件中的主题必须由硬分页符分隔开。

致谢 - 图36

图 2-12 程序的 Sav e（保存）命令的帮助窗口

写作帮助文件这个主题范围广泛，这里不可能将它完全说清楚。在线帮助描述了如何用 Visual C++ 提供的 Help Workshop 实用程序来构造由 AppWizard （应用程

序向导）生成的帮助系统。

Advanced （高级）按钮

在 AppWizar d（应用程序向导）第四步的对话框的右下角，是一个 Advance d（高级）按钮，单击它，将显示一个标题为“ Advanced Option s（高级选项）” 的两页的对话框。在第一页 Document Template String s（文档模板字符串）中，可以改写储存在 W indows 和 MFC 框架使用的程序数据中的某些字符串。如果在第三步中选中了 Active Document Server （活动的文档服务器）复选项，你必须在Document Template Strings 页中为应用程序的文档文件指定一个文件扩展名。在该页的第一个编辑框中键入扩展名，如下页图所示。

系统把带这种扩展名的文件识别为属于你的服务器应用程序的文件，这种方法与它用 M icrosoft Word 来关联 D O C 文件的方法一样。 AppWizard （应用程序向导）用适合于应用程序的字符串来填写剩下的编辑框，你可以接受它们，或按你的想法来修正它们。我们将在第 4 章中详细讨论这些字符串。

致谢 - 图37

对话框的第二页 W indow Styles （窗口风格）允许你控制程序主窗口的外观，而且，如果你在第一步中选择了 Multiple Documen t（多文档）选项，在这里还可以控制程序的文档窗口的外观。选择 Window Style s（窗口风格）页顶部的 Use Split W indow （使用分隔窗口）复选项，会在 SDI 项目的 M ainFrm.cpp 文件中添加下面这个函数：

BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT /*lpcs*/, CCreateContext* pContext)

{

return m_wndSplitter.Create(this,

2, 2,

Csize(10, 10), pContext);

}

MDI 项目在它的 ChildFrm.cpp 文件中接收到类似的 OnCreateClient 函数。对于

SDI 应用程序，OnCreateClient 函数启用程序主窗口中的分隔条。程序的 Vie w（查

看）菜单中的 Spli t（分隔）命令打开分隔条，它允许程序在同一窗口的一个、两个或四个窗格中显示数据。对于 M D I 应用程序， AppWizar d（应用程序向导）把Split（分隔）命令放在程序的 W indow （窗口）菜单中，它控制每个子窗口的分隔条。图 3-4 显示了 Visual C++ 文本编辑器中使用分隔条的例子。

步骤 5 ：使用 MFC 库

图 2-13 所示的 AppWizard （应用程序向导）的第五步询问你想创建的程序的风格、你是否需要附加的源代码注释，及你希望程序如何链接到 MFC 库。

致谢 - 图38

图 2-13 选择源文件注释和 MFC 库选项

项目风格

AppWizard （应用程序向导）提供了两种程序风格，它们由步骤 5 对话框顶部的两个单选按钮来决定。默认按钮为 MFC Standar d（ MFC 标准），对于创建带有从CView 派生而来的视图类的普通的 W indows 应用程序，它是正确的选择。本书中后面的章节在用 AppWizard （应用程序向导）来创建范例程序时采用 MFC Standard（ MFC 标准）设置，因此，这里花些时间来讨论一下第二个单选按钮的作用是值得的。按钮标题为 W indows Explorer（ W indows 资源管理器），是因为这时 AppWizard （应用程序向导）创建的应用程序有着与大家熟知的 W indows 所带的 Explorer（资源管理器）实用程序相似的外观和用户界面。

Explorer（资源管理器）形式的应用程序的主窗口被分隔成相邻的两个窗格，每一个窗格显示不同的内容，而且每一个窗格都由它自己的类来控制。左窗格的视图类派生自 MFC 的 CTreeView ，它使该窗格适合于显示一个通过树形层次相关联的条目列表，例如公司的职员列表、家谱表或硬盘上的目录和文件列表。对应于右边窗格的视图类派生自 CListView ，它被设计用来显示在某些方面属于左边窗格当前选中的选项的条目列表。像 Explore r（资源管理器）一样，程序的工具

栏包含了四个调整窗格外观的附加按钮，它允许用户选择大图标或小图标的不同排列。下面显示了一个典型的 Explorer（资源管理器）形式的应用程序的外观：

致谢 - 图39

左边窗格中包含的树形视图控制中的条目有小的加号和减号来展开或折叠列表。应用程序通过在窗口的 CREATESTRUCT 结构中设置风格标志，来添加按钮和分层线：

BOOL CLeftView::PreCreateWindow(CREATESTRUCT& cs)

{

cs.style |= TVS_HASLINES | TVS_HASBUTTONS | TVS_LINESATROOT;

return CTreeView::PreCreateWindow(cs);

}

我们还没有讨论过使你能检查和修改程序的 Visual C++ 编辑器，但如果你对回顾上述简单程序的源代码感兴趣，可以在附带光盘的 Code\Chapter.02\Demo 文件夹下找到这些项目文件。 Demo 项目是用 AppWizard （应用程序向导）来创建的，它在第一步中选择了 Single Document（单文档）选项，而在第五步中选择了W indows Explorer（资源管理器）选项，并且接受了剩下的 AppWizard （应用程序向导）的默认选择。 Demo 是一个基础项目，它仅创建了由 AppWizard （应用程序向导）生成的 Explore r（资源管理器）形式的应用程序所需的典型的代码。第 3 章和第 4 章更进一步地描述了如何用 Visual C++ 编辑器来访问和查看项目，例如那些在附带光盘上找到的项目。

源文件注释

要求源文件注释会使 AppWizar d（应用程序向导）在生成的源代码中添加有用的所做事项的注解。这些注解外观类似于下面的注释，它建议你添加的源代码，

应使一个特征或函数变得可操作：

void CDemoDoc::Serialize(CArchive& ar)

{

if (ar.IsStoring())

{

//TODO:add storing code here

}

else

{

//TODO: add loading code here

}

选择添加源文件注释，也会使 AppWizar d（应用程序向导）在项目文件夹中放置一个 ReadMe.txt 文件。 ReadMe 文件作为整个项目的目录列表，提供了对

AppWizard （应用程序向导）生成的所有文件的简要说明。链接到 MFC 库

第五步中的第三个选项决定程序如何链接到 MFC 。默认情况下，As A Shared DLL

（作为共享的 DLL ）单选按钮被选中，这意味着 AppWizar d（应用程序向导）建立应用程序，来动态地链接到包含在单独文件中的 MFC 库。这种链接方式显著地减小了应用程序的可执行文件的大小，并能更有效地利用系统资源。

然而，动态链接到 MFC 要求提供 M fc nn .dll 库文件，文件名中的 nn 代表 MFC 的版本号。文件通常是在 W indows System 或 System32 文件夹下。如果你的应用程序动态链接到 MFC ，而且应用程序通常是用在那些可能没有 M fc nn .dll 库的系统上，你应该把这个库文件作为应用程序包的一部分提供给用户。如果应用程序使用 Unicode ，则应用 Mfcnnu.dll 文件来代替上述的库文件。微软允许你自由地把这些库文件附在应用程序中。应用程序的安装程序可以搜索用户硬盘上已有的MFC 库文件，并把文件复制到 System 文件夹中（如果文件夹中还没有的话）。如果还没有 Msvcrt.dll 文件，则还要复制它，因为 MFC 使用 C 运行时库的共享版。库文件同旧的应用程序保持向上兼容，因此如果用户的 System 文件夹中已经包含有更新版本的 MFC 和 C 运行时库文件，你的安装程序就不需要再复制这些文件。

如果你的动态链接应用程序打算在国外发行，在那里，它可能会运行在不同语言的系统上，那么你需要考虑更多的事情。 MFC 库文件包含了字符串数据，例如

程序能访问的对话框文本和帮助信息。你必须保证应用程序不会访问和显示以用户母语以外的语言写的库文件字符串。有两个办法来解决这个问题。最简单的办法是写程序时使用自己专用的字符串数据，而不访问由库文件提供的文本（第 4 章更详细地讨论了这个问题）。然后，你在分发 M fc nn .dll 时，就可以不用考虑用户的区域设置了。

第二种解决办法是改写安装程序，使它询问主机系统的当地语言、把重新分配的M fc nnxxx .dll 文件复制到 System 文件夹中，并重命名为 M fc nn loc.dll（文件名中的 xxx 代表主机语言的三位代码，例如 deu 代表德语而 fra 代表标准的法语）。要了解这个主题的更多信息，参见在线帮助的 Technical Notes 56 和 57 ，你可以通过 MSDN 索引中的 “ MFC components ” 条目来找到它。

如果你愿意把应用程序静态链接到 MFC ，选择标题为 “ As A Statically Linked Library （作为静态链接库）” 的单选按钮。静态链接意味着，应用程序不依赖于MFC 库文件的存在，尽管它可能仍需要 Msvcrt.dll 文件。静态链接的代价是可执行文件更大，而且，对内存的利用可能不够充分。在 Visual C++ 的学习版中，静态链接到 MFC 是不可能的。

你在第五步中选择的 MFC 链接选项仅仅是项目的初始设置，你可以在开发过程中的任何时候选择一个不同的选项。在生成项目之前，从 Projec t（项目）菜单中选择 Settings（设置）命令，并在对话框的 Genera l（常规）选项卡中选择静态或动态链接。

步骤 6 ：类和文件名

AppWizar d（应用程序向导）的第六步（也是最后一步）逐条列举 AppWizar d（应用程序向导）将为项目创建的类。要改变类的名字，在列表中选中它，并在 Class Nam e（类名）文本框中输入一个新名字。其他的文本框显示了 AppWizard （应用程序向导）为类源代码创建的文件名。这些名字只是一个建议，你可以为列表中除应用程序类 ( 图 2-14 中名字为 CDemoApp 的类 ) 外的所有类输入一个新的名字。包含应用程序类的源文件的名字取自项目，因此不能被改变。

致谢 - 图40

图 2-14 在 AppWizard 的第六步中指定类名

单击 Finish （完成）按钮后， AppWizard （应用程序向导）显示一个摘要表，其中列出了所选的项目特征 ( 图 2-15) 。这个摘要是你取消项目的最后机会。单击O K （确定）会使 AppWizard （应用程序向导）在摘要表底部所列的目录下创建项目。

致谢 - 图41

图 2-15 在 AppWizard （应用程序向导）中选择的项目特征列表

用 AppWizard （应用程序向导）来创建 DLL 文件

如果你要开发一个动态链接库，而不是一个普通的 W indows 应用程序，在 New

（新建）对话框中选择 MFC AppWizard(dll) 图标 ( 参见图 2-3) 。这个特殊的AppWizar d（应用程序向导）仅显示图 2-16 所示的一个步骤，它询问诸如你的动态链接库应如何链接到 MFC 之类的信息。

致谢 - 图42

图 2-16 使用 AppWizard （应用程序向导）设置 DLL 项目

这个向导提供了三个不同的链接选项，每个都有优点和缺点。前两个选项使动态链接库能被任何 W in32 程序访问。第三个选项限制较严，因为它创建的动态链接库只能用在使用 MFC 的应用程序和其他库文件上。下面描述了各个链接选项：

Regular DLL with MFC statically linked （具有静态链接 MFC 的

常规DLL ）：动态链接库静态地链接到 MFC ，这使它能不依赖于 MFC 库文件的存在，而运行在任何的 W in32 系统上。
Regular DLL using shared MFC DLL （使用共享 MFC DLL 的常规DLL

）：运行你的动态链接库需要访问正确版本的 MFC 库文件。这样就减小了最终的可执行文件大小，但正如前面解释过的那样，这可能需要在你的产品中附带 MFC 库文件。如果你的动态链接库是设计用在动态链接到同一版本的 MFC 的应用程序上时，你尤其需要考虑这个选项，因为这样一个 MFC 的实例就可以既用作调用的应用程序，又作为你的库文件。
MFC Extension DLL(using shared MFC DLL )（ MFC 扩展 DL L（使用

共享 MFC DLL ））：这个选项同前述的选项有些类似，最重要的差别是调用过程也必须动态链接到正确版本的 MFC 库文件。一个 MFC Extension DLL 提供的类加强或补充了原有的类的功能。要了解编写MFC Extension DLL 的详细信息，参考 Technical Note 33 ， M S D N 在线

帮助中的 “ DLL Version of MFC ”。

如果你想把动态链接库用在诸如 M icrosoft Excel 和 Visual Basic 之类的Automation 客户上，选中 Automation 复选项。选中 W indows Sockets （ W indows 套接字）复选项来添加对在 Internet 或其他任何使用 TCP/IP 协议的网络系统上进行通信的支持。选择 W indows Sockets 支持会使 AppWizard （应用程序向导）增加一个对 MFC 的 AfxSocketInit 函数的调用：

BOOL CDemoApp::InitInstance()

{

if (!AfxSocketInit())

{

AfxMessageBox(IDP_SOCKETS_INIT_FAILED); return FALSE;

}

return TRUE;

}

当然，你必须自己写实际的通信代码。

管理模块状态

为保持动态链接库的简易特性， AppWizard （应用程序向导）为库文件项目生成的代码比起它为普通的应用程序所写的源代码来更简洁。项目的 CPP 文件包含一个消息映像和类的构造器。文件还包括一个注释块，它解释库文件中输出函数可能需要调用 MFC 的 AFX_MANAGE_STATE 宏。这取决于你的动态链接库是静态还是动态链接到 MFC 库。静态链接到 MFC 库不需要AFX_MANAGE_STATE 宏，但是，因为项目的链接设置在开发过程中很容易改变，在开始的时候，最好先假设使用 MFC 的动态链接库是动态链接到 MFC 库文件的。因此，调用 MFC 的输出函数，应该像下面这样通过调用AFX_MANAGE_STATE 宏来开始：

extern “ c ” _declspec( dllexport ) void WINAPI ExportedFunction()

{

#ifdef _AFXDLL

AFX_MANAGE_STATE( AfxGetStaticModuleState() ); #endif

}

在每个线程的局部存储器的内部， MFC 维持了一个指向被称为 “ 模块状态 ” 的结构的指针，该结构中包含了 MFC 库当前正在维护的过程模块的特定信息。当应用程序进入到动态链接库的输出函数中时，模块状态属于调用它的应用程序，而不是属于你的库文件。在把执行权转移到 MFC 时，输出函数应首先把指针改变为指向 DLL 自己的模块状态。这就是使用 AFX_MANAGE_STATE 宏的目的，它临时把模块状态指针指向当前的模块（即你的动态链接库），然后，当输出函数完成，并返回到调用它的应用程序时，这个宏恢复原来的指针。AFX_MANAGE_STATE 宏在由 MFC 库文件自己调用的输出函数中并不是必不可少的，例如，在消息映像中列出的 InitInstance 和句柄函数，这是因为 MFC 在调用函数之前已经正确设置好了模块状态。

AFX_MANAGE_STATE 宏应该放在函数的开头附近，甚至要在对象变量定义之前，因为它们的构造器本身可能就包括对 MFC 库文件的调用。程序段中的 #ifdef 条件块保证编译器只为动态链接到 MFC 的库文件包含宏代码。如果链接是静态

的， Visual C++ 编译器没有预定义 _AFXDLL 常量。要更详细地了解AFX_MANAGE_STATE 宏，请参考 Technical Note 58 ，MSDN 在线帮助中的“ MFC Module State Implementation ” 。

第二部分编辑器

第 3 章文本编辑器

Visual C++ 提供了一个专门为 “ 代码剪切 ” 而设计的文本编辑器。这个编辑器与各种环境工具（诸如调试器）组成一个完整的统一体，并提供了大量复杂的特征，包括 Undo/Redo （撤销 /重做）、可定制的快捷键命令和对 W in32 和 MFC 参考的快速访问。

作为一个程序员，你一定已用过了一种或几种编辑器。本章将介绍 Visual C++ 文本编辑器最重要的几个方面，讲述一些有用的和隐含的特性，并展示怎样有效地使用编辑器。即使你仍愿使用现有的编辑器来完成大多数编码任务，也应浏览一下本章，以便了解 Visual C++ 的强大功能。不久你将发现，如果只想修改编译器错误，那么，在编辑文本时，将文本保持在 Developer Studio 环境中将是很方便的。在本章的最后，还有一些有用的建议。

由于 Visual C++ 是一个基于 W indows 的软件，它将其文本文件以 ANSI 格式存储。有关 ANSI 标准和 ASCII 及 ANSI 码表，请参考附录 A 。

启动文本编辑器

刚进入 Visual C++ 时，看不到文本编辑器，也不会在任何菜单下看到“ Start the text edito r（启动文本编辑器）”或 “ edito r（编辑器）” 之类的选项。在 Visual C++ 通向对象的环境中，只需给出文件类型，而不必管应该使用哪一个工具。在这个环境中，除了文本编辑器，还有其他几个编辑器。只需指出想创建或修改的是一个文本文件，而不是其他类型（比如说，图表文件）， Visual C++ 将会根据文件类型自动启动相应的编辑器。

进入编辑器后，如果想创建一个新文件，请单击 File（文件）菜单，再选择 New

（新建）。在如图 3-1 所示的 New 对话框中， Visual C++ 按字母顺序列出可以创建的文件类型。

致谢 - 图43

图 3-1 在 New 对话框中选择文档类型

输入文件名，然后在列表中选定其类型，如 Active Server Page、 C/C++ Header File 、 C++Source File 、 HTML Page 、 Macro File 、 SQL Script File 或 Text File 。再单击 O K（确定）就会发现，文本编辑器以一个空文档窗口的形式出现在屏幕上。此时菜单和工具栏都基本不变，但会有一声短促的喇叭声。为了保持工作的连续性， Visual C++ 采用通用的外观和动作，以便使软件易学易用。例如，如果新文档满屏显示，那么，除了文档本身外，只有很少的几条可视线索能表明此时是在文本编辑器中，而不是在 Visual C++ 的主窗口中。其中之一是在菜单栏的左边缘有一个小页标；另一个是在主窗口顶部标题栏中有文档名称，它指出了文档的类型。如果在 New （新建）对话框中没有给出文档名称，编辑器将自动给此新文档赋一个临时名称，像 Text1 或 Cpp1 ，直到给文档赋了新名称为止。

在本章后面会看到， Visual C++ 的菜单在各种编辑器中是通用的。虽然表面的菜单和工具栏基本不变，但在内部会有一些变化。例如，在使用文本编辑器时，许多在主窗口中呈灰色的命令被激活，而变为正常体。对不同的编辑器，Visual C++ 会自动激活相应的命令。例如，由于文本只对文本编辑器有效，因此， Find（查找）命令在使用文本编辑器时被激活，而呈正常体，而在使用图形编辑器时，则因未被激活，而呈灰色。图 3-2 中简要列出了使用文本编辑器时可用的菜单命令。

致谢 - 图44

图 3-2 文本编辑器菜单

除了上图中所列的命令外，还有一些命令是可用的。例如，如果在编辑器中删除了文本，却又想恢复它，可使用 Edit （编辑）菜单下的 Undo （撤销）和 Redo

（重做）命令， Undo （撤销）能记忆最近一次删除操作。如果要恢复更早删除

的文本，连续单击 Undo （撤销），或重复按 Ctrl+Z 直到恢复到需要的文本为止。不过，有时会多击一次，或多按一次，从而多恢复了无用的文本，这时候，可以使用 Edit （编辑）下的 Redo （重做）命令来取消最近一次 Undo （撤销）操作。

文档

这一节是本章最长的一节，讲述怎样创建、打开、浏览、存储和打印文本文档。如序言中提到的那样，如果已使用过基于 W indows 的文本编辑器或字处理器，那么本节所讲的一些知识只是对已有知识的复习。但是，即使对于有经验的W indows 用户，在它们了解了 Visual C++ 的细节后，它们仍能在浏览和打印文档方面获益。

打开文档

Visual C++ 文本编辑器支持多文档操作，所以可以同时打开多个文档。再使用 New

（新建）命令，就可以创建另一个新文档，系统自动默认文档名为 Text2 或 Cpp2 。如果是满屏显示，则正在使用的文档名称显示在屏幕顶端标题栏中。可以通过按Ctrl+F6 在已打开的文档间进行切换，也可通过从 W indow（窗口）菜单中挑选所需的文件的名称来实现切换。

同一个文档只能创建一次。当将一个新文档存到盘上时，从那一刻起，它将成为一个文件，想再次对它进行处理时，就必须打开它，而不能再创建它。用下述办

法可打开一个已存在的文件：

单击标准工具栏中的 Open （打开）按钮。

致谢 - 图45

按 Ctrl+O 。
选择 File 下拉菜单中的 Open （打开）命令。
选择 File 下拉菜单中的 Recent File （最新文件）命令 ,

再选择所需文件

的名称。

前三种办法都会出现 Ope n（打开）对话框 ,在对话框中 , 可以通过浏览各个文件夹来寻找想要打开的文件。最后一种方法不需要对话框 , 系统自动列出最近编辑过的文件列表 , 称做 MRU 列表 ,从这个列表中，可以直接打开所需要的文件 .

最近编辑的文件列表

在默认情况下， MRU 列表包含最近编辑过的四个文件，这四个文件并不只是文本编辑器编辑过的，也包含其他任意一种编辑器编辑过的文件。拉下 Fil e（文件）下拉菜单，将鼠标光标放在 Recent File 命令行上 , 就可显示 M R U 列表。在表中挑选文件名，就可在相应的编辑器中打开文件。当同时对几个文件进行操作时，使用 MRU 列表是很方便的。然而，你会发现，即使对于一个很小的软件项目，也需同时对四个以上的文件进行操作。这时， M R U 列表就显得不够用了。幸运的是，Visual C++ 允许扩展 MRU 列表，以使它可容纳更多的文件名。单击 Tool s（工具）菜单下的 Option s（选项）命令，然后按左、右箭头键选择 Workspac e（工作空间）项。在标有 Recent File List Contains（最新文件列表包含）的文本框中输入新值即可 ( 如下图所示 )。

Workspace 选项还提供了另一种影响 M R U 列表外观的选项。如果希望 M R U 列表直接出现在 Fil e（文件）菜单中，而不是隐藏在下一级命令里，只需取消 Show Recently Used Items On Submenus（在子菜单上显示最近使用的项）选项即可。不过，由于文件名的增加， File （文件）菜单会显得很拥挤

致谢 - 图46

Open （打开）对话框

如果所需的文件不在 M R U 列表中，那么，必须使用 Open （打开）命令，再在Open （打开）对话框确定文件。这个对话框中的默认路径是当前软件所在的文件夹，因此不必花很大力气来寻找文件。

在选择要打开的文件时，按下 Ctrl 键再单击文件名，就可以同时打开一组文件，每单击一次就多打开一个文件。如果想取消某个已打开的文件，只需再次按下Ctrl，同时单击该文件名即可。选定文件后，单击 Open （打开），就可将所有选中的文件分别打开成不同的文档。如果想打开的文件在其目录下是连续排列的，那么，有一种更快的方法来选中它们。可先单击选中第一个文件，再按住 Shift 单击最后一个文件，这样，在这两个文件间的所有文件都被选中了。如果想不要其中某个文件，只需按住 Ctrl 的同时单击该文件即可。

注意：在 Open （打开）对话框中列出的文件并不是该文件夹下的所有文件，这是由于 Files Of Type（文件类型）组合框中有过滤设置。“ 过滤 ” 是指只选择一组相关的文件。例如，系统默认的 C++ Files 过滤器将使 Open（打开）对话框中只包含以 C 、 CPP 、 C X X 、 TL I、 H 、 TLH 、 INL 和 RC 为扩展名的文件。如要列出其他类型的文件，如以 HPP 或 TXT 为扩展名的文件，则须在 Files Of Typ e（文件类型）框中选择相应的过滤器。

在 Ope n（打开）对话框中有一个 Open As Read-Onl y（作为只读文件打开）选项。

这是一个很重要的选项，一旦它被选中，将不能对打开的文件作任何改变，而只能对其浏览、打印，或将其复制到剪贴板上。通常，只需使用 File（文件）菜单下的 Save as （另存为）命令，将此只读文档以一个新名称保存，就可以解除只读限制。注意，此时原文件只读属性并未改变，只是新文件中没有只读限制。Visual C++ 6.0 还提供了一种设置，使得即使对于上面这种无害的操作，系统也不允许进行。 Tools （工具）菜单下 Options（选项）对话框中 Compatibility （兼容性）选项卡下，有一个 Protect Read-Only Files From Editing （阻止编辑只读文件）选项，当它被选中后，只读文件将不能以新名称另存。

查看文档

尽管文本编辑器尽可能有效地使用屏幕空间，但当有好几个窗口同时显示时，空间常常显得很紧张。为了使可用空间尽可能大，选择 Vie w（查看）菜单下的 Full Screen （全屏）命令（如图 3-3 ），或者按 Ctrl+V ，就可使标题栏、菜单、工具栏都消失，以便最大限度地腾出空间。如果要返回正常显示，只需按 Esc ，或单击浮动的 Full Screen （全屏）工具栏即可。在满屏状态下，由于菜单栏消失，不能再用鼠标来单击下拉菜单。如果要使用下拉菜单，可先按 A lt，再按所需菜单的首字母即可。例如，先按 A lt，再按 F ，就可激活 File （文件）菜单，再按左、右箭头键，可激活相邻的菜单（在这里，按 A lt 起激活菜单栏的作用，因此两个键不必同时按下）。

如果 Full Scree n（全屏）工具栏令你感到眼花缭乱，单击此工具栏上的关闭按钮，就可移走它。不过这样的话，将只能通过按 Esc 键来返回正常显示。如要恢复该工具栏，按 A lt+T 显示 Tools （工具）菜单，再单击 Custmize （自定义）命令，在 Custmize （自定义）对话框内的 Toolbar（工具栏）选项卡下选中工具栏列表中的 Full Screen （全屏）。以同样的方法，也可以在满屏状态下显示其他工具栏或菜单栏。

W indow （窗口）菜单提供了一个文档列表，其中包含所有的 Visual C++ 编辑器打开的文件。例如，图 3-3 中的文档表就包含了一个文本文件 Test.CPP 和一个图表编辑器下的图片文件 Dimo.bm p。可以通过拉下 W indow （窗口）菜单，再单击想处理的文档名，来实现各个文档间的切换。如果想同时将所有的文档都显示在屏幕上，可选择 Cascad e（层叠）、Tile Horizontall y（水平平铺）或 Tile Vertically

（垂直平铺）命令（如图 3-3 ）。

致谢 - 图47

图 3-3 View （查看）和 Window （窗口）菜单

文本编辑器的文档窗口允许多窗格显示，可以将同一文档的一个、两个或四个不同部分同时显示在窗口上。图 3-4 就是同一文档的四窗格显示的例子。

致谢 - 图48

图 3-4 典型的文档窗口分为四个窗格

由于 Visual C++ 使用 MFC 的 CSplitterWnd 类创建每一个文本窗口，所以，当创建或打开一个文档时，多窗格功能自动生效。窗格分隔条最初显示为两个按钮，一个位于垂直滚动条的顶端，另一个位于水平滚动条的最左端。要想设定某个窗格分隔条的位置，只需拖动该窗格分隔条到所需位置再释放即可。也可以通过选择 Window （窗口）菜单下的 Split（分隔）命令，来一次设定两个窗格分隔条的位置。 Split（分隔）命令设定了两个窗格分隔条所决定的分割线在编辑窗口中交

点的位置，移动鼠标，将此交点移到所需位置上，再单击，即可将两个窗格分隔条同时设定。

由于各窗格没有自己的滚动条，因此，最有效的方法是将显示窗口划分为一上一下两个窗格。要想做此划分，只需要将垂直分隔条（即位于水平滚动条上的分隔条）移到最左端或最右端，直到其消失为止。通过单击窗格或按 F6 ，可从一个窗格切换到另一窗格。

上面的两窗格显示对于上下划分的文档非常方便，但由于各窗格不能独立滚动，因此对于左右划分的文档就不大有效了。幸运的是， W indow （窗口）菜单提供了另一个命令，它可以垂直视图的方式显示将一个文档分成两个或多个窗格。在文本编辑器只打开一个文档的情况下，单击 New Window （新窗口）命令，就会打开另一个包含同一文档的显示窗口。这并不是重新打开文件，而不过是在编辑器的工作空间中提供了原文档的第二个视图。这两个视图各有其滚动条及闪烁光标，所以可以同时浏览文档的不同部分。此时，再单击 Window （窗口）菜单下的 Tile Vertically（垂直平铺）命令，就可使两个浏览器实现左右显示。通过单击某个窗口，或按 F6 键，可实现视图之间的切换。

也可以通过 New Window （新窗口）命令再增加视图。不过，尽管各视图之间相互独立，但它们都只能显示同一文档的内容，因此，在一个视图中对文档做的任何修改，都会立即显示在其他视图中。

保存文档

当开始在一个文档窗口中输入文本时，一个“ * ” 符号会显示在标题栏和 W indow

（窗口）菜单下已打开文档表中的文档名后。这表明此时该文档已被改变，它和原文件已不相同。与文字处理器不同的是，Visual C++ 文本编辑器不能自动存盘，因此，在输入源代码时，一定要养成定时存盘的习惯。存盘可用以下方法：

单击标准工具栏上的 Save 按钮。

致谢 - 图49

按 Ctrl+S 。
选择 File （文件）菜单下的 Save （保存）命令。

保存文件时，文件名后的 “ * ” 符号将消失。当再次改变文本时，它又将出现。当 “ * ” 符号存在时，编辑器会提示先存盘。

定时存盘主要是针对长时间编辑一个文档的场合。在这种情况下，在处理文档时，偶尔问一下自己，“ 如果突然停电，我会不会因没存盘而很后悔？ ”。如果答案是肯定的，就请按 Ctrl+S。如果只是对源文件作一些小改动，再重新编译它，那么存盘就不那么重要了，因为在重新编译之前，系统会自动保存文档。

第一次保存一个未命名的文档时，会出现 Save as （另存为）对话框，在这个对话框里，你可给出文件名及其扩展名。请将扩展名定为 CPP 或 C ，因为文本编辑器只能通过扩展名判断文件内容，再依内容将其按 C++ 或 C 程序编译。如果不给出扩展名， Visual C++ 将自动设一个与在 New （新建）对话框（图 3-1 ）中选择的文件类型相近的扩展名。例如，如果从此对话框中选择 C++ Source File

（ C++ 源文件），则新文件名的扩展名将为 CPP 。

许多程序员常将 C++ 头文件的后缀名置为 HPP ，在使用 Visual C++ 时，这会带来一点小麻烦。当选择 Open （打开）命令时，对话框中通常只显示以 C 、 CPP 、C X X 、TL I、H 、TLH 、INL 、RC 等为扩展名的文件。要想打开一个扩展名为 HPP 的文件，必须将对话框下部的文件类型改为 C++ Include File（ C++ 包括文件）或A ll Files（所有文件）。除此之外，使用 HPP 作为头文件的扩展名再不会有别的麻烦。实际上，对于头文件可以使用任何扩展名，因为在创建项目时，Visual C++ 只根据“ #include” 语句来搜索源文件。无论扩展名是什么，只要被 #include 语句

包含，它就会自动加入到项目中，并显示在 Workspace （工作空间）窗口中的

FileView （文件视图）选项卡下的头文件表中。

当保存一个新文档，并给定其文件名时，这个文件名就代替系统默认的文件名，并显示在标题栏和 W indow （窗口）菜单下。从此，当再保存此文件时，系统将自动覆盖前一个版本，并不再显示 Save as （另存为）对话框。而且，系统也不会以任何形式保存前一个版本。因此，一旦保存了一个文档，则它从前的版本将不复存在。如果源文件需要多个版本，则必须通过 File（文件）菜单下的 Save as

（另存为）命令来给不同版本赋予不同名称。

打印文档

要打印一个正在编辑的文档，只需单击 Fil e（文件）菜单下的 Prin t（打印）命令，或按 Ctrl+P ，来打开 Prin t（打印）对话框。如果只想打印该文档中的一部分，先选择要打印的部分，再启用 Prin t（打印）对话框中的 Selectio n（选择）单选按钮

（如图 3-5 ）。

致谢 - 图50

图 3-5 Prin t（打印）对话框

Selectio n（选择）单选按钮设定系统只打印用户选中的部分。如要取消它 ,只需单击图中的 All( 所有 ) 单选按钮即可。

上图所示的对话框也给出了 W indows 将使用的打印机。如要选择其他打印机，单击 Printer（打印机）下拉框，并从其列表中选择打印机类型。再单击 O K （确定）就可开始打印。使用后台打印时，系统会立即返回文本编辑器，使你可以继续工作。尽管控制打印过程时需要浏览 Print 文件夹，但还是可以迅速打印数个

文档。单击任务栏中的 Sta r（t 启动）按钮，再选择 Settin g（设置），然后单击 Printers

（打印机），选定打印机后再单击 File （文件）菜单下的 Open （打开）命令，就可看到当前正在打印的文件列表。

当使用后台打印时，取消某个打印任务会稍微麻烦一些。一旦后台打印开始进行， Cance l（取消）按钮将从屏幕上消失，因此，只能通过 Printer 文件夹来取消打印任务。另外，如果后台打印不能用，那么，文本编辑器只能等待打印完成后才能被用户使用。

Visual C++ 文本编辑器为其打印的文本提供了有限格式，可以设置页边距，并指定每页的页眉和页脚。从 File（文件）菜单下选择 Page Setu p（页面设置）命令，在 Page Setup（页面设置）对话框下将所要的页眉和页脚文本分别输入到对应的文本框中。可使用表 3-1 中的代码在页眉和页脚文本中加入某些实时信息。

	表 3-1 在页眉	和页脚中添加信息的打印代码
代码		意义
& F		文件名称
& P &T		当前页数系统时间
& D &L		系统日期页眉和页脚与文本左边缘对齐
& C		页眉和页脚与文本中心对齐
& R		页眉和页脚与文本右边缘对齐

这些代码并不需要去记，只需单击 Page Setup（页面设置）对话框中文本框旁边的箭头，即可显示格式选项列表。单击其中某选项，就可将它插入到页眉或页脚中。打印代码就在此列表的最上端或最下端。

可将打印代码与正常文本以任意方式组合。例如，一个指明文件名称和打印日期的页眉可做如下安排：

&RFile: &F; Date: &Dpage & p

这里，& R 代码使得页眉与右边缘对齐，这和字处理器中的右对齐是一样的。 & P 代码打印页数，从 “ 1 ” 开始。这里的页数与打印作业相关，而不是与原文档相关。也就是说，如果选择文档的中间部分打印， & p 代码仍将被打印的第一页的页数定为 “ 1 ”。 Visual C++ 中没有代码可显示总页数，也就是说，不可能以类似于“ Page 1 of 20 ” 的形式来显示页数。另外，由于页眉和页脚中的打印代码在整个打印过程中都起作用，因此，不存在那种可交替使用左对齐与右对齐，以便设定奇数页为 “ &R " ，而偶数页为 “ &L" 的选项。

页眉和页脚中每行不能超过 40 个字符。每个打印代码算两个字符。 Tab 键不允许使用。

浏览文档

当然，通过按上下左、右箭头键或拉动滚动条，可以浏览文档。可是，在下面将可以看到，通过一些其他办法可更方便、更有效地浏览文档。在此之前，先让我们统一一些术语。在 DOS 模式文本编辑器中很熟悉的光标，在 Windows 中有不

同的名称。Windows 把闪烁光标称为提示符，因为它的功能与用来表示可输入新文本的 ^ 符号相似。光标一词在 W indows 中仍被保留，它被用来指代表示鼠标位置的箭头（或其他标志）。 Visual C++ 的在线帮助称插入符为 “ 插入点 ”，作为一个 W indows 程序员，应该知道光标与提示符之间的区别。这样，当进入 API 函数（例如 ShowCaret 和 SetCaretPos ）时，就不会感到迷惑了。

在文本编辑器中移动提示符的快捷键，对于任何一个使用过 W indows 字处理器的用户来说，都是很熟悉的。表 3-2 列出了主要的提示符移动快捷键。

表 3-2 文本编辑器插入符移动键

敲键插入符移动

左箭头，右箭头向前或向后移动一个字符。如果提示符在最左

端，则左移将移到前一行的末尾；如果提示符在右端，则右移将移到下一行的开头

上箭头，下箭头向上或向下一行。如果目标行比当前行短，则移

动后提示符的位置取决于提示符现在的具体位置

Ctrl+ 左箭头， Ctrl+

右箭头

向前或向后移动一个单词。 Visual C++ 编辑器将很多标点符号按独立单词对待。例如，必须按 7 次 Ctrl+ 右箭头，才能移过 “ CAN'T/WON'T ”

Hom e， End 移到一行的开头或末尾

Ctrl+Home ，

Ctrl+End

移到文档的开头或末尾

续表

Page U p ，Page Down 按照窗口中显示的行数来上下滚动文档。这里，

编辑器将重叠滚动一行，也就是说，当按下PageDown 键时，当前屏幕最底部的一行将变成下一屏的最顶行。这个滚动间距是不能改变的

在空白区内移动

当把插入符移到一行的末尾时，文本编辑器下面再怎样动作没有一个统一的规则。有些编辑器将不进行任何操作。另有一些编辑器将文本看作连续的流，当在行尾按右箭头键时，插入符会移到下一行的开头。如果长时间右箭头键不放，甚至可将插入符一直移到文档末尾。还有一些编辑器允许插入符继续向右进入空白区。这种方式的好处是，它使屏幕就像一页纸，你可以任意移动插入符，并可在任何地方输入。但同时它也有一些缺点。

想一想，当插入符位于下例中第一行的末尾时，想将它移到下一行，会出现什么情况：

b = SendMessgae( hwnd ， MY_MESSAGE ， wParam ， 1Param); b *=2;

如果没有空白区，按右箭头键就可很快移到第二行开头，按向下箭头键，可移到第二行的结尾。而对于有空白区的编辑器，则需要按两次键。必须先按向下箭头键，再按 End 或 Home 键。然而，在另一方面，有空白区的编辑器又可以很方便地给第二行加一个注释。只需把插入符向下移动到空白区即可：

b =SendMessage (hwnd, MY_MESSAGE, WParam, 1Param); b*=2; // Double it

顺便说一下， Visual C++ 之外的编辑器大都将文档看作文本流。这样，在文档中

就不能留有间隙。在原文档与在空白区加入的文档之间的间隙中， Visual C++ 编辑器用尽可能多的 TAB 键和空格键填充。

上面两种体系都有其麻烦之处。为了使操作方便， Visual C++ 文本编辑器将选择权交给了你，可按以下步骤将空白区设置改为自己所喜好的类型：

选 Tools（工具）菜单下 Options（选项）命令。
单击 Compatibility （兼容性）选项卡。
设置或清除 Enable Virtual Space （启用空白区）文本框中

的值。

括号匹配

Visual C++ 文本编辑器可识别包围 C/C++ 源代码块的括号对，这样，只按一次键，就可将插入符由一个括号处移到与此括号相对应的括号处。编辑器可区别三种不同类型的括号：小括号（），大括号 {} ，方括号 []。

括号通常成对使用，用于源代码块的两端。每一对括号建立一个层次，并可能包含若干个次级层。下例就是一个用大括号来分层次的典型例子：

if (msg=WM_USER)

{ //Begin level A

for(i=0;i<5;i++)

{ //Begin level B

} //End level B

} //End level A

当光标在任何一个括号旁边时，按 Ctrl+ ]可将插入符移到与之对应的另一个括号处。按 Shift+Ctrl+ ]可选定两括号间所有文本。

C 和 C++ 中的小括号用来含纳不同的代码元素。然而，被小括号定义的层次不依赖于语句类型，而依赖于这些层次在文档中的角色。下面这个例子就举出了 A 、B 、 C 三个层次的例子：

致谢 - 图51

这里，最里面的两对括号层次相同，都是 C 层，并且都包含在 A 层与 B 层内。当插入符位于第一个括号旁时，由于它代表 A 层的开始，因此，按 Ctrl+ ]，可将插入符移到代表 A 层结尾的最后一个括号处。

编辑器通过使用一个小程序计算源代码中括号的个数，从而确定每个括号属于那一层。任何一个完整层次中左右括号个数必须相等，否则就说明有错误。在把插入符从第一个括号处移到 A 层末尾的过程中，编辑器向前搜索匹配括号，并启动记数器。每发现一个左括号计数器加一，每发现一个右括号计数器减一，直到

编辑器发现层尾的括号时计数器又变为 0 ，于是，编辑器移动插入符到此括号处。

编辑器也把 #if ， #ifdef， #else ， #elif 和 #endif 这些条件编辑指令按括号对待，不过，相应的操作键是不同的。当插入符位于某个条件指令旁边时，按 Ctrl+J 可将它移到下一个指令旁。如果同时按下 Shift 键，则会在移动的同时选中这一区间的文本。

书签

文本编辑器的书签可以记忆一个位置，这样，无论在文档的任何位置，都可以迅速返回书签所在位置。如果以前是利用 Go To 命令来跳到想浏览的位置，那么，现在一定会发现书签的好处。 Go To 命令是以行数为目标的，若在文档的某些地方增加或删减了若干行，则其后的每一行都将向后或向前偏离其原始位置。因此，当有行加入或删除时， GoTo 命令不能准确到达想去的位置。而书签就方便多了，你不必去记行数，书签会自动保留在所在行，并随文档的增减而改变位置。Visual C++ 文本编辑器提供了两种类型的书签：有名书签和无名书签。

有名书签

个命名的书签将会长久留在文档中，直到删掉它为止
。它在文本中标志了一个精确的位置。实际上，当一个有书签的文档没有打开时，也可以从另一个已打开的文档中直接跳到该文档中。这里，编辑器自动打开该文档，并将插入符置于书

签所在的位置。

要创建一个有名书签，先将插入符置于所想标志的位置，再单击 Edi t（编辑）菜单下的 Bookmarks （书签）命令，此时就会看到 Bookmark （书签）对话框。输入给此书签所起的名字，再单击 Ad d（添加）按钮，就可将此书签加入到列表中。当关闭对话框后，此新书签就开始起作用了。有两种方式可返回书签处：直接方式和间接方式。如果文档中的书签不很多时，用间接方式是最方便的。只需按F2 就可跳到下一个书签处，按 Shift+F2 可跳到前一个书签处。单击 Edit（编辑）工

具栏中的 Next Bookmark （下一个书签）按钮，也会得到同样的结果，如下图所示：

致谢 - 图52

通过直接方式移动插入符到书签处，需要再次访问 Boodmark （书签）对话框。双击书签名，或选择目标书签，再单击 GoT o（转到）按钮即可。也可以通过 Edit

（编辑）菜单下的 GoTo （转到）命令来跳到某个有名书签处。

具体来说，有名书签是一个 32 位量，用以记录文本中一个特定位置。当在书签前的文本中添加或删除一个字节时，这个量会相应增加或减小。这样，书签就会继续指向其目标，文本怎样变更都不会影响它。与字处理器不同的是，关闭文档后， Visual C++ 编辑器不将有名书签保留在文档中，因为额外字符会使编辑器产生混乱。

无名书签

通常，上面使用书签的方式似乎有些大材小用。当想定义这样一个书签时，它标

志源代码的一处地方，在编辑文档的其他部分时，只想返回这个地方一两次，然后它就没用了，在这种情况下，有名书签就不是很方便了。此时，为方便起见，可使用一个无名书签。无名书签是暂时的，当取消它或关闭文档后，它就消失了。而且，无名书签只标志一行，而不是一个精确位置。当插入符跳到一个无名书签处时，插入符自动置于该行开头。如果删除被标志的行，则书签也将被删除。

无名书签的好处是，它易于设置，删除更简便。要使用一个无名书签，只需将插入符置于该行，按 Ctrl+F2 ，或单击标有旗帜的按钮（如图示）即可。

致谢 - 图53

如果页边选择（本章后面部分将会描述）被激活，那么，一个小盒子图标就会显示在被标志行左边的页边处。否则，编辑器将以不同颜色来显示整个被标志行。

可通过单击工具栏按钮，或按 F2/Shift+F2 ，来移动插入符到无名书签处。每按一

次，插入符将向前或向后移到下一个书签处，无论该书签是有名书签，还是无名书签。

有以下几种方法可删除无名书签：

将插入符移到此行，再按 Ctrl+F2 即可删除此书签。
按 Shift+Ctrl+F2 。这将删除所有无名书签。
不去理它。当文档关闭后，无名书签将自动消失。

文本搜索

Visual C++ 编辑器提供了三种文本搜索类型。可以：

在已打开的文档中搜索文本。
在已打开的文档中替换文本。
在磁盘文件中搜索文本。

前两种类型在文本编辑器中是很普通的，而在磁盘文件中搜索文本，则是一个不常见但却极有用的类型，它可显示出包含一个特定词或短语的所有文件。以下我

们将详细说明这三个类型。

在打开的文档中搜索文本

像大多数文本编辑器一样， Visual C++ 编辑器能够扫描文档，并找出给定单词或短语（我们称之为目标字符串）的位置。有两种方法可设定目标字符串的内容。最方便的方法是使用标准工具栏中的下拉框，如下图示：

致谢 - 图54

在下拉框中输入字符串，或者单击框旁的箭头按钮，再从列表中选择以前输入的字符串。按 Enter 键开始搜索。当编辑器找到该字符串后，它将其高亮显示，并将插入符置于此高亮字符串的首字符旁。只要组合框允许，按 Enter 键就可继续按下一个已给出的目标字符串搜索。按 Esc 键，或单击文档窗口的任何部分，就可返回编辑模式。再按 F3 或 Shift+F3 ，就可继续向后或向前继续搜索。Visual C++ 提供了这些命令的工具按钮，不过需要你自己将它们加到工具栏中。本章后面的“ 为命令创建工具栏按钮 ” 一节将说明怎样添加工具按钮。下面是它们被加到工具栏中后的样子：

致谢 - 图55

第二种设定目标字符串的方法需要 Fin d（查找）对话框。虽然这种方法不如第一种直接，但它提供了更多的选择。例如，如果想搜索的字符串碰巧在屏幕中，可以直接借用它，而不必再输入它。如果目标字符串只是一个单词，只需通过单击这个单词或将插入符置于这个单词上；否则，可通过拖动鼠标光标来选中所需文本。接下来，通过按 Ctrl+F ，或选择 Edit （编辑）菜单下的 Find （查找）命令，来打开 Fin d（查找）对话框。当对话框显示出来的时候，所选中的文本已经在对话框中了。

可通过设定是否区别大小写，或是否整词匹配，来使搜索更为精确。单击 M atch Cas e（区别大小写）复选框，将设定一个区别大小写的搜索。在这个搜索过程中，编辑器只找出与目标串完全相同的字符串。例如，对于目标串 “ abc ”，区分大小写的搜索只找出“ abc ”，而不区分大小写的搜索则会找出“ abc ”、“ ABC ”、“ Abc ”

等等。单击 Match Whole Word Only （整词匹配）复选框，可忽略包含于另一单词之中的目标串。例如，对于目标串“ any ”，在整词匹配搜索中，编辑器只找出以完整单词形式出现的 “ any ”，而忽略掉类似“ company ”、“ many ”、“ anywhere ” 之类的单词。

在 Fin d（查找）对话框中，单击 Mark Al l（标记所有的）按钮，就可在每一个搜索到的目标处设置一个无名书签。当继续使用 Find 命令搜索其他目标时，这种设置能够回到前面的目标处。

Visual C++ 编辑器中一个有用的变化是，有一个叫 Incremental Searc h（增量搜索）的命令，它使得搜索工作在输入目标串的同时就开始进行。在一个打开的文档中按 Ctrl+ I，则 “ Incremental Search :” 就会立即出现在屏幕左下角的状态栏中。在输入目标串的同时，编辑器就开始搜索，通常不等输完，搜索就已完成。当编辑器找到正在寻找的字符串时，按 Enter 键，或一个方向键就可回到编辑模式。如要再次搜索同样的目标串，按 F3 或单击适当的工具按钮即可。按 Shift+Ctrl+I 键可改变搜索方向，以使编辑器从插入符所在位置向前搜索。

在已打开的文档中替换文本

如果想替换文档中的某些字符串，可选择 Edi t（编辑）命令下的 Replac e（替换）命令。这个命令将给出一个类似于 Fin d（查找）对话框的对话框，只不过这个对话框有两个文本框，需要两个字符串。第一个文本框中放置普通的目标字符串。

第二个文本框中则要放置要用来替换的新字符串。如果将第二个文本框置空，则编辑器将把找到的所有目标串删除。为了有选择地搜索或替换，当编辑器找到目标串时，单击 Replac e（替换）按钮，系统将自动跳到下一个目标串处。单击 Find

Nex t（查找下一个）按钮，系统将跳过这个字符串，而不改变它。单击 Replace All

（全部替换）按钮，将会一次性完成所有替换。可以只向前，或只向后搜索或替换，但不能在多个文件中搜索或替换。

如果在激活 Replac e（替换）对话框之前，已选中了超过一行的文本，则 Selection

（选择）单选钮将自动打开，这表明编辑器将把搜索或替换操作限制在所选章节之中。单击 Whole File （整个文件）单选钮，将取消这一设置。虽然可通过在按下 Alt 键的同时向右下方拖动鼠标光标来选中一列字符串，但通常情况下，不能进行列的替换。如果选中一列字符串， Selection（选择）单选钮将不会打开。不过，有一个宏操作可克服这一困难，在第 13 章中举出了一个可对列进行搜索或替换的宏操作的例子。

在磁盘文件中搜索文本

UNIX 系统的用户都知道这一功能。给出一个目标字符串， Visual C++ 文本编辑器能找出某个文件夹下所有包含目标串的文件，包括位于子文件夹内的文件。单

击 Edit（编辑）菜单下的 Find In Files （在文件中查找）命令，可打开如图 3-6 所示的对话框。这个对话框需要指定目标串、文件类型以及搜索过程所在的文件夹。

致谢 - 图56

图 3-6 Find In Files 对话框，用于搜索磁盘文件

通常，默认文件夹是当前软件所在的文件夹；如果想搜索其他文件夹，在 In Folder

（文件夹中）框中，输入其路径，或单击框旁的有三个点的按钮，来寻找所需文件夹。 Look In Subfolders （在子文件夹中查找）复选框决定编辑器是否在子文件夹中进行搜索。通常其默认值为打开。单击 Advanced （高级）按钮，可设定除子文件夹之外的其他文件夹，搜索也将在这些文件夹中进行。

在第 1 章中我们已看到， Find In File s（在文件中查找）命令通常将其找到的文件

在 Outpu t（输出）窗口中的 Find In Files 1 选项卡下列出（参看图 1-7 ）。如要将其在 Find In Files 2 选项卡下列出，只需激活 Output To Pane 2 （输出到窗格 2 ）复选框，如图 3-6 所示。这个选项可同时显示两个独立的文件列表，这样，当前搜索的结果不会覆盖前一次搜索的结果。

如果已经设置好各项，单击 Fin d（查找）按钮。当 Visual C++ 找到一个包含所给出的目标串的文件时，它把其文件名和路径列在 Outpu t（输出）窗口中，同时还列出此文件中第一个目标串所在行，这便可以看到目标串在文件中是怎么用的。双击某个文件，可在文本编辑器中打开它。

在进行文件搜索之前， Visual C++ 首先保存任何在文本编辑器中打开而未保存的文档，这将确保所搜索的文件都是最新版本的。可通过调整 Option s（选项）对话框中 Edito r（编辑器）选项卡下的两个标有 “ Save Before Running Tools（在运行工具之前保存）”和“ Prompt Before Saving File s（在保存文件之前提示）”的复选框来改变这一属性。关闭“ Save Before Running Tools ”复选框，将使 Visual C++ 在搜索前不保存文档，这样就使搜索在上次保存的文档中进行。如果希望在激活Find In File s（在文件中查找）命令之前，由自己决定是否保存文档，则关闭这两个选项。这将使编辑器在保存每个文档前先征求你的意见。

常规表达式搜索

迄今为止，我们见到的搜索对话框中，都包含一个标有 Regular Expressio n（常规

表达式）的复选框。常规表达式是指有一个或多个特殊字符组成，用以表示一系列文本的字符或字符串。在 Open （打开）和 Save as（另存为）对话框中，我们已有过类似的使用，例如，“ *.CPP ” 表示以 CPP 为扩展名的任何文件。这里的星号就是一个常规表达式，它代表可组成有效文件的任何文本。

搜索中的目标字符串中所用的常规表达式则更为复杂，这样可以更为精确地控制目标字符串。表 3-3 列出了系统默认的常规表达式。注意，只有当搜索对话框中的 Regular Expressio n（常规表达式）复选框打开时，编辑器才把这些字符按常规表达式处理，否则，将把它们当作一般字符处理。

表	3-3	常规表达式字符
符号	含义	示例
。	任何单个字符	" ..do " 可以同	redo 和	undo 匹

配，但不能同 outdo 匹配

[] 任意字符或括号内的字符 " sl[aou]g " 可以同 slag ，slog 和

slug 匹配

[^] 插入符后所示范围之外的任何字符

"sl[^r-z]g"包含 slag ， slog ，但不含 slug

没有或有更多的前一个字符 "re*d" 包含 rd ， red ， reed

+ 一个或多个前一个字符 "re+d" 包含 red ， reed ，但不含

^ 一行的开头 "^word" 只包含位于行首的

word

续表

$	一行的结尾	"word$" 只包含位于行尾的
		word
\	下一个字符不是常规表达式	"word\$" 只与 word$ 匹配，而不把 $ 看作常规表达式

不必去记这张表。在所有的 Fin d（查找）对话框中，都通过组合框旁的一个小按钮来给出表 3-3 的当前版本。单击此按钮，打开常规表达式菜单，然后就可以选择所需的常规表达式了。

用加号可设计一个字符串。例如，考虑常规表达式 [a-zA-Z ]，它代表任何一个字母。如果再增加一个加号，意义就完全变了。加号的意义是“ 一个或多个这些字符 ”。因此，编辑器将 [a-zA-Z]+ 看作为任意字符串，也就是任意一个单词。同样，常规表达式 [0-9] 代表一个数字，而 [0-9]+ 则代表任意一个正数，无论其大小。

常规表达式搜索通常是区别大小写的。即使关闭 Fin d（查找）对话框中的 M atch Case 复选框，对常规表达式 [0-9a-f]+ 的搜索也只能找到类似于 0x37ac 的字符串，而不能找到 0x7A4B 。为了找到后者，必须将大写字母包含在常规表达式中，例如 :[0-9a-fA-F]+ 。

编程辅助工具

在 Winsows 和 MFC 下编程，即使是最有经验的程序员，也不得不经常翻阅大量的参考资料，或浏览在线资料。我们还不得不花大量时间，去记住一些编程所必须的信息，例如参数表、函数或变量的拼写等。现在， Visual C++ 文本编辑器的一些特性将使程序员省去了这些麻烦。本章将介绍这其中最有用的一个工具：一种称作 Statement Completion （语句补全）的输入辅助工具。

Statement Completio n（语句补全）是三个编程工具的总称，它们是：成员表（ List M embers ），参数信息（ Parameter Info ），输入信息（ Type Info ）。这三个工具就如同是手边随时可用的 W in32 和 MFC 的参考资料。

成员表

为了提高代码输入速度，并最大限度的减少输入错误， Visual C++ 编辑器的成员表可任随时调用。通过一个弹出式窗口，成员表给出了一个巨大的列表，其中包括 MFC 类成员、 C 运行函数、显示常量、结构名称、 W in32 API 函数、当前程序的类成员。可在这个列表找出要输入的单词，从而完成输入。当输入域运算符

（ ::）、成员运算符（ .）、指针运算符（ -> ）时，成员表会自动弹出到屏幕上。此时，当继续输入一个成员名时，这个弹出式窗口的选择条会自动移到与输入最匹配的成员名上。图 3-7 说明了在函数 CDC::SetMapMode 下，成员表是如何在完

成输入之前找到匹配名的。

致谢 - 图57

图 3-7 在文本编辑器中显示的 List Member （成员表）

当输入一个无字符码（如空格或 semicolon ）时，系统就将高亮显示的成员名插入到文档中。这个过程听起来挺复杂，但实际过程要简单得多，因为源代码中每一个成员名后都几乎总是跟着一个标志：函数名后跟一个左括号，变量名后跟一

个等号或分号。例如，在图 3-7 右图中，输入一个左括号会产生如下结果：

//Set coordinate system pDC->SetMapMode(

这里，成员表消失，高亮显示的 SetMapMode 被插入到插入符所在处，并在其后

加一小括号，从而为继续输入参数做好准备。在下一节我们会看到， Statement Completion（语句补全）并没有到此为止，而是又激活了 Parameter Info（参数信息 ) 工具来帮你继续完成参数输入。当成员表消失后，这个逻辑工具就自动取代了它的位置。

按 Tab 键或 Ctrl+Enter 键，可在不增添字符的情况下完成单词输入，并使成员表消失。按 Ctrl+Alt+T 键，可在任何时刻激活成员表窗口。编辑器总是以插入符左侧的文本为线索来定位选择条。例如，在键入 cv 后激活成员表，此时将显示成员表窗口，并将选择条定位在 CView 处：

致谢 - 图58

这里输入的字符 cv 与高亮显示的名称 CView 大小写不同。不过，成员表在定位工具栏时忽略大小写，因此，可以全部用小写输入，只是最后需要按 Tab 或回车

来确认一下。这个特点有助于输入一些难以记忆的组合函数，如

UnmapViewOfFile 和 UnMapAndLoad 等。

尽管通过按组合快捷键很容易显示成员表窗口，但如果乐意，还可以通过 Edit

（编辑）菜单，或在文档窗口内双击右箭头键，激活上下文菜单来打开成员表。成员表窗口中只包括那些在当前类或对象下有效的符号名。例如，当输入一个从CDialog 继承来的目标时，成员表中将包括 PrevDlgCtrl 函数，因为这个函数属于这个类。而当输入一个从 CString 继承来的类时，这个函数将不存在于列表中。

在 Edit （编辑）菜单下还有一个叫 Complete Word （补全词）的命令，它看似Statement Completio n（语句补全）的另一个工具，其实不过是成员表的一种简短方式。如果不想通过按 Ctrl+Alt+T 来激活 List Members（成员表）命令，可通过按 Ctrl+Space 来激活 Complete Word 命令。通常情况下，这两种方法会有同样的结果，都显示成员表窗口，并将选择条置于与正输入的文本最匹配的成员名上。不过，当与所输入的文本最匹配的成员名只有一个时，仍显示成员表就显得多余了。在这种情况下，按 Ctrl+Space 将不显示成员表，而直接完成操作。例如，在输入 CreateMul 后按 Ctrl+Spacebar，就可一步完成输入，因为它可以明确判定想输入的是 CreateMultiProfileTransform ，而不是 CreateMutex 或其他。

参数信息

参数信息包含函数的各个参数，当在函数后输入第一个括号时，参数信息将以一

个工具栏式窗口的形式弹到屏幕上。这种工具栏式窗口像一个屏幕提示，显示出函数原型 , 并要求输入参数。如下例：

致谢 - 图59

输入参数时，函数原型一直显示在屏幕上，当输入最后的右括号时，此窗口消失。如果这个函数是过载的，可接受多组参数，则参数信息窗口将显示一个函数原型，并在窗口左端给出数字，来说明此函数有多少过载的版本。按 Ctrl+PgU p，或单击参数信息窗口，可在一个函数原型循环到下一个。如下例 :

致谢 - 图60

有一个命令可使得当把插入符放在函数名上时，参数信息窗口会自动显示在屏幕上。可通过 Edit（编辑）菜单或按 Ctrl+Shift+Spacebar 来选择这个命令。也可在文本中用右击一个函数名，来打开上下文菜单，再从中选择该命令。和其他的Visual C++ 命令一样，也可以设置一个快捷键来激活参数信息工具。本章后面的“ 未结合命令 ” 一节解释这点。

输入信息

输入信息和参数信息类似，也以工具提示窗口出现，它包含有关函数和变量的信息。当系统认出鼠标光标处的符号时，输入信息窗口将自动显示出来，当把光标移开时，该窗口将自动消失。可通过 Edi t（编辑）菜单、上下文菜单或按 Ctrl+T ，来调用输入信息功能。如果想了解刚输入的，或刚从成员表中粘贴过来的代码信息，那么，最后一种方法是很方便的。当插入符位于一个函数名上时，输入信息窗口和参数信息窗口所提供的信息是一样的，都列出函数的原型。当调用一个定义的类型时，窗口中显示创建别名时的 typedef 语句：

致谢 - 图61

当需要显示某个变量的信息时，输入信息就显得很有用。它给出了变量的说明，使得不再需要查询源代码或类的头文件来确定该变量类型。例如，如果变量indicators 的类型不清楚，使用输入信息窗口，就会立即看到它是一个整数数组变量，如下图：

致谢 - 图62

输入信息窗口以及其他类似的弹出式窗口也许会使你感到眼花缭乱。如果这样，单击 Tools（工具）菜单下的 Options（选项）命令，再清除对话框中 Editor（编辑器）选项卡下的相应复选框即可（参看图 3-11 ）。通过相应的快捷键或菜单命令，可再次激活这些工具。

Advanced （高级）命令

Edit（编辑）菜单底部附近的 Advanced（高级）命令提供了一个选项集合，它们在进行文本文档工作时会非常有用。让光标在 Advanced （高级）命令上停留一会儿 ,会显示如下所示的子菜单。

致谢 - 图63

正如你所看到的那样，菜单提供了对前述 Incremental Searc h（增量搜索）命令的访问，尽管按 Ctrl+I 是访问该命令的更为方便的办法。 Format Selectio n（格式选择）命令通过插入制表符，来设置花括号内的 C/C++ 代码的缩进。这个命令把下面的代码：

if(msg=WM_USER)

{

for(i=0;i<5;i++)

{

//Additional code

}

变成：

if(msg= WM_USER)

{

for(i=0;i<5;i++)

{

//Additional code

}

Format Selectio n（选择）命令通过扫描为花括号选择的文本来决定嵌套层次。第一层的文本行缩进一个制表符，第二层的文本行缩进两个制表符，依此类推。

Tabify Selection （制表符选择）命令把选中的一系列空格转换成等量的制表符。Untabify Selection （取消制表符选择）则把这个操作反过来。通过打开 View Whitespace（查看工作空间）双态开关，可清楚地看到两个命令的效果，这时文档中的空格和制表符都变成可见的。当该开关打开时，文本中的空格字符显示为小圆点 (.) ，而制表符显示为书名号 (>> )。

子菜单中剩下的两个命令的作用就像它们的名字所表示的那样。 M ake Selection Uppercase（使选择内容成为大写）命令使选中的所有字母都变成大写，而 Make Selection Lowercase （使选择内容成为小写）命令则恰恰相反。选择中的非字母字符，如数字和标点符号，则不受这两个命令的影响。

未结合命令

每个 Visual C++ 命令都有一个描述性的内部名称。例如，刚刚说过的 Incremental Searc h（增量搜索）和 Tabif y（转换制表符）命令的内部名称为 SearchIncremental 、SelectionTabify 和 SelectionUntabify 。在线帮助提到了许多你在菜单中找不到的其他命令，例如名为 GoT o（转到）NextErrorTag ，LineTranspose 和 LineDeleteTo Start 的命令。有两个原因来解释为什么帮助系统宁愿用内部名称，而不用组合键，如

F4 或 Shift+Alt+T 来标识命令。首先，你可以把命令的组合键改成你喜欢的任意键。其次，许多命令还没有指派快捷键。这样的命令称为 “ 未结合的 ”。要使用一个未结合命令，你必须首先给它指定一个组合键。

在 Developer Studio 环境下，隐藏着一大套命令，除那些出现在菜单和工具栏按钮上的命令之外，还有更多的命令可以使用。在 Hel p（帮助）菜单中单击 Keyboard M ap （敲键映射）来查看命令列表，如图 3-8 所示。

致谢 - 图64

图 3-8 从 Help 菜单中选择 Keyboard Map ，以显示 Visual C++ 的命令列表

在 Help Keyboard（帮助键盘）窗口中出现的默认列表称为“ 结合命令 ”，这意味着，这些命令已经指派了组合键。要查看只属于文本编辑器的结合命令和未结合命令列表，在下拉列表框中选择 Edit（编辑），并在第二栏的上边单击 Command

（命令）按钮，来按命令的字母顺序排列列表。当你滚动列表时，你会在 Keys

（键）栏中看到最常用的命令已经约定了组合键，但许多命令还没有。未结合命令的设置使许多特征变得可用，否则它们就不能通过菜单、工具栏或键盘来访问。

如何访问命令完全取决于你的喜好。 Visual C++ 允许你向菜单或工具栏中添加任

何结合的和未结合命令，这将在第 13 章中详细讨论。但因为拥挤的菜单和工具栏反而容易误事，最好通过给未结合命令定义一个组合键来调用它。唯一的缺点是你必须记住访问命令的快捷键。

没有人会打算一次就启用所有的未结合命令。选择那些你认为最有用的命令，给它们指派最符合你的风格和最容易记忆的组合键。举个例子，让我们给文本编辑器添加两个非常有用的命令： WordUpperCase 和 WordLowerCase ，它们改变当前文本中插入符之下的单词的大小写。默认情况下， WordUpperCase 和WordLowerCase 没有被指派组合键，也没有工具栏按钮或菜单选项来访问它们。除非你给它们指定组合键，没有别的办法来使用这两个命令。

下面是调用命令的方式：从 Tools （工具）菜单中选择 Customize （自定义），来打开 Customiz e（自定义）对话框，然后单击 Keyboar d（键盘）选项卡。从 Category

（分类）下拉列表中选择 Edit（编辑），并确保 Tex t（文本）出现在 Editor 框中。这些设置表示我们正为一个只用于文本编辑器的命令定义一个组合键。在Commands 列表框中出现的命令是按字母顺序排列的。向下滚动列表到底部，找到 WordUpperCase 条目，然后单击它来选中它。对话框的左下角会出现命令的简短说明，但 Current Keys （当前键）列表框中是一片空白，这表示目前没有给WordUpperCase 定义快捷键。要定义一个快捷键，单击 Press New Shortcut Key

（按新的快捷键）文本框，并按下你想用来访问该命令的组合键。如果你按下Ctrl+U ，对话框提示你该组合键目前已指定给 SelectionLowercase 命令。这并不意味着你不能把 Ctrl+U 指定给 WordUpperCase ；它只是提示你，如果你这样做

的话，按 Ctrl+U 将不再调用 SelectionLowercase 命令，它会变成一个未结合命令。因为 Ctrl+U 已经使用了， A lt+U 对 WordUpperCase 来说是一个更好的选择。当你按下 A lt+U 时，对话框告诉你这个快捷键目前没有定义给别的命令（见图 3- 9 ）。单击 Assign （指定）按钮后，快捷键就可以使用了。

致谢 - 图65

图 3-9 对文本编辑器命令指定一个键组合

同样给 WordLowerCase 命令定义快捷键 A lt+L 。当你在 Press New Shortcut Key 文本框中按下 A lt+L 时，系统会提示你这个组合键被用来访问菜单。提示消息提到 Layou t（布局）菜单，它只在对话框编辑器调用时才能使用。因为 Layou t（布局）菜单对文本编辑器没有影响，选择 A lt+L 不会导致快捷键冲突。当文本编辑器调用时， A lt+L 调用 WordLowerCase 命令；当对话框编辑器调用时， A lt+L 像以前一样拉下 Layou t（布局）菜单。

要使用新的 WordUpperCase 和 WordLowerCase 命令，打开一个文本文档，并随便在一个单词上放一个插入符。按下 A lt+U 或 Alt+L 调用命令来改变从插入符到单词末尾的所有字母的大小写。同样地，新的命令会覆盖 SelectionUppercase 和SelectionLowercase 命令，因为它们作用在任何选中的文本块上，而不是在单一的单词上。现在 Selection （选择）命令是多余的了，没有关系。新的 Alt+U 和A lt+L 快捷键比起等同的 Shift+Ctrl+U(SelectionUppercase) 和Ctrl+U(SelectionLowercase) 组合键来更容易使用和记忆。然而这种覆盖只适用于选中的文本，因为当没有选择文本时 SelectionUppercase 和 SelectionLowercase 会影响插入符附近的字符。

为命令创建工具栏按钮

如果你喜欢使用工具栏，并发现自己经常使用诸如 WordUpperCase 和

WordLowerCase 之类没有预定义工具栏按钮的命令，你可能想为这些命令创建新

的按钮。你可以把按钮放在任何已有的工具栏上，或者创建一个新的工具栏。下面演示如何为新的 WordUpperCase 和 WordLowerCase 命令创建工具栏按钮。在Customize （自定义）对话框的 Commands 选项卡中，从 Category （分类）框中选择 A ll Command s（所有命令），来显示按字母顺序排列的 Visual C++ 命令列表。滚动列表，来找到 WordUpperCase ，然后从列表中拖动该条目，把它放在环境的一个工具栏，如 Edit 工具栏上。如果你更愿意创建一个新的工具栏，只要把WordUpperCase 条目拖出对话框，并放在屏幕上没有被工具栏覆盖的地方，就可以了。 Visual C++ 自动创建一个新的工具栏来放置按钮。从列表中把WordLowerCase 命令拖到同一个工具栏中。

致谢 - 图66

图 3-10 Visual C++ 提供新工具栏按钮的图标选择

因为 WordUpperCase 和 WordLowerCase 命令没有预定义的图标， Button

Appearance （按钮外观）对话框打开（图 3-10 ），在该对话框中，你可以为每个新的按钮选择一个图标。在可用的图标中，没有一个能反映 WordUpperCase 和WordLowerCase 的不寻常的功能，但你可以把图像和文字组合起来，以使按钮的功能变得明确。在 Button Appearanc e（按钮外观）对话框中选择一个图标，单击Image And Tex t（图像和文本）单选钮，然后，在对话框底部的文本框中键入按钮文本。下面是带有 WordUpperCase 和 WordLowerCase 命令的按钮的新工具栏的样子：

致谢 - 图67

未结合命令不只是用于文本编辑器。下一章描述如何用同样的方法来通过快捷键或工具栏按钮来执行图形编辑器中非常有用的命令。第 13 章中详细地讨论了在Visual C++ 环境中创建工具栏的主题，解释了如何重命名或删除工具栏，如何从一个工具栏中向另一个工具栏中复制按钮，以及如何定制按钮图标。

宏的基础

你可以把一个结合命令当作一个预定义的宏，即指派给一个组合键的用法说明。环境也允许你创建用于文本编辑器的宏，你可以通过记录按键和鼠标单击活动，来把它们组合成普通的 Visual C++ 命令中的一个可重复使用的命令。你可以像执行其他命令一样通过快捷键、菜单命令和工具栏按钮来执行一个宏。实际上，宏同普通的结合命令几乎没有区别，这使它们成为扩展环境功能的一个高级方法。这一部分只介绍一下宏的主题。因为宏用在整个 Developer Studio 环境中，而不只是用于文本编辑器，我们在第 13 章再作更详细的讨论。现在，我们可以简单地通过打开命令录制器来为文本编辑器创建一个宏。

下面演示如何创建一个建立在前面说过的 Untabify Selectio n（解除制表符转换选择）命令上的宏。该宏把命令的功能扩展到整个文档，而不仅仅是选中的文本。首先关闭文本编辑器中所有的文档，来防止改变已有的文本，然后通过按下Ctrl+Shift+R ，或从 Tools（工具）菜单中选择 Record Quick Macro（快速录制宏）命令，来开始录制新宏。这会打开 Recor d（录制）工具栏，并把鼠标变成一个盒式磁带形的图像，这表示 Visual C++ 正在录制每一个按键和鼠标单击动作。该宏包括下面四个步骤：

在 Edit （编辑）菜单中单击 Select All （全选）命令来

选中整个文档。
从 Edit（编辑）菜单中选择 Advanced ，并在子菜单中单

击 Untabify

Selection 命令。

按下 Ctrl+Home 来在文档开头返回一个插入符。
在 Recor d（录制）工具栏上单击 Stop Recordin g（停止录

制）按钮来结束录制过程。

致谢 - 图68

现在，我们有了一个新的宏。 Visual C++ 以 G lobalTemporary.dsm （该扩展名代表Developer Studio 宏）。的文件名把宏存储在 Common\MsDev98\Macros 的文件夹下。该文件包含一个简单的 Visual Basic 子程序，其中的语句调用了我们刚才录制的三个命令：

Sub GlobalTemporary

ActiveDocument.Selection.SelectAll ActiveDocument.Selection.Untabify ActiveDocument.Selection.StartOfDocument

End Sub

附录 C 更详细地说明了宏的源文件语言： Visual Basic Scripting Edition 。要检验这个宏，打开一个典型的文档，并在 Advanced （高级）子菜单中打开 View Whitespace （查看空白空间）命令，来使你能够看到宏的效果。现在通过按下Ctrl+Shift+P 或在 Tools （工具）菜单中单击 Play Quick Macro （快速播放宏）命令来运行宏。效果同重新键入录制的动作一样。

G lobalTemporary 宏是独特的，因为它没有出现在图 3-8 所示的 Visual C++ 命令列表中。它被保留为通过 Record Quick Macro 命令创建的 “ 快速 ” 宏。通过同样的命令来录制另一个宏，就会覆盖前一个宏，因此，一次只有一个快捷宏存在。

定制编辑器

Visual C++ 文本编辑器可以改变自己的许多特征，以更好地适应你的工作风格。我们已经讨论过 Tools（工具）菜单中的 Customiz e（自定义）命令，它让你定制工具栏，并给命令约定快捷键。要改变编辑器界面的其他特征，从 Tools（工具）菜单中选择 Options（选项）命令。

Options（选项）命令显示图 3-11 所示的对话框，它允许你指定文本编辑器的下列特征：

外观、文档保存和 Statement Completion （语句补全）选项
制表符和缩进
模拟
字体

致谢 - 图69

图 3-11 Options 对话框的 Editor 选项卡

在对话框的 Edit 选项卡中，根据你的爱好来选择编辑器如何及何时需要保存文档（下面将详细说明 Automatic Reload Of Externally Modified Files （外部修改的文件自动重新加载）复选项。你也可以指定编辑器在编译之前是否自动保存已改变的文件，以及在保存文档之前是否提示你。

值得一提的是同一页中的 Selection M argi n（选择边界）复选项。选择边界是文档窗口左边的大约半英寸宽的一列阴影区。通过单击该边界，你就可以选中附近的一整行。该空格也可以保留书签的图标，以及后面我们将在第 11 章中提到的调试断点。如果你宁愿恢复这些空白来显示文档，清除掉此复选项，来禁用选择空格。

Visual C++ 文本编辑器可以在一定程度上模拟 BRIEF 或 Epsilon 程序员的编辑器。如果你习惯于这些产品，可以打开相应的模拟选项。单击 Compatibility （兼容性）选项卡，然后从列表中选择编辑器中的一个，或通过打开单个的复选项来设置想要的选项。

Forma t（格式）选项卡允许你给编辑器窗口指定字体类型和颜色。从 Category 列表中单击 Source Window s（源窗口），来查看当前的字体。默认情况下，字体为10 号 Courie r，但你可以把它改成任何你所想要的类型和大小。Color 区允许你为编辑器中不同的标记和文本（如源文件注释和 H T M L 标记）调整背景和前景颜色。要改变颜色，从列表中选择一个条目，然后从组合框中选择想要的颜色。

在 Developer Studio 之外编辑文本

文本编辑器同用户喜欢的字处理程序共享了许多特征。 Visual C++ 给你提供了一个非常强大的程序编辑器，但是，如果你现在喜欢使用另一个编辑器，也可以。使用一个你非常熟悉的产品效率可能会更高一些。并且，如果你从来没有使用过Developer Studio 环境，除了使用别的编辑器外，你没有别的选择了。 Visual C++ 编辑器是 Developer Studio 整体的一部分，而不是一个独立的程序。你只能从Developer Studio 中访问该编辑器。

Visual C++ 文本编辑器的一个很大的优点是，展示了一个集成的开发环境的整体应是什么样子。当编译器在源代码中发现错误时，它自动把编辑器的光标设置在第一个出错的语句上，准备让你改正错误。双击列表中的下一个错误，光标就会移动到源文件中的正确位置上。编辑完后，只需单击 Build （建立）工具栏上的Compile （编译）按钮，就可以把修订过的文本重新提交给编译器。 Visual C++ 自动把新的源文件保存到磁盘上。在环境之外的编辑器中工作，就需要更多的努力。你必须切换到编辑器，把光标移到编译出错的语句行，改正之后，保存文件，然后再切换回 Visual C++ 来重新编译。

如果你决定用另一个文本编辑器来编写和维护源代码，你应该对 Visual C++ 环境作两个小小的改动。首先，如果你打算长期使用另外的一个编辑器，你可能会发现从 Tool s（工具）菜单中通过编辑器的专用命令来运行它更为方便。通过在 Tools

（工具）菜单中放置一个新的命令，你可以在环境内部启动编辑器。如果你的编

辑器从命令行接受文件名，可以配置该命令，以使编辑器在启动时自动加载源文件。添加一个新的 Tools （工具）命令，来启动一个文本编辑器（或任何其他外部程序），这将在第 13 章中详细讨论。

应该做的第二个改变是对默认设置的细小改动。在另一个编辑器中打开一个文件时，通常在 Visual C++ 中会打开同一个文件。这发生在编译和调试代码的过程中，因为调试器要加载源文件。当你在编辑器中改变，并保存文件后，切换回Visual C++ 来重新编译时，环境可以识别到打开的文件副本不再是当前的内容了。默认情况下，系统会显示图 3-12 所示的消息框，它提示你从磁盘上重新加载新的文件。你的回答通常会是 Yes ，或者至少你不会很在意。为了防止每次你切换回 Visual C++ 时出现这个消息，在 Tool s（工具）菜单中单击 Option s（选项）。选中图 3-11 所示的 Automatic Reload Of Externally Modified Files 复选项，来让编辑器自动加载改变了的文件，而不再提示你。

致谢 - 图70

图 3-12 在外部编辑器已经改变了一个文件时，解析文档版本

当你使用另外的编辑器时，你就已经与 Visual C++ 签订了这样的协议：你不会在两个编辑器中同时改变文档。然而，环境可以处理对文档的同时改变。Visual C++ 承认外部改动，因为当环境重新获得输入焦点时，它检查所有在文本编辑器中打开的文件的日期和时间标志。出于安全的目的，环境重新加载拥有更新标志的文件，但 Automatic Reload Of Externally Modified Files 设置仅适用于那些编辑器自己的文档副本没有改变的情况下。如果编辑器中的文档已经被改变，即使是一个字符，不论 Automatic Reload Of Externally Modified Files 复选项如何设置，Visual C++ 都显示图 3-12 所示的消息。这使你可以控制文档的哪个版本是正确的。

第 4 章资源

般地，当我们说起一个程序的数据时，我们指的是那

些用 X 或 pString 命名的源代码里的变量。一个典型的 W indows 应用程序也有另一类叫做资源的数据，它包括文本和图形，这些决定程序用户界面的外观和感觉。一个程序的资源定义界面元素如下：
- 菜单
- 加速键
- 位图、光标和图标
- 对话框和控件
- 字符串
- 工具栏

当 W indows 调用一个程序时，它从程序的可执行文件里读取程序代码和初始化

数据的数值，并把它们拷贝到分配的内存里。有些情况下，资源数据保留在程序硬盘上的可执行文件里。资源在运行时读取，而不是在装载时读取，实际上，它是程序创建窗口、显示对话框或装载位图时，从 EXE 文件或 DLL 文件里读取的。Visual C++ 提供一些资源编辑器，通过它，你可以创建或编辑一个项目的资源数据。出于某些考虑，本章是前面几章的延续，它描述怎样通过 Visual C++ 的文字编辑器创建和编辑文档。虽然这里“ 文档 ” 这个词的定义已经扩展，它包括的内容不仅仅有包括纯文本，还有其他格式，这些格式的编辑原理是相同的。

有关资源和资源编辑器的主题范围广泛，它占了本章和下一章的内容。本章覆盖了用户在应用里首先会遇到的界面元素，这种资源数据包括菜单、工具栏、加速键、图标和鼠标光标。有关对话框和控件的主题放在第 5 章里。

系统资源

为了以后清楚所讲的内容，我也应该谈谈系统资源，它是 Windows 提供给应用程序的公共资源数据集。系统资源实际上是借给应用程序的，要知道，在应用程序释放一个句柄时，它以显式的方式归还给系统，在应用程序终止时，它以隐式的方式归还给系统。某些系统资源，例如鼠标光标，是自动提供的，这样，就不需每个应用程序创建自己的资源了。虽然一个应用程序可以显示它自己独特的光标（正如我们在本章后面将看到的），但是，使用箭头、沙漏和其他系统提供的位图更容易些。在对程序员提供方便的同时，它也可以保证用户在程序之间切换

时，不会对各种光标感到不知所措。

其他的系统资源，例如设备上下文和系统插入符，不能够被一个应用程序复制，也不能够被真正类比为本章中所描述的程序资源。虽然在一个程序的外观上，内存没有起到什么作用，但是，它也是一种被经常谈及的系统资源，因为它作为堆分配给程序，这是程序所要求的。控件是另一种当我们谈及资源时容易混淆的潜在的资源。在一个程序的资源数据里，程序声明的仅仅是它想使用的控件类型，例如窗口的坐标，或者可能是初始化状态。控件的显示和操作是由系统传递的。如果系统资源和程序资源的界限有时看起来不明了，那么不要着急。当你在本章中学习更多的资源时，两者之间的差别将变得非常明显。

RC 资源脚本文件

个项目在源文件里定义它的资源，资源文件以 RC 为扩
展名，并且一般和项目具有相同的名字。 RC 文件只包含文本，它更像是一个程序资源文件，所以，你可以用一个文本编辑器查看它。在文件里，你将发现一些定义字符串和菜单内容的表格，但是，没有包含位图和图标的图形数据。图形资源保存在单独的文件里，它的名字和在磁盘中的位置保存在 RC 文件里。 RC 这个扩展名指示出这个文件为资源编译器提供像源代码那样的服务，资源编译器是 Visual C++ 的一个独立部分，它把程序的文本和图形资源编译成目标文件形式，这样，链接器可以把它联编到 EXE 文件里。一个项目的 RC 文件经常叫做资源脚本或资源定义文件。

资源脚本文件是可选择的。不与用户交互的窗口应用程序不需要资源，对一个程序来说，更可能在运行时随时创建所有的资源。但是，正如你将在本章中看到的那样，资源脚本利于开发者进行开发，因为资源脚本从源代码中分离出用户界面元素。通过使用 Visual C++ 资源编辑器，开发者可以设计一个界面，看到它是什么样子，并且可以通过少许鼠标单击来改变它。并且，由于程序要面向国际市场，所以资源脚本是必须的，因为它们允许转换者修改用户界面，而不用接触程序源代码。

个 Visual C++ 项目只认可一个主要的 RC 文件。如果你想
使用 Project（项目）菜单里的 Add To Project（添加到项目）命令添加一个额外的 RC 文件，集成环境会警告你，当编译这个项目时，这个文件将不会被编译，如下所示．

致谢 - 图71

然而，一个项目可以有任何数目的资源脚本文件，但是，所有的二级文件只能通过 #include 语句添加到 RC 文件里。例如， AppWizar d（应用程序向导）自动创建第二个资源文件，这个文件以项目文件名作为名字，以 RC2 作为扩展名，它提供了一个存放你以前开发和测试的任何资源的好地方，你不需进一步的修改。为了看看 RC2 文件怎样包含在 AppWizard （应用程序向导）创建的项目里，打开项目，并从 View （查看）菜单里选择 Resource Include s（资源包括）项，然后在Compile-Time Directives （编译时伪指令）控件里向下滚动，到下面这一行（在这里 project 是项目名）：

#include “ res\project.rc2 ” //non- M icrosoft Visual C++ resource

包含在补充文件里的所有资源均将编译，并链接到项目的可执行文件里。但是，

当你使用一个 Visual C++ 资源编辑器对主 RC 文件操作时，将不能访问它。这就是为什么只有完成的和测试过的资源才应该包含在 RC2 中的原因。资源编译器读取所有的脚本文件，并产生一个以 RES 做后缀的编译过的二进制文件，它类似于 C/C++ 编译器产生的 OBJ 文件．

在第 1 章中描述的作为环境的 Workspace （工作空间）窗口，列出了在主 RC 文件里定义的项目资源。当项目打开时，单击 ResourceView （资源查看）选项卡，并通过单击靠近文件夹图标的加号展开列表。为了在适当的编辑器里打开一个资源（我们将立刻做这件事情），双击列表里的资源。图 4-1 显示了 ResourceView

（资源查看）窗格中的资源，这是名为 Demo 的 AppWizard （应用程序向导）项目中的。

通过 AppWizard （应用程序向导）创建的默认 RC 文件是广泛的，包括冗长的字符串表、菜单脚本和与交叉开发平台有关的代码。如果你接受创建新的应用程序时 AppWizard （应用程序程序向导）产生的所有默认资源，那么，最终将得到一个将近 400 行的 RC 文件。你可以尝试在一个文本编辑器里修改 RC 文件，删除通过 AppWizard（应用程序程序向导）产生的多余的代码行，减少文件尺寸到易于管理的大小。但是，这样做意味着，以后当你使用一个 Visual C++ 的资源编辑器修改一种资源时，就会有麻烦。虽然你可以得到一个有效的 RC 文件，但是，不幸的是， Visual C++ 不再认为它是 AppWizard （应用程序程序向导）产生的。你仍然可以通过一个编辑器修改资源，但是，当你保存修改后的文件时， Visual C++ 用一个新的 RC 文件重写你的最低限要求的 RC 文件，它包含许多你在前面

已经删除的由 AppWizard（应用程序程序向导）生成的多余代码。唯一可供选择的是用一个不同的文件名保存修改后的文件，然后，使用文本编辑器从新文件里拷贝你想要的行，并粘贴到最初的资源脚本。我推荐你学习使用由 AppWizar d（应用程序程序向导）产生的巨大的 RC 文件，除了一些小的变化外，只通过资源编辑器来修改资源。

致谢 - 图72

图 4-1 Workspace 窗口的 ResourceView 窗格

Resource.h 头文件

项目里的每一个资源或者通过常量标识符，或者至少通过一个字符串名，来加以区别。例如，在图 4-1 中，假想的 Demo 程序的资源都用恒定的值标识： IDR_MAINFRAME 是菜单和工具栏， IDR_DEMOTYPE 是程序的一个图标， IDD_ABOUTBOX 是 Abou t（关于）对话框。用于标识一个项目的资源常量一般是在以 Resource.h 命名的文件里。 AppWizard （应用程序程序向导）自动创建Resource.h 作为项目的一部分，对资源标识符指定标准 MFC 的资源前缀。表格4-1 列出一些 MFC 使用的标识前缀。

	表	4-1	标准	MFC 标识符前缀
前缀				资源类型
IDR_				主菜单、工具栏、加速键表和应用程序图标
IDD_				对话框

续表

IDC_ 控件和光标

IDS_ 字符串

IDP_ 为消息框提示字符串

ID_ 菜单命令

常量标识符可以由字母（大写或小写）、数字和下划线组成，但是不能以一个数字开头。

C 程序把标识符成员认为是明显的常量或“ 定义 ”，但是， Visual C++ 有时将它们作为符号。从技术上来说，符号是在源代码里标明内存地址的名字，例如一个变量或一个函数名字。我们将在第 11 章里看到，编译器怎样生成一个程序里的符号列表，通过阅读它，调试器可以知道程序里的变量和函数名。不要混淆资源符号和源代码里的符号。毫无疑问， Visual C++ 的设计者选择单词符号，他们认为资源脚本也是一种源代码和资源标识符，类似于程序源代码里的变量名字。

你可以改变列在 Workspace （工作空间）窗口里 ResourceView （资源查看）窗格里的一个资源标识符的名字，或以数字表示的值。首先通过展开适当的文件夹图标，找到标识符名字，如图 4-1 所示。然后，单击列表里的标识符选择它，并单

击 View （查看）菜单里的 Properties（属性）。你也可以右击一个标识符，并从弹出的上下文菜单里选择 Properties 。在任何一种方法里，都要通过在 ID 控件里重新输入标识符名字来改变它。同时，你可以像下面这样给名字添加一个以数字表示的整型值，来给它赋值：

IDD_ABOUTBOX_NEW = 3001

按下 Enter 键时，一个星号出现在 ResourceView （资源查看）窗格顶部的项目行附近，它表明你已经改变了它，但是还没有保存。从 Fil e（文件）菜单里选择 Save

（保存）命令，使 Visual C++ 重写 Resource.h 文件，用新的标识符代替 #define

语句里旧的标识符。

从理论上来说，你可以给一个资源标识符赋以从 1 到 6553 5（ 0xFFFF ）中的任何一个值。然而， Windows 为系统菜单项保留了 0xF000 及它上面的值， MFC 为内部使用保留了从 0xE000 到 0xEFFF 之间的值，所以，你应该使自己的标识符值保持在 1 到 57343 之间（ 0xDFFF ）。标识符的值被限制在 W O R D 大小，而不是DWORD 大小，这是因为 W M _ C O M M A N D 消息在 wParam 消息参数的低字节里传递标识符的值。

你也可以在 Resource Symbols( 资源符号 ) 浏览器里改变、添加或删除标识符符号，如图 4-2 所示，这些标识符是由 AppWizard （应用程序程序向导）或其他一种 Visual C++ 资源编辑器创建的 RC 文件提供的。要打开视图，单击 Vie w（查看）菜单里的 Resource Symbols( 资源符号 )。视图将显示所有在 Resource.h 中定义的

标识符，要给标识符重命名或改变其值，从列表里选择它并单击 Change（更改）按钮。 New （新建）按钮让你在 Resource.h 里添加新的标识符，并给它们赋值。在你关闭 Resource Symbols( 资源符号 ) 对话框之后，右击 ResourceView （资源查看）窗格里的项目行，并选择 Save （保存）命令，把新的值写到 Resource.h 文件里。

致谢 - 图73

图 4-2 Resource Symbols 浏览器，它通过 View 菜单上的 Resource Symbols 命令调用

符号浏览器是为最佳利用由 AppWizard （应用程序程序向导）或其他一种 Visual C++ 资源编辑器创建的 RC 文件而设计的。你可以查看所有在项目 RC 文件里引用的标识符的定义，但是，浏览器只可以修改在 Resource.h 头文件里定义的标识符。它把定义在其他包含文件里的标识符当作只读的，并不提供修改它们名字和值的方法。要看这些标识符，单击浏览器对话框里的 Show Read-Only Symbols

（显示只读符号）检查框。例如， AppWizard （应用程序程序向导）添加到 RC

文件里的这一行，我们将在本章后面再次见到它：

#include "afxres.h"

当你选择了 Show Read-Only Symbols 复选框，浏览器将包含在 Afxres.h 文件里的所有符号的列表。你可以区别出在列表里的只读符号，因为可修改的符号以黑体字显示。

在 In Use （正在使用）列里，一个复选标记表明，在 RC 文件里，一个符号标识一种资源。在你开发一个程序时，偶尔可能要改变标识符的名字，没有关系，但是 Visual C++ 不删除旧的名字，而为新的标识符在 Resource.h 中添加一个定义。一些标识符最终会成为孤标识符（ orphan s），它在 Resource.h 文件里定义，但是在 RC 文件里任何地方都没有使用。在 In Use 列中，我们可以很容易确定孤标识符。要删除一个标识符，就是从 Resource.h 文件中删除它的 #define 语句，那么从列表里选择它，并单击 Delete 按钮。删除将在你下一次单击 Save（保存）命令时生效。记住，虽然浏览器告诉你，只有复选的符号才会出现在 RC 文件里，

但是，这并不意味着这个符号不在源代码或其他资源文件的其他地方使用。

AppWizard 资源的例子

在深入说明之前，让我们看看一部分 AppWizard（应用程序程序向导）为假想的Demo 程序生成的资源脚本文件。我们已经见到， AppWizard （应用程序程序向导）自动的为 About （关于）对话框创建一个资源脚本，还有一个 MFC 图标。在生成的 Demo.rc 文件里，对话框脚本看起来像下面这样：

IDD_ABOUTBOX DIALOG DISCARDABLE 0, 0, 217, 55

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "About Demo" FONT 8, "MS Sans Serif" BEGIN

ICON IDR_MAINFRAME,IDC_STATIC,10,22,20,20 LTEXT "Demo Version 1.0",IDC_STATIC,45,10,115,8

END

上述命令定义了下面所示的对话框，它是通过选择 Demo 程序的 Hel p（帮助）菜单里的 About 来调用的：

致谢 - 图74

虽然一行也没写，但是，效果还不错。然而， AppWizard （应用程序程序向导）并不是适合于任何场合。要看一下不使用 AppWizar d（应用程序程序向导）将会是什么样，本章的其余部分开发了一个不使用 AppWizar d（应用程序程序向导），而是从头开始的资源程序，并讨论这个方法的利弊。

例程 DiskPie1 简介

这里，我们将开始用连续的几节逐步开发一个叫做 D iskPie1 的例程。每一节集中一种资源类型，我们将从菜单和加速键开始，接着是状态栏、位图和工具栏。每一节都以总体讨论一种资源类型开始，以将这种资源加入 D iskPie1 结束，并

示范怎样用适当的 Visual C++ 编辑器创建或修改一种资源。当我们结束的时候， D iskPie1 将成为一个有用的工具，它快速查看当前内存使用情况和可用的磁盘空间。

为了更好地开发实践，我们将在写任何代码之前，首先对程序进行说明。这个说明将使你了解我们将加入到程序中的资源，并使我们可以很容易地看到它们怎样一起工作，形成一个和谐的界面。下面是 D iskPie1 的主要说明：

描述 ： DiskPie1 是一个用 MFC 写的实用程序，它显示
两份饼图。通过对菜单或工具栏的选择，这个图显示指定的磁盘驱动器上的存储空间分配。饼图的一部分描述已经分配的空间，而其余部分显示未分配的

空间。有标签将两者明显区分开。

主窗口 ：程序有四个菜单，叫做 File ， Chart， View
和 Help 。 File （文件）菜单只包含一个 Exit 命令， Help （帮助）菜单有一个显示程序信息的 About 命令。 View （查看）菜单允许用户显示或隐藏工具栏和状

态栏。 Chart 菜单开始时只包含一个命令，叫做 M emory ，它显示内存使用状况。在运行的时候， DiskPie1 搜索与系统相连的磁盘驱动器，包括 R A M 磁盘和远程网络驱动器，并把它们添加到 Chart 菜单里。此程序忽略软盘驱动器、 CD 驱动器及其他可卸式驱动器。

工具栏和加速键 ：可停靠的工具栏和键盘命令补
充了程序的菜单，允许用户通过单击按钮或通过按表示从 C 到 Z 的特定驱动器的键，来显

示表示使用状况的饼图。

状态栏 ：标识当前选择的菜单或工具栏。
上下文菜单 ： DiskPie1 不提供上下文菜单。

D iskPie1 可以很容易地通过 AppWizard 生成骨架代码，但是，我不选择这样做，有两个原因。首先， D iskPie1 并不是那种文档 / 视图形式的应用程序程序，而AppWizard 创建文件时，注重的是这种形式，并且，删除 AppWizard 生成的多余资源描述可能是冗长乏味的过程。第二，我们已经谈到过 AppWizard 。现在，应当看看在 Visual C++ 里从底层创建一个项目会怎样。下面的几节并没有忽略AppWizard ，不管怎样，在默认的情况下，它们都描述 AppWizard ，这样，你能够看到，通过使用 AppWizard 创建 D iskPie1 这样的小项目将得到或失去什么。

讨论假设 D iskPie1 以一个没有资源文件的空项目开始。如果你喜欢在这里略述的步骤从头开始创建这个项目，那么从 Fil e（文件）菜单选择 Ne w（新建）命令，然后单击 Project（项目）选项卡，选择 W in32 Application 图标。输入项目名字，然后单击 OK （确定）按钮。 Win32 Application Wizard 只显示一个单独的步骤，提供在三种不同的准备状态下，以设置一个新的项目，单击 Finis h（完成）按钮，接受为空项目选择的默认设置。

致谢 - 图75

如果你已经运行 Setup 程序，从所附 CD 中将 DiskPie1 拷贝到你的硬盘，那么你可能更喜欢打开项目，不用自己创建资源，而继续进行讨论。要打开已经完成的项目，从 File（文件）菜单选择 Open Workspace（打开工作空间）命令，并在硬盘驱动器上浏览 D iskPie1 项目所在的文件夹。双击 D iskPie1.dsw 打开项目。

打开已有的项目

新项目就像新文件一样，开始要使用 New 命令，并在一个 Visual C++ 向导的帮助下（如 AppWizard 或 W in32 Application ），设置新的项目。一旦向导完成了它的工作，此项目就不再使用 New 命令了。要打开一个已有的项目，例如从配套光盘中安装的任何一个项目，需从 File 菜单中选择 Open Workspace 命令，并浏览到项目的文件夹。对于最近使用过的项目，相同菜单上的 Recent Workspace 命令提供了更好的方便性。

如果你愿意， Visual C++ 环境可以在启动时自动打开最近的项目。对于你已经花费了许多时间的冗长的项目，这个特征非常方便。单击 Tools （工具）菜单上的Option s（选项），并滚动到右边，找到 Workspace 选项卡，然后，激活标为 Reload Last Workspace At Startup （在启动时重新加载上次的工作空间）复选框。

配置 DiskPie1 项目

W in32 Application 向导只生成几个文件，它们用于建立项目的主干内容。此向导也假设项目不使用 M F ，对 D iskPie1 来说，这是不正确的假设。在选择 W in32 Application 创建像 DiskPie1 一样的 MFC 程序之后，你必须配置这个项目，来识别 MFC 库文件。正如在第 2 章里描述的那样，这是通过在 Project Settings 对话框 General 选项卡的一个开关来实现的。通过从 Projec t（项目）菜单选择 Setting 打开对话框，从对话框的左上角的组合框里选择 All Configuration s（所有配置），

并为项目选择静态或动态链接库。图 4-3 显示后一种选择。

致谢 - 图76

图 4-3 在 Project Settings 对话框中选择到 MFC 的动态链接

一旦打开了初具雏形的 DiskPie1 项目，并正确进行配置，我们便可以开始为它

创建资源，并添加 DiskPie1.rc 和 Resource.h 文件了。对于 D iskPie1 这样一个小程序，它使用了很多资源，所以，大部分工作是创建资源数据。在完成资源的创建之后，我们将为程序写出实际的代码。

菜单和加速键

图 4-4 显示了 AppWizard 创建的默认菜单系统。你可以看到，图中的菜单和

AppWizard 放在 RC 文件中的菜单脚本是对应的： IDR_MAINFRAME MENU PRELOAD DISCARDABLE BEGIN

POPUP "&File" BEGIN

MENUITEM "&New\tCtrl+N", ID_FILE_NEW

MENUITEM "&Open...\tCtrl+O", ID_FILE_OPEN

MENUITEM "&Save\tCtrl+S", ID_FILE_SAVE

MENUITEM "Save &As...", ID_FILE_SAVE_AS MENUITEM SEPARATOR

MENUITEM "&Prin t… \tCtrl+P", ID_FILE_PRINT

MENUITEM "Print Pre&view", ID_FILE_PRINT_PREVIEW

MENUITEM "P&rint Setup … ", ID_FILE_PRINT_SETUP MENUITEM SEPARATOR

MENUITEM "Recent File",

ID_FILE_MRU_FILE1,GRAYED MENUITEM SEPARATOR

MENUITEM "E&xit", ID_APP_EXIT

END

POPUP "&Edit"

BEGIN

MENUITEM "&Undo\tCtrl+Z", ID_EDIT_UNDO MENUITEM SEPARATOR

MENUITEM "Cu&t\tCtrl+X", ID_EDIT_CUT

MENUITEM "&Copy\tCtrl+C", ID_EDIT_COPY

MENUITEM "&Paste\tCtrl+V", ID_EDIT_PASTE

END

POPUP "&View" BEGIN

MENUITEM "&Toolbar", ID_VIEW_TOOLBAR

MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR

END

POPUP "&Help" BEGIN

MENUITEM "&About Demo...", ID_APP_ABOUT

END

致谢 - 图77

图 4-4 由 AppWizard 生成的菜单系统

脚本的第一行给菜单栏一个 IDR_MAINFRAME 标识号，它在 AppWizard 添加到项目的 Resource.h 文件里定义。像文件里的所有标识符一样，IDR_MAINFRAME 只是 AppWizard 的默认名字。你可以为资源指定你想要的任何名字或值。

PRELOAD 和 DISCARDABLE 伪指令在 Win32 应用程序程序脚本中并不是必须的。只对 16 位程序有意义的 PRELOAD 告诉 W indow s，当它开始加载程序时，将菜单资源数据拷贝到内存，而不是以后当程序创建主窗口时，再打开程序的EXE 文件，并读取菜单数据。不需要 DISCARDABLE 伪指令，是因为在 W in32 里，所有的资源都是可丢弃的。这意味着，操作系统可以自由地从物理内存中删除程序的资源数据，以使其他程序能够得到这些内存。当程序再次获得焦点，并需要那些删除的资源时，系统从程序的 EXE 文件中重新读取数据。这可能是因

为资源是静态只读数据，在内存里的副本和磁盘上的一样。相反，从内存中移去动态数据由虚拟内存管理器完成，但是，虚拟内存管理器必须首先在内存被用于其他目的之前，将数据保存到系统交换文件。

资源脚本文件的缩进排列显示了 BEGIN 和 END 语句之间的资源的级别。第一级定义了完整的菜单资源，包括菜单栏，它被叫做顶级菜单。 BEGIN-END 对的第二级指明每一个下拉菜单的内容。每一个 POPUP 语句跟在一个显示在菜单栏上的菜单标题之后，随后的 MENUITEM 语句指明列在菜单上的命令。菜单上的一行叫做命令或菜单项。

些菜单命令包含键盘组合键，例如 Ctrl+N 相当于 New （
新建）命令， Ctrl+O 相当于 Open （打开）命令。如你所知，这些组合键提供像快捷键那样的服务，它让用户选择命令，而不用通过菜单系统。例如， Ctrl+O 立即显示 Ope n（打开）对话框，与从 File （文件）菜单里选择 Open （打开）命令的效果一样。加速键的麻烦是用户必须记住它们，它们出现在菜单中，是为了提醒用户，还有一种更容易的方法来选择命令。加速键要求在 RC 文件中附加的表格，我们将立即看到这些。

加速组合键之前的 \t 是一个制表符，它整齐地在菜单上排列加速键。你也可以使用 \a 代替 \t，在菜单上右对齐排列文本，以具有一致性。如果你使用 \a 来排列菜单上的任何加速组合键，那么，你应该在其他行上不使用 \t。如果不这样做，将使 Windows 混乱，导致菜单文本排列凌乱。\a 字符比 \t 对菜单的控制更好些。如

果菜单上的文本看起来太拥挤，那么在 \a 字符前输入几个空格，可以加宽菜单，并使加速键和命令之间的间隔更远。在每一个菜单命令里的字符 & 把它后面的字符作为菜单的助记符。如图 4-4 所示，在菜单里，一个助记符以下划线显示，以便用户识别它。对于一个菜单或菜单栏来说，助记符应该是唯一的，例如，Format 菜单应该有一个不是 “ F ” 的其他助记符，以便避免同 File （文件）菜单冲突。但是，使用唯一的助记符只是一个建议，而不是一条规则，如果一个菜单栏或下拉菜单在两个或更多的地方包含相同的助记符，那么，当用户按下助记符时， W indows 将依次加亮每一个命令，并且只激活你按下 Enter 键时选择的命令。下一节描述的菜单编辑器可以通过在弹出的上下文菜单上的命令，来检查重复的助记符。在编辑器工作区域的任何地方右击，将打开这个菜单：

致谢 - 图78

助记符和加速键并不是相同的东西。加速键不需要通过菜单系统，就可以激活一个命令，然而，下划线助记符只有当菜单可见时才是可用的。

每一个菜单命令都有一个以 ID _ 作为前缀，紧接着是描述命令的名字组成的辅助

标识符。包括 ID_ 前缀的标识符是完全由用户决定，前面的菜单脚本只是AppWizard 提出的（然而，正如我们将看到的，使用 MFC 已经定义的特定符号名是有好处的）。只有通过菜单标识符，程序才能引用菜单事件。当用户单击一个菜单命令，或按下一个加速键时， W indows 用在 wParam 低字节里的命令标识符给主窗口发出 W M _ C O M M A N D 消息。如果这个命令是用户按下加速键响应的，那么 wParam 的高字节是 TRU E ，如果是通过菜单选择响应的，那么 wParam 的高字节是 FALSE 。

按传统， C 程序通过一系列 switch-case 语句，来检查 W M _ C O M M A N D 消息的

wParam 参数以传递菜单命令：

switch (msg)

{

case W M _ C O M M A N D :

switch (LOWORD (wParam))

{

case ID_FILE_NEW OnFileNew ();

break;

case ID_FILE_OPEN: OnFileOpen ();

break;

}

MFC 程序通过一个消息映射来完成相同的事情：

BEGIN_MESSAGE_MAP(CMyFrame, CFrameWnd) ON_COMMAND(ID_FILE_NEW, OnFileNew) ON_COMMAND(ID_FILE_OPEN,OnFileOpen)

END_MESSAGE_MAP ()

为 DiskPie1 创建菜单

正如我们将为 DiskPie1 所做的那样，当我们从头开始创建菜单资源时，我们从Insert 菜单选择 Resource ，以显示资源类型列表，如下所示。然后，双击列表里的 Menu 条目打开菜单编辑器。

致谢 - 图79

项目必须是打开的，你可能不得不隐藏 Workspace 或 Outpu t（输出）窗口，以便不覆盖编辑器的工作区域。当你设计并保存菜单时， Visual C++ 把菜单脚本写到

项目的 RC 文件里，并把标识符 #define 语句写到 Resource.h 文件里。其后，当你打开菜单资源时，环境自动打开菜单编辑器。为了显示 Projec t（项目）菜单标识符的列表，双击 ResourceVie w（资源查看）窗格里的 Menu 条目（如图 4-1 所示）。通过双击列表里的资源标识符或右击标识符，并从上下文菜单里选择 Open 打开菜单编辑器。

致谢 - 图80

图 4-5 使用 Visual C++ 菜单编辑器创建 DiskPie1 的菜单

图 4-5 显示了当我们向 DiskPie1 项目进一步添加菜单时菜单编辑器的外观。顶级菜单（也就是菜单栏）包含一个点线矩形，叫做新项框，它指出菜单标题文本插入点。当你在菜单栏上输入一个条目，并按下 Enter 键，一个带有自己的新项框的下拉菜单出现了。模糊的边界表明新项框是激活的，而不管它是菜单栏上，还是在下拉菜单里。如果你想在没有击活的新项框里输入一项，那么，首先单击新项框来选择它。任何输入到新项框的东西将同时输入到图 4-6 所示的 M enu Item Properties（菜单项属性）对话框的 Caption 控件里。要返回并修改一个标题或菜

单项，或者选择这个项目，并输入新的文本，或者双击这个项目打开 M enu Item Properties （菜单项属性）对话框。当你正在菜单项之间跳转时，对话框会消失，有时，这是很不方便的。在这种情况下，单击对话框左上角带金属头的钢针按钮，可强制对话框保持可见。

D iskPie1 的 File （文件）菜单只有一个命令，叫做 Exit。要创建这个菜单，首先在菜单栏的新项框里输入 &File ，按下 Enter 键，然后输入 E&xit 作为菜单项的文本。如果此时按下 Enter 键，菜单编辑器自动给这个命令一个叫做 ID_FILE_EXIT 的标识符，它是菜单标题和菜单项文本的混和物。它也为 ID_FILE_EXIT 添加#define 语句到 Resource.h 文件中。

让我们停一会儿，想一下为什么这可能会导致以后的问题。当你保存这个新的菜单资源时， Visual C++ 看到这个项目没有 RC 文件，它自动为你创建一个。它也添加这些行到 RC 文件：

#include “ afxres.h ” #include “ resource.h ”

MFC 提供了 Afxres.h 头文件，使你不必为每一个项目定义相同的公共标识符，

它们显示在典型的 W indows 程序里。理论上，大多数 W indows 程序都有一个File ， Edit ， View 和 Help （帮助）菜单， Afxres.h 定义了一些常用的标识符，例如， ID_FILE_OPEN ， ID_EDIT_COPY 和 ID_APP_ABOUT 等。它为你定义自己

的资源标识符保留了 Resource.h 。偶然情况下， Afxres.h 没有为 ID_FILE_EXIT 定义，但是，如果它定义了会怎样呢？在那种情况下，当编译 RC 文件时，你将碰到一个错误，因为 ID_FILE_EXIT 将定义两次，一次是在 Afxres.h 里，一次是在 Resource.h 里。

AppWizard 生成的资源脚本并不存在这个潜在的命名冲突问题。 AppWizard 生成的所有的菜单项都在 Afxres.h 里定义，所以， AppWizard 并不为它们添加定义到Resource.h 里。对于 D iskPie1 这样的非 AppWizard 项目，当使用资源编辑器时，你有三种选择来防止定义重复：

在文本编辑器里打开 RC 文件，并为 Afxres.h 移去 #define

语句。
不接受资源编辑器可能在 A fxres.h 文件里的默认标识

符，用你自己定义的资源标识符。
编辑 Resource.h 文件，并删除任何已经在 A fxres.h 里定义

的标识符。第一种操作的问题是，它迫使你也从文件里移去了所有其他 Visual C++ 要求在

Afxres.h 里定义的跟踪信息。第二种解决方案更可靠。当命名资源标识符时，由于 ID M _ 在 Afxres.h 中从没有作为一种标识符前缀使用， MFC Technical Note 20 推荐你添加 IDM _ 到菜单标识符上。在 M enu Item Propertie s（菜单项属性）对话框里指定标识符名字，同时像下面那样随意为标识符设一个值：

IDM_FILE_EXIT=1001

当然，你要确定每一个菜单标识符有一个唯一的值。

采用上面列表选项中的第三种方案更好些，尽管这种方法有些粗野。考虑一下，如果你在程序里使用像 IDM_FILE_EXIT 这样的名字来标识 Exit 命令，将会发生什么。对于像 DiskPie1 这样的 MFC 应用程序，你必须接着为带有标识符的W M _ C O M M A N D 消息提供一个处理函数，同时也添加一个指向处理函数的消息映射。结果可能看起来像下面这样：

ON_COMMAND (IDM_FILE_EXIT,OnFileExit) // In the message map

void CMainFrame::OnFileExit() //Handler for IDM_FILE_EXIT

{

SendMessage( W M _CLOSE, 0, 0);

}

Afxres.h 包含几个特定的标识符名字，MFC 为它提供自己的处理函数，这样做可免除应用程序的麻烦。这些特定标识符中的一个是 ID_APP_EXIT ，它通过一个关闭应用程序的 MFC 函数来自动调用。通过指定 ID_APP_EXIT 的值给 Exit 菜单命令，D iskPie1 不需要提供它自己的代码来处理 Exit 菜单选项。出于类似的原因， D iskPie1 的 View （查看）菜单上的两个菜单项的值被指定为ID_VIEW_TOOLBAR 和 ID_VIEW_STATUS_BA R。MFC 认可这些特定值，并调用它自己的处理函数来显示或隐藏工具栏和状态栏。D iskPie1 在它自己的菜单脚本里为 Toolbar 和 Status Bar 命令简单地使用这些标识符，而 MFC 框架则处理其他每一件事情。

给命令特定的标识符（如 ID_APP_EXIT 或 ID_VIEW_TOOLBAR ）的缺点是菜单编辑器在 Resource.h 里为这些名字书写定义，这样就重复了在 Afxres.h 里的定义。我们不得不在创建资源之后使用文本编辑器，来删除在 Resource.h 里的无用定义。

D iskPie1 菜单项标识符的名字是通过把它们输入到 Menu Item Propertie s（菜单项属性）对话框里来指定的。下面是结果概况：

菜单标题	项目标题	标识符
&File	E&xit	ID_APP_EXIT
&Chart	&Memory\tCtrl+M	IDM_MEMORY
&View	&Toolbar	ID_VIEW_TOOLBAR
&View	&Status bar	ID_VIEW_STATUS_BAR
&Help	&About DiskPie1 …	ID_APP_ABOUT

在图 4-6 所示的 M enu Item Propertie s（菜单项属性）对话框中，可以优化菜单的外观。例如，如果程序刚开始时一个菜单命令是非激活的，那么，这个菜单的文本应该变灰，来提示用户这个命令当前是不可用的。通过单击对话框里的 Grayed

（变灰）复选框，可以为一个菜单项指定变灰文本。要在菜单命令旁放置复选标记，单击 Checked （复选的）。在资源脚本里设定变灰文本或复选标记，对于D iskPie1 这样的 MFC 程序是不需要的，因为框架会自动更正菜单。

致谢 - 图81

图 4-6 菜单资源的 Menu Item Properties 对话框

如果你想用菜单命令打开一个折叠的弹出菜单，单击在 M enu Item Propertie s（菜单项属性）对话框里的 Pop-u p（弹出）复选框。显示在菜单项旁边的箭头符号告诉用户，这个命令显示一个嵌套的弹出菜单。编辑器为这个弹出菜单显示另一个新项框，你在里面输入命令，就像在其他任何菜单里一样（在环境的 Fil e（文件）菜单上的 Recent File 命令给出一个折叠弹出菜单的例子）。

对于像 D iskPie1 这样有状态栏的程序，当用户加亮菜单上的命令时，对话框里的 Prompt （提示）文本框提供了一个方便的地方，来输入显示在状态栏里的描

述。我们将在以后的一节里，使用 Visual C++ 字符串编辑器添加 D iskPie1 的菜单描述。当你看到重复的描述时，你将会同意，使用字符串编辑器是最好的选择。

D iskPie1 的菜单是标准的。唯一有趣的添加项是 Chart 菜单底部的分隔条。在一个菜单最后放置一个分隔条，乍看起来是很古怪的。但是， DiskPie1 在执行时向Chart 菜单添加更多的命令：顶部的 M emory 命令和底部的 D isk 命令，像 Disk C 和 Disk D 。要在菜单上创建一个分隔条，需单击图 4-6 里的 Separator （分隔条）复选框。

如果你想插入一个新的菜单或菜单命令，将新项框拖到想要的地方。当你拖拉这个方框时，一个水平或垂直插入线显示在光标附近。放开鼠标按钮来放下新项框，然后一般是输入新菜单的标题。你也可以拖动独立的菜单项或菜单栏目，来改变它显示的顺序。例如，要改变 Chart 和 Vie w（查看）菜单的顺序，拖动 View

（查看）菜单到左边，直到你看到一个显示在 File 和 View 之间的垂直插入线．释放鼠标，就完成了操作。

如前所述创建一个新菜单资源时，菜单编辑器想给这个新资源起一个像IDR_MENU1 这样的名字。资源的符号名字显示在 RC 文件里菜单脚本的第一行：

IDR_MENU1 MENU PRELOAD DISCARDABLE

菜单应当有一个像 IDR_MENU1 这样的名字，但是，对 DiskPie1 这样的 MFC 程

序来说，它不是很好的选择。作为一个单文档界面程序 (SDI) ， D iskPie1 可以为它的资源注册模板，使用到 CSingleDocTemplate 构造器的单独调用，提供具有相同标识符值的所有资源。标识符的值是什么，甚至给资源不同的标识符名字，这些并不重要，只要菜单、工具栏、加速键表和状态栏资源是通过同一不变的数值描述的就行。如果你的程序不调用 CSingleDocTemplate 或同 M D I 等效的CMultiDocTemplate ，那么，你不需要担心像菜单和加速键那样用同样的符号值来标识资源。

在默认状态下，资源编辑器给所有的主窗口资源标识符提供不同的名字和值，所以， Resource.h 文件可能最终是这样：

#define IDR_MENU1 革者 101

#define IDR_ACCELERATOR1 102

#define IDR_ICON1 103

#define IDR_TOOLBAR1 104

如果创建资源时，你接受默认的名字，那么必须接着编辑 Resource.h 文件，在使用 CSingleDocTemplate 前给标识符一个通用值。对于 DiskPie1 ，我们将不接受默认的名字，而改为给菜单和其他资源指定相同的普通符号标识符，就是被AppWizard 使用的 IDR_MAINFRAM E 。这将保证 CSingleDoTemplate 总是得到一

个对所有的资源来说公共单一的值。要改变菜单的标识符，双击菜单栏的任何地方，但必须是在一个菜单名字上，来打开 Menu Properties 对话框，输入IDR_MAINFRAM E，并按下 Enter 键。

这时，项目的 RC 文件还没有存在。要保存项目的第一个资源，单击 Fil e（文件）菜单上的 Save 或 Save A s ，并给文件起一个同项目相同的名字，在此是 D iskPie1 。Visual C++ 就创建 D iskPie1.rc 文件，将菜单资源脚本写到它里面，并创建Resource.h 文件，以保存新的定义。不要忘记以后用文本编辑器编辑 Resource.h 文件，为 ID_APP_EXIT ， ID_VIEW_TOOLBAR ， ID_VIEW_STATUS_BAR 和

ID_APP_ABOUT 删除那些不需要的定义。

下一步，是将 DiskPie1.rc 文件添加到项目中。从 Properties 菜单中选择 Add To Project 命令，然后单击显示在下面的级联菜单中的 Files：

致谢 - 图82

双击在文件列表里的新的 DiskPie1.rc 文件，将它添加到项目中。对 Resource.h 文件不需要进行相同的操作，因为 Visual C++ 自动识别这个头文件作为项目的支持文件。从这点来看， DiskPie1 是一个实际的项目。接着，我们将为 D iskPie1 创建一个资源，由于 D iskPie1.rc 文件已经存在，我们将使用 Save （保存）命令来保存资源，而不是用 Save A s（另存为）命令。

你可能使用文本编辑器来查看 Visual C++ 写到 D iskPie1.rc 文件的菜单脚本。通过单击 File （文件）菜单上的 Open （打开）命令，将 RC 文件作为文本文档调入，来显示 Open （打开）对话框。从对话框底部的 Open A s（打开类型）组合框里选择 Text ，然后，双击文件列表里的 DiskPie1.rc 。这里是显示在文件里的新菜单

脚本：

IDR_MAINFRAME MENU DISCARDABLE BEGIN

POPUP "&File" BEGIN

MENUITEM "E&xit", ID_APP_EXIT

END

POPUP "&Chart" BEGIN

MENUITEM "Memory\tCtrl+M", IDM_MEMORY MENUITEM SEPARATOR

END

POPUP "&View" BEGIN

MENUITEM "&Toolbar", ID_VIEW_TOOLBAR

MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR

END

POPUP "&Help" BEGIN

MENUITEM "&About DiskPie1...", ID_APP_ABOUT

END

图 4-7 显示了 D iskPie1 已经完成的菜单外观。 Chart 菜单的 Disk C 和 D isk D 命令不会显示在上面的菜单脚本中，因为这些命令是在运行时添加到菜单上的。标题栏上的图标在本章后面创建。

致谢 - 图83

图 4-7 DiskPie1 的菜单系统

如果你想在继续下一节之前从屏幕上消除菜单编辑器，那么从 File（文件）菜单或从 W indows 菜单上选择 Clos e（关闭）命令。在使用这个命令时 , 要确定编辑器具有输入焦点。

为 DiskPie1 创建加速键

在 Visual C++ 将来的版本中，可能可以在菜单脚本里搜索加速组合键，并自动生成一个相应的加速键表。但是现在，我们将不得不手工做这些事。由于上面的脚本只有一个加速键，对应于 Memory 命令的 Ctrl+M ，你可能以为 DiskPie1.rc 文件里的加速键表很小，并且很简单。但是，实际上这个表是相当大的，因为我们不得不为那些还没有在菜单上但可能在运行时被添加的项添加按键。我们将使用Visual C++ 编辑器做这些。

对于已经存在的加速键表，例如一个通过 AppWizard 创建的加速键表，从项目的ResourceView （资源查看）窗格里打开加速键编辑器，就如同你打开其他任何资源编辑器一样。双击在 Accelerator 文件夹里的条目来启动这个编辑器。要为D iskPie1 这样的项目从头开始创建一个新表，通过从 Insert 菜单里选择Resource ，并双击在 Resource Type 列表里的 Accelerator 打开加速键编辑器。

图 4-8 显示了 D iskPie1 加速键列表的一部分，它包括对应于 Memory 命令的Ctrl+M ，以及从 C 到 Z 的 24 个键。这些字母键表示磁盘驱动器，作为 D iskPie1 在运行时添加到 Chart 菜单的 Disk 命令的加速键。因为磁盘驱动器（包括远程驱动器）可以指定最多到 Z 的任何字母，所以， D iskPie1.rc 必须在加速键表里包括所有可能的加速键。当程序运行时，这不会造成任何麻烦，因为 D iskPie1 忽略不与已有的驱动器相对应的按键。

致谢 - 图84

图 4-8 Visual C++ 加速器编辑器创建 DiskPie1 的加速器表

要添加一个加速键到表中，双击新项框 ( 它以一个点框显示），来打开 Accel Properties 对话框，然后输入加速键和它的标识符。例如，在 Key 控件里和在 ID 控件里的 IDM_MEMORY 中输入 M ，为 D iskPie1 的 M emory 命令添加 Ctrl+M 加速键。在菜单编辑器里给 Ctrl+M 加速键指定同 Memory 命令相同的标识符，我

们保证在 D iskPie1 里按下 Ctrl+M 和从 Chart 菜单里选择 M emory 命令具有相同的效果。在任何一种情况下，会调用相同的过程，以显示表示内存使用状况的饼图。

对应于 D iskPie1 的 D isk 命令的加速键都有像 IDM_DISK_C 、IDM_DISK_D 等的标识符。注意，在图 4-8 里，这些加速键没有一个是同其他的键（像 Ctrl 或 Shift ）进行组合，这样就允许用户仅仅按下一个字母键，例如 C 或 D ，来显示 C 或 D 磁盘的使用状况饼图。要为一个加速键设置或移去一个组合键，在 Accel Properties 对话框里的 Modifiers 域选定或不选定 Ctrl， Alt 或 Shift 复选框。

在加速键编辑器里，从表里移去加速键是很容易的 :仅仅选择表里的条目，然后按下 Delete 键。要选择一批条目，单击这些条目中的第一个条目，然后按下 Shift 键，并单击最后一个条目。在表中添加名称是比较麻烦的工作，特别是如果要添加一大批键的时候。对于有连续名字的符号标识符，例如那些在 D iskPie1 表中的，使用兼容宏的文本编辑器有时会更方便。如果你使用一个文本编辑器在 RC 文件里创建加速键表，那么，记住在 Resource.h 文件里添加适当的定义。如果一个加速键对应于一个菜单命令，要记住，也需要给加速键同菜单项相同的标识符。

当在加速键编辑器里添加一组具有相近名字（例如 IDM_DISK_C 直到IDM_DISK_Z ）的加速键时，可以利用剪贴板。完整地输入第一个条目，从列表里选择它，然后按下 Ctrl+C ，把它拷贝到 Windows 剪贴板，然后重复按 Ctrl+V ，

粘贴一系列的副本到加速键编辑器里。接着，双击第一个条目打开 Accel Properties 对话框，然后单击图钉按钮，以便对话框保留在屏幕上。你可以下移此列表选择条目，并按需要修改标识符名字和键。

单击 File 菜单上的 Save 来保存新的加速键表。编辑器给这个资源提供标识符，如 IDR_ACCELERATOR1 ，你可以从 Workspac e（工作空间）窗口的 ResourceView

（资源查看）窗格中看到。对于 D iskPie1 来说，这不是令人满意的名字，出于相同的原因， IDR_MAINFRAME1 对菜单资源来说也不令人满意。右击ResourceView （资源查看）窗格里的标识符，并单击弹出的上下文菜单里的Properties ，然后将资源的符号名字改为 IDR_MAINFRAM E，如图 4-9 所示。它与以前给菜单资源的名字相同。

致谢 - 图85

图 4-9 为加速键表更改标识符名

再次选择 Sav e（保存）命令，来为加速键表设置新的 IDR_MAINFRAME 标识符。在更新的 DiskPie1.rc 文件里，如下代码段显示了加速键表目前的样子：

IDR_MAINFRAME ACCELERATORS DISCARDABLE

BEGIN

"C",	IDM_DISK_C,	VIRTKEY, NOINVERT
"D",	IDM_DISK_D,	VIRTKEY, NOINVERT
"E", . .	IDM_DISK_E,	VIRTKEY, NOINVERT
. ."X",	IDM_DISK_X,	VIRTKEY, NOINVERT

"D",

IDM_DISK_D,

VIRTKEY, NOINVERT

"E",

IDM_DISK_E,

VIRTKEY, NOINVERT

."X",

IDM_DISK_X,

VIRTKEY, NOINVERT

	续表
"Y",	IDM_DISK_Y,	VIRTKEY,
		NOINVERT
"Z",	IDM_DISK_Z,	VIRTKEY, NOINVERT

END

D iskPie1 的 Resource.h 文件包含了与这些标识符相应的定义：

#define IDM_MEMORY 130

#define IDM_DISK_C 131

#define IDM_DISK_D 132

#define IDM_DISK_E 133

#define IDM_DISK_X 152

#define IDM_DISK_Y 153

#define IDM_DISK_Z 154

IDM_DISK 标识符的实际值是什么无所谓，但是，有两个理由应当保持这些值连续。第一，从 IDM_DISK_C 到 IDM_DISK_Z 之间使用连续值，便可以在 D iskPie1 里用单一的过程处理所有的菜单命令，或者，通过使用 MFC 的ON_COMMAND_RANGE 宏，来处理从 C 到 Z 之间的加速键。当我们开始添加代码到 D iskPie1 中时，我们略去了细节。第二个使用连续标识符值的理由是，它与 Windows 装载包含在一个程序资源数据里的字符串有关。那是下一节的内容。

字符串资源和状态栏

当用户加亮一个菜单上的命令时，D iskPie1 显示了在窗口左下角状态栏里的命令描述。当鼠标滑过工具栏上的按钮时，将发生同样的事情。这些描述是字符串资源那样的程序数据，它们是以文本形式保存在可执行程序的资源部分中。一个W indows 程序可以保存任何种类的只读文本作为字符串资源，状态栏的描述文本

只是一个例子。

这一节以字符串资源的一般性讨论开始，接着，缩小它的范围，来看看状态栏描述文本。最后，介绍以使用 Visual C++ 字符串编辑器写 D iskPie1 的状态栏描述文本。

字符串资源

字符串资源同程序数据里其他字符串没有什么不同，只是它必须从可执行的文件读到缓冲区中。C 程序通过调用 LoadString API 函数读取字符串资源，MFC 程序可以调用 CString 类的 LoadString 成员函数读取。并且，至少在状态栏描述文本的情况下， MFC 程序甚至还不必做这些。 MFC 提供了默认代码，可以自动加载描述字符串，我们在后面将看到这点。

字符串资源是在程序 RC 文件里的字符串表里定义的，它是用 STRINGTABLE

键标识的字符串列表，并用 BEGING-END 语句或大括号括在一起：

STRINGTABLE

{

ID_STRING1 “ Text for string resource #1 ”

ID_STRING2 “ Text for string resource #2 ”

}

在 Win32 里，字符串资源被限制在 4096 个字符之内，并在资源脚本里只能占一个独立的行。一个 RC 文件可以有多个字符串表，每一个表有任何多个字符串。

与一般的数据字符串相比，字符串资源具有两种主要的优点。第一，字符串资源只在需要时才加载到内存中，并允许程序“ 脱机 ”保存可能从不使用的文本数据。考虑一个向用户显示帮助提示的程序，它可能在消息框里显示。虽然很多用户可能会喜欢这个特征，但是，其他用户可能不需要它，并快速关闭这个选项。通过将提示以字符串资源的形式保存，程序在每次运行时，不会因不使用的文本而浪费内存。字符串的第二个优点是，通过将程序的字符串组织成资源，开发者将字符串保存在一个地方，而不是零散地放置在几个资源模块中。同其他优点相比，这样，翻译人员只修改 RC 文件中的脚本，便可以创建一个外国语言的版本，修改完之后，开发者可以重新编译和链接，而不需要接触程序源代码。

你可以通过文本编辑器或者 Visual C++ 字符串编辑器，在 RC 文件添加或修改字符串资源，如果改变了一个字符串标识符的名字，那么，字符串编辑器还可以自动为新的标识符添加定义到 Resource.h 文件中。然而，字符串编辑器没有在源代码里放置新的标识符来代替旧的标识符。

提示字符串和工具提示

状态栏里的命令描述（又名提示字符串或定点描述）迅速成为 W indows 应用程序的标准过程。对其简洁的菜单命令，以及抽象艺术形式的令人难以理解的工具栏按钮，由于它们几乎没有提供有关其功能的线索，我们都曾经感到困惑。你可以在状态栏里仔细浏览，那里有提示字符串，使新用户不再需要有经验的用户的帮助。

好在要显示提示字符串，在程序中并不需要做很多工作。你通过给所有三个元素相同的资源标识符，便可以将一个提示字符串绑定到一个指定的菜单命令和工具栏按钮上。接着，创建一个状态栏，并添加 CBRS_FLYBY 标记到工具栏风格里。MFC 处理其余的工作，当一个菜单命令处于高亮状态，或鼠标光标停在一个工具栏按钮上时，便会显示正确的字符串。

添加 CBRS_TOOLTIPS 标记到工具栏风格里，可以生成工具提示，这是提示字符串的变种。工具提示是一个小弹出窗口，当鼠标光标从一个工具栏按钮上移过时，它显示简要的描述信息。 Visual C++ 环境使用工具提示来标识它自己的工具栏按钮，可是，这个特征是可选的（要在 Visual C++ 中打开工具提示，通过单击

Tool（s

工具）菜单上的 Customize 打开 Customi z（e

自定义）对话框，再打开 Toolbars

选项卡里的 Show ToolTip s（显示工具提示）复选框。工具提示文本是提示字符串的一部分，像下面这样，在字符串结尾添加一个 \n 换行字符：

ID_PROMPT1 “ Prompt string text in the status bar \nTooltip tex t”

这里是一个简单的例子，它描述了菜单、工具栏、提示字符串和工具提示之间的关系。虽然接下来的代码段描述了一个只打开和保存文档的 MFC 程序，但是，用黑体字显示的相关步骤也同样可应用程序于非 MFC 程序。

给 R C 资源脚本文件里的相应菜单项、工具栏和提示字符串相同的标识符

IDR_MAINFRAME MENU BEGIN

POPUP “ &File ” BEGIN

MENUITEM “ &Open ” , ID_FILE_OPEN

MENUITEM “ &Save ” , ID_FILE_SAVE

END

IDR_MAINFRAME BITMAP “ res\\Toolbar.bm p” IDR_MAINFRAME TOOLBAR 16, 15

BEGIN

BUTTON ID_FILE_OPEN BUTTON ID_FILE_SAVE

END STRINGTABLE BEGIN

ID_FILE_OPEN “ Open an exitsting document\nOpen ” ID_FILE_SAVE “ Save the active document\nSave”

END

在源代码里创建菜单

要用一步过程创建主窗口，并配上菜单，需调用 CFrameWnd::Create 成员函数：

Create(NULL ,” Simple Dem o” , WS_OVERLAPPEDWINDOW, rectDefault, NULL,

MAKEINT RESOURCE (IDR_MAINFRAME));

或者，在创建主窗口后，使用此代码来单独加载菜单。Cmenu menu; menu.LoadMenu(IDR_MAINFRAME); SetMenu(&menu);

menu.Detach();

创建工具栏

CToolBar toolbar; //In the header file

//Style defaults to W S_CHILD | WS_VISIBLE | CBRS_TOP

toolbar.Create(this); toolbar.LoadToolBar(IDR_MAINFRAME);

//Add flyby and tooltip flags to style toolbar.SetBarStyle(toolbar.GetBarStyle()|CBRS_FLYBY|CBRS_TOOLTIPS);

创建并初始化状态栏

CstatusBar statusbar; //In the header file UINT nIndicator=ID_SEPARATOR; //Single pane in status bar statusbar.Create(this);

statusbar.SetIndicators(&nIndicator,1);

AppWizard 生成相似的代码，为你做所有这些工作。你只需要打开字符串编辑器，并移去不需要的字符串资源，用描述程序里新菜单命令的字符串代替它们，但是，首先将遇到一个或更多的字符串资源。

文档字符串

当我们完成 DiskPie1 时，它将有六个程序资源，每一个都用 IDR_MAINFRAME

标识符进行标记：

应用程序图标
主窗口的菜单
菜单的加速键表
工具栏窗口
工具栏位图
表示文档的字符串资源

列表里的最后一项叫做文档字符串，它由 7 个子串组成，它们通过 \n 换行符分开。当在 AppWizard 里创建一个 SDI 或 M D I 项目时，你可以通过单击在 AppWizard 第四个步骤里的 Advance 按钮，来预先查看文档字符串的 7 个子字符串元素

（ Advance 按钮是在第 2 章里描述的）。单击这个按钮显示 Advanced Option s（高级选项）对话框，如果你想改变它们，那么，可以在这里重新输入项目的默认子字符串。

如果我们使用 AppWizard 创建 D iskPie1 ，那么，AppWizard 将在 DiskPie1.rc 文件里像这样重新输入一个默认的文档字符串：

STRINGTABLE PRELOAD DISCARDABLE BEGIN -

IDR_MAINFRAME “ DiskPie1\n\nDiskPie1\n\n\nDiskPie1.Document\nDiskPie1 Document”

END

像其他字符串资源一样，文档字符串必须在 RC 文件里以单行显示，但是，由于空间的原因，在上面以两行显示。子字符串包含 MFC 指定给程序和它创建的文档的文本和名字。按显示的顺序，这些子字符串指定：

在主窗口标题栏上显示的程序名。
指定给程序创建的新文档名。
在 MDI 应用程序里使用的文档描述，它可以打开同一

类型的多个文档。
以常规表达式文件形式组合的文档描述，就如同显示

在 Open 和 Save A s（另存为）对话框的文件类型列表一样。
给程序创建的文档的默认扩展名。
在系统注册表里表示文档类型的名字。
对程序创建的文档类型的描述。

由于 D iskPie1 并不创建文档，所以，我们对文档字符串感兴趣只是因为第二个子字符串。当这个子字符串为空时， MFC 给出新文档一个叫做 “ Untitld ” 的默认名字。你可能已经注意到，通过 AppWizard 创建的程序经常在它们的标题栏里带有 “ Untitled ” 文件名。对于像 D iskPie1 这样不需要存储它的数据的程序，调用它的“ U titled ”显示，只能使用户感到混乱。一个解决办法是提供描述程序（而不是文档）的第二个子字符串的文本，像 “ D isk Usage ”。详见下一节介绍。

为 DiksPie1 创建字符串资源

在 RC 脚本文件里已经有一个字符串表的 AppWizard 项目，通过双击 Worksapce 窗口 ResourceView （资源查看）窗格里的 String Table 打开字符串编辑器。要为一个像 D iskPie1 这样的项目建一个新的字符串表，从 Insert 菜单里选择Resource ，然后双击 Resource Type（资源类型）列表里的 String Table 。

字符串编辑器同字符串本身一样普通。唯一有趣的部分是在编辑器窗口的水平线，你可以在图 4-10 看到。这些线是字符串表里的分隔线，介于 “ 段 ” 的字符

串组之间，每段最多有 16 个字符串。字符串标识符的值决定了字符串属于哪一个段。标识符的值在 0 到 15 之间的字符串属于第一个段，标识符值在 16 到 31 之间的字符串属于第二个段，如此类推。

有时，一个段可以作为预读缓冲区，在许多磁盘驱动器上都有这种缓冲区，在预读缓冲里，磁盘控制器不仅读取需要的磁盘上的扇区，而且同时读取许多连续的扇区，把它们储存在一个内存缓冲区里，以备以后使用。预读缓冲区加快了磁盘使用的速度，因为一次磁盘操作通常会伴随有更多的磁盘操作，这时，控制器可以读取缓冲区的内容，而不是磁盘中的内容。用同样的逻辑，系统从可执行文件里一次读取一个段的字符串资源。当一个程序 LoadString API 函数从它的资源数据里读取独立的字符串时，W indows 读取字符串所属的那个完整的段，如果程序现在想要一个字符串，那么它将很快会要求其他的字符串。出于这个原因，你应该尝试通过给字符串连续的标识符值将相关的字符串分组。你可能已经这样做了，但现在你知道了这样做的原因。

致谢 - 图86

图 4-10 Visual C++ String 编辑器

同其他 Visual C++ 资源编辑器一样，字符串编辑器通过显示一个以点框表示的新项框指出表中下一个字符串的位置。要输入一个新的字符串，可选择新项框，然后开始输入字符串文本。String Properties 对话框显示一个默认的字符标识符。如果你需要，那么重新写标识符的名字，或从对话框组合框的下拉列表里选择一个名字。这个列表包含了为这个项目定义的所有标识符，包括那些在 A fxres.h 文件

里的标识符，它允许你选择一个名字，例如 IDM_MEMORY ，而不是输入它。字符串编辑器自动用标识符的值来对表里的条目排序。

通过输入表 4-2 里的转义字符，可以将字符同字符串分开。此表涉及到 ASCII

和 ANSI 值的列表，请参阅附录 A 。

表 4-2 在字符串资源中特殊字符的转义序列转义序列意义

\n 新行（ ASCII 值 #10 ）

\r 回车（ ASCII 值 #13 ）

续表

\t 制表符（ ASCII 值 #9 ）

\a 响铃字符（ ASCII 值 #7 ）

\\ 反斜线（ \）

\ddd 任何 ANSI 字符，其中 ddd 是一个 8 位字节数字，范围从 001 到 377(10 进制数 255)，用于标识字符

D iskPie1.rc 文件里的字符串表包含程序所有的字符串资源：

STRINGTABLE DISCARDABLE BEGIN

IDR_MAINFRAME "DiskPie1\nDisk Usage\n\n\n\n\n\n" IDM_MEMORY "Memory usage\nMemory"

IDM_DISK_C "Usage for drive C\nDrive C"

IDM_DISK_D "Usage for drive D\nDrive D"

IDM_DISK_E "Usage for drive E\nDrive E"

IDM_DISK_X "Usage for drive X\nDrive X"

IDM_DISK_Y "Usage for drive Y\nDrive Y"

IDM_DISK_Z "Usage for drive Z\nDrive Z" AFX_IDS_IDLEMESSAGE "Ready"

AFX_IDS_SCSIZE "Change the window size"

AFX_IDS_SCMOVE "Change the window position" AFX_IDS_SCMINIMIZE "Reduce the window to an icon" AFX_IDS_SCMAXIMIZE "Enlarge the window to full size"

AFX_IDS_SCCLOSE "Close the DiskPie1 application" AFX_IDS_SCRESTORE "Restore the window to normal size"

END

列表里的第一个字符串是 DiskPie1 的文档字符串，它同程序的其他资源有相同的标识符：

IDR_MAINFRAME “ DiskPie1\nDisk Usage\n\n\n\n\n\n ”

这个指定的文本代替“ Untitled ” 标题，否则， MFC 将会把 “ Untitled ” 写在标题栏中。注意一下图 4-20 里 D iskPie1 的标题文本，你将看到， MFC 怎样从文档字符串的前两个子串获取标题栏的文本。虽然这比仅仅删除资源行里的第二个子串更麻烦，但是，还会可能从标题栏里完整地移去 “ D isk Usage ”。你必须找到CMainFrame::PreCreateWindw 虚拟函数，清除 MFC 默认添加给窗口风格的FWS_ADDTOTITLE 标记：

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)

{

cs.style &=~FWS_ADDTOTITLE;

return CFrameWnd::PreCreateWindow(cs);

}

在字符串表里，最后的字符串有指定的 AFX_ 前缀标识符，它指示这些符号是在Afxres.h 文件中定义的。例如，当程序在等待用户输入时， MFC 认可AFX_IDS_IDLEMESSAGE 标识符，并在状态栏里显示被赋予的字符串值。为了方便起见，字符串只是读取“ Ready ”。其他的 AFX_ 符号为 DiskPie1 的系统菜单标识提示字符串，你可以通过单击程序的图标或右击标题栏来打开系统菜单。当用户从系统菜单里选择一项时，状态栏中将显示适当的 AFX _ 字符串。我们将看到，当我们在本章结尾写 DiskPie2 程序时，一般根本不需要包含这些提示字符串。

位图、工具栏、图标和光标

Visual C++ 图形编辑器是创建和修改程序的图形资源的地方，图形资源包括位图、工具栏、图标和光标。图标和光标是位图，用途很小。图标显示在任务栏按钮上或在目录列表里，光标就是为鼠标光标而设计的，当鼠标放置在程序的用户区域里时，它将提供服务。工具栏是包含几个位图图形的窗口，它在一个水平行中显示几个按钮。别的东西，例如，窗口里的图形，或对话框里的动态图片，均叫做位图。

Visual C++ 环境提供一个适用于所有场合的图形编辑器，所以，你不需要去学四种不同的用法。你可能看到在线帮助里的“ toolbar editor”或“ icon editor ” 参考，但是，这些只是意味着， Visual C++ 图形编辑器可以应用于任何一种特定类型的资源。图形编辑器可以处理不同资源类型的多个文档。图 4-11 显示了打开两种不同文档的编辑器，一个是我们所熟悉的 16 × 15 的位图，另一个是两色的 32 × 32 的鼠标光标。

对于每一种资源类型，编辑器的外观差别不大，文档窗口的左上角的图标指示你正在使用的资源类型。表 4-3 显示每一种资源文档对应的图标，并列出这个图形编辑器可以读写的文件类型的扩展名。

当使用 Open （打开）命令打开已有的资源文档，而且这个文档还具有表 4-3 第三列里的某个扩展名时， Visual C++ 自动打开图形编辑器，并调整自己，以适合这种资源类型。

表 4-3 图形编辑器图标和文件类型

资源图标输入文件类型输出文件类型

Bitmap	（	位	B M P,	DIB,	EPS,	GIF,	B M P
图）			JPG

致谢 - 图87 致谢 - 图88 Toolba r（工具栏）

致谢 - 图89 Cursor （光标）

B M P B M P

C U R CUR

致谢 - 图90 Icon （图标） ICO ICO

D iskPie1 有菜单、加速键和字符串数据，但还没有图形资源。对于 D iskPie11 这样的项目，可以用两种稍有不同的方法来创建一种新的图形资源。选择什么方法取决于你想象的这个图形文件是什么样子。如果打开一个项目，并想添加一个新的图形资源到项目中，从 Insert 菜单中选择 Resource ，并双击位图或光标，或者

是在列表里的工具栏。 Visual C++ 打开图形编辑器，在标题栏里显示为这种资源文档指定的标识符。根据资源类型的不同，标识符是像 IDB_BITMAP1 ， IDC_CURSOR1 ， IDI_ICON1 或 IDR_TOOLBAR1 这样的名字。以后在编辑器里打开的资源将得到相似的标识符，只是在数字上加 1 ，例如 IDI_ICON2 ， IDI_ICON3 等等。保存图形资源到文件中时， Visual C++ 给这个文件起的名字是标识符减去前缀，然后在项目的 Resource.h 文件里定义这个标识符。例如，要保存名为 IDB_BITMAP1 的资源，需添加如下一行到 RC 文件：

IDB_BITMAP1 BITMAP DISCARDABLE “ res\\bitmap1.bmp”

并添加下面一行到 Resource.h 文件里：

#define IDB_BITMAP1 130

然而，你没有必要接受这些没有什么特征的名字。在保存资源前，通过单击 View

（查看）菜单上的 Properties ，并输入一个新的标识符名字来给它提供一个描述性的标识符。在相同的 Properties 对话框里，也可以给这个图形文件指定一个名字。

致谢 - 图91

图 4-11 Visual C++ 图形编辑器具有两个打开的文档

在启动图形编辑器的第二种方法中，你可以创建一个新的图形资源，但不添加它到项目文件列表里。你可能想这样做，例如，创建一个资源库，或为工具栏按钮设计位图。这种方法不要求打开项目，只单击 File（文件）菜单上的 New ，并在File 选项卡里，从列表里选择你想要的资源类型： Bitmap File （位图文件）， Icon File （图标文件）或 Cursor File （光标文件）。

图形编辑器的工作区是分成两个窗口。默认状态下，左边窗口以图形的实际尺寸显示图形，右边窗口显示的图形放大到大约 36 （ 6 × 6 ）倍。放大的图形有一个覆盖形式的网格，网格中，每一个方块表示实际图形上的一个像素。如果你以前使用过画图程序，例如 Microsoft Windows 的 Paint 应用程序，那么，就会对 Visual C++ 图形编辑器很熟悉。

通过单击左边或右边窗口中的任何地方，来选择要绘制的图形。如果要处理细节，可以在大的工作区域里进行，并在实际尺寸图形窗口里观察效果。将两个窗口分割开的分隔条是可以移动，只要用鼠标向左或向右拖动它即可。要开始画图形，通过单击显示在图 4-12 里 Graphics 工具栏上的一个按钮，来选择一个合适的工具。与在 Visual C++ 环境里使用其他工具栏一样，你可以通过向内或向外拖动工具栏来缩小或放大它。

致谢 - 图92

图 4-12 Visual C++ 图形编辑器中的工具

图形编辑器工具很灵活，而且很友好，只需要几分钟就可以学会，然而，有几点可能看起来不那么直观，所以要简要讨论一下。首先，图形的背景颜色依赖于图形的类型。图标和光标只有一种透明的背景色，在编辑器窗口里用蓝绿色进行着色。当 W indows 在屏幕上画图标或光标时，它只画前景色，在透明背景色下的所有像素均不擦除。另一方面，位图的背景色是不透明的。一个位图在屏幕上是作为一块画出来的，它将覆盖它下面的任何东西。背景色是否透明，可能是这两种图形资源类型之间的最大区别。

当你单击 Rectangle Selection（矩形选择）， Irregular Selection （不规则图形选择）或 Text 按钮时，透明选择框显示在 Graphics 工具栏的底部，它也是编辑器 Image 菜单上 Draw Opaque （不透明画图）命令的工具栏版本。要理解选择框的用途，考虑一下一个分为两层的图形，一层覆盖在另一层上。上层是一个漂浮的图形，你可以移动，或设定它的位置。下面这一层叫做底层，是固定的。利用选择框，你可以设定顶层的背景透明度，但不能影响底层的透明度。选择透明度选择框的顶部图标，意味着覆盖图形层上的背景像素应该当作前景颜色，使上面的一层成为实心的矩形框。选择框的底部图标使上面一层透明，实际上，是从这一层移去背景像素。例如，下面是当打开或关闭透明度时，在底层图形上输入字母 “ A ” 时的外观：

致谢 - 图93

不管透明度的设定如何，底层位图图形的背景颜色（在当前情况下是白色）均保持不透明，以便在屏幕上显示的位图覆盖位图矩形区域内的任何像素。然而，当显示一个位图时，程序可以模拟透明的像素，首先掩盖位图的背景颜色，然后用位图将出现的屏幕区域的副本来替代它。如果你对这个技术感兴趣，完全可以从

Jeff Prosise ’ s Programming W indows 95 with MFC 里题为 “ Bitmap s， Palettes ， and Region s” 那章的透明化位图教程中，找到详细的说明。通常，你只是想确保一个位图与显示它的窗口拥有一样的背景颜色，以便得到一种透明的假象。有一种简单的方法可以实现这种操作，下一节将详细说明。

另一种图形编辑器的隐藏特征是，鼠标的左右按钮分别对应于前景色和背景色。例如，用鼠标左键单击 Colors 调色板上的一种颜色，来选择前景色，用鼠标右击选择背景色。你可以在图形上通过拖动或单击适当的鼠标按钮，来选择使用一种颜色画图。

表 4-4 总结了在图形编辑器里能够看到的工具栏按钮。如图 4-12 所示，在 G raphics 工具栏里，按钮是以平面方式显示的。表 4-4 显示了处于凸起状态下的按钮，这可以帮助我们区别每一个按钮。

图 4-4 Graphics 工具栏按钮

按钮说明

致谢 - 图94 利用 Rectangle Selection 和 Irregular Selection 工具，可以标记要移动、清除或复制的图像部分。单击按钮，然后，拖动交叉十字或光标，指向要标记的矩形或区域。在释放鼠标按钮时，在标记的区域周围将出现选择框。你可以移动选择内容，方法是使用鼠标拖动它；要清除它，则按 Del 键；复制它到剪贴板的方法是按 Ctrl+C

致谢 - 图95 利用 Select Colo r（取色）工具，可以从图像中选取颜色，而不是从 Colors 调色板中。单击工具栏上的按钮，然后单击要选取颜色的图像上的区域。使用鼠标左键可以选取前景色，使用鼠标右键可以选取背景色

续表

致谢 - 图96 Eras e（橡皮擦）工具将光标改为一个方块，可以在图像上拖动它，来擦除像素。擦除的像素改变为当前前景色，这要取决与当前的资源类型。前面提到过，在Colors 调色板的左上角，图标和光标的背景是不透明的颜色。要改变擦除块的大小，可以单击工具栏底部选择框中的一个尺寸图标

致谢 - 图97 Fil l（填充）工具将颜色的像素改变为当前的前景或背景色。单击 Fill 按钮，然后单击要改变的颜色中的任何地方。若使用鼠标左键，则填充前景色；使用鼠标右键则填充背景色。编辑器将更改此颜色的所有连续像素，来填充颜色。像素必须水平或垂直接触，以对角方式接触的像素被认为是不连续的

续表

致谢 - 图98 要改变所选择图形的大小，可以使用 M agnif y（放大）工具，并选择一个值 1 ， 2 ， 6 或 8 。放大值指定对应于实际图形中一个像素的实际像素数。如果放大的图形有网格，则放大值确定的是每个网格的宽度和高度

致谢 - 图99 单击左边的图片按钮，可以手绘图，然后，拖动鼠标按钮，以留下像素的轨迹，颜色是前景色或背景色。Pencil （铅笔）工具只画出一个像素宽的细线。使用Brus h（刷子）可以画出粗线，在工具栏底部的选择框中可以选择刷子的宽度

致谢 - 图100 A ir Brush （喷雾）工具可以画出随机的颜色图案，模拟在画布上轻微喷射的效果。在工具栏的选择框中，可以选择喷射的密度和尺寸

续表

致谢 - 图101 画线工具可以画直线，还可以画曲线，曲线从初始位置开始弹性弯曲。单击要开始画线的位置，拖动光标到线的终点，然后释放鼠标键来确定此线。 Curve 工具还额外需要一个步骤：在释放鼠标键设置终点后，移动光标来设置曲线的曲率。在曲线以自己需要的方式成形后，双击便可以确定曲线（双击的鼠标键必须与拖动光标的鼠标键相同）。如果在画线的过程中改变了主意，可以按 Esc ，或者单击另一个鼠标键，来重新开始

续表

致谢 - 图102 致谢 - 图103 Text（文本）工具显示一个小窗口，可以从中输入在图形中出现的文字，所用的颜色是当前的前景色。如前所述，在透明选择框中选择文字的透明性，然后，在选择完 Text 工具时，按 Esc 键

这些工具可以画矩形、圆角矩形和椭圆形，这些图形可以是实心的，也可以是空心的。选择一个工具，然后，以前景色或背景色来画出形状，方法是在图形上，从左上角向右下角拖动鼠标光标。按下 Shift 键可以强制画出某种形状，使矩形画为正方形，或者将椭圆画为圆形。在拖动光标的过程中，如果要取消操作，可以按 Esc ，或者单击另一个鼠标键

位图

在为一个新的位图打开图形编辑器时，它提供一个边长为 48 像素的正方形的干净区域。然而，位图不要求一定是正方形，它们可以是边长不大于 2048 个像素的任何尺寸的矩形。要调整工作区域的大小，拖动工作区域边界上一个调整大小的手柄，在拖动手柄的同时，注意一下编辑器状态栏里的新尺寸。也可以通过单

击 View （查看）菜单上的 Properties 打开 Bitmap Propertie s（位图属性）对话框，从中输入想得到的大小。

这里是一个 C 程序如何显示位图资源的例子。此代码段假设位图最初是保存在文件 Res\Bitmap.bmp 里，并在程序的 RC 文件里，通过 BitmapDemo 名进行标识， LoadBitmap 函数用和名字相同的字符串加载资源。

// Resource declaration in the RC file

BitmapDemo BITMAP “ res\\bitmap.bm p”

// In the C source file

HBITMAP hbm; // Declare a globa handle for the bitmap

// Load the bitmap in WinMain or the InitInstance procedure static char szAppName [ ] = “ BitmapDemo ” ;

hbm = LoadBitmap( hInstance, szAppName);

// Display the bitmap in the window procedure case WM_PAINT:

hdc = BeginPaint( hwnd, &ps ) ’

hdcMemory = CreateCompatibleDC( hdc ); GetObject ( hbm, sizeof (BITAMP),&bm); SelectObject( hdcMemory, hbm);

BitBlt( hdc, x, y, bm.bmWidth, bm.bmHeight, hdcMemory, 0, 0, SRCCOPY ) ’

DeleteDC( hdcMemory);

EndPaint( hwnd,&ps); break;

在 MFC 程序里，显示这个位图的步骤是相似的。首先，用资源初始化一个 CBitmap

对象：

bitmap.LoadBitmap(szAppName);

然后，在窗口的 OnDraw 函数里显示这个位图：

BITMAP bm;

CDC dcMemory;

bitmap.GetObject( sizeof (BITMAP), &bm ); dcMemory.CreateCompatibleDC( Pdc ); dcMemory.SelectObject( &bitmap );

PDc->BitBlt ( x, y, bm.bmWidth, bm.bmHeight, &dcMemory, 0, 0, SRCCOPY );

在结束这一节中有关位图的说明之前，让我们再次看一下，上一次讨论的有关位

图透明性的题目。我们已经知道，位图的背景色是不透明的，但是，如果这个位图的背景色是白色，而且，这个位图将显示在一个背景色也是白色的窗口里，那么，这个位图的正方形形状会被掩盖。如果给出透明背景色的设想，那么，只有不是白色的前景色可以显示出来。当时，如果窗口的背景色不是白色的，将是什么样的呢？在那种情况下，在先前代码段里显示的位图将暴露出它的正方形外形，这可能不是你想要的效果。

应用程序窗口一般采用标识为 COLOR_WINDOW 的系统窗口颜色，默认状态下，它是白色的。然而，一个程序可以通过调用 SetSysColors 来改变系统窗口的颜色，或者，用户可以在 W indows Control Panel 里的 D isplay（显示）部分改变

颜色（如果想试一试，那么，在 D isplay Properti e（s 显示属性）对话框，从 Appearance

（外观）选项卡上的 Item 组合框里选择 W indow ，从 Color 下拉列表里选择一个新的颜色，然后单击 OK （确定））。通过使用 LoadImage API 函数，而不是LoadBitmap 函数，来装载位图，并像下面这样指定 LR_LOADTRANSPARENT 标记，程序可以保证位图的背景色总是同 COLOR_WINDOW 颜色一致：

hbm=LoadImage( hInstance,szAppName,IMAGE_BITMAP,

0,0,LR_LOADTRANSPARENT);

这个函数查看图像里的第一个像素的颜色，它处于矩形位图的左上角，推测起来，应该是背景的一部分。然后， LoadImage 函数用当前的 COLOR_WINDOW 颜色来代替位图颜色表里相应的条目。这样，在这个位图里组成背景的所有像素

都用默认的窗口颜色显示。唯一的警告是，如果位图有 256 多种颜色，那么

LR_LOADTRANSPARENT 将不起作用。

我们还没有完全使用 LoadImage 函数。正如我们将在下一节中看到的那样，这个函数也可以装载图标。但是现在，让我们看一下位图怎样成为工具栏。

工具栏

在 Visual C++ 中创建工具栏，只不过是设计包含工具栏按钮图形的位图。这个位图作为一个 B M P 文件保存，并在项目的 RC 文件里用一个标识符名字引用它：

IDR_TOOLBAR BITMAP “ res\\toolsbar.bm p”

标识符的名字和文件名都由你决定。D iskPie1 用 IDR_MAINFRAME 命名它的工具栏，同程序的其他资源保持一致，如前所述，允许调用到 CSingleDocTemple 构造器。

工具栏位图是一系列覆盖工具栏按钮的图形，每一个按钮都有一个图形。默认状态下，每一个图形都是 16 个像素宽， 15 个像素高，它适合标准的 24 个像素、宽 22 个像素高的工具栏按钮。通过以典型的 W indows 方式拖动编辑器工作空间的边界，可以设置一个图形的尺寸是大一点，还是小一点，是宽一点，还是窄一点。由于你不能使一个工具栏里按钮具有不同的尺寸，所以，新尺寸将应用于所

有的工具栏图形。当保存工作时， Visual C++ 自动指定 RC 文件里工具栏按钮的新尺寸。

如果 AppWizard 为你生成项目，那么，它在项目的 Res 文件夹中创建一个叫做Toolbar.bmp 的文件。这个文件包含对应于命令 New ， Open ， Save ， Cu t， Copy ， Paste ， Print 和 Help 的工具栏按钮的图形。图 4-13 是在 Toolbar.bmp 里放大的位图和最终的工具栏。

致谢 - 图104

图 4-13 AppWizard 生成的默认工具栏

在下一段代码中，显示了 AppWizard 项目中 RC 文件的创建工具栏的脚本。工具栏脚本里的每一个按钮，都具有对应于本章“ 菜单和加速键 ” 一节脚本里列出的菜单命令的相同标识符。

IDR_MAINFRAME BITMAP MOVEABLE PURE

“ res\\Toolbar.bm p”

IDR_MAINFRAME TOOLBAR DISCARDABLE 16, 15

BEGIN

BUTTON ID_FILE_NEW

BUTTON ID_FILE_OPEN

BUTTON ID_FILE_SAVE SEPARATOR

BUTTON ID_EDIT_CUT

BUTTON ID_ EDIT_COPY

BUTTON ID_ EDIT _PASTE SEPARATOR

BUTTON ID_ FILE_PRINT

BUTTON ID_ APP_ABOUT

END

脚本里的 BITMAP 语句指向保存位图的项目的 Toolbar.bmp 文件。 TOOLBAR 语句用 IDR_MAINFRAME 值标识工具栏资源，并为每个按钮指定尺寸为 16 × 15 个像素的图形。 SEPARATOR 语句使得邻近按钮之间有些空隙，它是通过BUTTON 语句定义的。

MFC 程序通过调用 CToolBar::Create 来创建工具栏。当函数返回时，它创建的工具栏只不过是一个空的子窗口。下一步是调用 CToolBar::LoadToolBar 函数，来读

取工具栏按钮数据，装载工具栏位图，并画出这些按钮，所有这些都在一步内完成。

窗口为每一个在工具栏脚本里的 BUTTON 语句提供一个空按钮，并在每个按钮上画出一个对应的位图图形区。例如，要装载在上面脚本里定义的工具栏，程序可以声明一个 CToolBar 对象，叫做 m_toolbar，并在资源里包含这些行：

m_toolbar.Create( this ); // Create the toolbar window m_toolbar.LoadToolBar ( IDR_MAINFRAME ); // Load the bitmap images

在 Visual C++ 里，有两种方法可以从头开始创建一个工具栏。第一个方法是我们

很熟悉的：在一个打开的项目里，单击 Insert 菜单上的 Resource ，并双击在Resource Type 列表里的 Toolbar。这将启动图形编辑器，以便对工具栏进行改变，在图 4-14 里，图形编辑器显示了三个分割的窗口。底部的两个窗口显示了你正在工作的当前工具栏按钮的实际尺寸，以及放大尺寸的视图，上部的窗口显示了一个工具栏的完整视图。开始在一个按钮上工作时，按钮图形自动显示在工具栏视图里，在你编辑时，实时改变按钮显示。当完成了一个按钮时，单击上面窗口里空的新项目按钮，为下一个按钮刷新工作区域。你可以在工具栏里拖动它，以改变按钮的位置，或把它完全拉离工具栏，以便删除按钮。要在如图 4-14 里所示的按钮之间添加分割空隙，向左或向右拖动一个按钮到大约半个按钮宽度就可以了。你可以用同样的方法去掉这个空隙。

致谢 - 图105

图 4-14 在 Visual C++ 图形编辑器中创建工具栏

保存工具栏时，不要担心空的项目按钮会一起保存。在编辑器写到 RC 文件里的工具栏脚本里，不会包括空的项目按钮。当在一个程序的主工具栏中工作时，应当给每一个按钮同菜单项对应的相同标识符，例如 ID_FILE_NEW 或ID_FILE_PRINT 。在 Toolbar Button Properties （工具栏按钮属性）对话框里输入

按钮的标识符，通过在工作区域里的任何地方双击鼠标，或通过从 View （查看）菜单上选择 Propertie s，来显示上述对话框。

在创建工具栏的第二种方法中，要求先设计位图图形，然后，将得到的结果转化为工具栏。对于 D iskPie1 ，这种方法更加方便些。

为 DiskPie1 创建工具栏

D iskPie1 是与众不同的，它在运行时决定需要的工具栏按钮，以及它们对应的图形的个数。在 D iskPie1.rc 文件里，工具栏脚本只有一个入口：

IDR_MAINFRAME TOOLBAR 16, 15 BEGIN

BUTTON IDM_MEMORY

END

在程序启动时，便添加了为磁盘驱动器显示使用状况饼图的按钮。例如，如果D iskPie1 找到了四个磁盘驱动器，分别指定为 C ， D ， P 和 R ，那么，在它创建工具栏时，它指定五个按钮：一个对应于 Memory 命令，其余四个对应于四个磁

盘驱动器。由于在 D iskPie1 运行之前，没有办法知道系统中运行着多少个磁盘驱动器，所以， DiskPie1 的工具栏位图有 24 个不同磁盘驱动器的按钮图形，它们分别以 C 到 Z 标记。由于这 25 个图形都是 16 个像素宽，所以， D iskPie1 完整的工具栏位图是 400 个像素宽、 15 个像素高。在图 4-15 中，可以看到一些按钮图形的特写视图。

致谢 - 图106

图 4-15 DiskPie1 的工具栏位图

可以看到，生成位图并不是十分困难，只用了大约 20 分钟的时间。这个秘密就是，告诉图形编辑器你正在创建一个位图，而不是一个工具栏。第一步在下列两种情况下是一样的：通过单击 Insert 菜单上的 Resource，来打开图形编辑器。为了用重复的图形加宽如图 4-15 所示的位图，从资源类型列表里选择 Bitmap ，而不是 Toolbar。这将可以在一个连续的条中操作按钮图形，而单独操作每个按钮。在图形编辑器里，将普通位图转换为工具栏是很容易的，设计它就是做这个的。

这里是使用重复图形生成加宽的位图的步骤。双击编辑器工作区域的空白区域的任何地方，打开 Bitmap Properties 对话框。输入工具栏标识符，对于 D iskPie1 ，

是 IDR_MAINFRAM E ，并给 B M P 文件起一个文件名。通过增加按钮的数目，来增加一个工具栏按钮的宽度，并输入这个数字作为位图的宽度。位图的高度是一个按钮的高度。对于 DiskPie1 ，对话框看起来像这样：

致谢 - 图107

按下 Enter 键返回工作区域，现在它有了新的尺寸。下一步，用亮灰色画出整个工作区域，以便每一个图形能和它的按钮相融合。在 Color 调色板里单击亮灰色框，并选择 Graphics 工具栏里的 Fill 工具。

致谢 - 图108

单击工作区域格子里的任何地方，来用亮灰色画整个区域。现在，在工作区域里的一个 16 × 15 的块里，画第一个按钮的图形（或是任何的按钮尺寸）。一旦已经画出第一个图形，就可以通过单击 Rectangle Selection 工具来复制它，并在图形的 16 × 15 方块上拖动光标。是用鼠标左键，还是用右键拖动，取决于你是移动这个位图，还是拷贝它。如果想移动图形到位图工作区域的其他地方，那么使用鼠标左键。当你释放鼠标按钮时，在图形的周围出现一个选择框，此时可以拖动它来重新定位选择区域。按下 Ctrl 键拖动选择框，便移动了被选择图形的一个副本，而不是图形本身，但是，有一种更好的方法来复制图形。

要生成一个图形的副本，需单击 Rectangle Selection （选择）工具，并用按下鼠标右键（而不是鼠标左键）来选择图形。释放鼠标按钮时，被选择图形的一个副

本将跟随鼠标光标而移动。将副本定位在工作区域的任何地方，并单击，将它放置在选择的位置上。单击左键将放下图形的一个副本，单击右键将放下图形的遮罩，其中，前景像素转化为当前图形的背景颜色，图形里的背景像素被当作透明的小洞。你可以用这种方法生成任何数量的副本。完成操作时，按下 ESC 键，或选择另一个工具来返回一般编辑模式。

你将发现图形横越整个 16 × 15 方块，像图 4-16 里的磁盘驱动器图形一样，那么定位它将更加容易。如果图形比方块窄，那么在方块的顶部或底部画一条 16 个像素宽的临时黑线。然后，当你拷贝图形时，就可以准确看到正在拖动什么。如果你打算使用文本标记每一个按钮，像图 4-15 里所做的那样，那么，最后，在所有的图形都到位后，将添加标记。单击 Text 工具，输入文字，并拖动文字图形到指定位置。在做完每一个文字之后，按下 ESC 键取消 Text 工具。

致谢 - 图109

图 4-16 复制选择的图形

完成了位图的设计时，单击 Image 菜单上的 Toolbar Editor，来转化位图到一个工具栏上，在 New Toolbar Resource （新工具栏资源）对话框里，接受建议的 16 × 15 的按钮尺寸。你可以使用相同的 Toolbar Editor 命令，在工具栏和位图之间来回转换。单击 File（文件）菜单上的 Sav e（保存）命令，将新的工具栏脚本写到RC 文件里，并将工具栏位图保存成在前面 Bitmap Properties 对话框里命名的B M P 文件。 Visual C++ 为新工具栏脚本中的按钮指定默认的标识符值，现在，在D iskPie1.rc 文件里，它们看起来像下面这样：

IDR_MAINFRAME TOOLBAR DISCARDABLE 16, 15 BEGIN

BUTTON ID_BUTTON40030 BUTTON ID_BUTTON40031

BUTTON ID_BUTTON40032

. END

按钮标识符最终必须改成同对应菜单命令的标识符相同的标识符，即IDM_MEMORY ， IDM_DISK_C ， IDM_DISK_D 等等。这将保证单击一个工具栏按钮有同选择相应菜单命令相同的效果。我们应该使用 Toolbar Button Properties 对话框，在图形编辑器里具有指定的正确按钮标识符，调用这个对话框的方法是选择一个按钮，并双击工作区域的任何地方。但是，这没有什么必要。当 D iskPie1 确定运行时必须在工具栏上显示多少按钮时， D iskPie1 给按钮指定正确的值。在后面，我们将编辑工具栏脚本，用在这节开头引用的简短的脚本来代替它，同时也从 Resource.h 文件中移去为按钮标识符定义的多余的 #define 语句。

图标

图标是特殊的位图，设计用来用图形方式表示程序或文档。一般情况下，图标指定给一个框架窗口，以便在窗口的标题栏里显示图形，当图标指定给程序的主窗口时，图标资源叫做程序图标或应用程序图标。本节集中讲述怎样创建应用程序图标，它是最普遍使用的一种图标资源。但是，不管图标是表示主窗口，还是屏幕上的另一个对象，图标不过就是图标，它是在 Visual C++ 图形编辑器里创建的，而且创建的方式相同。

个图标资源包含多个图形，它们经常是同样设计的不

同尺寸的图形。例如， M icrosoft 建议， W indows 程序提供给它图标资源的三个图形，每一个图形具有不同的尺寸：
- 一个边长为 16 个像素的正方形， 16 色图形， Windows
  
  将在程序的标题栏、任务栏和用小图标显示的目录列表里显示它。
- 边长为 32 个像素的正方形， 16 色图形，在 Abou t（关于
  
  ）对话框这样的对话框窗口里使用，或在桌面上表示程序，或在用大图标显示的目录列表里显示。
- 边长为 48 个像素的 256 色图形，在系统 D isplay
  
  Properties 对话框里，若选中 Effects（效果）选项卡里的 Use Large Ico n（使用大图标）选项

时，它在 Windows 98 里代替 32 × 32 图标（要打开这个对话框，在桌面空白区域按下鼠标右键，并选择 Properties 。 W indows 95 要求安装M icrosoft Plus! 包，在这种情况下，Use Large Icons 选项在对话框的 Plus! 选项卡里）。

你可以在 Explorer（资源管理器）窗口里看到大的和小的应用程序图标的例子，或在 Visual C++ 环境里通过打开 Save A s（另存为）或 Ope n（打开）对话框看到。在目录列表窗口的空白区域右击，并从上下文菜单的 View 命令中选择 Large Icon s（大图标）。同一个菜单里的 Small Icon s（小图标）命令显示 16 × 16 的图形。

在 W indows 编程中，应当使用具有独特魅力的图标，但这不是必须的。如果一个程序在它的资源里根本不包括任何图标，它仍可以使用在 W inuser.h 文件里的标准系统图标，像 IDI_APPLICATION 和 IDI_WINLOGO 。当系统图标处于 16

× 16 像素尺寸状态下，它们看起来像下面这样：

致谢 - 图110

在一个图标资源里封装的三个图形，可以将可执行文件的大小增加大约 5000 个字节。如果它看起来太大，便可以用一个单独的 16 × 16 或 32 × 32 图形创建一个图标，当用其他尺寸显示图标时， W indows 按适当的比例显示。然而，你可能对这个结果感到失望，因为曲线和斜线将产生边界粗糙的效果。

下一节显示怎样用 Visual C++ 图形编辑器创建一个图标，但是，首先让我们看一下程序怎样加载图标资源。通常， C 程序在它创建主程序窗口时加载应用程序图标。如果图标资源只包含一个图形尺寸，那么程序可以调用 LoadIcon API 函数

（在旧的 W indows 版本里使用的方法）。但是，要从相同的图标资源里加载多个图形，这个程序应该使用 LoadImage 函数代替前面的函数。由于使用旧版本的WNDCLASS 结构的 RegisterClass 函数只接受一个图标句柄，所以，程序也必须调用指向 WNDCLASSEX 结构的 RegisterClassEx 函数，为窗口类设定大的和小的图标。这里是一个加载两个图标图形的代码段，一个是边长为 16 个像素的正方形，另一个是边长为 32 个像素的正方形：

// Declare the icon in the .RC file

IconDemo ICON “ res\\appicon.ico ”

//In WinMain, initialize the WNDCLASSEX structure with image handles static char szAppName[]= ” IconDem o” ;

WNDCLASSEX wndclass; wndclass.cbSize = sizeof (wndclass);

wndclass.hIcon = LoadImage( nhInstance, szAppName,IMAGE_ICON,

32,32 LR_DEFAULTCOLOR );

wndclass.hIconSm = LoadImage(hInstance,szAppName,IMAGE_ICON,

16,16, LR_DEFAULTCOLOR );

RegisterClassEx( &wndclass );

MFC 程序不需要担心任何上面这种情况。 AppWizard 为项目提供两个图标，一个图标提供应用程序图标的功能，另一个表示应用程序创建的文档。 RC 文件用IDR_MAINFRAME 和 IDR_project_TYPE 标识图标资源，这里的 project 代表项目名。 AppWizard 保存图标，如下所示，在项目的 Res 文件夹里以 project.ico 和projectDoc.ico 表示：

致谢 - 图111

AppWizard 自动生成正确加载同程序的其他资源在一起的应用程序图标的代码。要使用你设计的图标来代替常规的 AppWizard 图标，需关闭项目的工作空间，并从 File（文件）菜单里选择 New 。双击在 File 选项卡里的 Icon File （图标文件）来打开图形编辑器，设计这个新图标，并把它保存在项目的 Res 文件夹里，重新覆盖已经存在的 project.ico 和 projectDoc.ico 文件。

如果你已经能够不使用 AppWizard 的帮助来写 MFC 程序，那么，加载应用程序的图标仍然是很简单的。如果主窗口类是来自 CFrameWnd ，那么，使用在 MFC 的 Afres.h 文件里定义的 AFX_IDI_STD_FRAME 值来标识 ICO 文件。例如，在项目的 RC 文件中，在名为 AppIcon.ico 文件里保存的图标资源按如下方式进行标识：

#include "afxres.h"

AFX_IDI_STD_FRAME ICON appicon.ico

如果窗口类来自 CMDIFrameWnd ，那么使用这一行代替上面这一行。

AFX_IDI_STD_MDIFRAME ICON appicon.ico

如果图标文件同时包含一个大的和一个小的图形，那么 MFC 加载这些图形，并把它们同窗口框架正确关联，以便小图形显示在标题栏上，大图形显示在 About

（关于）对话框里。如果你浏览 MFC 源代码，来学习有关这些工作的更多信息，那么你将看到 CWinApp::LoadIcon 并不像前面描述的那样调用 ::LoadImage 。相

反，它调用使用 RT_GROUP_ICON 值的 ::FindResource 函数，来从图标资源里加载所有的图形，然后搜索图形资源，来查找最符合所需要尺寸的图形。CWinApp::LoadIcon 检索图形的方法是，使用 ::FindResource 函数返回的实例值来调用 ::LoadIcon 函数。

为 DiskPie1 创建图标

创建 D iskPie1 应用程序图标的过程是，在打开的项目里单击 Visual C++ Insert 菜单上的 Resource 命令，然后，双击 Resource Type 列表里的 Icon 。图形编辑器默认打开一个边长为 32 个像素的正方形 16 色工作区域，Windows 在里面调用大的或标准的图标尺寸。编辑器在工作区域上面的 Device 组合框中，显示当前的标准 (32 × 32) 尺寸。组合框的下拉列表中只包含一个尺寸，这意味着，你当前正在操作的图标有一个图形，并且是边长为 32 个像素的正方形。

Visual C++ 图形编辑器可以创建有任何图形数目的图标资源，每一个都有不同的尺寸，或含有不同的颜色。要看其他可用的尺寸，可以按下 Insert 键、选择 Image 菜单的 New Device Image ，或者单击 New Device Image 按钮：

致谢 - 图112

上述方法都会打开图 4-17 里的 New Icon Image 对话框，在这里，显示了可用的图形尺寸，但是还没有与图标关联。如果你在列表里没有看到想要的尺寸，可单击 Custom 按钮，并指定一个新的图形尺寸。

致谢 - 图113

图 4-17 为图标选择新的图形

在 New Icon Image 对话框中，提供了在一个图标资源里包含多个图形的方法。在你画完这个标准的 32 × 32 大小的图形之后，从对话框里选择另一个尺寸，并重新开始。如果你想切换回原来的 32 × 32 大小的图形，在 Device 组合框里单击下拉箭头，并从打开的列表里选择 Standard(32 × 32)。当你从 New Icon Image 对话

框里选择了新的图形尺寸时，这个条目从对话框的列表里消失，并传递给组合框列表。换句话说，Device 组合框列出当前在图标里的图形尺寸，而 New Icon Image 对话框显示可添加到图标的尺寸。要从图标里移去当前图形，单击 Image 菜单上的 Delete Device Image（删除设备图形）。

D iskPie1 图标有三个图形尺寸，范围从边长为 16 个像素到 48 个像素的正方形：

致谢 - 图114

般情况下，程序图标里的图形是相同的图片，但是尺
寸不同。我给出了三种不同的设计图形，来清楚地显示 W indows 从 DiskPie1 的资源数据里提取正确的图形，而不是按比例显示图形。双击编辑器工作区域的任何地方打开 Icon Properties

对话框，并把 IDR_MAINFRAM 标识符指定给资源，并保存工作。

鼠标光标

就 DiskPie1 这个程序来说，不需要设计一个定制的鼠标光标，但是，让我们花一些时间，来看一下 Visual C++ 是怎样做这些工作的。鼠标光标是一个边长为 32 个像素的单色位图，它有透明的背景和一个 “ 热点 ”。热点是位图里的一个单独的像素， W indows 把它当做鼠标的坐标。例如，当一个程序接收到一个W M _ M O U S E M O V E 或一个 WM_LBUTTONDOWN 消息时，鼠标光标的 x 和 y 坐标保存在消息的 lParam 值里，表明这个在光标热点下面的像素坐标：

case WM_LBUTTONDOWN:

x= LOWORD(lParam);//x-coordinate of mouse click y= HIWORD(lParam);//y-coordinate of mouse click

要创建一个鼠标光标，或者从 File 菜单里选择 New （新建）命令，然后双击在File 选项卡里的 Cursor File （光标文件），或者，对于一个已经存在的项目，从Insert 菜单里选择 Resource 命令。双击列表里的 Cursor，可以提供一个空白的方块，你可以在上面设计新光标。如果要从一个标准的 W indows 光标图形开始设计，那么，展开 Cursor 标题，并从 IDC_NODROP ， IDC_POINTER 或

IDC_POINTER_COPY 里选择。编辑器显示一个边长为 32 个像素的工作区域，你将在上面画光标。如果你已经有了想使用的图形，但它是另一种形式，例如 32

× 32 的位图，那么，首先在图形编辑器里打开位图，并按下 Ctrl+C 将图形拷贝到剪贴板。然后打开一个新的光标，并按下 Ctrl+V 来粘贴位图到光标工作区域。位图里的颜色被转化为黑色或透明色，这取决于它们的亮度。如果你不喜欢这个结果，那么按下 Del 键删除光标图形。

致谢 - 图115

当图形编辑器加载一个光标图形时，一个 Set Hotspo t（设置热点）按钮显示在工作区域窗口的上面。你可以在图 4-18 里看到这个用坐标（ 0 ， 13 ）标记的按钮，将热点放在图中啮齿动物的鼻子上。单击 Set Hotspo t（设置热点）按钮，然后单击图形表格里想设置光标热点的点。完成时，从 File （文件）菜单里选择 Save ， Visual C++ 将把这个图形保存成一个 C U R 文件，像下面这样添加定义到项目的RC 文件里：

IDC_CURSOR1 COUSOR DISCARDABLE "res\\cursor1.cur"

致谢 - 图116

图 4-18 在 Visual C++ 图形编辑器中创建定制的鼠标光标

设置新的光标作为程序的默认光标，需要调用 LoadCursor API 函数。在一个 C 程序里，当为窗口初始化 WNDCLASS 或 WNDCLASSEX 结构时，这是典型的做法。这里是设置新的 IDC_CURSOR1 资源的方式：

WNDCLASSEX wndclass; wndclass.hCursor = LoadCursor( hInstance,

MAKEINTRESOURCE (IDC_CURSOR1) );

RegisterClassEx( &wndclass);

对于通过字符串名标识的光标资源，字符串是名字，而不是值，方法几乎和下面一样：

//Resource declaration in the RC file

MouseDemo CURSOR “ mouse.cur”

//Load and set resource during initialization in the C source file static char szAppName[ ] = “ MouseDem o”

WNDCLASSEX wndclass;

wndclass.hCursor = LoadCursor( hInstance, szAppName );

你可以在一个 MFC 程序里使用 AfxRegisterWndClass 全局函数做相同的事。下面的例子为 AfxRegisterWndClass 函数的最后一个参数使用一个常规图标，但是，真正的应用程序应该提供它自己的图标句柄：

CString wndclass = AfxRegisterWndClass( CS_HREDRAW | CS_VREDRAW,

::LoadCursor( hInstance,szAppName ), (HBRUSH) (COLOR_WINDOW + ),

theApp.LoadStandardIcon( IDI_APPLICATION ) );

利用这些命令，无论鼠标指针位于程序用户区域的任何地方，W indows 都会显示新的鼠标。图 4-19 显示了上面设计的光标在一个程序的外观（你可以从随书所附 CD 里的 Code\Chaper.04\Mouse 子文件夹里找到这个很小的 C 程序源代码）。

致谢 - 图117

图 4-19 新的鼠标光标在程序中出现

光标就讲这些吧，我们再来谈谈 DiskPie1 程序。

向 DiskPie1 添加代码

现在， D iskPie1 有菜单、加速键、工具栏、状态栏和图标，这些是需要的所有资源。现在，可以添加代码使它执行。如果你在本章里依照 DiskPie1 的生成过程进行，那么，你将可以识别在图 4-20 里的用户界面元素。应用程序图标、菜单、工具栏和状态栏是在前面几节里用 Visual C++ 资源编辑器设计的。

在创建主窗口的过程中， D iskPie1 将找到所有连接的固定磁盘，包括远程驱动器和 RAM 驱动器，每找到一个它，都要做下面这些工作：

致谢 - 图118

图 4-20 DiskPie1 程序，显示 8MB RAM 磁盘上的可用空间

向 Chart 菜单添加一个叫做 Disk x 的命令，这里 x 是磁盘

的指定字母。
在工具栏里添加一个按钮，从表示驱动器 C 到 Z 的工

具栏位图中，从

24 个图像中选择按钮的图形。

左下角的文本指出饼图的类型，或者是内存，或者是本地固定的驱动器、 R A M 驱动器或远程驱动器。饼图由两部分组成，分别标记为 “ Used ” 和 “ Free ”。内存的总数量或磁盘的容量通过右下角的图表表示。

虽然 DiskPie1 是一个相当小的程序，但是，它使用通用的 C++ 方式进行编译，将类分开放在分开的资源文件里。完整的程序列在后面，在随书附带的 CD 里的Code\Chapter.04\DiskPie1 子文件夹里，可以读取这些程序。如果你已经跟随本章里的步骤，为新的 D iskPie1 项目创建了资源，那么，你可能想完成这个项目，并为这个程序建立你自己的版本。在这种情况下，拷贝 H 和 CPP 资源文件到你的项目文件夹，并使用 Projec t（项目）菜单里的 Add To Project 命令添加 CPP 文件。此代码要求有一个 Abou t（关于）对话框，所以，使用文本编辑器从 CD 上的 DiskPie1.rc 文件里拷贝和粘贴脚本到你自己的 RC 文件。要记住，需除掉工具栏脚本，使它像 “ 为 DiskPie1 创建工具栏 ” 一节中给出的那样。

下面的目录描述了 D iskPie1 源文件，可以帮助你理解在列表 4-1 中的代码。

源文件说明

D iskPie InitInstance 函数，显示 About 对话

M ainFrm1 创建主窗口，确定可用的驱动器，并为每个驱动器添加菜单命令和工具栏按钮

D iskDoc 确定当前内存和磁盘的使用状况

D iskView 包含 OnDraw 函数，它为当前的使用状况数据显示饼图

列表 4-1 DiskaPie1 源文件

Resource.h

// ********************************************************************

// Resource.h

// ********************************************************************

#define IDD_ABOUTBOX 100

#define IDR_MAINFRAME 101

#define IDM_MEMORY 130

#define IDM_DISK_C 131

#define IDM_DISK_D 132

#define IDM_DISK_E 133

#define IDM_DISK_F 134

#define IDM_DISK_G 135

#define IDM_DISK_H 136

#define IDM_DISK_I 137

#define IDM_DISK_J 138

#define IDM_DISK_K 139

#define IDM_DISK_L 140

#define IDM_DISK_M 141

#define IDM_DISK_N 142

#define IDM_DISK_O 143

#define IDM_DISK_P 144

#define IDM_DISK_Q 145

#define IDM_DISK_R 146

#define IDM_DISK_S 147

#define IDM_DISK_T 148

#define IDM_DISK_U 149

#define IDM_DISK_V 150

#define IDM_DISK_W 151

#define IDM_DISK_X 152

#define IDM_DISK_Y 153

#define IDM_DISK_Z 154

DiskPie1.rc

// ********************************************************************

// DiskPie1.rc

// ********************************************************************

#include "resource.h"

#include "afxres.h"

IDR_MAINFRAME ICON "res\\diskpie1.ico"

IDR_MAINFRAME BITMAP "res\\toolbar.bmp"

IDR_MAINFRAME MENU

BEGIN

POPUP "&File"

BEGIN

MENUITEM "E&xit", ID_APP_EXIT

END

POPUP "&Chart"

BEGIN

MENUITEM "&Memory\tCtrl+M", IDM_MEMORY

MENUITEM SEPARATOR

END

POPUP "&View"

BEGIN

MENUITEM "&Toolbar", ID_VIEW_TOOLBAR

MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR

END

"F", IDM_DISK_F, VIRTKEY

"G", IDM_DISK_G, VIRTKEY

"H", IDM_DISK_H, VIRTKEY

"I", IDM_DISK_I, VIRTKEY

"J", IDM_DISK_J, VIRTKEY

"K", IDM_DISK_K, VIRTKEY

"L", IDM_DISK_L, VIRTKEY

"M", IDM_DISK_M, VIRTKEY

"N", IDM_DISK_N, VIRTKEY

"O", IDM_DISK_O, VIRTKEY

"P", IDM_DISK_P, VIRTKEY

"Q", IDM_DISK_Q, VIRTKEY

BUTTON IDM_MEMORY

END

IDD_ABOUTBOX DIALOG DISCARDABLE 0, 0, 240, 65

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "About DiskPie1"

FONT 8, "MS Sans Serif"

BEGIN

ICON IDR_MAINFRAME,IDC_STATIC,10,22,20,20

LTEXT "DiskPie1 Version 1.0",IDC_STATIC,45,10,115,8

LTEXT """Microsoft Visual C++ Programmer's Guide""",IDC_STATIC,45,26,140,8

IDM_DISK_H "Usage for drive H\nDrive H"

IDM_DISK_I "Usage for drive I\nDrive I"

IDM_DISK_J "Usage for drive J\nDrive J"

IDM_DISK_K "Usage for drive K\nDrive K"

IDM_DISK_L "Usage for drive L\nDrive L"

IDM_DISK_M "Usage for drive M\nDrive M"

IDM_DISK_N "Usage for drive N\nDrive N"

IDM_DISK_O "Usage for drive O\nDrive O"

IDM_DISK_P "Usage for drive P\nDrive P"

IDM_DISK_Q "Usage for drive Q\nDrive Q"

IDM_DISK_R "Usage for drive R\nDrive R"

IDM_DISK_S "Usage for drive S\nDrive S"

IDM_DISK_T "Usage for drive T\nDrive T"

IDM_DISK_U "Usage for drive U\nDrive U"

IDM_DISK_V "Usage for drive V\nDrive V"

IDM_DISK_W "Usage for drive W\nDrive W"

IDM_DISK_X "Usage for drive X\nDrive X"

IDM_DISK_Y "Usage for drive Y\nDrive Y"

IDM_DISK_Z "Usage for drive Z\nDrive Z"

AFX_IDS_IDLEMESSAGE "Ready"

AFX_IDS_SCSIZE "Change the window size"

AFX_IDS_SCMOVE "Change the window position"

AFX_IDS_SCMINIMIZE "Reduce the window to an icon"

AFX_IDS_SCMAXIMIZE "Enlarge the window to full size"

END

DiskPie1.h

// ********************************************************************

// DiskPie.h

// ********************************************************************

class CDiskPieApp : public CWinApp

{

public:

virtual BOOLInitInstance();

afx_msg voidOnAppAbout();

DECLARE_MESSAGE_MAP()

};

DiskPie.cpp

// ********************************************************************

// DiskPie.cpp

// ********************************************************************

#define VC_EXTRALEAN

#include <afxwin.h>

#include <afxext.h>

#include "resource.h"

#include "DiskPie.h"

#include "DiskDoc.h"

#include "MainFrm1.h"

#include "DiskView.h"

CDiskPieApp theApp;

BEGIN_MESSAGE_MAP (CDiskPieApp, CWinApp)

ON_COMMAND (ID_APP_ABOUT, OnAppAbout)

END_MESSAGE_MAP ()

BOOL CDiskPieApp::InitInstance()

{

CSingleDocTemplate* pDocTemplate;

pDocTemplate = new CSingleDocTemplate( IDR_MAINFRAME,

RUNTIME_CLASS (CDiskDoc),

RUNTIME_CLASS (CMainFrame),

RUNTIME_CLASS (CDiskView));

AddDocTemplate(pDocTemplate);

CCommandLineInfo cmdInfo;

if (!ProcessShellCommand(cmdInfo))

return FALSE;

return TRUE;

}

class CAboutDlg : public CDialog

{

public:

CAboutDlg();

enum { IDD = IDD_ABOUTBOX };

};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)

{

}

void CDiskPieApp::OnAppAbout()

{

CAboutDlg aboutDlg;

aboutDlg.DoModal();

}

DiskDoc.h

// ********************************************************************

// DiskDoc.h

// ********************************************************************

class CDiskDoc : public CDocument

{

DECLARE_DYNCREATE (CDiskDoc)

public:

static int iDriveType[24];

static DWORDdwTotal, dwFree;

static int iChartType;

static UINT nCurrent;

int GetDriveCount();

void GetMemoryUsage();

void GetDiskUsage( UINT nID );

};

DiskDoc.cpp

// ********************************************************************

// DiskDoc.cpp

// ********************************************************************

#define VC_EXTRALEAN

#include <afxwin.h>

#include "resource.h"

#include "DiskPie.h"

#include "DiskDoc.h"

#define PIE_MEMORY 0;

IMPLEMENT_DYNCREATE (CDiskDoc, CDocument)

int CDiskDoc::iDriveType[24],

int CDiskDoc::iChartType = PIE_MEMORY;

UINT CDiskDoc::nCurrent = IDM_MEMORY;

D W O R D CDiskDoc::dwTotal, CDiskDoc::dwFree;

void CDiskDoc::GetMemoryUsage ()

{

MEMORYSTATUSms;

::GlobalMemoryStatus( &ms );

dwTotal= ms.dwTotalPhys;

dwFree = ms.dwAvailPhys;

iChartType = PIE_MEMORY;

nCurrent = IDM_MEMORY;

}

void CDiskDoc::GetDiskUsage( UINT nID )

{

char szDrive[] = "x:\\\0";

DWORD dwSectsPerClust, dwBytesPerSect, dwFreeClusts, dwTotalClusts;

DWORD dwBytesPerClust;

GetDriveCount();

if (iDriveType[nID - IDM_DISK_C] == DRIVE_FIXED ||

iDriveType[nID - IDM_DISK_C] == DRIVE_REMOTE ||

iDriveType[nID - IDM_DISK_C] == DRIVE_RAMDISK)

{

szDrive[0] = (char) (nID - IDM_DISK_C) + 'C';

if (::GetDiskFreeSpace( szDrive, &dwSectsPerClust, &dwBytesPerSect,

&dwFreeClusts, &dwTotalClusts ))

{

dwBytesPerClust = dwSectsPerClust * dwBytesPerSect;

dwTotal = dwBytesPerClust * dwTotalClusts;

dwFree = dwBytesPerClust * dwFreeClusts;

iChartType = iDriveType[nID - IDM_DISK_C];

nCurrent = nID;

}

int CDiskDoc::GetDriveCount()

{

int i, cDrives = 0;

char szDrive[] = "x:\\\0";

for (szDrive[0]='C'; szDrive[0] <= 'Z'; szDrive[0]++)

{

i = (int) (szDrive[0] - 'C');

iDriveType[i] = ::GetDriveType( szDrive );

if (iDriveType[i] == DRIVE_FIXED ||

iDriveType[i] == DRIVE_REMOTE ||

iDriveType[i] == DRIVE_RAMDISK)

{

cDrives++;

}

return cDrives;

}

DiskView.h

// ********************************************************************

// DiskView.h

// ********************************************************************

class CDiskView : public CView

{

DECLARE_DYNCREATE (CDiskView)

private:

static COLORREF rgbColor[2];

static CString strType[];

void GetLabel( CString* str, double e, PCSTR strTail );

protected:

virtual void OnDraw( CDC* pDC );

afx_msg void OnMemoryUpdate( CCmdUI* pCmdUI );

afx_msg void OnDiskUpdate( CCmdUI* pCmdUI );

DECLARE_MESSAGE_MAP ()

};

DiskView.cpp

// ********************************************************************

// DiskView.cpp

// ********************************************************************

#define VC_EXTRALEAN

#include <afxwin.h>

#include "resource.h"

#include "DiskView.h"

#include "DiskDoc.h"

#include "math.h"

#define PI 3.141592654

#define RADIUS 900

#define SLICE_OFFSET 12

#define MEM_COLOR RGB (0, 255, 255) // Cyan

#define DISK_COLOR RGB (0, 255, 0) // Green

COLORREF CDiskView::rgbColor[2] = { MEM_COLOR, DISK_COLOR };

CString CDiskView::strType[] = { " Memory",

Fixed disk",
Remote drive",
RAM disk" };

IMPLEMENT_DYNCREATE (CDiskView, CView)

BEGIN_MESSAGE_MAP (CDiskView, CView)

ON_UPDATE_COMMAND_UI (IDM_MEMORY, OnMemoryUpdate)

ON_UPDATE_COMMAND_UI_RANGE (IDM_DISK_C, IDM_DISK_Z, OnDiskUpdate)

END_MESSAGE_MAP()

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Paint the pie chart

void CDiskView::OnDraw( CDC* pDC )

{

Cpen pen;

CBrush brush;

CRect rect;

Cstring str;

int x, y, i, iColor;

double dUseSweep, dFreeSweep;

// Color is cyan for memory chart, green for drive charts

iColor = (CDiskDoc::nCurrent == IDM_MEMORY) ? 0 : 1;

// Set coordinate system so that origin is at center of client area

GetClientRect( rect );

pDC->SetMapMode( MM_ISOTROPIC );

pDC->SetWindowExt( RADIUS+100, RADIUS+100 );

pDC->SetViewportExt( rect.right/2, -rect.bottom/2 );

pDC->SetViewportOrg( rect.right/2, rect.bottom/2 );

// Create solid brush of current color to paint "Used" pie slice

pen.CreatePen( PS_SOLID, 1, rgbColor[iColor] );

brush.CreateSolidBrush( rgbColor[iColor] );

pDC->SelectObject( &pen );

pDC->SelectObject( &brush );

// Sweep angles in radians for "Free" and "Used" pie slices

dFreeSweep = (double) (PI*2 * CDiskDoc::dwFree/CDiskDoc::dwTotal);

dUseSweep = (double) PI*2 - dFreeSweep;

// Paint "Used" slice first, sweeping counter-clockwise from due north

x = -(int) (sin( dUseSweep ) * RADIUS);

y = (int) (cos( dUseSweep ) * RADIUS);

pDC->Pie( -RADIUS, RADIUS, RADIUS, -RADIUS, 0, RADIUS, x, y );

// Create hatched brush of current color to paint "Free" pie slice

pDC->SelectStockObject( WHITE_BRUSH );

pDC->SelectStockObject( BLACK_PEN );

brush.DeleteObject();

pen.DeleteObject();

pen.CreatePen( PS_SOLID, 1, rgbColor[iColor] );

brush.CreateHatchBrush( HS_CROSS, rgbColor[iColor] );

pDC->SelectObject( &pen );

pDC->SelectObject( &brush );

// Compute new center for "Free" slice, slightly offset from

// original center, then paint the "Free" slice

x = (int) (sin( PI - dUseSweep/2 ) * SLICE_OFFSET);

y = -(int) (cos( PI - dUseSweep/2 ) * SLICE_OFFSET);

pDC->OffsetWindowOrg( x, y );

pDC->OffsetViewportOrg( x, y );

x = (int) (sin( dFreeSweep ) * RADIUS);

y = (int) (cos( dFreeSweep ) * RADIUS);

if(abs (x) > 4)

pDC->Pie( -RADIUS, RADIUS, RADIUS, -RADIUS, x, y, 0, RADIUS );

pDC->SelectStockObject( BLACK_PEN );

pDC->SelectStockObject( WHITE_BRUSH );

pDC->SetBkMode( TRANSPARENT );

pen.DeleteObject();

brush.DeleteObject();

// Label "Free" slice

GetLabel( &str, CDiskDoc::dwFree, "Free" );

pDC->TextOut( 10, RADIUS/2, str );

// Label "Used" slice, making sure it doesn't occur near the "Free" label

x = -(int) (sin( dUseSweep/2 ) * RADIUS);

y = (int) (cos( dUseSweep/2 ) * RADIUS);

if ( y > 0 && (y - RADIUS/2) < 25)

{

x = -(RADIUS - 10);

y = 0;

}

GetLabel( &str, (CDiskDoc::dwTotal - CDiskDoc::dwFree), "Used" );

pDC->TextOut( x, y, str );

// Restore original mapping mode so we can use DrawText function

pDC->SetMapMode( MM_TEXT );

pDC->SetWindowExt( rect.right, rect.bottom );

pDC->SetViewportExt( rect.right, rect.bottom );

pDC->SetViewportOrg( 0, 0 );

pDC->SetWindowOrg( 0, 0 );

// Write "Total" at bottom right corner of window

GetLabel( &str, CDiskDoc::dwTotal, "Total " );

pDC->DrawText( str, rect, DT_SINGLELINE | DT_BOTTOM | DT_RIGHT );

// Write device type at bottom left corner of window

i = 0;

if (CDiskDoc::iChartType == DRIVE_FIXED)

i = 1;

if (CDiskDoc::iChartType == DRIVE_REMOTE)

i = 2;

if (CDiskDoc::iChartType == DRIVE_RAMDISK)

i = 3; pDC->DrawText( strType[i], rect, DT_SINGLELINE \| DT_BOTTOM \| DT_LEFT ); } void CDiskView::GetLabel( CString* str, double d, PCSTR strTail ) { charch = 'K'; // 'K ' for kilobytes d /= 1024; if (d > 1024) // If amount is greater than
{			//	1024 kilobytes, divide
	d ch	/= 1024; = 'M ';	// //	again by 1024 to convert to megabytes
}

i = 3;

pDC->DrawText( strType[i], rect, DT_SINGLELINE | DT_BOTTOM | DT_LEFT );

}

void CDiskView::GetLabel( CString* str, double d, PCSTR strTail )

{

charch = 'K'; // 'K ' for kilobytes

d /= 1024;

if (d > 1024) // If amount is greater than

{

1024 kilobytes, divide

/= 1024;

= 'M ';

again by 1024 to convert

to megabytes

}

str->Format( "%.2f %c%s%s", d, ch, "b ", strTail );

}

/ / / / / / / / / / / / / / / / / / / / / / / / / // / / / / / / // / / / / / / / // / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Make sure menu check marks and toolbar buttons are in sync

void CDiskView::OnMemoryUpdate( CCmdUI* pCmdUI )

{

pCmdUI->SetCheck( CDiskDoc::nCurrent == IDM_MEMORY );

}

void CDiskView::OnDiskUpdate( CCmdUI* pCmdUI )

{

pCmdUI->SetCheck( CDiskDoc::nCurrent == pCmdUI->m_nID );

}

MainFrm1.h

// ********************************************************************

// MainFrm1.h

// ********************************************************************

class CMainFrame : public CFrameWnd

{

DECLARE_DYNCREATE (CMainFrame)

private:

CToolBartoolbar;

CStatusBar statusbar;

CDiskDocdiskdoc;

protected:

afx_msg int OnCreate( LPCREATESTRUCT lpCreateStruct );

afx_msg voidOnMemory ();

afx_msg voidOnDisk( UINT nID );

afx_msg voidOnSetFocus( CWnd* );

DECLARE_MESSAGE_MAP()

};

MainFrm1.cpp

// ********************************************************************

// MainFrm1.cpp

// ********************************************************************

#define VC_EXTRALEAN

#include <afxwin.h>

#include <afxext.h>

#include <afxcmn.h>

#include "resource.h"

#include "DiskPie.h"

#include "DiskDoc.h"

#include "MainFrm1.h"

#include "DiskView.h"

IMPLEMENT_DYNCREATE (CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP (CMainFrame, CFrameWnd)

ON_WM_CREATE ()

ON_WM_SETFOCUS ()

ON_COMMAND (IDM_MEMORY, OnMemory)

ON_COMMAND_RANGE (IDM_DISK_C, IDM_DISK_Z, OnDisk)

END_MESSAGE_MAP ()

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Create main window, toolbar, and status bar

int CMainFrame::OnCreate( LPCREATESTRUCT lpCreateStruct )

{

int i, j;

char szMenu[] = "Disk &x\tx\0";

CMenu* pmenu;

static const UINT indicator = ID_SEPARATOR;

static const UINT nButtons[] = { IDM_MEMORY, ID_SEPARATOR,

IDM_DISK_C, IDM_DISK_D, IDM_DISK_E, IDM_DISK_F,

IDM_DISK_G, IDM_DISK_H, IDM_DISK_I, IDM_DISK_J,

IDM_DISK_K, IDM_DISK_L, IDM_DISK_M, IDM_DISK_N,

IDM_DISK_O, IDM_DISK_P, IDM_DISK_Q, IDM_DISK_R,

IDM_DISK_S, IDM_DISK_T, IDM_DISK_U, IDM_DISK_V,

IDM_DISK_W, IDM_DISK_X, IDM_DISK_Y, IDM_DISK_Z };

if (CFrameWnd::OnCreate( lpCreateStruct ) == -1)

return -1;

statusbar.Create( this );

statusbar.SetIndicators( &indicator, 1 );

toolbar.Create( this );

toolbar.SetWindowText( "Charts" );

toolbar.LoadToolBar( IDR_MAINFRAME );

toolbar.SetBarStyle( toolbar.GetBarStyle() |

CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC );

toolbar.SetButtons( nButtons, diskdoc.GetDriveCount() + 2 );

toolbar.SetButtonStyle( 0, TBBS_CHECKGROUP );

pmenu = GetMenu()->GetSubMenu( 1 );

for (i=0, j=2; i < 24; i++)

{

if(CDiskDoc::iDriveType[i] == DRIVE_FIXED ||

CDiskDoc::iDriveType[i] == DRIVE_REMOTE ||

CDiskDoc::iDriveType[i] == DRIVE_RAMDISK)

{

szMenu[6] = 'C' + (char) i;

szMenu[8] = 'C' + (char) i;

pmenu->InsertMenu( 0xFFFF, MF_BYPOSITION, IDM_DISK_C+i, szMenu );

toolbar.SetButtonInfo( j++, IDM_DISK_C+i, TBBS_CHECKGROUP, i+1 );

}

toolbar.EnableDocking( CBRS_ALIGN_ANY );

EnableDocking( CBRS_ALIGN_ANY );

DockControlBar( &toolbar );

return 0;

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Respond to menu/toolbar/accelerator commands

void CMainFrame::OnMemory ()

{

diskdoc.GetMemoryUsage ();

Invalidate ();

}

void CMainFrame::OnDisk( UINT nID )

{

diskdoc.GetDiskUsage( nID );

Invalidate ();

}

/ / / / / / / / / / / / / / / / / // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// When focus regained, refresh display in case data has changed

void CMainFrame::OnSetFocus( CWnd* )

{

if(CDiskDoc::nCurrent == IDM_MEMORY)

diskdoc.GetMemoryUsage();

else

diskdoc.GetDiskUsage( CDiskDoc::nCurrent );

}

如果从程序的逻辑流来看，那么，你将发现，最重要的步骤在 MainFrm1.cpp 模块里。不管什么时候，只要 W indows 发送一条 WM_SETFOCUS 消息，通知获得输入焦点的主窗口，便将调用 CMainFrame::OnSetFocus 函数。当 D iskPie1 首先启动时，或无论何时，只要用户从其他程序切换到 D iskPie1 时，将发生这个事件。这样，这个函数提供两种用途的服务。它使 CMainFrame::OnCreate 免于在程序开始启动时调用 DiskDoc::GetMemoryUsage 来初始化数据，并且，它也保证当用户运行其他程序，或删除一个文件时，当 DiskPie1 重新获得焦点时，自动重画当前的饼图，来反映新的状况。

通过给 CMainFrame::OnCreate 函数提供一个连接的驱动器列表，函数添加 Chart 菜单命令，例如为每个连接的驱动器添加 D ISK C 和 DISK D 这样的命令。它也为每一个驱动器添加一个工具栏按钮，根据驱动器指定的字母选择工具栏位图的合适部分。例如，驱动器 D 的按钮是用位图的 16 × 15 这部分画的，其中包含这个磁盘驱动器图像和字母 D （含有 25 个位图块的完整工具栏位图显示在图 4-15 中）。

用户可以请求内存状况饼图或磁盘驱动器的饼图，你可以通过下面步骤完成：

从 Chart 菜单选择一个命令。
单击工具栏按钮。
要查看内存，按下 Ctrl+M ，或要查看磁盘驱动器，按

下 Ctrl 和从 C 到

Z 对应于驱动器的字母。

这些事件是通过 CMainFrame::OnMemory 和 CMainFrame::OnDisk 函数处理的，它通过类的消息映射接收控制：

BEGIN_MESSAGE_MAP (CMainFrame, CFrameWnd)

ON_COMMAND (idm_memory,OnMemory)

ON_COMMAND_RANGE (IDM_DISK_C, IDM_DISK_Z, OnDisk)

END_MESSAGE_MAP ()

你可能回想起，在本章前面创建 D iskPie1 加速键时的情形，我们必须保证从IDM_DISK_C 到 IDM_DISK_Z 的标识符值是连续排列的。上面的消息映射显示了为什么要这样。因为标识符有连续的值，程序可以使用 MFC 的ON_COMMAND_RANGE 宏来为任何磁盘驱动器发送请求给 OnDisk 函数。根据

作为参数传递的磁盘驱动器标识符， OnDisk 决定用户要求用饼图显示的磁盘。

OnMemory 不要求 ON_COMMAND_RANG E ，因为只有一个内存饼图。

决定内存和磁盘使用状况的机制是在 D iskDoc.cpp 模块里使用两个函数。这两个函数 CDiskDoc::GetMemoryUsage 和 CDiskDoc::GetDiskUsage 使用了相似的逻辑结构。它们通过调用 GlobalMemoryStatus 和 GetDiskFreeSpace API 函数，从系统中找到它们要求的信息，然后，使用这个信息来决定 dwTotal 和 dwFree 内存变量的值，它包含当前饼图的总字节数和未使用的字节数。变量中的数据不管是表示内存，还是磁盘空间，对于画图程序来说，都没有什么区别。在决定了当前使用状况数据之后，OnMemory 和 OnDisk 函数调用 Invalidate 来强制显示一个新的饼图。

现在，应该介绍 DiskView.cpp 文件里 CDiskView::OnDraw 函数了。这个函数使用了公共的 dwTotal 和 dwFree 值，来决定饼图的两个分块所占用的角度：

//Sweep angles in radians for “ Free ” and “ Used ” pie slices

dFreeSweep = (double) (PI*2 * CDiskDoc::dwFree/CDiskDoc::dwTotal); dUseSweep = (double) PI*2 - dFreeSweep;

OnDraw 先画出 “ Used （使用的）” 的那一部分，通过 dUseSweep 角度，来决定

从 12 点位置反时针转过的角度。“ Fre e（空闲）” 块是剩余的那部分。OnDraw 为

每一块关联一个标签，并显示这个饼图。如果需要画另一个饼图，就必须重新开始整个过程。

一个饼图快速提供了目前的使用状况。当 D iskPie1 获得焦点时，刷新饼图的唯一方便的方法是按下对应于这个饼图的加速键。在 W indows 这样的抢占式多任务系统里，内存使用状况的变化特别快，每一微秒都在发生变化。如果你在 Visual C++ 中，在后台编译一个项目时，连续按下 Ctrl+M 键，那么，你可以看到快速分配和释放物理内存的效果。添加 OnTimer 函数可以定期更新显示。

更严重的是， DiskPie1 无法解决驱动器连接的动态变化问题。我们已经看到， CMainFrame::OnCreate 函数怎样添加菜单命令，以及如何为连接到系统上的磁盘驱动器添加工具栏按钮，包括任何通过网络提供的远程驱动器。然后，在程序的生存期内，菜单和工具栏保持不变，即使用户后来可能添加或卸载一个网络驱动器，或由于服务器端出现问题，而使一个连接消失。然而，这并不会致命，D iskPie1 仍然正常工作，因为 CDiskDoc::GetDiskUsage 总是在显示一个饼图之前列举驱动器。增强程序将添加重新检查刷新显示时驱动器的连接状态的逻辑，从而根据情况添加或移去菜单命令和工具栏按钮。

再谈未结合命令

前面的章节描述了怎样通过指定键盘组合键和工具栏按钮打开命令，来设置名为

WordUpperCase 和 WordLowerCase 的命令，将它们与文本编辑命令结合。 Visual C++ 环境也提供许多为图形编辑器设计的有用的未结合命令，你可以完全使用第

3 章 “ 文本编辑器 ” 中描述的过程。要看到图形编辑器的未结合和结合命令的列表，单击在 Hel p（帮助）菜单上的 Keyboard Ma p（键盘映射），并从 Help Keyboard

（帮助键盘）对话框的组合框里选择 Image 。图 4-21 显示了一个相似的列表。

致谢 - 图119

图 4-21 图形编辑器的命令，通过从 Help 菜单中选择 Keyboard Map 来显示

列表里的许多 Image 命令已经有了键盘指定。例如，图 4-21 显示了按下 A 键打开 Airbus h（喷雾器）工具，按下 + 或－键增加或减少其尺寸。但是，其他命令在为它们指定按键或创建组合键后，才可以使用。为了证明这点，本节显示了怎样为列表里的第一个名为 Image3dRectangleTool 的命令指定一个组合键，它是图形编辑器上 Rectangle （矩形）工具的一个变种。

从 Tool 菜单上选择 Customize ，并单击 Keyboard 选项卡。从 Category 和 Editor

组合框里选择 Image ，它将告诉 Visual C++ ，只在图形编辑器中使用新的键盘命令（也叫做图像编辑器）。从命令列表里选择 Image3dRectangleToo l，单击 New Shortcut Key （新的快捷键）文本框，然后为命令输入一个组合键，例如Shift+Ctrl+3 。对话框显示说明目前没有分配的组合键，所以，我们不必担心是否从其他命令取走 Shift+Ctrl+3 。单击 Assign 按钮，然后单击 Close （关闭）按钮来除去对话框。

Image3dRectangleTool 命令是为位图设计的，所以，要在运行中看到它，通过选择 File 菜单里的 New 打开图形编辑器，并双击 Files 选项卡里的 Bitmap Fil e（位图文件）。按下 Shift+Ctrl+3 组合键时，或者按下指定给这个命令的任何其他组合键时，图形光标变成 Rectangle （矩形）工具使用的十字形。但是，当画一个矩形时，新的光标会稍微不同的效果。当你从左上角拖动光标到右下角时，上边和左边用目前的前景色，而右边和底部用背景色显示。通过用鼠标右键拖动来修改颜色。使用正确的颜色组合，嵌套的矩形显示一个三维外观，可以快速生成下面这样的图标：

致谢 - 图120

在图形编辑器里工作时， Image3dRectangleTool 只是许多有用的键盘命令中的一个。例如，当设计自画的按钮时，相似的 ImageWindowRectangle 命令快速画出按钮处于正常状态、按下或非活动状态下的位图图像。在列表中浏览，并看一下你喜欢的命令。如果想为命令创建工具栏按钮，可查看第 3 章的 “ 未结合命令 ” 一节。

修整资源数据

由于有不使用的或效率低下的资源数据，W indows 程序经常是过度负载，那些程序使程序的文件尺寸增大，更糟糕的是，它占用内存。即使从来都没有使用的资源，也可以进入内存，但只是闲在那里，占用有效的共享资源。你可以解决这种问题，所需要付出的努力也不大。这一节研究一些减小程序资源数据大小的技术，并通过对 DiskPie1 程序做一些修改，来证明我们常常可以修整一个程序里

资源数据的有效数量。

要记住的第一件事是，你不必保留 AppWizard 提供给你的每一件东西。字符串是罪魁祸首，因为它们太长了，或者根本不需要它们。 W in32 资源字符串保存在一个程序文件里，作为 Unicode 字符串，这意味着，你删除的每一个字符保存在两个字节里，而不是一个字节。如果你从通过 AppWizard 生成的 RC 文件里移去一个菜单命令，那么，你要确定移去和它在一起的提示字符串，并且不要忘记对应的加速键。

AppWizard 添加提示字符串到 RC 文件里，它描述了一个程序的系统菜单：

STRINGTABLE BEGIN

AFX_IDS_SCSIZE "Change the window size"

AFX_IDS_SCMOVE "Change the window position" AFX_IDS_SCMINIMIZE "Reduce the window to an icon" AFX_IDS_SCMAXIMIZE "Enlarge the window to full size" AFX_IDS_SCCLOSE "Close the active window"

AFX_IDS_SCRESTORE "Restore the window to normal size"

END

MFC 库文件包含这些相同的字符串，所以，如果你的程序使用 MFC 动态链接库，那么，你可以安全地从 RC 文件里删除这些字符串，而不用改变程序的行为（然而，如果你的程序是面向国际市场的，它有可能运行在配置不同使用语言系统的机器上，其他因素可能影响你是否使用 MFC 库文件提供的字符串的决定。看一下第 2 章开始的有关海外市场和动态链接到 MFC 的讨论）。通过释放一些资源字符串，动态链接到 MFC ，而不是静态链接，将明显减少可执行文件的尺寸，因为 MFC 代码是在 DLL 里的，而不是在调用的程序里。当然，只有在两个或两个以上的程序同时使用 MFC 库运行时，用户才会获益。

我在前面的章节里提到，如果一个应用程序只提供一个边长为 32 个像素的正方形图标， W indows 将自动将图形按需要成比例转换成 16 × 16 或 48 × 48 的正方形。如果图标图形只包含直线和矩形，比例变换一般不会改变图形。对于不受比例变换影响的图形，你可能考虑只包含一个 32 × 32 的图形，而不是两个或三个

不同尺寸的图形。

你可以通过使它们的颜色数最小，来进一步减少图标和位图要求的空间。例如，默认状态下，图形编辑器的 New Icon Image （新图标图像）对话框 ( 显示在图 4- 17 上 ) 为边长为 48 个像素的正方形图标图像设置 256 种颜色。但是，许多图标图形，像 D iskPie1 的图标，只包含几种颜色。为一个图形指定 16 种颜色，一个像素只使用 4 位；而不是使用 256 色的图形，每个像素占 8 位。通过减半 48 × 48 图形占用的空间，来减少图标文件的大小，这是最简单的步骤。在保存时，同时保存一个包含在图标里的颜色表，将增加 2K 字节大小的资源数据。要在图形编辑器里创建一个 16 色的 48 × 48 的图标图形，按下 Insert 键，打开 New Icon Image 对话框，单击对话框里的 Custom 按钮，并填写适当的控件框。

D iskPie1 使用了大量的资源空间，来保存它那巨大的工具栏位图，正如图 4-15 所示的那样。在位图里有 25 个图形，其中 24 个是副本，只有在重复的磁盘图形上显示的字母是不同的。在这种情况下，可以把它存成一个图形，并提供任何数目的工具栏按钮的服务。再增加一点附加的代码，它可以提供工具栏图形中其他23 个图形的作用。这就大量节省了程序的尺寸。下面说明怎样实现它。

程序 DiskPie2

D iskPie1.exe 的发行版本文件大小是 24579 字节。通过去掉其资源数据中的许多无用数据，新的 DiskPie2 程序大小减小到 17920 字节，在没有明显改动程序的

同时，减少了几乎三分之一的大小。D iskPie2 用四种技术来减少它的资源数据的大小：

通过接收一个 “ Ready（就绪）” 消息，这个程序没有在

它的资源数据里包含提示字符串，而通过 MFC 库文件提供提示字符串，D iskPie2 在它的状态栏里为所有的命令显示一般性的提示信息，但那些在 Chart 菜单里选择的命令除外。
由于没有提示字符串， D iskPie2 必须在需要的时候生

成工具提示。生成工具提示的代码比工具提示字符串本身占用更小的空间，导致程序大小整体降低。
48 × 48 图标图像有一个 16 色表，而不是 256 色表。
D iskPie2 工具提示位图只有两个图像，而不是像 D

iskPie1 那样要求的

25 个图像。

这两个工具栏位图的视图显示了 DiskPie2 的工具栏按钮所使用的图像：

致谢 - 图121

这些图像复制了 D iskPie1 中工具栏的前两个图形，只是第二个图形没有标记，并使它适于表示任何磁盘驱动器。运行时， D iskPie2 给按钮的磁盘驱动器图形添加像 “ C :”和 “ D :” 这样的名称。你可以在图 4-22 里看到这个结果。

致谢 - 图122

图 4-22 DiskPie2 程序

新的 DiskPie2 程序要求改变 DiskPie1 的三个源文件，来创建叫做 D iskPie2.rc ，

M ainFrm2.h 和 M ainFrm.cpp 文件的升级版本。列表 4-2 显示了修订的代码，在D iskPie1.rc 里去掉了不需要的提示字符串，在 MainFrm2.cpp 里接收为标记工具栏按钮构造工具提示文本而添加的指令。

IDR_MAINFRAME ICON"res\\DiskPie2.ico"

IDR_MAINFRAME BITMAP "res\\toolbar.bmp"

IDR_MAINFRAME MENU

BEGIN

POPUP "&File"

BEGIN

MENUITEM "E&xit", ID_APP_EXIT

END

POPUP "&Chart"

BEGIN

MENUITEM "&Memory\tCtrl+M", IDM_MEMORY

MENUITEM SEPARATOR

END

POPUP "&View"

BEGIN

MENUITEM "&Toolbar", ID_VIEW_TOOLBAR

MENUITEM "&Status Bar", ID_VIEW_STATUS_BAR

END

POPUP "&Help"

BEGIN

MENUITEM "&About DiskPie2...", ID_APP_ABOUT

END

IDR_MAINFRAME ACCELERATORS

BEGI N

"M", IDM_MEMORY, VIRTKEY, CONTROL

"C", IDM_DISK_C, VIRTKEY

"D", IDM_DISK_D, VIRTKEY

"E", IDM_DISK_E, VIRTKEY

"F", IDM_DISK_F, VIRTKEY

"G", IDM_DISK_G, VIRTKEY

"H", IDM_DISK_H, VIRTKEY

"I", IDM_DISK_I, VIRTKEY

"J", IDM_DISK_J, VIRTKEY

"K", IDM_DISK_K, VIRTKEY

"L", IDM_DISK_L, VIRTKEY

"M", IDM_DISK_M, VIRTKEY

"N", IDM_DISK_N, VIRTKEY

"O", IDM_DISK_O, VIRTKEY

"P", IDM_DISK_P, VIRTKEY

"Q", IDM_DISK_Q, VIRTKEY

"R", IDM_DISK_R, VIRTKEY

"S", IDM_DISK_S, VIRTKEY

"T", IDM_DISK_T, VIRTKEY

"U", IDM_DISK_U, VIRTKEY

"V", IDM_DISK_V, VIRTKEY

"W", IDM_DISK_W, VIRTKEY

"X", IDM_DISK_X, VIRTKEY

END

IDR_MAINFRAME TOOLBAR 16, 15

BEGIN

BUTTON IDM_MEMORY

END

IDD_ABOUTBOX DIALOG 0, 0, 240, 65

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "About DiskPie2"

FONT 8, "MS Sans Serif"

BEGIN

MainFrm2.h

// ********************************************************************

// MainFrm2.h

// ********************************************************************

class CMainFrame : public CFrameWnd

{

DECLARE_DYNCREATE (CMainFrame)

private:

CToolBartoolbar;

CStatusBar statusbar;

CDiskDocdiskdoc;

protected:

afx_msg int OnCreate( LPCREATESTRUCT lpCreateStruct );

afx_msg voidOnNewChart( UINT nID );

afx_msg voidOnSetFocus( CWnd* );

afx_msg BOOLOnTooltip( UINT id, NMHDR* pNMHDR, LRESULT* );

DECLARE_MESSAGE_MAP()

};

MainFrm2.cpp

// ********************************************************************

// MainFrm2.cpp

// ********************************************************************

#define VC_EXTRALEAN

#include <afxwin.h>

#include <afxext.h>

#include <afxcmn.h>

#include "resource.h"

#include "DiskPie.h"

#include "DiskDoc.h"

#include "MainFrm2.h"

#include "DiskView.h"

IMPLEMENT_DYNCREATE (CMainFrame, CFrameWnd)

BEGIN_MESSAGE_MAP (CMainFrame, CFrameWnd)

ON_WM_CREATE ()

ON_WM_SETFOCUS ()

ON_COMMAND_RANGE (IDM_MEMORY, IDM_DISK_Z, OnNewChart)

ON_NOTIFY_EX( TTN_NEEDTEXT, 0, OnTooltip )

END_MESSAGE_MAP ()

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Create main window, toolbar, and status bar

int CMainFrame::OnCreate( LPCREATESTRUCT lpCreateStruct )

{

int i, j;

char szDisk[] = "x:\0";

char szMenu[] = "Disk &x\tx\0";

CMenu* pmenu;

static const UINT indicator = ID_SEPARATOR;

if (CFrameWnd::OnCreate( lpCreateStruct ) == -1)

return -1;

statusbar.Create( this );

statusbar.SetIndicators( &indicator, 1 );

toolbar.Create( this );

toolbar.SetWindowText( "Charts" );

toolbar.LoadToolBar( IDR_MAINFRAME );

toolbar.SetBarStyle( toolbar.GetBarStyle() |

CBRS_TOOLTIPS | CBRS_FLYBY | CBRS_SIZE_DYNAMIC );

toolbar.SetButtons( NULL, diskdoc.GetDriveCount() + 2 );

toolbar.SetButtonInfo( 0, IDM_MEMORY, TBBS_CHECKGROUP, 0 );

toolbar.SetButtonText( 0, "Memory" );

// The second "button" is a separator

toolbar.SetButtonInfo( 1, ID_SEPARATOR,

TBBS_SEPARATOR | TBBS_CHECKGROUP, 0 );

pmenu = GetMenu()->GetSubMenu( 1 );

for (i=0, j=2; i < 24; i++)

{

if(CDiskDoc::iDriveType[i] == DRIVE_FIXED ||

CDiskDoc::iDriveType[i] == DRIVE_REMOTE ||

CDiskDoc::iDriveType[i] == DRIVE_RAMDISK)

{

szDisk[0] = 'C' + (char) i;

szMenu[6] = 'C' + (char) i;

szMenu[8] = 'C' + (char) i;

pmenu->InsertMenu( 0xFFFF, MF_BYPOSITION, IDM_DISK_C+i, szMenu );

toolbar.SetButtonInfo( j, IDM_DISK_C+i, TBBS_CHECKGROUP, 1 );

toolbar.SetButtonText( j++, szDisk );

}

toolbar.SetSizes( CSize( 45, 40 ), CSize( 16, 15 ) );

toolbar.EnableDocking( CBRS_ALIGN_ANY );

EnableDocking( CBRS_ALIGN_ANY );

DockControlBar( &toolbar );

return 0;

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// Respond to menu/toolbar/accelerator commands

void CMainFrame::OnNewChart( UINT nID )

{

CDiskDoc::nCurrent = nID;

OnSetFocus( NULL );

Invalidate();

toolbar.Invalidate(); // Necessary when bar is floating

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// When focus regained, refresh display in case data has changed

void CMainFrame::OnSetFocus( CWnd* )

{

if (CDiskDoc::nCurrent == IDM_MEMORY)

diskdoc.GetMemoryUsage();

else

diskdoc.GetDiskUsage( CDiskDoc::nCurrent );

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// When TTN_NEEDTEXT notification received. Generate tooltip text

BOOL CMainFrame::OnTooltip( UINT id, NMHDR* pNMHDR, LRESULT* )

{

static char szMemTip[] = "Memory usage chart\0";

static char szDiskTip[] = "Usage chart for drive x\0";

TOOLTIPTEXT* pTTT = (TOOLTIPTEXT*) pNMHDR;

UINT nID = pNMHDR->idFrom;

if (nID == IDM_MEMORY)

pTTT->lpszText = szMemTip;

else

{

szDiskTip[22] = (char) (nID - IDM_DISK_C) + 'C';

pTTT->lpszText = szDiskTip;

除了文件大小的差别外，D iskPie1 和 D iskPie2 之间唯一明显的差别在于它们工具栏的外观。由于 D iskPie2 为它的工具栏按钮使用单一的磁盘驱动器图像，所以，程序必须在运行时用文字标记它们。CMainFrame::OnCreate 函数在 For 循环里处理这个任务，这个循环运行通过每一个连接的驱动器。

for (i=0, j=2; i < 24; i++)

{

pmenu->InsertMenu( 0xFFFF, MF_BYPOSITION, IDM_DISK_C+i, szMenu );

toolbar.SetButtonInfo( j, IDM_DISK_C+i, TBBS_CHECKGROUP, 1 );

toolbar.SetButtonText( j++, szDisk );

}

toolbar.SetSizes(Csize(45,40),Csize(16,15));

对 CToolBar::SetButtonInfo 的调用与在 D iskPie1 里的指令相同，不同的是最后的参数，它是在工具栏位图里按钮图形的下标，以 0 开始。 D iskPie1 使用循环计数器从 24 个可用的图形中选择按钮的图形。D iskPie2 只处理一个磁盘驱动器图形。但是，为了不使每一个图标看起来都相似，代码也调用 CToolBar::SetButtonText 添加驱动器名称。添加的文本要求每一个按钮都有更多的空间，所以，代码通过调用 CToolBar::SetSizes 来增大按钮的尺寸到 45 × 40 ，而不是 D iskPie1 的 24 × 22 像素。

按要求出现的工具提示和提示字符串

由于在 D iskPie2 的资源数据中没有提示字符串，所以，它在运行时，根据需要来配置其工具提示。当系统要显示一个工具提示窗口时，它通过一个TTN_NEEDTEXT 通知消息来通知程序。D iskPie2 在它的 CMainFrame::OnTooltip 函数里处理它。这个消息提供了一个指向 TOOLTIPTEXT 结构的指针，它是N M H D R 结构的扩展形式：

typedef struct

{

NMHDR hdr;

LPTSTR lpszText;

char szText[80]; HINSTANCE hinst; UINT uFlags;

}TOOLTIPTEXT, FAR *LPTOOLTIPTEXT;

hdr.idFrom 的值标识光标停留处的工具栏按钮，通过这个值，OnTooltip 决定合适的工具提示， lpszText 指向新的文本字符串，并返回一个 TRUE 值。函数在它的两个静态的字符串里保留它的工具提示：

static char szMemTip[] = " Memory usage chart\0 " ; static char szDiskTip[] = " Usage chart for drive x\0 " ;

hdr.idFrom 里的 IDM_MEMORY 的值表明，第一个工具栏按钮需要工具提示文本。在这种情况下，代码将 lpszText 的结构成员指向字符串 szMemTip 。如果hdr.idFrom 标识从 IDM_DISK_C 到 IDM_DISK_Z 中的一个驱动器状况按钮， OnTooltip 将 lpszText 指向 szDiskTip 字符串，并将其中的字符 x 所处的位置用 C 到 Z 的合适的驱动器字母代替。这样，由于这些工具提示大多只差一个字符，所以， DiskPie2 的工具提示很容易创建。

通过相似的技术，就可以写 D iskPie2 ，使它按要求生成它缺少的状态栏提示信息。状态栏提示信息需要进行大量的测试，来决定光标是位于一个工具栏按钮上，还是在菜单命令上。在空闲时间中， MFC 框架自动完成这些工作，通过程序的 CCmdUI 对象来连续更新状态栏。随时产生滚动提示信息的秘密只是提供足够的字符串资源，来利用框架的碰撞测试，然后，建立一个超越CStatusBar::OnSet 函数的完整的提示字符串。例如， D iskPie2 将在程序的 RC 文件里使用驱动器分配字母作为最小的提示字符串：

STRINGTABLE BEGIN

IDM_MEMORY " Memory usage" IDM_DISK_C " C "

IDM_DISK_D " D "

IDM_DISK_X " X "

IDM_DISK_Y " Y "

IDM_DISK_Z " Z "

END

要钩住 OnSetText 函数，你必须声明一个来自 CStatusBar 的类，并使用它在

CMainFrame 来创建状态栏：

class CStatusHook : public CStatusBar

{

protected;

afx_msg LRESULT OnSetText( WPARAM wParam, LPARAM lparam ); DECLARE_MESSAGE_MAP()

};

class CMainFrame : public CFrameWnd

{

DECLARE_DYNCREATE (CMainFrame)

private:

CStatusHook statusbar;

当系统要在状态栏里显示一个简单的提示字符串时，一个消息映射和 OnSetText 处理函数捕获发送的 WM_SETTEXT 消息。处理函数通过将这个单独的字符提示插入一个冗长的文本字符串里，来生成一个完整的提示字符串，将 lParam 重新指向构造的字符串，并传递控制到低级的 OnSetText 函数。现在，状态栏中不是只显示单独的字母，像“ C ”，而是更加有用的字符串，如“ D isk C usage chart ”。下面是处理函数建立这样一个提示字符串的方式：

BEGIN_MESSAGE_MAP (CStatusHook,CStatusBar) ON_MESSAGE( WM_SETTEXT,OnSetText )

END_MESSAGE_MAP ()

LRESULT CStatusHook::OnSetText( WPARAM wParam, LPARAM lparam )

{

// Constructed string must be static

static char szDisk[] = " Disk x usage chart\0 " ;

//If display is onl 1 character, convert it to full string if (lstrlen( (LPCTSTR) lparm )==1)

{

szDisk[5] = *((LPCTSTR) lparam); //Set drive letter lparam =(LPARAM) szDisk; //Repoint lparam

}

return CStatusBar::OnSetText( wParam, lparam );

}

只有在实现代码比它所代替的资源数据占用更少的空间时，在运行时生成提示字符串才物有所值。不管怎样，当提示字符串必须反映某些动态的程序状态时，例如用户输入的不能预料的只读字符串资源，这个技术有时是很有用的。

第 5 章对话框和控件

我们经常同时介绍对话框和控件，这是因为它们经常同时出现。控件是具有特殊用途的子窗口 ( 例如，按钮、复选框或进度指示器 )，而对话框是在其客户区内包含了一个或多个控件的父窗口。对话框和控件之间的联系非常密切，以至于我们干脆就将其整个组合叫做 “ 对话 ”。

许多对话 ( 例如 About 对话框 ) 的作用是向用户传递信息，而其他对话则用于询问输入信息，为键入文件名或单击按钮做出选择提供一个方便的地方。如果此时你想起了工具栏，那么你就对了，工具栏就是对话的一种类型。像工具栏一样，大多数对话都是组成程序资源的用户界面元素的组成部分。

然而，有些对话框则不是程序资源数据的组成。像消息框这样的对话，以及所谓的通用对话是由系统提供的，它们可以通过像 M essageBox 和 GetOpenFileName 这样的 API 函数或像 CFileDialog 这样的 MFC 类来调用。你甚至可以在运行时使用 D ialogIndirect API 函数为一个程序设计和创建对话，这个 API 函数可以把结构作为输入，而不是来自该程序的资源区域的数据。这样的对话严格说来属于编程问题，而不是你在 Visual C++ 中创建的资源，因此，你在这里找不到有关它们的任何讨论。

本章将接着前一章讨论资源数据的另一方面。首先，我们将看一看在项目的 RC 文件中定义对话的资源脚本，然后进入 Visual C++ 对话编辑器，在那里，可以像单击一样轻松地进行对话设计。本章将用几个例程来说明编辑器的功能，其中有一个例子显示了如何创建属性表 ( 也多选项卡对话 )。

对话脚本

向程序中添加对话是件很容易的事情。每个对话都在资源数据区中做为一系列命令而存在，而这些命令是由该项目的 RC 文件中的脚本编译而来的。它们用来指定诸如对话窗口大小、标题栏中的标题以及控件的放置之类的详细资料。要修改对话，通常仅仅需要在 RC 文件中编辑脚本。

为了举一个例子，让我们来看一看第 4 章的 Resource ，在那里， AppWzard 将在Help 菜单上生成一个命令，并为 Abou t（关于）框生成所有必需的源代码，以及具有当前在 Windows 程序中越来越普遍的其他特征。 AppWizard 还在项目的 RC 文件中编写用来定义对话及控件外观的脚本。

下面是该脚本的另一种表示：

IDD_ABOUTBOX DIALOG DISCARDABLE 0, 0, 217, 55

CAPTION "About Demo"

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

FONT 8, "MS Sans Serif" BEGIN

ICON IDR_MAINFRAME,IDC_STATIC,11,17,20,20

LTEXT "Demo Version 1.0",

IDC_STATIC,40,10,119,8,SS_NOPREFIX

DEFPUSHBUTTON "OK",IDOK,178,7,32,14,WS_GROUP

END

脚本的第一行用符号 IDD_ABOUTBOX 来标识资源，该符号在项目的 Resource.h 文件中定义。 DISCARDABLE 关键字后面跟着的四个数字，用来指定对话的大小。前两个数字 (0 ， 0) 用来设定对话窗口左上角的原点坐标。脚本中的所有其他坐标都相对于原点，正值的 X 是向右，正值的 Y 是向下。后两个数用来确定对话窗口的尺寸，在本例中，窗口的宽度是 217 个单元，高度是 55 个单元。

对话单元不是像素，而且，在 X 和 Y 方向上代表的距离也不一定相同。对话单元的尺寸取决于用于对话文字的字体，而对话字体在默认状态下为系统字体 ( 在上面的脚本中，可选的 FONT 指令将对话字体指定为 8 磅 MS Sans Serif) 。水平X 方向的一个对话单元等于用于该对话字体的 1/4 平均字符宽。在垂直 Y 方向，一个对话单元是 1/8 字符高。因为在 W indows 采用的字体测量系统里面，将字符高度作为字体的大小，因此，对于一个使用了 8 磅字体的对话来说，一个垂直对话单元就是 1 磅，或 1/12 英寸。

尽管与可视化控件相比，完成控件的布局要复杂些，但将对话单元与字体大小结合起来，就意昧着一个对话框将在不同的屏幕分辨率下保持同一尺寸。它还可以确保当对话的字体改变时，控件之间的相对位置保持不变，虽然大一点儿或小一点儿的字体仅仅是导致对话窗口及其内容在尺寸上扩大或缩小。在运行时，在对话窗口之中放置控件的程序应该首先通过调用 GetDialogBaseUnits API 函数来确定该对话的 “ 基本单元 ”。基本单元定义了当前屏幕分辨率下的对话单元与像素之间的关系。 M apDialogRect 函数可以自动实现会话，将对话单元中的坐标翻译成相等数量的屏幕像素。 M S D N 在线帮助十分详细地介绍了这两个 API 函数。

对话脚本中的 STYLE 伪指令指定了影响对话外观的各种标志，例如，为对话提供标题栏的 WS_CAPTION 标志。DS_MODALFRAME 标志与对话的模态样式无关，它仅仅取决于程序创建对话的方式。模态样式的意思是，在对话可见期间，只有属于其他程序的窗口才可以接收输入焦点，因此，用户在运行负责该对话的程序 ( 或至少是线程 )之前必须先关闭它。例如， Abou t（关于）框就是模态对话，

它可以阻塞程序执行，直至被放弃。非模态对话则不太明显，它允许用户不必关闭对话，就可以在程序内切换到另一个窗口。Visual C++ 文本编辑器的 Find 命令是非模态对话的好例子。将要在本章稍后介绍的名为 Color 的范例程序，说明了如何使用 Visual C++ 来创建非模态样式的对话。

尽管名字叫做 W S_SYSMENU ，但这个标志只不过是在对话标题栏的最右边放置了一个 Close 按钮而已，因为子窗口控件是不会有真正的系统菜单的。可选的CAPTION 指令指定了将要在标题栏中出现的文字。

对话的控件定义语句被括在 BEGIN 和 END 语句之间。每条定义都包含有与脚本第一行一样的相同类型的四数字系列。在那里，前两个数字给出了控件左上角相对于对话原点的 X 和 Y 坐标，后两个数字用于指定控件窗口的宽度和高度。再重复一遍，所有的坐标和尺寸都是以对话单元表示的。

这个对话脚本为 About （关于）框提供了一个标签为 O K 的推压式按钮，以及三个静态控件，其中一个控件包含有程序图标的一个副本。我们将在本章后面的范例代码中遇到这些控件及其他控件。如果想获得包括有普遍控件在内的一个完整控件列表，请访问 MSDN 在线帮助，或查阅一些参考书，例如 Charles Petzold 编著的 Programming Windows 95 （ Windows 95 编程）。

你可以对 AppWizard 提供的 About 对话进行改进。如果没有别的改进的话，就在版权行中添上你的名字。让我们首先来看一看 Visual C++ 对话编辑器，然后使用这个编辑器向 AppWizard 创建的对话框中添加一些其他东西。

对话编辑器

在以前进行 W indows 编程的时候，开发者们设计对话框的过程大概是这样的，它们不得不在 RC 文件中编写脚本，然后，再编译和运行程序，才能看到对话框实际的样子。这个不断摸索反复试验的过程，通常需要反复多次，才能正确地放置控件，并使其工作。但是，那个时代已经结束了。就是这个资源编辑器而不是其他任何东西，使得 Visual C++ 变得 “ 形象 ” 了，一旦你已经开始用对话编辑器来设计对话，那么就再也不用回到旧方法了。你不仅可以通过单击几下鼠标，把专业质量的对话放在一起，当你创建它的时候，看着它在屏幕上形成表单，而且还可以在编辑器中对对话的工作模态进行测试。控件看上去不对吗 ? 想改变助记键吗 ? 利用这个编辑器，修改工作会很轻松愉快。当你完成之后，也就知道了对话的确切工作方式以及它们在运行程序中的样子。正如我们将要在下一章中看到的，对话编辑器与 ClassWizard 结合得也很好，后者可以自动生成代码，来初始化和检索来自对话控件的数据。

至于其他资源，你可能会发现，通过使用文本编辑器编辑 RC 文件，以便更容易地对现有的对话脚本做出小小的修改。这一点儿都没有错。但对大多数修改来说，特别是当你创建一个新对话的时候，对话编辑器应该是你最好的选择。与其他的 Visual C++ 资源编辑器类似，可以用两种方法之一来启动对话编辑器，究竟使用哪一种方法取决于你是想创建一个新对话框，还是想继续使用已经在项目的RC 文件中存在的那个对话框。如果想从头开始创建一个新对话框，请单击 Insert

（插入）菜单上的 Resource 来打开 Insert Resource （插入资源）框，然后从列表中选择 D ialog ：

致谢 - 图123

展开 Insert Resource 框中的 D ialog 条目，将展现出代表特殊对话形状的标识符，例如具有工具栏尺寸的 IDD_DIALOGBAR 。如果想创建一个带有默认的 O K 和

Cancel 按钮的通用对话，请双击 D ialog 而不展开它。

如果想继续在现有的对话上工作，请打开项目。并且单击 Workspac e（工作空间）窗口 ResourceView（资源视图）窗格中列出的对话标识符。如果你想在非当前项目的一个项目中编辑对话，请单击 File （文件）菜单，并打开另一个项目的 RC 文件。该操作将打开其他项目的资源列表，你可以从中选取需要的对话框。不过，你不能将该资源存入当前的项目，原因是 Visual C++ 不能将来自 RC 文件的对话脚本合并到另一个对话脚本之中。文本编辑器为将另一个项目的对话复制到当前的项目提供了最现实的办法。可以按照第 4 章中介绍的方法在文本编辑器中打开其他项目的 RC 文件，选择和复制所需要的脚本，并将其粘贴进当前的 RC 文件。另外，还要在项目 Resource.h 文件中定义必要的标识符。然后，你就可以打开当前项目中的资源，并对其进行正常的编辑了。

图 5-1 显示了用于 Demo 这个虚构的 AppWizard 项目的 Workspace（工作空间）窗口，在里面，单击 ADD_ABOUTBOX 标识符，可以启动对话编辑器，并加载程序的 About （关于）框对话。

致谢 - 图124

图 5-1 在 Workspace 窗口中，双击一个对话标识符，将启动对话编辑器

为现有的对话启动对话编辑器的时候，该编辑器将读取 RC 文件的脚本，并且在编辑器工作区中复制这个对话 (如果 Workspace 或 Output（输出）窗口处于连接模式之中，它可能会覆盖掉对话编辑器窗口。如果是这样的话，请右击每个覆盖

的窗口，并从上下文菜单中选择 H ide（隐藏）命令 )。图 5-2 显示了已加载到编辑器中准备修改的 Demo 的 About 对话框。

尽管这样看上去已经足够真实了，但图 5-2 中的 Abou t（关于）框只不过是一个没有运行的演示图片而已。单击对话工作区中的按钮或编辑框，可以选中控件，但不激活它。图 5-2 中所显示的规则指导是可选的，但是，你可能通过从 Layout

（布局）菜单中选择 Guide Settin g（s 指南设置）来将它们关闭。这两个叫做 Controls

和 Dialog 的工具栏需要详细解释一下。

致谢 - 图125

图 5-2 对话编辑器

Contro l（控件）工具栏

利用 Control（控件）工具栏，你可以单击访问对话窗口中放置的控件。单击代

表你想要的工具栏按钮，并且，将控件从工具栏拖入到对话框中的位置。在你拖动的时候，一个点划线的矩形显示了控件窗口的轮廓，这样，在你释放鼠标按钮放置控件之前，就可以对控件的尺寸和位置一目了然。另一种方法是，只需在从Controls （控件）工具栏选中一个按钮，然后，在对话窗口的任何地方单击即可。控件窗口将在单击位置的中心地方出现。图 5-3 标识了 Controls （控件）工具栏上可以提供的控件类型。

一旦已经把自己想要的控件从 Controls （控件）工具栏拖进了对话区，那么，下面就是在自己喜欢的位置安排控件了。D ialo g（对话）工具栏可以为你提供帮助，但是，首先我们必须来讨论一下在对话中选中控件窗口。

致谢 - 图126

图 5-3 Controls 工具栏

选择和安排控件

将控件窗口拖入对话框的时候，在该控件周围包围着一个有阴影的矩形，这就表示该控件已被选中了。阴影的选择矩形有八个尺寸控制柄，它们是放置在矩形四角和四边的小正方形。像在 W indows 中的典型操作一样，你可以通过用鼠标指针来拖动一个尺寸控制柄，来调整选中的控件，或者如果想更加精确地进行调整的话，还可以通过按箭头键的同时按下 Shift 键来完成。每按一次，控件的尺寸改变一个单位。你还可以通过在工作内的任何地方而不是在控件窗口上单击，来选中和调整对话框本身。

当你将控件窗口拖入对话的时候，没有必要对其进行仔细定位，因为移动已经就位的控件是很容易的。单击对话工作区中的控件来选中控件窗口，然后使用鼠标拖动或使用箭头键移动它。为了更好地对齐，可单击 D ialo g（对话）工具栏上的Toggle Grid （开关网格）按钮打开网格。

致谢 - 图127

当可以在对话窗口中看到网格的时候，控件仅从一个网格行移向另一个网格行，这个特征就是大家熟知的 “ 与网格对齐 ”。在默认状态下，水平和垂直网格间距是 5 个对话单位，但你可以在图 5-4 所示的 Grid Settings（网格设置）对话框中改变这个对话框。

致谢 - 图128

图 5.4 Guide Setting 框

如果与网格对齐特征阻碍你按照自己的方式来安排控件，那么只需将其关闭即可。如果你后来又打开了，编辑器不影响对话框中已经存在的控件窗口的放置。如果想临时抑制一下此特征，请在拖动控件的时候按 Alt 键。

每次将几个控件作为一组而不是单独一个进行移动或调整往往更加方便。对话编辑器为同时选中几个控件提供了两种方法。第一种方法是在按住 Shift 键的同时依次单击你想选中的控件。第二种方法最适于成组安排的控件。单击 Control s（控件）工具栏上的 Selectio n（选择）工具，并将虚线矩形拖到控件上面来选中它们。图 5-5 说明了这个过程。

如果你想取消对所选组中某个控件的选中，请在按住 Shift 键的同时单击该控件。还可以用同样的方法向组中添加控件。选中了多个控件之后，在选中组中，除了一个控件之外，除有控件的尺寸控制柄全都显示为空的，以表明它们处于非激活状态。剩下的那个具有实尺寸控制柄的控件被认为是选中组中的支配控件，编辑器可以从中确定作为整体的选中组的调整或对齐方式。例如，图 5-5 中的Check1 控件就是选中的组中的三个控件的支配控件，因为它是唯一具有实尺寸控制柄的控件。在按下 Ctrl 键的同时，单击选中组中的另一个控件，可以使其成为新的支配控件。

致谢 - 图129

图 5-5 同时选中几个控件

仅有实尺寸控制柄处于活动状态；如果尺寸控制柄是空的，那么该控件就不能在

这个方向上进行调整。组合框控件仅仅在两边上具有活动的尺寸控制柄。这是因为通常看不到的控件下拉区域边是控件窗口的一部分，在建立窗口尺寸的时候，必须将其考虑进来。图 5-6 说明了如何改变组合框控件下拉区域的尺寸。

你可以创建控件的一个副本，并通过在按下 Ctrl 键的时候拖动控件窗口，来将其放在工作区中，如图 5-7 所示。该操作将创建一个新窗口，除了具有自己的标识符值外，它就是原始窗口的 “ 克隆 ” 体。

致谢 - 图130

图 5-6 改变组合框的尺寸

致谢 - 图131

图 5-7 在对话编辑器中复制控件窗口

Dialog （对话）工具栏

既然你已经知道了如何选中一组控件，那么，图 5-8 所示的 D ialog（对话）工具栏就更有意义了。在对话中四处拖动控件是找到合适位置的好办法，但是，如果要精确对齐控件窗口，你应该使用 D ialog （对话）工具栏上的工具。利用它们，你可以在对话框内部对齐了的行和列中放置控件窗口，为对话提供整齐的和专业的外观。这个工具栏上还有一个测试模式开关，它允许你将新的对话用于测试驱动程序，来看看它在实际中的外观和行为。

致谢 - 图132

图 5-8 Dialog （对话）工具栏

所有的 D ialo g（对话）工具栏按钮在 Layou t（布局）菜单上都具有功能相同的命令，因此，如果你不想看见工具栏的话，还可以把它关闭。如果想显示或隐藏工具栏，请从 Tools （工具）菜单中选择 Customize（自定义），单击 Toolbars （工具栏）选项卡，然后单击列表中的 Dialog（对话）复选框。

正如你在图 5-8 中所看到的，工具栏将按钮安排在五个逻辑组中，它们分别用于对齐、居中、间隔、调整控件的尺寸，以及打开和关闭网格和标尺指南。在图

中呈现为灰色的对齐、间隔和尺寸调整工具，仅仅当
对话中选中了两个或多个控件时才被启用。

下面几节将阐述 D ialo g（对话）工具的几个效果。通常，为了将一组控件放到所需要的位置，需要采用几个工具。因此，你必须考虑一下应用工具的顺序。不过，即使做错了也没关系。如果一个工具的效果不合适，只需单击 Edit（编辑）菜单上的 Undo （撤消）即可。

对齐工具

对齐工具的作用是将所选组的控件与支配控件对齐。例如，单击 Align Left（左对齐）按钮，将改变选中控件的 X 坐标，以便与支配控件的 X 坐标和匹配，而不影响 Y 坐标。

致谢 - 图133

居中工具

居中工具可以作用于单个选中控件或一组控件，将选中部分放在对话客户区的水平或垂直中心。

致谢 - 图134

间隔工具

间隔工具仅仅在包含有三个或更多控件的选中组上才能工作。在 D ialog （对话）工具中，它们是独一无二的，因为它不能区分哪一个选中控件是支配控件。水平间隔将改变选中组中除了最左边和最右边控件之外的 X 坐标，使水平方向的控件均匀排列。垂直间隔工具完成 Y 坐标方向上相同的工作，使控件在垂直方向上均匀分布。在下列中，垂直间隔工具 ( 编辑器为它取了个容易引起混淆的名字， Space Dow n（向下间隔） ) 调整的仅仅是 Appl y（应用）按钮， O K 和 Cancel 按钮

依旧在原来的位置不变。

致谢 - 图135

尺寸调整工具

尺寸调整工具作用于包含有两个或更多控件的选中组。尺寸调整并不移动控件窗口，而仅仅改变选中的控件的高度和宽度，以便与选中部分中支配控件的尺寸相配。

致谢 - 图136

控件属性

对话工作区中的每个控件都有一个 Properties （属性）对话框，你可以在里面为控件指定标识符和值，键入标签，设置适合于控件窗口的样式标志。如果想展现控件的 Properties（属性）框，请右击工作区中的控件窗口，并从弹出的上下文菜单上选择 Propertie s。你还可以选中一个控件，并单击 View （查看）菜单上的Properties 命令。每个控件类型的 Properties （属性）对话在外观和内容上略有不同。图 5-9 显示了一个复选框控件的 Properties （属性）框。

致谢 - 图137

图 5-9 一个复选框控件的 Properties（属性）对话

在第 4 章中，你可能已经习惯于在 Visual C++ 图形编辑器中双击一个项目来打开合适的 Properties（属性）框了，但该项技术在对话编辑器中则不具有相同的效果。双击对话工作区中的一个控件窗口可以导致三个结果之一，这主要取决于环境和控件类型。

如果控件接受用户输入，双击控件窗口，将调用一个
题为 Add Function

（添加函数）的对话，它允许你为这个控件快速添加存根处理程序函数。

双击静态控件或对话窗口，将在文本编辑器中打开对

话类的源文件，并在构造器中放置插入符。
如果项目没有 ClassWizard 数据库 CLW 文件（将在下章介绍

)，那么双击非静态控件的一个控件将没有任何效果。这种行为不同于版本 5 ，在版本 5 中，没有 CLW 文件时，双击将显示该控件的 Properties （属性）框。

如果控件接受用户输入，例如复选框或滑块控件，那么，当你键入控件标题的时候，将分配一个独一无二的助记键。利用助记键，用户通过按下键盘上的一个键，可以将输入焦点移到控件上。前一章介绍了用于菜单命令的助记键，用于标签的助记键也没有什么差别。只需要在任何字符前加上 “ 与 ” 符号 (& )，将字符作为控件的助记键标识即可。例如图 5-9 中的复选框就具有标题 “ &Red ”，在里面，助记键是字母 “ R ”。

对于滑块控件或像编辑框这样的文字条目控件，应在静态控件标签中为其分配助记键，下面是一个简单的例子：

致谢 - 图138

在这种情况下，按 A lt+D 将把焦点放在 Date 编辑框中，按下 A lt+A ，将把焦点放在 Amount 编辑框中 ( 当两个编辑框都没有焦点时， A lt 键是可选的 )。为了使助记键工作，每个编辑框必须按照按 Tab 键的移动顺序排列它的静态控件标签。

按 Tab 键的移动顺序

助记键并不是为某个控件分配输入焦点的唯一办法。用户可以用鼠标单击控件，或通过反复按 Tab 键跳到某一控件。每当系统检测到 Tab 键的时候，它就把输入焦点移动到 Tab 键移动顺序的下一个控件。

按 Tab 键的移动顺序可以由 RC 文件对话脚本的控件语句顺序中推出。例如，当在下面脚本中定义的对话出现的时候， IDC_COMBO1 组合框控件就具有了输入焦点。按下 Tab 键，将输入焦点从 IDC_COMBO1 控件按显示的顺序移到另一个控件。当 ID_CANCEL 按钮具有了焦点之后，再次按下 Tab 键，将把焦点循环回IDC_COMBO1 的开始处。

IDD_DEMO_DLG DIALOG 0, 0, 247, 65

STYLE DS_MODALFRAME | DS_3DLOOK | WS_POPUP | WS_VISIBLE | WS_CAPTION

CAPTION " Demo Dialog " FONT 8, " MS Sans Serif" BEGIN

COMBOBOX IDC_COMB01,15,15,159,80,WS_VSCROLL |

WS_TABSTOP | CBS_DROPDOWN|CBS_AUTOHSCROLL CONTROL " and " ,IDC_RADI01, " Button " ,BS_AUTORADIOBUTTON |

WS_TABSTOP,14,39,25,10

CONTROL " or" ,IDC_RADI02 ," Button " ,BS_AUTORADIOBUTTON | WS_TABSTOP,44,39,20,10

COMBOBOX IDC_COMBO2,69,39,106,80,WS_VSCROLL | WS_GROUP | WS_TABSTOP | CBS_DROPDOWN | CBS_AUTOSCROLL

DEFPUSHBUTTON " OK " ,IDOK,196,12,44,17,WS_GROUP

PUSHBUTTON " Cancel" ,ID_CANCEL,196,34,44,17,WS_GROUP

END

对话编辑器可以将你与 RC 文件中的详细信息隔离开来，但是，你仍然需要留心询问用户输入对话中 Tab 键的移动顺序。检查顺序通常是你在单击 D ialo g（对话）工具栏上的测试开关之前所做的最后一件事情。从 Layou t（布局）菜单选择 Tab Orde r（ Tab 次序），可以显示当前对话的 Tab 键移动顺序，该顺序是作为序号码

在对话控件附近出现的。下面是在前面的脚本中定义的用于对话的工作区：

致谢 - 图139

如果想修改 Tab 键的移动顺序，请单击以第一个控件开头的序列中的每个控件，也就是当对话首次出现时，你想让其具有输入焦点的那个控件。如果现有的顺序仅仅对于某一点来说是正确的，那么，你可能会发现，只改变错误的是很容易的。在单击具有最高的正确 Tab 键的移动顺序号的控件窗口的同时按下 Ctrl 键，然后释放 Ctrl 键，并继续单击所要求顺序中的控件，直到顺序正确为止。例如，如果想改变控件 4 到 6 的顺序，请在按下 Ctrl 键的时候单击控件 3 ，然后依次单击你想让其拥有制表号 4 ， 5 和 6 的控件。按 Enter 键设置顺序并返回到编辑模式。

对于成组出现的控件，例如单选按钮和复选框，改正 Tab 键的移动顺序特别重要。第 6 章将主要介绍 Tab 键的移动顺序，以及它在使一组单选按钮互斥 ( 在一组按钮中设置一个将自动清除其他按钮 ) 中所起的作用。

例 1 ：修改 Abou t对话

这里是演示对话编辑器的一些功能的简单例子。假定你想修正一下前一章中为虚

构的 Demo 项目所引入的 Abo u （t 关于）框。图 5-10 显示了一种可能的修改结果，

它也是用于虚构程序 SpifDemo 的 Abou t（关于）框，它制作得更加精心。

致谢 - 图140

图 5-10 修改后的 Abou t（关于）框

位图标志事先在 Visual C++ 图形编辑器中创建，并保存在名为 XYZCorp.bmp 的

文件之中。除此之外，在对话编辑器中所做的改动只用几个步骤即可完成，所花的时间也就 5 分钟。如果你想试着自己修改 About （关于）框，那么，可以以一个名为 Demo 的免费分布的 AppWizard 项目作为开始。然后按如下步骤进行操作。

**创建标志：**单击 Inse r（t 插入）菜单上的 Resourc e（资
源），并选中 Bitmap

（位图），来启动 Visual C++ 图形编辑器。设计标志位图，从 View（查

看）菜单选择 Properties ，来为新的位图资源提供标识符，并指定文件名。完成之后单击 File （文件）菜单上的 Save （保存）。

启动对话编辑器并加载 Abou t（关于）框： 在

Workspace（工作空间）窗口的 ResourceView 窗格中，双击 IDD_ABOUTBOX 来启动对话编辑器。
调整对话的尺寸： 通过单击没有被控件占据的灰

色对话框里面的任何地方，来选中对话窗口，并拖动底部尺寸调整控制柄来扩大窗口。
改变标题： 在对话窗口处于选中状态的时候，单

击 View（查看）菜单上的 Properties 命令，并在 D ialog Properties （对话属性）框中重新编写标题。
添加标志： 在对话工作区中选中 MFC 图标，通过按

Del 键将其删除，然后用在步骤 1 中创建的代表公司标志的新位图来代替它。如果想向

对话添加一个位图，请单击 Controls （控件）工具栏上的 Picture （图片）按钮，并将控件拖到对话中的任何地方（位置不需要十分精确）。在图形控件处于选中状态的时候，使用 Propertie s（属性）命令可以调用代表新图形控件的 Picture Propertie s（图片属性）框 ( 如果想选中像图片这样的空控件，请单击该控件周围的框架，原因是编辑器不能将框架里面的单击识别为以控件作为目标 )。从 Typ e（类型）框的列表中选择 Bitmap （位图），并在 Imag e（图像）框中键入位图标识符。一定要键入与在步骤 1 给定的相同的标识符。你可以按照同样的方式向对话中添加图标，只是应选择 Type （类型）框中的 Icon （图标），而不是 Bitmap（位图）。

致谢 - 图141

编辑对话文字： 对话中每两行文字就是一个静态
控件。为每个静态控件调用 Text Propertie s（属性）框，并修改 Captio n（标题）框中的文字。在上例中，将 “ Dem o ” 改为 “ SpitfyDem o”，版权行扩展为包括 XYZ Corporation 。在原来文字中用 \251 代替 “ (C )” 版权符号， \251 是 AXSI

字符的八进制代码 ( 如果想获得你想用相同方式添加到文字控件的其他

ANSI 字符列表，请参考附录 A )。

**添加电话号码：**该步骤需要用 Contro l （s 控件）工具
栏提供的 Group Box

（组框）工具和 Static Tex t（静态文本）工具。首先，单击 Group Box

（组框）按钮，并将它的图像移动到对话框的下半空白区域。在需要的时候将其扩大，然后再次单击 Propertie s（属性）命令打开 Group Box Properties （组框属性）对话，并将标题改为 “ Phone Numbers ”，下一步，单击 Static tex t（静态文本）按钮，并将其拖到对话中的组合框里面。在静态控件窗口仍处于选中状态的时候，通过在按住 Ctrl 键的同时短距离地拖动控件，可以创建它的多个副本。将这些副本拖到独立的行上，一个接一个地放置。在这个阶段，对齐并不是很重要的，因为以后可以更加仔细地进行。

致谢 - 图142

在默认状态下，静态控件包含有单个单词 “ Static ”。为这三个静态控件中的每一个打开 Text Properties（属性）对话，并在 Caption（标题）框中用新文字和电话号码代替“ Static ”。单击位于 Properties 对话左上角的按钉按钮，可以阻止它在两个选择之间消失。

\t 制表符在三个静态控件中为电话号码留空，并将它们对齐，例如“ Sales:\t\t\t(206)555-1212 ”。不过，在 Caption 栏中键入 \t 字符将只为

静态控件扩展一个单空格，因此， \t 字符后面的文字可能不会在控件窗口中出现。如果看到它，你可以通过拖动控件的右尺寸调整控制柄来手工加长每个静态控件。

对齐控件： 打开网格，并使用鼠标拖动控件就位
。三个带有电话号码的文字控件应当被对齐，而且被均匀排列。在你所希望的地方设置第一行，然后选中全部三行，并且单击 D ialo g（对话）工具栏上的 Align

Left（左对齐）和 Space Down （向下间隔）按钮。

致谢 - 图143

如果想使对话的外观均衡，在上面的例子中，还可以扩大 O K 按钮。只需单击该按钮便可选中它，然后根据需要拖动尺寸调整控制柄即可。

测试： 单击 D ialog （对话）工具栏上的测试驱动开
关，可以看看完成以后的作品是什么样子。如果想返回编辑模式，请单击对话的 OK 按钮，或按 ESC 。

保存自己的工作之后，对话编辑器将用修改后的 Abou t（关于）框所对应的新脚本覆盖文件中原来的脚本。

IDD_ABOUTBOX DIALOG DISCARDABLE 0, 0, 217,129

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION " About XYZ SpiffyDemo" FONT 8, " MS Sans Serif "

BEGIN

CONTROL IDB_XYZCORP,IDC_STATIC ," Static " , SS_BITMAP,17,16,85,10

LTEXT " SpiffyDemo Version 1.0 " , IDC_STATIC,21,33,119,8,SS_NOPREFIX

续表

IDC_STATIC,21,45,119,8

DEFPUSHBUTTON " OK " ,IDOK,166,15,32,40,WS_GROUP

GROUPBOX " Phone Numbers" ,IDC_STATIC,17,65,181,56

LTEXT " Technical Support:\t(206) 555-1212 " , IDC_STATIC,33,82,140,8

LTEXT " Customer Service:\t(206) 555-1212 " , IDC_STATIC,33,94,142,8

LTEXT " Sales:\t\t\t(206) 555-1212 " , IDC_STATIC,33,106,141,8

END

该脚本的第一个 CONTROL 语句引用 IDB_XYZCORP 位图，该位图包含步骤 1 中用图形编辑器创建的公司标志。资源编辑器知道到哪里去找 IOB_XYZCORP 位图，因为图形编辑器已在 RC 文件中其他地方记录了文件名。

IDB_XYZCORP BIPMAP MOVEABLE PORE " yes\\xyzcorp.bmp"

例 2 ：简单的非模态对话框

About 是模态对话框，直到单击 OK 关闭对话之后，它才允许用户继续在程序中工作。相反，非模态对话框就允许用户在同一程序中切换到另一个窗口，并且继续工作。而对话仍在屏幕上保留，直到被退出。

对话是模态的，还是非模态的，仅仅取决于程序在运行时间创建该对话的方式。你可以用相同的方法设计模态和非模态对话框。只有一点例外：非模态对话框必须具有样式标志 WS_VISIBLE 。该标志可以这样设定，在对话工作区中右击，并从上下文菜单中选择 Properties 来调用 D ialog Properties （对话属性）框。然后，打开 More Style （其他风格）选项卡中的 Visible （可见性）复选框：

致谢 - 图144

该操作将把 WS_VISIBLE 标志添加到 RC 文件中该对话脚本的 STYLE 语句。

C 程序通过调用 CreatDialog API 函数或者它的一个变种 ( 例如，CreatDialogIndirect

来创建一个非模态对话：

hDig=CreateDialog(hInst,MAKEINTRESOURCE(IDD_DIALOG1),

hwnd,DlgProc) ；

在本例中， hInst 是程序的实例句柄， IDD_DIALOG1 是 RC 文件中代表该对话脚本的标识符，hwnd 是对话拥有者的句柄，D igProc 是指向运行该脚本及接收它的

消息的过程的指针。

使用 MFC 的 C++ 程序用 CDialog::Create 函数来创建非模态对话。下面几行假定

CMyDlg 类是由 MFC 的 CDialog 派生出来的：

CMyDly*pDlg=new Cmydlg;

Ddlg Create(IDD_DIALOG,this);

CDialog::Create 和 CDiglog::Domodel 之间有一个重要的差异。因为后一个函数创建的是模态对话。直到对话关闭，它才会返回。而 Create 可以立即返回，在非模态对话保留在屏幕上的时候，允许程序继续运行。对话在程序关闭它之前，将一直存在：

delete pDlg;

在本节展示的 Color 程序中，显示了带有三个滑块控件 ( 也叫轨迹条 )的非模态对话，这三个滑块可以调整主窗口背景颜色的红、绿、蓝组成。当你用鼠标或箭头键移动滑块的时候，主窗口的颜色将根据新的颜色组成而变化，颜色值可能在 0 到 255 之间变化。如果视频硬件足够的话，从理论上讲，你可以通过移动滑动栏来显示 16777216(256 ³ ) 种不同颜色中的任一种。图 5-11 显示了带有非模态的 Color 对话的程序窗口。

Color 是一个 MFC 程序，但不是用 AppWizard 创建的 ( 下节将显示如何在AppWizard 应用程序中创建新对话 )。 Color 项目开始是选中 New 对话 Properties 选项卡中的 Win32 Application 图标。键入 Color 作为项目名，单击 O K 。通过单击 Insert（插入）菜单上的 Resource，并双击资源类型列表中的 D ialog 来启动对话编辑器。新的对话是以出现默认的 OK 和 Cancel 按钮作为开始的；在工作区中选中这些按钮，并按 Delete 来删除它们。

致谢 - 图145

图 5-11 Color 程序

致谢 - 图146

Color 对话仅仅包含三个不同的类型，它们是由来自编辑器的 Controls （控件）工具栏的 Static Tex t（静态文本） ,Button （按钮）和 Slide r（滑块）工具创建的。

滑块栏在对话中形成了三条分界线，在图 5-11 中分别标为 Red, Green 和 Blue 。为了创建 Red (上 ) 线，首先需要在两个静态文本控件之间放置一个滑块控件，然后所有的控件都要对齐，并留出间隔。将文本控件的标题初始化为 Red ，并在Text Properties 对话中键入 X 。X 的作用是充当 Color 在运行期间用滑块位置的新值进行覆盖的占位符。为滑块控件分配一个静态边缘的边框和一个具有指针的按钮。这些样式可以在 Slider Propertie s（滑块属性）对话中进行设置，可以通过右击对话中的滑块控件窗口，并选择 Properties 来设置：

在 Style （样式）选项卡中，在拇指样式的 Point（指向
）框中选中

Bottom/Righ t（底部 /右边）。

在 Extender Style（扩展样式）选项卡中，单击 Static Edg
e（静态边缘）复选框。

Green 和 Blue 线的创建方法与 Red 线完全相同，通过将 Red 的三个控件做为一组选中来复制，然后按照前一章中介绍的方法，在按下 Ctrl 的同时拖动该组控件。这时候，对话编辑器工作区看上去与下图类似，完成该对话仅仅需要将第二个和第三个标题分别改为 Green 和 Blue，将控件对齐，并在对话窗口的底部添加O K 按钮。为该按钮分配一个标识符 IDOK ，并设置该按钮的 Propertie s（属性）对话 Styles 选项卡中的 Default Button （默认按钮）复选框。

致谢 - 图147

在复制选定了的控件的时候，对话编辑器将自动为新的控件分配不同的标识符符号，以确保该对话中的每个控件都被独一无二地标识。新的符号与原来的符号具

有相同的名字，只是后面添加了数字。例如，第一行的 Red 滑块控件将分配一个名为 IDC_SLIDE_RED 的标识符。当你通过复制 Red 线来创建 Green 和 Blue 线的时候，编辑器将为新控件分配名为 IDC_SLIDE_RED1 和 IDC_SLIDE_RED2 的标识符 ( 在 Color 程序中，以后将在 Properties（属性）框中把每个控件的标识符改为 IDC_SLIDE_GREEN 的 IDC_SLIDE_BLUE )。在保存这个对话的时候，编辑器将在 Resource.h 文件中为新的标识符写下 #define 语句。结果总结如下：

Color 对话中的控件标识符

	上行	中行	下行
Color 控件	静态	IDC_STATIC	IDC_STATIC	IDC_STATIC
滑块控	件	IDC_SLIDE_RE D	IDC_SLIDE_GREEN	IDC_SLIDE_BL UE
X 静态	控件	IDC_STATIC_R ED	IDC_STATIC_GREE N	IDC_STATIC_BL UE

Color

控件

静态

IDC_STATIC

滑块控

件

IDC_SLIDE_RE D

IDC_SLIDE_GREEN

IDC_SLIDE_BL UE

X 静态

控件

IDC_STATIC_R ED

IDC_STATIC_GREE N

IDC_STATIC_BL UE

Color 静态控件 ( 最左面的控件 ) 的标题应该是 Red ， Green 和 Blue。最右边的控件的标题是所有三条线的 X 。

Color 的源代码仅需要一个主文件，两个名为 Resource.h 和 Color.h 的头文件，以及一个定义了对话的名为 Color.re 的资源脚本文件。源程序列表如下 ( 见列表 5- 1)：

列表 5-1 ： Color 程序的源代码

// ********************************************************************

#include "resource.h"

#include "afxres.h"

AFX_IDI_STD_FRAME ICON "res\\Color.ico"

IDR_MAINFRAME MENU

BEGIN

POPUP "&Options"

BEGIN

MENUITEM "&Color", IDM_COLOR

MENUITEM SEPARATOR

MENUITEM "E&xit", ID_APP_EXIT

END

POPUP "&Help"

BEGIN

MENUITEM "&About Color...", ID_APP_ABOUT

END

IDD_ABOUTBOX DIALOG 0, 0, 240, 65

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "About Color"

FONT 8, "MS Sans Serif"

BEGIN

BEGI N

LTEXT "Red",IDC_STATIC,16,15,14,8

LTEXT "Green",IDC_STATIC,16,49,20,8

LTEXT "Blue",IDC_STATIC,16,83,14,8

CONTROL "Slider1",IDC_SLIDE_RED,"msctls_trackbar32",

TBS_NOTICKS | WS_TABSTOP,42,10,106,21,

WS_EX_STATICEDGE

CONTROL "Slider1",IDC_SLIDE_GREEN,"msctls_trackbar32",

TBS_NOTICKS | WS_TABSTOP,42,44,106,21,

WS_EX_STATICEDGE

CONTROL "Slider1",IDC_SLIDE_BLUE,"msctls_trackbar32",

TBS_NOTICKS | WS_TABSTOP,42,78,106,21,

#include "Resource.h"

class CColorApp : public CWinApp

{

public:

virtual BOOLInitInstance();

};

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CColorDlg dialog

class CColorDlg : public CDialog

{

public:

int nColor[3];

BOOL bCreate;

CColorDlg ();

protected:

virtual BOOLOnInitDialog ();

virtual voidOnOK ();

afx_msg voidOnCancel ();

afx_msg voidOnHScroll( UINT nCode, UINT nPos, CScrollBar* pScroll );

DECLARE_MESSAGE_MAP()

};

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CMainFrame

class CMainFrame : public CFrameWnd

{

public:

CColorDlg* pColorDlg;

CMainFrame();

~CMainFrame();

protected:

afx_msg voidOnAbout();

afx_msg BOOLOnEraseBkgnd( CDC* pDC );

afx_msg voidOnColor();

DECLARE_MESSAGE_MAP()

};

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CAboutDlg dialog

class CAboutDlg : public CDialog

{

public:

CAboutDlg();

};

CAboutDlg::CAboutDlg() : CDialog( IDD_ABOUTBOX )

{

}

Color.cpp

// ********************************************************************

// Color.cpp

// ********************************************************************

#define VC_EXTRALEAN

#include <afxwin.h>

#include <afxcmn.h>

#include "Color.h"

CColorApp theApp;

BOOL CColorApp::InitInstance()

{

m_pMainWnd = new CMainFrame;

m_pMainWnd->ShowWindow( m_nCmdShow );

m_pMainWnd->UpdateWindow ();

return TRUE;

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CMainFrame

BEGIN_MESSAGE_MAP (CMainFrame, CFrameWnd)

ON_COMMAND (IDM_COLOR, OnColor)

ON_COMMAND (ID_APP_ABOUT, OnAbout)

ON_WM_ERASEBKGND ()

END_MESSAGE_MAP ()

CMainFrame::CMainFrame ()

{

pColorDlg = new CColorDlg;

Create(NULL, "Color", WS_OVERLAPPEDWINDOW, rectDefault, NULL,

MAKEINTRESOURCE (IDR_MAINFRAME) );

}

CMainFrame::~CMainFrame ()

{

delete pColorDlg;

}

void CMainFrame::OnColor()

{

if (pColorDlg->bCreate) // If the dialog already exists,

pColorDlg->SetFocus(); // give it focus

else // Otherwise, create it

{

if (pColorDlg->Create( IDD_COLOR_DIALOG, this ))

pColorDlg->bCreate = TRUE;

}

BOOL CMainFrame::OnEraseBkgnd( CDC* pDC )

{

Cbrush brush;

CRect rect;

COLORREF rgbBackGnd = RGB ((BYTE) pColorDlg->nColor[0],

(BYTE) pColorDlg->nColor[1],

(BYTE) pColorDlg->nColor[2]);

GetClientRect( &rect );

brush.CreateSolidBrush( rgbBackGnd );

pDC->FillRect( rect, &brush );

return TRUE;

}

void CMainFrame::OnAbout()

{

CAboutDlg aboutDlg;

aboutDlg.DoModal();

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / // CColorDlg dialog BEGIN_MESSAGE_MAP (CColorDlg, CDialog) ON_WM_HSCROLL () END_MESSAGE_MAP () CColorDlg::CColorDlg ()
{
	nColor[0] = nColor[1] =	0; 128;	// Initial color is // medium-intensity green
	nColor[2] = bCreate =	0; FALSE;	// Haven't created the dialog yet
}

BOOL CColorDlg::OnInitDialog ()

{

CSliderCtrl* pSlide[3];

CString szColorValue;

int i;

for (i=0; i < 3; i++)

{

pSlide[i] = (CSliderCtrl*) GetDlgItem( IDC_SLIDE_RED + i );

pSlide[i]->SetRange( 0, 255 );

pSlide[i]->SetPos( nColor[i] );

szColorValue.Format( "%d", nColor[i] );

SetDlgItemText( i + IDC_STATIC_RED, szColorValue );

}

SetIcon( AfxGetApp()->LoadIcon( AFX_IDI_STD_FRAME ), FALSE );

return TRUE;

}

void CColorDlg::OnHScroll( UINT nCode, UINT nPos, CScrollBar* pScroll )

{

CSliderCtrl* pSlide = (CSliderCtrl*) pScroll;

CString szColorValue;

int i = pSlide->GetDlgCtrlID () - IDC_SLIDE_RED;

nColor[i] = pSlide->GetPos (); // Slider position is

szColorValue.Format( "%d", nColor[i] ); // component 0-255

// Write current component value in the "x" static control

SetDlgItemText( i + IDC_STATIC_RED, szColorValue );

AfxGetMainWnd()->Invalidate ();

}

void CColorDlg::OnOK ()

{

OnCancel (); // Close dialog when OK Clicked

}

// Close on (1) OK button; (2) Esc key; or (3) dialog's Close command

void CColorDlg::OnCancel ()

{

if (DestroyWindow ())

((CMainFrame*) AfxGetMainWnd())->pColorDlg->bCreate = FALSE;

}

程序的所有主要工作是由两个类来实现的，它们分别是用于主窗口的CMainFrame ，以及一个名为 Ccolordlg 的 Cdialog 派生类，它的作用是用来驱动非模态对话框。 CColorDlg 构造器初始化一个代表主窗口的背景颜色值的数组，它以中等密度的绿色开始。既然窗口背景颜色的红、绿和蓝成份可从 0 变到 255 ，那么， OnInitDialog 函数可以把每个滑块滚动范围设为从 0 到 255 。这就意味着，该范围内的一个整数可代表任何一个时刻的拇指按钮的位置，可以很方便地确定颜色成分的当前值。

当用户移动滑块拇指的时候， CColorDlg::OnHScroll 函数就获得控制权，并指出哪个滑块正在通过调用 GetDlgCtrlID 被移动。该函数然后调用 GetPos 来获得新的拇指位置，将该值写到 nColor 数组和对话中的静态文字控件之中，并且调用Invalidate 函数。

对 Invalidate 的调用将导致操作系统向主窗口发送一条 WH_ERASEBKGND 消息，告诉该窗口为自己重新上色。该消息为像 Color 这样的应用程序提供了一个为自己填上背景颜色的机会。大多数应用程序都忽略 W M _ERASEBKGND 消息，在这些情形中，W indows 将使用程序在创建窗口时所指定的默认背景颜色不为窗口上色 ( 通常是白的 )。 Color.cpp 在它的 CMainFrame::OnEraseBKGnd 函数中截住了 WM_ERASEBKGND 消息，该函数在存储在 nColor 数组中的红、绿和蓝颜色组成的当前值的基础之上，声明了 COLORREF 对象：

COLORREF rgbBackGnd = RGB ((BYTE) pColorDog->nColor[0],

(BYTE) pColorDog->nColor[1], (BYTE) pColorDog->nColor[2],

OnEraseBkGnd 然后从 rgbBackGnd 中创建画刷，并使用它为窗口上色，并且返回一个值 TURE 。 TRUE 返回值用来告诉操作系统，它不应该用默认的颜色清除窗口，因为应用程序已经重新上了背景颜色。

所有这些都是为了解释为什么程序要在创建主窗口之前采取特殊的步骤来创建非模态对话控件：

CMainFrame::CMainFrame ()

{

pColorDlg = new CColorDlg;

Create( NULL, " Color" , WS_OVERLAPPEDWINDOW, rectDefault, NULL, MAKEINTRESOURCE (IDR_MAINFRAME) );

}

在主窗口出现之后，操作系统立即发送 WM_ERASEBKGND 消息，因此，首先创建 CColorDlg 对象，可以确保 OnEraseDKGnd 函数读到 nColor 数组中有效的颜色值。

例 3 ：向 AppWizard 程序添加对话

如果你愿意在 AppWizard 的帮助下开始项目，那么，前一节中的 Color 程序看上去就与此没有关系了。实际上，它是有关的。向程序添加新对话将调用相同的步骤，不管是否由 AppWizard 创建这个程序。但 AppWizard 将生成精确表单的代码，它与 Color.cpp 的紧凑样式相匹配可能会有点儿困难。为显示在向 AppWizard 程序中添加新对话中引用了什么，本节将演示使用 AppWizard 范例程序 MFcTree 的必要步骤。

图 5-12 所显示的 M fcTree 对话并不稀奇，仅仅是一些 MFC 类和一个 O K 按钮的树状视图。但它却可以很好地用来演示要说明的问题，在本章稍后和第 13 章，我们还要对其进行改进。

致谢 - 图148

图 5-12 MfcTree 程序

该程序的创建过程可分为五步：

运行 AppWizard 创建 M fcTree 项目。
在对话编辑器中创建对话资源。
向项目添加新的对话类的资源文件。
修改菜单。
向项目资源文件添加必要的源代码。下面，我们来一

步一步地进行。

步骤 1 ：运行 AppWizard 来创建 M fcTree项目

在 File （文件）菜单上单击 New ，并在 New 对话中选中 Projects 选项卡。选择MFC AppWizard (exe) 图标，并将新项目命名为 MfcTree，然后单击 OK 按钮运行AppWizard 。除了如下说明的例外选项外，其他均接受 AppWizard 的默认设置。这些例外是，在步骤 1 中选中 Single Document Interfac e（单文档界面），在步骤 4中清除掉用于停靠工具栏和打印支持的复选框。如果想在配套 CD 上保持短文件名，那么默认的 M fcTreeDoc 和 MfcTreeView 文件名应改为 M fcDoc 和 M fcView ，但这个步骤完全是可选的。

步骤 2 ：创建 M fcTree 对话

既然 M fcTree 是一个打开的项目，那么，我们就可以设计它的对话资源。通过单

击 Insert（插入）菜单上的 Resource，并双击资源类型列表中的 D ialog 来启动资源对话框。在工作区中选中默认的 Cancel 按钮，并按 Del 键来删除该按钮。在对话工作区内任何地方右击，并从上下文菜单中选择 Properties 来引用 D ialog Properties （属性）框。将对话标题改为 M fcTree ，将对话标识符改为IDC_MFC_DIALOG 。

致谢 - 图149

下一步是添加树状视图控件，从 Controls （控件）工具栏中，将 Tree Contro l（树状控件）工具拖入对话工作区，并根据需要调整对话工作区和控件的大小。单击View （查看）菜单上的 Properties 来调用 Tree Control Propertie s（树状控件属性）框，并将标识符符号改为 IDC_MFC_TREE 。在 Style 选项卡中，单击 Has Buttons

（有按钮）， Has Lines （有线）和 Lines At Roo t（根位置的线）复选框，如下图所示：

致谢 - 图150

这些样式改变将向列表视图添加小的加号或减号图标，当单击这些图标的时候，将折叠或展开列表层次中的各级。使用本章前面介绍的水平间隔工具将 O K 按钮移到对话和中心两个控件的底部。现在，对话在编辑工作区中的样子如图所示：

致谢 - 图151

从 Fil e（文件）菜单选择 Save ，将新对话脚本保存到 M fcTree.rc 文件。Visual C++ 自动向 Resource 文件添加代表新标识符的 #define 语句。通过单击 File （文件）菜单上的 Close 命令关闭对话编辑器。

步骤 3 ：为 C M fcDlg 对话类添加源文件

我们现在已经拥有了一个新的对话资源，但是，需要从 CDialog 派生的一个类才能运行它。在下一章中，我们将会看到如何使用 ClassWizard 来生成主体的对话类，并自动将它的文件添加到项目中，但目前，我们只能使用文本编辑器来完成相同的工作。为包含新的 CMfcDlg 对话类 ( 列表 5-2) 而创建源文件 C M fD lg.h 和M fcDlg.cpp 。现在我们只需要这些很少的文件，就能将 CMfcDlg 类添加到项目。我们将在步骤 5 中将源代码添加到文件。

如果想从头开始为一个像 M fcTree 这样的开放项目创建新的源文件，请将箭头停在 Project（项目）菜单的 Add To Project（添加到项目）命令上，然后，单击随后出现的次级菜单上的 New 。选择你想创建的文件，并输入文件名。单击 O K 启动文本编辑器，编辑器中将出现一个空的文档窗口。

列表 5-2 ： CMfcDlg 类的主体源文件

MfcDlg. h

// ********************************************************************

// MfcDlg.h

// ********************************************************************

class CMfcDlg : public CDialog

{

public:

CMfcDlg( CWnd* pParent = NULL );

protected:

virtual BOOL OnInitDialog();

};

MfcDlg.cpp

// ********************************************************************

// MfcDlg.cpp

// ********************************************************************

#include "stdafx.h"

#include "MfcTree.h"

#include "MfcDlg.h"

CMfcDlg::CMfcDlg( CWnd* pParent ) :

如果你在文本编辑器中键入了两个源文件，完成之后，一定要把它们保存到项目文件夹。另一种方法是，你可以从配套 CD 上的 Chapter.os\MfcTree 文件夹中复制这两个文件的完整形式。复制文件需要你将它们手工添加到项目。在弹出的次级菜单上选择 Add To Project，并单击 Files ，然后双击文件列表中的 MfcDlg.cpp 文件，将它添加到项目之中。

致谢 - 图152

不必用相同的方法来添加 M fcDlg.h 文件，因为 Visual C++ 将头文件识别为

M fcDlg.cpp 的相关文件。

步骤 4 ：修改菜单

M fcTree 需要一个菜单命令来调用对话，但是，不需要 AppWizard 放在菜单上的其他命令。使用第 4 章中介绍的 Visual C++ 菜单编辑器将 M fcTree 的菜单修改成如下的样子。

致谢 - 图153

在菜单编辑器中，双击 Workspace （工作空间）窗口的 ResourceView 窗格中的IDR_MAINFRAME 菜单标识符可以打开资源。在菜单编辑器中，双击 MFcTree 菜单来显示 Menu Item Properties （菜单项属性）框。键入 IDM_OPTION_MFC 作为项目的标识符，然后按 ENTER 键。

步骤 5 ：添加需要的源代码

如果按照步骤 3 中所列出的代码键入了 MfcDlg.cpp 文件，该文件仅仅包含一个类构造器和一个叫做 OnInitDialog 的存根函数。 OnInitDialog 函数需要用下面显示的带阴影的代码，来初始化树形视图控件。正如你所看到的，它可以用许多指令来初始化树形视图。如果你通过自己创建 M fcTree 来顺着这些步骤进行操作，那么没有必要键入所有的行。只需键入头一组，或者从配套 CD 的Chapter.os\MfcTree 文件夹中的 MfcDlg.cpp 源文件中进行剪切和粘贴即可。

OnInitDialog 函数用来初始化一个名为 PTree 的指针，该指针指向的是作为IDC_MFe_TRUE 标识的对话的树形窗口控件。该函数然后重复调用 Ctree Ctrl::nsertItem 函数来向控制添加一个包含有从 CWnd 派生的 MFe 类的层次列表。项目被插入到层次中比它的父层低一级的列表之中，第二个参数或者是以前为父层级调用 InsertItem 所返回的 MTREEITEM 值，或者是值 TVI_ROOT ( 如果没有父层的话 )。 TV1_SORT 标志指示树形视窗控件将该项目按字母顺序排序：

BOOL CMfcDlg::OnInitDialog()

{

hRoot = pTree->InsertItem( "Control bars", TVI_ROOT, TVI_SORT );

hLevel1 = pTree->InsertItem( "CControlBar", hRoot );

hLevel2 = pTree->InsertItem( "CDialogBar", hLevel1 );

hLevel2 = pTree->InsertItem( "COleResizeBar", hLevel1 );

hLevel2 = pTree->InsertItem( "CStatusBar", hLevel1 );

hLevel2 = pTree->InsertItem( "CToolBar", hLevel1 );

hRoot = pTree->InsertItem( "Other windows", TVI_ROOT, TVI_SORT );

hLevel1 = pTree->InsertItem( "CPropertySheet", hRoot );

hLevel1 = pTree->InsertItem( "CSplitterWnd", hRoot );

hRoot = pTree->InsertItem( "Dialog boxes", TVI_ROOT, TVI_SORT );

hLevel1 = pTree->InsertItem( "CDialog", hRoot );

hLevel2 = pTree->InsertItem( "CCommonDialog", hLevel1 );

hLevel3 = pTree->InsertItem( "CColorDialog", hLevel2 );

hLevel3 = pTree->InsertItem( "CFileDialog", hLevel2 );

hLevel3 = pTree->InsertItem( "CFindReplaceDialog", hLevel2 );

hLevel3 = pTree->InsertItem( "CFontDialog", hLevel2 );

hLevel3 = pTree->InsertItem( "COleDialog", hLevel2 );

hLevel4 = pTree->InsertItem( "COleBusyDialog", hLevel3 );

hLevel4 = pTree->InsertItem( "COleChangeIconDialog", hLevel3 );

hLevel4 = pTree->InsertItem( "COleChangeSourceDialog", hLevel3 );

hLevel4 = pTree->InsertItem( "COleConvertDialog", hLevel3 );

hLevel4 = pTree->InsertItem( "COleInsertDialog", hLevel3 );

hLevel4 = pTree->InsertItem( "COleLinksDialog", hLevel3 );

hLevel5 = pTree->InsertItem( "COleUpdateDialog", hLevel4 );

hLevel4 = pTree->InsertItem( "COlepasteSpecialDialog", hLevel3 );

hLevel4 = pTree->InsertItem( "COlePropertiesDialog", hLevel3 );

hLevel3 = pTree->InsertItem( "CPageSetupDialog", hLevel2 );

hLevel3 = pTree->InsertItem( "CPrintDialog", hLevel2 );

hLevel2 = pTree->InsertItem( "COlePropertyPage", hLevel1 );

hLevel2 = pTree->InsertItem( "CPropertyPage", hLevel1 );

hRoot = pTree->InsertItem( "Views", TVI_ROOT, TVI_SORT );

hLevel1 = pTree->InsertItem( "CView", hRoot );

hLevel2 = pTree->InsertItem( "CCtrlView", hLevel1 );

hLevel3 = pTree->InsertItem( "CEditView", hLevel2 );

hLevel3 = pTree->InsertItem( "CListView", hLevel2 );

hLevel3 = pTree->InsertItem( "CRichEditView", hLevel2 );

hLevel3 = pTree->InsertItem( "CTreeView", hLevel2 );

hLevel2 = pTree->InsertItem( "CScrollView", hLevel1 );

hLevel3 = pTree->InsertItem( "CFormView", hLevel2 );

hLevel4 = pTree->InsertItem( "CDaoRecordView", hLevel3 );

hLevel4 = pTree->InsertItem( "CRecordView", hLevel3 );

hRoot = pTree->InsertItem( "Controls", TVI_ROOT, TVI_SORT );

hLevel1 = pTree->InsertItem( "CAnimateCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CButton", hRoot );

hLevel2 = pTree->InsertItem( "CBitmapButton", hLevel1 );

hLevel1 = pTree->InsertItem( "CComboBox", hRoot );

hLevel1 = pTree->InsertItem( "CEdit", hRoot );

hLevel1 = pTree->InsertItem( "CHeaderCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CHotKeyCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CListBox", hRoot );

hLevel2 = pTree->InsertItem( "CCheckListBox", hLevel1 );

hLevel2 = pTree->InsertItem( "CDragListBox", hLevel1 );

hLevel1 = pTree->InsertItem( "CListCtrl", hRoot );

hLevel1 = pTree->InsertItem( "COleCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CProgressCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CRichEditCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CScrollBar", hRoot );

hLevel1 = pTree->InsertItem( "CSliderCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CSpinButtonCtrl", hRoot );

hLevel1 = pTree->InsertItem( "CStatic", hRoot );

return TRUE;

}

尽管上面的代码目前可以工作，但是，这是十分不够的。第 13 章中所引入的

M fcTree3 程序显示了一个更加清楚的方法，来实现对 InsertItem 的一系列调用。

下一步，在文本编辑器中编辑文件 MfcTree.cpp 和 MfcTree.h ，并添加一个叫做OnMfcTree 的函数。当用户单击了程序的 Options 菜单上的 MFC TREE 命令的时候， OnMfcTree 处理函数就获得了控制。如果想添加 OnMfcTree ，请通过在

Workspa c （e 工作空间）窗口的 FileViews 窗格中双击其文件名，来打开 M fcTree.cpp

文档。在靠近源代码开始处插入如下代码：

#includ e "MfcDlg.h "

另外，编辑 MfcTree.cpp 中的消息映射，使它成为下面的样子：

BEGIN_MESSAGE_MAP(CMfcTreeApp, CWinApp)

//{{AFX_MSG_MAP(CMfcTreeApp) ON_COMMAND(ID_APP_ABOUT, OnAppAbout)

ON_COMMAND(IDM_OPTIONS_MFC , OnMfcTree )

//}}AFX_MSG_MAP END_MESSAGE_MAP()

将 OnMfcTree 函数添加到 MfcTree.cpp ：

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CMfcTreeApp message handlers

voi d CMfcTreeApp::OnMfcTree( )

并在 M fcTree.h 文件中声明它：

// Implementation

//{{AFX_MSG(CMfcTreeApp) afx_msg void OnAppAbout();

afx_ms g voi d OnMfcTree() ;

//}}AFX_MSG DECLARE_MESSAGE_MAP()

};

现在就准备创建 M fcTree 了。单击 Build 菜单上的 Set Active Configuratio n（设置有效配置）命令，来选中 W in32 Release 目标，然后就可以创建和测试这个应用程序。

基于对话的应用程序

M fcTree 的所有操作都在对话中而不是在主窗口中进行。如果程序将主窗口完全隐藏起来，仅仅显示对话，那么将更加方便，这可以省掉用户单击菜单命令来调用窗口的麻烦。以前，你曾经看到过这样的基于对话的应用程序，即 W indows 提供的 Character Map （字符映射表）， Calculator（计算器）和 Phone Dialer（电话拨号程序）实用程序，都是用来显示一个程序如何有效地通过代替主窗口的单个对话来与用户进行有效联系的例子。在本节中，我们将看到如何用 Visual C++ 编写基于对话的应用程序，并创建一个范例程序来演示这项技术。

用 C 编写的基于对话的应用程序不初始化 WNDCLASS 或 WNDCLASSEX 结构，不调用 RegisterClass 来注册窗口类。不调用 CreateWindow 来创建主窗口。它不调用 ShowWindow 和 UpdateWindow ，甚至没有调用 GetMessage 和D ispatch M essage 的消息循环。它不需要这些东西，与用户的所有交互都在对话中发生， W indows 可以处理它，程序仅仅需要创建类似于下面的对话即可：

int WINAPI WinMain( HINTANCE hInst, HINSTANCE hInstPrev,

LPSTR szCmdline, int nCmdShow)

{

DialogBox(hInst, MAKEINTRESOURCE (IDD_DIALOG),

NULL,DlgProc);

return( 0 );

}

在这个代码段中， IDD_DIALOG 值用来标识该程序的 RC 文件中的对话脚本。D lgProc 是一个指针，它指向的是接收像 WM_INITDIALOG 和 W M _ C O M M A N D 这样的系统消息的过程。

MFC 程序没有可见的 W inMain 函数或消息，因此，有关对话界面的代码数量减少了许多。但 MFC 提供了 AppWizard 的优点，它可以为基于对话的应用程序生成模板形式的代码。

例 4 ： M fcTree 的基于对话的版本

AppWizard 为基于对话的应用程序所编写的代码比它为一般的应用程序所生成

的代码更加清晰，更加易于理解。在 AppWizard 的 Step1( 如图 5-13 所示 ) 中单击D ialog Based 单选按钮，将导致 AppWizard 为两个类创建源文件，一个为应用程序，另一个为对话对象。

AppWizard 为仅包含一个 O K 按钮、一个 Cancel 按钮以及一个带有警告 “ Place dialog controls here （将对话控件放在这里）” 的静态控件的对话窗口生成资源脚本。如果你在 AppWizard 的步骤 2 中单击了 Content-Sensitive Help （与内容相关的帮助）复选框的话。该对话还包括一个 Help 按钮（如果想了解有关的详细信息，请参阅第 2 章 )。这种方法的思路是在创建项目之后，为你运行对话编辑器，并将应用程序需要的控件添加到对话中。

在 Visual C++ 版本 6.0 中，当 AppWizard 完成之后，对话编辑器将自动启动。在以前的版本中，你必须自己通过双击 ResourceView 窗口中的对话标识符才能启动。

致谢 - 图154

图 5-13 在 AppWizard 中创建基于对话的应用程序

用 AppWizard 创建 M fcTree 的基于对话的版本只需三个步骤，与前一节中的五个步骤对比如下：

步骤主窗口版本基于对话的版本

运行 AppWizard 创建项目 √ √
创建或修改对话 √ √
插入新对话类的源文件 √
修改菜单 √
添加所必需的源代码 √ √

为对话创建新类的步骤 3 和修改主菜单的步骤 4 ，在 MfcTree 基于对话的版本中是不需要的。 AppWizard 为对话类自动生成主体源文件，清除主窗口也取消了对菜单的需要。甚至 AppWizard 所生成的源代码也比较易于修改，因为你仅仅需要编辑 CMfDlg::OnInitDialog 函数，在该函数的 TODO 行后添加 InsertItem 调用和以前一样，下面代码段中的灰色阴影表示是新的源程序行，它们与以前介绍的添加到 M fcTree 的原始版本中的代码是一样的：

BOOL CMfcDlg::OnInitDialog()

{

Cdialog::OnInitDialog();

// TODO: Add extra initiallization here

//Ad d th e res t o f th e sourc e cod e her e

}

图 5-14 显示了 M fcTree ，这是它基于对话的版本。从本质上讲，除了主窗口已被清除，对话标题栏现在包含应用程序图标和系统菜单，并且程序更加易于创建和使用之外，它与图 5-12 中所显示的原始版本是同一个程序。如果你想自己试试这个新版本，可以在配套 CD 上 Chapteros\MfcTree2 文件类中找到它。

致谢 - 图155

图 5-14 MfcTree 程序基于对话的版本

例 5 ：不用 AppWizard 实现的基于对话的应用程序

在创建基于对话的应用程序的时候， AppWizard 起了很大的作用，因为这样的应用程序在方法上很一致，因此 AppWizard 添加你不想要的代码的可能性就很小。但 AppWizard 可能仍然满足不了你的特殊需要，如果你对不用 AppWizard 编写基于对话的应用程序感兴趣，那么本节将告诉你如何去做。它用名为 D irList1 的范例程序来进行说明，该程序的作用是在对话中显示一个目录列表。但是为了更加有趣，D irList1 展现给用户的对话是一个属性表，通常叫做多选项卡的对话框。

属性表可以向用户展示大量的信息，这就很好地解决了对话框过分拥挤的问题，但从本质上讲，属性表也仅仅是一个对话，或者可以说是一系列叫做页面的对话，这些页面一个盖着另一个，你可以像设计其他对话一样用对话编辑器设计属性表的每页。 RC 文件中一个页面的属性脚本看上去与普通的对话是一样的，只是属性表的所有页面都具有相同的大小。当程序调用 PropertySheet API 函数创建MFC CPropertySheet 对象的时候， Windows 将属性表页面做为对话来显示。

致谢 - 图156

偶然情况下，你可能会遇到对话编辑器的 Control s（控件）工具栏中的 Tab Control

（选项卡控件）的工具。这个控件显示一组可以在对话中充当属性表的分选项卡的页面，但并不将你的对话转化为属性表。

图 5-15 显示了 DirList1 属性对话的第一个和第二个页面，标签分别为 Location

和 Date 。

Date 选项卡利用新的 Date-Time Picke r（日期 - 时间选取器）控件，允许用户通过弹出的日历选择日期，尽管 Date 和 Size 页面可以正常工作，但是，该页面的存在仅仅是为了说明的目的，对程序的这个版本并没有影响 ( 第 7 章中将要介绍的 D irList2 项目，利用了 Date 和 Size 页 ) 。D irList1 中的重要活动在 Locatio n（位置）页中发生，它在一个列表框控件中显示一个目录列表。 DirList1 通过调用CWnd::DlgDirList 函数来用目录列表填充这个列表框。

DlgDirListDir,IDC_LIST,IDC_DIRPATH,DOL_ALL);

参数 pDir 指向以 null( 空 ) 结束的字符串，该字符串包含了目录路径。常数IDC_LIST 用来标识显示目录列表框控件， IDC_DIRPATH 用来标识一个静态控件， DLgDirList 把路径字符串写到这个控件里面。 DLL_ALL 是一个在源代码中定义的常数，它将标志 DDL_DRIV E ， DDL_DIRECTORT 和 DDL_HIDDEN 组合了起来。这些标志告诉 D lgDirList，在目录列表中包括驱动器、子目录和隐藏的文件。单击列表中的驱动器或子目录，将改变路径，并刷新列表。利用 Location 选项卡中标签为 Up 1 Directory Leve l（向上一级目录）的大按钮，用户可以回到上一级目录。

致谢 - 图157

图 5-15 DirList1 程序的 Location 和 Date 选项卡

D irList1 中的属性表对话仅用到了五种控件类型：推压按钮、单选按钮、列表框、编辑控件和微调框。如果你对这些控件的安装方式感兴趣，请打开 D irList.rc 文件，并且通过双击下图所示的一个对话标识符来启动对话编辑器。

致谢 - 图158

IDD_PAGE 1，IDD_PAGE2 和 IDD_PAGE3 分别用来标识对话的 Location 页，Date

页和 Size 页。列表 5-3 显示了 D irList1 项目的源代码。

列表 5-3 DirList1 的源程序文件

#define IDI_APPICON 105

#define IDC_DIRPATH 110

#define IDC_LIST 111

#define IDC_BUTTON1 120

#define IDC_EDIT1 121

#define IDC_EDIT2 122

#define IDC_RADIO1 123

#define IDC_RADIO2 124

#define IDC_RADIO3 125

#define IDC_RADIO4 126

#define IDC_SPIN1 127

#define IDC_SPIN2 128

#include "afxres.h"

IDI_APPICON ICON "res\\dirlist.ico"

STRINGTABLE

BEGIN

IDD_ABOUTBOX "&About DirList..."

END

IDD_ABOUTBOX DIALOG 0, 0, 240, 65

STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU

CAPTION "About Directory List"

FONT 8, "MS Sans Serif"

BEGIN

	LTEXT LTEXT	"Directory List Version 1.0",IDC_STATIC,45,10,115,8 """Microsoft Visual C++ Programmer's Guide""", IDC_STATIC,45,26,140,8
	LTEXT	"Copyright \251 1998, Beck Zaratian", IDC_STATIC,45,42,115,8
	DEFPUSHBUTTON	"OK",IDOK,195,10,35,40,WS_GROUP

END
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / /	/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
// // Property page 1 - "Location" // IDD_PAGE1 DIALOG 0, 0, 282, 135

EN D

CONTROL "&between",IDC_RADIO2,"Button",

BS_AUTORADIOBUTTON | WS_TABSTOP,100,23,43,10

CONTROL "&within previous",IDC_RADIO3,"Button",

BS_AUTORADIOBUTTON | WS_TABSTOP,100,80,63,10

CONTROL "within &previous",IDC_RADIO4,"Button",

BS_AUTORADIOBUTTON | WS_TABSTOP,100,105,63,10

GROUPBOX "Only files dated:",IDC_STATIC,70,10,200,115,WS_GROUP

CONTROL "DateTimePicker1",IDC_DATETIME1,"SysDateTimePick32",DTS_RI GHTALIGN | WS_TABSTOP,170,20,50,15

LTEXT "and",IDC_STATIC,128,50,13,8,NOT WS_GROUP

CONTROL "DateTimePicker1",IDC_DATETIME2,"SysDateTimePick32",DTS_RI GHTALIGN | WS_TABSTOP,170,45,50,15

EDITTEXT IDC_EDIT1,170,76,35,16,ES_NUMBER

// ********************************************************************

class CDirListApp : public CWinApp

{

public:

BOOL InitInstance ();

};

class CAboutDlg : public CDialog

{

public:

CAboutDlg();

};

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CPage1 property page

class CPage1 : public CPropertyPage

{

private:

BOOL bEditFocus;

CString strDirectory, strFilter;

void GetCurrentDirectory ();

void ShowList ();

public:

CPage1 () : CPropertyPage( IDD_PAGE1 ) {}

protected:

virtual void DoDataExchange( CDataExchange* pDX );

virtual BOOL OnInitDialog ();

afx_msg void OnEditGainFocus ();

afx_msg void OnEditLoseFocus ();

afx_msg void OnUp1Level ();

afx_msg void OnSelChange ();

DECLARE_MESSAGE_MAP ()

};

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CPage2 property page

class CPage2 : public CPropertyPage

{

public:

int nAnyDate;

Ctime timeMin, timeMax;

int PrevDays;

int PrevMonths;

CPage2 () : CPropertyPage( IDD_PAGE2 ) {}

protected:

virtual void Do DataExchange( CDataExchange* pDX );

virtual BOOL OnInitDialog ();

};

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CPage3 property page

class CPage3 : public CPropertyPage

{

public:

int nAnySize;

DWORD MinSize;

DWORD MaxSize;

CPage3 () : CPropertyPage( IDD_PAGE3 ) {}

protected:

virtual void DoDataExchange( CDataExchange* pDX );

virtual BOOL OnInitDialog ();

};

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CListSheet

class CListSheet : public CPropertySheet

{

public:

CPage1 page1;

CPage2 page2;

CPage3 page3;

CListSheet( LPCTSTR szCaption );

protected:

virtual BOOL OnInitDialog();

afx_msg void OnSysCommand( UINT nID, LPARAM lParam );

DECLARE_MESSAGE_MAP()

};

DirList1.cpp

// ********************************************************************

// DirList1.cpp

// ********************************************************************

#include "afxwin.h"

#include "afxdlgs.h"

#include "afxcmn.h"

#include "resource.h"

#include "dirlist1.h"

#define DDL_ALL DDL_DIRECT ORY | DDL_DRIVES | DDL_HIDDEN

CDirListApp DirListApp;

BOOL CDirListApp::InitInstance ()

{

CListSheet sh( "Directory List" ); // Create property sheet object

sh.DoModal (); // and display dialog

return FALSE; // Return FALSE to exit DirList

}

CAboutDlg::CAboutDlg() : CDialog( IDD_ABOUTBOX )

{

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CListSheet property sheet

CListSheet::CListSheet( LPCTSTR szCaption ) : CPropertySheet( szCaption )

{

AddPage( &page1 );

AddPage( &page2 );

AddPage( &page3 );

}

BEGIN_MESSAGE_MAP (CListSheet, CPropertySheet)

ON_WM_SYSCOMMAND()

END_MESSAGE_MAP()

BOOL CListSheet::OnInitDialog()

{

CPropertySheet::OnInitDialog();

// Add "About..." command to system menu

CMenu* pSysMenu = GetSystemMenu( FALSE );

CString str;

str.LoadString( IDD_ABOUTBOX );

pSysMenu->AppendMenu( MF_SEPARATOR );

pSysMenu->AppendMenu( MF_STRING, IDD_ABOUTBOX, str );

// Remove Apply button, since it's not needed

CButton* button = (CButton *) GetDlgItem( ID_APPLY_NOW );

button->DestroyWindow();

// Set the 16-by-16 image (see closing remarks in Chapter 5)

HICON hIcon = (HICON) ::LoadImage( DirListApp.m_hInstance,

MAKEINTRESOURCE( IDI_APPICON ),

IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR );

SetIcon( hIcon, FALSE );

return TRUE;

}

void CListSheet::OnSysCommand( UINT nID, LPARAM lParam )

{

if (nID == IDD_ABOUTBOX)

{

CAboutDlg dlgAbout;

dlgAbout.DoModal();

}

else

{

CPropertySheet::OnSysCommand( nID, lParam );

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CPage1 property page

BOOL CPage1::OnInitDialog ()

{

bEditFocus = FALSE;

strFilter = "*.*";

GetCurrentDirectory ();

ShowList ();

return CDialog::OnInitDialog ();

}

void CPage1::GetCurrentDirectory ()

{

PTSTR pDir = new char[MAX_PATH];

::GetCurrentDirectory( MAX_PATH, pDir );

strDirectory = pDir;

if(strDirectory.Right( 1 ) != "\\")

strDirectory += "\\"; // Append backslash

delete [] pDir;

}

void CPage1::ShowList ()

{

PTSTR pDir = new char[MAX_PATH];

lstrcpy( pDir, strDirectory );

lstrcat( pDir, strFilter );

DlgDirList( pDir, IDC_LIST, IDC_DIRPATH, DDL_ALL );

delete [] pDir;

}

BEGIN_MESSAGE_MAP (CPage1, CPropertyPage)

ON_EN_SETFOCUS (IDC_EDIT1, OnEditGainFocus)

ON_EN_KILLFOCUS (IDC_EDIT1, OnEditLoseFocus)

ON_BN_CLICKED(IDC_BUTTON1, OnUp1Level)

ON_LBN_SELCHANGE (IDC_LIST, OnSelChange)

END_MESSAGE_MAP ()

void CPage1::OnEditGainFocus ()

{

bEditFocus = TRUE;

}

void CPage1::OnEditLoseFocus ()

{

bEditFocus = FALSE;

GetDlgItemText( IDC_EDIT1, strFilter );

ShowList ();

}

void CPage1::OnUp1Level ()

{

// If Enter pressed in edit control, refresh list

if (bEditFocus)

{

GetDlgItemText( IDC_EDIT1, strFilter );

ShowList ();

}

// Else go up one directory level

else

{

// When strDirectory == "d:\", we're already at root

if (strDirectory.Right( 2 ) != ":\\")

{

// Remove '\' at end of string

strDirectory.GetBufferSetLength( strDirectory.GetLength() - 1 );

strDirectory.ReleaseBuffer ();

// Find last '\' and truncate strDirectory string

int cLastSlash = strDirectory.ReverseFind( '\\' );

if (cLastSlash != -1)

{

strDirectory.GetBufferSetLength( cLastSlash + 1 );

strDirectory.ReleaseBuffer ();

ShowList ();

}

void CPage1::OnSelChange ()

{

char szItem[MAX_PATH];

char *pItem = szItem;

int i;

i = SendDlgItemMessage( IDC_LIST, LB_GETCURSEL, 0, 0 ); SendDlgItemMessage( IDC_LIST, LB_GETTEXT, i, (LPARAM) szItem ); // We're interested only in drives [-d-] or subdirectories [subdir] if (szItem[0] == '[') { if (lstrcmp( szItem, "[..]" )) // Ignore parent directory "[..]" { pItem++; // Skip past first bracket '[' // If drive, change "[-d-]" to "d:"
if (pItem[0] == '-' {	&&	pItem[2] == '-')
pItem++;		// Skip past first hyphen '-'

i = SendDlgItemMessage( IDC_LIST, LB_GETCURSEL, 0, 0 ); SendDlgItemMessage( IDC_LIST, LB_GETTEXT, i, (LPARAM) szItem );

// We're interested only in drives [-d-] or subdirectories [subdir] if (szItem[0] == '[')

{

if (lstrcmp( szItem, "[..]" )) // Ignore parent directory "[..]"

{

pItem++; // Skip past first bracket '['

// If drive, change "[-d-]" to "d:"

if (pItem[0] == '-'

{

pItem[2] == '-')

pItem++;

// Skip past first hyphen '-'

pItem[1] = ':'; // Overwrite second '-' with ':'

pItem[2] = '\0'; // Truncate string

strDirectory = pItem; // New directory

}

// If subdir, change "[subdir]" to "subdir"

else

{

i = lstrlen( szItem );

pItem[i-2] = '\0'; // Overwrite ']' to truncate

strDirectory += pItem; // Append new subdirectory

}

strDirectory += "\\"; // Append backslash

ShowList (); // Refresh list

}

void CPage1::DoDataExchange( CDataExchange* pDX )

{

CPropertyPage::DoDataExchange( pDX );

DDX_Text( pDX, IDC_EDIT1, strFilter );

DDV_MaxChars( pDX, strFilter, 128 );

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CPage2 property page

BOOL CPage2::OnInitDialog ()

{

CSpinButtonCtrl* spin;

// Initialize variables

nAnyDate = 0;

PrevDays = 1;

PrevMonths = 1;

timeMin = 0;

timeMax = CTime::GetCurrentTime();

// Set limits of spin buttons

spin = (CSpinButtonCtrl *) GetDlgItem( IDC_SPIN1 );

spin->SetRange( 1, 100 ); // Within x months

spin = (CSpinButtonCtrl *) GetDlgItem( IDC_SPIN2 );

spin->SetRange( 1, 365 ); // Within x days

return CDialog::OnInitDialog ();

}

void CPage2::DoDataExchange( CDataExchange* pDX )

{

CPropertyPage::DoDataExchange( pDX );

DDX_DateTimeCtrl( pDX, IDC_DATETIME1, timeMin);

DDX_DateTimeCtrl( pDX, IDC_DATETIME2, timeMax);

DDX_Radio( pDX, IDC_RADIO1, nAnyDate );

DDX_Text( pDX, IDC_EDIT1, PrevMonths );

DDX_Text( pDX, IDC_EDIT2, PrevDays );

}

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

// CPage3 property page

BOOL CPage3::OnInitDialog ()

{

CSpinButtonCtrl* spin;

// Initialize variables

nAnySize = 0;

MinSize = 0;

MaxSize = 100;

// Set limits of spin buttons

spin = (CSpinButtonCtrl *) GetDlgItem( IDC_SPIN1 );

spin->SetRange( 0, 9999 ); // Min size

spin = (CSpinButtonCtrl *) GetDlgItem( IDC_SPIN2 );

spin->SetRange( 1, 9999 ); // Max size

return CDialog::OnInitDialog ();

}

void CPage3::DoDataExchange( CDataExchange* pDX )

{

CPropertyPage::DoDataExchange( pDX );

DDX_Radio( pDX, IDC_RADIO1, nAnySize );

DDX_Text( pDX, IDC_EDIT1, MinSize );

DDX_Text( pDX, IDC_EDIT2, MaxSize );

}

该程序的 InitInstance 函数首先创建一个 ClistSheet 对象，该对象是从 MFC 的

CPropertySheet 类中派生出来的。 DoModel 成员函数用来显示属性表：

CListSheet sh( “ Directory List” ); // Make propsheet object sh.DoModal (); // and display dialog

当该对象的 OnInitDialog 函数获得控制的时候，它向系统菜单添加一个调用该程序的 About 框的命令。然后删除不需要的 Apply 按钮，这个按钮是框架把它放在对话中的。 OnInitDialog 函数还演示了基于对话的应用程序是如何设置两个图标图像的，一个 16 × 16 像素的小图像作为对话标题栏上的应用程序图标， 32 × 32 像素的大图像将出现在 About （关于）框中。两个图像都在项目的 D irList.ico 文件之中。MFC 框架在创建应用程序窗口时将自动抽取大图像，因此， D irList1 必须通过调用第 4 章中介绍的 Load Image API 函数来自己调用小图像：

// Set the 16-by-16 icon image

HICON hIcon = (HICON) ::LoadImage( DirLsitApp.m_hInstance,

MAKEINTRESOURCE( IDI_APPICON ),

IMAGE_ICON,16,16,LR_DEFAULTCOLOR );

SetIcon( hIcon, FALSE );

在这种情况下，调用 LoadImage 是必要的，因为 LoadIcon 函数只能正确识别 32

× 32( 或更多 ) 像素的图像，一个尺寸与 SM_CXICON 和 SM_CYICON 系统计量值相匹配的图像。向 SetIcon 函数传递一个参数值 FALSE 可能把小的 16 × 16 图像设置为应用程序图标。

就其本身而言， ClistSheet 对象是一个空的对话窗口。 ClistSheet 构造器通过调用AddPage 成员函数来添加三个属性页。AddPage 将指针指向 CPropertyPage 对象，该对象是通过向 CPropertyPage 基本初始化程序传递对话标识符而创建的。例如，下面是 DirList1 为属性表的第一页声明 CPropertyPage 对象的代码：

public:

CPage1 ():CPropertyPage(IDD_PAGE1) {}

AddPage 函数负责将对话资源转换成带有选项卡的属性页，该选项卡上包含有对话标题，例如 Location 和 Size。

当准备显示第一页的时候，它的 CPage1::OnInitDialog 函数调用

GetCurrentDirectory API 函数，向当前路径添加 *.* 过滤器，并且调用 D lgDirList ，

将当前的目录列表写到列表框之中。 StrFilter 字符串包含有用户可以通过编辑控件改变的过滤器。程序最有趣的部分在 CPage1::OnSelChange 函数中，当用户选中了列表框中一个项目的时候，该函数便得到控制权。

如果用户选中了一个文件名，函数将忽略这个选择。如果选中的项目是磁盘驱动器，那么驱动器目标将代替 StrDirectory 中的路径，然后成为字符串 d:\，其中 d 是所选中的驱动器符号。在列表框中选定了一个子目录，将把子目录名添加到StrDirectory 中的路径。当路径改变的时候， OnSelChange 将调用 ShowList 来显示新路径的目录列表。OnSelChange 将按照 CWnd::DlgDirList 在列表框中写该文件名、驱动器和子目录的方式来在它们之间进行区分。驱动器符号包含在方括号和边字符之中，例如 [-a-] 或 [-c-]。子目录包括在没有连字符的方括号之中。文件名没有括号或连字符。

虽然调用 DlgDirList 添加目录列表具有一定的方便性，但该技术还存在着两个严重的缺陷。首先，目录列表不吸引人，并没有达到当前的 W indows 标准。其次， D lgDirList 只有在 W indows NT 下才能识别长文件名。出于这两方面的考虑，我们不得不完全放弃列表框，而来试一试其他东西。当我们创建了一个从 MFC 的CListView 中派生出来的新类，并将其添加到 Visual C++ 中叫做 Gallery 的组件集时，我们再来做这件事。

但是，目前有另一个问题比 Gallery 更加迫切。本章中已完成的一些工作可能就变得不必要了，或者至少是这样，它可以得到简化。你可能会记起，在创建

MFcTree 项目时，我们为 Mfclagh 和 M fcDlg.cpp 源文件编写了存根函数，并且将项目手工插入到一个消息映射之中。这些任务可以在 ClassWizard 中很容易地进行处理。 ClassWizard 是对话编辑器的天然伙伴；使用编辑器来设计对话，使ClassWizard 可以生成运行该对话的源代码。下一章将显示如何去做。

致 谢

美 国 微 软 出 版 社 授 权 的 标 准 、 权 威 、 完 整 的 中 文 图 书

北 京 希 望 电 脑 公 司 出 品

版 权 声 明

M icrosoft Visual C++ 6.0 程 序 员 指 南

北 京 希 望 电 脑 公 司 出 品

印 刷

致 谢

前 言

读 者 要 求

Visual C++ 简 史

本 书 内 容

第 一 部 分 ： 基 础 知 识

第 二 部 分 ： 编 辑 器

第 三 部 分 ： 编 程 指 南

第 四 部 分 ： ActiveX 控 件

第 五 部 分 ： 高 级 主 题

第 六 部 分 ： 附 录

范 例 代 码

附 带 光 盘

一 些 术 语 定 义

参 考 资 料

反 馈

目 录

第 1 章 环 境

工 具 栏 和 菜 单

环 境 窗 口

Wo rkspace （ 工 作 空 间 ） 窗 口 和 Ou tpu t（ 输 出 ） 窗 口

在 线 帮 助

MSDN 库

Contents （ 目 录 ） 选 项 卡

Index （ 索 引 ） 选 项 卡

Search （ 搜 索 ） 选 项 卡

运 算 符 例 子 结 果

Favorites （ 收 藏 ） 选 项 卡

访 问 万 维 网

在 开 发 环 境 之 外 工 作

第 2 章 A p p W izard （ 应 用 程 序 向 导 ）

AppWizard （ 应 用 程 序 向 导 ） 的 优 点

表 2-1 AppWizar d（ 应 用 程 序 向 导 ） 生 成 的 典 型 的 源 文 件 ， 斜 体 的 项 目 表 示 项目 名

运 行 AppWizard （ 应 用 程 序 向 导 ）

步 骤 1 ： 程 序 界 面

步 骤 2 ： 数 据 库 支 持

步 骤 3 ： OLE 和 ActiveX 支 持

步 骤 4 ： 用 户 界 面 特 征

被 调 用 的 函 数 当 用 户 做 如 下 事 情 的 时 候

步 骤 5 ： 使 用 MFC 库

步 骤 6 ： 类 和 文 件 名

用 AppWizard （ 应 用 程 序 向 导 ） 来 创 建 DLL 文 件

管 理 模 块 状 态

第 3 章 文 本 编 辑 器

启 动 文 本 编 辑 器

文 档

打 开 文 档

查 看 文 档

保 存 文 档

打 印 文 档

浏 览 文 档

表 3-2 文 本 编 辑 器 插 入 符 移 动 键

在 空 白 区 内 移 动

括 号 匹 配

书 签

文 本 搜 索

在 打 开 的 文 档 中 搜 索 文 本

在 已 打 开 的 文 档 中 替 换 文 本

在 磁 盘 文 件 中 搜 索 文 本

常 规 表 达 式 搜 索

编 程 辅 助 工 具

成 员 表

参 数 信 息

输 入 信 息

Advanced （ 高 级 ） 命 令

未 结 合 命 令

为 命 令 创 建 工 具 栏 按 钮

宏 的 基 础

定 制 编 辑 器

在 Developer Studio 之 外 编 辑 文 本

第 4 章 资 源

系 统 资 源

RC 资 源 脚 本 文 件

致谢

美国微软出版社授权的标准、权威、完整的中文图书

北京希望电脑公司出品

版权声明

M icrosoft Visual C++ 6.0 程序员指南

北京希望电脑公司出品

印刷

致谢

前言

读者要求

Visual C++ 简史

本书内容

第一部分：基础知识

第二部分：编辑器

第三部分：编程指南

第四部分： ActiveX 控件

第五部分：高级主题

第六部分：附录

范例代码

附带光盘

一些术语定义

参考资料

反馈

目录

第 1 章环境

工具栏和菜单

环境窗口

Wo rkspace （工作空间）窗口和 Ou tpu t（输出）窗口

在线帮助

Contents （目录）选项卡

Index （索引）选项卡

Search （搜索）选项卡

运算符例子结果

Favorites （收藏）选项卡

访问万维网

在开发环境之外工作

第 2 章 A p p W izard （应用程序向导）

AppWizard （应用程序向导）的优点

表 2-1 AppWizar d（应用程序向导）生成的典型的源文件，斜体的项目表示项目名

运行 AppWizard （应用程序向导）

步骤 1 ：程序界面

步骤 2 ：数据库支持

步骤 3 ： OLE 和 ActiveX 支持

步骤 4 ：用户界面特征

被调用的函数当用户做如下事情的时候

步骤 5 ：使用 MFC 库

步骤 6 ：类和文件名

用 AppWizard （应用程序向导）来创建 DLL 文件

管理模块状态

第 3 章文本编辑器

启动文本编辑器

文档

打开文档

查看文档

保存文档

打印文档

浏览文档

表 3-2 文本编辑器插入符移动键

在空白区内移动

括号匹配

书签

文本搜索

在打开的文档中搜索文本

在已打开的文档中替换文本

在磁盘文件中搜索文本

常规表达式搜索

编程辅助工具

成员表

参数信息

输入信息

Advanced （高级）命令

未结合命令

为命令创建工具栏按钮

宏的基础

定制编辑器

在 Developer Studio 之外编辑文本

第 4 章资源

系统资源

RC 资源脚本文件

Resource.h 头文件