高质量C++编程

C++编程规范 专栏收录该内容
4 篇文章 0 订阅

//-----------------------------第 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 
 
 
 
 
 
 
 
 

  • 1
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值