以下是阿鲤对高质量c++/c编程指南的读书笔记,分享出来希望对大家有用。这里是前六章的内容,比较简单,可能需要花费一两个小时阅读
1:文件结构
2:程序的版式
3:命名规则
4:表达式和基本语句
5:常量
6:函数设计
一:文件结构:
c++/c程序一般分为两个文件,一个文件用于保存程序的声明,称为头文件;另一个用于保存程序的实现,称为定义文件。通常头文件使用filename.h,定义文件使用filename.cpp/.c的格式
1:头文件的结构:版本声明 + 预处理块 + 函数和类结构声明等
需要注意的:
a:为了防止头文件被重复引用,应当使用ifndef/define/endif结构产生预处理块(#progma once也可以)
b:使用#include<filename.h>往往用来引入标准库的头文件;它会直接在标准库目录搜索。而#include"filename.h"往往用来引入自定义文件;编译器会首先在工作目录中搜索再去库目录搜素。
c:建议头文件只放“声明”而不存放“定义”
d:不提倡使用全局变量
2:定义文件的结构:版本声明 + 对头文件的引用 + 程序的实现(函数和代码)
3:头文件的作用
a:隐藏源码,只提供接口
b:加强类型检查
二:程序的版式:
1:空行 :合理使用空行可使得程序更加优美
a:每个类声明之后,每个函数定义结束之后都要加空行
b:在一个函数体内,逻辑上密切相关的语句之间不要加空行,其他地方空行分割
2:代码行
a:一行代码只做一件事,如定义一个变量,或只写一条语句。
b:if,for,while,do等语句自占一行,执行语句不得紧跟其后。不论执行语句有多少都要加{}。
c:尽可能在定义变量的同时初始化改变量(就近原则)
3:代码行内的空行
a:关键字之后要留空格。象 const、virtual、inline、case 等关键字之后至少要留一个空格,否则无法辨析关键字。象 if、for、while 等关键字之后应留 一个空格再跟左括号‘(’,以突出关键字。
b:函数名之后不要留空格,紧跟左括号‘(’,以与关键字区别。
c:‘(’向后紧跟,‘)’、‘,’、‘
;
’向前紧跟,紧跟处不留空格。
d:‘,’之后要留空格,如
Function(x, y, z)
。如果‘
;
’不是一行的结束 符号,其后要留空格,如 for (initialization; condition; update)。
e:赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符, 如“=
”、“
+=
” “
>=
”、“
<=
”、“
+
”、“
*
”、“
%
”、“
&&
”、“
||
”、“
<<
”
,
“
^
”等二 元操作符的前后应当加空格。
f:一元操作符如“
!
”、“
~
”、“
++
”、“
--
”、“
&
”(地址运算符)等前后不加空格。
g:象“[]”、“.”、“->”这类操作符前后不加空格。
h:对于表达式比较长的
for
语句和
if
语句,为了紧凑起见可以适当地去 掉一些空格,如 for (i=0; i<10; i++)和 if ((a<=b) && (c<=d))
4:对齐
a:程序的分界符‘
{
’和‘
}’应独占一行并且位于同一列,同时与引用 它们的语句左对齐。
b:{ }
之内的代码块在‘
{’右边数格处左对齐。
5:长行拆分
a:
代码行最大长度宜控制在
70
至
80
个字符以内。代码行不要过长,否则眼睛看不过来,也不便于打印。
b:长表达式要在低优先级操作符处拆分成新行,操作符放在新行之首(以便突出操作符)。拆分出的新行要进行适当的缩进,使排版整齐,语句可读。
6:修饰符的位置
修饰符 * 和 & 应该靠近数据类型还是该靠近变量名,是个有争议的活题。 若将修饰符 * 靠近数据类型,例如:int* x; 从语义上讲此写法比较直观,即 x 是 int 类型的指针。
上述写法的弊端是容易引起误解,例如:int* x, y; 此处 y 容易被误解为指针变 量。虽然将 x 和 y 分行定义可以避免误解,但并不是人人都愿意这样做。
a:应当将修饰符
* 和 & 紧靠变量名 例如: char *name;
7:注释
a:注释是对代码的“提示”,而不是文档。程序中的注释不可喧宾夺主, 注释太多了会让人眼花缭乱。注释的花样要少。
b:如果代码本来就是清楚的,则不必加注释。否则多此一举,令人厌烦。 例如i++; // i 加 1,多余的注释
c:边写代码边注释,修改代码同时修改相应的注释,以保证注释与代码 的一致性。不再有用的注释要删除。
d:注释应当准确、易懂,防止注释有二义性。错误的注释不但无益反而有害。
e:尽量避免在注释中使用缩写,特别是不常用缩写。
f:注释的位置应与被描述的代码相邻,可以放在代码的上方或右方,不可放在下方。
g:当代码比较长,特别是有多重嵌套时,应当在一些段落的结束处加注 释,便于阅读
8:类的版式
a:将
private
类型的数据写在前面,而将
public
类型的函数写在后面,如示例
8-3
(
a
)。
采用这种版式的程序员主张类的设计“以数据为中心”,重点关注类的内部结构。
b:将
public
类型的函数写在前面,而将
private
类型的数据写在后面,如示例
8.3
(
b
)
采用这种版式的程序员主张类的设计“以行为为中心”,重点关注的是类应该提供什么
样的接口(或服务)。
很多
C++
教课书受到
Biarne Stroustrup
第一本著作的影响,不知不觉地采用了“以
数据为中心”的书写方式,并不见得有多少道理。
建议采用“以行为为中心”的书写方式,即首先考虑类应该提供什么样的函
数。这是很多人的经验——“这样做不仅让自己在设计类时思路清晰,而且方便别人阅
读。因为用户最关心的是接口,谁愿意先看到一堆私有数据成员!
三:命名规则
1:共性规则
a:标识符应当直观且可以拼读,可望文知意,不必进行“解码”。 标识符最好采用英文单词或其组合,便于记忆和阅读。切忌使用汉语拼音来命名。
程序中的英文单词一般不会太复杂,用词应当准确。例如不要把
CurrentValue
写成
NowValue。
b:标识符的长度应当符合“min-length && max-information”原则。 几十年前老
ANSI C
规定名字不准超过
6
个字符,现今的 C++/C 不再有此限制。一
般来说,长名字能更好地表达含义,所以函数名、变量名、类名长达十几个字符不足为
怪。那么名字是否越长约好?不见得! 例如变量名 maxval 就比 maxValueUntilOverflow
好用。单字符的名字也是有用的,常见的如 i,j,k,m,n,x,y,z 等,它们通常可用作函数 内的局部变量。
c:命名规则尽量与所采用的操作系统或开发工具的风格保持一致。
例如
Windows
应用程序的标识符通常采用“大小写”混排的方式,如
AddChild
。
而
Unix
应用程序的标识符通常采用“小写加下划线”的方式,如
add_child
。别把这两类风格混在一起用。
d:程序中不要出现仅靠大小写区分的相似的标识符。
e:程序中不要出现标识符完全相同的局部变量和全局变量,尽管两者的 作用域不同而不会发生语法错误,但会使人误解。
f:的名字应当使用“名词”或者“形容词+名词”。
例如:
float value;
float oldValue;
float newValue;
g:全局函数的名字应当使用“动词”或者“动词+名词”(动宾词组)。 类的成员函数应当只使用“动词”,被省略掉的名词就是对象本身。
例如:
DrawBox(); // 全局函数
box->Draw(); // 类的成员函数
h:用正确的反义词组命名具有互斥意义的变量或相反动作的函数等。
例如:
int minValue;
int maxValue;
int SetValue(…);
int GetValue(…);
i:尽量避免名字中出现数字编号,如 Value1,Value2 等,除非逻辑上的确需要编号。这是为了防止程序员偷懒,不肯为命名动脑筋而导致产生无意义的名字
四:表达式和基本语句
1:
运算符的优先级
![](https://i-blog.csdnimg.cn/blog_migrate/6490966a423f55f3b6eb99bf302355f4.png)
C++/C
语言的运算符有数十个,运算符的优先级与结合律如表
4-1
所示。注意一元
运算符
+ - *
的优先级高于对应的二元运算符
如果代码行中的运算符比较多,用括号确定表达式的操作顺序,避免
使用默认的优先级。
由于将表
4-1
熟记是比较困难的,为了防止产生歧义并提高可读性,应当用括号确
定表达式的操作顺序。例如:
word = (high << 8) | low
if ((a | b) && (a & c))
2:复合表达式
如
a = b = c = 0
这样的表达式称为复合表达式。允许复合表达式存在的理由是:(
1
)
书写简洁;(
2
)可以提高编译效率。但要防止滥用复合表达式。
a:不要编写太复杂的复合表达式。
例如:
i = a >= b && c < d && c + f <= g + h ; // 复合表达式过于复杂
b:不要有多用途的复合表达式。
例如:
d = (a = b + c) + r ;
该表达式既求
a
值又求
d
值。应该拆分为两个独立的语句:
a = b + c;
d = a + r;
d:不要把程序中的复合表达式与“真正的数学表达式”混淆。
例如:
if (a < b < c) // a < b < c 是数学表达式而不是程序表达式
并不表示
if ((a<b) && (b<c))
而是成了令人费解的
if ( (a<b)<c )
3:if语句
if 语句是 C++/C 语言中最简单、最常用的语句,然而很多程序员用隐含错误的方式
写 if 语句。本节以“与零值比较”为例,展开讨论。
a:布尔变量与零值比较
不可将布尔变量直接与
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)
b:整型变量与零值比较
应当将整型变量用“==”或“!=”直接与 0 比较。
假设整型变量的名字为 value,它与零值比较的标准
if
语句如下:
if (value == 0)
if (value != 0)
不可模仿布尔变量的风格而写成
if (value) // 会让人误解 value 是布尔变量
if (!value)
c:浮点变量与零值比较
不可将浮点变量用“==”或“!=”与任何数字比较。
千万要留意,无论是 float 还是 double 类型的变量,都有精度限制。所以一定要
避免将浮点变量用“==”或“!=”与数字比较,应该设法转化成“>=”或“<=”形式。
假设浮点变量的名字为 x,应当将
if (x == 0.0) // 隐含错误的比较
转化为
if ((x>=-EPSINON) && (x<=EPSINON))
其中 EPSINON 是允许的误差(即精度)。
d:指针变量与零值比较
应当将指针变量用“==”或“!=”与 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)
e:对 if 语句的补充说明
有时候我们可能会看到 if (NULL == p) 这样古怪的格式。不是程序写错了,是程 序员为了防止将 if (p == NULL) 误写成 if (p = NULL),而有意把 p 和 NULL 颠倒。
编译器认为 if (p = NULL) 是合法的,但是会指出 if (NULL = p)是错误的,因为 NULL 不能被赋值。
4:
循环语句的效率
C++/C 循环语句中,for 语句使用频率最高,while 语句其次,do 语句很少用。本
节重点论述循环体的效率。提高循环体效率的基本办法是降低循环体的复杂性。
a:在多重循环中,如果有可能,应当将最长的循环放在最内层,最短的循环放在最外层,以减少 CPU 跨切循环层的次数。
b:如果循环体内存在逻辑判断,并且循环次数很大,宜将逻辑判断移到
循环体的外面。
c:不可在
for
循环体内修改循环变量,防止
for
循环失去控制。
d:建议 for 语句的循环控制变量的取值采用“半开半闭区间”写法。
5:switch语句
switch 是多分支选择语句,而 if 语句只有两个分支可供选择。虽然可以用嵌套的 if 语句来实现多分支选择,但那样的程序冗长难读。这是 switch 语句存在的理由。
a:
每个 case 语句的结尾不要忘了加 break,否则将导致多个分支重叠
b:
不要忘记最后那个 default 分支。即使程序真的不需要 default 处理,也应该保留语句 default : break; 这样做并非多此一举,而是为了防止别人误以 为你忘了 default 处理。
6:
goto
语句
自从提倡结构化设计以来,goto 就成了有争议的语句。首先,由于 goto 语句可以 灵活跳转,如果不加限制,它的确会破坏结构化设计风格。其次,goto 语句经常带来错 误或隐患。它可能跳过了某些对象的构造、变量的初始化、重要的计算等语句。
如果编译器不能发觉此类错误,每用一次 goto 语句都可能留下隐患。很多人建议废除 C++/C 的 goto 语句,以绝后患。但实事求是地说,错误是程序员 自己造成的,不是 goto 的过错。goto 语句至少有一处可显神通,它能从多重循环体中 咻地一下子跳到外面,用不着写很多次的 break 语句;
五:常量
常量是一种标识符,它的值在运行期间恒定不变。C 语言用 #define 来定义常量(称
为宏常量)。C++ 语言除了 #define 外还可以用 const 来定义常量(称为 const 常量)。
1:为什么需要常量
如果不使用常量,直接在程序中填写数字或字符串,将会有什么麻烦?
a:程序的可读性(可理解性)变差。程序员自己会忘记那些数字或字符串是什么意
思,用户则更加不知它们从何处来、表示什么。
b:在程序的很多地方输入同样的数字或字符串,难保不发生书写错误
。
c:如果要修改数字或字符串,则会在很多地方改动,既麻烦又容易出错。
d:尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或
字符串。
例如:
#define MAX 100 /* C 语言的宏常量 */
const int MAX = 100; // C++ 语言的 const 常量
const float PI = 3.14159; // C++ 语言的 const 常量
2:const
与
#define
的比较
C++ 语言可以用 const 来定义常量,也可以用 #define 来定义常量。但是前者比后
者有更多的优点:
a:const 常量有数据类型,而宏常量没有数据类型。编译器可以对前者进行类型安
全检查。而对后者只进行字符替换,没有类型安全检查,并且在字符替换可能会
产生意料不到的错误(边际效应)。
b:
有些集成化的调试工具可以对 const 常量进行调试,但是不能对宏常量进行调
试。
c:在 C++ 程序中只使用 const 常量而不使用宏常量,即const 常量完 全取代宏常量。
3:
常量定义规则
a:需要对外公开的常量放在头文件中,不需要对外公开的常量放在定义 文件的头部。为便于管理,可以把不同模块的常量集中存放在一个公共的头文件中。
b:
如果某一常量与其它常量密切相关,应在定义中包含这种关系,而不 应给出一些孤立的值。
例如:
const float RADIUS = 100;
const float DIAMETER = RADIUS * 2;
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)。
六:函数设计
函数是 C++/C 程序的基本功能单元,其重要性不言而喻。函数设计的细微缺点很容 易导致该函数被错用,所以光使函数的功能正确是不够的。本章重点论述函数的接口设 计和内部实现的一些规则。
函数接口的两个要素是参数和返回值。
C
语言中,函数的参数和返回值的传递方式
有两种:值传递(
pass by value
)和指针传递(
pass by pointer
)。
C++
语言中多了引用
传递(
pass by reference
)。
1:
参数的规则
a:参数的书写要完整,不要贪图省事只写参数的类型而省略参数名字。
如果函数没有参数,则用 void 填充。
例如:
void SetValue(int width, int height); // 良好的风格
void SetValue(int, int); // 不良的风格
float GetValue(void); // 良好的风格
float GetValue(); // 不良的风格
b:
参数命名要恰当,顺序要合理。
例如编写字符串拷贝函数
StringCopy
,它有两个参数。如果把参数名字起为
str1
和
str2
,例如
void StringCopy(char *str1, char *str2);
那么我们很难搞清楚究竟是把
str1
拷贝到
str2
中,还是刚好倒过来。
可以把参数名字起得更有意义,如叫
strSource
和
strDestination
。这样从名字上就
可以看出应该把
strSource
拷贝到
strDestination
。
还有一个问题,这两个参数那一个该在前那一个该在后?参数的顺序要遵循程序员
的习惯。一般地,应将目的参数放在前面,源参数放在后面。
c:如果参数是指针,且仅作输入用,则应在类型前加
const
,以防止该
指针在函数体内被意外修改。
例如:
void StringCopy(char *strDestination,const char *strSource);
e:
如果输入参数以值传递的方式传递对象,则宜改用“const &”方式 来传递,这样可以省去临时对象的构造和析构过程,从而提高效率。
f:避免函数有太多的参数,参数个数尽量控制在
5
个以内。如果参数太
多,在使用时容易将参数类型或顺序搞错。
g:尽量不要使用类型和数目不确定的参数。
C
标准库函数
printf
是采用不确定参数的典型代表,其原型为:
int printf(const chat *format[, argument]…);
这种风格的函数在编译时丧失了严格的类型安全检查。
2:
返回值的规则
a:
不要省略返回值的类型。 C 语言中,凡不加类型说明的函数,一律自动按整型处理。这样做不会有什么好处,
却容易被误解为 void
类型。
C++语言有很严格的类型安全检查,不允许上述情况发生。由于
C++
程序可以调用
C
函数,为了避免混乱,规定任何
C++/ C
函数都必须有类型。如果函数没有返回值,
那么应声明为
void 类型。
b:
函数名字与返回值类型在语义上不可冲突。 违反这条规则的典型代表是
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 误导了使用者。
c:
不要将正常值和错误标志混在一起返回。正常值用输出参数获得,而 错误标志用
return 语句返回。
d:
有时候函数原本不需要返回值,但为了增加灵活性如支持链式表达, 可以附加返回值。
例如字符串拷贝函数 strcpy 的原型:
char *strcpy(char *strDest,const char *strSrc);
strcpy 函数将 strSrc
拷贝至输出参数
strDest
中,同时函数的返回值又是
strDest。这样做并非多此一举,可以获得如下灵活性:
char str[20];
int length = strlen( strcpy(str, “Hello World”) );
e:如果函数的返回值是一个对象,有些场合用“引用传递”替换“值传
递”可以提高效率。而有些场合只能用“值传递”而不能用“引用传递”,否则会
出错。
例如:
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 什么也得不到,流下了隐患
3:
函数内部实现的规则
不同功能的函数其内部实现各不相同,看起来似乎无法就“内部实现”达成一致的
观点。但根据经验,我们可以在函数体的“入口处”和“出口处”从严把关,从而提高
函数的质量
。
a:
在函数体的“入口处”,对参数的有效性进行检查。 很多程序错误是由非法参数引起的,我们应该充分理解并正确使用“断言”(
assert
) 来防止此类错误。
b:
在函数体的“出口处”,对 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
的变量不存在构造函数与析构函数,虽然该“临
时变量的语法”不会提高多少效率,但是程序更加简洁易读。
c:
函数的功能要单一,不要设计多用途的函数。
d:
函数体的规模要小,尽量控制在 50 行代码之内。
e :尽量避免函数带有“记忆”功能。相同的输入应当产生相同的输出。 带有“记忆”功能的函数,其行为可能是不可预测的,因为它的行为可能取决于某种“记忆状态”。这样的函数既不易理解又不利于测试和维护。在 C/C++语言中,函数 的 static 局部变量是函数的“记忆”存储器。建议尽量少用 static 局部变量,除非必需。
f:
不仅要检查输入参数的有效性,还要检查通过其它途径进入函数体内的变量的有效性,例如全局变量、文件句柄等。
g:
用于出错处理的返回值一定要清楚,让使用者不容易忽视或误解错误情况。
6:
使用断言
程序一般分为
Debug
版本和
Release
版本,
Debug
版本用于内部调试,
Release
版本
发行给用户使用。
断言
assert
是仅在
Debug
版本起作用的宏,它用于检查“不应该”发生的情况。示
例
6-5
是一个内存复制函数。在运行过程中,如果
assert
的参数为假,那么程序就会中
止(一般地还会出现提示对话,说明在什么地方引发了
assert
)。
示例 6-5 复制不重叠的内存块
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;
}
assert 不是一个仓促拼凑起来的宏。为了不在程序的 Debug 版本和 Release 版本引 起差别,assert 不应该产生任何副作用。所以 assert 不是函数,而是宏。程序员可以把 assert 看成一个在任何系统状态下都可以安全使用的无害测试手段。如果程序在 assert 处终止了,并不是说含有该 assert 的函数有错误,而是调用者出了差错,assert 可以帮 助我们找到发生错误的原因。
很少有比跟踪到程序的断言,却不知道该断言的作用更让人沮丧的事了。你化了很
多时间,不是为了排除错误,而只是为了弄清楚这个错误到底是什么。有的时候,程序
员偶尔还会设计出有错误的断言。所以如果搞不清楚断言检查的是什么,就很难判断错
误是出现在程序中,还是出现在断言中。幸运的是这个问题很好解决,只要加上清晰的
注释即可。这本是显而易见的事情,可是很少有程序员这样做。这好比一个人在森林里,
看到树上钉着一块“危险”的大牌子。但危险到底是什么?树要倒?有废井?有野兽?
除非告诉人们“危险”是什么,否则这个警告牌难以起到积极有效的作用。难以理解的
断言常常被程序员忽略,甚至被删除。
a:使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况
之间的区别,后者是必然存在的并且是一定要作出处理的。
b:在函数的入口处,使用断言检查参数的有效性(合法性)。
c:在编写函数时,要进行反复的考查,并且自问:“我打算做哪些假定?”
一旦确定了的假定,就要使用断言对假定进行检查。
d:一般教科书都鼓励程序员们进行防错设计,但要记住这种编程风格可
能会隐瞒错误。当进行防错设计时,如果“不可能发生”的事情的确发生了,则要
使用断言进行报警。
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
对比上述三个示例程序,会发现“引用传递”的性质象“指针传递”,而书写方式
象“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做,为什么还要“引
用”这东西?
答案是“用适当的工具做恰如其分的工作”。
指针能够毫无约束地操作内存中的如何东西,尽管指针功能强大,但是非常危险。
就象一把刀,它可以用来砍树、裁纸、修指甲、理发等等,谁敢这样用?
如果的确只需要借用一下某个对象的“别名”,那么就用“引用”,而不要用“指针”,
以免发生意外。比如说,某人需要一份证明,本来在文件上盖上公章的印子就行了,如
果把取公章的钥匙交给他,那么他就获得了不该有的权利。