高质量C++编程

//-----------------------------第 1 章文件结构----------------------------
一、每个 C++/C 程序通常分为两个文件。一个文件用于保存程序的声明（declaration），
称为头文件。另一个文件用于保存程序的实现（implementation），称为定义（definition）
文件。
C++/C 程序的头文件以“.h”为后缀，C 程序的定义文件以“.c”为后缀，C++程序
的定义文件通常以“.cpp”为后缀（也有一些系统以“.cc”或“.cxx”为后缀）。

1.1 版权和版本的声明
 版权和版本的声明位于头文件和定义文件的开头（参见示例1-1），主要内容有：
 （1）版权信息。
 （2）文件名称，标识符，摘要。
 （3）当前版本号，作者/修改者，完成日期。
 （4）版本历史信息。
 如下：
 /*
 * Copyright (c) 2001,上海贝尔有限公司网络应用事业部
 * All rights reserved.
 *
 * 文件名称：filename.h
 * 文件标识：见配置管理计划书
 * 摘要：简要描述本文件的内容
 *
 * 当前版本：1.1
 * 作者：输入作者（或修改者）名字
 * 完成日期：2001年7月20日
 *
 * 取代版本：1.0
 * 原作者：输入原作者（或修改者）名字
 * 完成日期：2001年5月10日
 */
1.2 头文件的结构
 头文件由三部分内容组成：
 （1）头文件开头处的版权和版本声明（参见示例1-1）。
 （2）预处理块。
 （3）函数和类结构声明等。
 假设头文件名称为 graphics.h，头文件的结构参见示例1-2。
  【规则1-2-1】为了防止头文件被重复引用，应当用ifndef/define/endif 结构产生预
 处理块。
  【规则 1-2-2】用#include <filename.h> 格式来引用标准库的头文件（编译器将
 从标准库目录开始搜索）。
  【规则1-2-3】用#include “filename.h” 格式来引用非标准库的头文件（编译器将
 从用户的工作目录开始搜索）。
  【建议1-2-1】头文件中只存放“声明”而不存放“定义”
 在 C++ 语法中，类的成员函数可以在声明的同时被定义，并且自动成为内联函数。
 这虽然会带来书写上的方便，但却造成了风格不一致，弊大于利。建议将成员函数的定
 义与声明分开，不论该函数体有多么小。
  【建议1-2-2】不提倡使用全局变量，尽量不要在头文件中出现象extern int value 这
 类声明。
 // 版权和版本声明见示例1-1，此处省略。
 #ifndef GRAPHICS_H // 防止graphics.h 被重复引用
 #define GRAPHICS_H
 #include <math.h> // 引用标准库的头文件
 
 #include “myheader.h” // 引用非标准库的头文件
 
 void Function1(); // 全局函数声明
 class Box // 类结构声明
 {
  
 };
 #endif

 文件的结构
 定义文件有三部分内容：
 （1） 定义文件开头处的版权和版本声明（参见示例1-1）。
 （2） 对一些头文件的引用。
 （3） 程序的实现体（包括数据和代码）。
 假设定义文件的名称为 graphics.cpp，定义文件的结构参见示例1-3。
 // 版权和版本声明见示例1-1，此处省略。
 #include “graphics.h” // 引用头文件
 
 // 全局函数的实现体
 void Function1()
 {
 
 }
 // 类成员函数的实现体
 void Box::Draw()
 {
 
 }
 
1.4 头文件的作用
 早期的编程语言如Basic、Fortran 没有头文件的概念，C++/C 语言的初学者虽然会
 用使用头文件，但常常不明其理。这里对头文件的作用略作解释：
 （1）通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只
 要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库
 功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
 （2）头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件
 中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错
 的负担。 
  
1.5 目录结构
 如果一个软件的头文件数目比较多（如超过十个），通常应将头文件和定义文件分
 别保存于不同的目录，以便于维护。
 例如可将头文件保存于include 目录，将定义文件保存于source 目录（可以是多级
 目录）。
 如果某些头文件是私有的，它不会被用户的程序直接引用，则没有必要公开其“声
 明”。为了加强信息隐藏，这些私有的头文件可以和定义文件存放于同一个目录。
 
//------------------------第 2 章程序的版式--------------------------
2.1 空行
 空行起着分隔程序段落的作用。空行得体（不过多也不过少）将使程序的布局更加
 清晰。空行不会浪费内存，虽然打印含有空行的程序是会多消耗一些纸张，但是值得。
 所以不要舍不得用空行。
  【规则 2-1-1】在每个类声明之后、每个函数定义结束之后都要加空行。参见示例
 2-1（a）
  【规则2-1-2】在一个函数体内，逻揖上密切相关的语句之间不加空行，其它地方应
 加空行分隔。参见示例2-1（b ） 
 // 空行
 void Function1()
 {
 
 }
 // 空行
 void Function2()
 {
 
 }
 // 空行
 void Function3()
 {
 
 }
 // 空行
 while (condition)
 {
 statement1;
 // 空行
 if (condition)
 {
 statement2;
 }
 else
 {
 statement3;
 }
 // 空行
 statement4;
 }
 
2.2 代码行
  【规则2-2-1】一行代码只做一件事情，如只定义一个变量，或只写一条语句。这样
 的代码容易阅读，并且方便于写注释。
  【规则2-2-2】if、for、while、do 等语句自占一行，执行语句不得紧跟其后。不论
 执行语句有多少都要加{}。这样可以防止书写失误。
 
2.3 代码行内的空格
  【规则2-3-1】关键字之后要留空格。象const、virtual、inline、case 等关键字之
 后至少要留一个空格，否则无法辨析关键字。象if、for、while 等关键字之后应留
 一个空格再跟左括号‘（’，以突出关键字。
  【规则2-3-2】函数名之后不要留空格，紧跟左括号‘（’，以与关键字区别。
  【规则2-3-3】‘（’向后紧跟，‘）’、‘，’、‘;’向前紧跟，紧跟处不留空格。
  【规则2-3-4】‘，’之后要留空格，如Function(x, y, z)。如果‘;’不是一行的结束
 符号，其后要留空格，如for (initialization; condition; update)。
  【规则2-3-5】赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符，
 如“=”、“+=” “>=”、“<=”、“+”、“*”、“%”、“&&”、“||”、“<<”,“^”等二
 元操作符的前后应当加空格。
  【规则2-3-6】一元操作符如“!”、“~”、“++”、“--”、“&”（地址运算符）等前后不
 加空格。
  【规则2-3-7】象“［］”、“.”、“->”这类操作符前后不加空格。
  【建议2-3-1】对于表达式比较长的for 语句和if 语句，为了紧凑起见可以适当地去
 掉一些空格，如for (i=0; i<10; i++)和if ((a<=b) && (c<=d))

