标准C++开发入门与编程实践

20世纪80年代，Bjarne Stroustrup发明并实现了C++语言。一开始C++语言只是作为C语言的增强版（C with Classes）出现的，但是随着C++编程技术的发展，虚函数、运算符重载、多重继承、模板、异常、RTTI、名字空间等新的特性逐渐被加入C++。由此，1998年国际标准组织（ISO）正式颁布C++程序设计语言的国际标准ISO/IEC 14882?1998，即标准C++语言。

在OOP（面向对象编程）理论盛行的年代（其实也就是10年之前），几乎所有的C++教材，都在宣扬着一种论调：“C++是C的一个超集”，以此宣传C++的易学性和亲和力。实际上，这种说法在渐渐地发生改变。以Standley Lippman所著的《C++ Primer》一书为首的更多的言论认为，就目前学习C++而言，可以认为它是一门独立的语言。它兼容C语言，但是并不依赖C语言，我们完全可以不学习C语言，而直接学习C++语言。也就是说，阅读本书的读者，不必担心自己是否熟悉C语言。

C++语言发展至今，历受Java、C#语言的冲击，其优势及应用领域则变得愈来愈清晰明朗。C++语言目前仍然是专业编程人员的首选语言之一。但是C++语言是一门很复杂的语言。正因为如此，很多程序员仍然固执地认为：C++是唯一的真正的编程语言；很多学校仍然选择C++作为程序设计的第一门语言。这就要求C++初学者必须掌握合理的学习方法和正确的思维习惯，同时要保持足够的信心和耐心，才能真正学好C++语言。

ISO/IEC 14882?1998确立了C++的标准，遗憾的是，由于C++语言过于复杂，以及它经历了多年的演变，几乎没有一种编译器100%的完全符合标准。可喜的是，各家编译器也在努力提高对C++标准的兼容性。这就意味着，采用标准C++，可以在最大程度上使编写的代码具有可移植性；同样的代码，可以在超级计算机的分布式计算环境中和某个嵌入式系统中一样得以编译和运行。因此，当程序员看到一个有用的C++类库的时候，他的第一个问题会是：它是基于标准C++编写的吗？同样的，当读者看到一本新的C++图书上市时，他的第一个问题会是：这本书介绍的是标准的C++吗？

本书介绍的是标准的C++，其中大部分代码都在Microsoft Visual C++.NET 2003和Dev C++4.9.9.2中得以编译与运行。Visual C++.NET和Dev C++是Windows下两款优秀的C++开发工具，据称它们采用的C++编译器对C++标准的支持率分别达到98%和96%。

归结起来，本书具有如下特色：

• 注重知识的完整性。本书力求完整、系统地介绍C++的语法知识。书中同时安排了部分选读内容，并在节标题上以星号“*”标出，希望读者朋友们能够通过这些部分的阅读加深对前面知识的理解。 注重知识的趣味性。很多教材在保持了C++的严谨性的同时也拒绝了读者，特别是拒绝了我们可爱的C++初学者。初学者的耐心和信心很容易受到打击，本书努力让读者在失去耐心之前读完所有的C++知识。
• 注重C++的标准性。如上所述，标准性是本书一直努力遵循的原则。为了便于读者的理解，书中一些章节的某些编译器对C++标准的实现做了部分的猜测，希望读者朋友能够通过这些内容加深对C++的理解，但千万不要就此认为：所有的C++编译器都将采用同样的实现。
• 注重编程的实践性。本书的每一章节，甚至每一知识点，都配有格式化的代码示例。此外，本书第6篇特意安排了“C++编程实践”，介绍C++的标准库函数及实际操作指南，并结合一个《西游记》游戏的模拟程序演示了各种语法知识的综合运用，以方便读者学习。 本书内容系统、完整，共分为6篇24章。

