1 文件结构
每个C++/C程序通常分为两个文件。一个文件用于保存程序的声明(declaration),称为头文件。另一个文件用于保存程序的实现(implementation),称为定义(definition)文件。
C++/C程序的头文件以“.h”为后缀,C程序的定义文件以“.c”为后缀,C++程序的定义文件通常以“.cpp”为后缀(也有一些系统以“.cc”或“.cxx”为后缀)。
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)头文件开头处的版权和版本声明。
(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
这类声明。
#ifndef GRAPHICS_H // 防止graphics.h被重复引用
#define GRAPHICS_H
#include <math.h> // 引用标准库的头文件
…
#include "myheader.h" // 引用非标准库的头文件
…
void Function1(…); // 全局函数声明
…
class Box // 类结构声明
{
…
};
#endif
1.3 定义文件的结构
定义文件有三部分内容:
(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】在每个类声明之后、每个函数定义结束之后都要加空行。
// 空行
void Function1(…)
{
…
}
// 空行
void Function2(…)
{
…
}
// 空行
void Function3(…)
{
…
}
【规则2-1-2】在一个函数体内,逻揖上密切相关的语句之间不加空行,其它地方应加空行分隔。
// 空行
while (condition)
{
statement1;
// 空行
if (condition)
{
statement2;
}
else
{
statement3;
}
// 空行
statement4;
}
2.2 代码行
【规则2-2-1】一行代码只做一件事情,如只定义一个变量,或只写一条语句。这样的代码容易阅读,并且方便于写注释。
【规则2-2-2】if
、for
、while
、do
等语句自占一行,执行语句不得紧跟其后。不论执行语句有多少都要加{}。这样可以防止书写失误。
风格良好的代码行
int width; // 宽度
int height; // 高度
int depth; // 深度
x = a + b;
y = c + d;
z = e + f;
if (width < height)
{
dosomething();
}
for (initialization; condition; update)
{
dosomething();
}
// 空行
other();
风格不良的代码行(是不是和自己写的代码异常相似)
int width, height, depth; // 宽度高度深度
x = a + b; y = c + d; z = e + f;
if (width < height) dosomething();
for (initialization; condition; update)
dosomething();
other();
2.3 代码行内的空格
【规则2-3-1】关键字之后要留空格。像const
、virtual
、inline
、case
等关键字之后至少要留一个空格,否则无法辨析关键字。像if
、for
、while
等关键字之后应留一个空格再跟左括号(
,以突出关键字。
【规则2-3-2】函数名之后不要留空格,紧跟左括号(
,以与关键字区别。
【规则2-3-3】(
向后紧跟,)
、,
、;
向前紧跟,紧跟处不留空格。如:Function(x, y, z)
和for (initialization; condition; update)
注意此处:;
前都没有空格,)
也是。不良的分格如:Function( x, y, z )
或者for ( initialization; condition; update )
。
【规则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))
void Func1(int x, int y, int z); // 良好的风格
void Func1 (int x,int y,int z); // 不良的风格
if (year >= 2000) // 良好的风格
if(year>=2000) // 不良的风格
if ((a>=b) && (c<=d)) // 良好的风格
if(a>=b&&c<=d) // 不良的风格
for (i=0; i<10; i++) // 良好的风格
for(i=0;i<10;i++) // 不良的风格
for (i = 0; i < 10; i ++) // 过多的空格
x = a < b ? a : b; // 良好的风格
x=a<b?a:b; // 不好的风格
int *x = &y; // 良好的风格
int * x = & y; // 不良的风格
array[5] = 0; // 不要写成 array [ 5 ] = 0;
a.Function(); // 不要写成 a . Function();
b->Function(); // 不要写成 b -> Function();
2.4 对齐
【规则2-4-1】程序的分界符‘{
’和‘}
’应独占一行并且位于同一列,同时与引用它们的语句左对齐。
【规则2-4-2】{ }
之内的代码块在‘{
’右边数格处左对齐。
void Function(int x)
{
… // program code
}
if (condition)
{
… // program code
}
else
{
… // program code
}
for (initialization; condition; update)
{
… // program code
}
While (condition)
{
… // program code
}
如果出现嵌套的{}
,则使用缩进对齐,如:
{
…
{
…
}
…
}
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容易被误解为指针变量。
【规则2-6-1】应当将修饰符 * 和 & 紧靠变量名
例如:
char *name;
int *x, y; // 此处y不会被误解为指针
2.7 注释
C语言的注释符为“/*…*/
”。而在C++语言中,程序块的注释常采用“/*…*/
”,行注释一般采用“//…
”。注释通常用于:
(1)版本、版权声明;
(2)函数接口说明;
(3)重要的代码行或段落提示。
虽然注释有助于理解代码,但注意不可过多地使用注释。
【规则2-7-1】注释是对代码的“提示”,而不是文档。程序中的注释不可喧宾夺主,注释太多了会让人眼花缭乱。注释的花样要少。
【规则2-7-2】如果代码本来就是清楚的,则不必加注释。否则多此一举,令人厌烦。例如
i++; // i 加 1,多余的注释
【规则2-7-3】边写代码边注释,修改代码同时修改相应的注释,以保证注释与代码的一致性。不再有用的注释要删除。
【规则2-7-4】注释应当准确、易懂,防止注释有二义性。错误的注释不但无益反而有害。
【规则2-7-5】尽量避免在注释中使用缩写,特别是不常用缩写。
【规则2-7-6】注释的位置应与被描述的代码相邻,可以放在代码的上方或右方,不可放在下方。
【规则2-7-8】当代码比较长,特别是有多重嵌套时,应当在一些段落的结束处加注释,便于阅读。
3 命名规则
没有一种命名规则可以让所有的程序员赞同,程序设计教科书一般都不指定命名规则。命名规则对软件产品而言并不是“成败悠关”的事,我们不要化太多精力试图发明世界上最好的命名规则,而应当制定一种令大多数项目成员满意的命名规则,并在项目中贯彻实施。
3.1 共性规则
共性规则是被大多数程序员采纳的,我们应当在遵循这些共性规则的前提下,再扩充特定的规则。
【规则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-9】尽量避免名字中出现数字编号,如Value1
,Value2
等,除非逻辑上的确需要编号。这是为了防止程序员偷懒,不肯为命名动脑筋而导致产生无意义的名字(因为用数字编号最省事)。
3.2 简单的Windows应用程序命名规则
林锐博士对“匈牙利”命名规则做了合理的简化,下述的命名规则简单易用,比较适合于Windows应用软件的开发。类Unix也可以作为一个参考。再加上现在很多程序跨平台,所以这一套规则不止适用于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; //全局常量MAX
const int MAX_LENGTH = 100; //全局常量MAX_LENGTH
【规则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开头。
4 表达式和基本语句
表达式和语句都属于C++/C的短语结构语法。它们看似简单,但使用时隐患比较多。作为一个职业的程序员:连if、for、while、goto、switch这样简单的东西也要探讨编程风格。
4.1 运算符的优先级
C++/C语言的运算符有数十个,运算符的优先级与结合律如表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)的高。
//4-4(a) 低效率:长循环在最外层
for (row=0; row<100; row++)
{
for ( col=0; col<5; col++ )
{
sum = sum + a[row][col];
}
}
//4-4(b) 高效率:长循环在最内层
for (col=0; col<5; col++ )
{
for (row=0; row<100; row++)
{
sum = sum + a[row][col];
}
}
【建议4-4-2】如果循环体内存在逻辑判断,并且循环次数很大,宜将逻辑判断移到循环体的外面。示例4-4©的程序比示例4-4(d)多执行了N-1次逻辑判断。并且由于前者老要进行逻辑判断,打断了循环“流水线”作业,使得编译器不能对循环进行优化处理,降低了效率。如果N非常大,最好采用示例4-4(d)的写法,可以提高效率。如果N非常小,两者效率差别并不明显,采用示例4-4©的写法比较好,因为程序更加简洁。
//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.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)的写法更加直观,尽管两者的功能是相同的。
//4-5(a) 循环变量属于半开半闭区间
for (int x=0; x<N; x++)
{
…
}
//4-5(b) 循环变量属于闭区间
for (int x=0; x<=N-1; x++)
{
…
}
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.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”); // 参数顺序颠倒
良好的函数声明:
void StringCopy(char *strDestination, char *strSource);
【规则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 char *format, ...);
这种风格的函数在编译时丧失了严格的类型安全检查。
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
用错了,它的灵活性又有什么用呢?