2.4 对齐
 【规则2-4-1】程序的分界符‘{’和‘}’应独占一行并且位于同一列，同时与引用
 它们的语句左对齐。
 【规则2-4-2】{ }之内的代码块在‘{’右边数格处左对齐。  
 
2.5 长行拆分
 【规则2-5-1】代码行最大长度宜控制在70 至80 个字符以内。代码行不要过长，否
 则眼睛看不过来，也不便于打印。
 【规则2-5-2】长表达式要在低优先级操作符处拆分成新行，操作符放在新行之首（以
 便突出操作符）。拆分出的新行要进行适当的缩进，使排版整齐，语句可读。
 if ((very_longer_variable1 >= very_longer_variable12)
 && (very_longer_variable3 <= very_longer_variable14)
 && (very_longer_variable5 <= very_longer_variable16))
 {
 dosomething();
 }
 virtual CMatrix CMultiplyMatrix (CMatrix leftMatrix,
 CMatrix rightMatrix);
 for (very_longer_initialization;
 very_longer_condition;
 very_longer_update)
 {
 dosomething();
 } 
 
2.6 修饰符的位置
 修饰符 * 和＆ 应该靠近数据类型还是该靠近变量名，是个有争议的活题。
 若将修饰符 * 靠近数据类型，例如：int* x; 从语义上讲此写法比较直观，即x
 是int 类型的指针。
 上述写法的弊端是容易引起误解，例如：int* x, y; 此处y 容易被误解为指针变
 量。虽然将x 和y 分行定义可以避免误解，但并不是人人都愿意这样做。
 
 【规则2-6-1】应当将修饰符 * 和＆ 紧靠变量名
 例如：
 char *name;
 int *x, y; // 此处y 不会被误解为指针
 
2.7 注释
 C 语言的注释符为“/*…*/”。C++语言中，程序块的注释常采用“/*…*/”，行注释
 一般采用“//…”。注释通常用于：
 （1）版本、版权声明；
 （2）函数接口说明；
 （3）重要的代码行或段落提示。
 虽然注释有助于理解代码，但注意不可过多地使用注释。参见示例2-6。
  【规则2-7-1】注释是对代码的“提示”，而不是文档。程序中的注释不可喧宾夺主，
 注释太多了会让人眼花缭乱。注释的花样要少。
  【规则2-7-2】如果代码本来就是清楚的，则不必加注释。否则多此一举，令人厌烦。
 例如
 i++; // i 加 1，多余的注释
  【规则2-7-3】边写代码边注释，修改代码同时修改相应的注释，以保证注释与代码
 的一致性。不再有用的注释要删除。
  【规则2-7-4】注释应当准确、易懂，防止注释有二义性。错误的注释不但无益反而
 有害。
  【规则2-7-5】尽量避免在注释中使用缩写，特别是不常用缩写。
  【规则2-7-6】注释的位置应与被描述的代码相邻，可以放在代码的上方或右方，不
 可放在下方。
  【规则2-7-8】当代码比较长，特别是有多重嵌套时，应当在一些段落的结束处加注
 释，便于阅读。
 /*
 * 函数介绍：
 * 输入参数：
 * 输出参数：
 * 返回值：
 */
 void Function(float x, float y, float z)
 {
 …
 }
 if (…)
 {
 …
 while (…)
 {
 …
 } // end of while
 …
 } // end of if
 
2.8 类的版式
 类可以将数据和函数封装在一起，其中函数表示了类的行为（或称服务）。类提供
 关键字public、protected 和private，分别用于声明哪些数据和函数是公有的、受保护
 的或者是私有的。这样可以达到信息隐藏的目的，即让类仅仅公开必须要让外界知道的
 内容，而隐藏其它一切内容。我们不可以滥用类的封装功能，不要把它当成火锅，什么
 东西都往里扔。
 类的版式主要有两种方式：
 （1）将private 类型的数据写在前面，而将public 类型的函数写在后面，如示例8-3（a）。
 采用这种版式的程序员主张类的设计“以数据为中心”，重点关注类的内部结构。
 （2）将public 类型的函数写在前面，而将private 类型的数据写在后面，如示例8.3（b）
 采用这种版式的程序员主张类的设计“以行为为中心”，重点关注的是类应该提供什么
 样的接口（或服务）。
 很多 C++教课书受到Biarne Stroustrup 第一本著作的影响，不知不觉地采用了“以
 数据为中心”的书写方式，并不见得有多少道理。
 我建议读者采用“以行为为中心”的书写方式，即首先考虑类应该提供什么样的函
 数。这是很多人的经验——“这样做不仅让自己在设计类时思路清晰，而且方便别人阅
 读。因为用户最关心的是接口，谁愿意先看到一堆私有数据成员！”
 class A
 {
 private:
 int i, j;
 float x, y;
 …
 public:
 void Func1(void);
 void Func2(void);
 …
 }
 class A
 {
 public:
 void Func1(void);
 void Func2(void);
 …
 private:
 int i, j;
 float x, y;
 …
 } 

//--------------------------------------第 3 章命名规则
 法最大的缺点是烦琐，例如
 int i, j, k;
 float x, y, z;
 倘若采用“匈牙利”命名规则，则应当写成
 int iI, iJ, ik; // 前缀 i 表示int 类型
 float fX, fY, fZ; // 前缀 f 表示float 类型
 如此烦琐的程序会让绝大多数程序员无法忍受。
 据考察，没有一种命名规则可以让所有的程序员赞同，程序设计教科书一般都不指
 定命名规则。命名规则对软件产品而言并不是“成败悠关”的事，我们不要化太多精力
 试图发明世界上最好的命名规则，而应当制定一种令大多数项目成员满意的命名规则，
 并在项目中贯彻实施。
3.1 共性规则
 本节论述的共性规则是被大多数程序员采纳的，我们应当在遵循这些共性规则的前
 提下，再扩充特定的规则，如3.2 节。
 【规则3-1-1】标识符应当直观且可以拼读，可望文知意，不必进行“解码”。
 标识符最好采用英文单词或其组合，便于记忆和阅读。切忌使用汉语拼音来命名。
 程序中的英文单词一般不会太复杂，用词应当准确。例如不要把CurrentValue 写成
 NowValue。
 【规则3-1-2】标识符的长度应当符合“min-length && max-information”原则。
 几十年前老ANSI C 规定名字不准超过6 个字符，现今的C++/C 不再有此限制。一
 般来说，长名字能更好地表达含义，所以函数名、变量名、类名长达十几个字符不足为
 怪。那么名字是否越长约好？不见得! 例如变量名maxval 就比maxValueUntilOverflow
 好用。单字符的名字也是有用的，常见的如i,j,k,m,n,x,y,z 等，它们通常可用作函数
 内的局部变量。
 【规则3-1-3】命名规则尽量与所采用的操作系统或开发工具的风格保持一致。
 例如 Windows 应用程序的标识符通常采用“大小写”混排的方式，如AddChild。
 而Unix 应用程序的标识符通常采用“小写加下划线”的方式，如add_child。别把这两
 
 类风格混在一起用。
 【规则3-1-4】程序中不要出现仅靠大小写区分的相似的标识符。
 例如：
 int x, X; // 变量x 与 X 容易混淆
 void foo(int x); // 函数foo 与FOO 容易混淆
 void FOO(float x);
 【规则3-1-5】程序中不要出现标识符完全相同的局部变量和全局变量，尽管两者的
 作用域不同而不会发生语法错误，但会使人误解。
 【规则3-1-6】变量的名字应当使用“名词”或者“形容词＋名词”。
 例如：
 float value;
 float oldValue;
 float newValue;
 【规则3-1-7】全局函数的名字应当使用“动词”或者“动词＋名词”（动宾词组）。
 类的成员函数应当只使用“动词”，被省略掉的名词就是对象本身。
 例如：
 DrawBox(); // 全局函数
 box->Draw(); // 类的成员函数
 【规则3-1-8】用正确的反义词组命名具有互斥意义的变量或相反动作的函数等。
 例如：
 int minValue;
 int maxValue;
 int SetValue(…);
 int GetValue(…);
 【建议3-1-1】尽量避免名字中出现数字编号，如Value1,Value2 等，除非逻辑上的
 确需要编号。这是为了防止程序员偷懒，不肯为命名动脑筋而导致产生无意义的名
 字（因为用数字编号最省事）。
3.2 简单的Windows 应用程序命名规则
 作者对“匈牙利”命名规则做了合理的简化，下述的命名规则简单易用，比较适合
 于Windows 应用软件的开发。
 

 【规则3-2-1】类名和函数名用大写字母开头的单词组合而成。
 例如：
 class Node; // 类名
 class LeafNode; // 类名
 void Draw(void); // 函数名
 void SetValue(int value); // 函数名
 【规则3-2-2】变量和参数用小写字母开头的单词组合而成。
 例如：
 BOOL flag;
 int drawMode;
 【规则3-2-3】常量全用大写的字母，用下划线分割单词。
 例如：
 const int MAX = 100;
 const int MAX_LENGTH = 100;
 【规则3-2-4】静态变量加前缀s_（表示static）。
 例如：
 void Init(…)
 {
 static int s_initValue; // 静态变量
 …
 }
 【规则3-2-5】如果不得已需要全局变量，则使全局变量加前缀g_（表示global）。
 例如：
 int g_howManyPeople; // 全局变量
 int g_howMuchMoney; // 全局变量
 【规则3-2-6】类的数据成员加前缀m_（表示member），这样可以避免数据成员与
 成员函数的参数同名。
 例如：
 void Object::SetValue(int width, int height)
 {
 m_width = width;
 m_height = height;
 }
 

 【规则3-2-7】为了防止某一软件库中的一些标识符和其它软件库中的冲突，可以为
 各种标识符加上能反映软件性质的前缀。例如三维图形标准OpenGL 的所有库函数
 均以gl 开头，所有常量（或宏定义）均以GL 开头。
3.3 简单的Unix 应用程序命名规则 
 
//------------------------------第 4 章表达式和基本语句
 读者可能怀疑：连if、for、while、goto、switch 这样简单的东西也要探讨编程
 风格，是不是小题大做？
 我真的发觉很多程序员用隐含错误的方式写表达式和基本语句，我自己也犯过类似
 的错误。
 表达式和语句都属于C++/C 的短语结构语法。它们看似简单，但使用时隐患比较多。
 本章归纳了正确使用表达式和语句的一些规则与建议。
4.1 运算符的优先级
 C++/C 语言的运算符有数十个，运算符的优先级与结合律如表4-1 所示。注意一元
 运算符 + - * 的优先级高于对应的二元运算符。
 优先级运算符结合律
 ( ) [ ] -> . 从左至右
 ! ~ ++ -- （类型） sizeof
 + - * &
 从右至左
 * / % 从左至右
 + - 从左至右
 << >> 从左至右
 < <= > >= 从左至右
 == != 从左至右
 & 从左至右
 ^ 从左至右
 | 从左至右
 && 从左至右
 || 从右至左
 : 从右至左
 从
 高
 到
 低
 排
 列
 = += -= *= /= %= &= ^=
 |= <<= >>=
 从左至右
 表 4-1 运算符的优先级与结合律
  【规则4-1-1】如果代码行中的运算符比较多，用括号确定表达式的操作顺序，避免
 使用默认的优先级。
 由于将表4-1 熟记是比较困难的，为了防止产生歧义并提高可读性，应当用括号确
 定表达式的操作顺序。例如：
 word = (high << 8) | low
 
 
 if ((a | b) && (a & c))
4.2 复合表达式
 如 a = b = c = 0 这样的表达式称为复合表达式。允许复合表达式存在的理由是：（1）
 书写简洁；（2）可以提高编译效率。但要防止滥用复合表达式。
  【规则4-2-1】不要编写太复杂的复合表达式。
 例如：
 i = a >= b && c < d && c + f <= g + h ; // 复合表达式过于复杂
  【规则4-2-2】不要有多用途的复合表达式。
 例如：
 d = (a = b + c) + r ;
 该表达式既求a 值又求d 值。应该拆分为两个独立的语句：
 a = b + c;
 d = a + r;
  【规则4-2-3】不要把程序中的复合表达式与“真正的数学表达式”混淆。
 例如：
 if (a < b < c) // a < b < c 是数学表达式而不是程序表达式
 并不表示
 if ((a<b) && (b<c))
 而是成了令人费解的
 if ( (a<b)<c )
4.3 if 语句
 if 语句是C++/C 语言中最简单、最常用的语句，然而很多程序员用隐含错误的方式
 写if 语句。本节以“与零值比较”为例，展开讨论。
4.3.1 布尔变量与零值比较
  【规则4-3-1】不可将布尔变量直接与TRUE、FALSE 或者1、0 进行比较。
 根据布尔类型的语义，零值为“假”（记为FALSE），任何非零值都是“真”（记为
 TRUE）。TRUE 的值究竟是什么并没有统一的标准。例如Visual C++ 将TRUE 定义为
 1，而Visual Basic 则将TRUE 定义为-1。
 假设布尔变量名字为flag，它与零值比较的标准if 语句如下：
 if (flag) // 表示flag 为真
 
 
 if (!flag) // 表示flag 为假
 其它的用法都属于不良风格，例如：
 if (flag == TRUE)
 if (flag == 1 )
 if (flag == FALSE)
 if (flag == 0)
4.3.2 整型变量与零值比较
  【规则4-3-2】应当将整型变量用“==”或“！=”直接与0 比较。
 假设整型变量的名字为value，它与零值比较的标准if 语句如下：
 if (value == 0)
 if (value != 0)
 不可模仿布尔变量的风格而写成
 if (value) // 会让人误解 value 是布尔变量
 if (!value)
4.3.3 浮点变量与零值比较
  【规则4-3-3】不可将浮点变量用“==”或“！=”与任何数字比较。
 千万要留意，无论是float 还是double 类型的变量，都有精度限制。所以一定要
 避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。
 假设浮点变量的名字为x，应当将
 if (x == 0.0) // 隐含错误的比较
 转化为
 if ((x>=-EPSINON) && (x<=EPSINON))
 其中EPSINON 是允许的误差（即精度）。
4.3.4 指针变量与零值比较
  【规则4-3-4】应当将指针变量用“==”或“！=”与NULL 比较。
 指针变量的零值是“空”（记为NULL）。尽管NULL 的值与0 相同，但是两者意义不
 同。假设指针变量的名字为p，它与零值比较的标准if 语句如下：
 if (p == NULL) // p 与NULL 显式比较，强调p 是指针变量
 if (p != NULL)
 不要写成
 if (p == 0) // 容易让人误解p 是整型变量
 if (p != 0)
 或者
 if (p) // 容易让人误解p 是布尔变量
 if (!p)
4.3.5 对if 语句的补充说明
 
 
 有时候我们可能会看到 if (NULL == p) 这样古怪的格式。不是程序写错了，是程
 序员为了防止将 if (p == NULL) 误写成 if (p = NULL)，而有意把p 和NULL 颠倒。
 编译器认为 if (p = NULL) 是合法的，但是会指出 if (NULL = p)是错误的，因为NULL
 不能被赋值。
 程序中有时会遇到if/else/return 的组合，应该将如下不良风格的程序
 if (condition)
 return x;
 return y;
 改写为
 if (condition)
 {
 return x;
 }
 else
 {
 return y;
 }
 或者改写成更加简练的
 return (condition  x : y);
4.4 循环语句的效率
 C++/C 循环语句中，for 语句使用频率最高，while 语句其次，do 语句很少用。本
 节重点论述循环体的效率。提高循环体效率的基本办法是降低循环体的复杂性。
  【建议4-4-1】在多重循环中，如果有可能，应当将最长的循环放在最内层，最短的
 循环放在最外层，以减少CPU 跨切循环层的次数。例如示例4-4(b)的效率比示例
4-4(a)的高。
 for (row=0; row<100; row++)
 {
 for ( col=0; col<5; col++ )
 {
 sum = sum + a[row][col];
 }
 }
 for (col=0; col<5; col++ )
 {
 for (row=0; row<100; row++)
 {
 sum = sum + a[row][col];
 }
 }
 示例 4-4(a) 低效率：长循环在最外层 示例4-4(b) 高效率：长循环在最内层
  【建议4-4-2】如果循环体内存在逻辑判断，并且循环次数很大，宜将逻辑判断移到
 

 循环体的外面。示例4-4(c)的程序比示例4-4(d)多执行了N-1 次逻辑判断。并且
 由于前者老要进行逻辑判断，打断了循环“流水线”作业，使得编译器不能对循环
 进行优化处理，降低了效率。如果N 非常大，最好采用示例4-4(d)的写法，可以提
 高效率。如果N 非常小，两者效率差别并不明显，采用示例4-4(c)的写法比较好，
 因为程序更加简洁。
 for (i=0; i<N; i++)
 {
 if (condition)
 DoSomething();
 else
 DoOtherthing();
 }
 if (condition)
 {
 for (i=0; i<N; i++)
 DoSomething();
 }
 else
 {
 for (i=0; i<N; i++)
 DoOtherthing();
 }
 表4-4(c) 效率低但程序简洁 表4-4(d) 效率高但程序不简洁
4.5 for 语句的循环控制变量
  【规则4-5-1】不可在for 循环体内修改循环变量，防止for 循环失去控制。
  【建议4-5-1】建议for 语句的循环控制变量的取值采用“半开半闭区间”写法。
 示例 4-5(a)中的x 值属于半开半闭区间“0 =< x < N”，起点到终点的间隔为N，
 循环次数为N。
 示例 4-5(b)中的x 值属于闭区间“0 =< x <= N-1”，起点到终点的间隔为N-1，循
 环次数为N。
 相比之下，示例4-5(a)的写法更加直观，尽管两者的功能是相同的。
 for (int x=0; x<N; x++)
 {

 }
 for (int x=0; x<=N-1; x++)
 {

 }
 示例4-5(a) 循环变量属于半开半闭区间 示例4-5(b) 循环变量属于闭区间
4.6 switch 语句
 有了 if 语句为什么还要switch 语句？
 
 
 switch 是多分支选择语句，而if 语句只有两个分支可供选择。虽然可以用嵌套的
 if 语句来实现多分支选择，但那样的程序冗长难读。这是switch 语句存在的理由。
 switch 语句的基本格式是：
 switch (variable)
 {
 case value1 :
 break;
 case value2 :
 break;

 default :
 break;
 }
  【规则4-6-1】每个case 语句的结尾不要忘了加break，否则将导致多个分支重叠
 （除非有意使多个分支重叠）。
  【规则4-6-2】不要忘记最后那个default 分支。即使程序真的不需要default 处理，
 也应该保留语句 default : break; 这样做并非多此一举，而是为了防止别人误以
 为你忘了default 处理。
4.7 goto 语句
 自从提倡结构化设计以来，goto 就成了有争议的语句。首先，由于goto 语句可以
 灵活跳转，如果不加限制，它的确会破坏结构化设计风格。其次，goto 语句经常带来错
 误或隐患。它可能跳过了某些对象的构造、变量的初始化、重要的计算等语句，例如：
 goto state;
 String s1, s2; // 被goto 跳过
 int sum = 0; // 被goto 跳过

 state:

 如果编译器不能发觉此类错误，每用一次goto 语句都可能留下隐患。
 很多人建议废除C++/C 的goto 语句，以绝后患。但实事求是地说，错误是程序员
 自己造成的，不是goto 的过错。goto 语句至少有一处可显神通，它能从多重循环体中
 咻地一下子跳到外面，用不着写很多次的break 语句; 例如
 {
 {
 {
 goto error;
 
 
 }
 }
 }
 error:

 就象楼房着火了，来不及从楼梯一级一级往下走，可从窗口跳出火坑。所以我们主
 张少用、慎用goto 语句，而不是禁用。 

//-------------------------------------第 5 章常量
 常量是一种标识符，它的值在运行期间恒定不变。C 语言用 #define 来定义常量（称
 为宏常量）。C++ 语言除了 #define 外还可以用const 来定义常量（称为const 常量）。
5.1 为什么需要常量
 如果不使用常量，直接在程序中填写数字或字符串，将会有什么麻烦？
 （1） 程序的可读性（可理解性）变差。程序员自己会忘记那些数字或字符串是什么意
 思，用户则更加不知它们从何处来、表示什么。
 （2） 在程序的很多地方输入同样的数字或字符串，难保不发生书写错误。
 （3） 如果要修改数字或字符串，则会在很多地方改动，既麻烦又容易出错。
  【规则5-1-1】尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或
 字符串。
 例如：
 #define MAX 100 /* C 语言的宏常量 */
 const int MAX = 100; // C++ 语言的const 常量
 const float PI = 3.14159; // C++ 语言的const 常量
5.2 const 与 #define 的比较
 C++ 语言可以用const 来定义常量，也可以用 #define 来定义常量。但是前者比后
 者有更多的优点：
 （1） const 常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安
 全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会
 产生意料不到的错误（边际效应）。
 （2） 有些集成化的调试工具可以对 const 常量进行调试，但是不能对宏常量进行调
 试。
  【规则5-2-1】在C++ 程序中只使用const 常量而不使用宏常量，即const 常量完
 全取代宏常量。
5.3 常量定义规则
  【规则5-3-1】需要对外公开的常量放在头文件中，不需要对外公开的常量放在定义
 文件的头部。为便于管理，可以把不同模块的常量集中存放在一个公共的头文件中。
 
 
  【规则5-3-2】如果某一常量与其它常量密切相关，应在定义中包含这种关系，而不
 应给出一些孤立的值。
 例如：
 const float RADIUS = 100;
 const float DIAMETER = RADIUS * 2;
5.4 类中的常量
 有时我们希望某些常量只在类中有效。由于#define 定义的宏常量是全局的，不能
 达到目的，于是想当然地觉得应该用const 修饰数据成员来实现。const 数据成员的确
 是存在的，但其含义却不是我们所期望的。const 数据成员只在某个对象生存期内是常
 量，而对于整个类而言却是可变的，因为类可以创建多个对象，不同的对象其const 数
 据成员的值可以不同。
 不能在类声明中初始化const 数据成员。以下用法是错误的，因为类的对象未被创
 建时，编译器不知道SIZE 的值是什么。
 class A
 {
 const int SIZE = 100; // 错误，企图在类声明中初始化const 数据成员
 int array[SIZE]; // 错误，未知的SIZE
 };
 const 数据成员的初始化只能在类构造函数的初始化表中进行，例如
 class A
 {
 A(int size); // 构造函数
 const int SIZE ;
 };
 A::A(int size) : SIZE(size) // 构造函数的初始化表
 {

 }
 A a(100); // 对象 a 的SIZE 值为100
 A b(200); // 对象 b 的SIZE 值为200
 怎样才能建立在整个类中都恒定的常量呢？别指望const 数据成员了，应该用类中
 的枚举常量来实现。例如
 class A
 {
 enum { SIZE1 = 100, SIZE2 = 200}; // 枚举常量
 
 int array1[SIZE1];
 int array2[SIZE2];
 };
 枚举常量不会占用对象的存储空间，它们在编译时被全部求值。枚举常量的缺点是：
 它的隐含数据类型是整数，其最大值有限，且不能表示浮点数（如PI=3.14159）。

//------------------------第 6 章函数设计
 函数是C++/C 程序的基本功能单元，其重要性不言而喻。函数设计的细微缺点很容
 易导致该函数被错用，所以光使函数的功能正确是不够的。本章重点论述函数的接口设
 计和内部实现的一些规则。
 函数接口的两个要素是参数和返回值。C 语言中，函数的参数和返回值的传递方式
 有两种：值传递（pass by value）和指针传递（pass by pointer）。C++ 语言中多了引用
 传递（pass by reference）。由于引用传递的性质象指针传递，而使用方式却象值传递，
 初学者常常迷惑不解，容易引起混乱，请先阅读6.6 节“引用与指针的比较”。
6.1 参数的规则
  【规则6-1-1】参数的书写要完整，不要贪图省事只写参数的类型而省略参数名字。
 如果函数没有参数，则用void 填充。
 例如：
 void SetValue(int width, int height); // 良好的风格
 void SetValue(int, int); // 不良的风格
 float GetValue(void); // 良好的风格
 float GetValue(); // 不良的风格
  【规则6-1-2】参数命名要恰当，顺序要合理。
 例如编写字符串拷贝函数StringCopy，它有两个参数。如果把参数名字起为str1 和
 str2，例如
 void StringCopy(char *str1, char *str2);
 那么我们很难搞清楚究竟是把str1 拷贝到str2 中，还是刚好倒过来。
 可以把参数名字起得更有意义，如叫strSource 和strDestination。这样从名字上就
 可以看出应该把strSource 拷贝到strDestination。
 还有一个问题，这两个参数那一个该在前那一个该在后？参数的顺序要遵循程序员
 的习惯。一般地，应将目的参数放在前面，源参数放在后面。
 如果将函数声明为：
 void StringCopy(char *strSource, char *strDestination);
 别人在使用时可能会不假思索地写成如下形式：
 char str[20];
 StringCopy(str, “Hello World”); // 参数顺序颠倒
  【规则6-1-3】如果参数是指针，且仅作输入用，则应在类型前加const，以防止该
 指针在函数体内被意外修改。
 例如：
 
 
 void StringCopy(char *strDestination，const char *strSource);
  【规则6-1-4】如果输入参数以值传递的方式传递对象，则宜改用“const &”方式
 来传递，这样可以省去临时对象的构造和析构过程，从而提高效率。
  【建议6-1-1】避免函数有太多的参数，参数个数尽量控制在5 个以内。如果参数太
 多，在使用时容易将参数类型或顺序搞错。
  【建议6-1-2】尽量不要使用类型和数目不确定的参数。
 C 标准库函数printf 是采用不确定参数的典型代表，其原型为：
 int printf(const chat *format[, argument]);
 这种风格的函数在编译时丧失了严格的类型安全检查。

6.2 返回值的规则
  【规则6-2-1】不要省略返回值的类型。
 C 语言中，凡不加类型说明的函数，一律自动按整型处理。这样做不会有什么好处，
 却容易被误解为void 类型。
 C++语言有很严格的类型安全检查，不允许上述情况发生。由于C++程序可以调用
 C 函数，为了避免混乱，规定任何C++/ C 函数都必须有类型。如果函数没有返回值，
 那么应声明为void 类型。
  【规则6-2-2】函数名字与返回值类型在语义上不可冲突。
 违反这条规则的典型代表是C 标准库函数getchar。
 例如：
 char c;
 c = getchar();
 if (c == EOF)
 
 按照 getchar 名字的意思，将变量c 声明为char 类型是很自然的事情。但不幸的是
 getchar 的确不是char 类型，而是int 类型，其原型如下：
 int getchar(void);
 由于c 是char 类型，取值范围是[-128，127]，如果宏EOF 的值在char 的取值范围
 之外，那么if 语句将总是失败，这种“危险”人们一般哪里料得到！导致本例错误的责
 任并不在用户，是函数getchar 误导了使用者。
  【规则6-2-3】不要将正常值和错误标志混在一起返回。正常值用输出参数获得，而
 错误标志用return 语句返回。
 回顾上例，C 标准库函数的设计者为什么要将getchar 声明为令人迷糊的int 类型

 呢？他会那么傻吗？
 在正常情况下，getchar 的确返回单个字符。但如果getchar 碰到文件结束标志或发
 生读错误，它必须返回一个标志EOF。为了区别于正常的字符，只好将EOF 定义为负
 数（通常为负1）。因此函数getchar 就成了int 类型。
 我们在实际工作中，经常会碰到上述令人为难的问题。为了避免出现误解，我们应
 该将正常值和错误标志分开。即：正常值用输出参数获得，而错误标志用return 语句返
 回。
 函数 getchar 可以改写成BOOL GetChar(char *c);
 虽然gechar 比GetChar 灵活，例如putchar(getchar()); 但是如果getchar 用错
 了，它的灵活性又有什么用呢？
  【建议6-2-1】有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，
 可以附加返回值。
 例如字符串拷贝函数strcpy 的原型：
 char *strcpy(char *strDest，const char *strSrc);
 strcpy 函数将strSrc 拷贝至输出参数strDest 中，同时函数的返回值又是strDest。
 这样做并非多此一举，可以获得如下灵活性：
 char str[20];
 int length = strlen( strcpy(str, “Hello World”) );
  【建议6-2-2】如果函数的返回值是一个对象，有些场合用“引用传递”替换“值传
 递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”，否则会
 出错。
 例如：
 class String
 {
 // 赋值函数
 String & operate=(const String &other);
 // 相加函数，如果没有friend 修饰则只许有一个右侧参数
 friend String operate+( const String &s1, const String &s2);
 private:
 char *m_data;
 }
 String 的赋值函数operate = 的实现如下：
 String & String::operate=(const String &other)
 {
 if (this == &other)
 return *this;
 delete m_data;
 m_data = new char[strlen(other.data)+1];
 strcpy(m_data, other.data);
 return *this; // 返回的是 *this 的引用，无需拷贝过程
 }
 对于赋值函数，应当用“引用传递”的方式返回String 对象。如果用“值传递”的
 方式，虽然功能仍然正确，但由于return 语句要把 *this 拷贝到保存返回值的外部存
 储单元之中，增加了不必要的开销，降低了赋值函数的效率。例如：
 String a,b,c;
 
 a = b; // 如果用“值传递”，将产生一次 *this 拷贝
 a = b = c; // 如果用“值传递”，将产生两次 *this 拷贝
 String 的相加函数operate + 的实现如下：
 String operate+(const String &s1, const String &s2)
 {
 String temp;
 delete temp.data; // temp.data 是仅含‘\0’的字符串
 temp.data = new char[strlen(s1.data) + strlen(s2.data) +1];
 strcpy(temp.data, s1.data);
 strcat(temp.data, s2.data);
 return temp;
 }
 对于相加函数，应当用“值传递”的方式返回String 对象。如果改用“引用传递”，
 那么函数返回值是一个指向局部对象temp 的“引用”。由于temp 在函数结束时被自动
 销毁，将导致返回的“引用”无效。例如：
 c = a + b;
 此时 a + b 并不返回期望值，c 什么也得不到，流下了隐患。

6.3 函数内部实现的规则
 不同功能的函数其内部实现各不相同，看起来似乎无法就“内部实现”达成一致的
 观点。但根据经验，我们可以在函数体的“入口处”和“出口处”从严把关，从而提高
 函数的质量。
  【规则6-3-1】在函数体的“入口处”，对参数的有效性进行检查。
 很多程序错误是由非法参数引起的，我们应该充分理解并正确使用“断言”（assert）
 来防止此类错误。详见6.5 节“使用断言”。

  【规则6-3-2】在函数体的“出口处”，对return 语句的正确性和效率进行检查。
 如果函数有返回值，那么函数的“出口处”是return 语句。我们不要轻视return
 语句。如果return 语句写得不好，函数要么出错，要么效率低下。
 注意事项如下：
 （1）return 语句不可返回指向“栈内存”的“指针”或者“引用”，因为该内存在函数
 体结束时被自动销毁。例如
 char * Func(void)
 {
 char str[] = “hello world”; // str 的内存位于栈上
 …
 return str; // 将导致错误
 }
 （2）要搞清楚返回的究竟是“值”、“指针”还是“引用”。
 （3）如果函数返回值是一个对象，要考虑return 语句的效率。例如
 return String(s1 + s2);
 这是临时对象的语法，表示“创建一个临时对象并返回它”。不要以为它与“先创建
 一个局部对象temp 并返回它的结果”是等价的，如
 String temp(s1 + s2);
 return temp;
 实质不然，上述代码将发生三件事。首先，temp 对象被创建，同时完成初始化；然
 后拷贝构造函数把temp 拷贝到保存返回值的外部存储单元中；最后，temp 在函数结束
 时被销毁（调用析构函数）。然而“创建一个临时对象并返回它”的过程是不同的，编
 译器直接把临时对象创建并初始化在外部存储单元中，省去了拷贝和析构的化费，提高
 了效率。
 类似地，我们不要将
 return int(x + y); // 创建一个临时变量并返回它
 写成
 int temp = x + y;
 return temp;
 由于内部数据类型如int,float,double 的变量不存在构造函数与析构函数，虽然该“临
 时变量的语法”不会提高多少效率，但是程序更加简洁易读。
6.4 其它建议
  【建议6-4-1】函数的功能要单一，不要设计多用途的函数。
  【建议6-4-2】函数体的规模要小，尽量控制在50 行代码之内。
  【建议6-4-3】尽量避免函数带有“记忆”功能。相同的输入应当产生相同的输出。
 带有“记忆”功能的函数，其行为可能是不可预测的，因为它的行为可能取决于某

 种“记忆状态”。这样的函数既不易理解又不利于测试和维护。在C/C++语言中，函数
 的static 局部变量是函数的“记忆”存储器。建议尽量少用static 局部变量，除非必需。
  【建议6-4-4】不仅要检查输入参数的有效性，还要检查通过其它途径进入函数体内
 的变量的有效性，例如全局变量、文件句柄等。
  【建议6-4-5】用于出错处理的返回值一定要清楚，让使用者不容易忽视或误解错误
 情况。
6.5 使用断言
 程序一般分为Debug 版本和Release 版本，Debug 版本用于内部调试，Release 版本
 发行给用户使用。
 断言 assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生的情况。示
 例6-5 是一个内存复制函数。在运行过程中，如果assert 的参数为假，那么程序就会中
 止（一般地还会出现提示对话，说明在什么地方引发了assert）。
 void *memcpy(void *pvTo, const void *pvFrom, size_t size)
 {
 assert((pvTo != NULL) && (pvFrom != NULL)); // 使用断言
 byte *pbTo = (byte *) pvTo; // 防止改变pvTo 的地址
 byte *pbFrom = (byte *) pvFrom; // 防止改变pvFrom 的地址
 while(size -- > 0 )
 *pbTo ++ = *pbFrom ++ ;
 return pvTo;
 }
 示例 6-5 复制不重叠的内存块
 assert 不是一个仓促拼凑起来的宏。为了不在程序的Debug 版本和Release 版本引
 起差别，assert 不应该产生任何副作用。所以assert 不是函数，而是宏。程序员可以把
 assert 看成一个在任何系统状态下都可以安全使用的无害测试手段。如果程序在assert
 处终止了，并不是说含有该assert 的函数有错误，而是调用者出了差错，assert 可以帮
 助我们找到发生错误的原因。
 很少有比跟踪到程序的断言，却不知道该断言的作用更让人沮丧的事了。你化了很
 多时间，不是为了排除错误，而只是为了弄清楚这个错误到底是什么。有的时候，程序
 员偶尔还会设计出有错误的断言。所以如果搞不清楚断言检查的是什么，就很难判断错
 误是出现在程序中，还是出现在断言中。幸运的是这个问题很好解决，只要加上清晰的
 注释即可。这本是显而易见的事情，可是很少有程序员这样做。这好比一个人在森林里，
 看到树上钉着一块“危险”的大牌子。但危险到底是什么？树要倒？有废井？有野兽？
 除非告诉人们“危险”是什么，否则这个警告牌难以起到积极有效的作用。难以理解的
 断言常常被程序员忽略，甚至被删除。[Maguire, p8-p30]

  【规则6-5-1】使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况
 之间的区别，后者是必然存在的并且是一定要作出处理的。
  【规则6-5-2】在函数的入口处，使用断言检查参数的有效性（合法性）。
  【建议6-5-1】在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”
 一旦确定了的假定，就要使用断言对假定进行检查。
  【建议6-5-2】一般教科书都鼓励程序员们进行防错设计，但要记住这种编程风格可
 能会隐瞒错误。当进行防错设计时，如果“不可能发生”的事情的确发生了，则要
 使用断言进行报警。

6.6 引用与指针的比较
 引用是 C++中的概念，初学者容易把引用和指针混淆一起。一下程序中，n 是m 的
 一个引用（reference），m 是被引用物（referent）。
 int m;
 int &n = m;
 n 相当于m 的别名（绰号），对n 的任何操作就是对m 的操作。例如有人名叫王小毛，
 他的绰号是“三毛”。说“三毛”怎么怎么的，其实就是对王小毛说三道四。所以n 既
 不是m 的拷贝，也不是指向m 的指针，其实n 就是m 它自己。
 引用的一些规则如下：
 （1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
 （2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
 （3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。
 以下示例程序中，k 被初始化为i 的引用。语句k = j 并不能将k 修改成为j 的引
 用，只是把k 的值改变成为6。由于k 是i 的引用，所以i 的值也变成了6。
 int i = 5;
 int j = 6;
 int &k = i;
 k = j; // k 和i 的值都变成了6;
 上面的程序看起来象在玩文字游戏，没有体现出引用的价值。引用的主要功能是传
 递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、
 指针传递和引用传递。
 以下是“值传递”的示例程序。由于Func1 函数体内的x 是外部变量n 的一份拷贝，
 改变x 的值不会影响n, 所以n 的值仍然是0。
 void Func1(int x)
 {
 x = x + 10;
 }
 
 int n = 0;
 Func1(n);
 cout << “n = ” << n << endl; // n = 0
 以下是“指针传递”的示例程序。由于Func2 函数体内的x 是指向外部变量n 的指
 针，改变该指针的内容将导致n 的值改变，所以n 的值成为10。
 void Func2(int *x)
 {
 (* x) = (* x) + 10;
 }
 
 int n = 0;
 Func2(&n);
 cout << “n = ” << n << endl; // n = 10
 以下是“引用传递”的示例程序。由于Func3 函数体内的x 是外部变量n 的引用，
 x 和n 是同一个东西，改变x 等于改变n，所以n 的值成为10。
 void Func3(int &x)
 {
 x = x + 10;
 }
 
 int n = 0;
 Func3(n);
 cout << “n = ” << n << endl; // n = 10
 对比上述三个示例程序，会发现“引用传递”的性质象“指针传递”，而书写方式
 象“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做，为什么还要“引
 用”这东西？
 答案是“用适当的工具做恰如其分的工作”。
 指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。
 就象一把刀，它可以用来砍树、裁纸、修指甲、理发等等，谁敢这样用？
 如果的确只需要借用一下某个对象的“别名”，那么就用“引用”，而不要用“指针”，
 以免发生意外。比如说，某人需要一份证明，本来在文件上盖上公章的印子就行了，如
 果把取公章的钥匙交给他，那么他就获得了不该有的权利。

//------------------------------------第 7 章内存管理
7.1 内存分配方式
 内存分配方式有三种：
 （1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的
 整个运行期间都存在。例如全局变量，static 变量。
 （2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函
 数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集
 中，效率很高，但是分配的内存容量有限。
 （3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意
 多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存
 期由我们决定，使用非常灵活，但问题也最多。

7.2 常见的内存错误及其对策
 发生内存错误是件非常麻烦的事情。编译器不能自动发现这些错误，通常是在程序运行时才能捕捉到。
 而这些错误大多没有明显的症状，时隐时现，增加了改错的难度。
 常见的内存错误及其对策如下：
 1.内存分配未成功，却使用了它。
  编程新手常犯这种错误，因为他们没有意识到内存分配会不成功。常用解决办法是，
  在使用内存之前检查指针是否为NULL。如果指针p 是函数的参数，那么在函数的入口
  处用assert(p!=NULL)进行检查。如果是用malloc 或new 来申请内存，应该用if(p==NULL)
  或if(p!=NULL)进行防错处理。
 2.内存分配虽然成功，但是尚未初始化就引用它。
  犯这种错误主要有两个起因：一是没有初始化的观念；二是误以为内存的缺省初值全为零，导
  致引用初值错误（例如数组）。
  内存的缺省初值究竟是什么并没有统一的标准，尽管有些时候为零值，我们宁可信其无不可信
  其有。所以无论用何种方式创建数组，都别忘了赋初值，即便是赋零值也不可省略，不要嫌麻烦。
 3.内存分配成功并且已经初始化，但操作越过了内存的边界。
  例如在使用数组时经常发生下标“多1”或者“少1”的操作。特别是在for 循环语句中，循环次数
  很容易搞错，导致数组操作越界。
 4.忘记了释放内存，造成内存泄露。
  含有这种错误的函数每被调用一次就丢失一块内存。刚开始时系统的内存充足，你
  看不到错误。终有一次程序突然死掉，系统出现提示：内存耗尽。
  动态内存的申请与释放必须配对，程序中malloc 与free 的使用次数一定要相同，
  否则肯定有错误（new/delete 同理）。
 5.释放了内存却继续使用它。
  有三种情况：
  （1）程序中的对象调用关系过于复杂，实在难以搞清楚某个对象究竟是否已经释放了
  内存，此时应该重新设计数据结构，从根本上解决对象管理的混乱局面。
  （2）函数的return 语句写错了，注意不要返回指向“栈内存”的“指针”或者“引用”，
  因为该内存在函数体结束时被自动销毁。
  （3）使用free 或delete 释放了内存后，没有将指针设置为NULL。导致产生“野指针”。
 【规则7-2-1】用malloc 或new 申请内存之后，应该立即检查指针值是否为NULL。
  防止使用指针值为NULL 的内存。
 【规则7-2-2】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右
  值使用。
 【规则7-2-3】避免数组或指针的下标越界，特别要当心发生“多1”或者“少1”
  操作。
 【规则7-2-4】动态内存的申请与释放必须配对，防止内存泄漏。
 【规则7-2-5】用free 或delete 释放了内存之后，立即将指针设置为NULL，防止
  产生“野指针”。
  
7.3 指针与数组的对比
 C++/C 程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。
 数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而不是指向）
 一块内存，其地址与容量在生命期内保持不变，只有数组的内容以改变。指针可以随时指向任意类
 型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。
 下面以字符串为例比较指针与数组的特性。
 7.3.1 修改内容
 7.3.2 内容复制与比较
 7.3.3 计算内存容量
  用运算符sizeof 可以计算出数组的容量（字节数）。但是sizeof指针的值却是4。

7.4 指针参数是如何传递内存的？
 如果函数的参数是一个指针，不要指望用该指针去申请动态内存。
 Test 函数的语句GetMemory(str, 200)并没有使str 获得期望的内存，str 依旧是NULL；
 void GetMemory(char *p, int num)
 {
 p = (char *)malloc(sizeof(char) * num);
 }
 void Test(void)
 {
 char *str = NULL;
 GetMemory(str, 100); // str 仍然为 NULL
 strcpy(str, "hello"); // 运行错误
 }
 毛病出在函数GetMemory 中。编译器总是要为函数的每个参数制作临时副本，指针
 参数p 的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p 的内容，就导致
 参数p 的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p 申请
 了新的内存，只是把_p 所指的内存地址改变了，但是p 丝毫未变。所以函数GetMemory
 并不能输出任何东西。事实上，每执行一次GetMemory 就会泄露一块内存，因为没有用
 free 释放内存。
 如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”。
 void GetMemory2(char **p, int num)
 {
 *p = (char *)malloc(sizeof(char) * num);
 }
 void Test2(void)
 {
 char *str = NULL;
 GetMemory2(&str, 100); // 注意参数是 &str，而不是str
 strcpy(str, "hello");
 cout<< str << endl;
 free(str);
 }
 由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态
 内存。这种方法更加简单.
 char *GetMemory3(int num)
 {
 char *p = (char *)malloc(sizeof(char) * num);
 return p;
 }
 void Test3(void)
 {
 char *str = NULL;
 str = GetMemory3(100);
 strcpy(str, "hello");
 cout<< str << endl;
 free(str);
 }
 用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return 语句用错
 了。这里强调不要用return 语句返回指向“栈内存”的指针，因为该内存在函数结束时
 自动消亡.
7.5 free 和delete 把指针怎么啦？
 别看 free 和delete 的名字恶狠狠的（尤其是delete），它们只是把指针所指的内存给
 释放掉，但并没有把指针本身干掉。
 我们发现指针p 被free 以后其地址仍然不变（非NULL），只是
 该地址对应的内存是垃圾，p 成了“野指针”。如果此时不把p 设置为NULL，会让人误
 以为p 是个合法的指针。
 如果程序比较长，我们有时记不住p 所指的内存是否已经被释放，在继续使用p 之
 前，通常会用语句if (p != NULL)进行防错处理。很遗憾，此时if 语句起不到防错作
 用，因为即便p 不是NULL 指针，它也不指向合法的内存块。

7.6 动态内存会被自动释放吗？
 函数体内的局部变量在函数结束时自动消亡。很多人误以为示例7-6 是正确的。理
 由是p 是局部的指针变量，它消亡的时候会让它所指的动态内存一起完蛋。这是错觉！
 void Func(void)
 {
  char *p = (char *) malloc(100); // 动态内存会自动释放吗？
 }
 我们发现指针有一些“似是而非”的特征：
 （1）指针消亡了，并不表示它所指的内存会被自动释放。
 （2）内存被释放了，并不表示指针会消亡或者成了NULL 指针。
 这表明释放内存并不是一件可以草率对待的事。也许有人不服气，一定要找出可以
 草率行事的理由：

7.7 杜绝“野指针”
 “野指针”不是NULL 指针，是指向“垃圾”内存的指针。人们一般不会错用NULL
 指针，因为用if 语句很容易判断。但是“野指针”是很危险的，if 语句对它不起作用。
 “野指针”的成因主要有两种：
 （1）指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL 指针，它
  的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么
  将指针设置为NULL，要么让它指向合法的内存。例如
  char *p = NULL;
  char *str = (char *) malloc(100);
 （2）指针p 被free 或者delete 之后，没有置为NULL，让人误以为p 是个合法的指针。
 （3）指针操作超越了变量的作用范围。这种情况让人防不胜防.

7.8 有了malloc/free 为什么还要new/delete ？
 malloc 与free 是C++/C 语言的标准库函数，new/delete 是C++的运算符。它们都可
 用于申请动态内存和释放内存。
 对于非内部数据类型的对象而言，光用maloc/free 无法满足动态对象的要求。对象
 在创建的同时要自动执行构造函数， 对象在消亡之前要自动执行析构函数。由于
 malloc/free 是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数
 和析构函数的任务强加于malloc/free。
 因此 C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个
 能完成清理与释放内存工作的运算符delete。注意new/delete 不是库函数。
 
 所以我们不要企图用malloc/free 来完成动态对象的内存管理，应该用new/delete。
 由于内部数据类型的“ 对象”没有构造与析构的过程，对它们而言malloc/free 和
 new/delete 是等价的。
 既然 new/delete 的功能完全覆盖了malloc/free，为什么C++不把malloc/free 淘
 汰出局呢？这是因为C++程序经常要调用C 函数，而C 程序只能用malloc/free 管理动
 态内存。
 如果用 free 释放“new 创建的动态对象”，那么该对象因无法执行析构函数而可能
 导致程序出错。如果用delete 释放“malloc 申请的动态内存”，理论上讲程序不会出错，
 但是该程序的可读性很差。所以new/delete 必须配对使用，malloc/free 也一样。

7.9 内存耗尽怎么办？
 如果在申请动态内存时找不到足够大的内存块，malloc 和new 将返回NULL 指针，
 宣告内存申请失败。通常有三种方式处理“内存耗尽”问题。
 （1）判断指针是否为NULL，如果是则马上用return 语句终止本函数。例如：
 void Func(void)
 {
  A *a = new A;
  if(a == NULL)
  {
   return;
  }
  …
 }
 （2）判断指针是否为NULL，如果是则马上用exit(1)终止整个程序的运行。例如：
 void Func(void)
 {
  A *a = new A;
  if(a == NULL)
  {
   cout << “Memory Exhausted” << endl;
   exit(1);
  }
  …
 }
 （3）为new 和malloc 设置异常处理函数。例如Visual C++可以用_set_new_hander 函
   数为 new 设置用户自己定义的异常处理函数，也可以让malloc 享用与new 相同的异常
   处理函数。详细内容请参考C++使用手册。
 上述（1）（2）方式使用最普遍。如果一个函数内有多处需要申请动态内存，那么
 方式（1）就显得力不从心（释放内存很麻烦），应该用方式（2）来处理。
 
7.10 malloc/free 的使用要点 
 函数 malloc 的原型如下：
 void * malloc(size_t size);
 用 malloc 申请一块长度为length 的整数类型的内存，程序如下：
 int *p = (int *) malloc(sizeof(int) * length);
 我们应当把注意力集中在两个要素上：“类型转换”和“sizeof”。
  malloc 返回值的类型是void *，所以在调用malloc 时要显式地进行类型转换，将
 void * 转换成所需要的指针类型。
  malloc 函数本身并不识别要申请的内存是什么类型，它只关心内存的总字节数。
 
 函数 free 的原型如下：
 void free( void * memblock );
 为什么free 函数不象malloc 函数那样复杂呢？这是因为指针p 的类型以及它所指
 的内存的容量事先都是知道的，语句free(p)能正确地释放内存。如果p 是NULL 指针，
 那么free 对p 无论操作多少次都不会出问题。如果p 不是NULL 指针，那么free 对p
 连续操作两次就会导致程序运行错误。

7.11 new/delete 的使用要点
 运算符new 使用起来要比函数malloc 简单得多，例如：
 int *p1 = (int *)malloc(sizeof(int) * length);
 int *p2 = new int[length];
 这是因为new 内置了sizeof、类型转换和类型安全检查功能。对于非内部数据类型
 的对象而言，new 在创建动态对象的同时完成了初始化工作。如果对象有多个构造函数，
 那么new 的语句也可以有多种形式。例如
 class Obj
 {
 public :
 Obj(void); // 无参数的构造函数
 Obj(int x); // 带一个参数的构造函数
 …
 }
 void Test(void)
 {
 Obj *a = new Obj;
 Obj *b = new Obj(1); // 初值为1
 …
 delete a;
 delete b;
 }
 如果用new 创建对象数组，那么只能使用对象的无参数构造函数。例如
 Obj *objects = new Obj[100]; // 创建100 个动态对象
 不能写成
 Obj *objects = new Obj[100](1);// 创建100 个动态对象的同时赋初值1
 在用delete 释放对象数组时，留意不要丢了符号‘[]’。例如
 delete []objects; // 正确的用法
 delete objects; // 错误的用法
 后者相当于delete objects[0]，漏掉了另外99 个对象。

7.12 一些心得体会
 
 
 
//------------------------------第 8 章 C++函数的高级特性
对比于C 语言的函数，C++增加了重载（overloaded）、内联（inline）、const 和virtual
四种新机制。其中重载和内联机制既可用于全局函数也可用于类的成员函数，const 与
virtual 机制仅用于类的成员函数。

8.1 函数重载的概念
 所以只能靠参数而不能靠返回值类型的不同来区分重载函数。
 重载的首要前提就是作用域相同，而作用域不同会造成隐藏（遮掩）
 编译器根据参数为每
 个重载函数产生不同的内部标识符。例如编译器为示例8-1-1 中的三个Eat 函数产生象
 _eat_beef、_eat_fish、_eat_chicken 之类的内部标识符（不同的编译器可能产生不同
 风格的内部标识符）。
 
 假设某个C 函数的声明如下：
 void foo(int x, int y);
 该函数被C 编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int
 之类的名字用来支持函数重载和类型安全连接。由于编译后的名字不同，C++程序不能
 直接调用C 函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。
 例如：
 extern “C”
 {
 void foo(int x, int y);
  // 其它函数
 }
 或者写成
 extern “C”
 {
 #include “myheader.h”
  // 其它C 头文件
 }
 这就告诉C++编译器，函数foo 是个C 连接，应该到库中找名字_foo 而不是找
 _foo_int_int。C++编译器开发商已经对C 标准库的头文件作了extern“C”处理，所以
 我们可以用＃include 直接引用这些头文件。

 注意并不是两个函数的名字相同就能构成重载。全局函数和类的成员函数同名不算
 重载，因为函数的作用域不同。(重载的首要前提就是作用域相同，而作用域不同会造成隐藏（遮掩）)
 
 Print(); // 成员函数
 }
 不论两个 Print 函数的参数是否不同，如果类的某个成员函数要调用全局函数
 Print，为了与成员函数Print 区别，全局函数被调用时应加‘::’标志。如
 ::Print(); // 表示Print 是全局函数而非成员函数