第1篇：C++快速浏览篇。本篇介绍C++的语言背景和计算机数值系统知识，包括了解C++语言、计算机的数值表示和初识C++程序；结合示例工程HelloWorld，详细介绍C++编程的具体步骤，以及C++语言的基本元素，让读者对C++语言有个整体上的认识。 第2篇：C++数据表达篇。本篇介绍C++中的数据类型，即如何将现实中的数据表达出来，包括C++基础语法、数组与字符串（array & string）、指针与引用（pointer & reference）和自定义数据类型（UDT）等。 第3篇：C++过程设计篇。本篇介绍C++中的过程设计，即如何将静态的数据流动起来，实现程序的逻辑，包括C++流程控制、C++函数和预处理（preprocessing）等。 第4篇：C++面向对象编程篇。本篇介绍C++中的面向对象编程（OOP），即类的使用方法，包括C++类（class）、类的特殊函数、继承（inheritance）和多态（polymorphism）等。 第5篇：C++高级特性篇。本篇介绍C++的高级特性，读者一旦掌握了这些高级特性，就可以更好地实现C++编程，包括模板（template）、C++异常处理（exception handling）、名字空间与域和运行时类型信息（RTTI）等。 第6篇：C++编程实践篇。本篇结合C++的实际应用介绍C++的标准库函数以及实际操作指南，包括C++标准库、C++流、STL容器（STL container）、泛型算法（generic algorithm）、C++实践指南和综合实践：《西游记》游戏模拟等。 本书具有由浅入深、通俗易懂和注重实践等特点。本书由白乔编著，何洪波、杨汉玮、沈良忠参与了部分章节编写，并对内容安排提出了很好的意见和建议，在此一并感谢。希望读者能够通过本书的阅读，对标准C++有清晰的认识，并掌握真正实用的编程思想和方法，从而能在C++编程路上走得更远，这是我们最大的期望。

本书适合于没有或者缺乏C++程序设计经验的初学者作为标准C++语言的自学教材，同时也适合已掌握C++基础编程技术、需要提高C++实践能力（包括对标准库函数、STL、泛型算法的使用），以及对标准C++感兴趣的程序员进行阅读。

由于成书仓促，书中纰漏和欠缺之处在所难免，特别是关于C++标准之实现、C++实践指南等开放性的话题，言语之中有失偏颇之处，还望读者不吝赐教和批评。联系信箱：bluejoe2008@gmail.com，详情请垂询http://books.vcer.net/stdcpp。

目录：

第1篇  C++快速浏览

 

第1章  了解C++语言    3

1.1  编程语言    4

1.1.1  机器语言    4

1.1.2  汇编语言    4

1.1.3  高级语言    5

1.2  C++发展简史    6

1.3  C++开发环境    7

1.3.1  C++编译器    7

1.3.2  C++标准与编译器    8

1.3.3  C++开发环境    9

1.3.4  开发环境的选择    12

第2章  计算机的数值表示    15

2.1  进制系统    16

2.1.1  十进制    16

2.1.2  二进制    16

2.1.3  八进制和十六进制    17

2.2  数值的表示    19

2.2.1  整数的表示    19

2.2.2  负数的表示    19

2.2.3  整数的表示范围    20

2.2.4  浮点数的表示    20

2.2.5  观察数值的二进制表示*    22

2.3  字符的表示    23

2.3.1  ASCII码    23

2.3.2  汉字的编码    25

2.3.3  UNICODE编码    26

2.3.4  观察字符的二进制表示*    27

2.3.5  字符与字体    29

2.3.6  键盘与输入法    29

第3章  初识C++程序    33

3.1  开始C++编程    34

3.1.1  C++程序的开发流程    34

3.1.2  文件与工程（项目）    35

3.2  在Dev-C++中开发HelloWorld    37

3.2.1  编辑HelloWorld    38

3.2.2  编译连接HelloWorld    38

3.2.3  运行HelloWorld    39

3.3  在VC 2003中开发HelloWorld    39

3.3.1  编辑HelloWorld    40

3.3.2  编译连接Hello World    42

3.3.3  运行HelloWorld    43

3.4  可能遇到的问题    43

3.5  理解HelloWorld    45

3.5.1  main函数    45

3.5.2  函数    45

3.5.3  对象    46

3.5.4  头文件    46

3.5.5  名字空间    46

3.5.6  标准输入输出    47

3.5.7  编译器的行为    48

第2篇  C++数据表达

第4章  C++基础语法    51

4.1  理解c=2πr    52

4.2  注释    53

4.3  标识符    53

4.3.1  命名规则    53

4.3.2  关键字    54

4.4  数与类型    55

4.5  基本类型    55

4.5.1  整型    56

4.5.2  浮点型    56

4.5.3  布尔型    57

4.5.4  字符型    57

4.5.5  基本类型的字节长度*    57

4.6  字面常量    58

4.6.1  整型常量    59

4.6.2  浮点型常量    59

4.6.3  布尔型常量    59

4.6.4  字符型常量    60

