函数是C++/C程序的基本功能单元,其重要性不言而喻。函数设计的细微缺点很容易导致该函数被错用,所以光使函数的功能正确是不够的。本章重点论
述函数的接口
设计
和内部
实现
的一些
规则
。
函数接口的两个要素是参数和返回值。C语言中,函数的参数和返回值的传递方式有两种:值传递(pass by value)和指针传递(pass by pointer)。
C++
语
言中多了引用
传递(pass by reference)。由
于引用
传递
的性
质
象指
针传递
,而使用方式却象
值传递,初学者常常迷惑不解,容易引起混乱,请先阅读6.6节“引用与指针的比较”。
l
【
规则
6-1-1
】参数的书写要完整,不要贪图省事只写参数的类型而省略参数名字。如果函数没有参数,则用void填充。
例如:
void SetValue(int width, int height); //
良好的
风
格
void SetValue(int, int);
// 不良的风格
float GetValue(void);
// 良好的风格
float GetValue();
// 不良的风格
l
【
规则
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”);
// 参数顺序颠倒
l
【
规则
6-1-3
】
如果参数是指
针
,且
仅
作
输
入用,
则应
在
类
型前加
const
,以防止
该
指
针
在函数体内被意外修改。
例如:
void StringCopy(char *strDestination,const char *strSource);
l
【
规则
6-1-4
】如果输入参数以值传递的方式传递对象,则宜改用
“const &”方式来传递,
这样
可以省去
临时对
象的构造和析构
过
程,从而提高效率。
²
【建
议
6-1-1
】避免函数有太多的参数,参数个数尽量控制在5个以内。如果参数太多,在使用时容易将参数类型或顺序搞错。
²
【建
议
6-1-2
】尽量不要使用类型和数目不确定的参数。
C标准库函数printf是采用不确定参数的典型代表,其原型为:
int printf(const chat *format[, argument]…);
这种风格的函数在编译时丧失了严格的类型安全检查。
l
【
规则
6-2-1
】
不要省略返回
值
的
类
型。
C语言中,凡不加类型说明的函数,一律自
动
按整型处理。这样做不会有什么好处,却容易被误解为void类型。
C++语言有很严格的类型安全检查,不允许上述情况发生。由于C++程序可以调用C函数,为了避免混乱,规定任何C++/ C函数都必须有类型。如果函数没有返回值,那么应声明为void类型。
l
【
规则
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误导了使用者。
l
【
规则
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什么也得不到,流下了隐患。
不同功能的函数其内部实现各不相同,看起来似乎无法就“内部实现”达成一致的观点。但根据经验,我们可以在函数体的“入口处”和“出口处”从严把关,从而提高函数的质量。
l
【
规则
6-3-1
】
在函数体的
“
入口
处
”
,
对
参数的有效性
进
行
检查
。
很多程序错误是由非法参数引起的,我们应该充分理解并正确使用“断言”(assert)来防止此类错误。详见6.5节“使用断言”。
l
【
规则
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-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]
l
【
规则
6-5-1
】使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别,后者是必然存在的并且是一定要作出处理的。
l
【
规则
6-5-2
】在
函数的入口
处
,使用断言
检查
参数的有效性(合法性)。
l
【建
议
6-5-1
】在编写函数时,要进行反复的考查,并且自问:“我打算做哪些假定?”一旦确定了的假定,就要使用断言对假定进行检查。
l
【建
议
6-5-2
】一般教科书都鼓励程序员们进行防错设计,但要记住这种编程风格可能会隐瞒错误。当进行防错设计时,如果“不可能发生”的事情的确发生了,则要使用断言进行报警。
引用是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
对比上述三个示例程序,会发现“引用传递”的性质象“指针传递”,而书写方式象“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做,为什么还要“引用”这东西?
答案是“
用适当的工具做恰如其分的工作
”
。
指针能够毫无约束地操作内存中的如何东西,尽管指针功能强大,但是非常危险。就象一把刀,它可以用来砍树、裁纸、修指甲、理发等等,谁敢这样用?
如果的确只需要借用一下某个对象的“别名”,那么就用“引用”,而不要用“指针”,以免发生意外。
比如
说
,某人需要一份
证
明,本来在文件上盖上公章的印子就行了,如果把取公章的
钥
匙交
给
他,那
么
他就
获
得了不
该
有的
权
利。