8.1.3 当心隐式类型转换导致重载函数产生二义性
 ，第一个output 函数的参数是int 类型，第二个output 函数的参数
 是float 类型。由于数字本身没有类型，将数字当作参数时将自动进行类型转换（称为
 隐式类型转换）。语句output(0.5)将产生编译错误，因为编译器不知道该将0.5 转换成
 int 还是float 类型的参数。隐式类型转换在很多地方可以简化程序的书写，但是也可
 能留下隐患。
 # include <iostream.h>
 void output( int x); // 函数声明
 void output( float x); // 函数声明
 void output( int x)
 {
 cout << " output int " << x << endl ;
 }
 void output( float x)
 {
 cout << " output float " << x << endl ;
 }
 void main(void)
 {
 int x = 1;
 float y = 1.0;
 output(x); // output int 1
 output(y); // output float 1
 output(1); // output int 1
 // output(0.5); // error! ambiguous call, 因为自动类型转换
 output(int(0.5)); // output int 0
 output(float(0.5)); // output float 0.5
 }

8.2 成员函数的重载、覆盖与隐藏
 成员函数的重载、覆盖（override）与隐藏很容易混淆，C++程序员必须要搞清楚
 概念，否则错误将防不胜防。
 
 8.2.1 重载与覆盖
 成员函数被重载的特征：
 （1）相同的范围（在同一个类中）；
 （2）函数名字相同；
 （3）参数不同；
 （4）virtual 关键字可有可无。
 
 覆盖是指派生类函数覆盖基类函数
 特征是：
 （1）不同的范围（分别位于派生类与基类）；
 （2）函数名字相同；
 （3）参数相同；
 （4）基类函数必须有virtual 关键字。
 
 8.2.2 令人迷惑的隐藏规则
 这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数:
 （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
 关键字，基类的函数将被隐藏（注意别与重载混淆）。
 （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。
 8.2.3 摆脱隐藏
 隐藏规则引起了不少麻烦。示例8-2-3 程序中，语句pd->f(10)的本意是想调用函
 数Base::f(int)，但是Base::f(int)不幸被Derived::f(char *)隐藏了。由于数字10
 不能被隐式地转化为字符串，所以在编译时出错。
 