4.6.5  字符串常量    60

4.6.6  字面常量的类型*    61

4.6.7  变量    62

4.7  语句    62

4.7.1  表达式    62

4.7.2  语句    62

4.7.3  声明语句    62

4.7.4  赋值语句    63

4.7.5  初始化语句    63

4.7.6  使用调试器观察变量值*    64

4.8  操作符    67

4.8.1  赋值操作符    67

4.8.2  算术操作符    68

4.8.3  关系操作符    69

4.8.4  逻辑操作符    69

4.8.5  条件操作符    70

4.8.6  位操作符    70

4.8.7  观察二进制位操作*    71

4.8.8  复合赋值操作符    72

4.8.9  逗号操作符    73

4.8.10  sizeof操作符    74

4.8.11  typeid操作符    74

4.8.12  操作符的优先级    75

4.9  类型转换    76

4.9.1  隐式转换    76

4.9.2  显式转换    76

4.9.3  算术转换*    77

第5章  数组与字符串    79

5.1  数组    80

5.1.1  数组的概念    80

5.1.2  内存中的数组*    80

5.1.3  数组的初始化    81

5.1.4  数组元素的访问    82

5.1.5  安全使用数组下标*    82

5.1.6  多维数组    83

5.2  字符串    85

5.2.1  传统的字符串    85

5.2.2  安全的使用字符串*    86

5.2.3  std::string    86

第6章  指针与引用    89

6.1  指针    90

6.1.1  指针的概念    90

6.1.2  取址操作符    91

6.1.3  取值操作符    91

6.1.4  深入理解指针*    91

6.1.5  指针的比较    92

6.1.6  指针的加减    93

6.1.7  理解指针的运算*    93

6.1.8  数组与指针    95

6.1.9  指针的指针    96

6.1.10  指针数组    96

6.2  引用    96

6.2.1  引用的概念    96

6.2.2  理解引用*    97

6.3  动态内存分配    98

6.3.1  new    98

6.3.2  delete    98

6.3.3  数组的内存分配    99

第7章  自定义数据类型    101

7.1  结构    102

7.1.1  结构的定义    102

7.1.2  定义结构变量    103

7.1.3  结构的数据成员    103

7.1.4  结构成员的引用    103

7.1.5  结构的初始化    104

7.1.6  位域    105

7.2  联合    106

7.2.1  联合的定义    106

7.2.2  使用联合    107

7.3  枚举    108

7.3.1  枚举定义    108

7.3.2  枚举与int    109

7.4  typedef    109

7.5  数据类型修饰符    110

7.5.1  const    110

7.5.2  volatile    112

第3篇  C++过程设计

第8章  C++流程控制    115

8.1  判断    116

8.1.1  if    116

8.1.2  语句块*    116

8.1.3  if…else    116

8.1.4  if…else if…else    117

8.1.5  流程图*    118

8.2  分支    118

8.3  循环    121

8.3.1  while    121

8.3.2  do…while    124

8.3.3  for    125

8.4  跳转语句    126

8.4.1  嵌套循环    126

8.4.2  使用break中止循环    127

8.4.3  使用break中止分支    128

8.4.4  continue    128

8.4.5  goto    129

8.4.6  合理使用goto语句*    130

第9章  C++函数    133

9.1  函数    134

9.1.1  函数    134

9.1.2  函数调用    134

9.1.3  使用调试器观察函数的调用*    135

9.1.4  函数参数    137

9.1.5  返回值    138

9.2  函数原型    139

9.2.1  函数原型（function prototype）    139

9.2.2  main()函数    141

9.2.3  定义带参数的main()函数*    141

9.2.4  默认参数    142

9.2.5  可变参数*    144

9.2.6  内联函数    146

9.3  函数重载    147

9.3.1  函数的重载    147

9.3.2  重载函数的调用    148

9.3.3  安全连接    149

9.3.4  名字重组*    150

9.4  递归函数    151

9.4.1  递归函数    151

9.4.2  使用调试器观察函数的递归调用*    154

9.5  函数与指针    155

9.5.1  指向函数的指针    155

9.5.2  理解函数指针*    156

9.5.3  函数与值传递    157

第10章  预处理    159

10.1  预处理指令    160

10.2  宏指令    161

10.2.1  宏    161

10.2.2  带参数的宏    162

10.2.3  宏与常量、函数*    163

10.2.4  #操作符    164