8.3 参数的缺省值
 有一些参数的值在每次函数调用时都相同，书写这样的语句会使人厌烦。C++语言
 采用参数的缺省值使书写变得简洁（在编译时，缺省值由编译器自动插入）。
 
 参数缺省值的使用规则：
 【规则8-3-1】参数缺省值只能出现在函数的声明中，而不能出现在定义体中。
 例如：
 void Foo(int x=0, int y=0); // 正确，缺省值出现在函数的声明中
 void Foo(int x=0, int y=0) // 错误，缺省值出现在函数的定义体中
 {
 
 }
 为什么会这样？我想是有两个原因：一是函数的实现（定义）本来就与参数是否有
 缺省值无关，所以没有必要让缺省值出现在函数的定义体中。二是参数的缺省值可能会
 改动，显然修改函数的声明比修改函数的定义要方便。
 【规则8-3-2】如果函数有多个参数，参数只能从后向前挨个儿缺省，否则将导致
  函数调用语句怪模怪样。
 
8.4 运算符重载
 8.4.1 概念
  在 C++语言中，可以用关键字operator 加上运算符来表示函数，叫做运算符重载。 
 由于 C++语言支持函数重载，才能将运算符当成函数来用.
 8.4.2 不能被重载的运算符
 在 C++运算符集合中，有一些运算符是不允许被重载的。这种限制是出于安全方面
 的考虑，可防止错误和混乱。
 （1）不能改变C++内部数据类型（如int,float 等）的运算符。
 （2）不能重载‘.’，因为‘.’在类中对任何成员都有意义，已经成为标准用法。
 （3）不能重载目前C++运算符集合中没有的符号，如#,@,$等。原因有两点，一是难以
 理解，二是难以确定优先级。
 （4）对已经存在的运算符进行重载时，不能改变优先级规则，否则将引起混乱。 
  
8.5 函数内联
 8.5.1 用内联取代宏代码
  C++ 语言支持函数内联，其目的是为了提高函数的执行效率（速度）。
  在 C 程序中，可以用宏代码提高执行效率。宏代码本身不是函数，但使用起来象函
  数。预处理器用复制宏代码的方式代替函数调用，省去了参数压栈、生成汇编语言的CALL
  调用、返回参数、执行return 等过程，从而提高了速度。使用宏代码最大的缺点是容
  易出错，预处理器在复制宏代码时常常产生意想不到的边际效应。例如
  #define MAX(a, b) (a) > (b) ? (a) : (b)
  语句
  result = MAX(i, j) + 2 ;
  将被预处理器解释为
  result = (i) > (j) ? (i) : (j) + 2 ;
  由于运算符‘+’比运算符‘:’的优先级高，所以上述语句并不等价于期望的
  result = ( (i) > (j) ? (i) : (j) ) + 2 ;
  如果把宏代码改写为
  #define MAX(a, b) ( (a) > (b) ? (a) : (b) )
  则可以解决由优先级引起的错误。但是即使使用修改后的宏代码也不是万无一失的，例
  如语句
  result = MAX(i++, j);
  将被预处理器解释为
  result = (i++) > (j) ? (i++) : (j);
  对于 C++ 而言，使用宏代码还有另一种缺点：无法操作类的私有数据成员。
 
 “函数内联”是如何工作的?
  对于任何内联函数，编译器在符号
  表里放入函数的声明（包括名字、参数类型、返回值类型）。如果编译器没有发现内联
  函数存在错误，那么该函数的代码也被放入符号表里。在调用一个内联函数时，编译器
  首先检查调用是否正确（进行类型安全检查，或者进行自动类型转换，当然对所有的函
  数都一样）。如果正确，内联函数的代码就会直接替换函数调用，于是省去了函数调用
  的开销。这个过程与预处理有显著的不同，因为预处理器不能进行类型安全检查，或者
  进行自动类型转换。假如内联函数是成员函数，对象的地址（this）会被放在合适的地
  方，这也是预处理器办不到的。
  
  C++ 语言的函数内联机制既具备宏代码的效率，又增加了安全性，而且可以自由操
  作类的数据成员。所以在C++ 程序中，应该用内联函数取代所有宏代码，“断言assert”
  恐怕是唯一的例外。assert 是仅在Debug 版本起作用的宏，它用于检查“不应该”发生
  的情况。为了不在程序的Debug 版本和Release 版本引起差别，assert 不应该产生任何
  副作用。如果assert 是函数，由于函数调用会引起内存、代码的变动，那么将导致Debug
  版本与Release 版本存在差异。所以assert 不是函数，而是宏。
 
 8.5.2 内联函数的编程风格
  关键字inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在
  函数声明前面不起任何作用。
  
  所以说，inline 是一种“用于实现的关键字”，而不是一种“用于声明的关键字”。
  一般地，用户可以阅读函数的声明，但是看不到函数的定义。尽管在大多数教科书中内
  联函数的声明、定义体前面都加了inline 关键字，但我认为inline 不应该出现在函数
  的声明中。这个细节虽然不会影响函数的功能，但是体现了高质量C++/C 程序设计风格
  的一个基本原则：声明与定义不可混为一谈，用户没有必要、也不应该知道函数是否需
  要内联。
 
  定义在类声明之中的成员函数将自动地成为内联函数。
  
 8.5.3 慎用内联
  内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？
  如果所有的函数都是内联函数，还用得着“内联”这个关键字吗？
  内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的 
  执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收
  获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，
  消耗更多的内存空间。以下情况不宜使用内联：
  （1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
  （2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大。
  类的构造函数和析构函数容易让人误解成使用内联更有效。要当心构造函数和析构
  函数可能会隐藏一些行为，如“偷偷地”执行了基类或成员对象的构造函数和析构函数。
  所以不要随便地将构造函数和析构函数的定义体放在类声明中。
  一个好的编译器将会根据函数的定义体，自动地取消不值得的内联（这进一步说明
  了inline 不应该出现在函数的声明中）。