10.2.5  ##操作符    164

10.2.6  取消宏    164

10.2.7  C++预定义宏    165

10.3  条件编译指令    165

10.3.1  #if…#endif    165

10.3.2  #else    166

10.3.3  #elif    166

10.3.4  #if defined和#if !defined    167

10.3.5  #ifdef和#ifndef    167

10.4  文件包含指令    168

10.4.1  #include    168

10.4.2  合理使用头文件    169

10.5  其他标准指令    170

10.5.1  #error    170

10.5.2  #line    171

10.5.3  #pragma    171

第4篇  C++面向对象编程

第11章  C++的类    175

11.1  类与对象    176

11.1.1  对象    176

11.1.2  类    176

11.2  类的设计    177

11.2.1  类的定义    177

11.2.2  对象的定义    178

11.2.3  数据成员的访问    178

11.2.4  成员访问控制    178

11.2.5  成员函数    179

11.2.6  内联成员函数    181

11.2.7  成员函数的重载    182

11.2.8  this指针    182

11.2.9  内存中的类*    183

11.3  类的讨论    187

11.3.1  类与结构    187

11.3.2  抽象性    187

11.3.3  封装性    188

11.4  类的组合    191

11.4.1  使用类的组合    191

11.4.2  类的声明    193

第12章  类的特殊函数    195

12.1  构造函数    196

12.1.1  构造函数（constructor）    196

12.1.2  带参数的构造函数    197

12.1.3  初始值列表    198

12.2  成员初始值列表    199

12.2.1  使用成员初始值列表    199

12.2.2  对象成员初始化    200

12.3  析构函数    201

12.3.1  析构函数的定义    201

12.3.2  对象成员的构造与析构*    202

12.4  特殊构造函数    203

12.4.1  转换构造函数    204

12.4.2  explicit    205

12.4.3  拷贝构造函数    206

12.5  操作符函数    207

12.5.1  操作符重载    208

12.5.2  一元操作符重载    208

12.5.3  二元操作符重载    209

12.5.4  全局操作符的重载    210

12.5.5  可重载的操作符    212

12.5.6  类型转换函数    213

12.6  const与mutable    214

12.6.1  const    214

12.6.2  mutable    216

12.7  友元    217

12.7.1  声明某个函数为友元    217

12.7.2  声明某个类的成员函数 为友元    218

12.7.3  声明某个类为友元    219

第13章  继承    221

13.1  类的继承    222

13.1.1  继承的概念    222

13.1.2  类的继承    223

13.1.3  内存中的派生类*    224

13.1.4  protected    226

13.1.5  基类访问控制    227

13.2  构造与析构    228

13.2.1  派生类的构造    228

13.2.2  基类的初始化    229

13.2.3  默认构造函数    230

13.2.4  派生类的析构    230

13.3  名字隐藏    231

13.3.1  数据成员的隐藏    231

13.3.2  成员函数的隐藏    232

13.3.3  理解隐藏    233

第14章  多态性    235

14.1  类型转换    236

14.1.1  向上转换    236

14.1.2  向下转换    236

14.2  虚函数与多态    237

14.2.1  类型转换带来的问题    237

14.2.2  虚函数    238

14.2.3  虚函数的填充*    239

14.2.4  多态性    239

14.2.5  虚析构函数    240

14.2.6  纯虚函数    241

14.2.7  抽象类    241

14.3  多级继承    242

14.3.1  多级继承的使用    242

14.3.2  虚函数的多次填充*    244

14.4  多继承    245

14.4.1  多继承的使用    245

14.4.2  多继承带来的问题    247

14.4.3  虚拟继承    249

第5篇  C++高级特性

第15章  模板    253

15.1  函数模板    254

15.1.1  函数模板的概念    254

15.1.2  模板参数与函数参数    255

15.1.3  函数模板的实例化    256

15.1.4  函数模板的重载    256

15.1.5  函数模板的特化*    257

15.2  类模板    258

15.2.1  类模板的概念    258

15.2.2  类模板的成员函数    258

15.2.3  包含多个参数的类模板    259

15.2.4  类模板的默认参数    260

第16章  C++异常处理    263

16.1  传统的错误处理    264

16.2  抛出异常    268

16.3  捕获异常    268

16.3.1  使用catch捕获异常    269

16.3.2  捕获不同类型的异常    271

16.3.3  捕获所有的异常    272

16.3.4  在catch块抛出异常    273