//-----------------------------第 9 章类的构造函数、析构函数与赋值函数
9.1 构造函数与析构函数的起源
 作为比C 更先进的语言，C++提供了更好的机制来增强程序的安全性。C++编译器
 具有严格的类型安全检查功能，它几乎能找出程序中所有的语法问题，这的确帮了程序
 员的大忙。但是程序通过了编译检查并不表示错误已经不存在了，在“错误”的大家庭
 里，“语法错误”的地位只能算是小弟弟。级别高的错误通常隐藏得很深，就象狡猾的
 罪犯，想逮住他可不容易。
 
 构造函数与析构函数的另一个特别之处是没有返回值类型，这与返回
 值类型为void 的函数不同。
 
9.2 构造函数的初始化表
 构造函数有个特殊的初始化方式叫“初始化表达式表”（简称初始化表）。初始化表
 位于函数参数表之后，却在函数体 {} 之前。这说明该表里的初始化工作发生在函数体
 内的任何代码被执行之前。
 
 构造函数初始化表的使用规则：
 1.如果类存在继承关系，派生类必须在其初始化表里调用基类的构造函数。
 2.类的const 常量只能在初始化表里被初始化，因为它不能在函数体内用赋值的方式来初始化.
 3.类的数据成员的初始化可以采用初始化表或函数体内赋值两种方式，这两种方式的
   效率不完全相同。非内部数据类型的成员对象应当采用第一种方式初始化，以获取更高的效.
 
9.3 构造和析构的次序
 构造从类层次的最根处开始，在每一层中，首先调用基类的构造函数，然后调用成
 员对象的构造函数。析构则严格按照与构造相反的次序执行，该次序是唯一的，否则编
 译器将无法自动执行析构过程。
 一个有趣的现象是，成员对象初始化的次序完全不受它们在初始化表中次序的影
 响，只由成员对象在类中声明的次序决定。这是因为类的声明是唯一的，而类的构造函
 数可以有多个，因此会有多个不同次序的初始化表。如果成员对象按照初始化表的次序
 进行构造，这将导致析构函数无法得到唯一的逆序。
 
9.5 不要轻视拷贝构造函数与赋值函数
 如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。
 倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。
 
 以类String 的两个对象a,b 为例，假设a.m_data 的内容为“hello”，
 b.m_data 的内容为“world”。
 现将 a 赋给b，缺省赋值函数的“位拷贝”意味着执行b.m_data = a.m_data。
 这将造成三个错误：一是b.m_data 原有的内存没被释放，造成内存泄露；二是
 b.m_data 和a.m_data 指向同一块内存，a 或b 任何一方变动都会影响另一方；三
 是在对象被析构时，m_data 被释放了两次。
 
 拷贝构造函数和赋值函数非常容易混淆，常导致错写、错用。拷贝构造函数是在对
 象被创建时调用的，而赋值函数只能被已经存在了的对象调用。
 
 