16.3.5  未捕获的异常    273

16.3.6  定制terminate()的行为*    274

16.4  对抛出异常的声明    275

第17章  名字空间与域    277

17.1  名字空间    278

17.1.1  名字空间定义    278

17.1.2  using声明    279

17.1.3  using指令    279

17.1.4  名字空间的别名    279

17.2  作用域    279

17.3  局部作用域    280

17.3.1  局部作用域的概念    280

17.3.2  for语句的作用域    280

17.3.3  case语句块的作用域    280

17.3.4  函数的作用域    281

17.4  局部变量的存储类型    281

17.4.1  自动存储类型    281

17.4.2  寄存器存储类型    282

17.4.3  静态存储类型    283

17.5  名字空间域    284

17.5.1  全局域    284

17.5.2  外部存储类型    284

17.5.3  文件域    286

17.5.4  名字空间域    286

17.6  类域    286

17.6.1  类域的概念    286

17.6.2  static数据成员    288

17.6.3  static成员函数    290

17.7  作用域的嵌套    291

17.7.1  语句块的嵌套    291

17.7.2  名字空间的嵌套    292

17.7.3  类的嵌套    292

17.7.4  在语句块中定义类    293

17.7.5  嵌套带来的隐藏    293

17.8  对象的生命周期    293

第18章  运行时类型信息    297

18.1  动态类型的获取    298

18.1.1  typeid关键字    298

18.1.2  type_info    298

18.1.3  打开RTTI开关*    299

18.1.4  获取对象的动态类型    300

18.2  C++风格的类型转换    301

18.2.1  动态类型转换dynamic_cast    301

18.2.2  静态类型转换static_cast    303

18.2.3  再解释类型转换reinterpret_cast    304

18.2.4  常类型转换const_cast    304

第6篇  C++编程实践

第19章  C++标准库    307

19.1  C++标准库的组成    308

19.2  字符串库<string>    309

19.2.1  字符串的构造与赋值    309

19.2.2  字符串的连接    309

19.2.3  字符串的比较    309

19.2.4  字符串的下标    310

19.2.5  子串    310

19.2.6  字符串的查找    311

19.2.7  string与C-style字符串    311

19.2.8  空字符串    312

19.3  复数类<complex>    313

19.3.1  复数的构造    313

19.3.2  复数的四则运算    313

19.3.3  复数的操作函数    313

19.4  异常类<stdexcept>    314

19.5  C标准库    316

19.5.1  assert宏    317

19.5.2  类型函数    318

19.5.3  数学函数    318

19.5.4  类型转换函数    319

19.5.5  随机数函数    319

19.5.6  可变参数处理    320

19.5.7  内存操作函数    321

19.5.8  系统控制函数    322

19.5.9  字符串处理函数    323

19.5.10  时间处理函数    324

第20章  C++流    327

20.1  输入输出流<iostream>    328

20.1.1  输入输出流    328

20.1.2  流操作符    328

20.1.3  格式化输出函数    329

20.1.4  格式操纵符    330

20.1.5  流的输出    332

20.1.6  缓冲输出    332

20.1.7  流的输入    333

20.1.8  状态标志*    335

20.2  标准输入输出流    336

20.3  文件流<fstream>    337

20.3.1  文件的打开和关闭    338

20.3.2  二进制输入输出    340

20.3.3  定位文件位置    341

20.4  字符串流<sstream>    342

20.4.1  ostringstream    343

20.4.2  istringstream    343

20.4.3  stringstream    344

第21章  STL容器    345

21.1  标准模板库    346

21.1.1  STL的概念    346

21.1.2  STL的组成    348

21.1.3  STL的使用实例    348

21.2  容器    350

21.2.1  STL容器    350

21.2.2  容器的模板参数    351

21.2.3  容器的比较    352

21.2.4  容器的赋值和交换    352

21.2.5  operator []    352

21.2.6  指示器的获取    352

21.2.7  元素的迭代访问    353

21.2.8  容器的尺寸    353

21.3  向量    353

21.3.1  向量的构造    354

21.3.2  向量元素的访问    354

21.3.3  向量元素的添加    355

21.3.4  向量元素的删除    355

21.4  列表    355

21.4.1  列表的构造    356

21.4.2  列表元素的访问    356

21.4.3  列表元素的添加    356

21.4.4  列表元素的删除    356

21.5  双端队列    357

21.5.1  双端队列的构造    357