9.8 如何在派生类中实现类的基本函数
 基类的构造函数、析构函数、赋值函数都不能被派生类继承。如果类之间存在继承
 关系，在编写上述基本函数时应注意以下事项：
 1.派生类的构造函数应在其初始化表里调用基类的构造函数。
 2.基类与派生类的析构函数应该为虚（即加virtual 关键字）。
 3.在编写派生类的赋值函数时，注意不要忘记对基类的数据成员重新赋值。
 
//------------------------------第 10 章类的继承与组合
10.1 继承 
10.2 组合 
 
 
//------------------------------第 11 章其它编程经验 
11.1 使用const 提高函数的健壮性
 看到 const 关键字，C++程序员首先想到的可能是const 常量。这可不是良好的条件
 反射。如果只知道用const 定义常量，那么相当于把火药仅用于制作鞭炮。const 更大的
 魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。

11.1.1 用const 修饰函数的参数 
 1.如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引
   用传递”，都不能加const 修饰，否则该参数将失去输出功能。
 
 2.const 只能修饰输入参数：
 
 3.如果输入参数采用“指针传递”，那么加const 修饰可以防止意外地改动该指针，
   起到保护作用。
 
 4.如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该
   输入参数本来就无需保护，所以不要加const 修饰。
  
 5.对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比
  较底。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、
  复制、析构过程都将消耗时间。
  为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用
  一下参数的别名而已，不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点：
  “引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const
  修饰即可，因此函数最终成为void Func(const A &a)。
  以此类推，是否应将void Func(int x) 改写为void Func(const int &x)，以便
  提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制
  也非常快，“值传递”和“引用传递”的效率几乎相当。
  5.1:对于非内部数据类型(符合类型，如类对象)的输入参数，应该将“值传递”的方式改为“const 引用传
   递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。
  5.2:对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。
   否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不
   应该改为void Func(const int &x)。
   
11.1.2 用const 修饰函数的返回值 
 1.如果给以“指针传递”方式的函数返回值加const 修饰，那么函数返回值（即指针）
   的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。
   例如函数
   const char * GetString(void);
 
 2.如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储
   单元中，加const 修饰没有任何价值。
  
 3.函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数
   中，目的是为了实现链式表达。

11.1.3 const 成员函数
 任何不会修改数据成员的函数都应该声明为const 类型。如果在编写const 成员函
 数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，
 这无疑会提高程序的健壮性。
 以下程序中，类stack 的成员函数GetCount 仅用于计数，从逻辑上讲GetCount 应
 当为const 函数。编译器将指出GetCount 函数中的错误。
 class Stack
 {
 public:
  void Push(int elem);
  int Pop(void);
  int GetCount(void) const; // const 成员函数
 private:
  int m_num;
  int m_data[100];
 };
 int Stack::GetCount(void) const
 {
  ++ m_num; // 编译错误，企图修改数据成员m_num
  Pop(); // 编译错误，企图调用非const 函数
  return m_num;
 }
 const 成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部，大
 概是因为其它地方都已经被占用了。
 
11.2 提高程序的效率
 程序的时间效率是指运行速度，空间效率是指程序占用内存或者外存的状况。
 全局效率是指站在整个系统的角度上考虑的效率，局部效率是指站在模块或函数角
 度上考虑的效率。
 
 【规则11-2-1】不要一味地追求程序的效率，应当在满足正确性、可靠性、健壮性、
 可读性等质量因素的前提下，设法提高程序的效率。
 
 【规则11-2-2】以提高程序的全局效率为主，提高局部效率为辅。
 【规则11-2-3】在优化程序的效率时，应当先找出限制效率的“瓶颈”，不要在无关
 紧要之处优化。
 【规则11-2-4】先优化数据结构和算法，再优化执行代码。
 【规则11-2-5】有时候时间效率和空间效率可能对立，此时应当分析那个更重要，
  作出适当的折衷。例如多花费一些内存来提高性能。
 【规则11-2-6】不要追求紧凑的代码，因为紧凑的代码并不能产生高效的机器码。
 

 

参考文献
[Cline] Marshall P. Cline and Greg A. Lomow, C++ FAQs, Addison-Wesley, 1995
[Eckel] Bruce Eckel, Thinking in C++（C++ 编程思想，刘宗田等译），机械工业出版
社，2000
[Maguire] Steve Maguire, Writing Clean Code（编程精粹，姜静波等译），电子工业出
版社，1993
[Meyers] Scott Meyers, Effective C++, Addison-Wesley, 1992
[Murry] Robert B. Murry, C++ Strategies and Tactics, Addison-Wesley, 1993
[Summit] Steve Summit, C Programming FAQs, Addison-Wesley, 1996