21.5.2  双端队列元素的访问    357

21.5.3  双端队列元素的添加    357

21.5.4  双端队列元素的删除    357

21.6  容器适配器    358

21.6.1  栈    358

21.6.2  队列    358

21.6.3  优先级队列    359

21.7  映射    360

21.7.1  映射的构造    360

21.7.2  映射元素的访问    361

21.7.3  映射元素的添加    362

21.7.4  映射元素的删除    362

21.7.5  映射元素的查找    362

21.7.6  多重映射    362

21.8  集合    363

21.8.1  集合的构造    363

21.8.2  集合元素的访问    364

21.8.3  集合元素的添加    364

21.8.4  集合元素的删除    364

21.8.5  集合元素的查找    364

21.8.6  多重集合    365

21.9  位集合    365

21.9.1  位集合的概念    366

21.9.2  位集合的构造    366

21.9.3  位集合的输出    366

21.9.4  位元素的操作    366

21.9.5  位集合的赋值与转换    367

21.9.6  位集合的尺寸    367

21.9.7  位集合的比较    367

21.9.8  位集合的位操作    368

第22章  泛型算法    369

22.1  指示器    370

22.1.1  指示器的获取    370

22.1.2  指示器的数据类型    370

22.1.3  指示器的迭代    370

22.1.4  迭代的方向*    372

22.1.5  指示器的迭代类型    372

22.2  指示器适配器    373

22.2.1  反向指示器    373

22.2.2  插入型指示器    374

22.3  函数对象    374

22.4  算法    376

22.4.1  查找算法    377

22.4.2  排序与通用整序算法    378

22.4.3  删除和替换算法    379

22.4.4  排列组合算法    380

22.4.5  算术算法    380

22.4.6  生成和异变算法    381

22.4.7  关系算法    381

22.4.8  集合算法    382

22.4.9  堆算法    383

第23章  C++实践指南    385

23.1  提高代码的可读性    386

23.1.1  不要吝啬注释    386

23.1.2  不要吝啬空白    388

23.1.3  爱惜标识符    390

23.1.4  合理使用操作符函数    391

23.1.5  合理使用别名    391

23.1.6  合理使用跳转语句    392

23.2  编写笨的程序    394

23.2.1  书写正常的表达式    394

23.2.2  使用bool类型进行判断    395

23.2.3  保证对象的初始化    396

23.2.4  尽量多写一些if    397

23.2.5  不要再发明string类    398

23.2.6  使用标准C++    399

23.3  合理使用内存    399

23.3.1  C++中的内存    399

23.3.2  内存的非法访问    400

23.3.3  内存泄漏    402

23.3.4  内存泄漏的检测    404

23.3.5  CMemory State    405

23.3.6  智能指针（auto_ptr）    406

23.4  合理使用OOP    409

23.4.1  合理封装对象    409

23.4.2  对象拷贝的产生    409

23.4.3  对象的初始化    412

23.4.4  对象的赋值与初始化    413

23.4.5  合理使用继承与组合    414

23.4.6  合理使用多继承    416

23.4.7  合理使用虚函数和虚基类    418

23.5  不要教条主义    420

第24章  综合实践：《西游记》游戏模拟    423

24.1  功能分析    424

24.1.1  游戏运行界面    424

24.1.2  游戏角色划分    424

24.1.3  战斗的形成    425

24.1.4  兵器的分配    425

24.2  设计思路    426

24.2.1  使用类和继承完成角色的设计    426

24.2.2  使用文件流加载角色列表    426

24.2.3  使用虚函数实现角色的多态    427

24.2.4  使用操作符的重载    429

24.2.5  使用异常处理提高程序的鲁棒性    429

24.2.6  使用RTTI获取角色的类别    430

24.2.7  使用STL容器管理角色    431

24.2.8  使用STL容器管理兵器    432

24.2.9  使用泛型算法完成查找与排序    433

24.2.10  使用循环和判断完成主控逻辑    435

24.3  实现详解    435

24.3.1  Weapon    436

24.3.2  Actor    438

24.3.3  Monk    443

24.3.4  ActorPowersAccumulater    446

24.3.5  God    446

24.3.6  Monster    448

24.3.7  FollowerMonster    449

24.3.8  GameException    450

24.3.9  Game    453

24.3.10  main()函数    468

24.4  运行并观察游戏    469

24.4.1  actors.ini    469

24.4.2  运行程序    472